sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:contigs_to_positions; 3, parameters; 3, 4; 3, 5; 4, identifier:contigs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:binning; 7, integer:10000; 8, block; 8, 9; 8, 18; 8, 22; 8, 65; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:positions; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:np; 15, identifier:zeros_like; 16, argument_list; 16, 17; 17, identifier:contigs; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:index; 21, integer:0; 22, for_statement; 22, 23; 22, 26; 22, 32; 23, pattern_list; 23, 24; 23, 25; 24, identifier:_; 25, identifier:chunk; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:itertools; 29, identifier:groubpy; 30, argument_list; 30, 31; 31, identifier:contigs; 32, block; 32, 33; 32, 40; 32, 61; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:l; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:chunk; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 50; 42, subscript; 42, 43; 42, 44; 43, identifier:positions; 44, slice; 44, 45; 44, 46; 44, 47; 45, identifier:index; 46, colon; 47, binary_operator:+; 47, 48; 47, 49; 48, identifier:index; 49, identifier:l; 50, binary_operator:*; 50, 51; 50, 60; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:arange; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:list; 58, argument_list; 58, 59; 59, identifier:chunk; 60, identifier:binning; 61, expression_statement; 61, 62; 62, augmented_assignment:+=; 62, 63; 62, 64; 63, identifier:index; 64, identifier:l; 65, return_statement; 65, 66; 66, identifier:positions | def contigs_to_positions(contigs, binning=10000):
positions = np.zeros_like(contigs)
index = 0
for _, chunk in itertools.groubpy(contigs):
l = len(chunk)
positions[index : index + l] = np.arange(list(chunk)) * binning
index += l
return positions |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:find_nearest; 3, parameters; 3, 4; 3, 5; 4, identifier:sorted_list; 5, identifier:x; 6, block; 6, 7; 7, if_statement; 7, 8; 7, 13; 7, 18; 7, 31; 8, comparison_operator:<=; 8, 9; 8, 10; 9, identifier:x; 10, subscript; 10, 11; 10, 12; 11, identifier:sorted_list; 12, integer:0; 13, block; 13, 14; 14, return_statement; 14, 15; 15, subscript; 15, 16; 15, 17; 16, identifier:sorted_list; 17, integer:0; 18, elif_clause; 18, 19; 18, 25; 19, comparison_operator:>=; 19, 20; 19, 21; 20, identifier:x; 21, subscript; 21, 22; 21, 23; 22, identifier:sorted_list; 23, unary_operator:-; 23, 24; 24, integer:1; 25, block; 25, 26; 26, return_statement; 26, 27; 27, subscript; 27, 28; 27, 29; 28, identifier:sorted_list; 29, unary_operator:-; 29, 30; 30, integer:1; 31, else_clause; 31, 32; 32, block; 32, 33; 32, 41; 32, 49; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:lower; 36, call; 36, 37; 36, 38; 37, identifier:find_le; 38, argument_list; 38, 39; 38, 40; 39, identifier:sorted_list; 40, identifier:x; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:upper; 44, call; 44, 45; 44, 46; 45, identifier:find_ge; 46, argument_list; 46, 47; 46, 48; 47, identifier:sorted_list; 48, identifier:x; 49, if_statement; 49, 50; 49, 59; 49, 62; 50, comparison_operator:>; 50, 51; 50, 55; 51, parenthesized_expression; 51, 52; 52, binary_operator:-; 52, 53; 52, 54; 53, identifier:x; 54, identifier:lower; 55, parenthesized_expression; 55, 56; 56, binary_operator:-; 56, 57; 56, 58; 57, identifier:upper; 58, identifier:x; 59, block; 59, 60; 60, return_statement; 60, 61; 61, identifier:upper; 62, else_clause; 62, 63; 63, block; 63, 64; 64, return_statement; 64, 65; 65, identifier:lower | def find_nearest(sorted_list, x):
if x <= sorted_list[0]:
return sorted_list[0]
elif x >= sorted_list[-1]:
return sorted_list[-1]
else:
lower = find_le(sorted_list, x)
upper = find_ge(sorted_list, x)
if (x - lower) > (upper - x):
return upper
else:
return lower |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:execute; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:input_params; 5, identifier:engine; 6, default_parameter; 6, 7; 6, 8; 7, identifier:cwd; 8, None; 9, block; 9, 10; 9, 31; 9, 49; 9, 53; 9, 68; 9, 72; 9, 80; 9, 100; 9, 106; 9, 116; 9, 120; 9, 146; 9, 155; 9, 180; 9, 198; 10, try_statement; 10, 11; 10, 21; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:taskengine_exe; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:config; 18, identifier:get; 19, argument_list; 19, 20; 20, string:'engine'; 21, except_clause; 21, 22; 21, 23; 22, identifier:NoConfigOptionError; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:TaskEngineNotFoundError; 27, argument_list; 27, 28; 28, binary_operator:+; 28, 29; 28, 30; 29, string:"Task Engine config option not set."; 30, string:"\nPlease verify the 'engine' configuration setting."; 31, if_statement; 31, 32; 31, 41; 32, not_operator; 32, 33; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:os; 37, identifier:path; 38, identifier:exists; 39, argument_list; 39, 40; 40, identifier:taskengine_exe; 41, block; 41, 42; 42, raise_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:TaskEngineNotFoundError; 45, argument_list; 45, 46; 46, binary_operator:+; 46, 47; 46, 48; 47, string:"Task Engine executable not found."; 48, string:"\nPlease verify the 'engine' configuration setting."; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:engine_args; 52, None; 53, try_statement; 53, 54; 53, 64; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:engine_args; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:config; 61, identifier:get; 62, argument_list; 62, 63; 63, string:'engine-args'; 64, except_clause; 64, 65; 64, 66; 65, identifier:NoConfigOptionError; 66, block; 66, 67; 67, pass_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:environment; 71, None; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:config_environment; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:config; 78, identifier:get_environment; 79, argument_list; 80, if_statement; 80, 81; 80, 82; 81, identifier:config_environment; 82, block; 82, 83; 82, 93; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:environment; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:os; 90, identifier:environ; 91, identifier:copy; 92, argument_list; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:environment; 97, identifier:update; 98, argument_list; 98, 99; 99, identifier:config_environment; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:args; 103, list:[taskengine_exe, engine]; 103, 104; 103, 105; 104, identifier:taskengine_exe; 105, identifier:engine; 106, if_statement; 106, 107; 106, 108; 107, identifier:engine_args; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:args; 113, identifier:append; 114, argument_list; 114, 115; 115, identifier:engine_args; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:startupinfo; 119, None; 120, if_statement; 120, 121; 120, 129; 121, call; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:sys; 125, identifier:platform; 126, identifier:startswith; 127, argument_list; 127, 128; 128, string:'win'; 129, block; 129, 130; 129, 138; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:startupinfo; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:subprocess; 136, identifier:STARTUPINFO; 137, argument_list; 138, expression_statement; 138, 139; 139, augmented_assignment:|=; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:startupinfo; 142, identifier:dwFlags; 143, attribute; 143, 144; 143, 145; 144, identifier:subprocess; 145, identifier:STARTF_USESHOWWINDOW; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:input_json; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:json; 152, identifier:dumps; 153, argument_list; 153, 154; 154, identifier:input_params; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:process; 158, call; 158, 159; 158, 160; 159, identifier:Popen; 160, argument_list; 160, 161; 160, 162; 160, 165; 160, 168; 160, 171; 160, 174; 160, 177; 161, identifier:args; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:stdout; 164, identifier:PIPE; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:stdin; 167, identifier:PIPE; 168, keyword_argument; 168, 169; 168, 170; 169, identifier:stderr; 170, identifier:PIPE; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:cwd; 173, identifier:cwd; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:env; 176, identifier:environment; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:startupinfo; 179, identifier:startupinfo; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 185; 182, pattern_list; 182, 183; 182, 184; 183, identifier:stdout; 184, identifier:stderr; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:process; 188, identifier:communicate; 189, argument_list; 189, 190; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:input; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:input_json; 195, identifier:encode; 196, argument_list; 196, 197; 197, string:'utf-8'; 198, if_statement; 198, 199; 198, 204; 198, 234; 199, comparison_operator:!=; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:process; 202, identifier:returncode; 203, integer:0; 204, block; 204, 205; 205, if_statement; 205, 206; 205, 209; 205, 220; 206, comparison_operator:!=; 206, 207; 206, 208; 207, identifier:stderr; 208, string:''; 209, block; 209, 210; 210, raise_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:TaskEngineExecutionError; 213, argument_list; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:stderr; 217, identifier:decode; 218, argument_list; 218, 219; 219, string:'utf-8'; 220, else_clause; 220, 221; 221, block; 221, 222; 222, raise_statement; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:TaskEngineExecutionError; 225, argument_list; 225, 226; 226, binary_operator:+; 226, 227; 226, 228; 227, string:'Task Engine exited with code: '; 228, call; 228, 229; 228, 230; 229, identifier:str; 230, argument_list; 230, 231; 231, attribute; 231, 232; 231, 233; 232, identifier:process; 233, identifier:returncode; 234, else_clause; 234, 235; 235, block; 235, 236; 236, return_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:json; 240, identifier:loads; 241, argument_list; 241, 242; 241, 248; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:stdout; 245, identifier:decode; 246, argument_list; 246, 247; 247, string:'utf-8'; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:object_pairs_hook; 250, identifier:OrderedDict | def execute(input_params, engine, cwd=None):
try:
taskengine_exe = config.get('engine')
except NoConfigOptionError:
raise TaskEngineNotFoundError(
"Task Engine config option not set." +
"\nPlease verify the 'engine' configuration setting.")
if not os.path.exists(taskengine_exe):
raise TaskEngineNotFoundError(
"Task Engine executable not found." +
"\nPlease verify the 'engine' configuration setting.")
engine_args = None
try:
engine_args = config.get('engine-args')
except NoConfigOptionError:
pass
environment = None
config_environment = config.get_environment()
if config_environment:
environment = os.environ.copy()
environment.update(config_environment)
args = [taskengine_exe, engine]
if engine_args:
args.append(engine_args)
startupinfo = None
if sys.platform.startswith('win'):
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
input_json = json.dumps(input_params)
process = Popen(args,
stdout=PIPE,
stdin=PIPE,
stderr=PIPE,
cwd=cwd,
env=environment,
startupinfo=startupinfo)
stdout, stderr = process.communicate(input=input_json.encode('utf-8'))
if process.returncode != 0:
if stderr != '':
raise TaskEngineExecutionError(stderr.decode('utf-8'))
else:
raise TaskEngineExecutionError(
'Task Engine exited with code: ' + str(process.returncode))
else:
return json.loads(stdout.decode('utf-8'), object_pairs_hook=OrderedDict) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:merge_fasta; 3, parameters; 3, 4; 3, 5; 4, identifier:fasta_file; 5, identifier:output_dir; 6, block; 6, 7; 6, 44; 6, 95; 6, 121; 6, 141; 6, 151; 6, 157; 6, 270; 6, 296; 6, 305; 6, 317; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:chunk_lexicographic_order; 9, parameters; 9, 10; 10, identifier:chunk; 11, block; 11, 12; 11, 21; 11, 30; 11, 37; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:chunk_fields; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:chunk; 18, identifier:split; 19, argument_list; 19, 20; 20, string:"_"; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:chunk_name; 24, subscript; 24, 25; 24, 26; 25, identifier:chunk_fields; 26, slice; 26, 27; 26, 28; 27, colon; 28, unary_operator:-; 28, 29; 29, integer:1; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:chunk_id; 33, subscript; 33, 34; 33, 35; 34, identifier:chunk_fields; 35, unary_operator:-; 35, 36; 36, integer:1; 37, return_statement; 37, 38; 38, tuple; 38, 39; 38, 40; 39, identifier:chunk_name; 40, call; 40, 41; 40, 42; 41, identifier:int; 42, argument_list; 42, 43; 43, identifier:chunk_id; 44, function_definition; 44, 45; 44, 46; 44, 49; 45, function_name:are_consecutive; 46, parameters; 46, 47; 46, 48; 47, identifier:chunk1; 48, identifier:chunk2; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 56; 50, 59; 51, comparison_operator:in; 51, 52; 51, 53; 52, None; 53, set; 53, 54; 53, 55; 54, identifier:chunk1; 55, identifier:chunk2; 56, block; 56, 57; 57, return_statement; 57, 58; 58, False; 59, else_clause; 59, 60; 60, block; 60, 61; 60, 68; 60, 75; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:ord1; 64, call; 64, 65; 64, 66; 65, identifier:chunk_lexicographic_order; 66, argument_list; 66, 67; 67, identifier:chunk1; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:ord2; 71, call; 71, 72; 71, 73; 72, identifier:chunk_lexicographic_order; 73, argument_list; 73, 74; 74, identifier:chunk2; 75, return_statement; 75, 76; 76, boolean_operator:and; 76, 77; 76, 85; 77, parenthesized_expression; 77, 78; 78, comparison_operator:==; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:ord1; 81, integer:0; 82, subscript; 82, 83; 82, 84; 83, identifier:ord2; 84, integer:0; 85, parenthesized_expression; 85, 86; 86, comparison_operator:==; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:ord1; 89, integer:1; 90, binary_operator:+; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:ord2; 93, integer:1; 94, integer:1; 95, function_definition; 95, 96; 95, 97; 95, 99; 96, function_name:consecutiveness; 97, parameters; 97, 98; 98, identifier:key_chunk_pair; 99, block; 99, 100; 99, 106; 99, 115; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, pattern_list; 102, 103; 102, 104; 103, identifier:key; 104, identifier:chunk; 105, identifier:key_chunk_pair; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, pattern_list; 108, 109; 108, 110; 109, identifier:chunk_name; 110, identifier:chunk_id; 111, call; 111, 112; 111, 113; 112, identifier:chunk_lexicographic_order; 113, argument_list; 113, 114; 114, identifier:chunk; 115, return_statement; 115, 116; 116, tuple; 116, 117; 116, 118; 117, identifier:chunk_name; 118, binary_operator:-; 118, 119; 118, 120; 119, identifier:chunk_id; 120, identifier:key; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:genome; 124, dictionary_comprehension; 124, 125; 124, 132; 125, pair; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:record; 128, identifier:id; 129, attribute; 129, 130; 129, 131; 130, identifier:record; 131, identifier:seq; 132, for_in_clause; 132, 133; 132, 134; 133, identifier:record; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:SeqIO; 137, identifier:parse; 138, argument_list; 138, 139; 138, 140; 139, identifier:fasta_file; 140, string:"fasta"; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:sorted_ids; 144, call; 144, 145; 144, 146; 145, identifier:sorted; 146, argument_list; 146, 147; 146, 148; 147, identifier:genome; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:key; 150, identifier:chunk_lexicographic_order; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:new_genome; 154, call; 154, 155; 154, 156; 155, identifier:dict; 156, argument_list; 157, for_statement; 157, 158; 157, 161; 157, 171; 158, pattern_list; 158, 159; 158, 160; 159, identifier:_; 160, identifier:g; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:itertools; 164, identifier:groupby; 165, argument_list; 165, 166; 165, 170; 166, call; 166, 167; 166, 168; 167, identifier:enumerate; 168, argument_list; 168, 169; 169, identifier:sorted_ids; 170, identifier:consecutiveness; 171, block; 171, 172; 171, 185; 171, 192; 171, 198; 171, 202; 171, 224; 171, 245; 171, 264; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:chunk_range; 175, call; 175, 176; 175, 177; 176, identifier:map; 177, argument_list; 177, 178; 177, 184; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:operator; 181, identifier:itemgetter; 182, argument_list; 182, 183; 183, integer:1; 184, identifier:g; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:first_chunk; 188, call; 188, 189; 188, 190; 189, identifier:next; 190, argument_list; 190, 191; 191, identifier:chunk_range; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:my_sequence; 195, subscript; 195, 196; 195, 197; 196, identifier:genome; 197, identifier:first_chunk; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:my_chunk; 201, None; 202, while_statement; 202, 203; 202, 204; 203, string:"Reading chunk range"; 204, block; 204, 205; 205, try_statement; 205, 206; 205, 220; 206, block; 206, 207; 206, 214; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:my_chunk; 210, call; 210, 211; 210, 212; 211, identifier:next; 212, argument_list; 212, 213; 213, identifier:chunk_range; 214, expression_statement; 214, 215; 215, augmented_assignment:+=; 215, 216; 215, 217; 216, identifier:my_sequence; 217, subscript; 217, 218; 217, 219; 218, identifier:genome; 219, identifier:my_chunk; 220, except_clause; 220, 221; 220, 222; 221, identifier:StopIteration; 222, block; 222, 223; 223, break_statement; 224, try_statement; 224, 225; 224, 238; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:last_chunk_id; 229, subscript; 229, 230; 229, 236; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:my_chunk; 233, identifier:split; 234, argument_list; 234, 235; 235, string:"_"; 236, unary_operator:-; 236, 237; 237, integer:1; 238, except_clause; 238, 239; 238, 240; 239, identifier:AttributeError; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:last_chunk_id; 244, string:""; 245, if_statement; 245, 246; 245, 247; 245, 258; 246, identifier:last_chunk_id; 247, block; 247, 248; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:new_chunk_id; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, string:"{}_{}"; 254, identifier:format; 255, argument_list; 255, 256; 255, 257; 256, identifier:first_chunk; 257, identifier:last_chunk_id; 258, else_clause; 258, 259; 259, block; 259, 260; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:new_chunk_id; 263, identifier:first_chunk; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:new_genome; 268, identifier:new_chunk_id; 269, identifier:my_sequence; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:base_name; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, string:"."; 276, identifier:join; 277, argument_list; 277, 278; 278, subscript; 278, 279; 278, 292; 279, call; 279, 280; 279, 290; 280, attribute; 280, 281; 280, 289; 281, call; 281, 282; 281, 287; 282, attribute; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:os; 285, identifier:path; 286, identifier:basename; 287, argument_list; 287, 288; 288, identifier:fasta_file; 289, identifier:split; 290, argument_list; 290, 291; 291, string:"."; 292, slice; 292, 293; 292, 294; 293, colon; 294, unary_operator:-; 294, 295; 295, integer:1; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:output_name; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, string:"{}_merged.fa"; 302, identifier:format; 303, argument_list; 303, 304; 304, identifier:base_name; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:merged_core_file; 308, call; 308, 309; 308, 314; 309, attribute; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:os; 312, identifier:path; 313, identifier:join; 314, argument_list; 314, 315; 314, 316; 315, identifier:output_dir; 316, identifier:output_name; 317, with_statement; 317, 318; 317, 328; 318, with_clause; 318, 319; 319, with_item; 319, 320; 320, as_pattern; 320, 321; 320, 326; 321, call; 321, 322; 321, 323; 322, identifier:open; 323, argument_list; 323, 324; 323, 325; 324, identifier:merged_core_file; 325, string:"w"; 326, as_pattern_target; 326, 327; 327, identifier:output_handle; 328, block; 328, 329; 329, for_statement; 329, 330; 329, 331; 329, 338; 330, identifier:my_id; 331, call; 331, 332; 331, 333; 332, identifier:sorted; 333, argument_list; 333, 334; 333, 335; 334, identifier:new_genome; 335, keyword_argument; 335, 336; 335, 337; 336, identifier:key; 337, identifier:chunk_lexicographic_order; 338, block; 338, 339; 338, 351; 339, expression_statement; 339, 340; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:output_handle; 343, identifier:write; 344, argument_list; 344, 345; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, string:">{}\n"; 348, identifier:format; 349, argument_list; 349, 350; 350, identifier:my_id; 351, expression_statement; 351, 352; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:output_handle; 355, identifier:write; 356, argument_list; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, string:"{}\n"; 360, identifier:format; 361, argument_list; 361, 362; 362, subscript; 362, 363; 362, 364; 363, identifier:new_genome; 364, identifier:my_id | def merge_fasta(fasta_file, output_dir):
def chunk_lexicographic_order(chunk):
chunk_fields = chunk.split("_")
chunk_name = chunk_fields[:-1]
chunk_id = chunk_fields[-1]
return (chunk_name, int(chunk_id))
def are_consecutive(chunk1, chunk2):
if None in {chunk1, chunk2}:
return False
else:
ord1 = chunk_lexicographic_order(chunk1)
ord2 = chunk_lexicographic_order(chunk2)
return (ord1[0] == ord2[0]) and (ord1[1] == ord2[1] + 1)
def consecutiveness(key_chunk_pair):
key, chunk = key_chunk_pair
chunk_name, chunk_id = chunk_lexicographic_order(chunk)
return (chunk_name, chunk_id - key)
genome = {
record.id: record.seq for record in SeqIO.parse(fasta_file, "fasta")
}
sorted_ids = sorted(genome, key=chunk_lexicographic_order)
new_genome = dict()
for _, g in itertools.groupby(enumerate(sorted_ids), consecutiveness):
chunk_range = map(operator.itemgetter(1), g)
first_chunk = next(chunk_range)
my_sequence = genome[first_chunk]
my_chunk = None
while "Reading chunk range":
try:
my_chunk = next(chunk_range)
my_sequence += genome[my_chunk]
except StopIteration:
break
try:
last_chunk_id = my_chunk.split("_")[-1]
except AttributeError:
last_chunk_id = ""
if last_chunk_id:
new_chunk_id = "{}_{}".format(first_chunk, last_chunk_id)
else:
new_chunk_id = first_chunk
new_genome[new_chunk_id] = my_sequence
base_name = ".".join(os.path.basename(fasta_file).split(".")[:-1])
output_name = "{}_merged.fa".format(base_name)
merged_core_file = os.path.join(output_dir, output_name)
with open(merged_core_file, "w") as output_handle:
for my_id in sorted(new_genome, key=chunk_lexicographic_order):
output_handle.write(">{}\n".format(my_id))
output_handle.write("{}\n".format(new_genome[my_id])) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:print_block; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 11; 4, identifier:self; 5, identifier:section_key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:f; 8, attribute; 8, 9; 8, 10; 9, identifier:sys; 10, identifier:stdout; 11, default_parameter; 11, 12; 11, 13; 12, identifier:file_format; 13, string:"mwtab"; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 19; 15, 429; 16, comparison_operator:==; 16, 17; 16, 18; 17, identifier:file_format; 18, string:"mwtab"; 19, block; 19, 20; 20, for_statement; 20, 21; 20, 24; 20, 31; 21, pattern_list; 21, 22; 21, 23; 22, identifier:key; 23, identifier:value; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, subscript; 26, 27; 26, 28; 27, identifier:self; 28, identifier:section_key; 29, identifier:items; 30, argument_list; 31, block; 31, 32; 31, 44; 31, 86; 32, if_statement; 32, 33; 32, 42; 33, boolean_operator:and; 33, 34; 33, 37; 34, comparison_operator:==; 34, 35; 34, 36; 35, identifier:section_key; 36, string:"METABOLOMICS WORKBENCH"; 37, comparison_operator:not; 37, 38; 37, 39; 38, identifier:key; 39, tuple; 39, 40; 39, 41; 40, string:"VERSION"; 41, string:"CREATED_ON"; 42, block; 42, 43; 43, continue_statement; 44, if_statement; 44, 45; 44, 50; 44, 60; 44, 75; 45, comparison_operator:in; 45, 46; 45, 47; 46, identifier:key; 47, tuple; 47, 48; 47, 49; 48, string:"VERSION"; 49, string:"CREATED_ON"; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:cw; 54, binary_operator:-; 54, 55; 54, 56; 55, integer:20; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:key; 60, elif_clause; 60, 61; 60, 65; 61, comparison_operator:in; 61, 62; 61, 63; 62, identifier:key; 63, tuple; 63, 64; 64, string:"SUBJECT_SAMPLE_FACTORS"; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:cw; 69, binary_operator:-; 69, 70; 69, 71; 70, integer:33; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:key; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:cw; 80, binary_operator:-; 80, 81; 80, 82; 81, integer:30; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:key; 86, if_statement; 86, 87; 86, 90; 86, 126; 86, 161; 86, 183; 86, 260; 86, 401; 87, comparison_operator:in; 87, 88; 87, 89; 88, string:"\n"; 89, identifier:value; 90, block; 90, 91; 91, for_statement; 91, 92; 91, 93; 91, 99; 92, identifier:line; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:value; 96, identifier:split; 97, argument_list; 97, 98; 98, string:"\n"; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:print; 103, argument_list; 103, 104; 103, 123; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, string:"{}{}{}\t{}"; 107, identifier:format; 108, argument_list; 108, 109; 108, 118; 108, 119; 108, 122; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:prefixes; 114, identifier:get; 115, argument_list; 115, 116; 115, 117; 116, identifier:section_key; 117, string:""; 118, identifier:key; 119, binary_operator:*; 119, 120; 119, 121; 120, identifier:cw; 121, string:" "; 122, identifier:line; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:file; 125, identifier:f; 126, elif_clause; 126, 127; 126, 130; 127, comparison_operator:==; 127, 128; 127, 129; 128, identifier:key; 129, string:"SUBJECT_SAMPLE_FACTORS"; 130, block; 130, 131; 131, for_statement; 131, 132; 131, 133; 131, 134; 132, identifier:factor; 133, identifier:value; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:print; 138, argument_list; 138, 139; 138, 158; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, string:"{}{}\t{}"; 142, identifier:format; 143, argument_list; 143, 144; 143, 145; 143, 148; 144, identifier:key; 145, binary_operator:*; 145, 146; 145, 147; 146, identifier:cw; 147, string:" "; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, string:"\t"; 151, identifier:join; 152, argument_list; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:factor; 156, identifier:values; 157, argument_list; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:file; 160, identifier:f; 161, elif_clause; 161, 162; 161, 168; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:key; 165, identifier:endswith; 166, argument_list; 166, 167; 167, string:":UNITS"; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:print; 172, argument_list; 172, 173; 172, 180; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, string:"{}\t{}"; 176, identifier:format; 177, argument_list; 177, 178; 177, 179; 178, identifier:key; 179, identifier:value; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:file; 182, identifier:f; 183, elif_clause; 183, 184; 183, 190; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:key; 187, identifier:endswith; 188, argument_list; 188, 189; 189, string:"_RESULTS_FILE"; 190, block; 190, 191; 191, if_statement; 191, 192; 191, 197; 191, 232; 192, call; 192, 193; 192, 194; 193, identifier:isinstance; 194, argument_list; 194, 195; 194, 196; 195, identifier:value; 196, identifier:dict; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:print; 201, argument_list; 201, 202; 201, 229; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, string:"{}{} \t{}\t{}:{}"; 205, identifier:format; 206, argument_list; 206, 207; 206, 216; 207, call; 207, 208; 207, 213; 208, attribute; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:prefixes; 212, identifier:get; 213, argument_list; 213, 214; 213, 215; 214, identifier:section_key; 215, string:""; 216, list_splat; 216, 217; 217, list_comprehension; 217, 218; 217, 219; 217, 226; 218, identifier:i; 219, for_in_clause; 219, 220; 219, 221; 220, identifier:pair; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:value; 224, identifier:items; 225, argument_list; 226, for_in_clause; 226, 227; 226, 228; 227, identifier:i; 228, identifier:pair; 229, keyword_argument; 229, 230; 229, 231; 230, identifier:file; 231, identifier:f; 232, else_clause; 232, 233; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 237; 236, identifier:print; 237, argument_list; 237, 238; 237, 257; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, string:"{}{}{}\t{}"; 241, identifier:format; 242, argument_list; 242, 243; 242, 252; 242, 253; 242, 256; 243, call; 243, 244; 243, 249; 244, attribute; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:prefixes; 248, identifier:get; 249, argument_list; 249, 250; 249, 251; 250, identifier:section_key; 251, string:""; 252, identifier:key; 253, binary_operator:*; 253, 254; 253, 255; 254, identifier:cw; 255, string:" "; 256, identifier:value; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:file; 259, identifier:f; 260, elif_clause; 260, 261; 260, 267; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:key; 264, identifier:endswith; 265, argument_list; 265, 266; 266, string:"_START"; 267, block; 267, 268; 267, 272; 267, 287; 267, 295; 267, 393; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:start_key; 271, identifier:key; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:end_key; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, string:"{}{}"; 278, identifier:format; 279, argument_list; 279, 280; 279, 286; 280, subscript; 280, 281; 280, 282; 281, identifier:start_key; 282, slice; 282, 283; 282, 284; 283, colon; 284, unary_operator:-; 284, 285; 285, integer:5; 286, string:"END"; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:print; 290, argument_list; 290, 291; 290, 292; 291, identifier:start_key; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:file; 294, identifier:f; 295, for_statement; 295, 296; 295, 297; 295, 298; 296, identifier:data_key; 297, identifier:value; 298, block; 298, 299; 299, if_statement; 299, 300; 299, 305; 299, 331; 299, 361; 300, comparison_operator:in; 300, 301; 300, 302; 301, identifier:data_key; 302, tuple; 302, 303; 302, 304; 303, string:"Samples"; 304, string:"Factors"; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, call; 307, 308; 307, 309; 308, identifier:print; 309, argument_list; 309, 310; 309, 328; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, string:"{}\t{}"; 313, identifier:format; 314, argument_list; 314, 315; 314, 316; 315, identifier:data_key; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, string:"\t"; 319, identifier:join; 320, argument_list; 320, 321; 321, subscript; 321, 322; 321, 327; 322, subscript; 322, 323; 322, 326; 323, subscript; 323, 324; 323, 325; 324, identifier:self; 325, identifier:section_key; 326, identifier:key; 327, identifier:data_key; 328, keyword_argument; 328, 329; 328, 330; 329, identifier:file; 330, identifier:f; 331, elif_clause; 331, 332; 331, 336; 332, comparison_operator:in; 332, 333; 332, 334; 333, identifier:data_key; 334, tuple; 334, 335; 335, string:"Fields"; 336, block; 336, 337; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 340; 339, identifier:print; 340, argument_list; 340, 341; 340, 358; 341, call; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, string:"{}"; 344, identifier:format; 345, argument_list; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, string:"\t"; 349, identifier:join; 350, argument_list; 350, 351; 351, subscript; 351, 352; 351, 357; 352, subscript; 352, 353; 352, 356; 353, subscript; 353, 354; 353, 355; 354, identifier:self; 355, identifier:section_key; 356, identifier:key; 357, identifier:data_key; 358, keyword_argument; 358, 359; 358, 360; 359, identifier:file; 360, identifier:f; 361, elif_clause; 361, 362; 361, 365; 362, comparison_operator:==; 362, 363; 362, 364; 363, identifier:data_key; 364, string:"DATA"; 365, block; 365, 366; 366, for_statement; 366, 367; 366, 368; 366, 375; 367, identifier:data; 368, subscript; 368, 369; 368, 374; 369, subscript; 369, 370; 369, 373; 370, subscript; 370, 371; 370, 372; 371, identifier:self; 372, identifier:section_key; 373, identifier:key; 374, identifier:data_key; 375, block; 375, 376; 376, expression_statement; 376, 377; 377, call; 377, 378; 377, 379; 378, identifier:print; 379, argument_list; 379, 380; 379, 390; 380, call; 380, 381; 380, 384; 381, attribute; 381, 382; 381, 383; 382, string:"\t"; 383, identifier:join; 384, argument_list; 384, 385; 385, call; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:data; 388, identifier:values; 389, argument_list; 390, keyword_argument; 390, 391; 390, 392; 391, identifier:file; 392, identifier:f; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 396; 395, identifier:print; 396, argument_list; 396, 397; 396, 398; 397, identifier:end_key; 398, keyword_argument; 398, 399; 398, 400; 399, identifier:file; 400, identifier:f; 401, else_clause; 401, 402; 402, block; 402, 403; 403, expression_statement; 403, 404; 404, call; 404, 405; 404, 406; 405, identifier:print; 406, argument_list; 406, 407; 406, 426; 407, call; 407, 408; 407, 411; 408, attribute; 408, 409; 408, 410; 409, string:"{}{}{}\t{}"; 410, identifier:format; 411, argument_list; 411, 412; 411, 421; 411, 422; 411, 425; 412, call; 412, 413; 412, 418; 413, attribute; 413, 414; 413, 417; 414, attribute; 414, 415; 414, 416; 415, identifier:self; 416, identifier:prefixes; 417, identifier:get; 418, argument_list; 418, 419; 418, 420; 419, identifier:section_key; 420, string:""; 421, identifier:key; 422, binary_operator:*; 422, 423; 422, 424; 423, identifier:cw; 424, string:" "; 425, identifier:value; 426, keyword_argument; 426, 427; 426, 428; 427, identifier:file; 428, identifier:f; 429, elif_clause; 429, 430; 429, 433; 430, comparison_operator:==; 430, 431; 430, 432; 431, identifier:file_format; 432, string:"json"; 433, block; 433, 434; 434, expression_statement; 434, 435; 435, call; 435, 436; 435, 437; 436, identifier:print; 437, argument_list; 437, 438; 437, 452; 438, call; 438, 439; 438, 442; 439, attribute; 439, 440; 439, 441; 440, identifier:json; 441, identifier:dumps; 442, argument_list; 442, 443; 442, 446; 442, 449; 443, subscript; 443, 444; 443, 445; 444, identifier:self; 445, identifier:section_key; 446, keyword_argument; 446, 447; 446, 448; 447, identifier:sort_keys; 448, False; 449, keyword_argument; 449, 450; 449, 451; 450, identifier:indent; 451, integer:4; 452, keyword_argument; 452, 453; 452, 454; 453, identifier:file; 454, identifier:f | def print_block(self, section_key, f=sys.stdout, file_format="mwtab"):
if file_format == "mwtab":
for key, value in self[section_key].items():
if section_key == "METABOLOMICS WORKBENCH" and key not in ("VERSION", "CREATED_ON"):
continue
if key in ("VERSION", "CREATED_ON"):
cw = 20 - len(key)
elif key in ("SUBJECT_SAMPLE_FACTORS", ):
cw = 33 - len(key)
else:
cw = 30 - len(key)
if "\n" in value:
for line in value.split("\n"):
print("{}{}{}\t{}".format(self.prefixes.get(section_key, ""), key, cw * " ", line), file=f)
elif key == "SUBJECT_SAMPLE_FACTORS":
for factor in value:
print("{}{}\t{}".format(key, cw * " ", "\t".join(factor.values())), file=f)
elif key.endswith(":UNITS"):
print("{}\t{}".format(key, value), file=f)
elif key.endswith("_RESULTS_FILE"):
if isinstance(value, dict):
print("{}{} \t{}\t{}:{}".format(self.prefixes.get(section_key, ""),
*[i for pair in value.items() for i in pair]), file=f)
else:
print("{}{}{}\t{}".format(self.prefixes.get(section_key, ""), key, cw * " ", value), file=f)
elif key.endswith("_START"):
start_key = key
end_key = "{}{}".format(start_key[:-5], "END")
print(start_key, file=f)
for data_key in value:
if data_key in ("Samples", "Factors"):
print("{}\t{}".format(data_key, "\t".join(self[section_key][key][data_key])), file=f)
elif data_key in ("Fields", ):
print("{}".format("\t".join(self[section_key][key][data_key])), file=f)
elif data_key == "DATA":
for data in self[section_key][key][data_key]:
print("\t".join(data.values()), file=f)
print(end_key, file=f)
else:
print("{}{}{}\t{}".format(self.prefixes.get(section_key, ""), key, cw * " ", value), file=f)
elif file_format == "json":
print(json.dumps(self[section_key], sort_keys=False, indent=4), file=f) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:retry; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:ExceptionToCheck; 5, default_parameter; 5, 6; 5, 7; 6, identifier:tries; 7, integer:4; 8, default_parameter; 8, 9; 8, 10; 9, identifier:delay; 10, integer:3; 11, default_parameter; 11, 12; 11, 13; 12, identifier:backoff; 13, integer:2; 14, default_parameter; 14, 15; 14, 16; 15, identifier:status_codes; 16, list:[]; 17, default_parameter; 17, 18; 17, 19; 18, identifier:logger; 19, None; 20, block; 20, 21; 20, 35; 20, 44; 20, 54; 20, 68; 20, 173; 21, if_statement; 21, 22; 21, 29; 22, boolean_operator:or; 22, 23; 22, 26; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:backoff; 25, None; 26, comparison_operator:<=; 26, 27; 26, 28; 27, identifier:backoff; 28, integer:0; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:ValueError; 33, argument_list; 33, 34; 34, string:"backoff must be a number greater than 0"; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:tries; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:math; 41, identifier:floor; 42, argument_list; 42, 43; 43, identifier:tries; 44, if_statement; 44, 45; 44, 48; 45, comparison_operator:<; 45, 46; 45, 47; 46, identifier:tries; 47, integer:0; 48, block; 48, 49; 49, raise_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:ValueError; 52, argument_list; 52, 53; 53, string:"tries must be a number 0 or greater"; 54, if_statement; 54, 55; 54, 62; 55, boolean_operator:or; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:delay; 58, None; 59, comparison_operator:<=; 59, 60; 59, 61; 60, identifier:delay; 61, integer:0; 62, block; 62, 63; 63, raise_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:ValueError; 66, argument_list; 66, 67; 67, string:"delay must be a number greater than 0"; 68, function_definition; 68, 69; 68, 70; 68, 72; 69, function_name:deco_retry; 70, parameters; 70, 71; 71, identifier:f; 72, block; 72, 73; 72, 171; 73, function_definition; 73, 74; 73, 75; 73, 80; 74, function_name:f_retry; 75, parameters; 75, 76; 75, 78; 76, list_splat_pattern; 76, 77; 77, identifier:args; 78, dictionary_splat_pattern; 78, 79; 79, identifier:kwargs; 80, block; 80, 81; 80, 89; 80, 163; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, pattern_list; 83, 84; 83, 85; 84, identifier:mtries; 85, identifier:mdelay; 86, expression_list; 86, 87; 86, 88; 87, identifier:tries; 88, identifier:delay; 89, while_statement; 89, 90; 89, 93; 90, comparison_operator:>; 90, 91; 90, 92; 91, identifier:mtries; 92, integer:1; 93, block; 93, 94; 94, try_statement; 94, 95; 94, 104; 95, block; 95, 96; 96, return_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:f; 99, argument_list; 99, 100; 99, 102; 100, list_splat; 100, 101; 101, identifier:args; 102, dictionary_splat; 102, 103; 103, identifier:kwargs; 104, except_clause; 104, 105; 104, 109; 105, as_pattern; 105, 106; 105, 107; 106, identifier:ExceptionToCheck; 107, as_pattern_target; 107, 108; 108, identifier:err; 109, block; 109, 110; 109, 131; 109, 148; 109, 155; 109, 159; 110, if_statement; 110, 111; 110, 129; 111, parenthesized_expression; 111, 112; 112, boolean_operator:and; 112, 113; 112, 124; 113, boolean_operator:and; 113, 114; 113, 120; 114, comparison_operator:is; 114, 115; 114, 119; 115, call; 115, 116; 115, 117; 116, identifier:type; 117, argument_list; 117, 118; 118, identifier:err; 119, identifier:DataFailureException; 120, call; 120, 121; 120, 122; 121, identifier:len; 122, argument_list; 122, 123; 123, identifier:status_codes; 124, comparison_operator:not; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:err; 127, identifier:status; 128, identifier:status_codes; 129, block; 129, 130; 130, raise_statement; 131, if_statement; 131, 132; 131, 133; 132, identifier:logger; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:logger; 138, identifier:warning; 139, argument_list; 139, 140; 140, binary_operator:%; 140, 141; 140, 142; 141, string:'%s: %s, Retrying in %s seconds.'; 142, tuple; 142, 143; 142, 146; 142, 147; 143, attribute; 143, 144; 143, 145; 144, identifier:f; 145, identifier:__name__; 146, identifier:err; 147, identifier:mdelay; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:time; 152, identifier:sleep; 153, argument_list; 153, 154; 154, identifier:mdelay; 155, expression_statement; 155, 156; 156, augmented_assignment:-=; 156, 157; 156, 158; 157, identifier:mtries; 158, integer:1; 159, expression_statement; 159, 160; 160, augmented_assignment:*=; 160, 161; 160, 162; 161, identifier:mdelay; 162, identifier:backoff; 163, return_statement; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:f; 166, argument_list; 166, 167; 166, 169; 167, list_splat; 167, 168; 168, identifier:args; 169, dictionary_splat; 169, 170; 170, identifier:kwargs; 171, return_statement; 171, 172; 172, identifier:f_retry; 173, return_statement; 173, 174; 174, identifier:deco_retry | def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, status_codes=[],
logger=None):
if backoff is None or backoff <= 0:
raise ValueError("backoff must be a number greater than 0")
tries = math.floor(tries)
if tries < 0:
raise ValueError("tries must be a number 0 or greater")
if delay is None or delay <= 0:
raise ValueError("delay must be a number greater than 0")
def deco_retry(f):
def f_retry(*args, **kwargs):
mtries, mdelay = tries, delay
while mtries > 1:
try:
return f(*args, **kwargs)
except ExceptionToCheck as err:
if (type(err) is DataFailureException and
len(status_codes) and
err.status not in status_codes):
raise
if logger:
logger.warning('%s: %s, Retrying in %s seconds.' % (
f.__name__, err, mdelay))
time.sleep(mdelay)
mtries -= 1
mdelay *= backoff
return f(*args, **kwargs)
return f_retry
return deco_retry |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:lcopt_bw2_autosetup; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 4, default_parameter; 4, 5; 4, 6; 5, identifier:ei_username; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:ei_password; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:write_config; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:ecoinvent_version; 15, string:'3.3'; 16, default_parameter; 16, 17; 16, 18; 17, identifier:ecoinvent_system_model; 18, string:"cutoff"; 19, default_parameter; 19, 20; 19, 21; 20, identifier:overwrite; 21, False; 22, block; 22, 23; 22, 39; 22, 45; 22, 79; 22, 85; 22, 155; 22, 176; 22, 222; 22, 234; 22, 248; 22, 267; 22, 307; 22, 420; 22, 445; 22, 454; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:ei_name; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, string:"Ecoinvent{}_{}_{}"; 29, identifier:format; 30, argument_list; 30, 31; 30, 38; 31, list_splat; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:ecoinvent_version; 35, identifier:split; 36, argument_list; 36, 37; 37, string:'.'; 38, identifier:ecoinvent_system_model; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:config; 42, call; 42, 43; 42, 44; 43, identifier:check_for_config; 44, argument_list; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:config; 48, None; 49, block; 49, 50; 49, 54; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:config; 53, identifier:DEFAULT_CONFIG; 54, with_statement; 54, 55; 54, 67; 55, with_clause; 55, 56; 56, with_item; 56, 57; 57, as_pattern; 57, 58; 57, 65; 58, call; 58, 59; 58, 60; 59, identifier:open; 60, argument_list; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:storage; 63, identifier:config_file; 64, string:"w"; 65, as_pattern_target; 65, 66; 66, identifier:cfg; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:yaml; 72, identifier:dump; 73, argument_list; 73, 74; 73, 75; 73, 76; 74, identifier:config; 75, identifier:cfg; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:default_flow_style; 78, False; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:store_option; 82, attribute; 82, 83; 82, 84; 83, identifier:storage; 84, identifier:project_type; 85, if_statement; 85, 86; 85, 89; 85, 124; 86, comparison_operator:==; 86, 87; 86, 88; 87, identifier:store_option; 88, string:'single'; 89, block; 89, 90; 89, 96; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:project_name; 93, attribute; 93, 94; 93, 95; 94, identifier:storage; 95, identifier:single_project_name; 96, if_statement; 96, 97; 96, 101; 97, call; 97, 98; 97, 99; 98, identifier:bw2_project_exists; 99, argument_list; 99, 100; 100, identifier:project_name; 101, block; 101, 102; 101, 111; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:bw2; 107, identifier:projects; 108, identifier:set_current; 109, argument_list; 109, 110; 110, identifier:project_name; 111, if_statement; 111, 112; 111, 121; 112, boolean_operator:and; 112, 113; 112, 118; 113, comparison_operator:in; 113, 114; 113, 115; 114, identifier:ei_name; 115, attribute; 115, 116; 115, 117; 116, identifier:bw2; 117, identifier:databases; 118, comparison_operator:==; 118, 119; 118, 120; 119, identifier:overwrite; 120, False; 121, block; 121, 122; 122, return_statement; 122, 123; 123, True; 124, else_clause; 124, 125; 125, block; 125, 126; 125, 132; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:project_name; 129, binary_operator:+; 129, 130; 129, 131; 130, identifier:DEFAULT_PROJECT_STEM; 131, identifier:ei_name; 132, if_statement; 132, 133; 132, 137; 133, call; 133, 134; 133, 135; 134, identifier:bw2_project_exists; 135, argument_list; 135, 136; 136, identifier:project_name; 137, block; 137, 138; 138, if_statement; 138, 139; 138, 140; 139, identifier:overwrite; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:bw2; 146, identifier:projects; 147, identifier:delete_project; 148, argument_list; 148, 149; 148, 152; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:name; 151, identifier:project_name; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:delete_dir; 154, True; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:auto_ecoinvent; 158, call; 158, 159; 158, 160; 159, identifier:partial; 160, argument_list; 160, 161; 160, 164; 160, 167; 160, 170; 160, 173; 161, attribute; 161, 162; 161, 163; 162, identifier:eidl; 163, identifier:get_ecoinvent; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:db_name; 166, identifier:ei_name; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:auto_write; 169, True; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:version; 172, identifier:ecoinvent_version; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:system_model; 175, identifier:ecoinvent_system_model; 176, if_statement; 176, 177; 176, 180; 177, comparison_operator:is; 177, 178; 177, 179; 178, identifier:config; 179, None; 180, block; 180, 181; 181, if_statement; 181, 182; 181, 185; 182, comparison_operator:in; 182, 183; 182, 184; 183, string:"ecoinvent"; 184, identifier:config; 185, block; 185, 186; 185, 202; 185, 218; 186, if_statement; 186, 187; 186, 190; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:ei_username; 189, None; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:ei_username; 194, call; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, subscript; 196, 197; 196, 198; 197, identifier:config; 198, string:'ecoinvent'; 199, identifier:get; 200, argument_list; 200, 201; 201, string:'username'; 202, if_statement; 202, 203; 202, 206; 203, comparison_operator:is; 203, 204; 203, 205; 204, identifier:ei_password; 205, None; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:ei_password; 210, call; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, subscript; 212, 213; 212, 214; 213, identifier:config; 214, string:'ecoinvent'; 215, identifier:get; 216, argument_list; 216, 217; 217, string:'password'; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:write_config; 221, False; 222, if_statement; 222, 223; 222, 226; 223, comparison_operator:is; 223, 224; 223, 225; 224, identifier:ei_username; 225, None; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:ei_username; 230, call; 230, 231; 230, 232; 231, identifier:input; 232, argument_list; 232, 233; 233, string:'ecoinvent username: '; 234, if_statement; 234, 235; 234, 238; 235, comparison_operator:is; 235, 236; 235, 237; 236, identifier:ei_password; 237, None; 238, block; 238, 239; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:ei_password; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:getpass; 245, identifier:getpass; 246, argument_list; 246, 247; 247, string:'ecoinvent password: '; 248, if_statement; 248, 249; 248, 252; 249, comparison_operator:is; 249, 250; 249, 251; 250, identifier:write_config; 251, None; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:write_config; 256, comparison_operator:in; 256, 257; 256, 261; 257, call; 257, 258; 257, 259; 258, identifier:input; 259, argument_list; 259, 260; 260, string:'store username and password on this computer? y/[n]'; 261, list:['y', 'Y', 'yes', 'YES', 'Yes']; 261, 262; 261, 263; 261, 264; 261, 265; 261, 266; 262, string:'y'; 263, string:'Y'; 264, string:'yes'; 265, string:'YES'; 266, string:'Yes'; 267, if_statement; 267, 268; 267, 269; 268, identifier:write_config; 269, block; 269, 270; 269, 282; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:config; 274, string:'ecoinvent'; 275, dictionary; 275, 276; 275, 279; 276, pair; 276, 277; 276, 278; 277, string:'username'; 278, identifier:ei_username; 279, pair; 279, 280; 279, 281; 280, string:'password'; 281, identifier:ei_password; 282, with_statement; 282, 283; 282, 295; 283, with_clause; 283, 284; 284, with_item; 284, 285; 285, as_pattern; 285, 286; 285, 293; 286, call; 286, 287; 286, 288; 287, identifier:open; 288, argument_list; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:storage; 291, identifier:config_file; 292, string:"w"; 293, as_pattern_target; 293, 294; 294, identifier:cfg; 295, block; 295, 296; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:yaml; 300, identifier:dump; 301, argument_list; 301, 302; 301, 303; 301, 304; 302, identifier:config; 303, identifier:cfg; 304, keyword_argument; 304, 305; 304, 306; 305, identifier:default_flow_style; 306, False; 307, if_statement; 307, 308; 307, 311; 307, 380; 308, comparison_operator:==; 308, 309; 308, 310; 309, identifier:store_option; 310, string:'single'; 311, block; 311, 312; 312, if_statement; 312, 313; 312, 317; 312, 327; 313, call; 313, 314; 313, 315; 314, identifier:bw2_project_exists; 315, argument_list; 315, 316; 316, identifier:project_name; 317, block; 317, 318; 318, expression_statement; 318, 319; 319, call; 319, 320; 319, 325; 320, attribute; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:bw2; 323, identifier:projects; 324, identifier:set_current; 325, argument_list; 325, 326; 326, identifier:project_name; 327, else_clause; 327, 328; 328, block; 328, 329; 329, if_statement; 329, 330; 329, 335; 329, 351; 330, not_operator; 330, 331; 331, call; 331, 332; 331, 333; 332, identifier:bw2_project_exists; 333, argument_list; 333, 334; 334, identifier:DEFAULT_BIOSPHERE_PROJECT; 335, block; 335, 336; 335, 345; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 343; 338, attribute; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:bw2; 341, identifier:projects; 342, identifier:set_current; 343, argument_list; 343, 344; 344, identifier:project_name; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:bw2; 349, identifier:bw2setup; 350, argument_list; 351, else_clause; 351, 352; 352, block; 352, 353; 352, 362; 352, 368; 353, expression_statement; 353, 354; 354, call; 354, 355; 354, 360; 355, attribute; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:bw2; 358, identifier:projects; 359, identifier:set_current; 360, argument_list; 360, 361; 361, identifier:DEFAULT_BIOSPHERE_PROJECT; 362, expression_statement; 362, 363; 363, call; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:bw2; 366, identifier:create_core_migrations; 367, argument_list; 368, expression_statement; 368, 369; 369, call; 369, 370; 369, 375; 370, attribute; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:bw2; 373, identifier:projects; 374, identifier:copy_project; 375, argument_list; 375, 376; 375, 377; 376, identifier:project_name; 377, keyword_argument; 377, 378; 377, 379; 378, identifier:switch; 379, True; 380, else_clause; 380, 381; 381, block; 381, 382; 381, 393; 381, 402; 381, 408; 382, if_statement; 382, 383; 382, 388; 383, not_operator; 383, 384; 384, call; 384, 385; 384, 386; 385, identifier:bw2_project_exists; 386, argument_list; 386, 387; 387, identifier:DEFAULT_BIOSPHERE_PROJECT; 388, block; 388, 389; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 392; 391, identifier:lcopt_biosphere_setup; 392, argument_list; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 400; 395, attribute; 395, 396; 395, 399; 396, attribute; 396, 397; 396, 398; 397, identifier:bw2; 398, identifier:projects; 399, identifier:set_current; 400, argument_list; 400, 401; 401, identifier:DEFAULT_BIOSPHERE_PROJECT; 402, expression_statement; 402, 403; 403, call; 403, 404; 403, 407; 404, attribute; 404, 405; 404, 406; 405, identifier:bw2; 406, identifier:create_core_migrations; 407, argument_list; 408, expression_statement; 408, 409; 409, call; 409, 410; 409, 415; 410, attribute; 410, 411; 410, 414; 411, attribute; 411, 412; 411, 413; 412, identifier:bw2; 413, identifier:projects; 414, identifier:copy_project; 415, argument_list; 415, 416; 415, 417; 416, identifier:project_name; 417, keyword_argument; 417, 418; 417, 419; 418, identifier:switch; 419, True; 420, if_statement; 420, 421; 420, 428; 420, 439; 421, boolean_operator:and; 421, 422; 421, 425; 422, comparison_operator:is; 422, 423; 422, 424; 423, identifier:ei_username; 424, None; 425, comparison_operator:is; 425, 426; 425, 427; 426, identifier:ei_password; 427, None; 428, block; 428, 429; 429, expression_statement; 429, 430; 430, call; 430, 431; 430, 432; 431, identifier:auto_ecoinvent; 432, argument_list; 432, 433; 432, 436; 433, keyword_argument; 433, 434; 433, 435; 434, identifier:username; 435, identifier:ei_username; 436, keyword_argument; 436, 437; 436, 438; 437, identifier:password; 438, identifier:ei_password; 439, else_clause; 439, 440; 440, block; 440, 441; 441, expression_statement; 441, 442; 442, call; 442, 443; 442, 444; 443, identifier:auto_ecoinvent; 444, argument_list; 445, expression_statement; 445, 446; 446, call; 446, 447; 446, 448; 447, identifier:write_search_index; 448, argument_list; 448, 449; 448, 450; 448, 451; 449, identifier:project_name; 450, identifier:ei_name; 451, keyword_argument; 451, 452; 451, 453; 452, identifier:overwrite; 453, identifier:overwrite; 454, return_statement; 454, 455; 455, True | def lcopt_bw2_autosetup(ei_username=None, ei_password=None, write_config=None, ecoinvent_version='3.3', ecoinvent_system_model = "cutoff", overwrite=False):
ei_name = "Ecoinvent{}_{}_{}".format(*ecoinvent_version.split('.'), ecoinvent_system_model)
config = check_for_config()
if config is None:
config = DEFAULT_CONFIG
with open(storage.config_file, "w") as cfg:
yaml.dump(config, cfg, default_flow_style=False)
store_option = storage.project_type
if store_option == 'single':
project_name = storage.single_project_name
if bw2_project_exists(project_name):
bw2.projects.set_current(project_name)
if ei_name in bw2.databases and overwrite == False:
return True
else:
project_name = DEFAULT_PROJECT_STEM + ei_name
if bw2_project_exists(project_name):
if overwrite:
bw2.projects.delete_project(name=project_name, delete_dir=True)
auto_ecoinvent = partial(eidl.get_ecoinvent,db_name=ei_name, auto_write=True, version=ecoinvent_version, system_model=ecoinvent_system_model)
if config is not None:
if "ecoinvent" in config:
if ei_username is None:
ei_username = config['ecoinvent'].get('username')
if ei_password is None:
ei_password = config['ecoinvent'].get('password')
write_config = False
if ei_username is None:
ei_username = input('ecoinvent username: ')
if ei_password is None:
ei_password = getpass.getpass('ecoinvent password: ')
if write_config is None:
write_config = input('store username and password on this computer? y/[n]') in ['y', 'Y', 'yes', 'YES', 'Yes']
if write_config:
config['ecoinvent'] = {
'username': ei_username,
'password': ei_password
}
with open(storage.config_file, "w") as cfg:
yaml.dump(config, cfg, default_flow_style=False)
if store_option == 'single':
if bw2_project_exists(project_name):
bw2.projects.set_current(project_name)
else:
if not bw2_project_exists(DEFAULT_BIOSPHERE_PROJECT):
bw2.projects.set_current(project_name)
bw2.bw2setup()
else:
bw2.projects.set_current(DEFAULT_BIOSPHERE_PROJECT)
bw2.create_core_migrations()
bw2.projects.copy_project(project_name, switch=True)
else:
if not bw2_project_exists(DEFAULT_BIOSPHERE_PROJECT):
lcopt_biosphere_setup()
bw2.projects.set_current(DEFAULT_BIOSPHERE_PROJECT)
bw2.create_core_migrations()
bw2.projects.copy_project(project_name, switch=True)
if ei_username is not None and ei_password is not None:
auto_ecoinvent(username=ei_username, password=ei_password)
else:
auto_ecoinvent()
write_search_index(project_name, ei_name, overwrite=overwrite)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:lcopt_bw2_forwast_setup; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:use_autodownload; 6, True; 7, default_parameter; 7, 8; 7, 9; 8, identifier:forwast_path; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:db_name; 12, identifier:FORWAST_PROJECT_NAME; 13, default_parameter; 13, 14; 13, 15; 14, identifier:overwrite; 15, False; 16, block; 16, 17; 16, 43; 16, 161; 16, 170; 17, if_statement; 17, 18; 17, 19; 17, 27; 17, 36; 18, identifier:use_autodownload; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:forwast_filepath; 23, call; 23, 24; 23, 25; 24, identifier:forwast_autodownload; 25, argument_list; 25, 26; 26, identifier:FORWAST_URL; 27, elif_clause; 27, 28; 27, 31; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:forwast_path; 30, None; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:forwast_filepath; 35, identifier:forwast_path; 36, else_clause; 36, 37; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:ValueError; 41, argument_list; 41, 42; 42, string:'Need a path if not using autodownload'; 43, if_statement; 43, 44; 43, 49; 43, 88; 44, comparison_operator:==; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:storage; 47, identifier:project_type; 48, string:'single'; 49, block; 49, 50; 49, 56; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:db_name; 53, attribute; 53, 54; 53, 55; 54, identifier:storage; 55, identifier:single_project_name; 56, if_statement; 56, 57; 56, 61; 56, 71; 57, call; 57, 58; 57, 59; 58, identifier:bw2_project_exists; 59, argument_list; 59, 60; 60, identifier:db_name; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:bw2; 67, identifier:projects; 68, identifier:set_current; 69, argument_list; 69, 70; 70, identifier:db_name; 71, else_clause; 71, 72; 72, block; 72, 73; 72, 82; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:bw2; 78, identifier:projects; 79, identifier:set_current; 80, argument_list; 80, 81; 81, identifier:db_name; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:bw2; 86, identifier:bw2setup; 87, argument_list; 88, else_clause; 88, 89; 89, block; 89, 90; 89, 123; 89, 134; 89, 143; 89, 149; 90, if_statement; 90, 91; 90, 96; 91, comparison_operator:in; 91, 92; 91, 93; 92, identifier:db_name; 93, attribute; 93, 94; 93, 95; 94, identifier:bw2; 95, identifier:projects; 96, block; 96, 97; 97, if_statement; 97, 98; 97, 99; 97, 114; 98, identifier:overwrite; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:bw2; 105, identifier:projects; 106, identifier:delete_project; 107, argument_list; 107, 108; 107, 111; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:name; 110, identifier:db_name; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:delete_dir; 113, True; 114, else_clause; 114, 115; 115, block; 115, 116; 115, 121; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:print; 119, argument_list; 119, 120; 120, string:'Looks like bw2 is already set up for the FORWAST database - if you want to overwrite the existing version run lcopt.utils.lcopt_bw2_forwast_setup in a python shell using overwrite = True'; 121, return_statement; 121, 122; 122, False; 123, if_statement; 123, 124; 123, 129; 124, not_operator; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:bw2_project_exists; 127, argument_list; 127, 128; 128, identifier:DEFAULT_BIOSPHERE_PROJECT; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:lcopt_biosphere_setup; 133, argument_list; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:bw2; 139, identifier:projects; 140, identifier:set_current; 141, argument_list; 141, 142; 142, identifier:DEFAULT_BIOSPHERE_PROJECT; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:bw2; 147, identifier:create_core_migrations; 148, argument_list; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:bw2; 154, identifier:projects; 155, identifier:copy_project; 156, argument_list; 156, 157; 156, 158; 157, identifier:db_name; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:switch; 160, True; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:bw2; 166, identifier:BW2Package; 167, identifier:import_file; 168, argument_list; 168, 169; 169, identifier:forwast_filepath; 170, return_statement; 170, 171; 171, True | def lcopt_bw2_forwast_setup(use_autodownload=True, forwast_path=None, db_name=FORWAST_PROJECT_NAME, overwrite=False):
if use_autodownload:
forwast_filepath = forwast_autodownload(FORWAST_URL)
elif forwast_path is not None:
forwast_filepath = forwast_path
else:
raise ValueError('Need a path if not using autodownload')
if storage.project_type == 'single':
db_name = storage.single_project_name
if bw2_project_exists(db_name):
bw2.projects.set_current(db_name)
else:
bw2.projects.set_current(db_name)
bw2.bw2setup()
else:
if db_name in bw2.projects:
if overwrite:
bw2.projects.delete_project(name=db_name, delete_dir=True)
else:
print('Looks like bw2 is already set up for the FORWAST database - if you want to overwrite the existing version run lcopt.utils.lcopt_bw2_forwast_setup in a python shell using overwrite = True')
return False
if not bw2_project_exists(DEFAULT_BIOSPHERE_PROJECT):
lcopt_biosphere_setup()
bw2.projects.set_current(DEFAULT_BIOSPHERE_PROJECT)
bw2.create_core_migrations()
bw2.projects.copy_project(db_name, switch=True)
bw2.BW2Package.import_file(forwast_filepath)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_validate_samples_factors; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:mwtabfile; 5, default_parameter; 5, 6; 5, 7; 6, identifier:validate_samples; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:validate_factors; 10, True; 11, block; 11, 12; 11, 26; 11, 40; 11, 91; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:from_subject_samples; 15, set_comprehension; 15, 16; 15, 19; 16, subscript; 16, 17; 16, 18; 17, identifier:i; 18, string:"local_sample_id"; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:i; 21, subscript; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:mwtabfile; 24, string:"SUBJECT_SAMPLE_FACTORS"; 25, string:"SUBJECT_SAMPLE_FACTORS"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:from_subject_factors; 29, set_comprehension; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:i; 32, string:"factors"; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:i; 35, subscript; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:mwtabfile; 38, string:"SUBJECT_SAMPLE_FACTORS"; 39, string:"SUBJECT_SAMPLE_FACTORS"; 40, if_statement; 40, 41; 40, 42; 41, identifier:validate_samples; 42, block; 42, 43; 42, 65; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:in; 44, 45; 44, 46; 45, string:"MS_METABOLITE_DATA"; 46, identifier:mwtabfile; 47, block; 47, 48; 47, 61; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:from_metabolite_data_samples; 51, call; 51, 52; 51, 53; 52, identifier:set; 53, argument_list; 53, 54; 54, subscript; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:mwtabfile; 58, string:"MS_METABOLITE_DATA"; 59, string:"MS_METABOLITE_DATA_START"; 60, string:"Samples"; 61, assert_statement; 61, 62; 62, comparison_operator:==; 62, 63; 62, 64; 63, identifier:from_subject_samples; 64, identifier:from_metabolite_data_samples; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:in; 66, 67; 66, 68; 67, string:"NMR_BINNED_DATA"; 68, identifier:mwtabfile; 69, block; 69, 70; 69, 87; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:from_nmr_binned_data_samples; 73, call; 73, 74; 73, 75; 74, identifier:set; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 84; 77, subscript; 77, 78; 77, 83; 78, subscript; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:mwtabfile; 81, string:"NMR_BINNED_DATA"; 82, string:"NMR_BINNED_DATA_START"; 83, string:"Fields"; 84, slice; 84, 85; 84, 86; 85, integer:1; 86, colon; 87, assert_statement; 87, 88; 88, comparison_operator:==; 88, 89; 88, 90; 89, identifier:from_subject_samples; 90, identifier:from_nmr_binned_data_samples; 91, if_statement; 91, 92; 91, 93; 92, identifier:validate_factors; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:in; 95, 96; 95, 97; 96, string:"MS_METABOLITE_DATA"; 97, identifier:mwtabfile; 98, block; 98, 99; 98, 112; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:from_metabolite_data_factors; 102, call; 102, 103; 102, 104; 103, identifier:set; 104, argument_list; 104, 105; 105, subscript; 105, 106; 105, 111; 106, subscript; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:mwtabfile; 109, string:"MS_METABOLITE_DATA"; 110, string:"MS_METABOLITE_DATA_START"; 111, string:"Factors"; 112, assert_statement; 112, 113; 113, comparison_operator:==; 113, 114; 113, 115; 114, identifier:from_subject_factors; 115, identifier:from_metabolite_data_factors | def _validate_samples_factors(mwtabfile, validate_samples=True, validate_factors=True):
from_subject_samples = {i["local_sample_id"] for i in mwtabfile["SUBJECT_SAMPLE_FACTORS"]["SUBJECT_SAMPLE_FACTORS"]}
from_subject_factors = {i["factors"] for i in mwtabfile["SUBJECT_SAMPLE_FACTORS"]["SUBJECT_SAMPLE_FACTORS"]}
if validate_samples:
if "MS_METABOLITE_DATA" in mwtabfile:
from_metabolite_data_samples = set(mwtabfile["MS_METABOLITE_DATA"]["MS_METABOLITE_DATA_START"]["Samples"])
assert from_subject_samples == from_metabolite_data_samples
if "NMR_BINNED_DATA" in mwtabfile:
from_nmr_binned_data_samples = set(mwtabfile["NMR_BINNED_DATA"]["NMR_BINNED_DATA_START"]["Fields"][1:])
assert from_subject_samples == from_nmr_binned_data_samples
if validate_factors:
if "MS_METABOLITE_DATA" in mwtabfile:
from_metabolite_data_factors = set(mwtabfile["MS_METABOLITE_DATA"]["MS_METABOLITE_DATA_START"]["Factors"])
assert from_subject_factors == from_metabolite_data_factors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:convert; 3, parameters; 3, 4; 4, identifier:schema; 5, block; 5, 6; 5, 21; 5, 152; 5, 183; 5, 232; 5, 277; 5, 296; 5, 347; 5, 378; 5, 393; 5, 405; 6, if_statement; 6, 7; 6, 14; 7, call; 7, 8; 7, 9; 8, identifier:isinstance; 9, argument_list; 9, 10; 9, 11; 10, identifier:schema; 11, attribute; 11, 12; 11, 13; 12, identifier:vol; 13, identifier:Schema; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:schema; 18, attribute; 18, 19; 18, 20; 19, identifier:schema; 20, identifier:schema; 21, if_statement; 21, 22; 21, 27; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:schema; 26, identifier:Mapping; 27, block; 27, 28; 27, 32; 27, 150; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:val; 31, list:[]; 32, for_statement; 32, 33; 32, 36; 32, 41; 33, pattern_list; 33, 34; 33, 35; 34, identifier:key; 35, identifier:value; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:schema; 39, identifier:items; 40, argument_list; 41, block; 41, 42; 41, 46; 41, 73; 41, 80; 41, 86; 41, 97; 41, 143; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:description; 45, None; 46, if_statement; 46, 47; 46, 54; 46, 67; 47, call; 47, 48; 47, 49; 48, identifier:isinstance; 49, argument_list; 49, 50; 49, 51; 50, identifier:key; 51, attribute; 51, 52; 51, 53; 52, identifier:vol; 53, identifier:Marker; 54, block; 54, 55; 54, 61; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:pkey; 58, attribute; 58, 59; 58, 60; 59, identifier:key; 60, identifier:schema; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:description; 64, attribute; 64, 65; 64, 66; 65, identifier:key; 66, identifier:description; 67, else_clause; 67, 68; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:pkey; 72, identifier:key; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:pval; 76, call; 76, 77; 76, 78; 77, identifier:convert; 78, argument_list; 78, 79; 79, identifier:value; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:pval; 84, string:'name'; 85, identifier:pkey; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:description; 89, None; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:pval; 95, string:'description'; 96, identifier:description; 97, if_statement; 97, 98; 97, 109; 98, call; 98, 99; 98, 100; 99, identifier:isinstance; 100, argument_list; 100, 101; 100, 102; 101, identifier:key; 102, tuple; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:vol; 105, identifier:Required; 106, attribute; 106, 107; 106, 108; 107, identifier:vol; 108, identifier:Optional; 109, block; 109, 110; 109, 124; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 123; 112, subscript; 112, 113; 112, 114; 113, identifier:pval; 114, call; 114, 115; 114, 122; 115, attribute; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:key; 119, identifier:__class__; 120, identifier:__name__; 121, identifier:lower; 122, argument_list; 123, True; 124, if_statement; 124, 125; 124, 132; 125, comparison_operator:is; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:key; 128, identifier:default; 129, attribute; 129, 130; 129, 131; 130, identifier:vol; 131, identifier:UNDEFINED; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:pval; 137, string:'default'; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:key; 141, identifier:default; 142, argument_list; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:val; 147, identifier:append; 148, argument_list; 148, 149; 149, identifier:pval; 150, return_statement; 150, 151; 151, identifier:val; 152, if_statement; 152, 153; 152, 160; 153, call; 153, 154; 153, 155; 154, identifier:isinstance; 155, argument_list; 155, 156; 155, 157; 156, identifier:schema; 157, attribute; 157, 158; 157, 159; 158, identifier:vol; 159, identifier:All; 160, block; 160, 161; 160, 165; 160, 181; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:val; 164, dictionary; 165, for_statement; 165, 166; 165, 167; 165, 170; 166, identifier:validator; 167, attribute; 167, 168; 167, 169; 168, identifier:schema; 169, identifier:validators; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:val; 175, identifier:update; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:convert; 179, argument_list; 179, 180; 180, identifier:validator; 181, return_statement; 181, 182; 182, identifier:val; 183, if_statement; 183, 184; 183, 195; 184, call; 184, 185; 184, 186; 185, identifier:isinstance; 186, argument_list; 186, 187; 186, 188; 187, identifier:schema; 188, tuple; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:vol; 191, identifier:Clamp; 192, attribute; 192, 193; 192, 194; 193, identifier:vol; 194, identifier:Range; 195, block; 195, 196; 195, 200; 195, 215; 195, 230; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:val; 199, dictionary; 200, if_statement; 200, 201; 200, 206; 201, comparison_operator:is; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:schema; 204, identifier:min; 205, None; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:val; 211, string:'valueMin'; 212, attribute; 212, 213; 212, 214; 213, identifier:schema; 214, identifier:min; 215, if_statement; 215, 216; 215, 221; 216, comparison_operator:is; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:schema; 219, identifier:max; 220, None; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:val; 226, string:'valueMax'; 227, attribute; 227, 228; 227, 229; 228, identifier:schema; 229, identifier:max; 230, return_statement; 230, 231; 231, identifier:val; 232, if_statement; 232, 233; 232, 240; 233, call; 233, 234; 233, 235; 234, identifier:isinstance; 235, argument_list; 235, 236; 235, 237; 236, identifier:schema; 237, attribute; 237, 238; 237, 239; 238, identifier:vol; 239, identifier:Length; 240, block; 240, 241; 240, 245; 240, 260; 240, 275; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:val; 244, dictionary; 245, if_statement; 245, 246; 245, 251; 246, comparison_operator:is; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:schema; 249, identifier:min; 250, None; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 257; 254, subscript; 254, 255; 254, 256; 255, identifier:val; 256, string:'lengthMin'; 257, attribute; 257, 258; 257, 259; 258, identifier:schema; 259, identifier:min; 260, if_statement; 260, 261; 260, 266; 261, comparison_operator:is; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:schema; 264, identifier:max; 265, None; 266, block; 266, 267; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 272; 269, subscript; 269, 270; 269, 271; 270, identifier:val; 271, string:'lengthMax'; 272, attribute; 272, 273; 272, 274; 273, identifier:schema; 274, identifier:max; 275, return_statement; 275, 276; 276, identifier:val; 277, if_statement; 277, 278; 277, 285; 278, call; 278, 279; 278, 280; 279, identifier:isinstance; 280, argument_list; 280, 281; 280, 282; 281, identifier:schema; 282, attribute; 282, 283; 282, 284; 283, identifier:vol; 284, identifier:Datetime; 285, block; 285, 286; 286, return_statement; 286, 287; 287, dictionary; 287, 288; 287, 291; 288, pair; 288, 289; 288, 290; 289, string:'type'; 290, string:'datetime'; 291, pair; 291, 292; 291, 293; 292, string:'format'; 293, attribute; 293, 294; 293, 295; 294, identifier:schema; 295, identifier:format; 296, if_statement; 296, 297; 296, 304; 297, call; 297, 298; 297, 299; 298, identifier:isinstance; 299, argument_list; 299, 300; 299, 301; 300, identifier:schema; 301, attribute; 301, 302; 301, 303; 302, identifier:vol; 303, identifier:In; 304, block; 304, 305; 304, 331; 305, if_statement; 305, 306; 305, 313; 306, call; 306, 307; 306, 308; 307, identifier:isinstance; 308, argument_list; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:schema; 311, identifier:container; 312, identifier:Mapping; 313, block; 313, 314; 314, return_statement; 314, 315; 315, dictionary; 315, 316; 315, 319; 316, pair; 316, 317; 316, 318; 317, string:'type'; 318, string:'select'; 319, pair; 319, 320; 319, 321; 320, string:'options'; 321, call; 321, 322; 321, 323; 322, identifier:list; 323, argument_list; 323, 324; 324, call; 324, 325; 324, 330; 325, attribute; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:schema; 328, identifier:container; 329, identifier:items; 330, argument_list; 331, return_statement; 331, 332; 332, dictionary; 332, 333; 332, 336; 333, pair; 333, 334; 333, 335; 334, string:'type'; 335, string:'select'; 336, pair; 336, 337; 336, 338; 337, string:'options'; 338, list_comprehension; 338, 339; 338, 342; 339, tuple; 339, 340; 339, 341; 340, identifier:item; 341, identifier:item; 342, for_in_clause; 342, 343; 342, 344; 343, identifier:item; 344, attribute; 344, 345; 344, 346; 345, identifier:schema; 346, identifier:container; 347, if_statement; 347, 348; 347, 366; 348, comparison_operator:in; 348, 349; 348, 350; 349, identifier:schema; 350, tuple; 350, 351; 350, 354; 350, 357; 350, 360; 350, 363; 351, attribute; 351, 352; 351, 353; 352, identifier:vol; 353, identifier:Lower; 354, attribute; 354, 355; 354, 356; 355, identifier:vol; 356, identifier:Upper; 357, attribute; 357, 358; 357, 359; 358, identifier:vol; 359, identifier:Capitalize; 360, attribute; 360, 361; 360, 362; 361, identifier:vol; 362, identifier:Title; 363, attribute; 363, 364; 363, 365; 364, identifier:vol; 365, identifier:Strip; 366, block; 366, 367; 367, return_statement; 367, 368; 368, dictionary; 368, 369; 369, pair; 369, 370; 369, 377; 370, call; 370, 371; 370, 376; 371, attribute; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:schema; 374, identifier:__name__; 375, identifier:lower; 376, argument_list; 377, True; 378, if_statement; 378, 379; 378, 386; 379, call; 379, 380; 379, 381; 380, identifier:isinstance; 381, argument_list; 381, 382; 381, 383; 382, identifier:schema; 383, attribute; 383, 384; 383, 385; 384, identifier:vol; 385, identifier:Coerce; 386, block; 386, 387; 387, expression_statement; 387, 388; 388, assignment; 388, 389; 388, 390; 389, identifier:schema; 390, attribute; 390, 391; 390, 392; 391, identifier:schema; 392, identifier:type; 393, if_statement; 393, 394; 393, 397; 394, comparison_operator:in; 394, 395; 394, 396; 395, identifier:schema; 396, identifier:TYPES_MAP; 397, block; 397, 398; 398, return_statement; 398, 399; 399, dictionary; 399, 400; 400, pair; 400, 401; 400, 402; 401, string:'type'; 402, subscript; 402, 403; 402, 404; 403, identifier:TYPES_MAP; 404, identifier:schema; 405, raise_statement; 405, 406; 406, call; 406, 407; 406, 408; 407, identifier:ValueError; 408, argument_list; 408, 409; 409, call; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, string:'Unable to convert schema: {}'; 412, identifier:format; 413, argument_list; 413, 414; 414, identifier:schema | def convert(schema):
if isinstance(schema, vol.Schema):
schema = schema.schema
if isinstance(schema, Mapping):
val = []
for key, value in schema.items():
description = None
if isinstance(key, vol.Marker):
pkey = key.schema
description = key.description
else:
pkey = key
pval = convert(value)
pval['name'] = pkey
if description is not None:
pval['description'] = description
if isinstance(key, (vol.Required, vol.Optional)):
pval[key.__class__.__name__.lower()] = True
if key.default is not vol.UNDEFINED:
pval['default'] = key.default()
val.append(pval)
return val
if isinstance(schema, vol.All):
val = {}
for validator in schema.validators:
val.update(convert(validator))
return val
if isinstance(schema, (vol.Clamp, vol.Range)):
val = {}
if schema.min is not None:
val['valueMin'] = schema.min
if schema.max is not None:
val['valueMax'] = schema.max
return val
if isinstance(schema, vol.Length):
val = {}
if schema.min is not None:
val['lengthMin'] = schema.min
if schema.max is not None:
val['lengthMax'] = schema.max
return val
if isinstance(schema, vol.Datetime):
return {
'type': 'datetime',
'format': schema.format,
}
if isinstance(schema, vol.In):
if isinstance(schema.container, Mapping):
return {
'type': 'select',
'options': list(schema.container.items()),
}
return {
'type': 'select',
'options': [(item, item) for item in schema.container]
}
if schema in (vol.Lower, vol.Upper, vol.Capitalize, vol.Title, vol.Strip):
return {
schema.__name__.lower(): True,
}
if isinstance(schema, vol.Coerce):
schema = schema.type
if schema in TYPES_MAP:
return {'type': TYPES_MAP[schema]}
raise ValueError('Unable to convert schema: {}'.format(schema)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_jsmin; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 19; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:theA; 11, string:'\n'; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_action; 17, argument_list; 17, 18; 18, integer:3; 19, while_statement; 19, 20; 19, 25; 20, comparison_operator:!=; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:theA; 24, string:'\000'; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 32; 26, 57; 26, 123; 27, comparison_operator:==; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:theA; 31, string:' '; 32, block; 32, 33; 33, if_statement; 33, 34; 33, 40; 33, 48; 34, call; 34, 35; 34, 36; 35, identifier:isAlphanum; 36, argument_list; 36, 37; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:theB; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_action; 46, argument_list; 46, 47; 47, integer:1; 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:self; 54, identifier:_action; 55, argument_list; 55, 56; 56, integer:2; 57, elif_clause; 57, 58; 57, 63; 58, comparison_operator:==; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:theA; 62, string:'\n'; 63, block; 63, 64; 64, if_statement; 64, 65; 64, 75; 64, 83; 64, 97; 65, comparison_operator:in; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:theB; 69, list:['{', '[', '(', '+', '-']; 69, 70; 69, 71; 69, 72; 69, 73; 69, 74; 70, string:'{'; 71, string:'['; 72, string:'('; 73, string:'+'; 74, string:'-'; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_action; 81, argument_list; 81, 82; 82, integer:1; 83, elif_clause; 83, 84; 83, 89; 84, comparison_operator:==; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:theB; 88, string:' '; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_action; 95, argument_list; 95, 96; 96, integer:3; 97, else_clause; 97, 98; 98, block; 98, 99; 99, if_statement; 99, 100; 99, 106; 99, 114; 100, call; 100, 101; 100, 102; 101, identifier:isAlphanum; 102, argument_list; 102, 103; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:theB; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:_action; 112, argument_list; 112, 113; 113, integer:1; 114, else_clause; 114, 115; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:_action; 121, argument_list; 121, 122; 122, integer:2; 123, else_clause; 123, 124; 124, block; 124, 125; 125, if_statement; 125, 126; 125, 131; 125, 156; 125, 210; 126, comparison_operator:==; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:theB; 130, string:' '; 131, block; 131, 132; 132, if_statement; 132, 133; 132, 139; 132, 147; 133, call; 133, 134; 133, 135; 134, identifier:isAlphanum; 135, argument_list; 135, 136; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:theA; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:_action; 145, argument_list; 145, 146; 146, integer:1; 147, else_clause; 147, 148; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:_action; 154, argument_list; 154, 155; 155, integer:3; 156, elif_clause; 156, 157; 156, 162; 157, comparison_operator:==; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:theB; 161, string:'\n'; 162, block; 162, 163; 163, if_statement; 163, 164; 163, 176; 163, 184; 164, comparison_operator:in; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:theA; 168, list:['}', ']', ')', '+', '-', '"', '\'']; 168, 169; 168, 170; 168, 171; 168, 172; 168, 173; 168, 174; 168, 175; 169, string:'}'; 170, string:']'; 171, string:')'; 172, string:'+'; 173, string:'-'; 174, string:'"'; 175, string:'\''; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:_action; 182, argument_list; 182, 183; 183, integer:1; 184, else_clause; 184, 185; 185, block; 185, 186; 186, if_statement; 186, 187; 186, 193; 186, 201; 187, call; 187, 188; 187, 189; 188, identifier:isAlphanum; 189, argument_list; 189, 190; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:theA; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:_action; 199, argument_list; 199, 200; 200, integer:1; 201, else_clause; 201, 202; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:_action; 208, argument_list; 208, 209; 209, integer:3; 210, else_clause; 210, 211; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_action; 217, argument_list; 217, 218; 218, integer:1 | def _jsmin(self):
self.theA = '\n'
self._action(3)
while self.theA != '\000':
if self.theA == ' ':
if isAlphanum(self.theB):
self._action(1)
else:
self._action(2)
elif self.theA == '\n':
if self.theB in ['{', '[', '(', '+', '-']:
self._action(1)
elif self.theB == ' ':
self._action(3)
else:
if isAlphanum(self.theB):
self._action(1)
else:
self._action(2)
else:
if self.theB == ' ':
if isAlphanum(self.theA):
self._action(1)
else:
self._action(3)
elif self.theB == '\n':
if self.theA in ['}', ']', ')', '+', '-', '"', '\'']:
self._action(1)
else:
if isAlphanum(self.theA):
self._action(1)
else:
self._action(3)
else:
self._action(1) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:tokenizer; 3, parameters; 3, 4; 4, identifier:text; 5, block; 5, 6; 5, 18; 5, 393; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:stream; 9, call; 9, 10; 9, 11; 10, identifier:deque; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:text; 15, identifier:split; 16, argument_list; 16, 17; 17, string:"\n"; 18, while_statement; 18, 19; 18, 25; 19, comparison_operator:>; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:stream; 24, integer:0; 25, block; 25, 26; 25, 34; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:line; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:stream; 32, identifier:popleft; 33, argument_list; 34, if_statement; 34, 35; 34, 56; 34, 80; 34, 142; 34, 216; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:line; 38, identifier:startswith; 39, generator_expression; 39, 40; 39, 48; 40, call; 40, 41; 40, 42; 40, 45; 41, string:"
yield KeyValue("; 42, ERROR; 42, 43; 42, 44; 43, identifier:yield; 44, identifier:KeyValue; 45, argument_list; 45, 46; 45, 47; 46, string:"HEADER"; 47, identifier:line; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:identifier; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:line; 53, identifier:split; 54, argument_list; 54, 55; 55, string:" "; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:in; 58, 59; 58, 60; 59, string:":"; 60, identifier:identifier; 61, block; 61, 62; 61, 73; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, pattern_list; 64, 65; 64, 66; 65, identifier:key; 66, identifier:value; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:identifier; 70, identifier:split; 71, argument_list; 71, 72; 72, string:":"; 73, expression_statement; 73, 74; 74, yield; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:KeyValue; 77, argument_list; 77, 78; 77, 79; 78, identifier:key; 79, identifier:value; 80, elif_clause; 80, 81; 80, 95; 80, 113; 81, attribute; 81, 82; 81, 91; 81, 94; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:line; 85, identifier:startswith; 86, argument_list; 86, 87; 86, 88; 86, 90; 87, string:"
yield KeyValue("; 88, ERROR; 88, 89; 89, identifier:HEADER; 90, identifier:line; 91, ERROR; 91, 92; 91, 93; 92, identifier:elif; 93, identifier:line; 94, identifier:startswith; 95, ERROR; 95, 96; 95, 97; 95, 100; 95, 101; 95, 104; 96, string:"
yield KeyValue("; 97, ERROR; 97, 98; 97, 99; 98, identifier:yield; 99, identifier:KeyValue; 100, string:"
elif line.startswith("; 101, ERROR; 101, 102; 101, 103; 102, identifier:yield; 103, identifier:KeyValue; 104, call; 104, 105; 104, 111; 105, attribute; 105, 106; 105, 107; 105, 110; 106, string:"
yield KeyValue(line.strip(), "; 107, ERROR; 107, 108; 107, 109; 108, escape_sequence:\n; 109, identifier:line; 110, identifier:startswith; 111, argument_list; 111, 112; 112, string:"SUBJECT_SAMPLE_FACTORS"; 113, block; 113, 114; 113, 128; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 122; 116, pattern_list; 116, 117; 116, 118; 116, 119; 116, 120; 116, 121; 117, identifier:key; 118, identifier:subject_type; 119, identifier:local_sample_id; 120, identifier:factors; 121, identifier:additional_sample_data; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:line; 125, identifier:split; 126, argument_list; 126, 127; 127, string:"\t"; 128, expression_statement; 128, 129; 129, yield; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:SubjectSampleFactors; 132, argument_list; 132, 133; 132, 138; 132, 139; 132, 140; 132, 141; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:key; 136, identifier:strip; 137, argument_list; 138, identifier:subject_type; 139, identifier:local_sample_id; 140, identifier:factors; 141, identifier:additional_sample_data; 142, elif_clause; 142, 143; 142, 149; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:line; 146, identifier:endswith; 147, argument_list; 147, 148; 148, string:"_START"; 149, block; 149, 150; 149, 157; 150, expression_statement; 150, 151; 151, yield; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:KeyValue; 154, argument_list; 154, 155; 154, 156; 155, identifier:line; 156, string:"\n"; 157, while_statement; 157, 158; 157, 165; 158, not_operator; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:line; 162, identifier:endswith; 163, argument_list; 163, 164; 164, string:"_END"; 165, block; 165, 166; 165, 174; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:line; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:stream; 172, identifier:popleft; 173, argument_list; 174, if_statement; 174, 175; 174, 181; 174, 193; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:line; 178, identifier:endswith; 179, argument_list; 179, 180; 180, string:"_END"; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, yield; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:KeyValue; 186, argument_list; 186, 187; 186, 192; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:line; 190, identifier:strip; 191, argument_list; 192, string:"\n"; 193, else_clause; 193, 194; 194, block; 194, 195; 194, 204; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:data; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:line; 201, identifier:split; 202, argument_list; 202, 203; 203, string:"\t"; 204, expression_statement; 204, 205; 205, yield; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:KeyValue; 208, argument_list; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:data; 211, integer:0; 212, call; 212, 213; 212, 214; 213, identifier:tuple; 214, argument_list; 214, 215; 215, identifier:data; 216, else_clause; 216, 217; 217, block; 217, 218; 218, if_statement; 218, 219; 218, 220; 219, identifier:line; 220, block; 220, 221; 221, if_statement; 221, 222; 221, 235; 221, 311; 222, boolean_operator:or; 222, 223; 222, 229; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:line; 226, identifier:startswith; 227, argument_list; 227, 228; 228, string:"MS:MS_RESULTS_FILE"; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:line; 232, identifier:startswith; 233, argument_list; 233, 234; 234, string:"NM:NMR_RESULTS_FILE"; 235, block; 235, 236; 236, try_statement; 236, 237; 236, 282; 237, block; 237, 238; 237, 250; 237, 265; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 244; 240, pattern_list; 240, 241; 240, 242; 240, 243; 241, identifier:key; 242, identifier:value; 243, identifier:extra; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:line; 247, identifier:split; 248, argument_list; 248, 249; 249, string:"\t"; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 255; 252, pattern_list; 252, 253; 252, 254; 253, identifier:extra_key; 254, identifier:extra_value; 255, call; 255, 256; 255, 263; 256, attribute; 256, 257; 256, 262; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:extra; 260, identifier:strip; 261, argument_list; 262, identifier:split; 263, argument_list; 263, 264; 264, string:":"; 265, expression_statement; 265, 266; 266, yield; 266, 267; 267, call; 267, 268; 267, 269; 268, identifier:KeyValueExtra; 269, argument_list; 269, 270; 269, 279; 269, 280; 269, 281; 270, subscript; 270, 271; 270, 276; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:key; 274, identifier:strip; 275, argument_list; 276, slice; 276, 277; 276, 278; 277, integer:3; 278, colon; 279, identifier:value; 280, identifier:extra_key; 281, identifier:extra_value; 282, except_clause; 282, 283; 282, 284; 283, identifier:ValueError; 284, block; 284, 285; 284, 296; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 290; 287, pattern_list; 287, 288; 287, 289; 288, identifier:key; 289, identifier:value; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:line; 293, identifier:split; 294, argument_list; 294, 295; 295, string:"\t"; 296, expression_statement; 296, 297; 297, yield; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:KeyValue; 300, argument_list; 300, 301; 300, 310; 301, subscript; 301, 302; 301, 307; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:key; 305, identifier:strip; 306, argument_list; 307, slice; 307, 308; 307, 309; 308, integer:3; 309, colon; 310, identifier:value; 311, else_clause; 311, 312; 312, block; 312, 313; 313, try_statement; 313, 314; 313, 380; 314, block; 314, 315; 314, 326; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 320; 317, pattern_list; 317, 318; 317, 319; 318, identifier:key; 319, identifier:value; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:line; 323, identifier:split; 324, argument_list; 324, 325; 325, string:"\t"; 326, if_statement; 326, 327; 326, 330; 326, 367; 327, comparison_operator:in; 327, 328; 327, 329; 328, string:":"; 329, identifier:key; 330, block; 330, 331; 331, if_statement; 331, 332; 331, 338; 331, 350; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:key; 335, identifier:startswith; 336, argument_list; 336, 337; 337, string:"MS_METABOLITE_DATA:UNITS"; 338, block; 338, 339; 339, expression_statement; 339, 340; 340, yield; 340, 341; 341, call; 341, 342; 341, 343; 342, identifier:KeyValue; 343, argument_list; 343, 344; 343, 349; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:key; 347, identifier:strip; 348, argument_list; 349, identifier:value; 350, else_clause; 350, 351; 351, block; 351, 352; 352, expression_statement; 352, 353; 353, yield; 353, 354; 354, call; 354, 355; 354, 356; 355, identifier:KeyValue; 356, argument_list; 356, 357; 356, 366; 357, subscript; 357, 358; 357, 363; 358, call; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:key; 361, identifier:strip; 362, argument_list; 363, slice; 363, 364; 363, 365; 364, integer:3; 365, colon; 366, identifier:value; 367, else_clause; 367, 368; 368, block; 368, 369; 369, expression_statement; 369, 370; 370, yield; 370, 371; 371, call; 371, 372; 371, 373; 372, identifier:KeyValue; 373, argument_list; 373, 374; 373, 379; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:key; 377, identifier:strip; 378, argument_list; 379, identifier:value; 380, except_clause; 380, 381; 380, 382; 381, identifier:ValueError; 382, block; 382, 383; 382, 392; 383, expression_statement; 383, 384; 384, call; 384, 385; 384, 386; 385, identifier:print; 386, argument_list; 386, 387; 386, 388; 387, string:"LINE WITH ERROR:\n\t"; 388, call; 388, 389; 388, 390; 389, identifier:repr; 390, argument_list; 390, 391; 391, identifier:line; 392, raise_statement; 393, ERROR; 393, 394; 393, 395; 393, 396; 394, identifier:KeyValue; 395, string:"
yield KeyValue("; 396, ERROR:! | def tokenizer(text):
stream = deque(text.split("\n"))
while len(stream) > 0:
line = stream.popleft()
if line.startswith("
yield KeyValue("
yield KeyValue("HEADER", line)
for identifier in line.split(" "):
if ":" in identifier:
key, value = identifier.split(":")
yield KeyValue(key, value)
elif line.startswith("
yield KeyValue("HEADER", line)
elif line.startswith("
yield KeyValue("
yield KeyValue("
elif line.startswith("
yield KeyValue("
yield KeyValue(line.strip(), "\n")
elif line.startswith("SUBJECT_SAMPLE_FACTORS"):
key, subject_type, local_sample_id, factors, additional_sample_data = line.split("\t")
yield SubjectSampleFactors(key.strip(), subject_type, local_sample_id, factors, additional_sample_data)
elif line.endswith("_START"):
yield KeyValue(line, "\n")
while not line.endswith("_END"):
line = stream.popleft()
if line.endswith("_END"):
yield KeyValue(line.strip(), "\n")
else:
data = line.split("\t")
yield KeyValue(data[0], tuple(data))
else:
if line:
if line.startswith("MS:MS_RESULTS_FILE") or line.startswith("NM:NMR_RESULTS_FILE"):
try:
key, value, extra = line.split("\t")
extra_key, extra_value = extra.strip().split(":")
yield KeyValueExtra(key.strip()[3:], value, extra_key, extra_value)
except ValueError:
key, value = line.split("\t")
yield KeyValue(key.strip()[3:], value)
else:
try:
key, value = line.split("\t")
if ":" in key:
if key.startswith("MS_METABOLITE_DATA:UNITS"):
yield KeyValue(key.strip(), value)
else:
yield KeyValue(key.strip()[3:], value)
else:
yield KeyValue(key.strip(), value)
except ValueError:
print("LINE WITH ERROR:\n\t", repr(line))
raise
yield KeyValue("
yield KeyValue("! |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_proxy; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:url; 6, default_parameter; 6, 7; 6, 8; 7, identifier:urlparams; 8, None; 9, block; 9, 10; 9, 28; 9, 35; 9, 39; 9, 59; 9, 70; 9, 114; 9, 123; 9, 131; 9, 139; 9, 143; 9, 180; 9, 188; 9, 194; 10, for_statement; 10, 11; 10, 14; 10, 21; 11, pattern_list; 11, 12; 11, 13; 12, identifier:k; 13, identifier:v; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:request; 18, identifier:params; 19, identifier:iteritems; 20, argument_list; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:urlparams; 26, identifier:k; 27, identifier:v; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:query; 31, call; 31, 32; 31, 33; 32, identifier:urlencode; 33, argument_list; 33, 34; 34, identifier:urlparams; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:full_url; 38, identifier:url; 39, if_statement; 39, 40; 39, 41; 40, identifier:query; 41, block; 41, 42; 41, 55; 42, if_statement; 42, 43; 42, 50; 43, not_operator; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:full_url; 47, identifier:endswith; 48, argument_list; 48, 49; 49, string:"?"; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, augmented_assignment:+=; 52, 53; 52, 54; 53, identifier:full_url; 54, string:"?"; 55, expression_statement; 55, 56; 56, augmented_assignment:+=; 56, 57; 56, 58; 57, identifier:full_url; 58, identifier:query; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:req; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:urllib2; 65, identifier:Request; 66, argument_list; 66, 67; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:url; 69, identifier:full_url; 70, for_statement; 70, 71; 70, 72; 70, 75; 71, identifier:header; 72, attribute; 72, 73; 72, 74; 73, identifier:request; 74, identifier:headers; 75, block; 75, 76; 76, if_statement; 76, 77; 76, 84; 76, 100; 77, comparison_operator:==; 77, 78; 77, 83; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:header; 81, identifier:lower; 82, argument_list; 83, string:"host"; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:req; 89, identifier:add_header; 90, argument_list; 90, 91; 90, 92; 91, identifier:header; 92, subscript; 92, 93; 92, 99; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:urlparse; 96, identifier:urlparse; 97, argument_list; 97, 98; 98, identifier:url; 99, integer:1; 100, else_clause; 100, 101; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:req; 106, identifier:add_header; 107, argument_list; 107, 108; 107, 109; 108, identifier:header; 109, subscript; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:request; 112, identifier:headers; 113, identifier:header; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:res; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:urllib2; 120, identifier:urlopen; 121, argument_list; 121, 122; 122, identifier:req; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:i; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:res; 129, identifier:info; 130, argument_list; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:response; 135, identifier:status; 136, attribute; 136, 137; 136, 138; 137, identifier:res; 138, identifier:code; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:got_content_length; 142, False; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:header; 145, identifier:i; 146, block; 146, 147; 146, 157; 146, 170; 147, if_statement; 147, 148; 147, 155; 148, comparison_operator:==; 148, 149; 148, 154; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:header; 152, identifier:lower; 153, argument_list; 154, string:"transfer-encoding"; 155, block; 155, 156; 156, continue_statement; 157, if_statement; 157, 158; 157, 165; 158, comparison_operator:==; 158, 159; 158, 164; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:header; 162, identifier:lower; 163, argument_list; 164, string:"content-length"; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:got_content_length; 169, True; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 177; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:response; 175, identifier:headers; 176, identifier:header; 177, subscript; 177, 178; 177, 179; 178, identifier:i; 179, identifier:header; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:result; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:res; 186, identifier:read; 187, argument_list; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:res; 192, identifier:close; 193, argument_list; 194, return_statement; 194, 195; 195, identifier:result | def _proxy(self, url, urlparams=None):
for k,v in request.params.iteritems():
urlparams[k]=v
query = urlencode(urlparams)
full_url = url
if query:
if not full_url.endswith("?"):
full_url += "?"
full_url += query
req = urllib2.Request(url=full_url)
for header in request.headers:
if header.lower() == "host":
req.add_header(header, urlparse.urlparse(url)[1])
else:
req.add_header(header, request.headers[header])
res = urllib2.urlopen(req)
i = res.info()
response.status = res.code
got_content_length = False
for header in i:
if header.lower() == "transfer-encoding":
continue
if header.lower() == "content-length":
got_content_length = True
response.headers[header] = i[header]
result = res.read()
res.close()
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:attempt_open_query_permutations; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:url; 5, identifier:orig_file_path; 6, identifier:is_header_file; 7, block; 7, 8; 7, 20; 7, 48; 7, 109; 7, 118; 7, 134; 7, 140; 7, 146; 7, 155; 7, 170; 7, 184; 7, 200; 7, 223; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:directory; 11, binary_operator:+; 11, 12; 11, 19; 12, call; 12, 13; 12, 14; 13, identifier:dirname; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:convert_to_platform_safe; 17, argument_list; 17, 18; 18, identifier:orig_file_path; 19, string:"/"; 20, try_statement; 20, 21; 20, 44; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:filenames; 25, list_comprehension; 25, 26; 25, 27; 25, 35; 26, identifier:f; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:f; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:os; 32, identifier:listdir; 33, argument_list; 33, 34; 34, identifier:directory; 35, if_clause; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:isfile; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:join; 41, argument_list; 41, 42; 41, 43; 42, identifier:directory; 43, identifier:f; 44, except_clause; 44, 45; 44, 46; 45, identifier:OSError; 46, block; 46, 47; 47, return_statement; 48, if_statement; 48, 49; 48, 50; 48, 80; 49, identifier:is_header_file; 50, block; 50, 51; 50, 63; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:filenames; 54, list_comprehension; 54, 55; 54, 56; 54, 59; 55, identifier:f; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:f; 58, identifier:filenames; 59, if_clause; 59, 60; 60, comparison_operator:in; 60, 61; 60, 62; 61, string:".http-headers"; 62, identifier:f; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:filenames; 66, list_comprehension; 66, 67; 66, 68; 66, 71; 67, identifier:f; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:f; 70, identifier:filenames; 71, if_clause; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:_compare_file_name; 74, argument_list; 74, 75; 74, 78; 74, 79; 75, binary_operator:+; 75, 76; 75, 77; 76, identifier:orig_file_path; 77, string:".http-headers"; 78, identifier:directory; 79, identifier:f; 80, else_clause; 80, 81; 81, block; 81, 82; 81, 94; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:filenames; 85, list_comprehension; 85, 86; 85, 87; 85, 90; 86, identifier:f; 87, for_in_clause; 87, 88; 87, 89; 88, identifier:f; 89, identifier:filenames; 90, if_clause; 90, 91; 91, comparison_operator:not; 91, 92; 91, 93; 92, string:".http-headers"; 93, identifier:f; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:filenames; 97, list_comprehension; 97, 98; 97, 99; 97, 102; 98, identifier:f; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:f; 101, identifier:filenames; 102, if_clause; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:_compare_file_name; 105, argument_list; 105, 106; 105, 107; 105, 108; 106, identifier:orig_file_path; 107, identifier:directory; 108, identifier:f; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:url_parts; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:url; 115, identifier:split; 116, argument_list; 116, 117; 117, string:"/"; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:url_parts; 121, call; 121, 122; 121, 132; 122, attribute; 122, 123; 122, 131; 123, subscript; 123, 124; 123, 125; 124, identifier:url_parts; 125, binary_operator:-; 125, 126; 125, 130; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, identifier:url_parts; 130, integer:1; 131, identifier:split; 132, argument_list; 132, 133; 133, string:"?"; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:base; 137, subscript; 137, 138; 137, 139; 138, identifier:url_parts; 139, integer:0; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:params; 143, subscript; 143, 144; 143, 145; 144, identifier:url_parts; 145, integer:1; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:params; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:params; 152, identifier:split; 153, argument_list; 153, 154; 154, string:"&"; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:filenames; 158, list_comprehension; 158, 159; 158, 160; 158, 163; 159, identifier:f; 160, for_in_clause; 160, 161; 160, 162; 161, identifier:f; 162, identifier:filenames; 163, if_clause; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:f; 167, identifier:startswith; 168, argument_list; 168, 169; 169, identifier:base; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:params; 173, list_comprehension; 173, 174; 173, 181; 174, call; 174, 175; 174, 176; 175, identifier:convert_to_platform_safe; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:unquote; 179, argument_list; 179, 180; 180, identifier:p; 181, for_in_clause; 181, 182; 181, 183; 182, identifier:p; 183, identifier:params; 184, for_statement; 184, 185; 184, 186; 184, 187; 185, identifier:param; 186, identifier:params; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:filenames; 191, list_comprehension; 191, 192; 191, 193; 191, 196; 192, identifier:f; 193, for_in_clause; 193, 194; 193, 195; 194, identifier:f; 195, identifier:filenames; 196, if_clause; 196, 197; 197, comparison_operator:in; 197, 198; 197, 199; 198, identifier:param; 199, identifier:f; 200, if_statement; 200, 201; 200, 207; 201, comparison_operator:==; 201, 202; 201, 206; 202, call; 202, 203; 202, 204; 203, identifier:len; 204, argument_list; 204, 205; 205, identifier:filenames; 206, integer:1; 207, block; 207, 208; 207, 218; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:path; 211, call; 211, 212; 211, 213; 212, identifier:join; 213, argument_list; 213, 214; 213, 215; 214, identifier:directory; 215, subscript; 215, 216; 215, 217; 216, identifier:filenames; 217, integer:0; 218, return_statement; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:open_file; 221, argument_list; 221, 222; 222, identifier:path; 223, if_statement; 223, 224; 223, 230; 224, comparison_operator:>; 224, 225; 224, 229; 225, call; 225, 226; 225, 227; 226, identifier:len; 227, argument_list; 227, 228; 228, identifier:filenames; 229, integer:1; 230, block; 230, 231; 231, raise_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:DataFailureException; 234, argument_list; 234, 235; 234, 236; 234, 239; 235, identifier:url; 236, binary_operator:+; 236, 237; 236, 238; 237, string:"Multiple mock data files matched the "; 238, string:"parameters provided!"; 239, integer:404 | def attempt_open_query_permutations(url, orig_file_path, is_header_file):
directory = dirname(convert_to_platform_safe(orig_file_path)) + "/"
try:
filenames = [f for f in os.listdir(directory)
if isfile(join(directory, f))]
except OSError:
return
if is_header_file:
filenames = [f for f in filenames if ".http-headers" in f]
filenames = [f for f in filenames if
_compare_file_name(orig_file_path + ".http-headers",
directory,
f)]
else:
filenames = [f for f in filenames if ".http-headers" not in f]
filenames = [f for f in filenames if _compare_file_name(orig_file_path,
directory,
f)]
url_parts = url.split("/")
url_parts = url_parts[len(url_parts) - 1].split("?")
base = url_parts[0]
params = url_parts[1]
params = params.split("&")
filenames = [f for f in filenames if f.startswith(base)]
params = [convert_to_platform_safe(unquote(p)) for p in params]
for param in params:
filenames = [f for f in filenames if param in f]
if len(filenames) == 1:
path = join(directory, filenames[0])
return open_file(path)
if len(filenames) > 1:
raise DataFailureException(url,
"Multiple mock data files matched the " +
"parameters provided!",
404) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:search_databases; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:search_term; 6, default_parameter; 6, 7; 6, 8; 7, identifier:location; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:markets_only; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:databases_to_search; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:allow_internal; 17, False; 18, block; 18, 19; 18, 23; 18, 67; 18, 104; 18, 112; 18, 118; 18, 137; 18, 158; 18, 170; 18, 177; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:dict_list; 22, list:[]; 23, if_statement; 23, 24; 23, 25; 24, identifier:allow_internal; 25, block; 25, 26; 25, 30; 25, 60; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:internal_dict; 29, dictionary; 30, for_statement; 30, 31; 30, 34; 30, 43; 31, pattern_list; 31, 32; 31, 33; 32, identifier:k; 33, identifier:v; 34, call; 34, 35; 34, 42; 35, attribute; 35, 36; 35, 41; 36, subscript; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:database; 40, string:'items'; 41, identifier:items; 42, argument_list; 43, block; 43, 44; 44, if_statement; 44, 45; 44, 53; 45, comparison_operator:==; 45, 46; 45, 52; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:v; 49, identifier:get; 50, argument_list; 50, 51; 51, string:'lcopt_type'; 52, string:'intermediate'; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:internal_dict; 58, identifier:k; 59, identifier:v; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:dict_list; 64, identifier:append; 65, argument_list; 65, 66; 66, identifier:internal_dict; 67, if_statement; 67, 68; 67, 71; 67, 84; 68, comparison_operator:is; 68, 69; 68, 70; 69, identifier:databases_to_search; 70, None; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, augmented_assignment:+=; 73, 74; 73, 75; 74, identifier:dict_list; 75, list_comprehension; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:x; 78, string:'items'; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:x; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:external_databases; 84, else_clause; 84, 85; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, augmented_assignment:+=; 87, 88; 87, 89; 88, identifier:dict_list; 89, list_comprehension; 89, 90; 89, 93; 89, 98; 90, subscript; 90, 91; 90, 92; 91, identifier:x; 92, string:'items'; 93, for_in_clause; 93, 94; 93, 95; 94, identifier:x; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:external_databases; 98, if_clause; 98, 99; 99, comparison_operator:in; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:x; 102, string:'name'; 103, identifier:databases_to_search; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:data; 107, call; 107, 108; 107, 109; 108, identifier:Dictionaries; 109, argument_list; 109, 110; 110, list_splat; 110, 111; 111, identifier:dict_list; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:query; 115, call; 115, 116; 115, 117; 116, identifier:Query; 117, argument_list; 118, if_statement; 118, 119; 118, 120; 119, identifier:markets_only; 120, block; 120, 121; 120, 130; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:market_filter; 124, call; 124, 125; 124, 126; 125, identifier:Filter; 126, argument_list; 126, 127; 126, 128; 126, 129; 127, string:"name"; 128, string:"has"; 129, string:"market for"; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:query; 134, identifier:add; 135, argument_list; 135, 136; 136, identifier:market_filter; 137, if_statement; 137, 138; 137, 141; 138, comparison_operator:is; 138, 139; 138, 140; 139, identifier:location; 140, None; 141, block; 141, 142; 141, 151; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:location_filter; 145, call; 145, 146; 145, 147; 146, identifier:Filter; 147, argument_list; 147, 148; 147, 149; 147, 150; 148, string:"location"; 149, string:"is"; 150, identifier:location; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:query; 155, identifier:add; 156, argument_list; 156, 157; 157, identifier:location_filter; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:query; 162, identifier:add; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:Filter; 166, argument_list; 166, 167; 166, 168; 166, 169; 167, string:"name"; 168, string:"ihas"; 169, identifier:search_term; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:result; 173, call; 173, 174; 173, 175; 174, identifier:query; 175, argument_list; 175, 176; 176, identifier:data; 177, return_statement; 177, 178; 178, identifier:result | def search_databases(self, search_term, location=None, markets_only=False, databases_to_search=None, allow_internal=False):
dict_list = []
if allow_internal:
internal_dict = {}
for k, v in self.database['items'].items():
if v.get('lcopt_type') == 'intermediate':
internal_dict[k] = v
dict_list.append(internal_dict)
if databases_to_search is None:
dict_list += [x['items'] for x in self.external_databases]
else:
dict_list += [x['items'] for x in self.external_databases if x['name'] in databases_to_search]
data = Dictionaries(*dict_list)
query = Query()
if markets_only:
market_filter = Filter("name", "has", "market for")
query.add(market_filter)
if location is not None:
location_filter = Filter("location", "is", location)
query.add(location_filter)
query.add(Filter("name", "ihas", search_term))
result = query(data)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:create_parameter_map; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 24; 5, 28; 5, 50; 5, 173; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:names; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:modelInstance; 13, identifier:names; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:db; 17, subscript; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:modelInstance; 22, identifier:database; 23, string:'items'; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:parameter_map; 27, dictionary; 28, function_definition; 28, 29; 28, 30; 28, 32; 29, function_name:get_names_index; 30, parameters; 30, 31; 31, identifier:my_thing; 32, block; 32, 33; 33, return_statement; 33, 34; 34, subscript; 34, 35; 34, 49; 35, list_comprehension; 35, 36; 35, 37; 35, 45; 36, identifier:i; 37, for_in_clause; 37, 38; 37, 41; 38, pattern_list; 38, 39; 38, 40; 39, identifier:i; 40, identifier:x; 41, call; 41, 42; 41, 43; 42, identifier:enumerate; 43, argument_list; 43, 44; 44, identifier:names; 45, if_clause; 45, 46; 46, comparison_operator:==; 46, 47; 46, 48; 47, identifier:x; 48, identifier:my_thing; 49, integer:0; 50, for_statement; 50, 51; 50, 54; 50, 59; 51, pattern_list; 51, 52; 51, 53; 52, identifier:k; 53, identifier:this_item; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:db; 57, identifier:items; 58, argument_list; 59, block; 59, 60; 60, if_statement; 60, 61; 60, 66; 61, comparison_operator:==; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:this_item; 64, string:'type'; 65, string:'process'; 66, block; 66, 67; 66, 87; 66, 105; 66, 116; 66, 131; 66, 145; 66, 166; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:production_id; 70, subscript; 70, 71; 70, 86; 71, list_comprehension; 71, 72; 71, 75; 71, 80; 72, subscript; 72, 73; 72, 74; 73, identifier:x; 74, string:'input'; 75, for_in_clause; 75, 76; 75, 77; 76, identifier:x; 77, subscript; 77, 78; 77, 79; 78, identifier:this_item; 79, string:'exchanges'; 80, if_clause; 80, 81; 81, comparison_operator:==; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:x; 84, string:'type'; 85, string:'production'; 86, integer:0; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:input_ids; 90, list_comprehension; 90, 91; 90, 94; 90, 99; 91, subscript; 91, 92; 91, 93; 92, identifier:x; 93, string:'input'; 94, for_in_clause; 94, 95; 94, 96; 95, identifier:x; 96, subscript; 96, 97; 96, 98; 97, identifier:this_item; 98, string:'exchanges'; 99, if_clause; 99, 100; 100, comparison_operator:==; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:x; 103, string:'type'; 104, string:'technosphere'; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:production_index; 108, call; 108, 109; 108, 110; 109, identifier:get_names_index; 110, argument_list; 110, 111; 111, subscript; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:db; 114, identifier:production_id; 115, string:'name'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:input_indexes; 119, list_comprehension; 119, 120; 119, 128; 120, call; 120, 121; 120, 122; 121, identifier:get_names_index; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:db; 126, identifier:x; 127, string:'name'; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:x; 130, identifier:input_ids; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:parameter_ids; 134, list_comprehension; 134, 135; 134, 142; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, string:'n_p_{}_{}'; 138, identifier:format; 139, argument_list; 139, 140; 139, 141; 140, identifier:x; 141, identifier:production_index; 142, for_in_clause; 142, 143; 142, 144; 143, identifier:x; 144, identifier:input_indexes; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:parameter_map_items; 148, dictionary_comprehension; 148, 149; 148, 158; 149, pair; 149, 150; 149, 155; 150, tuple; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:input_ids; 153, identifier:n; 154, identifier:k; 155, subscript; 155, 156; 155, 157; 156, identifier:parameter_ids; 157, identifier:n; 158, for_in_clause; 158, 159; 158, 162; 159, pattern_list; 159, 160; 159, 161; 160, identifier:n; 161, identifier:x; 162, call; 162, 163; 162, 164; 163, identifier:enumerate; 164, argument_list; 164, 165; 165, identifier:input_ids; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:parameter_map; 170, identifier:update; 171, argument_list; 171, 172; 172, identifier:parameter_map_items; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:parameter_map; 178, identifier:parameter_map | def create_parameter_map(self):
names = self.modelInstance.names
db = self.modelInstance.database['items']
parameter_map = {}
def get_names_index(my_thing):
return[i for i, x in enumerate(names) if x == my_thing][0]
for k, this_item in db.items():
if this_item['type'] == 'process':
production_id = [x['input'] for x in this_item['exchanges'] if x['type'] == 'production'][0]
input_ids = [x['input'] for x in this_item['exchanges'] if x['type'] == 'technosphere']
production_index = get_names_index(db[production_id]['name'])
input_indexes = [get_names_index(db[x]['name']) for x in input_ids]
parameter_ids = ['n_p_{}_{}'.format(x, production_index) for x in input_indexes]
parameter_map_items = {(input_ids[n], k): parameter_ids[n] for n, x in enumerate(input_ids)}
parameter_map.update(parameter_map_items)
self.parameter_map = parameter_map |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:apply; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:config_override; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:tag_override; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:rollback; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:skip_missing; 15, None; 16, block; 16, 17; 16, 24; 16, 30; 16, 41; 16, 252; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:config; 20, call; 20, 21; 20, 22; 21, identifier:get_config; 22, argument_list; 22, 23; 23, identifier:config_override; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:databases; 27, subscript; 27, 28; 27, 29; 28, identifier:config; 29, string:'databases'; 30, if_statement; 30, 31; 30, 35; 31, boolean_operator:and; 31, 32; 31, 33; 32, identifier:rollback; 33, not_operator; 33, 34; 34, identifier:tag_override; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:RuntimeError; 39, argument_list; 39, 40; 40, string:'To rollback a migration you need to specify the database tag with `--tag`'; 41, for_statement; 41, 42; 41, 43; 41, 47; 42, identifier:tag; 43, call; 43, 44; 43, 45; 44, identifier:sorted; 45, argument_list; 45, 46; 46, identifier:databases; 47, block; 47, 48; 47, 56; 47, 68; 47, 80; 47, 92; 47, 100; 47, 108; 47, 116; 47, 127; 47, 139; 47, 151; 47, 174; 47, 192; 47, 202; 47, 242; 48, if_statement; 48, 49; 48, 54; 49, boolean_operator:and; 49, 50; 49, 51; 50, identifier:tag_override; 51, comparison_operator:!=; 51, 52; 51, 53; 52, identifier:tag_override; 53, identifier:tag; 54, block; 54, 55; 55, continue_statement; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:engine; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:databases; 63, identifier:tag; 64, identifier:get; 65, argument_list; 65, 66; 65, 67; 66, string:'engine'; 67, string:'mysql'; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:host; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:databases; 75, identifier:tag; 76, identifier:get; 77, argument_list; 77, 78; 77, 79; 78, string:'host'; 79, string:'localhost'; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:port; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:databases; 87, identifier:tag; 88, identifier:get; 89, argument_list; 89, 90; 89, 91; 90, string:'port'; 91, integer:3306; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:user; 95, subscript; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:databases; 98, identifier:tag; 99, string:'user'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:password; 103, subscript; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:databases; 106, identifier:tag; 107, string:'password'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:db; 111, subscript; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:databases; 114, identifier:tag; 115, string:'db'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:path; 119, call; 119, 120; 119, 121; 120, identifier:add_slash; 121, argument_list; 121, 122; 122, subscript; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:databases; 125, identifier:tag; 126, string:'path'; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:pre_migration; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:databases; 134, identifier:tag; 135, identifier:get; 136, argument_list; 136, 137; 136, 138; 137, string:'pre_migration'; 138, None; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:post_migration; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:databases; 146, identifier:tag; 147, identifier:get; 148, argument_list; 148, 149; 148, 150; 149, string:'post_migration'; 150, None; 151, if_statement; 151, 152; 151, 153; 151, 166; 152, identifier:skip_missing; 153, block; 153, 154; 154, try_statement; 154, 155; 154, 162; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:check_exists; 159, argument_list; 159, 160; 159, 161; 160, identifier:path; 161, string:'dir'; 162, except_clause; 162, 163; 162, 164; 163, identifier:RuntimeError; 164, block; 164, 165; 165, continue_statement; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:check_exists; 171, argument_list; 171, 172; 171, 173; 172, identifier:path; 173, string:'dir'; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:connection; 177, call; 177, 178; 177, 179; 178, identifier:get_connection; 179, argument_list; 179, 180; 179, 181; 179, 182; 179, 183; 179, 184; 179, 185; 179, 186; 180, identifier:engine; 181, identifier:host; 182, identifier:user; 183, identifier:port; 184, identifier:password; 185, identifier:db; 186, call; 186, 187; 186, 188; 187, identifier:get_ssl; 188, argument_list; 188, 189; 189, subscript; 189, 190; 189, 191; 190, identifier:databases; 191, identifier:tag; 192, if_statement; 192, 193; 192, 194; 193, identifier:pre_migration; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:run_migration; 198, argument_list; 198, 199; 198, 200; 198, 201; 199, identifier:connection; 200, identifier:pre_migration; 201, identifier:engine; 202, if_statement; 202, 203; 202, 204; 202, 223; 203, identifier:rollback; 204, block; 204, 205; 204, 215; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:print; 208, argument_list; 208, 209; 209, binary_operator:%; 209, 210; 209, 211; 210, string:' * Rolling back %s (`%s` on %s)'; 211, tuple; 211, 212; 211, 213; 211, 214; 212, identifier:tag; 213, identifier:db; 214, identifier:engine; 215, expression_statement; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:rollback_migration; 218, argument_list; 218, 219; 218, 220; 218, 221; 218, 222; 219, identifier:engine; 220, identifier:connection; 221, identifier:path; 222, identifier:rollback; 223, else_clause; 223, 224; 224, block; 224, 225; 224, 235; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 228; 227, identifier:print; 228, argument_list; 228, 229; 229, binary_operator:%; 229, 230; 229, 231; 230, string:' * Applying migrations for %s (`%s` on %s)'; 231, tuple; 231, 232; 231, 233; 231, 234; 232, identifier:tag; 233, identifier:db; 234, identifier:engine; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 238; 237, identifier:apply_migrations; 238, argument_list; 238, 239; 238, 240; 238, 241; 239, identifier:engine; 240, identifier:connection; 241, identifier:path; 242, if_statement; 242, 243; 242, 244; 243, identifier:post_migration; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:run_migration; 248, argument_list; 248, 249; 248, 250; 248, 251; 249, identifier:connection; 250, identifier:post_migration; 251, identifier:engine; 252, return_statement; 252, 253; 253, True | def apply(config_override=None, tag_override=None, rollback=None, skip_missing=None):
config = get_config(config_override)
databases = config['databases']
if rollback and not tag_override:
raise RuntimeError(
'To rollback a migration you need to specify the database tag with `--tag`')
for tag in sorted(databases):
if tag_override and tag_override != tag:
continue
engine = databases[tag].get('engine', 'mysql')
host = databases[tag].get('host', 'localhost')
port = databases[tag].get('port', 3306)
user = databases[tag]['user']
password = databases[tag]['password']
db = databases[tag]['db']
path = add_slash(databases[tag]['path'])
pre_migration = databases[tag].get('pre_migration', None)
post_migration = databases[tag].get('post_migration', None)
if skip_missing:
try:
check_exists(path, 'dir')
except RuntimeError:
continue
else:
check_exists(path, 'dir')
connection = get_connection(
engine, host, user, port, password, db, get_ssl(databases[tag]))
if pre_migration:
run_migration(connection, pre_migration, engine)
if rollback:
print(' * Rolling back %s (`%s` on %s)' % (tag, db, engine))
rollback_migration(engine, connection, path, rollback)
else:
print(' * Applying migrations for %s (`%s` on %s)' %
(tag, db, engine))
apply_migrations(engine, connection, path)
if post_migration:
run_migration(connection, post_migration, engine)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:_configure_common; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, identifier:self; 5, identifier:prefix; 6, identifier:fallback_level; 7, identifier:fallback_format; 8, identifier:handler_name; 9, identifier:handler; 10, default_parameter; 10, 11; 10, 12; 11, identifier:custom_args; 12, string:''; 13, block; 13, 14; 13, 30; 13, 46; 13, 57; 13, 68; 13, 77; 13, 84; 13, 91; 13, 100; 13, 125; 13, 141; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:log_level; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:config; 22, identifier:get_option; 23, argument_list; 23, 24; 23, 25; 23, 28; 23, 29; 24, string:'LOGGING'; 25, binary_operator:+; 25, 26; 25, 27; 26, identifier:prefix; 27, string:'log_level'; 28, None; 29, identifier:fallback_level; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:log_format_name; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:config; 38, identifier:get_option; 39, argument_list; 39, 40; 39, 41; 39, 44; 39, 45; 40, string:'LOGGING'; 41, binary_operator:+; 41, 42; 41, 43; 42, identifier:prefix; 43, string:'log_format'; 44, None; 45, None; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:log_format; 49, conditional_expression:if; 49, 50; 49, 55; 49, 56; 50, attribute; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:ReportingFormats; 53, identifier:log_format_name; 54, identifier:value; 55, identifier:log_format_name; 56, identifier:fallback_format; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:log_format; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:log_format; 63, identifier:format; 64, argument_list; 64, 65; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:custom_args; 67, identifier:custom_args; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:formatter; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:logging; 74, identifier:Formatter; 75, argument_list; 75, 76; 76, identifier:log_format; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:handler; 81, identifier:setFormatter; 82, argument_list; 82, 83; 83, identifier:formatter; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:handler; 88, identifier:setLevel; 89, argument_list; 89, 90; 90, identifier:log_level; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:logger; 97, identifier:addHandler; 98, argument_list; 98, 99; 99, identifier:handler; 100, if_statement; 100, 101; 100, 115; 101, not_operator; 101, 102; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:logger; 107, identifier:isEnabledFor; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:logging; 112, identifier:getLevelName; 113, argument_list; 113, 114; 114, identifier:log_level; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:logger; 122, identifier:setLevel; 123, argument_list; 123, 124; 124, identifier:log_level; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:log_info; 131, identifier:append; 132, argument_list; 132, 133; 133, binary_operator:+; 133, 134; 133, 137; 134, binary_operator:+; 134, 135; 134, 136; 135, identifier:handler_name; 136, string:' @ '; 137, call; 137, 138; 137, 139; 138, identifier:str; 139, argument_list; 139, 140; 140, identifier:log_level; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:log_handlers; 147, identifier:append; 148, argument_list; 148, 149; 149, identifier:handler | def _configure_common(
self,
prefix,
fallback_level,
fallback_format,
handler_name,
handler,
custom_args=''
):
log_level = self.config.get_option(
'LOGGING', prefix + 'log_level',
None, fallback_level
)
log_format_name = self.config.get_option(
'LOGGING', prefix + 'log_format',
None, None
)
log_format = ReportingFormats[log_format_name].value if log_format_name else fallback_format
log_format = log_format.format(custom_args=custom_args)
formatter = logging.Formatter(log_format)
handler.setFormatter(formatter)
handler.setLevel(log_level)
self.logger.addHandler(handler)
if not self.logger.isEnabledFor(logging.getLevelName(log_level)):
self.logger.setLevel(log_level)
self.log_info.append(handler_name + ' @ ' + str(log_level))
self.log_handlers.append(handler) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:get_file; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:self; 5, identifier:name; 6, identifier:save_to; 7, default_parameter; 7, 8; 7, 9; 8, identifier:add_to_cache; 9, True; 10, default_parameter; 10, 11; 10, 12; 11, identifier:force_refresh; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:_lock_exclusive; 15, False; 16, block; 16, 17; 16, 26; 16, 30; 16, 69; 16, 77; 16, 85; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, pattern_list; 19, 20; 19, 21; 20, identifier:uname; 21, identifier:version; 22, call; 22, 23; 22, 24; 23, identifier:split_name; 24, argument_list; 24, 25; 25, identifier:name; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:lock; 29, None; 30, if_statement; 30, 31; 30, 34; 30, 63; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:local_store; 34, block; 34, 35; 34, 46; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:lock; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:lock_manager; 43, identifier:lock_for; 44, argument_list; 44, 45; 45, identifier:uname; 46, if_statement; 46, 47; 46, 48; 46, 55; 47, identifier:_lock_exclusive; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:lock; 53, identifier:lock_exclusive; 54, argument_list; 55, else_clause; 55, 56; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:lock; 61, identifier:lock_shared; 62, argument_list; 63, else_clause; 63, 64; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:add_to_cache; 68, False; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:t; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:time; 75, identifier:time; 76, argument_list; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:logger; 81, identifier:debug; 82, argument_list; 82, 83; 82, 84; 83, string:' downloading %s'; 84, identifier:name; 85, try_statement; 85, 86; 85, 213; 86, block; 86, 87; 86, 149; 86, 206; 87, if_statement; 87, 88; 87, 100; 88, boolean_operator:or; 88, 89; 88, 93; 89, not_operator; 89, 90; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:remote_store; 93, parenthesized_expression; 93, 94; 94, boolean_operator:and; 94, 95; 94, 98; 95, comparison_operator:is; 95, 96; 95, 97; 96, identifier:version; 97, None; 98, not_operator; 98, 99; 99, identifier:force_refresh; 100, block; 100, 101; 101, try_statement; 101, 102; 101, 127; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 116; 104, boolean_operator:and; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:local_store; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:local_store; 113, identifier:exists; 114, argument_list; 114, 115; 115, identifier:name; 116, block; 116, 117; 117, return_statement; 117, 118; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:local_store; 123, identifier:get_file; 124, argument_list; 124, 125; 124, 126; 125, identifier:name; 126, identifier:save_to; 127, except_clause; 127, 128; 127, 129; 128, identifier:Exception; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 134; 130, 146; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:remote_store; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:logger; 139, identifier:warning; 140, argument_list; 140, 141; 140, 142; 140, 143; 141, string:"Error getting '%s' from local store"; 142, identifier:name; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:exc_info; 145, True; 146, else_clause; 146, 147; 147, block; 147, 148; 148, raise_statement; 149, if_statement; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:remote_store; 153, block; 153, 154; 153, 181; 153, 193; 153, 204; 154, if_statement; 154, 155; 154, 159; 155, boolean_operator:and; 155, 156; 155, 158; 156, not_operator; 156, 157; 157, identifier:_lock_exclusive; 158, identifier:add_to_cache; 159, block; 159, 160; 159, 169; 160, if_statement; 160, 161; 160, 162; 161, identifier:lock; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:lock; 167, identifier:unlock; 168, argument_list; 169, return_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:get_file; 174, argument_list; 174, 175; 174, 176; 174, 177; 174, 178; 175, identifier:name; 176, identifier:save_to; 177, identifier:add_to_cache; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:_lock_exclusive; 180, True; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:vname; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:remote_store; 189, identifier:get_file; 190, argument_list; 190, 191; 190, 192; 191, identifier:name; 192, identifier:save_to; 193, if_statement; 193, 194; 193, 195; 194, identifier:add_to_cache; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:_add_to_cache; 201, argument_list; 201, 202; 201, 203; 202, identifier:vname; 203, identifier:save_to; 204, return_statement; 204, 205; 205, identifier:vname; 206, raise_statement; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:FiletrackerError; 209, argument_list; 209, 210; 210, binary_operator:%; 210, 211; 210, 212; 211, string:"File not available: %s"; 212, identifier:name; 213, finally_clause; 213, 214; 214, block; 214, 215; 214, 224; 215, if_statement; 215, 216; 215, 217; 216, identifier:lock; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:lock; 222, identifier:close; 223, argument_list; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:logger; 228, identifier:debug; 229, argument_list; 229, 230; 229, 231; 229, 232; 230, string:' processed %s in %.2fs'; 231, identifier:name; 232, binary_operator:-; 232, 233; 232, 238; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:time; 236, identifier:time; 237, argument_list; 238, identifier:t | def get_file(self, name, save_to, add_to_cache=True,
force_refresh=False, _lock_exclusive=False):
uname, version = split_name(name)
lock = None
if self.local_store:
lock = self.lock_manager.lock_for(uname)
if _lock_exclusive:
lock.lock_exclusive()
else:
lock.lock_shared()
else:
add_to_cache = False
t = time.time()
logger.debug(' downloading %s', name)
try:
if not self.remote_store or (version is not None
and not force_refresh):
try:
if self.local_store and self.local_store.exists(name):
return self.local_store.get_file(name, save_to)
except Exception:
if self.remote_store:
logger.warning("Error getting '%s' from local store",
name, exc_info=True)
else:
raise
if self.remote_store:
if not _lock_exclusive and add_to_cache:
if lock:
lock.unlock()
return self.get_file(name, save_to, add_to_cache,
_lock_exclusive=True)
vname = self.remote_store.get_file(name, save_to)
if add_to_cache:
self._add_to_cache(vname, save_to)
return vname
raise FiletrackerError("File not available: %s" % name)
finally:
if lock:
lock.close()
logger.debug(' processed %s in %.2fs', name, time.time() - t) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_stream; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:force_refresh; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:serve_from_cache; 11, False; 12, block; 12, 13; 12, 22; 12, 26; 12, 48; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 18; 15, pattern_list; 15, 16; 15, 17; 16, identifier:uname; 17, identifier:version; 18, call; 18, 19; 18, 20; 19, identifier:split_name; 20, argument_list; 20, 21; 21, identifier:name; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:lock; 25, None; 26, if_statement; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:local_store; 30, block; 30, 31; 30, 42; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:lock; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:lock_manager; 39, identifier:lock_for; 40, argument_list; 40, 41; 41, identifier:uname; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:lock; 46, identifier:lock_shared; 47, argument_list; 48, try_statement; 48, 49; 48, 213; 49, block; 49, 50; 49, 111; 49, 206; 50, if_statement; 50, 51; 50, 63; 51, boolean_operator:or; 51, 52; 51, 56; 52, not_operator; 52, 53; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:remote_store; 56, parenthesized_expression; 56, 57; 57, boolean_operator:and; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:version; 60, None; 61, not_operator; 61, 62; 62, identifier:force_refresh; 63, block; 63, 64; 64, try_statement; 64, 65; 64, 89; 65, block; 65, 66; 66, if_statement; 66, 67; 66, 79; 67, boolean_operator:and; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:local_store; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:local_store; 76, identifier:exists; 77, argument_list; 77, 78; 78, identifier:name; 79, block; 79, 80; 80, return_statement; 80, 81; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:local_store; 86, identifier:get_stream; 87, argument_list; 87, 88; 88, identifier:name; 89, except_clause; 89, 90; 89, 91; 90, identifier:Exception; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 96; 92, 108; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:remote_store; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:logger; 101, identifier:warning; 102, argument_list; 102, 103; 102, 104; 102, 105; 103, string:"Error getting '%s' from local store"; 104, identifier:name; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:exc_info; 107, True; 108, else_clause; 108, 109; 109, block; 109, 110; 110, raise_statement; 111, if_statement; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:remote_store; 115, block; 115, 116; 115, 197; 116, if_statement; 116, 117; 116, 122; 117, boolean_operator:and; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:local_store; 121, identifier:serve_from_cache; 122, block; 122, 123; 122, 150; 122, 188; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:version; 126, None; 127, block; 127, 128; 127, 139; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:version; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:remote_store; 136, identifier:file_version; 137, argument_list; 137, 138; 138, identifier:name; 139, if_statement; 139, 140; 139, 141; 140, identifier:version; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:name; 145, call; 145, 146; 145, 147; 146, identifier:versioned_name; 147, argument_list; 147, 148; 147, 149; 148, identifier:uname; 149, identifier:version; 150, if_statement; 150, 151; 150, 162; 151, boolean_operator:or; 151, 152; 151, 153; 152, identifier:force_refresh; 153, not_operator; 153, 154; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:local_store; 159, identifier:exists; 160, argument_list; 160, 161; 161, identifier:name; 162, block; 162, 163; 162, 176; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 168; 165, tuple_pattern; 165, 166; 165, 167; 166, identifier:stream; 167, identifier:vname; 168, call; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:remote_store; 173, identifier:get_stream; 174, argument_list; 174, 175; 175, identifier:name; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:name; 179, call; 179, 180; 179, 185; 180, attribute; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:local_store; 184, identifier:add_stream; 185, argument_list; 185, 186; 185, 187; 186, identifier:vname; 187, identifier:stream; 188, return_statement; 188, 189; 189, call; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:local_store; 194, identifier:get_stream; 195, argument_list; 195, 196; 196, identifier:name; 197, return_statement; 197, 198; 198, call; 198, 199; 198, 204; 199, attribute; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:remote_store; 203, identifier:get_stream; 204, argument_list; 204, 205; 205, identifier:name; 206, raise_statement; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:FiletrackerError; 209, argument_list; 209, 210; 210, binary_operator:%; 210, 211; 210, 212; 211, string:"File not available: %s"; 212, identifier:name; 213, finally_clause; 213, 214; 214, block; 214, 215; 215, if_statement; 215, 216; 215, 217; 216, identifier:lock; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:lock; 222, identifier:close; 223, argument_list | def get_stream(self, name, force_refresh=False, serve_from_cache=False):
uname, version = split_name(name)
lock = None
if self.local_store:
lock = self.lock_manager.lock_for(uname)
lock.lock_shared()
try:
if not self.remote_store or (version is not None
and not force_refresh):
try:
if self.local_store and self.local_store.exists(name):
return self.local_store.get_stream(name)
except Exception:
if self.remote_store:
logger.warning("Error getting '%s' from local store",
name, exc_info=True)
else:
raise
if self.remote_store:
if self.local_store and serve_from_cache:
if version is None:
version = self.remote_store.file_version(name)
if version:
name = versioned_name(uname, version)
if force_refresh or not self.local_store.exists(name):
(stream, vname) = self.remote_store.get_stream(name)
name = self.local_store.add_stream(vname, stream)
return self.local_store.get_stream(name)
return self.remote_store.get_stream(name)
raise FiletrackerError("File not available: %s" % name)
finally:
if lock:
lock.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:put_file; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:self; 5, identifier:name; 6, identifier:filename; 7, default_parameter; 7, 8; 7, 9; 8, identifier:to_local_store; 9, True; 10, default_parameter; 10, 11; 10, 12; 11, identifier:to_remote_store; 12, True; 13, default_parameter; 13, 14; 13, 15; 14, identifier:compress_hint; 15, True; 16, block; 16, 17; 16, 31; 16, 36; 16, 40; 16, 62; 16, 128; 17, if_statement; 17, 18; 17, 23; 18, boolean_operator:and; 18, 19; 18, 21; 19, not_operator; 19, 20; 20, identifier:to_local_store; 21, not_operator; 21, 22; 22, identifier:to_remote_store; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:ValueError; 27, argument_list; 27, 28; 28, concatenated_string; 28, 29; 28, 30; 29, string:"Neither to_local_store nor to_remote_store set "; 30, string:"in a call to filetracker.Client.put_file"; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:check_name; 34, argument_list; 34, 35; 35, identifier:name; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:lock; 39, None; 40, if_statement; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:local_store; 44, block; 44, 45; 44, 56; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:lock; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:lock_manager; 53, identifier:lock_for; 54, argument_list; 54, 55; 55, identifier:name; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:lock; 60, identifier:lock_exclusive; 61, argument_list; 62, try_statement; 62, 63; 62, 117; 63, block; 63, 64; 63, 89; 64, if_statement; 64, 65; 64, 76; 65, boolean_operator:and; 65, 66; 65, 73; 66, parenthesized_expression; 66, 67; 67, boolean_operator:or; 67, 68; 67, 69; 68, identifier:to_local_store; 69, not_operator; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:remote_store; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:local_store; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:versioned_name; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:local_store; 85, identifier:add_file; 86, argument_list; 86, 87; 86, 88; 87, identifier:name; 88, identifier:filename; 89, if_statement; 89, 90; 89, 101; 90, boolean_operator:and; 90, 91; 90, 98; 91, parenthesized_expression; 91, 92; 92, boolean_operator:or; 92, 93; 92, 94; 93, identifier:to_remote_store; 94, not_operator; 94, 95; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:local_store; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:remote_store; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:versioned_name; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:remote_store; 110, identifier:add_file; 111, argument_list; 111, 112; 111, 113; 111, 114; 112, identifier:name; 113, identifier:filename; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:compress_hint; 116, identifier:compress_hint; 117, finally_clause; 117, 118; 118, block; 118, 119; 119, if_statement; 119, 120; 119, 121; 120, identifier:lock; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:lock; 126, identifier:close; 127, argument_list; 128, return_statement; 128, 129; 129, identifier:versioned_name | def put_file(self,
name,
filename,
to_local_store=True,
to_remote_store=True,
compress_hint=True):
if not to_local_store and not to_remote_store:
raise ValueError("Neither to_local_store nor to_remote_store set "
"in a call to filetracker.Client.put_file")
check_name(name)
lock = None
if self.local_store:
lock = self.lock_manager.lock_for(name)
lock.lock_exclusive()
try:
if (to_local_store or not self.remote_store) and self.local_store:
versioned_name = self.local_store.add_file(name, filename)
if (to_remote_store or not self.local_store) and self.remote_store:
versioned_name = self.remote_store.add_file(
name, filename, compress_hint=compress_hint)
finally:
if lock:
lock.close()
return versioned_name |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:check; 3, parameters; 3, 4; 3, 5; 4, identifier:operations; 5, default_parameter; 5, 6; 5, 7; 6, identifier:loud; 7, False; 8, block; 8, 9; 8, 17; 8, 21; 8, 25; 8, 54; 8, 165; 9, if_statement; 9, 10; 9, 12; 10, not_operator; 10, 11; 11, identifier:CHECKERS; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:load_checkers; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:roll_call; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:everything_ok; 24, True; 25, if_statement; 25, 26; 25, 29; 26, boolean_operator:and; 26, 27; 26, 28; 27, identifier:loud; 28, identifier:operations; 29, block; 29, 30; 29, 34; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:title; 33, string:"Preflyt Checklist"; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:sys; 39, identifier:stderr; 40, identifier:write; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, string:"{}\n{}\n"; 45, identifier:format; 46, argument_list; 46, 47; 46, 48; 47, identifier:title; 48, binary_operator:*; 48, 49; 48, 50; 49, string:"="; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:title; 54, for_statement; 54, 55; 54, 56; 54, 57; 55, identifier:operation; 56, identifier:operations; 57, block; 57, 58; 57, 73; 57, 81; 57, 101; 57, 109; 57, 119; 57, 127; 57, 143; 58, if_statement; 58, 59; 58, 67; 59, comparison_operator:not; 59, 60; 59, 66; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:operation; 63, identifier:get; 64, argument_list; 64, 65; 65, string:'checker'; 66, identifier:CHECKERS; 67, block; 67, 68; 68, raise_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:CheckerNotFoundError; 71, argument_list; 71, 72; 72, identifier:operation; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:checker_cls; 76, subscript; 76, 77; 76, 78; 77, identifier:CHECKERS; 78, subscript; 78, 79; 78, 80; 79, identifier:operation; 80, string:'checker'; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:args; 84, dictionary_comprehension; 84, 85; 84, 88; 84, 97; 85, pair; 85, 86; 85, 87; 86, identifier:k; 87, identifier:v; 88, for_in_clause; 88, 89; 88, 92; 89, pattern_list; 89, 90; 89, 91; 90, identifier:k; 91, identifier:v; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:operation; 95, identifier:items; 96, argument_list; 97, if_clause; 97, 98; 98, comparison_operator:!=; 98, 99; 98, 100; 99, identifier:k; 100, string:'checker'; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:checker; 104, call; 104, 105; 104, 106; 105, identifier:checker_cls; 106, argument_list; 106, 107; 107, dictionary_splat; 107, 108; 108, identifier:args; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, pattern_list; 111, 112; 111, 113; 112, identifier:success; 113, identifier:message; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:checker; 117, identifier:check; 118, argument_list; 119, if_statement; 119, 120; 119, 122; 120, not_operator; 120, 121; 121, identifier:success; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:everything_ok; 126, False; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:roll_call; 131, identifier:append; 132, argument_list; 132, 133; 133, dictionary; 133, 134; 133, 137; 133, 140; 134, pair; 134, 135; 134, 136; 135, string:"check"; 136, identifier:operation; 137, pair; 137, 138; 137, 139; 138, string:"success"; 139, identifier:success; 140, pair; 140, 141; 140, 142; 141, string:"message"; 142, identifier:message; 143, if_statement; 143, 144; 143, 145; 144, identifier:loud; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:sys; 151, identifier:stderr; 152, identifier:write; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, string:" {}\n"; 157, identifier:format; 158, argument_list; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:pformat_check; 161, argument_list; 161, 162; 161, 163; 161, 164; 162, identifier:success; 163, identifier:operation; 164, identifier:message; 165, return_statement; 165, 166; 166, expression_list; 166, 167; 166, 168; 167, identifier:everything_ok; 168, identifier:roll_call | def check(operations, loud=False):
if not CHECKERS:
load_checkers()
roll_call = []
everything_ok = True
if loud and operations:
title = "Preflyt Checklist"
sys.stderr.write("{}\n{}\n".format(title, "=" * len(title)))
for operation in operations:
if operation.get('checker') not in CHECKERS:
raise CheckerNotFoundError(operation)
checker_cls = CHECKERS[operation['checker']]
args = {k: v for k, v in operation.items() if k != 'checker'}
checker = checker_cls(**args)
success, message = checker.check()
if not success:
everything_ok = False
roll_call.append({"check": operation, "success": success, "message": message})
if loud:
sys.stderr.write(" {}\n".format(pformat_check(success, operation, message)))
return everything_ok, roll_call |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:deci2sexa; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:deci; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pre; 7, integer:3; 8, default_parameter; 8, 9; 8, 10; 9, identifier:trunc; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:lower; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:upper; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:b; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:upper_trim; 22, False; 23, block; 23, 24; 23, 49; 23, 53; 23, 70; 23, 80; 23, 92; 23, 98; 23, 104; 23, 131; 23, 138; 23, 153; 23, 166; 23, 173; 23, 180; 23, 203; 23, 220; 23, 227; 24, if_statement; 24, 25; 24, 32; 25, boolean_operator:and; 25, 26; 25, 29; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:lower; 28, None; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:upper; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:deci; 36, call; 36, 37; 36, 38; 37, identifier:normalize; 38, argument_list; 38, 39; 38, 40; 38, 43; 38, 46; 39, identifier:deci; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:lower; 42, identifier:lower; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:upper; 45, identifier:upper; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:b; 48, identifier:b; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:sign; 52, integer:1; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:<; 54, 55; 54, 56; 55, identifier:deci; 56, integer:0; 57, block; 57, 58; 57, 65; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:deci; 61, call; 61, 62; 61, 63; 62, identifier:abs; 63, argument_list; 63, 64; 64, identifier:deci; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:sign; 68, unary_operator:-; 68, 69; 69, integer:1; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, pattern_list; 72, 73; 72, 74; 73, identifier:hd; 74, identifier:f1; 75, call; 75, 76; 75, 77; 76, identifier:divmod; 77, argument_list; 77, 78; 77, 79; 78, identifier:deci; 79, integer:1; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, pattern_list; 82, 83; 82, 84; 83, identifier:mm; 84, identifier:f2; 85, call; 85, 86; 85, 87; 86, identifier:divmod; 87, argument_list; 87, 88; 87, 91; 88, binary_operator:*; 88, 89; 88, 90; 89, identifier:f1; 90, float:60.0; 91, integer:1; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:sf; 95, binary_operator:*; 95, 96; 95, 97; 96, identifier:f2; 97, float:60.0; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:fp; 101, binary_operator:**; 101, 102; 101, 103; 102, integer:10; 103, identifier:pre; 104, if_statement; 104, 105; 104, 106; 104, 119; 105, identifier:trunc; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 112; 109, pattern_list; 109, 110; 109, 111; 110, identifier:ss; 111, identifier:_; 112, call; 112, 113; 112, 114; 113, identifier:divmod; 114, argument_list; 114, 115; 114, 118; 115, binary_operator:*; 115, 116; 115, 117; 116, identifier:sf; 117, identifier:fp; 118, integer:1; 119, else_clause; 119, 120; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:ss; 124, call; 124, 125; 124, 126; 125, identifier:round; 126, argument_list; 126, 127; 126, 130; 127, binary_operator:*; 127, 128; 127, 129; 128, identifier:sf; 129, identifier:fp; 130, integer:0; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:ss; 134, call; 134, 135; 134, 136; 135, identifier:int; 136, argument_list; 136, 137; 137, identifier:ss; 138, if_statement; 138, 139; 138, 144; 139, comparison_operator:==; 139, 140; 139, 141; 140, identifier:ss; 141, binary_operator:*; 141, 142; 141, 143; 142, integer:60; 143, identifier:fp; 144, block; 144, 145; 144, 149; 145, expression_statement; 145, 146; 146, augmented_assignment:+=; 146, 147; 146, 148; 147, identifier:mm; 148, integer:1; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:ss; 152, integer:0; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:==; 154, 155; 154, 156; 155, identifier:mm; 156, integer:60; 157, block; 157, 158; 157, 162; 158, expression_statement; 158, 159; 159, augmented_assignment:+=; 159, 160; 159, 161; 160, identifier:hd; 161, integer:1; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:mm; 165, integer:0; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:hd; 169, call; 169, 170; 169, 171; 170, identifier:int; 171, argument_list; 171, 172; 172, identifier:hd; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:mm; 176, call; 176, 177; 176, 178; 177, identifier:int; 178, argument_list; 178, 179; 179, identifier:mm; 180, if_statement; 180, 181; 180, 190; 181, boolean_operator:and; 181, 182; 181, 189; 182, boolean_operator:and; 182, 183; 182, 186; 183, comparison_operator:is; 183, 184; 183, 185; 184, identifier:lower; 185, None; 186, comparison_operator:is; 186, 187; 186, 188; 187, identifier:upper; 188, None; 189, identifier:upper_trim; 190, block; 190, 191; 191, if_statement; 191, 192; 191, 195; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:hd; 194, identifier:upper; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:hd; 199, call; 199, 200; 199, 201; 200, identifier:int; 201, argument_list; 201, 202; 202, identifier:lower; 203, if_statement; 203, 204; 203, 215; 204, boolean_operator:and; 204, 205; 204, 212; 205, boolean_operator:and; 205, 206; 205, 209; 206, comparison_operator:==; 206, 207; 206, 208; 207, identifier:hd; 208, integer:0; 209, comparison_operator:==; 209, 210; 209, 211; 210, identifier:mm; 211, integer:0; 212, comparison_operator:==; 212, 213; 212, 214; 213, identifier:ss; 214, integer:0; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:sign; 219, integer:1; 220, expression_statement; 220, 221; 221, augmented_assignment:/=; 221, 222; 221, 223; 222, identifier:ss; 223, call; 223, 224; 223, 225; 224, identifier:float; 225, argument_list; 225, 226; 226, identifier:fp; 227, return_statement; 227, 228; 228, tuple; 228, 229; 228, 230; 228, 231; 228, 232; 229, identifier:sign; 230, identifier:hd; 231, identifier:mm; 232, identifier:ss | def deci2sexa(deci, pre=3, trunc=False, lower=None, upper=None,
b=False, upper_trim=False):
if lower is not None and upper is not None:
deci = normalize(deci, lower=lower, upper=upper, b=b)
sign = 1
if deci < 0:
deci = abs(deci)
sign = -1
hd, f1 = divmod(deci, 1)
mm, f2 = divmod(f1 * 60.0, 1)
sf = f2 * 60.0
fp = 10 ** pre
if trunc:
ss, _ = divmod(sf * fp, 1)
else:
ss = round(sf * fp, 0)
ss = int(ss)
if ss == 60 * fp:
mm += 1
ss = 0
if mm == 60:
hd += 1
mm = 0
hd = int(hd)
mm = int(mm)
if lower is not None and upper is not None and upper_trim:
if hd == upper:
hd = int(lower)
if hd == 0 and mm == 0 and ss == 0:
sign = 1
ss /= float(fp)
return (sign, hd, mm, ss) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:phmsdms; 3, parameters; 3, 4; 4, identifier:hmsdms; 5, block; 5, 6; 5, 10; 5, 14; 5, 23; 5, 32; 5, 40; 5, 49; 5, 56; 5, 129; 5, 423; 5, 451; 5, 460; 5, 476; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:units; 9, None; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sign; 13, None; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:pattern1; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:re; 20, identifier:compile; 21, argument_list; 21, 22; 22, string:r"([-+]?[0-9]*\.?[0-9]+[^0-9\-+]*)"; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:pattern2; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:re; 29, identifier:compile; 30, argument_list; 30, 31; 31, string:r"([-+]?[0-9]*\.?[0-9]+)"; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:hmsdms; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:hmsdms; 38, identifier:lower; 39, argument_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:hdlist; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:pattern1; 46, identifier:findall; 47, argument_list; 47, 48; 48, identifier:hmsdms; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:parts; 52, list:[None, None, None]; 52, 53; 52, 54; 52, 55; 53, None; 54, None; 55, None; 56, function_definition; 56, 57; 56, 58; 56, 59; 57, function_name:_fill_right_not_none; 58, parameters; 59, block; 59, 60; 59, 67; 59, 82; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:rp; 63, call; 63, 64; 63, 65; 64, identifier:reversed; 65, argument_list; 65, 66; 66, identifier:parts; 67, for_statement; 67, 68; 67, 71; 67, 75; 68, pattern_list; 68, 69; 68, 70; 69, identifier:i; 70, identifier:j; 71, call; 71, 72; 71, 73; 72, identifier:enumerate; 73, argument_list; 73, 74; 74, identifier:rp; 75, block; 75, 76; 76, if_statement; 76, 77; 76, 80; 77, comparison_operator:is; 77, 78; 77, 79; 78, identifier:j; 79, None; 80, block; 80, 81; 81, break_statement; 82, if_statement; 82, 83; 82, 86; 82, 92; 82, 103; 83, comparison_operator:==; 83, 84; 83, 85; 84, identifier:i; 85, integer:0; 86, block; 86, 87; 87, raise_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:ValueError; 90, argument_list; 90, 91; 91, string:"Invalid string."; 92, elif_clause; 92, 93; 92, 96; 93, comparison_operator:==; 93, 94; 93, 95; 94, identifier:i; 95, integer:1; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:parts; 101, integer:2; 102, identifier:v; 103, elif_clause; 103, 104; 103, 107; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:i; 106, integer:2; 107, block; 107, 108; 108, if_statement; 108, 109; 108, 114; 108, 121; 109, comparison_operator:is; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:parts; 112, integer:0; 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:parts; 119, integer:0; 120, identifier:v; 121, else_clause; 121, 122; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:parts; 127, integer:1; 128, identifier:v; 129, for_statement; 129, 130; 129, 131; 129, 132; 130, identifier:valun; 131, identifier:hdlist; 132, block; 132, 133; 132, 415; 133, try_statement; 133, 134; 133, 146; 134, block; 134, 135; 134, 142; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:v; 138, call; 138, 139; 138, 140; 139, identifier:float; 140, argument_list; 140, 141; 141, identifier:valun; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:_fill_right_not_none; 145, argument_list; 146, except_clause; 146, 147; 146, 148; 147, identifier:ValueError; 148, block; 148, 149; 148, 193; 148, 237; 148, 277; 148, 317; 148, 353; 148, 389; 149, if_statement; 149, 150; 149, 157; 150, boolean_operator:or; 150, 151; 150, 154; 151, comparison_operator:in; 151, 152; 151, 153; 152, string:"hh"; 153, identifier:valun; 154, comparison_operator:in; 154, 155; 154, 156; 155, string:"h"; 156, identifier:valun; 157, block; 157, 158; 157, 167; 157, 189; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:m; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:pattern2; 164, identifier:search; 165, argument_list; 165, 166; 166, identifier:valun; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:parts; 171, integer:0; 172, call; 172, 173; 172, 174; 173, identifier:float; 174, argument_list; 174, 175; 175, subscript; 175, 176; 175, 177; 176, identifier:valun; 177, slice; 177, 178; 177, 183; 177, 184; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:m; 181, identifier:start; 182, argument_list; 183, colon; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:m; 187, identifier:end; 188, argument_list; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:units; 192, string:"hours"; 193, if_statement; 193, 194; 193, 201; 194, boolean_operator:or; 194, 195; 194, 198; 195, comparison_operator:in; 195, 196; 195, 197; 196, string:"dd"; 197, identifier:valun; 198, comparison_operator:in; 198, 199; 198, 200; 199, string:"d"; 200, identifier:valun; 201, block; 201, 202; 201, 211; 201, 233; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:m; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:pattern2; 208, identifier:search; 209, argument_list; 209, 210; 210, identifier:valun; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 216; 213, subscript; 213, 214; 213, 215; 214, identifier:parts; 215, integer:0; 216, call; 216, 217; 216, 218; 217, identifier:float; 218, argument_list; 218, 219; 219, subscript; 219, 220; 219, 221; 220, identifier:valun; 221, slice; 221, 222; 221, 227; 221, 228; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:m; 225, identifier:start; 226, argument_list; 227, colon; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:m; 231, identifier:end; 232, argument_list; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:units; 236, string:"degrees"; 237, if_statement; 237, 238; 237, 245; 238, boolean_operator:or; 238, 239; 238, 242; 239, comparison_operator:in; 239, 240; 239, 241; 240, string:"mm"; 241, identifier:valun; 242, comparison_operator:in; 242, 243; 242, 244; 243, string:"m"; 244, identifier:valun; 245, block; 245, 246; 245, 255; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:m; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:pattern2; 252, identifier:search; 253, argument_list; 253, 254; 254, identifier:valun; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:parts; 259, integer:1; 260, call; 260, 261; 260, 262; 261, identifier:float; 262, argument_list; 262, 263; 263, subscript; 263, 264; 263, 265; 264, identifier:valun; 265, slice; 265, 266; 265, 271; 265, 272; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:m; 269, identifier:start; 270, argument_list; 271, colon; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:m; 275, identifier:end; 276, argument_list; 277, if_statement; 277, 278; 277, 285; 278, boolean_operator:or; 278, 279; 278, 282; 279, comparison_operator:in; 279, 280; 279, 281; 280, string:"ss"; 281, identifier:valun; 282, comparison_operator:in; 282, 283; 282, 284; 283, string:"s"; 284, identifier:valun; 285, block; 285, 286; 285, 295; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:m; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:pattern2; 292, identifier:search; 293, argument_list; 293, 294; 294, identifier:valun; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 300; 297, subscript; 297, 298; 297, 299; 298, identifier:parts; 299, integer:2; 300, call; 300, 301; 300, 302; 301, identifier:float; 302, argument_list; 302, 303; 303, subscript; 303, 304; 303, 305; 304, identifier:valun; 305, slice; 305, 306; 305, 311; 305, 312; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:m; 309, identifier:start; 310, argument_list; 311, colon; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:m; 315, identifier:end; 316, argument_list; 317, if_statement; 317, 318; 317, 321; 318, comparison_operator:in; 318, 319; 318, 320; 319, string:"'"; 320, identifier:valun; 321, block; 321, 322; 321, 331; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 325; 324, identifier:m; 325, call; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:pattern2; 328, identifier:search; 329, argument_list; 329, 330; 330, identifier:valun; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 336; 333, subscript; 333, 334; 333, 335; 334, identifier:parts; 335, integer:1; 336, call; 336, 337; 336, 338; 337, identifier:float; 338, argument_list; 338, 339; 339, subscript; 339, 340; 339, 341; 340, identifier:valun; 341, slice; 341, 342; 341, 347; 341, 348; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:m; 345, identifier:start; 346, argument_list; 347, colon; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:m; 351, identifier:end; 352, argument_list; 353, if_statement; 353, 354; 353, 357; 354, comparison_operator:in; 354, 355; 354, 356; 355, string:'"'; 356, identifier:valun; 357, block; 357, 358; 357, 367; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:m; 361, call; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:pattern2; 364, identifier:search; 365, argument_list; 365, 366; 366, identifier:valun; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 372; 369, subscript; 369, 370; 369, 371; 370, identifier:parts; 371, integer:2; 372, call; 372, 373; 372, 374; 373, identifier:float; 374, argument_list; 374, 375; 375, subscript; 375, 376; 375, 377; 376, identifier:valun; 377, slice; 377, 378; 377, 383; 377, 384; 378, call; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:m; 381, identifier:start; 382, argument_list; 383, colon; 384, call; 384, 385; 384, 388; 385, attribute; 385, 386; 385, 387; 386, identifier:m; 387, identifier:end; 388, argument_list; 389, if_statement; 389, 390; 389, 393; 390, comparison_operator:in; 390, 391; 390, 392; 391, string:":"; 392, identifier:valun; 393, block; 393, 394; 393, 404; 393, 411; 394, expression_statement; 394, 395; 395, assignment; 395, 396; 395, 397; 396, identifier:v; 397, call; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:valun; 400, identifier:replace; 401, argument_list; 401, 402; 401, 403; 402, string:":"; 403, string:""; 404, expression_statement; 404, 405; 405, assignment; 405, 406; 405, 407; 406, identifier:v; 407, call; 407, 408; 407, 409; 408, identifier:float; 409, argument_list; 409, 410; 410, identifier:v; 411, expression_statement; 411, 412; 412, call; 412, 413; 412, 414; 413, identifier:_fill_right_not_none; 414, argument_list; 415, if_statement; 415, 416; 415, 418; 416, not_operator; 416, 417; 417, identifier:units; 418, block; 418, 419; 419, expression_statement; 419, 420; 420, assignment; 420, 421; 420, 422; 421, identifier:units; 422, string:"degrees"; 423, for_statement; 423, 424; 423, 425; 423, 426; 424, identifier:i; 425, identifier:parts; 426, block; 426, 427; 427, if_statement; 427, 428; 427, 433; 428, boolean_operator:and; 428, 429; 428, 430; 429, identifier:i; 430, comparison_operator:<; 430, 431; 430, 432; 431, identifier:i; 432, float:0.0; 433, block; 433, 434; 434, if_statement; 434, 435; 434, 438; 434, 444; 435, comparison_operator:is; 435, 436; 435, 437; 436, identifier:sign; 437, None; 438, block; 438, 439; 439, expression_statement; 439, 440; 440, assignment; 440, 441; 440, 442; 441, identifier:sign; 442, unary_operator:-; 442, 443; 443, integer:1; 444, else_clause; 444, 445; 445, block; 445, 446; 446, raise_statement; 446, 447; 447, call; 447, 448; 447, 449; 448, identifier:ValueError; 449, argument_list; 449, 450; 450, string:"Only one number can be negative."; 451, if_statement; 451, 452; 451, 455; 452, comparison_operator:is; 452, 453; 452, 454; 453, identifier:sign; 454, None; 455, block; 455, 456; 456, expression_statement; 456, 457; 457, assignment; 457, 458; 457, 459; 458, identifier:sign; 459, integer:1; 460, expression_statement; 460, 461; 461, assignment; 461, 462; 461, 463; 462, identifier:vals; 463, list_comprehension; 463, 464; 463, 473; 464, conditional_expression:if; 464, 465; 464, 469; 464, 472; 465, call; 465, 466; 465, 467; 466, identifier:abs; 467, argument_list; 467, 468; 468, identifier:i; 469, comparison_operator:is; 469, 470; 469, 471; 470, identifier:i; 471, None; 472, float:0.0; 473, for_in_clause; 473, 474; 473, 475; 474, identifier:i; 475, identifier:parts; 476, return_statement; 476, 477; 477, call; 477, 478; 477, 479; 478, identifier:dict; 479, argument_list; 479, 480; 479, 483; 479, 486; 479, 489; 480, keyword_argument; 480, 481; 480, 482; 481, identifier:sign; 482, identifier:sign; 483, keyword_argument; 483, 484; 483, 485; 484, identifier:units; 485, identifier:units; 486, keyword_argument; 486, 487; 486, 488; 487, identifier:vals; 488, identifier:vals; 489, keyword_argument; 489, 490; 489, 491; 490, identifier:parts; 491, identifier:parts | def phmsdms(hmsdms):
units = None
sign = None
pattern1 = re.compile(r"([-+]?[0-9]*\.?[0-9]+[^0-9\-+]*)")
pattern2 = re.compile(r"([-+]?[0-9]*\.?[0-9]+)")
hmsdms = hmsdms.lower()
hdlist = pattern1.findall(hmsdms)
parts = [None, None, None]
def _fill_right_not_none():
rp = reversed(parts)
for i, j in enumerate(rp):
if j is not None:
break
if i == 0:
raise ValueError("Invalid string.")
elif i == 1:
parts[2] = v
elif i == 2:
if parts[0] is None:
parts[0] = v
else:
parts[1] = v
for valun in hdlist:
try:
v = float(valun)
_fill_right_not_none()
except ValueError:
if "hh" in valun or "h" in valun:
m = pattern2.search(valun)
parts[0] = float(valun[m.start():m.end()])
units = "hours"
if "dd" in valun or "d" in valun:
m = pattern2.search(valun)
parts[0] = float(valun[m.start():m.end()])
units = "degrees"
if "mm" in valun or "m" in valun:
m = pattern2.search(valun)
parts[1] = float(valun[m.start():m.end()])
if "ss" in valun or "s" in valun:
m = pattern2.search(valun)
parts[2] = float(valun[m.start():m.end()])
if "'" in valun:
m = pattern2.search(valun)
parts[1] = float(valun[m.start():m.end()])
if '"' in valun:
m = pattern2.search(valun)
parts[2] = float(valun[m.start():m.end()])
if ":" in valun:
v = valun.replace(":", "")
v = float(v)
_fill_right_not_none()
if not units:
units = "degrees"
for i in parts:
if i and i < 0.0:
if sign is None:
sign = -1
else:
raise ValueError("Only one number can be negative.")
if sign is None:
sign = 1
vals = [abs(i) if i is not None else 0.0 for i in parts]
return dict(sign=sign, units=units, vals=vals, parts=parts) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:pposition; 3, parameters; 3, 4; 3, 5; 4, identifier:hd; 5, default_parameter; 5, 6; 5, 7; 6, identifier:details; 7, False; 8, block; 8, 9; 8, 19; 8, 34; 8, 160; 8, 192; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:p; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:re; 15, identifier:split; 16, argument_list; 16, 17; 16, 18; 17, string:r"[^\d\-+.]*"; 18, identifier:hd; 19, if_statement; 19, 20; 19, 28; 20, comparison_operator:not; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:p; 25, list:[2, 6]; 25, 26; 25, 27; 26, integer:2; 27, integer:6; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:ValueError; 32, argument_list; 32, 33; 33, string:"Input must contain either 2 or 6 numbers."; 34, if_statement; 34, 35; 34, 41; 34, 79; 35, comparison_operator:==; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:p; 40, integer:2; 41, block; 41, 42; 41, 60; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, pattern_list; 44, 45; 44, 46; 45, identifier:x; 46, identifier:y; 47, expression_list; 47, 48; 47, 54; 48, call; 48, 49; 48, 50; 49, identifier:float; 50, argument_list; 50, 51; 51, subscript; 51, 52; 51, 53; 52, identifier:p; 53, integer:0; 54, call; 54, 55; 54, 56; 55, identifier:float; 56, argument_list; 56, 57; 57, subscript; 57, 58; 57, 59; 58, identifier:p; 59, integer:1; 60, if_statement; 60, 61; 60, 62; 61, identifier:details; 62, block; 62, 63; 62, 67; 62, 73; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:numvals; 66, integer:2; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:raw_x; 70, subscript; 70, 71; 70, 72; 71, identifier:p; 72, integer:0; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:raw_y; 76, subscript; 76, 77; 76, 78; 77, identifier:p; 78, integer:1; 79, elif_clause; 79, 80; 79, 86; 80, comparison_operator:==; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:p; 85, integer:6; 86, block; 86, 87; 86, 103; 86, 116; 86, 132; 86, 145; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:x_p; 90, call; 90, 91; 90, 92; 91, identifier:phmsdms; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, string:" "; 96, identifier:join; 97, argument_list; 97, 98; 98, subscript; 98, 99; 98, 100; 99, identifier:p; 100, slice; 100, 101; 100, 102; 101, colon; 102, integer:3; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:x; 106, call; 106, 107; 106, 108; 107, identifier:sexa2deci; 108, argument_list; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:x_p; 111, string:'sign'; 112, list_splat; 112, 113; 113, subscript; 113, 114; 113, 115; 114, identifier:x_p; 115, string:'vals'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:y_p; 119, call; 119, 120; 119, 121; 120, identifier:phmsdms; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, string:" "; 125, identifier:join; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 129; 128, identifier:p; 129, slice; 129, 130; 129, 131; 130, integer:3; 131, colon; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:y; 135, call; 135, 136; 135, 137; 136, identifier:sexa2deci; 137, argument_list; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:y_p; 140, string:'sign'; 141, list_splat; 141, 142; 142, subscript; 142, 143; 142, 144; 143, identifier:y_p; 144, string:'vals'; 145, if_statement; 145, 146; 145, 147; 146, identifier:details; 147, block; 147, 148; 147, 152; 147, 156; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:raw_x; 151, identifier:x_p; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:raw_y; 155, identifier:y_p; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:numvals; 159, integer:6; 160, if_statement; 160, 161; 160, 162; 160, 184; 161, identifier:details; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:result; 166, call; 166, 167; 166, 168; 167, identifier:dict; 168, argument_list; 168, 169; 168, 172; 168, 175; 168, 178; 168, 181; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:x; 171, identifier:x; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:y; 174, identifier:y; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:numvals; 177, identifier:numvals; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:raw_x; 180, identifier:raw_x; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:raw_y; 183, identifier:raw_y; 184, else_clause; 184, 185; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:result; 189, expression_list; 189, 190; 189, 191; 190, identifier:x; 191, identifier:y; 192, return_statement; 192, 193; 193, identifier:result | def pposition(hd, details=False):
p = re.split(r"[^\d\-+.]*", hd)
if len(p) not in [2, 6]:
raise ValueError("Input must contain either 2 or 6 numbers.")
if len(p) == 2:
x, y = float(p[0]), float(p[1])
if details:
numvals = 2
raw_x = p[0]
raw_y = p[1]
elif len(p) == 6:
x_p = phmsdms(" ".join(p[:3]))
x = sexa2deci(x_p['sign'], *x_p['vals'])
y_p = phmsdms(" ".join(p[3:]))
y = sexa2deci(y_p['sign'], *y_p['vals'])
if details:
raw_x = x_p
raw_y = y_p
numvals = 6
if details:
result = dict(x=x, y=y, numvals=numvals, raw_x=raw_x,
raw_y=raw_y)
else:
result = x, y
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 68; 2, function_name:Create; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 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; 3, 56; 3, 59; 3, 62; 3, 65; 4, identifier:name; 5, identifier:template; 6, identifier:group_id; 7, identifier:network_id; 8, default_parameter; 8, 9; 8, 10; 9, identifier:cpu; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:memory; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:alias; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:password; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:ip_address; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:storage_type; 25, string:"standard"; 26, default_parameter; 26, 27; 26, 28; 27, identifier:type; 28, string:"standard"; 29, default_parameter; 29, 30; 29, 31; 30, identifier:primary_dns; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:secondary_dns; 34, None; 35, default_parameter; 35, 36; 35, 37; 36, identifier:additional_disks; 37, list:[]; 38, default_parameter; 38, 39; 38, 40; 39, identifier:custom_fields; 40, list:[]; 41, default_parameter; 41, 42; 41, 43; 42, identifier:ttl; 43, None; 44, default_parameter; 44, 45; 44, 46; 45, identifier:managed_os; 46, False; 47, default_parameter; 47, 48; 47, 49; 48, identifier:description; 49, None; 50, default_parameter; 50, 51; 50, 52; 51, identifier:source_server_password; 52, None; 53, default_parameter; 53, 54; 53, 55; 54, identifier:cpu_autoscale_policy_id; 55, None; 56, default_parameter; 56, 57; 56, 58; 57, identifier:anti_affinity_policy_id; 58, None; 59, default_parameter; 59, 60; 59, 61; 60, identifier:packages; 61, list:[]; 62, default_parameter; 62, 63; 62, 64; 63, identifier:configuration_id; 64, None; 65, default_parameter; 65, 66; 65, 67; 66, identifier:session; 67, None; 68, block; 68, 69; 68, 88; 68, 96; 68, 195; 68, 222; 68, 247; 68, 260; 68, 275; 68, 300; 68, 331; 68, 394; 69, if_statement; 69, 70; 69, 72; 70, not_operator; 70, 71; 71, identifier:alias; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:alias; 76, call; 76, 77; 76, 84; 77, attribute; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:clc; 81, identifier:v2; 82, identifier:Account; 83, identifier:GetAlias; 84, argument_list; 84, 85; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:session; 87, identifier:session; 88, if_statement; 88, 89; 88, 91; 89, not_operator; 89, 90; 90, identifier:description; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:description; 95, identifier:name; 96, if_statement; 96, 97; 96, 104; 97, comparison_operator:!=; 97, 98; 97, 103; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:type; 101, identifier:lower; 102, argument_list; 103, string:"baremetal"; 104, block; 104, 105; 104, 131; 104, 163; 105, if_statement; 105, 106; 105, 111; 106, boolean_operator:or; 106, 107; 106, 109; 107, not_operator; 107, 108; 108, identifier:cpu; 109, not_operator; 109, 110; 110, identifier:memory; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:group; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:clc; 119, identifier:v2; 120, identifier:Group; 121, argument_list; 121, 122; 121, 125; 121, 128; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:id; 124, identifier:group_id; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:alias; 127, identifier:alias; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:session; 130, identifier:session; 131, if_statement; 131, 132; 131, 141; 131, 151; 132, boolean_operator:and; 132, 133; 132, 135; 133, not_operator; 133, 134; 134, identifier:cpu; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:group; 138, identifier:Defaults; 139, argument_list; 139, 140; 140, string:"cpu"; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:cpu; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:group; 148, identifier:Defaults; 149, argument_list; 149, 150; 150, string:"cpu"; 151, elif_clause; 151, 152; 151, 154; 152, not_operator; 152, 153; 153, identifier:cpu; 154, block; 154, 155; 155, raise_statement; 155, 156; 156, parenthesized_expression; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:clc; 160, identifier:CLCException; 161, argument_list; 161, 162; 162, string:"No default CPU defined"; 163, if_statement; 163, 164; 163, 173; 163, 183; 164, boolean_operator:and; 164, 165; 164, 167; 165, not_operator; 165, 166; 166, identifier:memory; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:group; 170, identifier:Defaults; 171, argument_list; 171, 172; 172, string:"memory"; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:memory; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:group; 180, identifier:Defaults; 181, argument_list; 181, 182; 182, string:"memory"; 183, elif_clause; 183, 184; 183, 186; 184, not_operator; 184, 185; 185, identifier:memory; 186, block; 186, 187; 187, raise_statement; 187, 188; 188, parenthesized_expression; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:clc; 192, identifier:CLCException; 193, argument_list; 193, 194; 194, string:"No default Memory defined"; 195, if_statement; 195, 196; 195, 213; 196, boolean_operator:and; 196, 197; 196, 204; 197, comparison_operator:==; 197, 198; 197, 203; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:type; 201, identifier:lower; 202, argument_list; 203, string:"standard"; 204, comparison_operator:not; 204, 205; 204, 210; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:storage_type; 208, identifier:lower; 209, argument_list; 210, tuple; 210, 211; 210, 212; 211, string:"standard"; 212, string:"premium"; 213, block; 213, 214; 214, raise_statement; 214, 215; 215, parenthesized_expression; 215, 216; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:clc; 219, identifier:CLCException; 220, argument_list; 220, 221; 221, string:"Invalid type/storage_type combo"; 222, if_statement; 222, 223; 222, 238; 223, boolean_operator:and; 223, 224; 223, 231; 224, comparison_operator:==; 224, 225; 224, 230; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:type; 228, identifier:lower; 229, argument_list; 230, string:"hyperscale"; 231, comparison_operator:!=; 231, 232; 231, 237; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:storage_type; 235, identifier:lower; 236, argument_list; 237, string:"hyperscale"; 238, block; 238, 239; 239, raise_statement; 239, 240; 240, parenthesized_expression; 240, 241; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:clc; 244, identifier:CLCException; 245, argument_list; 245, 246; 246, string:"Invalid type/storage_type combo"; 247, if_statement; 247, 248; 247, 255; 248, comparison_operator:==; 248, 249; 248, 254; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:type; 252, identifier:lower; 253, argument_list; 254, string:"baremetal"; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:type; 259, string:"bareMetal"; 260, if_statement; 260, 261; 260, 266; 261, boolean_operator:and; 261, 262; 261, 263; 262, identifier:ttl; 263, comparison_operator:<=; 263, 264; 263, 265; 264, identifier:ttl; 265, integer:3600; 266, block; 266, 267; 267, raise_statement; 267, 268; 268, parenthesized_expression; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:clc; 272, identifier:CLCException; 273, argument_list; 273, 274; 274, string:"ttl must be greater than 3600 seconds"; 275, if_statement; 275, 276; 275, 277; 276, identifier:ttl; 277, block; 277, 278; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:ttl; 281, call; 281, 282; 281, 289; 282, attribute; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:clc; 286, identifier:v2; 287, identifier:time_utils; 288, identifier:SecondsToZuluTS; 289, argument_list; 289, 290; 290, binary_operator:+; 290, 291; 290, 299; 291, call; 291, 292; 291, 293; 292, identifier:int; 293, argument_list; 293, 294; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:time; 297, identifier:time; 298, argument_list; 299, identifier:ttl; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:payload; 303, dictionary; 303, 304; 303, 307; 303, 310; 303, 313; 303, 316; 303, 319; 303, 322; 303, 325; 303, 328; 304, pair; 304, 305; 304, 306; 305, string:'name'; 306, identifier:name; 307, pair; 307, 308; 307, 309; 308, string:'description'; 309, identifier:description; 310, pair; 310, 311; 310, 312; 311, string:'groupId'; 312, identifier:group_id; 313, pair; 313, 314; 313, 315; 314, string:'primaryDNS'; 315, identifier:primary_dns; 316, pair; 316, 317; 316, 318; 317, string:'secondaryDNS'; 318, identifier:secondary_dns; 319, pair; 319, 320; 319, 321; 320, string:'networkId'; 321, identifier:network_id; 322, pair; 322, 323; 322, 324; 323, string:'password'; 324, identifier:password; 325, pair; 325, 326; 325, 327; 326, string:'type'; 327, identifier:type; 328, pair; 328, 329; 328, 330; 329, string:'customFields'; 330, identifier:custom_fields; 331, if_statement; 331, 332; 331, 335; 331, 349; 332, comparison_operator:==; 332, 333; 332, 334; 333, identifier:type; 334, string:'bareMetal'; 335, block; 335, 336; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:payload; 340, identifier:update; 341, argument_list; 341, 342; 342, dictionary; 342, 343; 342, 346; 343, pair; 343, 344; 343, 345; 344, string:'configurationId'; 345, identifier:configuration_id; 346, pair; 346, 347; 346, 348; 347, string:'osType'; 348, identifier:template; 349, else_clause; 349, 350; 350, block; 350, 351; 351, expression_statement; 351, 352; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:payload; 355, identifier:update; 356, argument_list; 356, 357; 357, dictionary; 357, 358; 357, 361; 357, 364; 357, 367; 357, 370; 357, 373; 357, 376; 357, 379; 357, 382; 357, 385; 357, 388; 357, 391; 358, pair; 358, 359; 358, 360; 359, string:'sourceServerId'; 360, identifier:template; 361, pair; 361, 362; 361, 363; 362, string:'isManagedOS'; 363, identifier:managed_os; 364, pair; 364, 365; 364, 366; 365, string:'ipAddress'; 366, identifier:ip_address; 367, pair; 367, 368; 367, 369; 368, string:'sourceServerPassword'; 369, identifier:source_server_password; 370, pair; 370, 371; 370, 372; 371, string:'cpu'; 372, identifier:cpu; 373, pair; 373, 374; 373, 375; 374, string:'cpuAutoscalePolicyId'; 375, identifier:cpu_autoscale_policy_id; 376, pair; 376, 377; 376, 378; 377, string:'memoryGB'; 378, identifier:memory; 379, pair; 379, 380; 379, 381; 380, string:'storageType'; 381, identifier:storage_type; 382, pair; 382, 383; 382, 384; 383, string:'antiAffinityPolicyId'; 384, identifier:anti_affinity_policy_id; 385, pair; 385, 386; 385, 387; 386, string:'additionalDisks'; 387, identifier:additional_disks; 388, pair; 388, 389; 388, 390; 389, string:'ttl'; 390, identifier:ttl; 391, pair; 391, 392; 391, 393; 392, string:'packages'; 393, identifier:packages; 394, return_statement; 394, 395; 395, call; 395, 396; 395, 401; 396, attribute; 396, 397; 396, 400; 397, attribute; 397, 398; 397, 399; 398, identifier:clc; 399, identifier:v2; 400, identifier:Requests; 401, argument_list; 401, 402; 401, 425; 401, 428; 402, call; 402, 403; 402, 410; 403, attribute; 403, 404; 403, 409; 404, attribute; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:clc; 407, identifier:v2; 408, identifier:API; 409, identifier:Call; 410, argument_list; 410, 411; 410, 412; 410, 416; 410, 422; 411, string:'POST'; 412, binary_operator:%; 412, 413; 412, 414; 413, string:'servers/%s'; 414, parenthesized_expression; 414, 415; 415, identifier:alias; 416, call; 416, 417; 416, 420; 417, attribute; 417, 418; 417, 419; 418, identifier:json; 419, identifier:dumps; 420, argument_list; 420, 421; 421, identifier:payload; 422, keyword_argument; 422, 423; 422, 424; 423, identifier:session; 424, identifier:session; 425, keyword_argument; 425, 426; 425, 427; 426, identifier:alias; 427, identifier:alias; 428, keyword_argument; 428, 429; 428, 430; 429, identifier:session; 430, identifier:session | def Create(name,template,group_id,network_id,cpu=None,memory=None,alias=None,password=None,ip_address=None,
storage_type="standard",type="standard",primary_dns=None,secondary_dns=None,
additional_disks=[],custom_fields=[],ttl=None,managed_os=False,description=None,
source_server_password=None,cpu_autoscale_policy_id=None,anti_affinity_policy_id=None,
packages=[],configuration_id=None,session=None):
if not alias: alias = clc.v2.Account.GetAlias(session=session)
if not description: description = name
if type.lower() != "baremetal":
if not cpu or not memory:
group = clc.v2.Group(id=group_id,alias=alias,session=session)
if not cpu and group.Defaults("cpu"):
cpu = group.Defaults("cpu")
elif not cpu:
raise(clc.CLCException("No default CPU defined"))
if not memory and group.Defaults("memory"):
memory = group.Defaults("memory")
elif not memory:
raise(clc.CLCException("No default Memory defined"))
if type.lower() == "standard" and storage_type.lower() not in ("standard","premium"):
raise(clc.CLCException("Invalid type/storage_type combo"))
if type.lower() == "hyperscale" and storage_type.lower() != "hyperscale":
raise(clc.CLCException("Invalid type/storage_type combo"))
if type.lower() == "baremetal":
type = "bareMetal"
if ttl and ttl<=3600: raise(clc.CLCException("ttl must be greater than 3600 seconds"))
if ttl: ttl = clc.v2.time_utils.SecondsToZuluTS(int(time.time())+ttl)
payload = {
'name': name, 'description': description, 'groupId': group_id, 'primaryDNS': primary_dns, 'secondaryDNS': secondary_dns,
'networkId': network_id, 'password': password, 'type': type, 'customFields': custom_fields
}
if type == 'bareMetal':
payload.update({'configurationId': configuration_id, 'osType': template})
else:
payload.update({'sourceServerId': template, 'isManagedOS': managed_os, 'ipAddress': ip_address,
'sourceServerPassword': source_server_password, 'cpu': cpu, 'cpuAutoscalePolicyId': cpu_autoscale_policy_id,
'memoryGB': memory, 'storageType': storage_type, 'antiAffinityPolicyId': anti_affinity_policy_id,
'additionalDisks': additional_disks, 'ttl': ttl, 'packages': packages})
return clc.v2.Requests(clc.v2.API.Call('POST','servers/%s' % (alias), json.dumps(payload), session=session),
alias=alias,
session=session) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 66; 2, function_name:Clone; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 3, 33; 3, 36; 3, 39; 3, 42; 3, 45; 3, 48; 3, 51; 3, 54; 3, 57; 3, 60; 3, 63; 4, identifier:self; 5, identifier:network_id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:name; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:cpu; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:memory; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:group_id; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:alias; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:password; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:ip_address; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:storage_type; 29, None; 30, default_parameter; 30, 31; 30, 32; 31, identifier:type; 32, None; 33, default_parameter; 33, 34; 33, 35; 34, identifier:primary_dns; 35, None; 36, default_parameter; 36, 37; 36, 38; 37, identifier:secondary_dns; 38, None; 39, default_parameter; 39, 40; 39, 41; 40, identifier:custom_fields; 41, None; 42, default_parameter; 42, 43; 42, 44; 43, identifier:ttl; 44, None; 45, default_parameter; 45, 46; 45, 47; 46, identifier:managed_os; 47, False; 48, default_parameter; 48, 49; 48, 50; 49, identifier:description; 50, None; 51, default_parameter; 51, 52; 51, 53; 52, identifier:source_server_password; 53, None; 54, default_parameter; 54, 55; 54, 56; 55, identifier:cpu_autoscale_policy_id; 56, None; 57, default_parameter; 57, 58; 57, 59; 58, identifier:anti_affinity_policy_id; 59, None; 60, default_parameter; 60, 61; 60, 62; 61, identifier:packages; 62, list:[]; 63, default_parameter; 63, 64; 63, 65; 64, identifier:count; 65, integer:1; 66, block; 66, 67; 66, 92; 66, 102; 66, 112; 66, 122; 66, 132; 66, 146; 66, 154; 66, 164; 66, 174; 66, 184; 66, 201; 66, 211; 66, 215; 66, 307; 67, if_statement; 67, 68; 67, 70; 68, not_operator; 68, 69; 69, identifier:name; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:name; 74, call; 74, 75; 74, 90; 75, attribute; 75, 76; 75, 89; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:re; 79, identifier:search; 80, argument_list; 80, 81; 80, 86; 81, binary_operator:%; 81, 82; 81, 83; 82, string:"%s(.+)\d{2}$"; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:alias; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:name; 89, identifier:group; 90, argument_list; 90, 91; 91, integer:1; 92, if_statement; 92, 93; 92, 95; 93, not_operator; 93, 94; 94, identifier:cpu; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:cpu; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:cpu; 102, if_statement; 102, 103; 102, 105; 103, not_operator; 103, 104; 104, identifier:memory; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:memory; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:memory; 112, if_statement; 112, 113; 112, 115; 113, not_operator; 113, 114; 114, identifier:group_id; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:group_id; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:group_id; 122, if_statement; 122, 123; 122, 125; 123, not_operator; 123, 124; 124, identifier:alias; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:alias; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:alias; 132, if_statement; 132, 133; 132, 135; 133, not_operator; 133, 134; 134, identifier:source_server_password; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:source_server_password; 139, subscript; 139, 140; 139, 145; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:Credentials; 144, argument_list; 145, string:'password'; 146, if_statement; 146, 147; 146, 149; 147, not_operator; 147, 148; 148, identifier:password; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:password; 153, identifier:source_server_password; 154, if_statement; 154, 155; 154, 157; 155, not_operator; 155, 156; 156, identifier:storage_type; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:storage_type; 161, attribute; 161, 162; 161, 163; 162, identifier:self; 163, identifier:storage_type; 164, if_statement; 164, 165; 164, 167; 165, not_operator; 165, 166; 166, identifier:type; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:type; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:type; 174, if_statement; 174, 175; 174, 177; 175, not_operator; 175, 176; 176, identifier:storage_type; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:storage_type; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:storage_type; 184, if_statement; 184, 185; 184, 194; 185, boolean_operator:and; 185, 186; 185, 188; 186, not_operator; 186, 187; 187, identifier:custom_fields; 188, call; 188, 189; 188, 190; 189, identifier:len; 190, argument_list; 190, 191; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:custom_fields; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:custom_fields; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:custom_fields; 201, if_statement; 201, 202; 201, 204; 202, not_operator; 202, 203; 203, identifier:description; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:description; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:description; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:requests_lst; 214, list:[]; 215, for_statement; 215, 216; 215, 217; 215, 222; 216, identifier:i; 217, call; 217, 218; 217, 219; 218, identifier:range; 219, argument_list; 219, 220; 219, 221; 220, integer:0; 221, identifier:count; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:requests_lst; 227, identifier:append; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:Server; 232, identifier:Create; 233, argument_list; 233, 234; 233, 235; 233, 238; 233, 241; 233, 244; 233, 247; 233, 250; 233, 255; 233, 258; 233, 261; 233, 264; 233, 267; 233, 270; 233, 273; 233, 276; 233, 279; 233, 282; 233, 285; 233, 288; 233, 291; 233, 294; 233, 297; 233, 302; 234, line_continuation:\; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:name; 237, identifier:name; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:cpu; 240, identifier:cpu; 241, keyword_argument; 241, 242; 241, 243; 242, identifier:memory; 243, identifier:memory; 244, keyword_argument; 244, 245; 244, 246; 245, identifier:group_id; 246, identifier:group_id; 247, keyword_argument; 247, 248; 247, 249; 248, identifier:network_id; 249, identifier:network_id; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:alias; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:alias; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:password; 257, identifier:password; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:ip_address; 260, identifier:ip_address; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:storage_type; 263, identifier:storage_type; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:type; 266, identifier:type; 267, keyword_argument; 267, 268; 267, 269; 268, identifier:primary_dns; 269, identifier:primary_dns; 270, keyword_argument; 270, 271; 270, 272; 271, identifier:secondary_dns; 272, identifier:secondary_dns; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:custom_fields; 275, identifier:custom_fields; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:ttl; 278, identifier:ttl; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:managed_os; 281, identifier:managed_os; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:description; 284, identifier:description; 285, keyword_argument; 285, 286; 285, 287; 286, identifier:source_server_password; 287, identifier:source_server_password; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:cpu_autoscale_policy_id; 290, identifier:cpu_autoscale_policy_id; 291, keyword_argument; 291, 292; 291, 293; 292, identifier:anti_affinity_policy_id; 293, identifier:anti_affinity_policy_id; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:packages; 296, identifier:packages; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:template; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:id; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:session; 304, attribute; 304, 305; 304, 306; 305, identifier:self; 306, identifier:session; 307, return_statement; 307, 308; 308, parenthesized_expression; 308, 309; 309, call; 309, 310; 309, 311; 310, identifier:sum; 311, argument_list; 311, 312; 312, identifier:requests_lst | def Clone(self,network_id,name=None,cpu=None,memory=None,group_id=None,alias=None,password=None,ip_address=None,
storage_type=None,type=None,primary_dns=None,secondary_dns=None,
custom_fields=None,ttl=None,managed_os=False,description=None,
source_server_password=None,cpu_autoscale_policy_id=None,anti_affinity_policy_id=None,
packages=[],count=1):
if not name: name = re.search("%s(.+)\d{2}$" % self.alias,self.name).group(1)
if not cpu: cpu = self.cpu
if not memory: memory = self.memory
if not group_id: group_id = self.group_id
if not alias: alias = self.alias
if not source_server_password: source_server_password = self.Credentials()['password']
if not password: password = source_server_password
if not storage_type: storage_type = self.storage_type
if not type: type = self.type
if not storage_type: storage_type = self.storage_type
if not custom_fields and len(self.custom_fields): custom_fields = self.custom_fields
if not description: description = self.description
requests_lst = []
for i in range(0,count):
requests_lst.append(Server.Create( \
name=name,cpu=cpu,memory=memory,group_id=group_id,network_id=network_id,alias=self.alias,
password=password,ip_address=ip_address,storage_type=storage_type,type=type,
primary_dns=primary_dns,secondary_dns=secondary_dns,
custom_fields=custom_fields,ttl=ttl,managed_os=managed_os,description=description,
source_server_password=source_server_password,cpu_autoscale_policy_id=cpu_autoscale_policy_id,
anti_affinity_policy_id=anti_affinity_policy_id,packages=packages,
template=self.id,session=self.session))
return(sum(requests_lst)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:Call; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:method; 5, identifier:url; 6, default_parameter; 6, 7; 6, 8; 7, identifier:payload; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:session; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:debug; 14, False; 15, block; 15, 16; 15, 59; 15, 68; 15, 101; 15, 115; 15, 140; 15, 189; 15, 222; 16, if_statement; 16, 17; 16, 20; 16, 33; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:session; 19, None; 20, block; 20, 21; 20, 27; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:token; 24, subscript; 24, 25; 24, 26; 25, identifier:session; 26, string:'token'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:http_session; 30, subscript; 30, 31; 30, 32; 31, identifier:session; 32, string:'http_session'; 33, else_clause; 33, 34; 34, block; 34, 35; 34, 47; 34, 53; 35, if_statement; 35, 36; 35, 40; 36, not_operator; 36, 37; 37, attribute; 37, 38; 37, 39; 38, identifier:clc; 39, identifier:_LOGIN_TOKEN_V2; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:API; 45, identifier:_Login; 46, argument_list; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:token; 50, attribute; 50, 51; 50, 52; 51, identifier:clc; 52, identifier:_LOGIN_TOKEN_V2; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:http_session; 56, attribute; 56, 57; 56, 58; 57, identifier:clc; 58, identifier:_REQUESTS_SESSION; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:payload; 62, None; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:payload; 67, dictionary; 68, if_statement; 68, 69; 68, 74; 68, 87; 69, comparison_operator:==; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:url; 72, integer:0; 73, string:'/'; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:fq_url; 78, binary_operator:%; 78, 79; 78, 80; 79, string:"%s%s"; 80, tuple; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:clc; 84, identifier:defaults; 85, identifier:ENDPOINT_URL_V2; 86, identifier:url; 87, else_clause; 87, 88; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:fq_url; 92, binary_operator:%; 92, 93; 92, 94; 93, string:"%s/v2/%s"; 94, tuple; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:clc; 98, identifier:defaults; 99, identifier:ENDPOINT_URL_V2; 100, identifier:url; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:http_session; 106, identifier:headers; 107, identifier:update; 108, argument_list; 108, 109; 109, dictionary; 109, 110; 110, pair; 110, 111; 110, 112; 111, string:'Authorization'; 112, binary_operator:%; 112, 113; 112, 114; 113, string:"Bearer %s"; 114, identifier:token; 115, if_statement; 115, 116; 115, 121; 115, 130; 116, call; 116, 117; 116, 118; 117, identifier:isinstance; 118, argument_list; 118, 119; 118, 120; 119, identifier:payload; 120, identifier:basestring; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 129; 124, subscript; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:http_session; 127, identifier:headers; 128, string:'content-type'; 129, string:"Application/json"; 130, else_clause; 130, 131; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:http_session; 137, identifier:headers; 138, string:'content-type'; 139, string:"application/x-www-form-urlencoded"; 140, if_statement; 140, 141; 140, 144; 140, 166; 141, comparison_operator:==; 141, 142; 141, 143; 142, identifier:method; 143, string:"GET"; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:r; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:http_session; 151, identifier:request; 152, argument_list; 152, 153; 152, 154; 152, 155; 152, 158; 153, identifier:method; 154, identifier:fq_url; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:params; 157, identifier:payload; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:verify; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:API; 163, identifier:_ResourcePath; 164, argument_list; 164, 165; 165, string:'clc/cacert.pem'; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:r; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:http_session; 174, identifier:request; 175, argument_list; 175, 176; 175, 177; 175, 178; 175, 181; 176, identifier:method; 177, identifier:fq_url; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:data; 180, identifier:payload; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:verify; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:API; 186, identifier:_ResourcePath; 187, argument_list; 187, 188; 188, string:'clc/cacert.pem'; 189, if_statement; 189, 190; 189, 191; 190, identifier:debug; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:API; 196, identifier:_DebugRequest; 197, argument_list; 197, 198; 197, 219; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:request; 200, call; 200, 201; 200, 218; 201, attribute; 201, 202; 201, 217; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:requests; 205, identifier:Request; 206, argument_list; 206, 207; 206, 208; 206, 209; 206, 212; 207, identifier:method; 208, identifier:fq_url; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:data; 211, identifier:payload; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:headers; 214, attribute; 214, 215; 214, 216; 215, identifier:http_session; 216, identifier:headers; 217, identifier:prepare; 218, argument_list; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:response; 221, identifier:r; 222, if_statement; 222, 223; 222, 234; 222, 249; 223, boolean_operator:and; 223, 224; 223, 229; 224, comparison_operator:>=; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:r; 227, identifier:status_code; 228, integer:200; 229, comparison_operator:<; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:r; 232, identifier:status_code; 233, integer:300; 234, block; 234, 235; 235, try_statement; 235, 236; 235, 244; 236, block; 236, 237; 237, return_statement; 237, 238; 238, parenthesized_expression; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:r; 242, identifier:json; 243, argument_list; 244, except_clause; 244, 245; 245, block; 245, 246; 246, return_statement; 246, 247; 247, parenthesized_expression; 247, 248; 248, dictionary; 249, else_clause; 249, 250; 250, block; 250, 251; 251, try_statement; 251, 252; 251, 305; 251, 311; 252, block; 252, 253; 252, 276; 252, 284; 252, 294; 252, 302; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:e; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:clc; 259, identifier:APIFailedResponse; 260, argument_list; 260, 261; 261, binary_operator:%; 261, 262; 261, 263; 262, string:"Response code %s. %s %s %s"; 263, tuple; 263, 264; 263, 267; 263, 274; 263, 275; 264, attribute; 264, 265; 264, 266; 265, identifier:r; 266, identifier:status_code; 267, subscript; 267, 268; 267, 273; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:r; 271, identifier:json; 272, argument_list; 273, string:'message'; 274, identifier:method; 275, identifier:fq_url; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:e; 280, identifier:response_status_code; 281, attribute; 281, 282; 281, 283; 282, identifier:r; 283, identifier:status_code; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:e; 288, identifier:response_json; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:r; 292, identifier:json; 293, argument_list; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:e; 298, identifier:response_text; 299, attribute; 299, 300; 299, 301; 300, identifier:r; 301, identifier:text; 302, raise_statement; 302, 303; 303, parenthesized_expression; 303, 304; 304, identifier:e; 305, except_clause; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:clc; 308, identifier:APIFailedResponse; 309, block; 309, 310; 310, raise_statement; 311, except_clause; 311, 312; 312, block; 312, 313; 312, 332; 312, 340; 312, 346; 312, 354; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:e; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:clc; 319, identifier:APIFailedResponse; 320, argument_list; 320, 321; 321, binary_operator:%; 321, 322; 321, 323; 322, string:"Response code %s. %s. %s %s"; 323, tuple; 323, 324; 323, 327; 323, 330; 323, 331; 324, attribute; 324, 325; 324, 326; 325, identifier:r; 326, identifier:status_code; 327, attribute; 327, 328; 327, 329; 328, identifier:r; 329, identifier:text; 330, identifier:method; 331, identifier:fq_url; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:e; 336, identifier:response_status_code; 337, attribute; 337, 338; 337, 339; 338, identifier:r; 339, identifier:status_code; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:e; 344, identifier:response_json; 345, dictionary; 346, expression_statement; 346, 347; 347, assignment; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:e; 350, identifier:response_text; 351, attribute; 351, 352; 351, 353; 352, identifier:r; 353, identifier:text; 354, raise_statement; 354, 355; 355, parenthesized_expression; 355, 356; 356, identifier:e | def Call(method,url,payload=None,session=None,debug=False):
if session is not None:
token = session['token']
http_session = session['http_session']
else:
if not clc._LOGIN_TOKEN_V2:
API._Login()
token = clc._LOGIN_TOKEN_V2
http_session = clc._REQUESTS_SESSION
if payload is None:
payload = {}
if url[0]=='/': fq_url = "%s%s" % (clc.defaults.ENDPOINT_URL_V2,url)
else: fq_url = "%s/v2/%s" % (clc.defaults.ENDPOINT_URL_V2,url)
http_session.headers.update({'Authorization': "Bearer %s" % token})
if isinstance(payload, basestring): http_session.headers['content-type'] = "Application/json"
else: http_session.headers['content-type'] = "application/x-www-form-urlencoded"
if method=="GET":
r = http_session.request(method,fq_url,
params=payload,
verify=API._ResourcePath('clc/cacert.pem'))
else:
r = http_session.request(method,fq_url,
data=payload,
verify=API._ResourcePath('clc/cacert.pem'))
if debug:
API._DebugRequest(request=requests.Request(method,fq_url,data=payload,headers=http_session.headers).prepare(),
response=r)
if r.status_code>=200 and r.status_code<300:
try:
return(r.json())
except:
return({})
else:
try:
e = clc.APIFailedResponse("Response code %s. %s %s %s" %
(r.status_code,r.json()['message'],method,fq_url))
e.response_status_code = r.status_code
e.response_json = r.json()
e.response_text = r.text
raise(e)
except clc.APIFailedResponse:
raise
except:
e = clc.APIFailedResponse("Response code %s. %s. %s %s" %
(r.status_code,r.text,method,fq_url))
e.response_status_code = r.status_code
e.response_json = {}
e.response_text = r.text
raise(e) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:processFiles; 3, parameters; 3, 4; 4, identifier:args; 5, block; 5, 6; 5, 10; 5, 346; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:to_process; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 15; 11, identifier:filename; 12, subscript; 12, 13; 12, 14; 13, identifier:args; 14, string:'filenames'; 15, block; 15, 16; 15, 22; 15, 56; 15, 65; 15, 90; 15, 109; 15, 128; 15, 141; 15, 147; 15, 203; 15, 222; 15, 228; 15, 333; 15, 339; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:file; 19, call; 19, 20; 19, 21; 20, identifier:dict; 21, argument_list; 22, if_statement; 22, 23; 22, 26; 22, 48; 23, subscript; 23, 24; 23, 25; 24, identifier:args; 25, string:'include'; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:file; 31, string:'include'; 32, binary_operator:+; 32, 33; 32, 34; 33, identifier:INCLUDE_STRING; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, string:''; 37, identifier:join; 38, argument_list; 38, 39; 39, list_comprehension; 39, 40; 39, 43; 40, binary_operator:+; 40, 41; 40, 42; 41, string:'-I'; 42, identifier:item; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:item; 45, subscript; 45, 46; 45, 47; 46, identifier:args; 47, string:'include'; 48, else_clause; 48, 49; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:file; 54, string:'include'; 55, identifier:INCLUDE_STRING; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:file; 60, string:'file_path'; 61, call; 61, 62; 61, 63; 62, identifier:getPath; 63, argument_list; 63, 64; 64, identifier:filename; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 66, 71; 67, subscript; 67, 68; 67, 69; 68, identifier:file; 69, string:'file_base_name'; 70, line_continuation:\; 71, subscript; 71, 72; 71, 89; 72, call; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:os; 76, identifier:path; 77, identifier:splitext; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:os; 83, identifier:path; 84, identifier:basename; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 88; 87, identifier:file; 88, string:'file_path'; 89, integer:0; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 99; 92, pattern_list; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:file; 95, string:'no_extension'; 96, subscript; 96, 97; 96, 98; 97, identifier:file; 98, string:'extension'; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:os; 103, identifier:path; 104, identifier:splitext; 105, argument_list; 105, 106; 106, subscript; 106, 107; 106, 108; 107, identifier:file; 108, string:'file_path'; 109, if_statement; 109, 110; 109, 115; 110, comparison_operator:not; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:file; 113, string:'extension'; 114, identifier:CYTHONIZABLE_FILE_EXTS; 115, block; 115, 116; 116, raise_statement; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:CytherError; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, string:"The file '{}' is not a designated cython file"; 123, identifier:format; 124, argument_list; 124, 125; 125, subscript; 125, 126; 125, 127; 126, identifier:file; 127, string:'file_path'; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:base_path; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:os; 135, identifier:path; 136, identifier:dirname; 137, argument_list; 137, 138; 138, subscript; 138, 139; 138, 140; 139, identifier:file; 140, string:'file_path'; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:local_build; 144, subscript; 144, 145; 144, 146; 145, identifier:args; 146, string:'local'; 147, if_statement; 147, 148; 147, 150; 147, 191; 148, not_operator; 148, 149; 149, identifier:local_build; 150, block; 150, 151; 150, 163; 150, 173; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:cache_name; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:os; 158, identifier:path; 159, identifier:join; 160, argument_list; 160, 161; 160, 162; 161, identifier:base_path; 162, string:'__cythercache__'; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:os; 167, identifier:makedirs; 168, argument_list; 168, 169; 168, 170; 169, identifier:cache_name; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:exist_ok; 172, True; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 178; 175, subscript; 175, 176; 175, 177; 176, identifier:file; 177, string:'c_name'; 178, binary_operator:+; 178, 179; 178, 190; 179, call; 179, 180; 179, 185; 180, attribute; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:os; 183, identifier:path; 184, identifier:join; 185, argument_list; 185, 186; 185, 187; 186, identifier:cache_name; 187, subscript; 187, 188; 187, 189; 188, identifier:file; 189, string:'file_base_name'; 190, string:'.c'; 191, else_clause; 191, 192; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:file; 197, string:'c_name'; 198, binary_operator:+; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:file; 201, string:'no_extension'; 202, string:'.c'; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:file; 207, string:'object_file_name'; 208, binary_operator:+; 208, 209; 208, 221; 209, subscript; 209, 210; 209, 220; 210, call; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:os; 214, identifier:path; 215, identifier:splitext; 216, argument_list; 216, 217; 217, subscript; 217, 218; 217, 219; 218, identifier:file; 219, string:'c_name'; 220, integer:0; 221, string:'.o'; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:output_name; 225, subscript; 225, 226; 225, 227; 226, identifier:args; 227, string:'output_name'; 228, if_statement; 228, 229; 228, 232; 228, 243; 228, 321; 229, subscript; 229, 230; 229, 231; 230, identifier:args; 231, string:'watch'; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:file; 237, string:'output_name'; 238, binary_operator:+; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:file; 241, string:'no_extension'; 242, identifier:DEFAULT_OUTPUT_EXTENSION; 243, elif_clause; 243, 244; 243, 245; 244, identifier:output_name; 245, block; 245, 246; 246, if_statement; 246, 247; 246, 264; 246, 271; 247, boolean_operator:and; 247, 248; 247, 256; 248, call; 248, 249; 248, 254; 249, attribute; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:os; 252, identifier:path; 253, identifier:exists; 254, argument_list; 254, 255; 255, identifier:output_name; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:os; 260, identifier:path; 261, identifier:isfile; 262, argument_list; 262, 263; 263, identifier:output_name; 264, block; 264, 265; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:file; 269, string:'output_name'; 270, identifier:output_name; 271, else_clause; 271, 272; 272, block; 272, 273; 272, 284; 272, 296; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:dirname; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:os; 280, identifier:path; 281, identifier:dirname; 282, argument_list; 282, 283; 283, identifier:output_name; 284, if_statement; 284, 285; 284, 287; 285, not_operator; 285, 286; 286, identifier:dirname; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:dirname; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:os; 294, identifier:getcwd; 295, argument_list; 296, if_statement; 296, 297; 296, 305; 296, 312; 297, call; 297, 298; 297, 303; 298, attribute; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:os; 301, identifier:path; 302, identifier:exists; 303, argument_list; 303, 304; 304, identifier:dirname; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 311; 308, subscript; 308, 309; 308, 310; 309, identifier:file; 310, string:'output_name'; 311, identifier:output_name; 312, else_clause; 312, 313; 313, block; 313, 314; 314, raise_statement; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:CytherError; 317, argument_list; 317, 318; 318, concatenated_string; 318, 319; 318, 320; 319, string:'The directory specified to write'; 320, string:'the output file in does not exist'; 321, else_clause; 321, 322; 322, block; 322, 323; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 328; 325, subscript; 325, 326; 325, 327; 326, identifier:file; 327, string:'output_name'; 328, binary_operator:+; 328, 329; 328, 332; 329, subscript; 329, 330; 329, 331; 330, identifier:file; 331, string:'no_extension'; 332, identifier:DEFAULT_OUTPUT_EXTENSION; 333, expression_statement; 333, 334; 334, assignment; 334, 335; 334, 338; 335, subscript; 335, 336; 335, 337; 336, identifier:file; 337, string:'stamp_if_error'; 338, integer:0; 339, expression_statement; 339, 340; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:to_process; 343, identifier:append; 344, argument_list; 344, 345; 345, identifier:file; 346, return_statement; 346, 347; 347, identifier:to_process | def processFiles(args):
to_process = []
for filename in args['filenames']:
file = dict()
if args['include']:
file['include'] = INCLUDE_STRING + ''.join(
['-I' + item for item in args['include']])
else:
file['include'] = INCLUDE_STRING
file['file_path'] = getPath(filename)
file['file_base_name'] = \
os.path.splitext(os.path.basename(file['file_path']))[0]
file['no_extension'], file['extension'] = os.path.splitext(
file['file_path'])
if file['extension'] not in CYTHONIZABLE_FILE_EXTS:
raise CytherError(
"The file '{}' is not a designated cython file".format(
file['file_path']))
base_path = os.path.dirname(file['file_path'])
local_build = args['local']
if not local_build:
cache_name = os.path.join(base_path, '__cythercache__')
os.makedirs(cache_name, exist_ok=True)
file['c_name'] = os.path.join(cache_name,
file['file_base_name']) + '.c'
else:
file['c_name'] = file['no_extension'] + '.c'
file['object_file_name'] = os.path.splitext(file['c_name'])[0] + '.o'
output_name = args['output_name']
if args['watch']:
file['output_name'] = file['no_extension']+DEFAULT_OUTPUT_EXTENSION
elif output_name:
if os.path.exists(output_name) and os.path.isfile(output_name):
file['output_name'] = output_name
else:
dirname = os.path.dirname(output_name)
if not dirname:
dirname = os.getcwd()
if os.path.exists(dirname):
file['output_name'] = output_name
else:
raise CytherError('The directory specified to write'
'the output file in does not exist')
else:
file['output_name'] = file['no_extension']+DEFAULT_OUTPUT_EXTENSION
file['stamp_if_error'] = 0
to_process.append(file)
return to_process |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:main; 3, parameters; 4, block; 4, 5; 4, 19; 4, 32; 4, 46; 4, 68; 4, 95; 4, 123; 4, 145; 4, 168; 4, 176; 4, 217; 4, 233; 4, 257; 4, 270; 4, 281; 4, 303; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:parser; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:argparse; 11, identifier:ArgumentParser; 12, argument_list; 12, 13; 12, 16; 13, keyword_argument; 13, 14; 13, 15; 14, identifier:description; 15, string:'DistanceClassifier for classification based on distance measure in feature space.'; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:add_help; 18, False; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:parser; 23, identifier:add_argument; 24, argument_list; 24, 25; 24, 26; 24, 29; 25, string:'INPUT_FILE'; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:type; 28, identifier:str; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:help; 31, string:'Data file to perform DistanceClassifier on; ensure that the class label column is labeled as "class".'; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:parser; 36, identifier:add_argument; 37, argument_list; 37, 38; 37, 39; 37, 40; 37, 43; 38, string:'-h'; 39, string:'--help'; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:action; 42, string:'help'; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:help; 45, string:'Show this help message and exit.'; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:parser; 50, identifier:add_argument; 51, argument_list; 51, 52; 51, 53; 51, 56; 51, 59; 51, 62; 51, 65; 52, string:'-is'; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:action; 55, string:'store'; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:dest; 58, string:'INPUT_SEPARATOR'; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:default; 61, string:'\t'; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:type; 64, identifier:str; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:help; 67, string:'Character used to separate columns in the input file.'; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:parser; 72, identifier:add_argument; 73, argument_list; 73, 74; 73, 75; 73, 78; 73, 81; 73, 84; 73, 89; 73, 92; 74, string:'-d'; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:action; 77, string:'store'; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:dest; 80, string:'D'; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:default; 83, string:'mahalanobis'; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:choices; 86, list:['mahalanobis','euclidean']; 86, 87; 86, 88; 87, string:'mahalanobis'; 88, string:'euclidean'; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:type; 91, identifier:str; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:help; 94, string:'Distance metric to use.'; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:parser; 99, identifier:add_argument; 100, argument_list; 100, 101; 100, 102; 100, 105; 100, 108; 100, 111; 100, 117; 100, 120; 101, string:'-v'; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:action; 104, string:'store'; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:dest; 107, string:'VERBOSITY'; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:default; 110, integer:1; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:choices; 113, list:[0, 1, 2]; 113, 114; 113, 115; 113, 116; 114, integer:0; 115, integer:1; 116, integer:2; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:type; 119, identifier:int; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:help; 122, string:'How much information DistanceClassifier communicates while it is running: 0 = none, 1 = minimal, 2 = all.'; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:parser; 127, identifier:add_argument; 128, argument_list; 128, 129; 128, 130; 128, 133; 128, 136; 128, 139; 128, 142; 129, string:'-s'; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:action; 132, string:'store'; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:dest; 135, string:'RANDOM_STATE'; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:default; 138, integer:0; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:type; 141, identifier:int; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:help; 144, string:'Random state for train/test split.'; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:parser; 149, identifier:add_argument; 150, argument_list; 150, 151; 150, 152; 150, 155; 150, 165; 151, string:'--version'; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:action; 154, string:'version'; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:version; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, string:'DistanceClassifier {version}'; 160, identifier:format; 161, argument_list; 161, 162; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:version; 164, identifier:__version__; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:help; 167, string:'Show DistanceClassifier\'s version number and exit.'; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:args; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:parser; 174, identifier:parse_args; 175, argument_list; 176, if_statement; 176, 177; 176, 182; 177, comparison_operator:>=; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:args; 180, identifier:VERBOSITY; 181, integer:2; 182, block; 182, 183; 182, 188; 182, 212; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:print; 186, argument_list; 186, 187; 187, string:'\nDistanceClassifier settings:'; 188, for_statement; 188, 189; 188, 190; 188, 196; 189, identifier:arg; 190, call; 190, 191; 190, 192; 191, identifier:sorted; 192, argument_list; 192, 193; 193, attribute; 193, 194; 193, 195; 194, identifier:args; 195, identifier:__dict__; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:print; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, string:'{}\t=\t{}'; 204, identifier:format; 205, argument_list; 205, 206; 205, 207; 206, identifier:arg; 207, subscript; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:args; 210, identifier:__dict__; 211, identifier:arg; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 215; 214, identifier:print; 215, argument_list; 215, 216; 216, string:''; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:input_data; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:pd; 223, identifier:read_csv; 224, argument_list; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:args; 227, identifier:INPUT_FILE; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:sep; 230, attribute; 230, 231; 230, 232; 231, identifier:args; 232, identifier:INPUT_SEPARATOR; 233, if_statement; 233, 234; 233, 241; 234, comparison_operator:in; 234, 235; 234, 236; 235, string:'Class'; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:input_data; 239, identifier:columns; 240, identifier:values; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:input_data; 246, identifier:rename; 247, argument_list; 247, 248; 247, 254; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:columns; 250, dictionary; 250, 251; 251, pair; 251, 252; 251, 253; 252, string:'Label'; 253, string:'label'; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:inplace; 256, True; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:RANDOM_STATE; 260, conditional_expression:if; 260, 261; 260, 264; 260, 269; 261, attribute; 261, 262; 261, 263; 262, identifier:args; 263, identifier:RANDOM_STATE; 264, comparison_operator:>; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:args; 267, identifier:RANDOM_STATE; 268, integer:0; 269, None; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:dc; 273, call; 273, 274; 273, 275; 274, identifier:DistanceClassifier; 275, argument_list; 275, 276; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:d; 278, attribute; 278, 279; 278, 280; 279, identifier:args; 280, identifier:D; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:dc; 285, identifier:fit; 286, argument_list; 286, 287; 286, 298; 287, attribute; 287, 288; 287, 297; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:input_data; 291, identifier:drop; 292, argument_list; 292, 293; 292, 294; 293, string:'label'; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:axis; 296, integer:1; 297, identifier:values; 298, attribute; 298, 299; 298, 302; 299, subscript; 299, 300; 299, 301; 300, identifier:input_data; 301, string:'label'; 302, identifier:values; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 306; 305, identifier:print; 306, argument_list; 306, 307; 307, call; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, identifier:dc; 310, identifier:score; 311, argument_list; 311, 312; 311, 323; 312, attribute; 312, 313; 312, 322; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:input_data; 316, identifier:drop; 317, argument_list; 317, 318; 317, 319; 318, string:'label'; 319, keyword_argument; 319, 320; 319, 321; 320, identifier:axis; 321, integer:1; 322, identifier:values; 323, attribute; 323, 324; 323, 327; 324, subscript; 324, 325; 324, 326; 325, identifier:input_data; 326, string:'label'; 327, identifier:values | def main():
parser = argparse.ArgumentParser(description='DistanceClassifier for classification based on distance measure in feature space.',
add_help=False)
parser.add_argument('INPUT_FILE', type=str, help='Data file to perform DistanceClassifier on; ensure that the class label column is labeled as "class".')
parser.add_argument('-h', '--help', action='help', help='Show this help message and exit.')
parser.add_argument('-is', action='store', dest='INPUT_SEPARATOR', default='\t',
type=str, help='Character used to separate columns in the input file.')
parser.add_argument('-d', action='store', dest='D', default='mahalanobis',choices = ['mahalanobis','euclidean'],
type=str, help='Distance metric to use.')
parser.add_argument('-v', action='store', dest='VERBOSITY', default=1, choices=[0, 1, 2],
type=int, help='How much information DistanceClassifier communicates while it is running: 0 = none, 1 = minimal, 2 = all.')
parser.add_argument('-s', action='store', dest='RANDOM_STATE', default=0,
type=int, help='Random state for train/test split.')
parser.add_argument('--version', action='version', version='DistanceClassifier {version}'.format(version=__version__),
help='Show DistanceClassifier\'s version number and exit.')
args = parser.parse_args()
if args.VERBOSITY >= 2:
print('\nDistanceClassifier settings:')
for arg in sorted(args.__dict__):
print('{}\t=\t{}'.format(arg, args.__dict__[arg]))
print('')
input_data = pd.read_csv(args.INPUT_FILE, sep=args.INPUT_SEPARATOR)
if 'Class' in input_data.columns.values:
input_data.rename(columns={'Label': 'label'}, inplace=True)
RANDOM_STATE = args.RANDOM_STATE if args.RANDOM_STATE > 0 else None
dc = DistanceClassifier(d = args.D)
dc.fit(input_data.drop('label',axis=1).values, input_data['label'].values)
print(dc.score(input_data.drop('label',axis=1).values, input_data['label'].values)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:delete; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:name; 6, identifier:version; 7, default_parameter; 7, 8; 7, 9; 8, identifier:_lock; 9, True; 10, block; 10, 11; 10, 20; 10, 44; 10, 312; 10, 320; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:link_path; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_link_path; 18, argument_list; 18, 19; 19, identifier:name; 20, if_statement; 20, 21; 20, 22; 20, 36; 21, identifier:_lock; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:file_lock; 26, call; 26, 27; 26, 28; 27, identifier:_exclusive_lock; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_lock_path; 33, argument_list; 33, 34; 33, 35; 34, string:'links'; 35, identifier:name; 36, else_clause; 36, 37; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:file_lock; 41, call; 41, 42; 41, 43; 42, identifier:_no_lock; 43, argument_list; 44, with_statement; 44, 45; 44, 48; 45, with_clause; 45, 46; 46, with_item; 46, 47; 47, identifier:file_lock; 48, block; 48, 49; 48, 57; 48, 66; 48, 89; 48, 98; 48, 304; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:logger; 53, identifier:debug; 54, argument_list; 54, 55; 54, 56; 55, string:'Acquired or inherited lock for link %s.'; 56, identifier:name; 57, if_statement; 57, 58; 57, 63; 58, not_operator; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:_path_exists; 61, argument_list; 61, 62; 62, identifier:link_path; 63, block; 63, 64; 64, raise_statement; 64, 65; 65, identifier:FiletrackerFileNotFoundError; 66, if_statement; 66, 67; 66, 73; 67, comparison_operator:>; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:_file_version; 70, argument_list; 70, 71; 71, identifier:link_path; 72, identifier:version; 73, block; 73, 74; 73, 87; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:logger; 78, identifier:info; 79, argument_list; 79, 80; 79, 81; 79, 82; 79, 83; 80, string:'Tried to delete newer version of %s (%d < %d), ignoring.'; 81, identifier:name; 82, identifier:version; 83, call; 83, 84; 83, 85; 84, identifier:_file_version; 85, argument_list; 85, 86; 86, identifier:link_path; 87, return_statement; 87, 88; 88, False; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:digest; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_digest_for_link; 96, argument_list; 96, 97; 97, identifier:name; 98, with_statement; 98, 99; 98, 111; 99, with_clause; 99, 100; 100, with_item; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:_exclusive_lock; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:_lock_path; 108, argument_list; 108, 109; 108, 110; 109, string:'blobs'; 110, identifier:digest; 111, block; 111, 112; 111, 120; 111, 124; 111, 267; 111, 274; 111, 281; 111, 289; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:logger; 116, identifier:debug; 117, argument_list; 117, 118; 117, 119; 118, string:'Acquired lock for blob %s.'; 119, identifier:digest; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:should_delete_blob; 123, False; 124, with_statement; 124, 125; 124, 135; 125, with_clause; 125, 126; 126, with_item; 126, 127; 127, as_pattern; 127, 128; 127, 133; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_db_transaction; 132, argument_list; 133, as_pattern_target; 133, 134; 134, identifier:txn; 135, block; 135, 136; 135, 143; 135, 151; 135, 165; 135, 175; 135, 182; 135, 260; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:logger; 140, identifier:debug; 141, argument_list; 141, 142; 142, string:'Started DB transaction (deleting link).'; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:digest_bytes; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:digest; 149, identifier:encode; 150, argument_list; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:link_count; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:db; 159, identifier:get; 160, argument_list; 160, 161; 160, 162; 161, identifier:digest_bytes; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:txn; 164, identifier:txn; 165, if_statement; 165, 166; 165, 169; 166, comparison_operator:is; 166, 167; 166, 168; 167, identifier:link_count; 168, None; 169, block; 169, 170; 170, raise_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:RuntimeError; 173, argument_list; 173, 174; 174, string:"File exists but has no key in db"; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:link_count; 178, call; 178, 179; 178, 180; 179, identifier:int; 180, argument_list; 180, 181; 181, identifier:link_count; 182, if_statement; 182, 183; 182, 186; 182, 232; 183, comparison_operator:==; 183, 184; 183, 185; 184, identifier:link_count; 185, integer:1; 186, block; 186, 187; 186, 195; 186, 207; 186, 228; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:logger; 191, identifier:debug; 192, argument_list; 192, 193; 192, 194; 193, string:'Deleting last link to blob %s.'; 194, identifier:digest; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 202; 197, attribute; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:db; 201, identifier:delete; 202, argument_list; 202, 203; 202, 204; 203, identifier:digest_bytes; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:txn; 206, identifier:txn; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:self; 212, identifier:db; 213, identifier:delete; 214, argument_list; 214, 215; 214, 225; 215, call; 215, 216; 215, 224; 216, attribute; 216, 217; 216, 223; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, string:'{}:logical_size'; 220, identifier:format; 221, argument_list; 221, 222; 222, identifier:digest; 223, identifier:encode; 224, argument_list; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:txn; 227, identifier:txn; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:should_delete_blob; 231, True; 232, else_clause; 232, 233; 233, block; 233, 234; 233, 247; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:new_count; 237, call; 237, 238; 237, 246; 238, attribute; 238, 239; 238, 245; 239, call; 239, 240; 239, 241; 240, identifier:str; 241, argument_list; 241, 242; 242, binary_operator:-; 242, 243; 242, 244; 243, identifier:link_count; 244, integer:1; 245, identifier:encode; 246, argument_list; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 254; 249, attribute; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:db; 253, identifier:put; 254, argument_list; 254, 255; 254, 256; 254, 257; 255, identifier:digest_bytes; 256, identifier:new_count; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:txn; 259, identifier:txn; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:logger; 264, identifier:debug; 265, argument_list; 265, 266; 266, string:'Committing DB transaction (deleting link).'; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:logger; 271, identifier:debug; 272, argument_list; 272, 273; 273, string:'Committed DB transaction (deleting link).'; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:os; 278, identifier:unlink; 279, argument_list; 279, 280; 280, identifier:link_path; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:logger; 285, identifier:debug; 286, argument_list; 286, 287; 286, 288; 287, string:'Deleted link %s.'; 288, identifier:name; 289, if_statement; 289, 290; 289, 291; 290, identifier:should_delete_blob; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:os; 296, identifier:unlink; 297, argument_list; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:_blob_path; 302, argument_list; 302, 303; 303, identifier:digest; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:logger; 308, identifier:debug; 309, argument_list; 309, 310; 309, 311; 310, string:'Released lock for blob %s.'; 311, identifier:digest; 312, expression_statement; 312, 313; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:logger; 316, identifier:debug; 317, argument_list; 317, 318; 317, 319; 318, string:'Released (or gave back) lock for link %s.'; 319, identifier:name; 320, return_statement; 320, 321; 321, True | def delete(self, name, version, _lock=True):
link_path = self._link_path(name)
if _lock:
file_lock = _exclusive_lock(self._lock_path('links', name))
else:
file_lock = _no_lock()
with file_lock:
logger.debug('Acquired or inherited lock for link %s.', name)
if not _path_exists(link_path):
raise FiletrackerFileNotFoundError
if _file_version(link_path) > version:
logger.info(
'Tried to delete newer version of %s (%d < %d), ignoring.',
name, version, _file_version(link_path))
return False
digest = self._digest_for_link(name)
with _exclusive_lock(self._lock_path('blobs', digest)):
logger.debug('Acquired lock for blob %s.', digest)
should_delete_blob = False
with self._db_transaction() as txn:
logger.debug('Started DB transaction (deleting link).')
digest_bytes = digest.encode()
link_count = self.db.get(digest_bytes, txn=txn)
if link_count is None:
raise RuntimeError("File exists but has no key in db")
link_count = int(link_count)
if link_count == 1:
logger.debug('Deleting last link to blob %s.', digest)
self.db.delete(digest_bytes, txn=txn)
self.db.delete(
'{}:logical_size'.format(digest).encode(),
txn=txn)
should_delete_blob = True
else:
new_count = str(link_count - 1).encode()
self.db.put(digest_bytes, new_count, txn=txn)
logger.debug('Committing DB transaction (deleting link).')
logger.debug('Committed DB transaction (deleting link).')
os.unlink(link_path)
logger.debug('Deleted link %s.', name)
if should_delete_blob:
os.unlink(self._blob_path(digest))
logger.debug('Released lock for blob %s.', digest)
logger.debug('Released (or gave back) lock for link %s.', name)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:wait_socks; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:sock_events; 5, default_parameter; 5, 6; 5, 7; 6, identifier:inmask; 7, integer:1; 8, default_parameter; 8, 9; 8, 10; 9, identifier:outmask; 10, integer:2; 11, default_parameter; 11, 12; 11, 13; 12, identifier:timeout; 13, None; 14, block; 14, 15; 14, 19; 14, 58; 14, 63; 14, 67; 14, 71; 14, 135; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:results; 18, list:[]; 19, for_statement; 19, 20; 19, 23; 19, 24; 20, pattern_list; 20, 21; 20, 22; 21, identifier:sock; 22, identifier:mask; 23, identifier:sock_events; 24, block; 24, 25; 25, if_statement; 25, 26; 25, 35; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:sock; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:zmq; 33, identifier:backend; 34, identifier:Socket; 35, block; 35, 36; 35, 46; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:mask; 39, call; 39, 40; 39, 41; 40, identifier:_check_events; 41, argument_list; 41, 42; 41, 43; 41, 44; 41, 45; 42, identifier:sock; 43, identifier:mask; 44, identifier:inmask; 45, identifier:outmask; 46, if_statement; 46, 47; 46, 48; 47, identifier:mask; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:results; 53, identifier:append; 54, argument_list; 54, 55; 55, tuple; 55, 56; 55, 57; 56, identifier:sock; 57, identifier:mask; 58, if_statement; 58, 59; 58, 60; 59, identifier:results; 60, block; 60, 61; 61, return_statement; 61, 62; 62, identifier:results; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:fd_map; 66, dictionary; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:fd_events; 70, list:[]; 71, for_statement; 71, 72; 71, 75; 71, 76; 72, pattern_list; 72, 73; 72, 74; 73, identifier:sock; 74, identifier:mask; 75, identifier:sock_events; 76, block; 76, 77; 76, 120; 76, 126; 77, if_statement; 77, 78; 77, 87; 77, 99; 77, 110; 78, call; 78, 79; 78, 80; 79, identifier:isinstance; 80, argument_list; 80, 81; 80, 82; 81, identifier:sock; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:zmq; 85, identifier:backend; 86, identifier:Socket; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:fd; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:sock; 94, identifier:getsockopt; 95, argument_list; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:zmq; 98, identifier:FD; 99, elif_clause; 99, 100; 99, 105; 100, call; 100, 101; 100, 102; 101, identifier:isinstance; 102, argument_list; 102, 103; 102, 104; 103, identifier:sock; 104, identifier:int; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:fd; 109, identifier:sock; 110, else_clause; 110, 111; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:fd; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:sock; 118, identifier:fileno; 119, argument_list; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:fd_map; 124, identifier:fd; 125, identifier:sock; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:fd_events; 130, identifier:append; 131, argument_list; 131, 132; 132, tuple; 132, 133; 132, 134; 133, identifier:fd; 134, identifier:mask; 135, while_statement; 135, 136; 135, 137; 136, integer:1; 137, block; 137, 138; 137, 146; 137, 158; 137, 164; 137, 168; 137, 215; 137, 220; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:started; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:time; 144, identifier:time; 145, argument_list; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:active; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:descriptor; 152, identifier:wait_fds; 153, argument_list; 153, 154; 153, 155; 153, 156; 153, 157; 154, identifier:fd_events; 155, identifier:inmask; 156, identifier:outmask; 157, identifier:timeout; 158, if_statement; 158, 159; 158, 161; 159, not_operator; 159, 160; 160, identifier:active; 161, block; 161, 162; 162, return_statement; 162, 163; 163, list:[]; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:results; 167, list:[]; 168, for_statement; 168, 169; 168, 172; 168, 173; 169, pattern_list; 169, 170; 169, 171; 170, identifier:fd; 171, identifier:mask; 172, identifier:active; 173, block; 173, 174; 173, 180; 173, 206; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:sock; 177, subscript; 177, 178; 177, 179; 178, identifier:fd_map; 179, identifier:fd; 180, if_statement; 180, 181; 180, 190; 181, call; 181, 182; 181, 183; 182, identifier:isinstance; 183, argument_list; 183, 184; 183, 185; 184, identifier:sock; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:zmq; 188, identifier:backend; 189, identifier:Socket; 190, block; 190, 191; 190, 201; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:mask; 194, call; 194, 195; 194, 196; 195, identifier:_check_events; 196, argument_list; 196, 197; 196, 198; 196, 199; 196, 200; 197, identifier:sock; 198, identifier:mask; 199, identifier:inmask; 200, identifier:outmask; 201, if_statement; 201, 202; 201, 204; 202, not_operator; 202, 203; 203, identifier:mask; 204, block; 204, 205; 205, continue_statement; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:results; 210, identifier:append; 211, argument_list; 211, 212; 212, tuple; 212, 213; 212, 214; 213, identifier:sock; 214, identifier:mask; 215, if_statement; 215, 216; 215, 217; 216, identifier:results; 217, block; 217, 218; 218, return_statement; 218, 219; 219, identifier:results; 220, expression_statement; 220, 221; 221, augmented_assignment:-=; 221, 222; 221, 223; 222, identifier:timeout; 223, binary_operator:-; 223, 224; 223, 229; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:time; 227, identifier:time; 228, argument_list; 229, identifier:started | def wait_socks(sock_events, inmask=1, outmask=2, timeout=None):
results = []
for sock, mask in sock_events:
if isinstance(sock, zmq.backend.Socket):
mask = _check_events(sock, mask, inmask, outmask)
if mask:
results.append((sock, mask))
if results:
return results
fd_map = {}
fd_events = []
for sock, mask in sock_events:
if isinstance(sock, zmq.backend.Socket):
fd = sock.getsockopt(zmq.FD)
elif isinstance(sock, int):
fd = sock
else:
fd = sock.fileno()
fd_map[fd] = sock
fd_events.append((fd, mask))
while 1:
started = time.time()
active = descriptor.wait_fds(fd_events, inmask, outmask, timeout)
if not active:
return []
results = []
for fd, mask in active:
sock = fd_map[fd]
if isinstance(sock, zmq.backend.Socket):
mask = _check_events(sock, mask, inmask, outmask)
if not mask:
continue
results.append((sock, mask))
if results:
return results
timeout -= time.time() - started |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sync_ldap_user_membership; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:user; 6, identifier:ldap_groups; 7, block; 7, 8; 7, 12; 7, 26; 7, 33; 7, 37; 7, 41; 7, 45; 7, 51; 7, 55; 7, 244; 7, 280; 7, 312; 7, 318; 7, 324; 7, 330; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:groupname_field; 11, string:'name'; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:actualGroups; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:user; 19, identifier:groups; 20, identifier:values_list; 21, argument_list; 21, 22; 21, 23; 22, string:'name'; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:flat; 25, True; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:user_Membership_total; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:ldap_groups; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:user_Membership_added; 36, integer:0; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:user_Membership_deleted; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:user_Membership_errors; 44, integer:0; 45, expression_statement; 45, 46; 46, augmented_assignment:+=; 46, 47; 46, 48; 47, identifier:ldap_groups; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:conf_LDAP_SYNC_GROUP_MEMBERSHIP_ADD_DEFAULT; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:ldap_name_groups; 54, list:[]; 55, for_statement; 55, 56; 55, 59; 55, 60; 56, pattern_list; 56, 57; 56, 58; 57, identifier:cname; 58, identifier:ldap_attributes; 59, identifier:ldap_groups; 60, block; 60, 61; 60, 65; 60, 98; 60, 130; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:defaults; 64, dictionary; 65, try_statement; 65, 66; 65, 94; 66, block; 66, 67; 67, for_statement; 67, 68; 67, 71; 67, 76; 68, pattern_list; 68, 69; 68, 70; 69, identifier:name; 70, identifier:attribute; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:ldap_attributes; 74, identifier:items; 75, argument_list; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 86; 79, subscript; 79, 80; 79, 81; 80, identifier:defaults; 81, subscript; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:conf_LDAP_SYNC_GROUP_ATTRIBUTES; 85, identifier:name; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:attribute; 90, integer:0; 91, identifier:decode; 92, argument_list; 92, 93; 93, string:'utf-8'; 94, except_clause; 94, 95; 94, 96; 95, identifier:AttributeError; 96, block; 96, 97; 97, continue_statement; 98, try_statement; 98, 99; 98, 113; 99, block; 99, 100; 99, 106; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:groupname; 103, subscript; 103, 104; 103, 105; 104, identifier:defaults; 105, identifier:groupname_field; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:ldap_name_groups; 110, identifier:append; 111, argument_list; 111, 112; 112, identifier:groupname; 113, except_clause; 113, 114; 113, 115; 114, identifier:KeyError; 115, block; 115, 116; 115, 125; 115, 129; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:logger; 120, identifier:warning; 121, argument_list; 121, 122; 122, binary_operator:%; 122, 123; 122, 124; 123, string:"Group is missing a required attribute '%s'"; 124, identifier:groupname_field; 125, expression_statement; 125, 126; 126, augmented_assignment:+=; 126, 127; 126, 128; 127, identifier:user_Membership_errors; 128, integer:1; 129, continue_statement; 130, if_statement; 130, 131; 130, 135; 131, parenthesized_expression; 131, 132; 132, comparison_operator:not; 132, 133; 132, 134; 133, identifier:groupname; 134, identifier:actualGroups; 135, block; 135, 136; 135, 148; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:kwargs; 139, dictionary; 139, 140; 139, 145; 140, pair; 140, 141; 140, 144; 141, binary_operator:+; 141, 142; 141, 143; 142, identifier:groupname_field; 143, string:'__iexact'; 144, identifier:groupname; 145, pair; 145, 146; 145, 147; 146, string:'defaults'; 147, identifier:defaults; 148, try_statement; 148, 149; 148, 189; 148, 194; 148, 217; 149, block; 149, 150; 150, if_statement; 150, 151; 150, 155; 150, 170; 151, parenthesized_expression; 151, 152; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:conf_LDAP_SYNC_GROUP_MEMBERSHIP_CREATE_IF_NOT_EXISTS; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, pattern_list; 158, 159; 158, 160; 159, identifier:group; 160, identifier:created; 161, call; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:Group; 165, identifier:objects; 166, identifier:get_or_create; 167, argument_list; 167, 168; 168, dictionary_splat; 168, 169; 169, identifier:kwargs; 170, else_clause; 170, 171; 171, block; 171, 172; 171, 185; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:group; 175, call; 175, 176; 175, 181; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:Group; 179, identifier:objects; 180, identifier:get; 181, argument_list; 181, 182; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:name; 184, identifier:groupname; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:created; 188, False; 189, except_clause; 189, 190; 189, 192; 190, parenthesized_expression; 190, 191; 191, identifier:ObjectDoesNotExist; 192, block; 192, 193; 193, continue_statement; 194, except_clause; 194, 195; 194, 201; 195, as_pattern; 195, 196; 195, 199; 196, tuple; 196, 197; 196, 198; 197, identifier:IntegrityError; 198, identifier:DataError; 199, as_pattern_target; 199, 200; 200, identifier:e; 201, block; 201, 202; 201, 213; 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; 208, binary_operator:%; 208, 209; 208, 210; 209, string:"Error creating group %s: %s"; 210, tuple; 210, 211; 210, 212; 211, identifier:groupname; 212, identifier:e; 213, expression_statement; 213, 214; 214, augmented_assignment:+=; 214, 215; 214, 216; 215, identifier:user_Membership_errors; 216, integer:1; 217, else_clause; 217, 218; 218, block; 218, 219; 218, 231; 218, 240; 219, if_statement; 219, 220; 219, 221; 220, identifier:created; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:logger; 226, identifier:debug; 227, argument_list; 227, 228; 228, binary_operator:%; 228, 229; 228, 230; 229, string:"Created group %s"; 230, identifier:groupname; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 238; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:group; 236, identifier:user_set; 237, identifier:add; 238, argument_list; 238, 239; 239, identifier:user; 240, expression_statement; 240, 241; 241, augmented_assignment:+=; 241, 242; 241, 243; 242, identifier:user_Membership_added; 243, integer:1; 244, for_statement; 244, 245; 244, 246; 244, 247; 245, identifier:check_group; 246, identifier:actualGroups; 247, block; 247, 248; 248, if_statement; 248, 249; 248, 253; 249, parenthesized_expression; 249, 250; 250, comparison_operator:not; 250, 251; 250, 252; 251, identifier:check_group; 252, identifier:ldap_name_groups; 253, block; 253, 254; 253, 267; 253, 276; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:group; 257, call; 257, 258; 257, 263; 258, attribute; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:Group; 261, identifier:objects; 262, identifier:get; 263, argument_list; 263, 264; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:name; 266, identifier:check_group; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 274; 269, attribute; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:group; 272, identifier:user_set; 273, identifier:remove; 274, argument_list; 274, 275; 275, identifier:user; 276, expression_statement; 276, 277; 277, augmented_assignment:+=; 277, 278; 277, 279; 278, identifier:user_Membership_deleted; 279, integer:1; 280, if_statement; 280, 281; 280, 291; 281, parenthesized_expression; 281, 282; 282, boolean_operator:or; 282, 283; 282, 287; 283, parenthesized_expression; 283, 284; 284, comparison_operator:>; 284, 285; 284, 286; 285, identifier:user_Membership_deleted; 286, integer:0; 287, parenthesized_expression; 287, 288; 288, comparison_operator:>; 288, 289; 288, 290; 289, identifier:user_Membership_added; 290, integer:0; 291, block; 291, 292; 291, 298; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:group; 296, identifier:save; 297, argument_list; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:logger; 302, identifier:info; 303, argument_list; 303, 304; 304, binary_operator:%; 304, 305; 304, 306; 305, string:"Group membership for user %s synchronized: %d Added, %d Removed"; 306, tuple; 306, 307; 306, 310; 306, 311; 307, attribute; 307, 308; 307, 309; 308, identifier:user; 309, identifier:username; 310, identifier:user_Membership_added; 311, identifier:user_Membership_deleted; 312, expression_statement; 312, 313; 313, augmented_assignment:+=; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:stats_membership_total; 317, identifier:user_Membership_total; 318, expression_statement; 318, 319; 319, augmented_assignment:+=; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:stats_membership_added; 323, identifier:user_Membership_added; 324, expression_statement; 324, 325; 325, augmented_assignment:+=; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:self; 328, identifier:stats_membership_deleted; 329, identifier:user_Membership_deleted; 330, expression_statement; 330, 331; 331, augmented_assignment:+=; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:stats_membership_errors; 335, identifier:user_Membership_errors | def sync_ldap_user_membership(self, user, ldap_groups):
groupname_field = 'name'
actualGroups = user.groups.values_list('name', flat=True)
user_Membership_total = len(ldap_groups)
user_Membership_added = 0
user_Membership_deleted = 0
user_Membership_errors = 0
ldap_groups += self.conf_LDAP_SYNC_GROUP_MEMBERSHIP_ADD_DEFAULT
ldap_name_groups = []
for cname, ldap_attributes in ldap_groups:
defaults = {}
try:
for name, attribute in ldap_attributes.items():
defaults[self.conf_LDAP_SYNC_GROUP_ATTRIBUTES[name]] = attribute[0].decode('utf-8')
except AttributeError:
continue
try:
groupname = defaults[groupname_field]
ldap_name_groups.append(groupname)
except KeyError:
logger.warning("Group is missing a required attribute '%s'" % groupname_field)
user_Membership_errors += 1
continue
if (groupname not in actualGroups):
kwargs = {
groupname_field + '__iexact': groupname,
'defaults': defaults,
}
try:
if (self.conf_LDAP_SYNC_GROUP_MEMBERSHIP_CREATE_IF_NOT_EXISTS):
group, created = Group.objects.get_or_create(**kwargs)
else:
group = Group.objects.get(name=groupname)
created = False
except (ObjectDoesNotExist):
continue
except (IntegrityError, DataError) as e:
logger.error("Error creating group %s: %s" % (groupname, e))
user_Membership_errors += 1
else:
if created:
logger.debug("Created group %s" % groupname)
group.user_set.add(user)
user_Membership_added += 1
for check_group in actualGroups:
if (check_group not in ldap_name_groups):
group = Group.objects.get(name=check_group)
group.user_set.remove(user)
user_Membership_deleted += 1
if ((user_Membership_deleted > 0) or (user_Membership_added > 0)):
group.save()
logger.info("Group membership for user %s synchronized: %d Added, %d Removed" % (user.username, user_Membership_added, user_Membership_deleted))
self.stats_membership_total += user_Membership_total
self.stats_membership_added += user_Membership_added
self.stats_membership_deleted += user_Membership_deleted
self.stats_membership_errors += user_Membership_errors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:block; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:timeout; 10, None; 11, block; 11, 12; 11, 113; 11, 139; 12, if_statement; 12, 13; 12, 17; 13, not_operator; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_data; 17, block; 17, 18; 17, 26; 17, 34; 17, 49; 17, 62; 17, 73; 17, 83; 18, if_statement; 18, 19; 18, 21; 19, not_operator; 19, 20; 20, identifier:block; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:Empty; 25, argument_list; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:current; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:compat; 32, identifier:getcurrent; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:waketime; 37, conditional_expression:if; 37, 38; 37, 39; 37, 42; 38, None; 39, comparison_operator:is; 39, 40; 39, 41; 40, identifier:timeout; 41, None; 42, binary_operator:+; 42, 43; 42, 48; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:time; 46, identifier:time; 47, argument_list; 48, identifier:timeout; 49, if_statement; 49, 50; 49, 53; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:timeout; 52, None; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:scheduler; 58, identifier:schedule_at; 59, argument_list; 59, 60; 59, 61; 60, identifier:waketime; 61, identifier:current; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_waiters; 68, identifier:append; 69, argument_list; 69, 70; 70, tuple; 70, 71; 70, 72; 71, identifier:current; 72, identifier:waketime; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 82; 75, attribute; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:scheduler; 79, identifier:state; 80, identifier:mainloop; 81, identifier:switch; 82, argument_list; 83, if_statement; 83, 84; 83, 87; 84, comparison_operator:is; 84, 85; 84, 86; 85, identifier:timeout; 86, None; 87, block; 87, 88; 88, if_statement; 88, 89; 88, 97; 89, not_operator; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:scheduler; 93, identifier:_remove_timer; 94, argument_list; 94, 95; 94, 96; 95, identifier:waketime; 96, identifier:current; 97, block; 97, 98; 97, 109; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_waiters; 104, identifier:remove; 105, argument_list; 105, 106; 106, tuple; 106, 107; 106, 108; 107, identifier:current; 108, identifier:waketime; 109, raise_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:Empty; 112, argument_list; 113, if_statement; 113, 114; 113, 123; 114, boolean_operator:and; 114, 115; 114, 120; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:full; 119, argument_list; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:_waiters; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:scheduler; 128, identifier:schedule; 129, argument_list; 129, 130; 130, subscript; 130, 131; 130, 138; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:_waiters; 136, identifier:popleft; 137, argument_list; 138, integer:0; 139, return_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:_get; 144, argument_list | def get(self, block=True, timeout=None):
if not self._data:
if not block:
raise Empty()
current = compat.getcurrent()
waketime = None if timeout is None else time.time() + timeout
if timeout is not None:
scheduler.schedule_at(waketime, current)
self._waiters.append((current, waketime))
scheduler.state.mainloop.switch()
if timeout is not None:
if not scheduler._remove_timer(waketime, current):
self._waiters.remove((current, waketime))
raise Empty()
if self.full() and self._waiters:
scheduler.schedule(self._waiters.popleft()[0])
return self._get() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:put; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:item; 6, default_parameter; 6, 7; 6, 8; 7, identifier:block; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:timeout; 11, None; 12, block; 12, 13; 12, 115; 12, 142; 12, 156; 12, 162; 13, if_statement; 13, 14; 13, 19; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:full; 18, argument_list; 19, block; 19, 20; 19, 28; 19, 36; 19, 51; 19, 64; 19, 75; 19, 85; 20, if_statement; 20, 21; 20, 23; 21, not_operator; 21, 22; 22, identifier:block; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:Full; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:current; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:compat; 34, identifier:getcurrent; 35, argument_list; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:waketime; 39, conditional_expression:if; 39, 40; 39, 41; 39, 44; 40, None; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:timeout; 43, None; 44, binary_operator:+; 44, 45; 44, 50; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:time; 48, identifier:time; 49, argument_list; 50, identifier:timeout; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:timeout; 54, None; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:scheduler; 60, identifier:schedule_at; 61, argument_list; 61, 62; 61, 63; 62, identifier:waketime; 63, identifier:current; 64, expression_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:_waiters; 70, identifier:append; 71, argument_list; 71, 72; 72, tuple; 72, 73; 72, 74; 73, identifier:current; 74, identifier:waketime; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 84; 77, attribute; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:scheduler; 81, identifier:state; 82, identifier:mainloop; 83, identifier:switch; 84, argument_list; 85, if_statement; 85, 86; 85, 89; 86, comparison_operator:is; 86, 87; 86, 88; 87, identifier:timeout; 88, None; 89, block; 89, 90; 90, if_statement; 90, 91; 90, 99; 91, not_operator; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:scheduler; 95, identifier:_remove_timer; 96, argument_list; 96, 97; 96, 98; 97, identifier:waketime; 98, identifier:current; 99, block; 99, 100; 99, 111; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:_waiters; 106, identifier:remove; 107, argument_list; 107, 108; 108, tuple; 108, 109; 108, 110; 109, identifier:current; 110, identifier:waketime; 111, raise_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:Full; 114, argument_list; 115, if_statement; 115, 116; 115, 126; 116, boolean_operator:and; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:_waiters; 120, not_operator; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:full; 125, argument_list; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:scheduler; 131, identifier:schedule; 132, argument_list; 132, 133; 133, subscript; 133, 134; 133, 141; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:_waiters; 139, identifier:popleft; 140, argument_list; 141, integer:0; 142, if_statement; 142, 143; 142, 147; 143, not_operator; 143, 144; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:_open_tasks; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:_jobs_done; 154, identifier:clear; 155, argument_list; 156, expression_statement; 156, 157; 157, augmented_assignment:+=; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:_open_tasks; 161, integer:1; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:_put; 167, argument_list; 167, 168; 168, identifier:item | def put(self, item, block=True, timeout=None):
if self.full():
if not block:
raise Full()
current = compat.getcurrent()
waketime = None if timeout is None else time.time() + timeout
if timeout is not None:
scheduler.schedule_at(waketime, current)
self._waiters.append((current, waketime))
scheduler.state.mainloop.switch()
if timeout is not None:
if not scheduler._remove_timer(waketime, current):
self._waiters.remove((current, waketime))
raise Full()
if self._waiters and not self.full():
scheduler.schedule(self._waiters.popleft()[0])
if not self._open_tasks:
self._jobs_done.clear()
self._open_tasks += 1
self._put(item) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_compress_tokens; 3, parameters; 3, 4; 4, identifier:tokens; 5, block; 5, 6; 5, 10; 5, 50; 5, 57; 5, 61; 5, 155; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:recorder; 9, None; 10, function_definition; 10, 11; 10, 12; 10, 15; 11, function_name:_edge_case_stray_end_quoted; 12, parameters; 12, 13; 12, 14; 13, identifier:tokens; 14, identifier:index; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:tokens; 20, identifier:index; 21, call; 21, 22; 21, 23; 22, identifier:Token; 23, argument_list; 23, 24; 23, 29; 23, 36; 23, 43; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:type; 26, attribute; 26, 27; 26, 28; 27, identifier:TokenType; 28, identifier:UnquotedLiteral; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:content; 31, attribute; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:tokens; 34, identifier:index; 35, identifier:content; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:line; 38, attribute; 38, 39; 38, 42; 39, subscript; 39, 40; 39, 41; 40, identifier:tokens; 41, identifier:index; 42, identifier:line; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:col; 45, attribute; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:tokens; 48, identifier:index; 49, identifier:col; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:tokens_len; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:tokens; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:index; 60, integer:0; 61, with_statement; 61, 62; 61, 70; 62, with_clause; 62, 63; 63, with_item; 63, 64; 64, as_pattern; 64, 65; 64, 68; 65, call; 65, 66; 65, 67; 66, identifier:_EdgeCaseStrayParens; 67, argument_list; 68, as_pattern_target; 68, 69; 69, identifier:edge_case_stray_parens; 70, block; 70, 71; 70, 81; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:edge_cases; 74, list:[
(_is_paren_type, edge_case_stray_parens),
(_is_end_quoted_type, _edge_case_stray_end_quoted),
]; 74, 75; 74, 78; 75, tuple; 75, 76; 75, 77; 76, identifier:_is_paren_type; 77, identifier:edge_case_stray_parens; 78, tuple; 78, 79; 78, 80; 79, identifier:_is_end_quoted_type; 80, identifier:_edge_case_stray_end_quoted; 81, while_statement; 81, 82; 81, 85; 82, comparison_operator:<; 82, 83; 82, 84; 83, identifier:index; 84, identifier:tokens_len; 85, block; 85, 86; 85, 95; 85, 151; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:recorder; 89, call; 89, 90; 89, 91; 90, identifier:_find_recorder; 91, argument_list; 91, 92; 91, 93; 91, 94; 92, identifier:recorder; 93, identifier:tokens; 94, identifier:index; 95, if_statement; 95, 96; 95, 99; 95, 127; 96, comparison_operator:is; 96, 97; 96, 98; 97, identifier:recorder; 98, None; 99, block; 99, 100; 99, 111; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:result; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:recorder; 106, identifier:consume_token; 107, argument_list; 107, 108; 107, 109; 107, 110; 108, identifier:tokens; 109, identifier:index; 110, identifier:tokens_len; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:result; 114, None; 115, block; 115, 116; 115, 123; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 122; 118, tuple_pattern; 118, 119; 118, 120; 118, 121; 119, identifier:index; 120, identifier:tokens_len; 121, identifier:tokens; 122, identifier:result; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:recorder; 126, None; 127, else_clause; 127, 128; 128, block; 128, 129; 129, for_statement; 129, 130; 129, 133; 129, 134; 130, pattern_list; 130, 131; 130, 132; 131, identifier:matcher; 132, identifier:handler; 133, identifier:edge_cases; 134, block; 134, 135; 135, if_statement; 135, 136; 135, 144; 136, call; 136, 137; 136, 138; 137, identifier:matcher; 138, argument_list; 138, 139; 139, attribute; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:tokens; 142, identifier:index; 143, identifier:type; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:handler; 148, argument_list; 148, 149; 148, 150; 149, identifier:tokens; 150, identifier:index; 151, expression_statement; 151, 152; 152, augmented_assignment:+=; 152, 153; 152, 154; 153, identifier:index; 154, integer:1; 155, return_statement; 155, 156; 156, identifier:tokens | def _compress_tokens(tokens):
recorder = None
def _edge_case_stray_end_quoted(tokens, index):
tokens[index] = Token(type=TokenType.UnquotedLiteral,
content=tokens[index].content,
line=tokens[index].line,
col=tokens[index].col)
tokens_len = len(tokens)
index = 0
with _EdgeCaseStrayParens() as edge_case_stray_parens:
edge_cases = [
(_is_paren_type, edge_case_stray_parens),
(_is_end_quoted_type, _edge_case_stray_end_quoted),
]
while index < tokens_len:
recorder = _find_recorder(recorder, tokens, index)
if recorder is not None:
result = recorder.consume_token(tokens, index, tokens_len)
if result is not None:
(index, tokens_len, tokens) = result
recorder = None
else:
for matcher, handler in edge_cases:
if matcher(tokens[index].type):
handler(tokens, index)
index += 1
return tokens |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_parse_dependencies; 3, parameters; 3, 4; 4, identifier:string; 5, block; 5, 6; 5, 15; 5, 24; 5, 31; 5, 35; 5, 39; 5, 70; 5, 85; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:contents; 9, call; 9, 10; 9, 11; 10, identifier:_get_contents_between; 11, argument_list; 11, 12; 11, 13; 11, 14; 12, identifier:string; 13, string:'('; 14, string:')'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:unsorted_dependencies; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:contents; 21, identifier:split; 22, argument_list; 22, 23; 23, string:','; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:_check_parameters; 27, argument_list; 27, 28; 27, 29; 28, identifier:unsorted_dependencies; 29, tuple; 29, 30; 30, string:'?'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:buildable_dependencies; 34, list:[]; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:given_dependencies; 38, list:[]; 39, for_statement; 39, 40; 39, 41; 39, 42; 40, identifier:dependency; 41, identifier:unsorted_dependencies; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 49; 43, 61; 44, comparison_operator:==; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:dependency; 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:given_dependencies; 54, identifier:append; 55, argument_list; 55, 56; 56, subscript; 56, 57; 56, 58; 57, identifier:dependency; 58, slice; 58, 59; 58, 60; 59, integer:1; 60, colon; 61, else_clause; 61, 62; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:buildable_dependencies; 67, identifier:append; 68, argument_list; 68, 69; 69, identifier:dependency; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:string; 73, subscript; 73, 74; 73, 75; 74, identifier:string; 75, slice; 75, 76; 75, 84; 76, binary_operator:+; 76, 77; 76, 83; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:string; 80, identifier:index; 81, argument_list; 81, 82; 82, string:')'; 83, integer:1; 84, colon; 85, return_statement; 85, 86; 86, expression_list; 86, 87; 86, 88; 86, 89; 87, identifier:buildable_dependencies; 88, identifier:given_dependencies; 89, identifier:string | def _parse_dependencies(string):
contents = _get_contents_between(string, '(', ')')
unsorted_dependencies = contents.split(',')
_check_parameters(unsorted_dependencies, ('?',))
buildable_dependencies = []
given_dependencies = []
for dependency in unsorted_dependencies:
if dependency[0] == '?':
given_dependencies.append(dependency[1:])
else:
buildable_dependencies.append(dependency)
string = string[string.index(')') + 1:]
return buildable_dependencies, given_dependencies, string |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:wait_fds; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:fd_events; 5, default_parameter; 5, 6; 5, 7; 6, identifier:inmask; 7, integer:1; 8, default_parameter; 8, 9; 8, 10; 9, identifier:outmask; 10, integer:2; 11, default_parameter; 11, 12; 11, 13; 12, identifier:timeout; 13, None; 14, block; 14, 15; 14, 23; 14, 27; 14, 31; 14, 35; 14, 81; 14, 148; 14, 191; 14, 219; 14, 234; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:current; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:compat; 21, identifier:getcurrent; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:activated; 26, dictionary; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:poll_regs; 30, dictionary; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:callback_refs; 34, dictionary; 35, function_definition; 35, 36; 35, 37; 35, 40; 36, function_name:activate; 37, parameters; 37, 38; 37, 39; 38, identifier:fd; 39, identifier:event; 40, block; 40, 41; 40, 67; 40, 75; 41, if_statement; 41, 42; 41, 48; 42, boolean_operator:and; 42, 43; 42, 45; 43, not_operator; 43, 44; 44, identifier:activated; 45, comparison_operator:!=; 45, 46; 45, 47; 46, identifier:timeout; 47, integer:0; 48, block; 48, 49; 48, 56; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:scheduler; 53, identifier:schedule; 54, argument_list; 54, 55; 55, identifier:current; 56, if_statement; 56, 57; 56, 58; 57, identifier:timeout; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:scheduler; 63, identifier:_remove_timer; 64, argument_list; 64, 65; 64, 66; 65, identifier:waketime; 66, identifier:current; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:activated; 71, identifier:setdefault; 72, argument_list; 72, 73; 72, 74; 73, identifier:fd; 74, integer:0; 75, expression_statement; 75, 76; 76, augmented_assignment:|=; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:activated; 79, identifier:fd; 80, identifier:event; 81, for_statement; 81, 82; 81, 85; 81, 86; 82, pattern_list; 82, 83; 82, 84; 83, identifier:fd; 84, identifier:events; 85, identifier:fd_events; 86, block; 86, 87; 86, 91; 86, 95; 86, 111; 86, 127; 86, 135; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:readable; 90, None; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:writable; 94, None; 95, if_statement; 95, 96; 95, 99; 96, binary_operator:&; 96, 97; 96, 98; 97, identifier:events; 98, identifier:inmask; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:readable; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:functools; 106, identifier:partial; 107, argument_list; 107, 108; 107, 109; 107, 110; 108, identifier:activate; 109, identifier:fd; 110, identifier:inmask; 111, if_statement; 111, 112; 111, 115; 112, binary_operator:&; 112, 113; 112, 114; 113, identifier:events; 114, identifier:outmask; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:writable; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:functools; 122, identifier:partial; 123, argument_list; 123, 124; 123, 125; 123, 126; 124, identifier:activate; 125, identifier:fd; 126, identifier:outmask; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:callback_refs; 131, identifier:fd; 132, tuple; 132, 133; 132, 134; 133, identifier:readable; 134, identifier:writable; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:poll_regs; 139, identifier:fd; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:scheduler; 143, identifier:_register_fd; 144, argument_list; 144, 145; 144, 146; 144, 147; 145, identifier:fd; 146, identifier:readable; 147, identifier:writable; 148, if_statement; 148, 149; 148, 150; 148, 168; 148, 179; 149, identifier:timeout; 150, block; 150, 151; 150, 161; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:waketime; 154, binary_operator:+; 154, 155; 154, 160; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:time; 158, identifier:time; 159, argument_list; 160, identifier:timeout; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:scheduler; 165, identifier:pause_until; 166, argument_list; 166, 167; 167, identifier:waketime; 168, elif_clause; 168, 169; 168, 172; 169, comparison_operator:==; 169, 170; 169, 171; 170, identifier:timeout; 171, integer:0; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:scheduler; 177, identifier:pause; 178, argument_list; 179, else_clause; 179, 180; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 190; 183, attribute; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:scheduler; 187, identifier:state; 188, identifier:mainloop; 189, identifier:switch; 190, argument_list; 191, for_statement; 191, 192; 191, 195; 191, 200; 192, pattern_list; 192, 193; 192, 194; 193, identifier:fd; 194, identifier:reg; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:poll_regs; 198, identifier:iteritems; 199, argument_list; 200, block; 200, 201; 200, 209; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, pattern_list; 203, 204; 203, 205; 204, identifier:readable; 205, identifier:writable; 206, subscript; 206, 207; 206, 208; 207, identifier:callback_refs; 208, identifier:fd; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:scheduler; 213, identifier:_unregister_fd; 214, argument_list; 214, 215; 214, 216; 214, 217; 214, 218; 215, identifier:fd; 216, identifier:readable; 217, identifier:writable; 218, identifier:reg; 219, if_statement; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:scheduler; 223, identifier:state; 224, identifier:interrupted; 225, block; 225, 226; 226, raise_statement; 226, 227; 227, call; 227, 228; 227, 229; 228, identifier:IOError; 229, argument_list; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:errno; 232, identifier:EINTR; 233, string:"interrupted system call"; 234, return_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:activated; 238, identifier:items; 239, argument_list | def wait_fds(fd_events, inmask=1, outmask=2, timeout=None):
current = compat.getcurrent()
activated = {}
poll_regs = {}
callback_refs = {}
def activate(fd, event):
if not activated and timeout != 0:
scheduler.schedule(current)
if timeout:
scheduler._remove_timer(waketime, current)
activated.setdefault(fd, 0)
activated[fd] |= event
for fd, events in fd_events:
readable = None
writable = None
if events & inmask:
readable = functools.partial(activate, fd, inmask)
if events & outmask:
writable = functools.partial(activate, fd, outmask)
callback_refs[fd] = (readable, writable)
poll_regs[fd] = scheduler._register_fd(fd, readable, writable)
if timeout:
waketime = time.time() + timeout
scheduler.pause_until(waketime)
elif timeout == 0:
scheduler.pause()
else:
scheduler.state.mainloop.switch()
for fd, reg in poll_regs.iteritems():
readable, writable = callback_refs[fd]
scheduler._unregister_fd(fd, readable, writable, reg)
if scheduler.state.interrupted:
raise IOError(errno.EINTR, "interrupted system call")
return activated.items() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:processAndSetDefaults; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 37; 5, 44; 5, 51; 5, 69; 6, if_statement; 6, 7; 6, 11; 7, not_operator; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:input; 11, block; 11, 12; 12, raise_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:ValueError; 15, argument_list; 15, 16; 16, identifier:NO_INPUT_FILE; 17, if_statement; 17, 18; 17, 22; 17, 34; 18, not_operator; 18, 19; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:output; 22, block; 22, 23; 22, 33; 23, if_statement; 23, 24; 23, 28; 24, not_operator; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:build_directory; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:File; 32, argument_list; 33, pass_statement; 34, else_clause; 34, 35; 35, block; 35, 36; 36, pass_statement; 37, if_statement; 37, 38; 37, 42; 38, not_operator; 38, 39; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:build_directory; 42, block; 42, 43; 43, pass_statement; 44, for_statement; 44, 45; 44, 46; 44, 49; 45, identifier:dependency; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:given_dependencies; 49, block; 49, 50; 50, pass_statement; 51, if_statement; 51, 52; 51, 63; 52, comparison_operator:!=; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:output_format; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:output; 61, identifier:getType; 62, argument_list; 63, block; 63, 64; 64, raise_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:ValueError; 67, argument_list; 67, 68; 68, string:""; 69, return_statement | def processAndSetDefaults(self):
if not self.input:
raise ValueError(NO_INPUT_FILE)
if not self.output:
if not self.build_directory:
File()
pass
else:
pass
if not self.build_directory:
pass
for dependency in self.given_dependencies:
pass
if self.output_format != self.output.getType():
raise ValueError("")
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:schedule; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:target; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:args; 9, tuple; 10, default_parameter; 10, 11; 10, 12; 11, identifier:kwargs; 12, None; 13, block; 13, 14; 13, 37; 13, 67; 13, 76; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:target; 17, None; 18, block; 18, 19; 18, 35; 19, function_definition; 19, 20; 19, 21; 19, 23; 20, function_name:decorator; 21, parameters; 21, 22; 22, identifier:target; 23, block; 23, 24; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:schedule; 27, argument_list; 27, 28; 27, 29; 27, 32; 28, identifier:target; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:args; 31, identifier:args; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:kwargs; 35, return_statement; 35, 36; 36, identifier:decorator; 37, if_statement; 37, 38; 37, 51; 37, 56; 38, boolean_operator:or; 38, 39; 38, 46; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:target; 43, attribute; 43, 44; 43, 45; 44, identifier:compat; 45, identifier:greenlet; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:target; 48, attribute; 48, 49; 48, 50; 49, identifier:compat; 50, identifier:main_greenlet; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:glet; 55, identifier:target; 56, else_clause; 56, 57; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:glet; 61, call; 61, 62; 61, 63; 62, identifier:greenlet; 63, argument_list; 63, 64; 63, 65; 63, 66; 64, identifier:target; 65, identifier:args; 66, identifier:kwargs; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:state; 72, identifier:paused; 73, identifier:append; 74, argument_list; 74, 75; 75, identifier:glet; 76, return_statement; 76, 77; 77, identifier:target | def schedule(target=None, args=(), kwargs=None):
if target is None:
def decorator(target):
return schedule(target, args=args, kwargs=kwargs)
return decorator
if isinstance(target, compat.greenlet) or target is compat.main_greenlet:
glet = target
else:
glet = greenlet(target, args, kwargs)
state.paused.append(glet)
return target |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:schedule_at; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:unixtime; 5, default_parameter; 5, 6; 5, 7; 6, identifier:target; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:args; 10, tuple; 11, default_parameter; 11, 12; 11, 13; 12, identifier:kwargs; 13, None; 14, block; 14, 15; 14, 39; 14, 69; 14, 79; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:target; 18, None; 19, block; 19, 20; 19, 37; 20, function_definition; 20, 21; 20, 22; 20, 24; 21, function_name:decorator; 22, parameters; 22, 23; 23, identifier:target; 24, block; 24, 25; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:schedule_at; 28, argument_list; 28, 29; 28, 30; 28, 31; 28, 34; 29, identifier:unixtime; 30, identifier:target; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:args; 33, identifier:args; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:kwargs; 36, identifier:kwargs; 37, return_statement; 37, 38; 38, identifier:decorator; 39, if_statement; 39, 40; 39, 53; 39, 58; 40, boolean_operator:or; 40, 41; 40, 48; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 45; 44, identifier:target; 45, attribute; 45, 46; 45, 47; 46, identifier:compat; 47, identifier:greenlet; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:target; 50, attribute; 50, 51; 50, 52; 51, identifier:compat; 52, identifier:main_greenlet; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:glet; 57, identifier:target; 58, else_clause; 58, 59; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:glet; 63, call; 63, 64; 63, 65; 64, identifier:greenlet; 65, argument_list; 65, 66; 65, 67; 65, 68; 66, identifier:target; 67, identifier:args; 68, identifier:kwargs; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:state; 74, identifier:timed_paused; 75, identifier:insert; 76, argument_list; 76, 77; 76, 78; 77, identifier:unixtime; 78, identifier:glet; 79, return_statement; 79, 80; 80, identifier:target | def schedule_at(unixtime, target=None, args=(), kwargs=None):
if target is None:
def decorator(target):
return schedule_at(unixtime, target, args=args, kwargs=kwargs)
return decorator
if isinstance(target, compat.greenlet) or target is compat.main_greenlet:
glet = target
else:
glet = greenlet(target, args, kwargs)
state.timed_paused.insert(unixtime, glet)
return target |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:schedule_recurring; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:interval; 5, default_parameter; 5, 6; 5, 7; 6, identifier:target; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:maxtimes; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:starting_at; 13, integer:0; 14, default_parameter; 14, 15; 14, 16; 15, identifier:args; 16, tuple; 17, default_parameter; 17, 18; 17, 19; 18, identifier:kwargs; 19, None; 20, block; 20, 21; 20, 31; 20, 53; 20, 57; 20, 88; 20, 130; 20, 136; 20, 147; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:starting_at; 24, boolean_operator:or; 24, 25; 24, 26; 25, identifier:starting_at; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:time; 29, identifier:time; 30, argument_list; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:target; 34, None; 35, block; 35, 36; 35, 51; 36, function_definition; 36, 37; 36, 38; 36, 40; 37, function_name:decorator; 38, parameters; 38, 39; 39, identifier:target; 40, block; 40, 41; 41, return_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:schedule_recurring; 44, argument_list; 44, 45; 44, 46; 44, 47; 44, 48; 44, 49; 44, 50; 45, identifier:interval; 46, identifier:target; 47, identifier:maxtimes; 48, identifier:starting_at; 49, identifier:args; 50, identifier:kwargs; 51, return_statement; 51, 52; 52, identifier:decorator; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:func; 56, identifier:target; 57, if_statement; 57, 58; 57, 71; 58, boolean_operator:or; 58, 59; 58, 66; 59, call; 59, 60; 59, 61; 60, identifier:isinstance; 61, argument_list; 61, 62; 61, 63; 62, identifier:target; 63, attribute; 63, 64; 63, 65; 64, identifier:compat; 65, identifier:greenlet; 66, comparison_operator:is; 66, 67; 66, 68; 67, identifier:target; 68, attribute; 68, 69; 68, 70; 69, identifier:compat; 70, identifier:main_greenlet; 71, block; 71, 72; 71, 82; 72, if_statement; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:target; 75, identifier:dead; 76, block; 76, 77; 77, raise_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:TypeError; 80, argument_list; 80, 81; 81, string:"can't schedule a dead greenlet"; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:func; 85, attribute; 85, 86; 85, 87; 86, identifier:target; 87, identifier:run; 88, function_definition; 88, 89; 88, 90; 88, 93; 89, function_name:run_and_schedule_one; 90, parameters; 90, 91; 90, 92; 91, identifier:tstamp; 92, identifier:count; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 101; 95, boolean_operator:or; 95, 96; 95, 98; 96, not_operator; 96, 97; 97, identifier:maxtimes; 98, comparison_operator:<; 98, 99; 98, 100; 99, identifier:count; 100, identifier:maxtimes; 101, block; 101, 102; 101, 106; 101, 117; 102, expression_statement; 102, 103; 103, augmented_assignment:+=; 103, 104; 103, 105; 104, identifier:tstamp; 105, identifier:interval; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:func; 109, argument_list; 109, 110; 109, 112; 110, list_splat; 110, 111; 111, identifier:args; 112, dictionary_splat; 112, 113; 113, parenthesized_expression; 113, 114; 114, boolean_operator:or; 114, 115; 114, 116; 115, identifier:kwargs; 116, dictionary; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:schedule_at; 120, argument_list; 120, 121; 120, 122; 120, 123; 121, identifier:tstamp; 122, identifier:run_and_schedule_one; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:args; 125, tuple; 125, 126; 125, 127; 126, identifier:tstamp; 127, binary_operator:+; 127, 128; 127, 129; 128, identifier:count; 129, integer:1; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:firstrun; 133, binary_operator:+; 133, 134; 133, 135; 134, identifier:starting_at; 135, identifier:interval; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:schedule_at; 139, argument_list; 139, 140; 139, 141; 139, 142; 140, identifier:firstrun; 141, identifier:run_and_schedule_one; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:args; 144, tuple; 144, 145; 144, 146; 145, identifier:firstrun; 146, integer:0; 147, return_statement; 147, 148; 148, identifier:target | def schedule_recurring(interval, target=None, maxtimes=0, starting_at=0,
args=(), kwargs=None):
starting_at = starting_at or time.time()
if target is None:
def decorator(target):
return schedule_recurring(
interval, target, maxtimes, starting_at, args, kwargs)
return decorator
func = target
if isinstance(target, compat.greenlet) or target is compat.main_greenlet:
if target.dead:
raise TypeError("can't schedule a dead greenlet")
func = target.run
def run_and_schedule_one(tstamp, count):
if not maxtimes or count < maxtimes:
tstamp += interval
func(*args, **(kwargs or {}))
schedule_at(tstamp, run_and_schedule_one,
args=(tstamp, count + 1))
firstrun = starting_at + interval
schedule_at(firstrun, run_and_schedule_one, args=(firstrun, 0))
return target |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:assert_output; 3, parameters; 3, 4; 3, 5; 4, identifier:output; 5, identifier:assert_equal; 6, block; 6, 7; 6, 14; 6, 21; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sorted_output; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 13, identifier:output; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:sorted_assert; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 20, identifier:assert_equal; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:!=; 22, 23; 22, 24; 23, identifier:sorted_output; 24, identifier:sorted_assert; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:ValueError; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:ASSERT_ERROR; 33, identifier:format; 34, argument_list; 34, 35; 34, 36; 35, identifier:sorted_output; 36, identifier:sorted_assert | def assert_output(output, assert_equal):
sorted_output = sorted(output)
sorted_assert = sorted(assert_equal)
if sorted_output != sorted_assert:
raise ValueError(ASSERT_ERROR.format(sorted_output, sorted_assert)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:get_input; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:prompt; 5, identifier:check; 6, keyword_separator; 7, default_parameter; 7, 8; 7, 9; 8, identifier:redo_prompt; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:repeat_prompt; 12, False; 13, block; 13, 14; 13, 26; 13, 30; 13, 56; 13, 70; 13, 95; 13, 142; 13, 149; 13, 175; 14, if_statement; 14, 15; 14, 20; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:check; 19, identifier:str; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:check; 24, tuple; 24, 25; 25, identifier:check; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:to_join; 29, list:[]; 30, for_statement; 30, 31; 30, 32; 30, 33; 31, identifier:item; 32, identifier:check; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 36; 34, 47; 35, identifier:item; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:to_join; 41, identifier:append; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:str; 45, argument_list; 45, 46; 46, identifier:item; 47, else_clause; 47, 48; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:to_join; 53, identifier:append; 54, argument_list; 54, 55; 55, string:"''"; 56, expression_statement; 56, 57; 57, augmented_assignment:+=; 57, 58; 57, 59; 58, identifier:prompt; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, string:" [{}]: "; 62, identifier:format; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, string:'/'; 67, identifier:join; 68, argument_list; 68, 69; 69, identifier:to_join; 70, if_statement; 70, 71; 70, 72; 70, 77; 71, identifier:repeat_prompt; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:redo_prompt; 76, identifier:prompt; 77, elif_clause; 77, 78; 77, 80; 78, not_operator; 78, 79; 79, identifier:redo_prompt; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:redo_prompt; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, concatenated_string; 86, 87; 86, 88; 87, string:"Incorrect input, please choose from {}: "; 88, string:""; 89, identifier:format; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:str; 93, argument_list; 93, 94; 94, identifier:check; 95, if_statement; 95, 96; 95, 100; 95, 111; 95, 127; 96, call; 96, 97; 96, 98; 97, identifier:callable; 98, argument_list; 98, 99; 99, identifier:check; 100, block; 100, 101; 101, function_definition; 101, 102; 101, 103; 101, 105; 102, function_name:_checker; 103, parameters; 103, 104; 104, identifier:r; 105, block; 105, 106; 106, return_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:check; 109, argument_list; 109, 110; 110, identifier:r; 111, elif_clause; 111, 112; 111, 117; 112, call; 112, 113; 112, 114; 113, identifier:isinstance; 114, argument_list; 114, 115; 114, 116; 115, identifier:check; 116, identifier:tuple; 117, block; 117, 118; 118, function_definition; 118, 119; 118, 120; 118, 122; 119, function_name:_checker; 120, parameters; 120, 121; 121, identifier:r; 122, block; 122, 123; 123, return_statement; 123, 124; 124, comparison_operator:in; 124, 125; 124, 126; 125, identifier:r; 126, identifier:check; 127, else_clause; 127, 128; 128, block; 128, 129; 129, raise_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:ValueError; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:RESPONSES_ERROR; 136, identifier:format; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:type; 140, argument_list; 140, 141; 141, identifier:check; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:response; 145, call; 145, 146; 145, 147; 146, identifier:input; 147, argument_list; 147, 148; 148, identifier:prompt; 149, while_statement; 149, 150; 149, 155; 150, not_operator; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:_checker; 153, argument_list; 153, 154; 154, identifier:response; 155, block; 155, 156; 155, 165; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:print; 159, argument_list; 159, 160; 159, 161; 160, identifier:response; 161, call; 161, 162; 161, 163; 162, identifier:type; 163, argument_list; 163, 164; 164, identifier:response; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:response; 168, call; 168, 169; 168, 170; 169, identifier:input; 170, argument_list; 170, 171; 171, conditional_expression:if; 171, 172; 171, 173; 171, 174; 172, identifier:redo_prompt; 173, identifier:redo_prompt; 174, identifier:prompt; 175, return_statement; 175, 176; 176, identifier:response | def get_input(prompt, check, *, redo_prompt=None, repeat_prompt=False):
if isinstance(check, str):
check = (check,)
to_join = []
for item in check:
if item:
to_join.append(str(item))
else:
to_join.append("''")
prompt += " [{}]: ".format('/'.join(to_join))
if repeat_prompt:
redo_prompt = prompt
elif not redo_prompt:
redo_prompt = "Incorrect input, please choose from {}: " \
"".format(str(check))
if callable(check):
def _checker(r): return check(r)
elif isinstance(check, tuple):
def _checker(r): return r in check
else:
raise ValueError(RESPONSES_ERROR.format(type(check)))
response = input(prompt)
while not _checker(response):
print(response, type(response))
response = input(redo_prompt if redo_prompt else prompt)
return response |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:install_build_requires; 3, parameters; 3, 4; 4, identifier:pkg_targets; 5, block; 5, 6; 5, 45; 5, 103; 6, function_definition; 6, 7; 6, 8; 6, 13; 7, function_name:pip_install; 8, parameters; 8, 9; 8, 10; 9, identifier:pkg_name; 10, default_parameter; 10, 11; 10, 12; 11, identifier:pkg_vers; 12, None; 13, block; 13, 14; 13, 25; 13, 29; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:pkg_name_version; 17, conditional_expression:if; 17, 18; 17, 23; 17, 24; 18, binary_operator:%; 18, 19; 18, 20; 19, string:'%s==%s'; 20, tuple; 20, 21; 20, 22; 21, identifier:pkg_name; 22, identifier:pkg_vers; 23, identifier:pkg_vers; 24, identifier:pkg_name; 25, print_statement; 25, 26; 26, binary_operator:%; 26, 27; 26, 28; 27, string:'[WARNING] %s not found, attempting to install using a raw "pip install" call!'; 28, identifier:pkg_name_version; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 44; 31, attribute; 31, 32; 31, 43; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:subprocess; 35, identifier:Popen; 36, argument_list; 36, 37; 36, 40; 37, binary_operator:%; 37, 38; 37, 39; 38, string:'pip install %s'; 39, identifier:pkg_name_version; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:shell; 42, True; 43, identifier:communicate; 44, argument_list; 45, function_definition; 45, 46; 45, 47; 45, 49; 46, function_name:get_pkg_info; 47, parameters; 47, 48; 48, identifier:pkg; 49, block; 49, 50; 49, 58; 49, 99; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:pkg_name; 54, identifier:pkg_vers; 55, expression_list; 55, 56; 55, 57; 56, None; 57, None; 58, if_statement; 58, 59; 58, 62; 58, 74; 59, comparison_operator:in; 59, 60; 59, 61; 60, string:'=='; 61, identifier:pkg; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, pattern_list; 65, 66; 65, 67; 66, identifier:pkg_name; 67, identifier:pkg_vers; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:pkg; 71, identifier:split; 72, argument_list; 72, 73; 73, string:'=='; 74, else_clause; 74, 75; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:pkg_name; 79, subscript; 79, 80; 79, 98; 80, call; 80, 81; 80, 96; 81, attribute; 81, 82; 81, 95; 82, call; 82, 83; 82, 92; 83, attribute; 83, 84; 83, 91; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:pkg; 87, identifier:replace; 88, argument_list; 88, 89; 88, 90; 89, string:'>'; 90, string:''; 91, identifier:replace; 92, argument_list; 92, 93; 92, 94; 93, string:'<'; 94, string:''; 95, identifier:split; 96, argument_list; 96, 97; 97, string:'='; 98, integer:0; 99, return_statement; 99, 100; 100, expression_list; 100, 101; 100, 102; 101, identifier:pkg_name; 102, identifier:pkg_vers; 103, for_statement; 103, 104; 103, 105; 103, 106; 104, identifier:pkg; 105, identifier:pkg_targets; 106, block; 106, 107; 106, 116; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 112; 109, pattern_list; 109, 110; 109, 111; 110, identifier:pkg_name; 111, identifier:pkg_vers; 112, call; 112, 113; 112, 114; 113, identifier:get_pkg_info; 114, argument_list; 114, 115; 115, identifier:pkg; 116, try_statement; 116, 117; 116, 165; 117, block; 117, 118; 117, 129; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:pkg_name_version; 121, conditional_expression:if; 121, 122; 121, 127; 121, 128; 122, binary_operator:%; 122, 123; 122, 124; 123, string:'%s==%s'; 124, tuple; 124, 125; 124, 126; 125, identifier:pkg_name; 126, identifier:pkg_vers; 127, identifier:pkg_vers; 128, identifier:pkg_name; 129, if_statement; 129, 130; 129, 131; 129, 156; 130, identifier:pkg_vers; 131, block; 131, 132; 131, 145; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:version; 135, call; 135, 136; 135, 137; 136, identifier:getattr; 137, argument_list; 137, 138; 137, 144; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:importlib; 141, identifier:import_module; 142, argument_list; 142, 143; 143, identifier:pkg_name; 144, string:'__version__'; 145, if_statement; 145, 146; 145, 149; 146, comparison_operator:!=; 146, 147; 146, 148; 147, identifier:version; 148, identifier:pkg_vers; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:pip_install; 153, argument_list; 153, 154; 153, 155; 154, identifier:pkg_name; 155, identifier:pkg_vers; 156, else_clause; 156, 157; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:importlib; 162, identifier:import_module; 163, argument_list; 163, 164; 164, identifier:pkg_name; 165, except_clause; 165, 166; 165, 167; 166, identifier:ImportError; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:pip_install; 171, argument_list; 171, 172; 171, 173; 172, identifier:pkg_name; 173, identifier:pkg_vers | def install_build_requires(pkg_targets):
def pip_install(pkg_name, pkg_vers=None):
pkg_name_version = '%s==%s' % (pkg_name, pkg_vers) if pkg_vers else pkg_name
print '[WARNING] %s not found, attempting to install using a raw "pip install" call!' % pkg_name_version
subprocess.Popen('pip install %s' % pkg_name_version, shell=True).communicate()
def get_pkg_info(pkg):
pkg_name, pkg_vers = None, None
if '==' in pkg:
pkg_name, pkg_vers = pkg.split('==')
else:
pkg_name = pkg.replace('>', '').replace('<', '').split('=')[0]
return pkg_name, pkg_vers
for pkg in pkg_targets:
pkg_name, pkg_vers = get_pkg_info(pkg)
try:
pkg_name_version = '%s==%s' % (pkg_name, pkg_vers) if pkg_vers else pkg_name
if pkg_vers:
version = getattr(importlib.import_module(pkg_name), '__version__')
if version != pkg_vers:
pip_install(pkg_name, pkg_vers)
else:
importlib.import_module(pkg_name)
except ImportError:
pip_install(pkg_name, pkg_vers) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:PackagePublishUI; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:package; 5, identifier:type; 6, identifier:visibility; 7, block; 7, 8; 7, 21; 7, 34; 7, 96; 7, 117; 7, 248; 7, 273; 7, 277; 7, 319; 7, 340; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:linux_lst; 11, dictionary; 11, 12; 12, pair; 12, 13; 12, 14; 13, string:'L'; 14, dictionary; 14, 15; 14, 18; 15, pair; 15, 16; 15, 17; 16, string:'selected'; 17, False; 18, pair; 18, 19; 18, 20; 19, string:'Description'; 20, string:'All Linux'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:windows_lst; 24, dictionary; 24, 25; 25, pair; 25, 26; 25, 27; 26, string:'W'; 27, dictionary; 27, 28; 27, 31; 28, pair; 28, 29; 28, 30; 29, string:'selected'; 30, False; 31, pair; 31, 32; 31, 33; 32, string:'Description'; 33, string:'All Windows'; 34, for_statement; 34, 35; 34, 36; 34, 45; 35, identifier:r; 36, call; 36, 37; 36, 44; 37, attribute; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:clc; 41, identifier:v1; 42, identifier:Server; 43, identifier:GetTemplates; 44, argument_list; 45, block; 45, 46; 45, 52; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:r; 50, string:'selected'; 51, False; 52, if_statement; 52, 53; 52, 62; 52, 74; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:re; 56, identifier:search; 57, argument_list; 57, 58; 57, 59; 58, string:"Windows"; 59, subscript; 59, 60; 59, 61; 60, identifier:r; 61, string:'Description'; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 73; 65, subscript; 65, 66; 65, 67; 66, identifier:windows_lst; 67, call; 67, 68; 67, 69; 68, identifier:str; 69, argument_list; 69, 70; 70, subscript; 70, 71; 70, 72; 71, identifier:r; 72, string:'OperatingSystem'; 73, identifier:r; 74, elif_clause; 74, 75; 74, 84; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:re; 78, identifier:search; 79, argument_list; 79, 80; 79, 81; 80, string:"CentOS|RedHat|Ubuntu"; 81, subscript; 81, 82; 81, 83; 82, identifier:r; 83, string:'Description'; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 95; 87, subscript; 87, 88; 87, 89; 88, identifier:linux_lst; 89, call; 89, 90; 89, 91; 90, identifier:str; 91, argument_list; 91, 92; 92, subscript; 92, 93; 92, 94; 93, identifier:r; 94, string:'OperatingSystem'; 95, identifier:r; 96, if_statement; 96, 97; 96, 102; 97, comparison_operator:==; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:os; 100, identifier:name; 101, string:'posix'; 102, block; 102, 103; 102, 111; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:scr; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:curses; 109, identifier:initscr; 110, argument_list; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:curses; 115, identifier:cbreak; 116, argument_list; 117, while_statement; 117, 118; 117, 119; 118, True; 119, block; 119, 120; 119, 150; 120, if_statement; 120, 121; 120, 126; 120, 138; 121, comparison_operator:==; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:os; 124, identifier:name; 125, string:'posix'; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:c; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:Blueprint; 133, identifier:_DrawPublishPackageUIPosix; 134, argument_list; 134, 135; 134, 136; 134, 137; 135, identifier:scr; 136, identifier:linux_lst; 137, identifier:windows_lst; 138, else_clause; 138, 139; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:c; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:Blueprint; 146, identifier:_DrawPublishPackageUI; 147, argument_list; 147, 148; 147, 149; 148, identifier:linux_lst; 149, identifier:windows_lst; 150, if_statement; 150, 151; 150, 158; 150, 160; 150, 186; 150, 212; 150, 230; 151, comparison_operator:==; 151, 152; 151, 157; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:c; 155, identifier:lower; 156, argument_list; 157, string:'q'; 158, block; 158, 159; 159, break_statement; 160, elif_clause; 160, 161; 160, 168; 161, comparison_operator:==; 161, 162; 161, 167; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:c; 165, identifier:lower; 166, argument_list; 167, string:'l'; 168, block; 168, 169; 169, for_statement; 169, 170; 169, 171; 169, 172; 170, identifier:l; 171, identifier:linux_lst; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 180; 175, subscript; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:linux_lst; 178, identifier:l; 179, string:'selected'; 180, not_operator; 180, 181; 181, subscript; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:linux_lst; 184, identifier:l; 185, string:'selected'; 186, elif_clause; 186, 187; 186, 194; 187, comparison_operator:==; 187, 188; 187, 193; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:c; 191, identifier:lower; 192, argument_list; 193, string:'w'; 194, block; 194, 195; 195, for_statement; 195, 196; 195, 197; 195, 198; 196, identifier:l; 197, identifier:windows_lst; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 206; 201, subscript; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:windows_lst; 204, identifier:l; 205, string:'selected'; 206, not_operator; 206, 207; 207, subscript; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:windows_lst; 210, identifier:l; 211, string:'selected'; 212, elif_clause; 212, 213; 212, 216; 213, comparison_operator:in; 213, 214; 213, 215; 214, identifier:c; 215, identifier:linux_lst; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 224; 219, subscript; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:linux_lst; 222, identifier:c; 223, string:'selected'; 224, not_operator; 224, 225; 225, subscript; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:linux_lst; 228, identifier:c; 229, string:'selected'; 230, elif_clause; 230, 231; 230, 234; 231, comparison_operator:in; 231, 232; 231, 233; 232, identifier:c; 233, identifier:windows_lst; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 242; 237, subscript; 237, 238; 237, 241; 238, subscript; 238, 239; 238, 240; 239, identifier:windows_lst; 240, identifier:c; 241, string:'selected'; 242, not_operator; 242, 243; 243, subscript; 243, 244; 243, 247; 244, subscript; 244, 245; 244, 246; 245, identifier:windows_lst; 246, identifier:c; 247, string:'selected'; 248, if_statement; 248, 249; 248, 254; 249, comparison_operator:==; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:os; 252, identifier:name; 253, string:'posix'; 254, block; 254, 255; 254, 261; 254, 267; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:curses; 259, identifier:nocbreak; 260, argument_list; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:curses; 265, identifier:echo; 266, argument_list; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:curses; 271, identifier:endwin; 272, argument_list; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:ids; 276, list:[]; 277, for_statement; 277, 278; 277, 279; 277, 297; 278, identifier:l; 279, call; 279, 280; 279, 296; 280, attribute; 280, 281; 280, 295; 281, call; 281, 282; 281, 283; 282, identifier:dict; 283, argument_list; 283, 284; 284, binary_operator:+; 284, 285; 284, 290; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:linux_lst; 288, identifier:items; 289, argument_list; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:windows_lst; 293, identifier:items; 294, argument_list; 295, identifier:values; 296, argument_list; 297, block; 297, 298; 298, if_statement; 298, 299; 298, 306; 299, boolean_operator:and; 299, 300; 299, 303; 300, subscript; 300, 301; 300, 302; 301, identifier:l; 302, string:'selected'; 303, comparison_operator:in; 303, 304; 303, 305; 304, string:'OperatingSystem'; 305, identifier:l; 306, block; 306, 307; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:ids; 311, identifier:append; 312, argument_list; 312, 313; 313, call; 313, 314; 313, 315; 314, identifier:str; 315, argument_list; 315, 316; 316, subscript; 316, 317; 316, 318; 317, identifier:l; 318, string:'OperatingSystem'; 319, expression_statement; 319, 320; 320, call; 320, 321; 320, 328; 321, attribute; 321, 322; 321, 327; 322, attribute; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:clc; 325, identifier:v1; 326, identifier:output; 327, identifier:Status; 328, argument_list; 328, 329; 328, 330; 328, 331; 329, string:'SUCCESS'; 330, integer:2; 331, binary_operator:%; 331, 332; 331, 333; 332, string:'Selected operating system IDs: %s'; 333, parenthesized_expression; 333, 334; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, string:" "; 337, identifier:join; 338, argument_list; 338, 339; 339, identifier:ids; 340, return_statement; 340, 341; 341, parenthesized_expression; 341, 342; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:Blueprint; 345, identifier:PackagePublish; 346, argument_list; 346, 347; 346, 348; 346, 349; 346, 350; 347, identifier:package; 348, identifier:type; 349, identifier:visibility; 350, identifier:ids | def PackagePublishUI(package,type,visibility):
linux_lst = {'L': {'selected': False, 'Description': 'All Linux'}}
windows_lst = {'W': {'selected': False, 'Description': 'All Windows'}}
for r in clc.v1.Server.GetTemplates():
r['selected'] = False
if re.search("Windows",r['Description']): windows_lst[str(r['OperatingSystem'])] = r
elif re.search("CentOS|RedHat|Ubuntu",r['Description']): linux_lst[str(r['OperatingSystem'])] = r
if os.name=='posix':
scr = curses.initscr()
curses.cbreak();
while True:
if os.name=='posix': c = Blueprint._DrawPublishPackageUIPosix(scr,linux_lst,windows_lst)
else: c = Blueprint._DrawPublishPackageUI(linux_lst,windows_lst)
if c.lower() == 'q': break
elif c.lower() == 'l':
for l in linux_lst: linux_lst[l]['selected'] = not linux_lst[l]['selected']
elif c.lower() == 'w':
for l in windows_lst: windows_lst[l]['selected'] = not windows_lst[l]['selected']
elif c in linux_lst: linux_lst[c]['selected'] = not linux_lst[c]['selected']
elif c in windows_lst: windows_lst[c]['selected'] = not windows_lst[c]['selected']
if os.name=='posix':
curses.nocbreak(); curses.echo(); curses.endwin()
ids = []
for l in dict(linux_lst.items()+windows_lst.items()).values():
if l['selected'] and 'OperatingSystem' in l: ids.append(str(l['OperatingSystem']))
clc.v1.output.Status('SUCCESS',2,'Selected operating system IDs: %s' % (" ".join(ids)))
return(Blueprint.PackagePublish(package,type,visibility,ids)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_construct_select_query; 3, parameters; 3, 4; 4, dictionary_splat_pattern; 4, 5; 5, identifier:filter_definition; 6, block; 6, 7; 6, 16; 6, 26; 6, 36; 6, 46; 6, 58; 6, 109; 6, 226; 6, 235; 6, 249; 6, 263; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:table_name; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:filter_definition; 13, identifier:pop; 14, argument_list; 14, 15; 15, string:'table'; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:distinct; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:filter_definition; 22, identifier:pop; 23, argument_list; 23, 24; 23, 25; 24, string:'distinct'; 25, False; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:select_count; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:filter_definition; 32, identifier:pop; 33, argument_list; 33, 34; 33, 35; 34, string:'count'; 35, False; 36, if_statement; 36, 37; 36, 40; 37, boolean_operator:and; 37, 38; 37, 39; 38, identifier:distinct; 39, identifier:select_count; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:UnsupportedDefinitionError; 44, argument_list; 44, 45; 45, string:'SELECT (DISTINCT ...) is not supported'; 46, if_statement; 46, 47; 46, 52; 47, boolean_operator:and; 47, 48; 47, 49; 48, identifier:select_count; 49, comparison_operator:in; 49, 50; 49, 51; 50, string:'select'; 51, identifier:filter_definition; 52, block; 52, 53; 53, raise_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:UnsupportedDefinitionError; 56, argument_list; 56, 57; 57, string:'SELECT COUNT(columns) is not supported'; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:in; 59, 60; 59, 61; 60, string:'joins'; 61, identifier:filter_definition; 62, block; 62, 63; 62, 72; 62, 87; 62, 93; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:join_definitions; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:filter_definition; 69, identifier:pop; 70, argument_list; 70, 71; 71, string:'joins'; 72, if_statement; 72, 73; 72, 81; 73, not_operator; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:join_definitions; 78, tuple; 78, 79; 78, 80; 79, identifier:tuple; 80, identifier:list; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:join_definitions; 85, tuple; 85, 86; 86, identifier:join_definitions; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:filter_definition; 91, string:'joins'; 92, list:[]; 93, for_statement; 93, 94; 93, 95; 93, 96; 94, identifier:join_def; 95, identifier:join_definitions; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:filter_definition; 102, string:'joins'; 103, identifier:append; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:_expand_join; 107, argument_list; 107, 108; 108, identifier:join_def; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:in; 110, 111; 110, 112; 111, string:'where'; 112, identifier:filter_definition; 113, block; 113, 114; 114, for_statement; 114, 115; 114, 118; 114, 125; 115, pattern_list; 115, 116; 115, 117; 116, identifier:key; 117, identifier:value; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:filter_definition; 122, string:'where'; 123, identifier:items; 124, argument_list; 125, block; 125, 126; 126, if_statement; 126, 127; 126, 131; 126, 171; 127, call; 127, 128; 127, 129; 128, identifier:is_filter_query; 129, argument_list; 129, 130; 130, identifier:value; 131, block; 131, 132; 131, 141; 131, 151; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:sub_query; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:value; 138, identifier:pop; 139, argument_list; 139, 140; 140, identifier:DEFAULT_FILTER_KEY; 141, if_statement; 141, 142; 141, 143; 142, identifier:value; 143, block; 143, 144; 144, raise_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:ParsingInputError; 147, argument_list; 147, 148; 148, binary_operator:%; 148, 149; 148, 150; 149, string:"Unknown keys for sub-query provided: %s"; 150, identifier:value; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 158; 153, subscript; 153, 154; 153, 157; 154, subscript; 154, 155; 154, 156; 155, identifier:filter_definition; 156, string:'where'; 157, identifier:key; 158, call; 158, 159; 158, 160; 159, identifier:mosql_raw; 160, argument_list; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, string:'( {} )'; 164, identifier:format; 165, argument_list; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:_construct_select_query; 168, argument_list; 168, 169; 169, dictionary_splat; 169, 170; 170, identifier:sub_query; 171, elif_clause; 171, 172; 171, 195; 172, boolean_operator:and; 172, 173; 172, 185; 173, boolean_operator:and; 173, 174; 173, 179; 174, call; 174, 175; 174, 176; 175, identifier:isinstance; 176, argument_list; 176, 177; 176, 178; 177, identifier:value; 178, identifier:str; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:value; 182, identifier:startswith; 183, argument_list; 183, 184; 184, string:'$'; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:QUERY_REFERENCE; 188, identifier:fullmatch; 189, argument_list; 189, 190; 190, subscript; 190, 191; 190, 192; 191, identifier:value; 192, slice; 192, 193; 192, 194; 193, integer:1; 194, colon; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 203; 198, subscript; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:filter_definition; 201, string:'where'; 202, identifier:key; 203, call; 203, 204; 203, 205; 204, identifier:mosql_raw; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, string:'"{}"'; 209, identifier:format; 210, argument_list; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, string:'"."'; 214, identifier:join; 215, argument_list; 215, 216; 216, call; 216, 217; 216, 224; 217, attribute; 217, 218; 217, 223; 218, subscript; 218, 219; 218, 220; 219, identifier:value; 220, slice; 220, 221; 220, 222; 221, integer:1; 222, colon; 223, identifier:split; 224, argument_list; 224, 225; 225, string:'.'; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:raw_select; 229, call; 229, 230; 229, 231; 230, identifier:select; 231, argument_list; 231, 232; 231, 233; 232, identifier:table_name; 233, dictionary_splat; 233, 234; 234, identifier:filter_definition; 235, if_statement; 235, 236; 235, 237; 236, identifier:distinct; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:raw_select; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:raw_select; 244, identifier:replace; 245, argument_list; 245, 246; 245, 247; 245, 248; 246, string:'SELECT'; 247, string:'SELECT DISTINCT'; 248, integer:1; 249, if_statement; 249, 250; 249, 251; 250, identifier:select_count; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:raw_select; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:raw_select; 258, identifier:replace; 259, argument_list; 259, 260; 259, 261; 259, 262; 260, string:'SELECT *'; 261, string:'SELECT COUNT(*)'; 262, integer:1; 263, return_statement; 263, 264; 264, identifier:raw_select | def _construct_select_query(**filter_definition):
table_name = filter_definition.pop('table')
distinct = filter_definition.pop('distinct', False)
select_count = filter_definition.pop('count', False)
if distinct and select_count:
raise UnsupportedDefinitionError('SELECT (DISTINCT ...) is not supported')
if select_count and 'select' in filter_definition:
raise UnsupportedDefinitionError('SELECT COUNT(columns) is not supported')
if 'joins' in filter_definition:
join_definitions = filter_definition.pop('joins')
if not isinstance(join_definitions, (tuple, list)):
join_definitions = (join_definitions,)
filter_definition['joins'] = []
for join_def in join_definitions:
filter_definition['joins'].append(_expand_join(join_def))
if 'where' in filter_definition:
for key, value in filter_definition['where'].items():
if is_filter_query(value):
sub_query = value.pop(DEFAULT_FILTER_KEY)
if value:
raise ParsingInputError("Unknown keys for sub-query provided: %s" % value)
filter_definition['where'][key] = mosql_raw('( {} )'.format(_construct_select_query(**sub_query)))
elif isinstance(value, str) and value.startswith('$') and QUERY_REFERENCE.fullmatch(value[1:]):
filter_definition['where'][key] = mosql_raw('"{}"'.format('"."'.join(value[1:].split('.'))))
raw_select = select(table_name, **filter_definition)
if distinct:
raw_select = raw_select.replace('SELECT', 'SELECT DISTINCT', 1)
if select_count:
raw_select = raw_select.replace('SELECT *', 'SELECT COUNT(*)', 1)
return raw_select |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:encode; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:df; 5, default_parameter; 5, 6; 5, 7; 6, identifier:encoding; 7, string:'utf8'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:verbosity; 10, integer:1; 11, block; 11, 12; 11, 38; 11, 304; 11, 313; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:>; 13, 14; 13, 15; 14, identifier:verbosity; 15, integer:0; 16, block; 16, 17; 16, 32; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:pbar; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:progressbar; 23, identifier:ProgressBar; 24, argument_list; 24, 25; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:maxval; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:df; 30, identifier:shape; 31, integer:1; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:pbar; 36, identifier:start; 37, argument_list; 38, for_statement; 38, 39; 38, 42; 38, 48; 39, pattern_list; 39, 40; 39, 41; 40, identifier:colnum; 41, identifier:col; 42, call; 42, 43; 42, 44; 43, identifier:enumerate; 44, argument_list; 44, 45; 45, attribute; 45, 46; 45, 47; 46, identifier:df; 47, identifier:columns; 48, block; 48, 49; 49, if_statement; 49, 50; 49, 59; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:df; 55, identifier:col; 56, attribute; 56, 57; 56, 58; 57, identifier:pd; 58, identifier:Series; 59, block; 59, 60; 59, 70; 60, if_statement; 60, 61; 60, 62; 61, identifier:verbosity; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:pbar; 67, identifier:update; 68, argument_list; 68, 69; 69, identifier:colnum; 70, if_statement; 70, 71; 70, 110; 71, boolean_operator:and; 71, 72; 71, 97; 72, comparison_operator:in; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:df; 76, identifier:col; 77, identifier:dtype; 78, tuple; 78, 79; 78, 85; 78, 91; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:dtype; 83, argument_list; 83, 84; 84, string:'object'; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:np; 88, identifier:dtype; 89, argument_list; 89, 90; 90, string:'U'; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:np; 94, identifier:dtype; 95, argument_list; 95, 96; 96, string:'S'; 97, call; 97, 98; 97, 99; 98, identifier:any; 99, generator_expression; 99, 100; 99, 105; 100, call; 100, 101; 100, 102; 101, identifier:isinstance; 102, argument_list; 102, 103; 102, 104; 103, identifier:obj; 104, identifier:basestring; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:obj; 107, subscript; 107, 108; 107, 109; 108, identifier:df; 109, identifier:col; 110, block; 110, 111; 110, 130; 110, 140; 110, 298; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:strmask; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:np; 117, identifier:array; 118, argument_list; 118, 119; 119, list_comprehension; 119, 120; 119, 125; 120, call; 120, 121; 120, 122; 121, identifier:isinstance; 122, argument_list; 122, 123; 122, 124; 123, identifier:obj; 124, identifier:basestring; 125, for_in_clause; 125, 126; 125, 127; 126, identifier:obj; 127, subscript; 127, 128; 127, 129; 128, identifier:df; 129, identifier:col; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:series; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:df; 137, identifier:col; 138, identifier:copy; 139, argument_list; 140, try_statement; 140, 141; 140, 164; 140, 198; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:series; 146, identifier:strmask; 147, call; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:np; 151, identifier:char; 152, identifier:encode; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 162; 155, attribute; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:series; 159, identifier:strmask; 160, identifier:values; 161, identifier:astype; 162, argument_list; 162, 163; 163, string:'U'; 164, except_clause; 164, 165; 164, 166; 165, identifier:TypeError; 166, block; 166, 167; 166, 197; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:print; 170, argument_list; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, string:"Unable to convert {} elements starting at position {} in column {}"; 174, identifier:format; 175, argument_list; 175, 176; 175, 180; 175, 196; 176, call; 176, 177; 176, 178; 177, identifier:sum; 178, argument_list; 178, 179; 179, identifier:strmask; 180, subscript; 180, 181; 180, 193; 181, list_comprehension; 181, 182; 181, 183; 181, 191; 182, identifier:i; 183, for_in_clause; 183, 184; 183, 187; 184, pattern_list; 184, 185; 184, 186; 185, identifier:i; 186, identifier:b; 187, call; 187, 188; 187, 189; 188, identifier:enumerate; 189, argument_list; 189, 190; 190, identifier:strmask; 191, if_clause; 191, 192; 192, identifier:b; 193, slice; 193, 194; 193, 195; 194, colon; 195, integer:1; 196, identifier:col; 197, raise_statement; 198, except_clause; 198, 199; 198, 202; 199, tuple; 199, 200; 199, 201; 200, identifier:UnicodeDecodeError; 201, identifier:UnicodeEncodeError; 202, block; 202, 203; 203, try_statement; 203, 204; 203, 227; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:series; 209, identifier:strmask; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:np; 213, identifier:array; 214, argument_list; 214, 215; 215, list_comprehension; 215, 216; 215, 222; 216, call; 216, 217; 216, 218; 217, identifier:eval; 218, argument_list; 218, 219; 218, 220; 218, 221; 219, identifier:s; 220, dictionary; 221, dictionary; 222, for_in_clause; 222, 223; 222, 224; 223, identifier:s; 224, subscript; 224, 225; 224, 226; 225, identifier:series; 226, identifier:strmask; 227, except_clause; 227, 228; 227, 232; 228, tuple; 228, 229; 228, 230; 228, 231; 229, identifier:SyntaxError; 230, identifier:UnicodeDecodeError; 231, identifier:UnicodeEncodeError; 232, block; 232, 233; 232, 237; 232, 282; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:newseries; 236, list:[]; 237, for_statement; 237, 238; 237, 239; 237, 242; 238, identifier:s; 239, subscript; 239, 240; 239, 241; 240, identifier:series; 241, identifier:strmask; 242, block; 242, 243; 243, try_statement; 243, 244; 243, 255; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, augmented_assignment:+=; 246, 247; 246, 248; 247, identifier:newseries; 248, list:[s.encode('utf8')]; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:s; 252, identifier:encode; 253, argument_list; 253, 254; 254, string:'utf8'; 255, except_clause; 255, 256; 256, block; 256, 257; 256, 274; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:print; 260, argument_list; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, string:u'Had trouble encoding {} so used repr to turn it into {}'; 264, identifier:format; 265, argument_list; 265, 266; 265, 267; 266, identifier:s; 267, call; 267, 268; 267, 269; 268, identifier:repr; 269, argument_list; 269, 270; 270, call; 270, 271; 270, 272; 271, identifier:transcode_unicode; 272, argument_list; 272, 273; 273, identifier:s; 274, expression_statement; 274, 275; 275, augmented_assignment:+=; 275, 276; 275, 277; 276, identifier:newseries; 277, list:[transcode_unicode(s)]; 277, 278; 278, call; 278, 279; 278, 280; 279, identifier:transcode_unicode; 280, argument_list; 280, 281; 281, identifier:s; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:series; 286, identifier:strmask; 287, call; 287, 288; 287, 296; 288, attribute; 288, 289; 288, 295; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:np; 292, identifier:array; 293, argument_list; 293, 294; 294, identifier:newseries; 295, identifier:astype; 296, argument_list; 296, 297; 297, string:'O'; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 303; 300, subscript; 300, 301; 300, 302; 301, identifier:df; 302, identifier:col; 303, identifier:series; 304, if_statement; 304, 305; 304, 306; 305, identifier:verbosity; 306, block; 306, 307; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:pbar; 311, identifier:finish; 312, argument_list; 313, return_statement; 313, 314; 314, identifier:df | def encode(df, encoding='utf8', verbosity=1):
if verbosity > 0:
pbar = progressbar.ProgressBar(maxval=df.shape[1])
pbar.start()
for colnum, col in enumerate(df.columns):
if isinstance(df[col], pd.Series):
if verbosity:
pbar.update(colnum)
if df[col].dtype in (np.dtype('object'), np.dtype('U'), np.dtype('S')) and any(isinstance(obj, basestring) for obj in df[col]):
strmask = np.array([isinstance(obj, basestring) for obj in df[col]])
series = df[col].copy()
try:
series[strmask] = np.char.encode(series[strmask].values.astype('U'))
except TypeError:
print("Unable to convert {} elements starting at position {} in column {}".format(
sum(strmask), [i for i, b in enumerate(strmask) if b][:1], col))
raise
except (UnicodeDecodeError, UnicodeEncodeError):
try:
series[strmask] = np.array([eval(s, {}, {}) for s in series[strmask]])
except (SyntaxError, UnicodeDecodeError, UnicodeEncodeError):
newseries = []
for s in series[strmask]:
try:
newseries += [s.encode('utf8')]
except:
print(u'Had trouble encoding {} so used repr to turn it into {}'.format(s, repr(transcode_unicode(s))))
newseries += [transcode_unicode(s)]
series[strmask] = np.array(newseries).astype('O')
df[col] = series
if verbosity:
pbar.finish()
return df |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:data_worker; 3, parameters; 3, 4; 4, dictionary_splat_pattern; 4, 5; 5, identifier:kwargs; 6, block; 6, 7; 6, 181; 6, 185; 7, if_statement; 7, 8; 7, 11; 7, 174; 8, comparison_operator:is; 8, 9; 8, 10; 9, identifier:kwargs; 10, None; 11, block; 11, 12; 11, 30; 11, 48; 11, 66; 11, 94; 11, 137; 12, if_statement; 12, 13; 12, 16; 12, 23; 13, comparison_operator:in; 13, 14; 13, 15; 14, string:"function"; 15, identifier:kwargs; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:function; 20, subscript; 20, 21; 20, 22; 21, identifier:kwargs; 22, string:"function"; 23, else_clause; 23, 24; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:Exception; 28, argument_list; 28, 29; 29, string:"Invalid arguments, no function specified"; 30, if_statement; 30, 31; 30, 34; 30, 41; 31, comparison_operator:in; 31, 32; 31, 33; 32, string:"input"; 33, identifier:kwargs; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:input_queue; 38, subscript; 38, 39; 38, 40; 39, identifier:kwargs; 40, string:"input"; 41, else_clause; 41, 42; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:Exception; 46, argument_list; 46, 47; 47, string:"Invalid Arguments, no input queue"; 48, if_statement; 48, 49; 48, 52; 48, 59; 49, comparison_operator:in; 49, 50; 49, 51; 50, string:"output"; 51, identifier:kwargs; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:output_map; 56, subscript; 56, 57; 56, 58; 57, identifier:kwargs; 58, string:"output"; 59, else_clause; 59, 60; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:Exception; 64, argument_list; 64, 65; 65, string:"Invalid Arguments, no output map"; 66, if_statement; 66, 67; 66, 70; 66, 80; 67, comparison_operator:in; 67, 68; 67, 69; 68, string:"token"; 69, identifier:kwargs; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:argsdict; 74, dictionary; 74, 75; 75, pair; 75, 76; 75, 77; 76, string:"quandl_token"; 77, subscript; 77, 78; 77, 79; 78, identifier:kwargs; 79, string:"token"; 80, else_clause; 80, 81; 81, block; 81, 82; 82, if_statement; 82, 83; 82, 88; 83, comparison_operator:in; 83, 84; 83, 85; 84, string:"Quandl"; 85, attribute; 85, 86; 85, 87; 86, identifier:function; 87, identifier:__module__; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:Exception; 92, argument_list; 92, 93; 93, string:"Invalid Arguments, no Quandl token"; 94, if_statement; 94, 95; 94, 103; 94, 123; 95, comparison_operator:in; 95, 96; 95, 102; 96, parenthesized_expression; 96, 97; 97, boolean_operator:and; 97, 98; 97, 101; 98, boolean_operator:and; 98, 99; 98, 100; 99, string:"source"; 100, string:"begin"; 101, string:"end"; 102, identifier:kwargs; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:argsdict; 107, dictionary; 107, 108; 107, 113; 107, 118; 108, pair; 108, 109; 108, 110; 109, string:"data_source"; 110, subscript; 110, 111; 110, 112; 111, identifier:kwargs; 112, string:"source"; 113, pair; 113, 114; 113, 115; 114, string:"begin"; 115, subscript; 115, 116; 115, 117; 116, identifier:kwargs; 117, string:"begin"; 118, pair; 118, 119; 118, 120; 119, string:"end"; 120, subscript; 120, 121; 120, 122; 121, identifier:kwargs; 122, string:"end"; 123, else_clause; 123, 124; 124, block; 124, 125; 125, if_statement; 125, 126; 125, 131; 126, comparison_operator:in; 126, 127; 126, 128; 127, string:"pandas.io.data"; 128, attribute; 128, 129; 128, 130; 129, identifier:function; 130, identifier:__module__; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:Exception; 135, argument_list; 135, 136; 136, string:"Invalid Arguments, no pandas data source specified"; 137, if_statement; 137, 138; 137, 150; 137, 160; 138, boolean_operator:and; 138, 139; 138, 143; 139, parenthesized_expression; 139, 140; 140, comparison_operator:in; 140, 141; 140, 142; 141, string:"source"; 142, identifier:kwargs; 143, parenthesized_expression; 143, 144; 144, comparison_operator:not; 144, 145; 144, 149; 145, parenthesized_expression; 145, 146; 146, boolean_operator:and; 146, 147; 146, 148; 147, string:"begin"; 148, string:"end"; 149, identifier:kwargs; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:argsdict; 154, dictionary; 154, 155; 155, pair; 155, 156; 155, 157; 156, string:"data_source"; 157, subscript; 157, 158; 157, 159; 158, identifier:kwargs; 159, string:"source"; 160, else_clause; 160, 161; 161, block; 161, 162; 162, if_statement; 162, 163; 162, 168; 163, comparison_operator:in; 163, 164; 163, 165; 164, string:"pandas.io.data"; 165, attribute; 165, 166; 165, 167; 166, identifier:function; 167, identifier:__module__; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:Exception; 172, argument_list; 172, 173; 173, string:"Invalid Arguments, no pandas data source specified"; 174, else_clause; 174, 175; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:Exception; 179, argument_list; 179, 180; 180, string:"Invalid Arguments"; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:retries; 184, integer:5; 185, while_statement; 185, 186; 185, 192; 186, not_operator; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:input_queue; 190, identifier:empty; 191, argument_list; 192, block; 192, 193; 192, 201; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:data_key; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:input_queue; 199, identifier:get; 200, argument_list; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:get_data; 204, argument_list; 204, 205; 204, 206; 204, 207; 204, 208; 204, 209; 205, identifier:function; 206, identifier:data_key; 207, identifier:output_map; 208, identifier:retries; 209, identifier:argsdict | def data_worker(**kwargs):
if kwargs is not None:
if "function" in kwargs:
function = kwargs["function"]
else:
Exception("Invalid arguments, no function specified")
if "input" in kwargs:
input_queue = kwargs["input"]
else:
Exception("Invalid Arguments, no input queue")
if "output" in kwargs:
output_map = kwargs["output"]
else:
Exception("Invalid Arguments, no output map")
if "token" in kwargs:
argsdict = {"quandl_token": kwargs["token"]}
else:
if "Quandl" in function.__module__:
Exception("Invalid Arguments, no Quandl token")
if ("source" and "begin" and "end") in kwargs:
argsdict = {"data_source": kwargs["source"], "begin": kwargs["begin"], "end": kwargs["end"]}
else:
if "pandas.io.data" in function.__module__:
Exception("Invalid Arguments, no pandas data source specified")
if ("source" in kwargs) and (("begin" and "end") not in kwargs):
argsdict = {"data_source": kwargs["source"]}
else:
if "pandas.io.data" in function.__module__:
Exception("Invalid Arguments, no pandas data source specified")
else:
Exception("Invalid Arguments")
retries = 5
while not input_queue.empty():
data_key = input_queue.get()
get_data(function, data_key, output_map, retries, argsdict) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:makeproperty; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:ns; 5, default_parameter; 5, 6; 5, 7; 6, identifier:cls; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:name; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:docstring; 13, string:''; 14, default_parameter; 14, 15; 14, 16; 15, identifier:descendant; 16, True; 17, block; 17, 18; 17, 111; 17, 248; 17, 313; 18, function_definition; 18, 19; 18, 20; 18, 22; 19, function_name:get_property; 20, parameters; 20, 21; 21, identifier:self; 22, block; 22, 23; 22, 48; 22, 64; 23, if_statement; 23, 24; 23, 27; 23, 36; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:cls; 26, None; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:xpath; 31, binary_operator:%; 31, 32; 31, 33; 32, string:'%s:%s'; 33, tuple; 33, 34; 33, 35; 34, identifier:ns; 35, identifier:name; 36, else_clause; 36, 37; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:xpath; 41, binary_operator:%; 41, 42; 41, 43; 42, string:'%s:%s'; 43, tuple; 43, 44; 43, 45; 44, identifier:ns; 45, attribute; 45, 46; 45, 47; 46, identifier:cls; 47, identifier:__name__; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:xpath; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_node; 56, identifier:xpath; 57, argument_list; 57, 58; 57, 59; 58, identifier:xpath; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:namespaces; 61, attribute; 61, 62; 61, 63; 62, identifier:SLDNode; 63, identifier:_nsmap; 64, if_statement; 64, 65; 64, 71; 64, 107; 65, comparison_operator:==; 65, 66; 65, 70; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:xpath; 70, integer:1; 71, block; 71, 72; 72, if_statement; 72, 73; 72, 76; 72, 83; 73, comparison_operator:is; 73, 74; 73, 75; 74, identifier:cls; 75, None; 76, block; 76, 77; 77, return_statement; 77, 78; 78, attribute; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:xpath; 81, integer:0; 82, identifier:text; 83, else_clause; 83, 84; 84, block; 84, 85; 84, 94; 84, 105; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:elem; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:cls; 91, identifier:__new__; 92, argument_list; 92, 93; 93, identifier:cls; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:cls; 98, identifier:__init__; 99, argument_list; 99, 100; 99, 101; 99, 102; 100, identifier:elem; 101, identifier:self; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:descendant; 104, identifier:descendant; 105, return_statement; 105, 106; 106, identifier:elem; 107, else_clause; 107, 108; 108, block; 108, 109; 109, return_statement; 109, 110; 110, None; 111, function_definition; 111, 112; 111, 113; 111, 116; 112, function_name:set_property; 113, parameters; 113, 114; 113, 115; 114, identifier:self; 115, identifier:value; 116, block; 116, 117; 116, 142; 116, 158; 117, if_statement; 117, 118; 117, 121; 117, 130; 118, comparison_operator:is; 118, 119; 118, 120; 119, identifier:cls; 120, None; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:xpath; 125, binary_operator:%; 125, 126; 125, 127; 126, string:'%s:%s'; 127, tuple; 127, 128; 127, 129; 128, identifier:ns; 129, identifier:name; 130, else_clause; 130, 131; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:xpath; 135, binary_operator:%; 135, 136; 135, 137; 136, string:'%s:%s'; 137, tuple; 137, 138; 137, 139; 138, identifier:ns; 139, attribute; 139, 140; 139, 141; 140, identifier:cls; 141, identifier:__name__; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:xpath; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_node; 150, identifier:xpath; 151, argument_list; 151, 152; 151, 153; 152, identifier:xpath; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:namespaces; 155, attribute; 155, 156; 155, 157; 156, identifier:SLDNode; 157, identifier:_nsmap; 158, if_statement; 158, 159; 158, 165; 158, 189; 159, comparison_operator:==; 159, 160; 159, 164; 160, call; 160, 161; 160, 162; 161, identifier:len; 162, argument_list; 162, 163; 163, identifier:xpath; 164, integer:1; 165, block; 165, 166; 166, if_statement; 166, 167; 166, 170; 166, 179; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:cls; 169, None; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 178; 173, attribute; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:xpath; 176, integer:0; 177, identifier:text; 178, identifier:value; 179, else_clause; 179, 180; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:xpath; 185, integer:0; 186, attribute; 186, 187; 186, 188; 187, identifier:value; 188, identifier:_node; 189, else_clause; 189, 190; 190, block; 190, 191; 191, if_statement; 191, 192; 191, 195; 191, 235; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:cls; 194, None; 195, block; 195, 196; 195, 220; 195, 226; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:elem; 199, call; 199, 200; 199, 205; 200, attribute; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:_node; 204, identifier:makeelement; 205, argument_list; 205, 206; 205, 215; 206, binary_operator:%; 206, 207; 206, 208; 207, string:'{%s}%s'; 208, tuple; 208, 209; 208, 214; 209, subscript; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:SLDNode; 212, identifier:_nsmap; 213, identifier:ns; 214, identifier:name; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:nsmap; 217, attribute; 217, 218; 217, 219; 218, identifier:SLDNode; 219, identifier:_nsmap; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:elem; 224, identifier:text; 225, identifier:value; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:_node; 232, identifier:append; 233, argument_list; 233, 234; 234, identifier:elem; 235, else_clause; 235, 236; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 244; 239, attribute; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:self; 242, identifier:_node; 243, identifier:append; 244, argument_list; 244, 245; 245, attribute; 245, 246; 245, 247; 246, identifier:value; 247, identifier:_node; 248, function_definition; 248, 249; 248, 250; 248, 252; 249, function_name:del_property; 250, parameters; 250, 251; 251, identifier:self; 252, block; 252, 253; 252, 278; 252, 294; 253, if_statement; 253, 254; 253, 257; 253, 266; 254, comparison_operator:is; 254, 255; 254, 256; 255, identifier:cls; 256, None; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:xpath; 261, binary_operator:%; 261, 262; 261, 263; 262, string:'%s:%s'; 263, tuple; 263, 264; 263, 265; 264, identifier:ns; 265, identifier:name; 266, else_clause; 266, 267; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:xpath; 271, binary_operator:%; 271, 272; 271, 273; 272, string:'%s:%s'; 273, tuple; 273, 274; 273, 275; 274, identifier:ns; 275, attribute; 275, 276; 275, 277; 276, identifier:cls; 277, identifier:__name__; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:xpath; 281, call; 281, 282; 281, 287; 282, attribute; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:self; 285, identifier:_node; 286, identifier:xpath; 287, argument_list; 287, 288; 287, 289; 288, identifier:xpath; 289, keyword_argument; 289, 290; 289, 291; 290, identifier:namespaces; 291, attribute; 291, 292; 291, 293; 292, identifier:SLDNode; 293, identifier:_nsmap; 294, if_statement; 294, 295; 294, 301; 295, comparison_operator:==; 295, 296; 295, 300; 296, call; 296, 297; 296, 298; 297, identifier:len; 298, argument_list; 298, 299; 299, identifier:xpath; 300, integer:1; 301, block; 301, 302; 302, expression_statement; 302, 303; 303, call; 303, 304; 303, 309; 304, attribute; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:self; 307, identifier:_node; 308, identifier:remove; 309, argument_list; 309, 310; 310, subscript; 310, 311; 310, 312; 311, identifier:xpath; 312, integer:0; 313, return_statement; 313, 314; 314, call; 314, 315; 314, 316; 315, identifier:property; 316, argument_list; 316, 317; 316, 318; 316, 319; 316, 320; 317, identifier:get_property; 318, identifier:set_property; 319, identifier:del_property; 320, identifier:docstring | def makeproperty(ns, cls=None, name=None, docstring='', descendant=True):
def get_property(self):
if cls is None:
xpath = '%s:%s' % (ns, name)
else:
xpath = '%s:%s' % (ns, cls.__name__)
xpath = self._node.xpath(xpath, namespaces=SLDNode._nsmap)
if len(xpath) == 1:
if cls is None:
return xpath[0].text
else:
elem = cls.__new__(cls)
cls.__init__(elem, self, descendant=descendant)
return elem
else:
return None
def set_property(self, value):
if cls is None:
xpath = '%s:%s' % (ns, name)
else:
xpath = '%s:%s' % (ns, cls.__name__)
xpath = self._node.xpath(xpath, namespaces=SLDNode._nsmap)
if len(xpath) == 1:
if cls is None:
xpath[0].text = value
else:
xpath[0] = value._node
else:
if cls is None:
elem = self._node.makeelement('{%s}%s' % (SLDNode._nsmap[ns], name), nsmap=SLDNode._nsmap)
elem.text = value
self._node.append(elem)
else:
self._node.append(value._node)
def del_property(self):
if cls is None:
xpath = '%s:%s' % (ns, name)
else:
xpath = '%s:%s' % (ns, cls.__name__)
xpath = self._node.xpath(xpath, namespaces=SLDNode._nsmap)
if len(xpath) == 1:
self._node.remove(xpath[0])
return property(get_property, set_property, del_property, docstring) |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 43; 1, 144; 1, 161; 1, 220; 2, function_definition; 2, 3; 2, 4; 2, 6; 2, 38; 3, function_name:_parse_from_string; 4, parameters; 4, 5; 5, identifier:string_input; 6, ERROR; 6, 7; 6, 23; 6, 28; 6, 29; 6, 37; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:read_lines; 10, call; 10, 11; 10, 12; 11, identifier:list; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:filter; 15, argument_list; 15, 16; 15, 17; 16, None; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:string_input; 20, identifier:split; 21, argument_list; 21, 22; 22, string:'\n'; 23, attribute; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:read_lines; 26, integer:0; 27, identifier:startswith; 28, ERROR; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:comment; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:read_lines; 34, identifier:pop; 35, argument_list; 35, 36; 36, integer:0; 37, identifier:else; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:comment; 42, string:''; 43, if_statement; 43, 44; 43, 50; 43, 66; 44, comparison_operator:>; 44, 45; 44, 49; 45, call; 45, 46; 45, 47; 46, identifier:len; 47, argument_list; 47, 48; 48, identifier:read_lines; 49, integer:1; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:order; 54, call; 54, 55; 54, 56; 55, identifier:int; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:math; 60, identifier:sqrt; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:len; 64, argument_list; 64, 65; 65, identifier:read_lines; 66, else_clause; 66, 67; 67, block; 67, 68; 67, 90; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:order; 71, call; 71, 72; 71, 73; 72, identifier:int; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:math; 77, identifier:sqrt; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:math; 82, identifier:sqrt; 83, argument_list; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, subscript; 87, 88; 87, 89; 88, identifier:read_lines; 89, integer:0; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:read_lines; 93, call; 93, 94; 93, 95; 94, identifier:filter; 95, argument_list; 95, 96; 95, 108; 96, lambda; 96, 97; 96, 99; 97, lambda_parameters; 97, 98; 98, identifier:x; 99, comparison_operator:==; 99, 100; 99, 104; 100, call; 100, 101; 100, 102; 101, identifier:len; 102, argument_list; 102, 103; 103, identifier:x; 104, parenthesized_expression; 104, 105; 105, binary_operator:**; 105, 106; 105, 107; 106, identifier:order; 107, integer:2; 108, list_comprehension; 108, 109; 108, 122; 108, 135; 109, subscript; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:read_lines; 112, integer:0; 113, slice; 113, 114; 113, 115; 113, 116; 114, identifier:i; 115, colon; 116, parenthesized_expression; 116, 117; 117, binary_operator:+; 117, 118; 117, 119; 118, identifier:i; 119, binary_operator:**; 119, 120; 119, 121; 120, identifier:order; 121, integer:2; 122, for_in_clause; 122, 123; 122, 124; 123, identifier:i; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:utils; 127, identifier:range_; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, subscript; 132, 133; 132, 134; 133, identifier:read_lines; 134, integer:0; 135, if_clause; 135, 136; 136, comparison_operator:==; 136, 137; 136, 143; 137, binary_operator:%; 137, 138; 137, 139; 138, identifier:i; 139, parenthesized_expression; 139, 140; 140, binary_operator:**; 140, 141; 140, 142; 141, identifier:order; 142, integer:2; 143, integer:0; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:matrix; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:utils; 150, identifier:get_list_of_lists; 151, argument_list; 151, 152; 151, 155; 151, 158; 152, binary_operator:**; 152, 153; 152, 154; 153, identifier:order; 154, integer:2; 155, binary_operator:**; 155, 156; 155, 157; 156, identifier:order; 157, integer:2; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:fill_with; 160, integer:0; 161, for_statement; 161, 162; 161, 165; 161, 169; 162, pattern_list; 162, 163; 162, 164; 163, identifier:i; 164, identifier:line; 165, call; 165, 166; 165, 167; 166, identifier:enumerate; 167, argument_list; 167, 168; 168, identifier:read_lines; 169, block; 169, 170; 169, 178; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:line; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:line; 176, identifier:strip; 177, argument_list; 178, for_statement; 178, 179; 178, 182; 178, 186; 179, pattern_list; 179, 180; 179, 181; 180, identifier:j; 181, identifier:value; 182, call; 182, 183; 182, 184; 183, identifier:enumerate; 184, argument_list; 184, 185; 185, identifier:line; 186, block; 186, 187; 187, if_statement; 187, 188; 187, 198; 187, 210; 188, boolean_operator:and; 188, 189; 188, 194; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:value; 192, identifier:isdigit; 193, argument_list; 194, call; 194, 195; 194, 196; 195, identifier:int; 196, argument_list; 196, 197; 197, identifier:value; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 206; 201, subscript; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:matrix; 204, identifier:i; 205, identifier:j; 206, call; 206, 207; 206, 208; 207, identifier:int; 208, argument_list; 208, 209; 209, identifier:value; 210, else_clause; 210, 211; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 219; 214, subscript; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:matrix; 217, identifier:i; 218, identifier:j; 219, integer:0; 220, return_statement; 220, 221; 221, expression_list; 221, 222; 221, 223; 221, 224; 222, identifier:order; 223, identifier:comment; 224, identifier:matrix | def _parse_from_string(string_input):
read_lines = list(filter(None, string_input.split('\n')))
if read_lines[0].startswith('
comment = read_lines.pop(0)
else:
comment = ''
if len(read_lines) > 1:
order = int(math.sqrt(len(read_lines)))
else:
order = int(math.sqrt(math.sqrt(len(read_lines[0]))))
read_lines = filter(lambda x: len(x) == (order ** 2), [read_lines[0][i:(i + order ** 2)] for
i in utils.range_(len(read_lines[0])) if i % (order ** 2) == 0])
matrix = utils.get_list_of_lists(
order ** 2, order ** 2, fill_with=0)
for i, line in enumerate(read_lines):
line = line.strip()
for j, value in enumerate(line):
if value.isdigit() and int(value):
matrix[i][j] = int(value)
else:
matrix[i][j] = 0
return order, comment, matrix |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:solve; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:allow_brute_force; 10, True; 11, block; 11, 12; 11, 153; 12, while_statement; 12, 13; 12, 17; 13, not_operator; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:is_solved; 17, block; 17, 18; 17, 24; 17, 40; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_update; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:singles_found; 27, boolean_operator:or; 27, 28; 27, 35; 28, boolean_operator:or; 28, 29; 28, 30; 29, False; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_fill_naked_singles; 34, argument_list; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_fill_hidden_singles; 39, argument_list; 40, if_statement; 40, 41; 40, 43; 41, not_operator; 41, 42; 42, identifier:singles_found; 43, block; 43, 44; 44, if_statement; 44, 45; 44, 46; 44, 141; 45, identifier:allow_brute_force; 46, block; 46, 47; 46, 51; 46, 131; 46, 140; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:solution; 50, None; 51, try_statement; 51, 52; 51, 89; 51, 113; 51, 124; 52, block; 52, 53; 52, 67; 52, 75; 52, 82; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:dlxs; 56, call; 56, 57; 56, 58; 57, identifier:DancingLinksSolver; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:copy; 62, identifier:deepcopy; 63, argument_list; 63, 64; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_matrix; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:solutions; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:dlxs; 73, identifier:solve; 74, argument_list; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:solution; 78, call; 78, 79; 78, 80; 79, identifier:next; 80, argument_list; 80, 81; 81, identifier:solutions; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:more_solutions; 85, call; 85, 86; 85, 87; 86, identifier:next; 87, argument_list; 87, 88; 88, identifier:solutions; 89, except_clause; 89, 90; 89, 94; 90, as_pattern; 90, 91; 90, 92; 91, identifier:StopIteration; 92, as_pattern_target; 92, 93; 93, identifier:e; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 99; 95, 106; 96, comparison_operator:is; 96, 97; 96, 98; 97, identifier:solution; 98, None; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_matrix; 105, identifier:solution; 106, else_clause; 106, 107; 107, block; 107, 108; 108, raise_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:SudokuHasNoSolutionError; 111, argument_list; 111, 112; 112, string:"Dancing Links solver could not find any solution."; 113, except_clause; 113, 114; 113, 118; 114, as_pattern; 114, 115; 114, 116; 115, identifier:Exception; 116, as_pattern_target; 116, 117; 117, identifier:e; 118, block; 118, 119; 119, raise_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:SudokuHasNoSolutionError; 122, argument_list; 122, 123; 123, string:"Brute Force method failed."; 124, else_clause; 124, 125; 125, block; 125, 126; 126, raise_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:SudokuHasMultipleSolutionsError; 129, argument_list; 129, 130; 130, string:"This Sudoku has multiple solutions!"; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:solution_steps; 137, identifier:append; 138, argument_list; 138, 139; 139, string:"BRUTE FORCE - Dancing Links"; 140, break_statement; 141, else_clause; 141, 142; 142, block; 142, 143; 142, 148; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:print; 146, argument_list; 146, 147; 147, identifier:self; 148, raise_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:SudokuTooDifficultError; 151, argument_list; 151, 152; 152, string:"This Sudoku requires more advanced methods!"; 153, if_statement; 153, 154; 153, 155; 154, identifier:verbose; 155, block; 155, 156; 155, 172; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:print; 159, argument_list; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, string:"Sudoku solved in {0} iterations!\n{1}"; 163, identifier:format; 164, argument_list; 164, 165; 164, 171; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:solution_steps; 171, identifier:self; 172, for_statement; 172, 173; 172, 174; 172, 177; 173, identifier:step; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:solution_steps; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:print; 181, argument_list; 181, 182; 182, identifier:step | def solve(self, verbose=False, allow_brute_force=True):
while not self.is_solved:
self._update()
singles_found = False or self._fill_naked_singles() or self._fill_hidden_singles()
if not singles_found:
if allow_brute_force:
solution = None
try:
dlxs = DancingLinksSolver(copy.deepcopy(self._matrix))
solutions = dlxs.solve()
solution = next(solutions)
more_solutions = next(solutions)
except StopIteration as e:
if solution is not None:
self._matrix = solution
else:
raise SudokuHasNoSolutionError("Dancing Links solver could not find any solution.")
except Exception as e:
raise SudokuHasNoSolutionError("Brute Force method failed.")
else:
raise SudokuHasMultipleSolutionsError("This Sudoku has multiple solutions!")
self.solution_steps.append("BRUTE FORCE - Dancing Links")
break
else:
print(self)
raise SudokuTooDifficultError("This Sudoku requires more advanced methods!")
if verbose:
print("Sudoku solved in {0} iterations!\n{1}".format(len(self.solution_steps), self))
for step in self.solution_steps:
print(step) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_fill_hidden_singles; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 346; 6, for_statement; 6, 7; 6, 8; 6, 16; 7, identifier:i; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:utils; 11, identifier:range_; 12, argument_list; 12, 13; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:side; 16, block; 16, 17; 16, 30; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:box_i; 20, binary_operator:*; 20, 21; 20, 27; 21, parenthesized_expression; 21, 22; 22, binary_operator://; 22, 23; 22, 24; 23, identifier:i; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:order; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:order; 30, for_statement; 30, 31; 30, 32; 30, 40; 31, identifier:j; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:utils; 35, identifier:range_; 36, argument_list; 36, 37; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:side; 40, block; 40, 41; 40, 54; 40, 64; 40, 74; 40, 106; 40, 151; 40, 161; 40, 193; 40, 238; 40, 248; 40, 301; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:box_j; 44, binary_operator:*; 44, 45; 44, 51; 45, parenthesized_expression; 45, 46; 46, binary_operator://; 46, 47; 46, 48; 47, identifier:j; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:order; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:order; 54, if_statement; 54, 55; 54, 62; 55, comparison_operator:>; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:self; 59, identifier:i; 60, identifier:j; 61, integer:0; 62, block; 62, 63; 63, continue_statement; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:p; 67, subscript; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_possibles; 72, identifier:i; 73, identifier:j; 74, for_statement; 74, 75; 74, 76; 74, 84; 75, identifier:k; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:utils; 79, identifier:range_; 80, argument_list; 80, 81; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:side; 84, block; 84, 85; 84, 91; 85, if_statement; 85, 86; 85, 89; 86, comparison_operator:==; 86, 87; 86, 88; 87, identifier:k; 88, identifier:j; 89, block; 89, 90; 90, continue_statement; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:p; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:p; 97, identifier:difference; 98, argument_list; 98, 99; 99, subscript; 99, 100; 99, 105; 100, subscript; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_possibles; 104, identifier:i; 105, identifier:k; 106, if_statement; 106, 107; 106, 113; 107, comparison_operator:==; 107, 108; 107, 112; 108, call; 108, 109; 108, 110; 109, identifier:len; 110, argument_list; 110, 111; 111, identifier:p; 112, integer:1; 113, block; 113, 114; 113, 127; 113, 149; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:set_cell; 119, argument_list; 119, 120; 119, 121; 119, 122; 120, identifier:i; 121, identifier:j; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:p; 125, identifier:pop; 126, argument_list; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:solution_steps; 133, identifier:append; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:_format_step; 139, argument_list; 139, 140; 139, 141; 139, 144; 140, string:"HIDDEN-ROW"; 141, tuple; 141, 142; 141, 143; 142, identifier:i; 143, identifier:j; 144, subscript; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:self; 147, identifier:i; 148, identifier:j; 149, return_statement; 149, 150; 150, True; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:p; 154, subscript; 154, 155; 154, 160; 155, subscript; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:_possibles; 159, identifier:i; 160, identifier:j; 161, for_statement; 161, 162; 161, 163; 161, 171; 162, identifier:k; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:utils; 166, identifier:range_; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:side; 171, block; 171, 172; 171, 178; 172, if_statement; 172, 173; 172, 176; 173, comparison_operator:==; 173, 174; 173, 175; 174, identifier:k; 175, identifier:i; 176, block; 176, 177; 177, continue_statement; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:p; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:p; 184, identifier:difference; 185, argument_list; 185, 186; 186, subscript; 186, 187; 186, 192; 187, subscript; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:_possibles; 191, identifier:k; 192, identifier:j; 193, if_statement; 193, 194; 193, 200; 194, comparison_operator:==; 194, 195; 194, 199; 195, call; 195, 196; 195, 197; 196, identifier:len; 197, argument_list; 197, 198; 198, identifier:p; 199, integer:1; 200, block; 200, 201; 200, 214; 200, 236; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:set_cell; 206, argument_list; 206, 207; 206, 208; 206, 209; 207, identifier:i; 208, identifier:j; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:p; 212, identifier:pop; 213, argument_list; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 221; 216, attribute; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:self; 219, identifier:solution_steps; 220, identifier:append; 221, argument_list; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:_format_step; 226, argument_list; 226, 227; 226, 228; 226, 231; 227, string:"HIDDEN-COL"; 228, tuple; 228, 229; 228, 230; 229, identifier:i; 230, identifier:j; 231, subscript; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:self; 234, identifier:i; 235, identifier:j; 236, return_statement; 236, 237; 237, True; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:p; 241, subscript; 241, 242; 241, 247; 242, subscript; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:_possibles; 246, identifier:i; 247, identifier:j; 248, for_statement; 248, 249; 248, 250; 248, 261; 249, identifier:k; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:utils; 253, identifier:range_; 254, argument_list; 254, 255; 254, 256; 255, identifier:box_i; 256, binary_operator:+; 256, 257; 256, 258; 257, identifier:box_i; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:order; 261, block; 261, 262; 262, for_statement; 262, 263; 262, 264; 262, 275; 263, identifier:kk; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:utils; 267, identifier:range_; 268, argument_list; 268, 269; 268, 270; 269, identifier:box_j; 270, binary_operator:+; 270, 271; 270, 272; 271, identifier:box_j; 272, attribute; 272, 273; 272, 274; 273, identifier:self; 274, identifier:order; 275, block; 275, 276; 275, 286; 276, if_statement; 276, 277; 276, 284; 277, boolean_operator:and; 277, 278; 277, 281; 278, comparison_operator:==; 278, 279; 278, 280; 279, identifier:k; 280, identifier:i; 281, comparison_operator:==; 281, 282; 281, 283; 282, identifier:kk; 283, identifier:j; 284, block; 284, 285; 285, continue_statement; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:p; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:p; 292, identifier:difference; 293, argument_list; 293, 294; 294, subscript; 294, 295; 294, 300; 295, subscript; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:_possibles; 299, identifier:k; 300, identifier:kk; 301, if_statement; 301, 302; 301, 308; 302, comparison_operator:==; 302, 303; 302, 307; 303, call; 303, 304; 303, 305; 304, identifier:len; 305, argument_list; 305, 306; 306, identifier:p; 307, integer:1; 308, block; 308, 309; 308, 322; 308, 344; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:self; 313, identifier:set_cell; 314, argument_list; 314, 315; 314, 316; 314, 317; 315, identifier:i; 316, identifier:j; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:p; 320, identifier:pop; 321, argument_list; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 329; 324, attribute; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:self; 327, identifier:solution_steps; 328, identifier:append; 329, argument_list; 329, 330; 330, call; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:self; 333, identifier:_format_step; 334, argument_list; 334, 335; 334, 336; 334, 339; 335, string:"HIDDEN-BOX"; 336, tuple; 336, 337; 336, 338; 337, identifier:i; 338, identifier:j; 339, subscript; 339, 340; 339, 343; 340, subscript; 340, 341; 340, 342; 341, identifier:self; 342, identifier:i; 343, identifier:j; 344, return_statement; 344, 345; 345, True; 346, return_statement; 346, 347; 347, False | def _fill_hidden_singles(self):
for i in utils.range_(self.side):
box_i = (i // self.order) * self.order
for j in utils.range_(self.side):
box_j = (j // self.order) * self.order
if self[i][j] > 0:
continue
p = self._possibles[i][j]
for k in utils.range_(self.side):
if k == j:
continue
p = p.difference(self._possibles[i][k])
if len(p) == 1:
self.set_cell(i, j, p.pop())
self.solution_steps.append(self._format_step("HIDDEN-ROW", (i, j), self[i][j]))
return True
p = self._possibles[i][j]
for k in utils.range_(self.side):
if k == i:
continue
p = p.difference(self._possibles[k][j])
if len(p) == 1:
self.set_cell(i, j, p.pop())
self.solution_steps.append(self._format_step("HIDDEN-COL", (i, j), self[i][j]))
return True
p = self._possibles[i][j]
for k in utils.range_(box_i, box_i + self.order):
for kk in utils.range_(box_j, box_j + self.order):
if k == i and kk == j:
continue
p = p.difference(self._possibles[k][kk])
if len(p) == 1:
self.set_cell(i, j, p.pop())
self.solution_steps.append(self._format_step("HIDDEN-BOX", (i, j), self[i][j]))
return True
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:request; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, False; 9, block; 9, 10; 9, 27; 9, 35; 9, 46; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:field; 13, call; 13, 14; 13, 23; 14, attribute; 14, 15; 14, 22; 15, attribute; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:model; 20, identifier:_meta; 21, identifier:fields; 22, identifier:get; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:columns_sort; 27, if_statement; 27, 28; 27, 30; 28, not_operator; 28, 29; 29, identifier:field; 30, block; 30, 31; 31, return_statement; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:collection; 35, if_statement; 35, 36; 35, 37; 36, identifier:reverse; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:field; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:field; 44, identifier:desc; 45, argument_list; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:collection; 52, identifier:order_by; 53, argument_list; 53, 54; 54, identifier:field | def sort(self, request, reverse=False):
field = self.model._meta.fields.get(self.columns_sort)
if not field:
return self.collection
if reverse:
field = field.desc()
return self.collection.order_by(field) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:process_docstring; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:app; 5, identifier:what; 6, identifier:name; 7, identifier:obj; 8, identifier:options; 9, identifier:lines; 10, block; 10, 11; 10, 20; 10, 52; 10, 60; 10, 68; 10, 80; 10, 202; 10, 209; 10, 219; 10, 234; 10, 248; 10, 338; 10, 372; 10, 376; 10, 399; 10, 405; 10, 434; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:aliases; 14, call; 14, 15; 14, 16; 15, identifier:getattr; 16, argument_list; 16, 17; 16, 18; 16, 19; 17, identifier:app; 18, string:"_sigaliases"; 19, None; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:aliases; 23, None; 24, block; 24, 25; 25, if_statement; 25, 26; 25, 29; 26, comparison_operator:==; 26, 27; 26, 28; 27, identifier:what; 28, string:"module"; 29, block; 29, 30; 29, 46; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:aliases; 33, call; 33, 34; 33, 35; 34, identifier:get_aliases; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 45; 37, attribute; 37, 38; 37, 44; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:inspect; 41, identifier:getsource; 42, argument_list; 42, 43; 43, identifier:obj; 44, identifier:splitlines; 45, argument_list; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:app; 50, identifier:_sigaliases; 51, identifier:aliases; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:sig_marker; 55, binary_operator:+; 55, 56; 55, 59; 56, binary_operator:+; 56, 57; 56, 58; 57, string:":"; 58, identifier:SIG_FIELD; 59, string:":"; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:is_class; 63, comparison_operator:in; 63, 64; 63, 65; 64, identifier:what; 65, tuple; 65, 66; 65, 67; 66, string:"class"; 67, string:"exception"; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:signature; 71, call; 71, 72; 71, 73; 72, identifier:extract_signature; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, string:"\n"; 77, identifier:join; 78, argument_list; 78, 79; 79, identifier:lines; 80, if_statement; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:signature; 83, None; 84, block; 84, 85; 84, 90; 84, 98; 84, 104; 84, 116; 84, 150; 84, 156; 84, 160; 84, 190; 85, if_statement; 85, 86; 85, 88; 86, not_operator; 86, 87; 87, identifier:is_class; 88, block; 88, 89; 89, return_statement; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:init_method; 93, call; 93, 94; 93, 95; 94, identifier:getattr; 95, argument_list; 95, 96; 95, 97; 96, identifier:obj; 97, string:"__init__"; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:init_doc; 101, attribute; 101, 102; 101, 103; 102, identifier:init_method; 103, identifier:__doc__; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:init_lines; 107, subscript; 107, 108; 107, 113; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:init_doc; 111, identifier:splitlines; 112, argument_list; 113, slice; 113, 114; 113, 115; 114, integer:1; 115, colon; 116, if_statement; 116, 117; 116, 123; 117, comparison_operator:>; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:init_lines; 122, integer:1; 123, block; 123, 124; 123, 142; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:init_doc; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:textwrap; 130, identifier:dedent; 131, argument_list; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, string:"\n"; 135, identifier:join; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:init_lines; 139, slice; 139, 140; 139, 141; 140, integer:1; 141, colon; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:init_lines; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:init_doc; 148, identifier:splitlines; 149, argument_list; 150, if_statement; 150, 151; 150, 154; 151, comparison_operator:not; 151, 152; 151, 153; 152, identifier:sig_marker; 153, identifier:init_doc; 154, block; 154, 155; 155, return_statement; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:sig_started; 159, False; 160, for_statement; 160, 161; 160, 162; 160, 163; 161, identifier:line; 162, identifier:init_lines; 163, block; 163, 164; 163, 180; 164, if_statement; 164, 165; 164, 175; 165, call; 165, 166; 165, 173; 166, attribute; 166, 167; 166, 172; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:line; 170, identifier:lstrip; 171, argument_list; 172, identifier:startswith; 173, argument_list; 173, 174; 174, identifier:sig_marker; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:sig_started; 179, True; 180, if_statement; 180, 181; 180, 182; 181, identifier:sig_started; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:lines; 187, identifier:append; 188, argument_list; 188, 189; 189, identifier:line; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:signature; 193, call; 193, 194; 193, 195; 194, identifier:extract_signature; 195, argument_list; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, string:"\n"; 199, identifier:join; 200, argument_list; 200, 201; 201, identifier:lines; 202, if_statement; 202, 203; 202, 204; 203, identifier:is_class; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:obj; 208, identifier:init_method; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 215; 211, pattern_list; 211, 212; 211, 213; 211, 214; 212, identifier:param_types; 213, identifier:rtype; 214, identifier:_; 215, call; 215, 216; 215, 217; 216, identifier:parse_signature; 217, argument_list; 217, 218; 218, identifier:signature; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:param_names; 222, list_comprehension; 222, 223; 222, 224; 223, identifier:p; 224, for_in_clause; 224, 225; 224, 226; 225, identifier:p; 226, attribute; 226, 227; 226, 233; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:inspect; 230, identifier:signature; 231, argument_list; 231, 232; 232, identifier:obj; 233, identifier:parameters; 234, if_statement; 234, 235; 234, 243; 235, boolean_operator:and; 235, 236; 235, 237; 236, identifier:is_class; 237, parenthesized_expression; 237, 238; 238, comparison_operator:==; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:param_names; 241, integer:0; 242, string:"self"; 243, block; 243, 244; 244, delete_statement; 244, 245; 245, subscript; 245, 246; 245, 247; 246, identifier:param_names; 247, integer:0; 248, if_statement; 248, 249; 248, 258; 249, comparison_operator:==; 249, 250; 249, 254; 250, call; 250, 251; 250, 252; 251, identifier:len; 252, argument_list; 252, 253; 253, identifier:param_names; 254, call; 254, 255; 254, 256; 255, identifier:len; 256, argument_list; 256, 257; 257, identifier:param_types; 258, block; 258, 259; 259, for_statement; 259, 260; 259, 263; 259, 268; 260, pattern_list; 260, 261; 260, 262; 261, identifier:name; 262, identifier:type_; 263, call; 263, 264; 263, 265; 264, identifier:zip; 265, argument_list; 265, 266; 265, 267; 266, identifier:param_names; 267, identifier:param_types; 268, block; 268, 269; 268, 278; 268, 287; 268, 304; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:find; 272, binary_operator:%; 272, 273; 272, 274; 273, string:":param %(name)s:"; 274, dictionary; 274, 275; 275, pair; 275, 276; 275, 277; 276, string:"name"; 277, identifier:name; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:alias; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:aliases; 284, identifier:get; 285, argument_list; 285, 286; 286, identifier:type_; 287, if_statement; 287, 288; 287, 291; 288, comparison_operator:is; 288, 289; 288, 290; 289, identifier:alias; 290, None; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:type_; 295, binary_operator:%; 295, 296; 295, 297; 296, string:"*%(type)s* :sup:`%(alias)s`"; 297, dictionary; 297, 298; 297, 301; 298, pair; 298, 299; 298, 300; 299, string:"type"; 300, identifier:type_; 301, pair; 301, 302; 301, 303; 302, string:"alias"; 303, identifier:alias; 304, for_statement; 304, 305; 304, 308; 304, 312; 305, pattern_list; 305, 306; 305, 307; 306, identifier:i; 307, identifier:line; 308, call; 308, 309; 308, 310; 309, identifier:enumerate; 310, argument_list; 310, 311; 311, identifier:lines; 312, block; 312, 313; 313, if_statement; 313, 314; 313, 320; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:line; 317, identifier:startswith; 318, argument_list; 318, 319; 319, identifier:find; 320, block; 320, 321; 320, 337; 321, expression_statement; 321, 322; 322, call; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:lines; 325, identifier:insert; 326, argument_list; 326, 327; 326, 328; 327, identifier:i; 328, binary_operator:%; 328, 329; 328, 330; 329, string:":type %(name)s: %(type)s"; 330, dictionary; 330, 331; 330, 334; 331, pair; 331, 332; 331, 333; 332, string:"name"; 333, identifier:name; 334, pair; 334, 335; 334, 336; 335, string:"type"; 336, identifier:type_; 337, break_statement; 338, if_statement; 338, 339; 338, 341; 339, not_operator; 339, 340; 340, identifier:is_class; 341, block; 341, 342; 342, for_statement; 342, 343; 342, 346; 342, 350; 343, pattern_list; 343, 344; 343, 345; 344, identifier:i; 345, identifier:line; 346, call; 346, 347; 346, 348; 347, identifier:enumerate; 348, argument_list; 348, 349; 349, identifier:lines; 350, block; 350, 351; 351, if_statement; 351, 352; 351, 360; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:line; 355, identifier:startswith; 356, argument_list; 356, 357; 357, tuple; 357, 358; 357, 359; 358, string:":return:"; 359, string:":returns:"; 360, block; 360, 361; 360, 371; 361, expression_statement; 361, 362; 362, call; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:lines; 365, identifier:insert; 366, argument_list; 366, 367; 366, 368; 367, identifier:i; 368, binary_operator:+; 368, 369; 368, 370; 369, string:":rtype: "; 370, identifier:rtype; 371, break_statement; 372, expression_statement; 372, 373; 373, assignment; 373, 374; 373, 375; 374, identifier:sig_start; 375, integer:0; 376, while_statement; 376, 377; 376, 383; 377, comparison_operator:<; 377, 378; 377, 379; 378, identifier:sig_start; 379, call; 379, 380; 379, 381; 380, identifier:len; 381, argument_list; 381, 382; 382, identifier:lines; 383, block; 383, 384; 383, 395; 384, if_statement; 384, 385; 384, 393; 385, call; 385, 386; 385, 391; 386, attribute; 386, 387; 386, 390; 387, subscript; 387, 388; 387, 389; 388, identifier:lines; 389, identifier:sig_start; 390, identifier:startswith; 391, argument_list; 391, 392; 392, identifier:sig_marker; 393, block; 393, 394; 394, break_statement; 395, expression_statement; 395, 396; 396, augmented_assignment:+=; 396, 397; 396, 398; 397, identifier:sig_start; 398, integer:1; 399, expression_statement; 399, 400; 400, assignment; 400, 401; 400, 402; 401, identifier:sig_end; 402, binary_operator:+; 402, 403; 402, 404; 403, identifier:sig_start; 404, integer:1; 405, while_statement; 405, 406; 405, 412; 406, comparison_operator:<; 406, 407; 406, 408; 407, identifier:sig_end; 408, call; 408, 409; 408, 410; 409, identifier:len; 410, argument_list; 410, 411; 411, identifier:lines; 412, block; 412, 413; 412, 430; 413, if_statement; 413, 414; 413, 428; 414, boolean_operator:or; 414, 415; 414, 420; 415, parenthesized_expression; 415, 416; 416, not_operator; 416, 417; 417, subscript; 417, 418; 417, 419; 418, identifier:lines; 419, identifier:sig_end; 420, parenthesized_expression; 420, 421; 421, comparison_operator:!=; 421, 422; 421, 427; 422, subscript; 422, 423; 422, 426; 423, subscript; 423, 424; 423, 425; 424, identifier:lines; 425, identifier:sig_end; 426, integer:0; 427, string:" "; 428, block; 428, 429; 429, break_statement; 430, expression_statement; 430, 431; 431, augmented_assignment:+=; 431, 432; 431, 433; 432, identifier:sig_end; 433, integer:1; 434, for_statement; 434, 435; 434, 436; 434, 444; 435, identifier:i; 436, call; 436, 437; 436, 438; 437, identifier:reversed; 438, argument_list; 438, 439; 439, call; 439, 440; 439, 441; 440, identifier:range; 441, argument_list; 441, 442; 441, 443; 442, identifier:sig_start; 443, identifier:sig_end; 444, block; 444, 445; 445, delete_statement; 445, 446; 446, subscript; 446, 447; 446, 448; 447, identifier:lines; 448, identifier:i | def process_docstring(app, what, name, obj, options, lines):
aliases = getattr(app, "_sigaliases", None)
if aliases is None:
if what == "module":
aliases = get_aliases(inspect.getsource(obj).splitlines())
app._sigaliases = aliases
sig_marker = ":" + SIG_FIELD + ":"
is_class = what in ("class", "exception")
signature = extract_signature("\n".join(lines))
if signature is None:
if not is_class:
return
init_method = getattr(obj, "__init__")
init_doc = init_method.__doc__
init_lines = init_doc.splitlines()[1:]
if len(init_lines) > 1:
init_doc = textwrap.dedent("\n".join(init_lines[1:]))
init_lines = init_doc.splitlines()
if sig_marker not in init_doc:
return
sig_started = False
for line in init_lines:
if line.lstrip().startswith(sig_marker):
sig_started = True
if sig_started:
lines.append(line)
signature = extract_signature("\n".join(lines))
if is_class:
obj = init_method
param_types, rtype, _ = parse_signature(signature)
param_names = [p for p in inspect.signature(obj).parameters]
if is_class and (param_names[0] == "self"):
del param_names[0]
if len(param_names) == len(param_types):
for name, type_ in zip(param_names, param_types):
find = ":param %(name)s:" % {"name": name}
alias = aliases.get(type_)
if alias is not None:
type_ = "*%(type)s* :sup:`%(alias)s`" % {"type": type_, "alias": alias}
for i, line in enumerate(lines):
if line.startswith(find):
lines.insert(i, ":type %(name)s: %(type)s" % {"name": name, "type": type_})
break
if not is_class:
for i, line in enumerate(lines):
if line.startswith((":return:", ":returns:")):
lines.insert(i, ":rtype: " + rtype)
break
sig_start = 0
while sig_start < len(lines):
if lines[sig_start].startswith(sig_marker):
break
sig_start += 1
sig_end = sig_start + 1
while sig_end < len(lines):
if (not lines[sig_end]) or (lines[sig_end][0] != " "):
break
sig_end += 1
for i in reversed(range(sig_start, sig_end)):
del lines[i] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:main; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:argv; 6, None; 7, block; 7, 8; 7, 17; 7, 32; 7, 45; 7, 68; 7, 85; 7, 101; 7, 114; 7, 125; 7, 138; 7, 161; 7, 174; 7, 202; 7, 206; 7, 314; 7, 331; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:parser; 11, call; 11, 12; 11, 13; 12, identifier:ArgumentParser; 13, argument_list; 13, 14; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:prog; 16, string:"pygenstub"; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:parser; 21, identifier:add_argument; 22, argument_list; 22, 23; 22, 24; 22, 27; 23, string:"--version"; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:action; 26, string:"version"; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:version; 29, binary_operator:+; 29, 30; 29, 31; 30, string:"%(prog)s "; 31, identifier:__version__; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:parser; 36, identifier:add_argument; 37, argument_list; 37, 38; 37, 39; 37, 42; 38, string:"files"; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:nargs; 41, string:"*"; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:help; 44, string:"generate stubs for given files"; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:parser; 49, identifier:add_argument; 50, argument_list; 50, 51; 50, 52; 50, 53; 50, 56; 50, 59; 50, 62; 50, 65; 51, string:"-m"; 52, string:"--module"; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:action; 55, string:"append"; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:metavar; 58, string:"MODULE"; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:dest; 61, string:"modules"; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:default; 64, list:[]; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:help; 67, string:"generate stubs for given modules"; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:parser; 72, identifier:add_argument; 73, argument_list; 73, 74; 73, 75; 73, 76; 73, 79; 73, 82; 74, string:"-o"; 75, string:"--output"; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:metavar; 78, string:"PATH"; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:dest; 81, string:"out_dir"; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:help; 84, string:"change the output directory"; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:parser; 89, identifier:add_argument; 90, argument_list; 90, 91; 90, 92; 90, 95; 90, 98; 91, string:"--generic"; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:action; 94, string:"store_true"; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:default; 97, False; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:help; 100, string:"generate generic stubs"; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:parser; 105, identifier:add_argument; 106, argument_list; 106, 107; 106, 108; 106, 111; 107, string:"--debug"; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:action; 110, string:"store_true"; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:help; 113, string:"enable debug messages"; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:argv; 117, conditional_expression:if; 117, 118; 117, 119; 117, 122; 118, identifier:argv; 119, comparison_operator:is; 119, 120; 119, 121; 120, identifier:argv; 121, None; 122, attribute; 122, 123; 122, 124; 123, identifier:sys; 124, identifier:argv; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:arguments; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:parser; 131, identifier:parse_args; 132, argument_list; 132, 133; 133, subscript; 133, 134; 133, 135; 134, identifier:argv; 135, slice; 135, 136; 135, 137; 136, integer:1; 137, colon; 138, if_statement; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:arguments; 141, identifier:debug; 142, block; 142, 143; 142, 154; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:logging; 147, identifier:basicConfig; 148, argument_list; 148, 149; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:level; 151, attribute; 151, 152; 151, 153; 152, identifier:logging; 153, identifier:DEBUG; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:_logger; 158, identifier:debug; 159, argument_list; 159, 160; 160, string:"running in debug mode"; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:out_dir; 164, conditional_expression:if; 164, 165; 164, 168; 164, 173; 165, attribute; 165, 166; 165, 167; 166, identifier:arguments; 167, identifier:out_dir; 168, comparison_operator:is; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:arguments; 171, identifier:out_dir; 172, None; 173, string:""; 174, if_statement; 174, 175; 174, 189; 175, boolean_operator:and; 175, 176; 175, 180; 176, parenthesized_expression; 176, 177; 177, comparison_operator:==; 177, 178; 177, 179; 178, identifier:out_dir; 179, string:""; 180, parenthesized_expression; 180, 181; 181, comparison_operator:>; 181, 182; 181, 188; 182, call; 182, 183; 182, 184; 183, identifier:len; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:arguments; 187, identifier:modules; 188, integer:0; 189, block; 189, 190; 189, 195; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:print; 193, argument_list; 193, 194; 194, string:"Output directory must be given when generating stubs for modules."; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:sys; 199, identifier:exit; 200, argument_list; 200, 201; 201, integer:1; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:modules; 205, list:[]; 206, for_statement; 206, 207; 206, 208; 206, 211; 207, identifier:path; 208, attribute; 208, 209; 208, 210; 209, identifier:arguments; 210, identifier:files; 211, block; 211, 212; 211, 238; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:paths; 215, conditional_expression:if; 215, 216; 215, 225; 215, 233; 216, call; 216, 217; 216, 223; 217, attribute; 217, 218; 217, 222; 218, call; 218, 219; 218, 220; 219, identifier:Path; 220, argument_list; 220, 221; 221, identifier:path; 222, identifier:glob; 223, argument_list; 223, 224; 224, string:"**/*.py"; 225, call; 225, 226; 225, 232; 226, attribute; 226, 227; 226, 231; 227, call; 227, 228; 227, 229; 228, identifier:Path; 229, argument_list; 229, 230; 230, identifier:path; 231, identifier:is_dir; 232, argument_list; 233, list:[Path(path)]; 233, 234; 234, call; 234, 235; 234, 236; 235, identifier:Path; 236, argument_list; 236, 237; 237, identifier:path; 238, for_statement; 238, 239; 238, 240; 238, 241; 239, identifier:source; 240, identifier:paths; 241, block; 241, 242; 241, 269; 241, 292; 241, 305; 242, if_statement; 242, 243; 242, 256; 243, call; 243, 244; 243, 250; 244, attribute; 244, 245; 244, 249; 245, call; 245, 246; 245, 247; 246, identifier:str; 247, argument_list; 247, 248; 248, identifier:source; 249, identifier:startswith; 250, argument_list; 250, 251; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:os; 254, identifier:path; 255, identifier:pardir; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:source; 260, call; 260, 261; 260, 268; 261, attribute; 261, 262; 261, 267; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:source; 265, identifier:absolute; 266, argument_list; 267, identifier:resolve; 268, argument_list; 269, if_statement; 269, 270; 269, 280; 270, boolean_operator:and; 270, 271; 270, 275; 271, parenthesized_expression; 271, 272; 272, comparison_operator:!=; 272, 273; 272, 274; 273, identifier:out_dir; 274, string:""; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:source; 278, identifier:is_absolute; 279, argument_list; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:source; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:source; 287, identifier:relative_to; 288, argument_list; 288, 289; 289, attribute; 289, 290; 289, 291; 290, identifier:source; 291, identifier:root; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:destination; 295, call; 295, 296; 295, 297; 296, identifier:Path; 297, argument_list; 297, 298; 297, 299; 298, identifier:out_dir; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:source; 302, identifier:with_suffix; 303, argument_list; 303, 304; 304, string:".pyi"; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:modules; 309, identifier:append; 310, argument_list; 310, 311; 311, tuple; 311, 312; 311, 313; 312, identifier:source; 313, identifier:destination; 314, for_statement; 314, 315; 314, 316; 314, 319; 315, identifier:mod_name; 316, attribute; 316, 317; 316, 318; 317, identifier:arguments; 318, identifier:modules; 319, block; 319, 320; 320, expression_statement; 320, 321; 321, call; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:modules; 324, identifier:extend; 325, argument_list; 325, 326; 326, call; 326, 327; 326, 328; 327, identifier:get_pkg_paths; 328, argument_list; 328, 329; 328, 330; 329, identifier:mod_name; 330, identifier:out_dir; 331, for_statement; 331, 332; 331, 335; 331, 336; 332, pattern_list; 332, 333; 332, 334; 333, identifier:source; 334, identifier:destination; 335, identifier:modules; 336, block; 336, 337; 336, 346; 336, 366; 336, 399; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:_logger; 341, identifier:info; 342, argument_list; 342, 343; 342, 344; 342, 345; 343, string:"generating stub for %s to path %s"; 344, identifier:source; 345, identifier:destination; 346, with_statement; 346, 347; 346, 357; 347, with_clause; 347, 348; 348, with_item; 348, 349; 349, as_pattern; 349, 350; 349, 355; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:source; 353, identifier:open; 354, argument_list; 355, as_pattern_target; 355, 356; 356, identifier:f; 357, block; 357, 358; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:code; 361, call; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:f; 364, identifier:read; 365, argument_list; 366, try_statement; 366, 367; 366, 380; 367, block; 367, 368; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:stub; 371, call; 371, 372; 371, 373; 372, identifier:get_stub; 373, argument_list; 373, 374; 373, 375; 374, identifier:code; 375, keyword_argument; 375, 376; 375, 377; 376, identifier:generic; 377, attribute; 377, 378; 377, 379; 378, identifier:arguments; 379, identifier:generic; 380, except_clause; 380, 381; 380, 385; 381, as_pattern; 381, 382; 381, 383; 382, identifier:Exception; 383, as_pattern_target; 383, 384; 384, identifier:e; 385, block; 385, 386; 385, 398; 386, expression_statement; 386, 387; 387, call; 387, 388; 387, 389; 388, identifier:print; 389, argument_list; 389, 390; 389, 391; 389, 392; 389, 393; 390, identifier:source; 391, string:"-"; 392, identifier:e; 393, keyword_argument; 393, 394; 393, 395; 394, identifier:file; 395, attribute; 395, 396; 395, 397; 396, identifier:sys; 397, identifier:stderr; 398, continue_statement; 399, if_statement; 399, 400; 399, 403; 400, comparison_operator:!=; 400, 401; 400, 402; 401, identifier:stub; 402, string:""; 403, block; 403, 404; 403, 425; 404, if_statement; 404, 405; 404, 413; 405, not_operator; 405, 406; 406, call; 406, 407; 406, 412; 407, attribute; 407, 408; 407, 411; 408, attribute; 408, 409; 408, 410; 409, identifier:destination; 410, identifier:parent; 411, identifier:exists; 412, argument_list; 413, block; 413, 414; 414, expression_statement; 414, 415; 415, call; 415, 416; 415, 421; 416, attribute; 416, 417; 416, 420; 417, attribute; 417, 418; 417, 419; 418, identifier:destination; 419, identifier:parent; 420, identifier:mkdir; 421, argument_list; 421, 422; 422, keyword_argument; 422, 423; 422, 424; 423, identifier:parents; 424, True; 425, with_statement; 425, 426; 425, 437; 425, 441; 426, with_clause; 426, 427; 427, with_item; 427, 428; 428, as_pattern; 428, 429; 428, 435; 429, call; 429, 430; 429, 433; 430, attribute; 430, 431; 430, 432; 431, identifier:destination; 432, identifier:open; 433, argument_list; 433, 434; 434, string:"w"; 435, as_pattern_target; 435, 436; 436, identifier:f; 437, ERROR; 437, 438; 438, attribute; 438, 439; 438, 440; 439, identifier:f; 440, identifier:write; 441, block: | def main(argv=None):
parser = ArgumentParser(prog="pygenstub")
parser.add_argument("--version", action="version", version="%(prog)s " + __version__)
parser.add_argument("files", nargs="*", help="generate stubs for given files")
parser.add_argument(
"-m",
"--module",
action="append",
metavar="MODULE",
dest="modules",
default=[],
help="generate stubs for given modules",
)
parser.add_argument(
"-o", "--output", metavar="PATH", dest="out_dir", help="change the output directory"
)
parser.add_argument(
"--generic", action="store_true", default=False, help="generate generic stubs"
)
parser.add_argument("--debug", action="store_true", help="enable debug messages")
argv = argv if argv is not None else sys.argv
arguments = parser.parse_args(argv[1:])
if arguments.debug:
logging.basicConfig(level=logging.DEBUG)
_logger.debug("running in debug mode")
out_dir = arguments.out_dir if arguments.out_dir is not None else ""
if (out_dir == "") and (len(arguments.modules) > 0):
print("Output directory must be given when generating stubs for modules.")
sys.exit(1)
modules = []
for path in arguments.files:
paths = Path(path).glob("**/*.py") if Path(path).is_dir() else [Path(path)]
for source in paths:
if str(source).startswith(os.path.pardir):
source = source.absolute().resolve()
if (out_dir != "") and source.is_absolute():
source = source.relative_to(source.root)
destination = Path(out_dir, source.with_suffix(".pyi"))
modules.append((source, destination))
for mod_name in arguments.modules:
modules.extend(get_pkg_paths(mod_name, out_dir))
for source, destination in modules:
_logger.info("generating stub for %s to path %s", source, destination)
with source.open() as f:
code = f.read()
try:
stub = get_stub(code, generic=arguments.generic)
except Exception as e:
print(source, "-", e, file=sys.stderr)
continue
if stub != "":
if not destination.parent.exists():
destination.parent.mkdir(parents=True)
with destination.open("w") as f:
f.write(" |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_code; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 38; 5, 42; 5, 81; 5, 111; 5, 117; 5, 208; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:stub; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 15; 11, identifier:deco; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:decorators; 15, block; 15, 16; 16, if_statement; 16, 17; 16, 28; 17, boolean_operator:or; 17, 18; 17, 22; 18, parenthesized_expression; 18, 19; 19, comparison_operator:in; 19, 20; 19, 21; 20, identifier:deco; 21, identifier:DECORATORS; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:deco; 25, identifier:endswith; 26, argument_list; 26, 27; 27, string:".setter"; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:stub; 33, identifier:append; 34, argument_list; 34, 35; 35, binary_operator:+; 35, 36; 35, 37; 36, string:"@"; 37, identifier:deco; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:parameters; 41, list:[]; 42, for_statement; 42, 43; 42, 47; 42, 50; 43, pattern_list; 43, 44; 43, 45; 43, 46; 44, identifier:name; 45, identifier:type_; 46, identifier:has_default; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:parameters; 50, block; 50, 51; 50, 74; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:decl; 54, binary_operator:%; 54, 55; 54, 56; 55, string:"%(n)s%(t)s%(d)s"; 56, dictionary; 56, 57; 56, 60; 56, 68; 57, pair; 57, 58; 57, 59; 58, string:"n"; 59, identifier:name; 60, pair; 60, 61; 60, 62; 61, string:"t"; 62, conditional_expression:if; 62, 63; 62, 66; 62, 67; 63, binary_operator:+; 63, 64; 63, 65; 64, string:": "; 65, identifier:type_; 66, identifier:type_; 67, string:""; 68, pair; 68, 69; 68, 70; 69, string:"d"; 70, conditional_expression:if; 70, 71; 70, 72; 70, 73; 71, string:" = ..."; 72, identifier:has_default; 73, string:""; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:parameters; 78, identifier:append; 79, argument_list; 79, 80; 80, identifier:decl; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:slots; 84, dictionary; 84, 85; 84, 93; 84, 98; 84, 106; 85, pair; 85, 86; 85, 87; 86, string:"a"; 87, conditional_expression:if; 87, 88; 87, 89; 87, 92; 88, string:"async "; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_async; 92, string:""; 93, pair; 93, 94; 93, 95; 94, string:"n"; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:name; 98, pair; 98, 99; 98, 100; 99, string:"p"; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, string:", "; 103, identifier:join; 104, argument_list; 104, 105; 105, identifier:parameters; 106, pair; 106, 107; 106, 108; 107, string:"r"; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:rtype; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:prototype; 114, binary_operator:%; 114, 115; 114, 116; 115, string:"%(a)sdef %(n)s(%(p)s) -> %(r)s: ..."; 116, identifier:slots; 117, if_statement; 117, 118; 117, 124; 117, 132; 117, 173; 118, comparison_operator:<=; 118, 119; 118, 123; 119, call; 119, 120; 119, 121; 120, identifier:len; 121, argument_list; 121, 122; 122, identifier:prototype; 123, identifier:LINE_LENGTH_LIMIT; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:stub; 129, identifier:append; 130, argument_list; 130, 131; 131, identifier:prototype; 132, elif_clause; 132, 133; 132, 143; 133, comparison_operator:<=; 133, 134; 133, 142; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, binary_operator:+; 137, 138; 137, 139; 138, identifier:INDENT; 139, subscript; 139, 140; 139, 141; 140, identifier:slots; 141, string:"p"; 142, identifier:LINE_LENGTH_LIMIT; 143, block; 143, 144; 143, 153; 143, 164; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:stub; 148, identifier:append; 149, argument_list; 149, 150; 150, binary_operator:%; 150, 151; 150, 152; 151, string:"%(a)sdef %(n)s("; 152, identifier:slots; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:stub; 157, identifier:append; 158, argument_list; 158, 159; 159, binary_operator:+; 159, 160; 159, 161; 160, identifier:INDENT; 161, subscript; 161, 162; 161, 163; 162, identifier:slots; 163, string:"p"; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:stub; 168, identifier:append; 169, argument_list; 169, 170; 170, binary_operator:%; 170, 171; 170, 172; 171, string:") -> %(r)s: ..."; 172, identifier:slots; 173, else_clause; 173, 174; 174, block; 174, 175; 174, 184; 174, 199; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:stub; 179, identifier:append; 180, argument_list; 180, 181; 181, binary_operator:%; 181, 182; 181, 183; 182, string:"%(a)sdef %(n)s("; 183, identifier:slots; 184, for_statement; 184, 185; 184, 186; 184, 187; 185, identifier:param; 186, identifier:parameters; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:stub; 192, identifier:append; 193, argument_list; 193, 194; 194, binary_operator:+; 194, 195; 194, 198; 195, binary_operator:+; 195, 196; 195, 197; 196, identifier:INDENT; 197, identifier:param; 198, string:","; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:stub; 203, identifier:append; 204, argument_list; 204, 205; 205, binary_operator:%; 205, 206; 205, 207; 206, string:") -> %(r)s: ..."; 207, identifier:slots; 208, return_statement; 208, 209; 209, identifier:stub | def get_code(self):
stub = []
for deco in self.decorators:
if (deco in DECORATORS) or deco.endswith(".setter"):
stub.append("@" + deco)
parameters = []
for name, type_, has_default in self.parameters:
decl = "%(n)s%(t)s%(d)s" % {
"n": name,
"t": ": " + type_ if type_ else "",
"d": " = ..." if has_default else "",
}
parameters.append(decl)
slots = {
"a": "async " if self._async else "",
"n": self.name,
"p": ", ".join(parameters),
"r": self.rtype,
}
prototype = "%(a)sdef %(n)s(%(p)s) -> %(r)s: ..." % slots
if len(prototype) <= LINE_LENGTH_LIMIT:
stub.append(prototype)
elif len(INDENT + slots["p"]) <= LINE_LENGTH_LIMIT:
stub.append("%(a)sdef %(n)s(" % slots)
stub.append(INDENT + slots["p"])
stub.append(") -> %(r)s: ..." % slots)
else:
stub.append("%(a)sdef %(n)s(" % slots)
for param in parameters:
stub.append(INDENT + param + ",")
stub.append(") -> %(r)s: ..." % slots)
return stub |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:query_metric_stats; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:metric_type; 6, default_parameter; 6, 7; 6, 8; 7, identifier:metric_id; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:start; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:end; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:bucketDuration; 17, None; 18, dictionary_splat_pattern; 18, 19; 19, identifier:query_options; 20, block; 20, 21; 20, 51; 20, 81; 20, 111; 20, 160; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:start; 24, None; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 33; 26, 43; 27, comparison_operator:is; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:type; 30, argument_list; 30, 31; 31, identifier:start; 32, identifier:datetime; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:query_options; 38, string:'start'; 39, call; 39, 40; 39, 41; 40, identifier:datetime_to_time_millis; 41, argument_list; 41, 42; 42, identifier:start; 43, else_clause; 43, 44; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:query_options; 49, string:'start'; 50, identifier:start; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:end; 54, None; 55, block; 55, 56; 56, if_statement; 56, 57; 56, 63; 56, 73; 57, comparison_operator:is; 57, 58; 57, 62; 58, call; 58, 59; 58, 60; 59, identifier:type; 60, argument_list; 60, 61; 61, identifier:end; 62, identifier:datetime; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:query_options; 68, string:'end'; 69, call; 69, 70; 69, 71; 70, identifier:datetime_to_time_millis; 71, argument_list; 71, 72; 72, identifier:end; 73, else_clause; 73, 74; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:query_options; 79, string:'end'; 80, identifier:end; 81, if_statement; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:bucketDuration; 84, None; 85, block; 85, 86; 86, if_statement; 86, 87; 86, 93; 86, 103; 87, comparison_operator:is; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:type; 90, argument_list; 90, 91; 91, identifier:bucketDuration; 92, identifier:timedelta; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:query_options; 98, string:'bucketDuration'; 99, call; 99, 100; 99, 101; 100, identifier:timedelta_to_duration; 101, argument_list; 101, 102; 102, identifier:bucketDuration; 103, else_clause; 103, 104; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:query_options; 109, string:'bucketDuration'; 110, identifier:bucketDuration; 111, if_statement; 111, 112; 111, 115; 111, 131; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:metric_id; 114, None; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:url; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:_get_metrics_stats_url; 123, argument_list; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:_get_metrics_single_url; 128, argument_list; 128, 129; 128, 130; 129, identifier:metric_type; 130, identifier:metric_id; 131, else_clause; 131, 132; 132, block; 132, 133; 132, 146; 133, if_statement; 133, 134; 133, 140; 134, comparison_operator:<; 134, 135; 134, 139; 135, call; 135, 136; 135, 137; 136, identifier:len; 137, argument_list; 137, 138; 138, identifier:query_options; 139, integer:0; 140, block; 140, 141; 141, raise_statement; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:HawkularError; 144, argument_list; 144, 145; 145, string:'Tags are required when querying without metric_id'; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:url; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_get_metrics_stats_url; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:_get_url; 158, argument_list; 158, 159; 159, identifier:metric_type; 160, return_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:_get; 165, argument_list; 165, 166; 165, 167; 166, identifier:url; 167, dictionary_splat; 167, 168; 168, identifier:query_options | def query_metric_stats(self, metric_type, metric_id=None, start=None, end=None, bucketDuration=None, **query_options):
if start is not None:
if type(start) is datetime:
query_options['start'] = datetime_to_time_millis(start)
else:
query_options['start'] = start
if end is not None:
if type(end) is datetime:
query_options['end'] = datetime_to_time_millis(end)
else:
query_options['end'] = end
if bucketDuration is not None:
if type(bucketDuration) is timedelta:
query_options['bucketDuration'] = timedelta_to_duration(bucketDuration)
else:
query_options['bucketDuration'] = bucketDuration
if metric_id is not None:
url = self._get_metrics_stats_url(self._get_metrics_single_url(metric_type, metric_id))
else:
if len(query_options) < 0:
raise HawkularError('Tags are required when querying without metric_id')
url = self._get_metrics_stats_url(self._get_url(metric_type))
return self._get(url, **query_options) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:find_files; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, default_parameter; 4, 5; 4, 6; 5, identifier:path; 6, string:''; 7, default_parameter; 7, 8; 7, 9; 8, identifier:ext; 9, string:''; 10, default_parameter; 10, 11; 10, 12; 11, identifier:level; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:typ; 15, identifier:list; 16, default_parameter; 16, 17; 16, 18; 17, identifier:dirs; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:files; 21, True; 22, default_parameter; 22, 23; 22, 24; 23, identifier:verbosity; 24, integer:0; 25, block; 25, 26; 25, 48; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:gen; 29, call; 29, 30; 29, 31; 30, identifier:generate_files; 31, argument_list; 31, 32; 31, 33; 31, 36; 31, 39; 31, 42; 31, 45; 32, identifier:path; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:ext; 35, identifier:ext; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:level; 38, identifier:level; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:dirs; 41, identifier:dirs; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:files; 44, identifier:files; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:verbosity; 47, identifier:verbosity; 48, if_statement; 48, 49; 48, 58; 48, 71; 48, 81; 49, call; 49, 50; 49, 51; 50, identifier:isinstance; 51, argument_list; 51, 52; 51, 55; 52, call; 52, 53; 52, 54; 53, identifier:typ; 54, argument_list; 55, attribute; 55, 56; 55, 57; 56, identifier:collections; 57, identifier:Mapping; 58, block; 58, 59; 59, return_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:typ; 62, generator_expression; 62, 63; 62, 68; 63, tuple; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:ff; 66, string:'path'; 67, identifier:ff; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:ff; 70, identifier:gen; 71, elif_clause; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:typ; 74, None; 75, block; 75, 76; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:typ; 79, argument_list; 79, 80; 80, identifier:gen; 81, else_clause; 81, 82; 82, block; 82, 83; 83, return_statement; 83, 84; 84, identifier:gen | def find_files(path='', ext='', level=None, typ=list, dirs=False, files=True, verbosity=0):
gen = generate_files(path, ext=ext, level=level, dirs=dirs, files=files, verbosity=verbosity)
if isinstance(typ(), collections.Mapping):
return typ((ff['path'], ff) for ff in gen)
elif typ is not None:
return typ(gen)
else:
return gen |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:limitted_dump; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 4, default_parameter; 4, 5; 4, 6; 5, identifier:cursor; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:twitter; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:path; 12, string:'tweets.json'; 13, default_parameter; 13, 14; 13, 15; 14, identifier:limit; 15, integer:450; 16, default_parameter; 16, 17; 16, 18; 17, identifier:rate; 18, identifier:TWITTER_SEARCH_RATE_LIMIT; 19, default_parameter; 19, 20; 19, 21; 20, identifier:indent; 21, unary_operator:-; 21, 22; 22, integer:1; 23, block; 23, 24; 23, 34; 23, 40; 23, 57; 23, 66; 23, 75; 24, if_statement; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:twitter; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:twitter; 31, call; 31, 32; 31, 33; 32, identifier:get_twitter; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:cursor; 37, boolean_operator:or; 37, 38; 37, 39; 38, identifier:cursor; 39, string:'python'; 40, if_statement; 40, 41; 40, 46; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 45; 44, identifier:cursor; 45, identifier:basestring; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:cursor; 50, call; 50, 51; 50, 52; 51, identifier:get_cursor; 52, argument_list; 52, 53; 52, 54; 53, identifier:twitter; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:search; 56, identifier:cursor; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:newline; 60, conditional_expression:if; 60, 61; 60, 62; 60, 65; 61, string:'\n'; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:indent; 64, None; 65, string:''; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:<; 67, 68; 67, 69; 68, identifier:indent; 69, integer:0; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:indent; 74, None; 75, with_statement; 75, 76; 75, 95; 76, with_clause; 76, 77; 77, with_item; 77, 78; 78, as_pattern; 78, 79; 78, 93; 79, parenthesized_expression; 79, 80; 80, conditional_expression:if; 80, 81; 80, 86; 80, 92; 81, call; 81, 82; 81, 83; 82, identifier:open; 83, argument_list; 83, 84; 83, 85; 84, identifier:path; 85, string:'w'; 86, not_operator; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:isinstance; 89, argument_list; 89, 90; 89, 91; 90, identifier:path; 91, identifier:file; 92, identifier:path; 93, as_pattern_target; 93, 94; 94, identifier:f; 95, block; 95, 96; 95, 103; 95, 179; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:f; 100, identifier:write; 101, argument_list; 101, 102; 102, string:'[\n'; 103, for_statement; 103, 104; 103, 107; 103, 111; 104, pattern_list; 104, 105; 104, 106; 105, identifier:i; 106, identifier:obj; 107, call; 107, 108; 107, 109; 108, identifier:enumerate; 109, argument_list; 109, 110; 110, identifier:cursor; 111, block; 111, 112; 111, 127; 111, 146; 111, 158; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:f; 116, identifier:write; 117, argument_list; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:json; 121, identifier:dumps; 122, argument_list; 122, 123; 122, 124; 123, identifier:obj; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:indent; 126, identifier:indent; 127, if_statement; 127, 128; 127, 133; 127, 143; 128, comparison_operator:<; 128, 129; 128, 130; 129, identifier:i; 130, binary_operator:-; 130, 131; 130, 132; 131, identifier:limit; 132, integer:1; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:f; 138, identifier:write; 139, argument_list; 139, 140; 140, binary_operator:+; 140, 141; 140, 142; 141, string:','; 142, identifier:newline; 143, else_clause; 143, 144; 144, block; 144, 145; 145, break_statement; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:remaining; 149, call; 149, 150; 149, 151; 150, identifier:int; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:twitter; 155, identifier:get_lastfunction_header; 156, argument_list; 156, 157; 157, string:'x-rate-limit-remaining'; 158, if_statement; 158, 159; 158, 162; 158, 170; 159, comparison_operator:>; 159, 160; 159, 161; 160, identifier:remaining; 161, integer:0; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:sleep; 166, argument_list; 166, 167; 167, binary_operator:/; 167, 168; 167, 169; 168, float:1.; 169, identifier:rate; 170, else_clause; 170, 171; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:sleep; 175, argument_list; 175, 176; 176, binary_operator:*; 176, 177; 176, 178; 177, integer:15; 178, integer:60; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:f; 183, identifier:write; 184, argument_list; 184, 185; 185, string:'\n]\n' | def limitted_dump(cursor=None, twitter=None, path='tweets.json', limit=450, rate=TWITTER_SEARCH_RATE_LIMIT, indent=-1):
if not twitter:
twitter = get_twitter()
cursor = cursor or 'python'
if isinstance(cursor, basestring):
cursor = get_cursor(twitter, search=cursor)
newline = '\n' if indent is not None else ''
if indent < 0:
indent = None
with (open(path, 'w') if not isinstance(path, file) else path) as f:
f.write('[\n')
for i, obj in enumerate(cursor):
f.write(json.dumps(obj, indent=indent))
if i < limit - 1:
f.write(',' + newline)
else:
break
remaining = int(twitter.get_lastfunction_header('x-rate-limit-remaining'))
if remaining > 0:
sleep(1. / rate)
else:
sleep(15 * 60)
f.write('\n]\n') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:request; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, False; 9, block; 9, 10; 10, return_statement; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:sorted; 13, argument_list; 13, 14; 13, 17; 13, 30; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:collection; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:key; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:o; 22, call; 22, 23; 22, 24; 23, identifier:getattr; 24, argument_list; 24, 25; 24, 26; 24, 29; 25, identifier:o; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:columns_sort; 29, integer:0; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:reverse; 32, identifier:reverse | async def sort(self, request, reverse=False):
return sorted(
self.collection, key=lambda o: getattr(o, self.columns_sort, 0), reverse=reverse) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:_request; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, identifier:self; 5, identifier:path; 6, identifier:key; 7, identifier:data; 8, identifier:method; 9, identifier:key_is_cik; 10, default_parameter; 10, 11; 10, 12; 11, identifier:extra_headers; 12, dictionary; 13, block; 13, 14; 13, 55; 13, 59; 13, 76; 13, 87; 13, 93; 13, 100; 13, 116; 13, 124; 13, 139; 14, if_statement; 14, 15; 14, 18; 14, 45; 15, comparison_operator:==; 15, 16; 15, 17; 16, identifier:method; 17, string:'GET'; 18, block; 18, 19; 18, 41; 19, if_statement; 19, 20; 19, 26; 19, 35; 20, comparison_operator:>; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:data; 25, integer:0; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:url; 30, binary_operator:+; 30, 31; 30, 34; 31, binary_operator:+; 31, 32; 31, 33; 32, identifier:path; 33, string:'?'; 34, identifier:data; 35, else_clause; 35, 36; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:url; 40, identifier:path; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:body; 44, None; 45, else_clause; 45, 46; 46, block; 46, 47; 46, 51; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:url; 50, identifier:path; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:body; 54, identifier:data; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:headers; 58, dictionary; 59, if_statement; 59, 60; 59, 61; 59, 68; 60, identifier:key_is_cik; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:headers; 66, string:'X-Exosite-CIK'; 67, identifier:key; 68, else_clause; 68, 69; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:headers; 74, string:'X-Exosite-Token'; 75, identifier:key; 76, if_statement; 76, 77; 76, 80; 77, comparison_operator:==; 77, 78; 77, 79; 78, identifier:method; 79, string:'POST'; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:headers; 85, string:'Content-Type'; 86, string:'application/x-www-form-urlencoded; charset=utf-8'; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:headers; 91, string:'Accept'; 92, string:'text/plain, text/csv, application/x-www-form-urlencoded'; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:headers; 97, identifier:update; 98, argument_list; 98, 99; 99, identifier:extra_headers; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, pattern_list; 102, 103; 102, 104; 103, identifier:body; 104, identifier:response; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:_onephttp; 110, identifier:request; 111, argument_list; 111, 112; 111, 113; 111, 114; 111, 115; 112, identifier:method; 113, identifier:url; 114, identifier:body; 115, identifier:headers; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:pr; 119, call; 119, 120; 119, 121; 120, identifier:ProvisionResponse; 121, argument_list; 121, 122; 121, 123; 122, identifier:body; 123, identifier:response; 124, if_statement; 124, 125; 124, 133; 125, boolean_operator:and; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_raise_api_exceptions; 129, not_operator; 129, 130; 130, attribute; 130, 131; 130, 132; 131, identifier:pr; 132, identifier:isok; 133, block; 133, 134; 134, raise_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:ProvisionException; 137, argument_list; 137, 138; 138, identifier:pr; 139, return_statement; 139, 140; 140, identifier:pr | def _request(self, path, key, data, method, key_is_cik, extra_headers={}):
if method == 'GET':
if len(data) > 0:
url = path + '?' + data
else:
url = path
body = None
else:
url = path
body = data
headers = {}
if key_is_cik:
headers['X-Exosite-CIK'] = key
else:
headers['X-Exosite-Token'] = key
if method == 'POST':
headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
headers['Accept'] = 'text/plain, text/csv, application/x-www-form-urlencoded'
headers.update(extra_headers)
body, response = self._onephttp.request(method,
url,
body,
headers)
pr = ProvisionResponse(body, response)
if self._raise_api_exceptions and not pr.isok:
raise ProvisionException(pr)
return pr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:parse_intervals; 3, parameters; 3, 4; 3, 5; 4, identifier:path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:as_context; 7, False; 8, block; 8, 9; 8, 57; 8, 79; 8, 88; 8, 94; 8, 103; 9, function_definition; 9, 10; 9, 11; 9, 12; 10, function_name:_regions_from_range; 11, parameters; 12, block; 12, 13; 13, if_statement; 13, 14; 13, 15; 13, 47; 14, identifier:as_context; 15, block; 15, 16; 15, 37; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:ctxs; 19, call; 19, 20; 19, 21; 20, identifier:list; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:set; 24, argument_list; 24, 25; 25, subscript; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:pf; 28, identifier:lines; 29, slice; 29, 30; 29, 33; 29, 34; 30, binary_operator:-; 30, 31; 30, 32; 31, identifier:start; 32, integer:1; 33, colon; 34, binary_operator:-; 34, 35; 34, 36; 35, identifier:stop; 36, integer:1; 37, return_statement; 37, 38; 38, list_comprehension; 38, 39; 38, 44; 39, call; 39, 40; 39, 41; 40, identifier:ContextInterval; 41, argument_list; 41, 42; 41, 43; 42, identifier:filename; 43, identifier:ctx; 44, for_in_clause; 44, 45; 44, 46; 45, identifier:ctx; 46, identifier:ctxs; 47, else_clause; 47, 48; 48, block; 48, 49; 49, return_statement; 49, 50; 50, list:[LineInterval(filename, start, stop)]; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:LineInterval; 53, argument_list; 53, 54; 53, 55; 53, 56; 54, identifier:filename; 55, identifier:start; 56, identifier:stop; 57, if_statement; 57, 58; 57, 61; 57, 73; 58, comparison_operator:in; 58, 59; 58, 60; 59, string:':'; 60, identifier:path; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, pattern_list; 64, 65; 64, 66; 65, identifier:path; 66, identifier:subpath; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:path; 70, identifier:split; 71, argument_list; 71, 72; 72, string:':'; 73, else_clause; 73, 74; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:subpath; 78, string:''; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:pf; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:PythonFile; 85, identifier:from_modulename; 86, argument_list; 86, 87; 87, identifier:path; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:filename; 91, attribute; 91, 92; 91, 93; 92, identifier:pf; 93, identifier:filename; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:rng; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:NUMBER_RE; 100, identifier:match; 101, argument_list; 101, 102; 102, identifier:subpath; 103, if_statement; 103, 104; 103, 105; 103, 133; 103, 165; 104, identifier:rng; 105, block; 105, 106; 105, 121; 105, 129; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, pattern_list; 108, 109; 108, 110; 109, identifier:start; 110, identifier:stop; 111, call; 111, 112; 111, 113; 112, identifier:map; 113, argument_list; 113, 114; 113, 115; 114, identifier:int; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:rng; 118, identifier:groups; 119, argument_list; 119, 120; 120, integer:0; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:stop; 124, boolean_operator:or; 124, 125; 124, 126; 125, identifier:stop; 126, binary_operator:+; 126, 127; 126, 128; 127, identifier:start; 128, integer:1; 129, return_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:_regions_from_range; 132, argument_list; 133, elif_clause; 133, 134; 133, 136; 134, not_operator; 134, 135; 135, identifier:subpath; 136, block; 136, 137; 136, 149; 136, 161; 137, if_statement; 137, 138; 137, 139; 138, identifier:as_context; 139, block; 139, 140; 140, return_statement; 140, 141; 141, list:[ContextInterval(filename, pf.prefix)]; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:ContextInterval; 144, argument_list; 144, 145; 144, 146; 145, identifier:filename; 146, attribute; 146, 147; 146, 148; 147, identifier:pf; 148, identifier:prefix; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, pattern_list; 151, 152; 151, 153; 152, identifier:start; 153, identifier:stop; 154, expression_list; 154, 155; 154, 156; 155, integer:1; 156, binary_operator:+; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:pf; 159, identifier:line_count; 160, integer:1; 161, return_statement; 161, 162; 162, call; 162, 163; 162, 164; 163, identifier:_regions_from_range; 164, argument_list; 165, else_clause; 165, 166; 166, block; 166, 167; 166, 177; 166, 195; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:context; 170, binary_operator:+; 170, 171; 170, 176; 171, binary_operator:+; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:pf; 174, identifier:prefix; 175, string:':'; 176, identifier:subpath; 177, if_statement; 177, 178; 177, 183; 178, comparison_operator:not; 178, 179; 178, 180; 179, identifier:context; 180, attribute; 180, 181; 180, 182; 181, identifier:pf; 182, identifier:lines; 183, block; 183, 184; 184, raise_statement; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:ValueError; 187, argument_list; 187, 188; 188, binary_operator:%; 188, 189; 188, 190; 189, string:"%s is not a valid context for %s"; 190, tuple; 190, 191; 190, 192; 191, identifier:context; 192, attribute; 192, 193; 192, 194; 193, identifier:pf; 194, identifier:prefix; 195, if_statement; 195, 196; 195, 197; 195, 205; 196, identifier:as_context; 197, block; 197, 198; 198, return_statement; 198, 199; 199, list:[ContextInterval(filename, context)]; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:ContextInterval; 202, argument_list; 202, 203; 202, 204; 203, identifier:filename; 204, identifier:context; 205, else_clause; 205, 206; 206, block; 206, 207; 206, 218; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 212; 209, pattern_list; 209, 210; 209, 211; 210, identifier:start; 211, identifier:stop; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:pf; 215, identifier:context_range; 216, argument_list; 216, 217; 217, identifier:context; 218, return_statement; 218, 219; 219, list:[LineInterval(filename, start, stop)]; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:LineInterval; 222, argument_list; 222, 223; 222, 224; 222, 225; 223, identifier:filename; 224, identifier:start; 225, identifier:stop | def parse_intervals(path, as_context=False):
def _regions_from_range():
if as_context:
ctxs = list(set(pf.lines[start - 1: stop - 1]))
return [
ContextInterval(filename, ctx)
for ctx in ctxs
]
else:
return [LineInterval(filename, start, stop)]
if ':' in path:
path, subpath = path.split(':')
else:
subpath = ''
pf = PythonFile.from_modulename(path)
filename = pf.filename
rng = NUMBER_RE.match(subpath)
if rng:
start, stop = map(int, rng.groups(0))
stop = stop or start + 1
return _regions_from_range()
elif not subpath:
if as_context:
return [ContextInterval(filename, pf.prefix)]
start, stop = 1, pf.line_count + 1
return _regions_from_range()
else:
context = pf.prefix + ':' + subpath
if context not in pf.lines:
raise ValueError("%s is not a valid context for %s"
% (context, pf.prefix))
if as_context:
return [ContextInterval(filename, context)]
else:
start, stop = pf.context_range(context)
return [LineInterval(filename, start, stop)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:graphiter; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:self; 5, identifier:graph; 6, identifier:target; 7, default_parameter; 7, 8; 7, 9; 8, identifier:ascendants; 9, integer:0; 10, default_parameter; 10, 11; 10, 12; 11, identifier:descendants; 12, integer:1; 13, block; 13, 14; 13, 20; 13, 29; 13, 35; 13, 44; 13, 51; 13, 137; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:asc; 17, binary_operator:+; 17, 18; 17, 19; 18, integer:0; 19, identifier:ascendants; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:!=; 21, 22; 21, 23; 22, identifier:asc; 23, integer:0; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, augmented_assignment:-=; 26, 27; 26, 28; 27, identifier:asc; 28, integer:1; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:desc; 32, binary_operator:+; 32, 33; 32, 34; 33, integer:0; 34, identifier:descendants; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:!=; 36, 37; 36, 38; 37, identifier:desc; 38, integer:0; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, augmented_assignment:-=; 41, 42; 41, 43; 42, identifier:desc; 43, integer:1; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:t; 47, call; 47, 48; 47, 49; 48, identifier:str; 49, argument_list; 49, 50; 50, identifier:target; 51, if_statement; 51, 52; 51, 63; 52, boolean_operator:and; 52, 53; 52, 56; 53, comparison_operator:!=; 53, 54; 53, 55; 54, identifier:descendants; 55, integer:0; 56, comparison_operator:is; 56, 57; 56, 62; 57, subscript; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:downwards; 61, identifier:t; 62, True; 63, block; 63, 64; 63, 72; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:downwards; 70, identifier:t; 71, False; 72, for_statement; 72, 73; 72, 76; 72, 82; 73, pattern_list; 73, 74; 73, 75; 74, identifier:pred; 75, identifier:obj; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:graph; 79, identifier:predicate_objects; 80, argument_list; 80, 81; 81, identifier:target; 82, block; 82, 83; 82, 95; 82, 105; 83, if_statement; 83, 84; 83, 93; 84, boolean_operator:and; 84, 85; 84, 88; 85, comparison_operator:==; 85, 86; 85, 87; 86, identifier:desc; 87, integer:0; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:obj; 92, identifier:BNode; 93, block; 93, 94; 94, continue_statement; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:add; 100, argument_list; 100, 101; 101, tuple; 101, 102; 101, 103; 101, 104; 102, identifier:target; 103, identifier:pred; 104, identifier:obj; 105, if_statement; 105, 106; 105, 120; 106, boolean_operator:and; 106, 107; 106, 110; 107, comparison_operator:!=; 107, 108; 107, 109; 108, identifier:desc; 109, integer:0; 110, comparison_operator:is; 110, 111; 110, 119; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:downwards; 115, call; 115, 116; 115, 117; 116, identifier:str; 117, argument_list; 117, 118; 118, identifier:obj; 119, True; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:graphiter; 126, argument_list; 126, 127; 126, 128; 126, 131; 126, 134; 127, identifier:graph; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:target; 130, identifier:obj; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:ascendants; 133, integer:0; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:descendants; 136, identifier:desc; 137, if_statement; 137, 138; 137, 149; 138, boolean_operator:and; 138, 139; 138, 142; 139, comparison_operator:!=; 139, 140; 139, 141; 140, identifier:ascendants; 141, integer:0; 142, comparison_operator:is; 142, 143; 142, 148; 143, subscript; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:updwards; 147, identifier:t; 148, True; 149, block; 149, 150; 149, 158; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 157; 152, subscript; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:updwards; 156, identifier:t; 157, False; 158, for_statement; 158, 159; 158, 162; 158, 170; 159, pattern_list; 159, 160; 159, 161; 160, identifier:s; 161, identifier:p; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:graph; 165, identifier:subject_predicates; 166, argument_list; 166, 167; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:object; 169, identifier:target; 170, block; 170, 171; 170, 183; 170, 193; 171, if_statement; 171, 172; 171, 181; 172, boolean_operator:and; 172, 173; 172, 176; 173, comparison_operator:==; 173, 174; 173, 175; 174, identifier:desc; 175, integer:0; 176, call; 176, 177; 176, 178; 177, identifier:isinstance; 178, argument_list; 178, 179; 178, 180; 179, identifier:s; 180, identifier:BNode; 181, block; 181, 182; 182, continue_statement; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:add; 188, argument_list; 188, 189; 189, tuple; 189, 190; 189, 191; 189, 192; 190, identifier:s; 191, identifier:p; 192, identifier:target; 193, if_statement; 193, 194; 193, 208; 194, boolean_operator:and; 194, 195; 194, 198; 195, comparison_operator:!=; 195, 196; 195, 197; 196, identifier:asc; 197, integer:0; 198, comparison_operator:is; 198, 199; 198, 207; 199, subscript; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:updwards; 203, call; 203, 204; 203, 205; 204, identifier:str; 205, argument_list; 205, 206; 206, identifier:s; 207, True; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:graphiter; 214, argument_list; 214, 215; 214, 216; 214, 219; 214, 222; 215, identifier:graph; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:target; 218, identifier:s; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:ascendants; 221, identifier:asc; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:descendants; 224, integer:0 | def graphiter(self, graph, target, ascendants=0, descendants=1):
asc = 0 + ascendants
if asc != 0:
asc -= 1
desc = 0 + descendants
if desc != 0:
desc -= 1
t = str(target)
if descendants != 0 and self.downwards[t] is True:
self.downwards[t] = False
for pred, obj in graph.predicate_objects(target):
if desc == 0 and isinstance(obj, BNode):
continue
self.add((target, pred, obj))
if desc != 0 and self.downwards[str(obj)] is True:
self.graphiter(graph, target=obj, ascendants=0, descendants=desc)
if ascendants != 0 and self.updwards[t] is True:
self.updwards[t] = False
for s, p in graph.subject_predicates(object=target):
if desc == 0 and isinstance(s, BNode):
continue
self.add((s, p, target))
if asc != 0 and self.updwards[str(s)] is True:
self.graphiter(graph, target=s, ascendants=asc, descendants=0) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:map_aliases_to_device_objects; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 45; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:all_devices; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:get_all_devices_in_portal; 13, argument_list; 14, for_statement; 14, 15; 14, 16; 14, 17; 15, identifier:dev_o; 16, identifier:all_devices; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, subscript; 20, 21; 20, 22; 21, identifier:dev_o; 22, string:'portals_aliases'; 23, subscript; 23, 24; 23, 42; 24, subscript; 24, 25; 24, 41; 25, subscript; 25, 26; 25, 40; 26, subscript; 26, 27; 26, 39; 27, subscript; 27, 28; 27, 38; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:get_portal_by_name; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:portal_name; 37, argument_list; 38, integer:2; 39, integer:1; 40, string:'info'; 41, string:'aliases'; 42, subscript; 42, 43; 42, 44; 43, identifier:dev_o; 44, string:'rid'; 45, return_statement; 45, 46; 46, identifier:all_devices | def map_aliases_to_device_objects(self):
all_devices = self.get_all_devices_in_portal()
for dev_o in all_devices:
dev_o['portals_aliases'] = self.get_portal_by_name(
self.portal_name()
)[2][1]['info']['aliases'][ dev_o['rid'] ]
return all_devices |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:print_sorted_device_list; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:device_list; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort_key; 10, string:'sn'; 11, block; 11, 12; 11, 25; 11, 29; 11, 206; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:dev_list; 15, conditional_expression:if; 15, 16; 15, 17; 15, 20; 16, identifier:device_list; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:device_list; 19, None; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:get_all_devices_in_portal; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:sorted_dev_list; 28, list:[]; 29, if_statement; 29, 30; 29, 33; 29, 78; 29, 141; 29, 190; 30, comparison_operator:==; 30, 31; 30, 32; 31, identifier:sort_key; 32, string:'sn'; 33, block; 33, 34; 33, 50; 33, 57; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:sort_keys; 37, list_comprehension; 37, 38; 37, 41; 37, 44; 38, subscript; 38, 39; 38, 40; 39, identifier:k; 40, identifier:sort_key; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:k; 43, identifier:dev_list; 44, if_clause; 44, 45; 45, comparison_operator:is; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:k; 48, identifier:sort_key; 49, None; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:sort_keys; 53, call; 53, 54; 53, 55; 54, identifier:sorted; 55, argument_list; 55, 56; 56, identifier:sort_keys; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:key; 59, identifier:sort_keys; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:sorted_dev_list; 65, identifier:extend; 66, argument_list; 66, 67; 67, list_comprehension; 67, 68; 67, 69; 67, 72; 68, identifier:d; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:d; 71, identifier:dev_list; 72, if_clause; 72, 73; 73, comparison_operator:==; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:d; 76, string:'sn'; 77, identifier:key; 78, elif_clause; 78, 79; 78, 82; 79, comparison_operator:==; 79, 80; 79, 81; 80, identifier:sort_key; 81, string:'name'; 82, block; 82, 83; 82, 108; 82, 115; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:sort_keys; 86, list_comprehension; 86, 87; 86, 94; 86, 95; 86, 98; 87, subscript; 87, 88; 87, 93; 88, subscript; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:k; 91, string:'info'; 92, string:'description'; 93, identifier:sort_key; 94, line_continuation:\; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:k; 97, identifier:dev_list; 98, if_clause; 98, 99; 99, comparison_operator:is; 99, 100; 99, 107; 100, subscript; 100, 101; 100, 106; 101, subscript; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:k; 104, string:'info'; 105, string:'description'; 106, identifier:sort_key; 107, None; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:sort_keys; 111, call; 111, 112; 111, 113; 112, identifier:sorted; 113, argument_list; 113, 114; 114, identifier:sort_keys; 115, for_statement; 115, 116; 115, 117; 115, 118; 116, identifier:key; 117, identifier:sort_keys; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:sorted_dev_list; 123, identifier:extend; 124, argument_list; 124, 125; 125, list_comprehension; 125, 126; 125, 127; 125, 130; 125, 131; 126, identifier:d; 127, for_in_clause; 127, 128; 127, 129; 128, identifier:d; 129, identifier:dev_list; 130, line_continuation:\; 131, if_clause; 131, 132; 132, comparison_operator:==; 132, 133; 132, 140; 133, subscript; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:d; 137, string:'info'; 138, string:'description'; 139, identifier:sort_key; 140, identifier:key; 141, elif_clause; 141, 142; 141, 145; 142, comparison_operator:==; 142, 143; 142, 144; 143, identifier:sort_key; 144, string:'portals_aliases'; 145, block; 145, 146; 145, 162; 145, 169; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:sort_keys; 149, list_comprehension; 149, 150; 149, 153; 149, 156; 150, subscript; 150, 151; 150, 152; 151, identifier:k; 152, identifier:sort_key; 153, for_in_clause; 153, 154; 153, 155; 154, identifier:k; 155, identifier:dev_list; 156, if_clause; 156, 157; 157, comparison_operator:is; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:k; 160, identifier:sort_key; 161, None; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:sort_keys; 165, call; 165, 166; 165, 167; 166, identifier:sorted; 167, argument_list; 167, 168; 168, identifier:sort_keys; 169, for_statement; 169, 170; 169, 171; 169, 172; 170, identifier:key; 171, identifier:sort_keys; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:sorted_dev_list; 177, identifier:extend; 178, argument_list; 178, 179; 179, list_comprehension; 179, 180; 179, 181; 179, 184; 180, identifier:d; 181, for_in_clause; 181, 182; 181, 183; 182, identifier:d; 183, identifier:dev_list; 184, if_clause; 184, 185; 185, comparison_operator:==; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:d; 188, identifier:sort_key; 189, identifier:key; 190, else_clause; 190, 191; 191, block; 191, 192; 191, 202; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:print; 195, argument_list; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, string:"Sort key {!r} not recognized."; 199, identifier:format; 200, argument_list; 200, 201; 201, identifier:sort_key; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:sort_keys; 205, None; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:print_device_list; 211, argument_list; 211, 212; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:device_list; 214, identifier:sorted_dev_list | def print_sorted_device_list(self, device_list=None, sort_key='sn'):
dev_list = device_list if device_list is not None else self.get_all_devices_in_portal()
sorted_dev_list = []
if sort_key == 'sn':
sort_keys = [ k[sort_key] for k in dev_list if k[sort_key] is not None ]
sort_keys = sorted(sort_keys)
for key in sort_keys:
sorted_dev_list.extend([ d for d in dev_list if d['sn'] == key ])
elif sort_key == 'name':
sort_keys = [ k['info']['description'][sort_key]\
for k in dev_list if k['info']['description'][sort_key] is not None ]
sort_keys = sorted(sort_keys)
for key in sort_keys:
sorted_dev_list.extend( [ d for d in dev_list\
if d['info']['description'][sort_key] == key
]
)
elif sort_key == 'portals_aliases':
sort_keys = [ k[sort_key] for k in dev_list if k[sort_key] is not None ]
sort_keys = sorted(sort_keys)
for key in sort_keys:
sorted_dev_list.extend([ d for d in dev_list if d[sort_key] == key ])
else:
print("Sort key {!r} not recognized.".format(sort_key))
sort_keys = None
self.print_device_list(device_list=sorted_dev_list) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:enrich; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:columns; 6, block; 6, 7; 6, 24; 6, 37; 6, 41; 6, 49; 6, 148; 6, 164; 7, for_statement; 7, 8; 7, 9; 7, 10; 8, identifier:column; 9, identifier:columns; 10, block; 10, 11; 11, if_statement; 11, 12; 11, 19; 12, comparison_operator:not; 12, 13; 12, 14; 13, identifier:column; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:data; 18, identifier:columns; 19, block; 19, 20; 20, return_statement; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:data; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:first_column; 27, call; 27, 28; 27, 29; 28, identifier:list; 29, argument_list; 29, 30; 30, subscript; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:data; 34, subscript; 34, 35; 34, 36; 35, identifier:columns; 36, integer:0; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:count; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:append_df; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:pandas; 47, identifier:DataFrame; 48, argument_list; 49, for_statement; 49, 50; 49, 51; 49, 52; 50, identifier:cell; 51, identifier:first_column; 52, block; 52, 53; 52, 142; 53, if_statement; 53, 54; 53, 60; 54, comparison_operator:>=; 54, 55; 54, 59; 55, call; 55, 56; 55, 57; 56, identifier:len; 57, argument_list; 57, 58; 58, identifier:cell; 59, integer:1; 60, block; 60, 61; 60, 69; 60, 86; 60, 107; 60, 122; 60, 134; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:df; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:pandas; 67, identifier:DataFrame; 68, argument_list; 69, for_statement; 69, 70; 69, 71; 69, 72; 70, identifier:column; 71, identifier:columns; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:df; 77, identifier:column; 78, subscript; 78, 79; 78, 84; 78, 85; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:data; 83, identifier:loc; 84, identifier:count; 85, identifier:column; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:extra_df; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:pandas; 92, identifier:DataFrame; 93, argument_list; 93, 94; 94, binary_operator:*; 94, 95; 94, 103; 95, list:[self.data.loc[count]]; 95, 96; 96, subscript; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:data; 101, identifier:loc; 102, identifier:count; 103, call; 103, 104; 103, 105; 104, identifier:len; 105, argument_list; 105, 106; 106, identifier:df; 107, for_statement; 107, 108; 107, 109; 107, 110; 108, identifier:column; 109, identifier:columns; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:extra_df; 115, identifier:column; 116, call; 116, 117; 116, 118; 117, identifier:list; 118, argument_list; 118, 119; 119, subscript; 119, 120; 119, 121; 120, identifier:df; 121, identifier:column; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:append_df; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:append_df; 128, identifier:append; 129, argument_list; 129, 130; 129, 131; 130, identifier:extra_df; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:ignore_index; 133, True; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:extra_df; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:pandas; 140, identifier:DataFrame; 141, argument_list; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:count; 145, binary_operator:+; 145, 146; 145, 147; 146, identifier:count; 147, integer:1; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:data; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:data; 158, identifier:append; 159, argument_list; 159, 160; 159, 161; 160, identifier:append_df; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:ignore_index; 163, True; 164, return_statement; 164, 165; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:data | def enrich(self, columns):
for column in columns:
if column not in self.data.columns:
return self.data
first_column = list(self.data[columns[0]])
count = 0
append_df = pandas.DataFrame()
for cell in first_column:
if len(cell) >= 1:
df = pandas.DataFrame()
for column in columns:
df[column] = self.data.loc[count, column]
extra_df = pandas.DataFrame([self.data.loc[count]] * len(df))
for column in columns:
extra_df[column] = list(df[column])
append_df = append_df.append(extra_df, ignore_index=True)
extra_df = pandas.DataFrame()
count = count + 1
self.data = self.data.append(append_df, ignore_index=True)
return self.data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:parse_metadata; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:obj; 6, identifier:xml; 7, block; 7, 8; 7, 45; 7, 82; 7, 99; 7, 131; 8, for_statement; 8, 9; 8, 10; 8, 19; 9, identifier:child; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:xml; 13, identifier:xpath; 14, argument_list; 14, 15; 14, 16; 15, string:"ti:description"; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:namespaces; 18, identifier:XPATH_NAMESPACES; 19, block; 19, 20; 19, 29; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:lg; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:child; 26, identifier:get; 27, argument_list; 27, 28; 28, string:"{http://www.w3.org/XML/1998/namespace}lang"; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:lg; 32, None; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:obj; 38, identifier:set_cts_property; 39, argument_list; 39, 40; 39, 41; 39, 44; 40, string:"description"; 41, attribute; 41, 42; 41, 43; 42, identifier:child; 43, identifier:text; 44, identifier:lg; 45, for_statement; 45, 46; 45, 47; 45, 56; 46, identifier:child; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:xml; 50, identifier:xpath; 51, argument_list; 51, 52; 51, 53; 52, string:"ti:label"; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:namespaces; 55, identifier:XPATH_NAMESPACES; 56, block; 56, 57; 56, 66; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:lg; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:child; 63, identifier:get; 64, argument_list; 64, 65; 65, string:"{http://www.w3.org/XML/1998/namespace}lang"; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:lg; 69, None; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:obj; 75, identifier:set_cts_property; 76, argument_list; 76, 77; 76, 78; 76, 81; 77, string:"label"; 78, attribute; 78, 79; 78, 80; 79, identifier:child; 80, identifier:text; 81, identifier:lg; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:obj; 86, identifier:citation; 87, call; 87, 88; 87, 93; 88, attribute; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:cls; 91, identifier:CLASS_CITATION; 92, identifier:ingest; 93, argument_list; 93, 94; 93, 95; 93, 98; 94, identifier:xml; 95, attribute; 95, 96; 95, 97; 96, identifier:obj; 97, identifier:citation; 98, string:"ti:online/ti:citationMapping/ti:citation"; 99, for_statement; 99, 100; 99, 101; 99, 110; 100, identifier:child; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:xml; 104, identifier:xpath; 105, argument_list; 105, 106; 105, 107; 106, string:"ti:about"; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:namespaces; 109, identifier:XPATH_NAMESPACES; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:obj; 115, identifier:set_link; 116, argument_list; 116, 117; 116, 125; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:RDF_NAMESPACES; 121, identifier:CTS; 122, identifier:term; 123, argument_list; 123, 124; 124, string:"about"; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:child; 128, identifier:get; 129, argument_list; 129, 130; 130, string:'urn'; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:_parse_structured_metadata; 134, argument_list; 134, 135; 134, 136; 135, identifier:obj; 136, identifier:xml | def parse_metadata(cls, obj, xml):
for child in xml.xpath("ti:description", namespaces=XPATH_NAMESPACES):
lg = child.get("{http://www.w3.org/XML/1998/namespace}lang")
if lg is not None:
obj.set_cts_property("description", child.text, lg)
for child in xml.xpath("ti:label", namespaces=XPATH_NAMESPACES):
lg = child.get("{http://www.w3.org/XML/1998/namespace}lang")
if lg is not None:
obj.set_cts_property("label", child.text, lg)
obj.citation = cls.CLASS_CITATION.ingest(xml, obj.citation, "ti:online/ti:citationMapping/ti:citation")
for child in xml.xpath("ti:about", namespaces=XPATH_NAMESPACES):
obj.set_link(RDF_NAMESPACES.CTS.term("about"), child.get('urn'))
_parse_structured_metadata(obj, xml) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:setup; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:app; 6, block; 6, 7; 6, 16; 6, 24; 6, 45; 6, 68; 6, 94; 6, 159; 6, 184; 6, 234; 6, 252; 6, 307; 6, 336; 6, 357; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 14; 9, attribute; 9, 10; 9, 13; 10, call; 10, 11; 10, 12; 11, identifier:super; 12, argument_list; 13, identifier:setup; 14, argument_list; 14, 15; 15, identifier:app; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:handlers; 21, call; 21, 22; 21, 23; 22, identifier:OrderedDict; 23, argument_list; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 37; 26, attribute; 26, 27; 26, 36; 27, attribute; 27, 28; 27, 35; 28, attribute; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:app; 32, identifier:ps; 33, identifier:jinja2; 34, identifier:cfg; 35, identifier:template_folders; 36, identifier:append; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:op; 41, identifier:join; 42, argument_list; 42, 43; 42, 44; 43, identifier:PLUGIN_ROOT; 44, string:'templates'; 45, decorated_definition; 45, 46; 45, 54; 46, decorator; 46, 47; 47, attribute; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:app; 51, identifier:ps; 52, identifier:jinja2; 53, identifier:filter; 54, function_definition; 54, 55; 54, 56; 54, 62; 55, function_name:admtest; 56, parameters; 56, 57; 56, 58; 56, 59; 57, identifier:value; 58, identifier:a; 59, default_parameter; 59, 60; 59, 61; 60, identifier:b; 61, None; 62, block; 62, 63; 63, return_statement; 63, 64; 64, conditional_expression:if; 64, 65; 64, 66; 64, 67; 65, identifier:a; 66, identifier:value; 67, identifier:b; 68, decorated_definition; 68, 69; 68, 77; 69, decorator; 69, 70; 70, attribute; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:app; 74, identifier:ps; 75, identifier:jinja2; 76, identifier:filter; 77, function_definition; 77, 78; 77, 79; 77, 85; 78, function_name:admeq; 79, parameters; 79, 80; 79, 81; 79, 82; 80, identifier:a; 81, identifier:b; 82, default_parameter; 82, 83; 82, 84; 83, identifier:result; 84, True; 85, block; 85, 86; 86, return_statement; 86, 87; 87, conditional_expression:if; 87, 88; 87, 89; 87, 92; 88, identifier:result; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:a; 91, identifier:b; 92, not_operator; 92, 93; 93, identifier:result; 94, decorated_definition; 94, 95; 94, 103; 95, decorator; 95, 96; 96, attribute; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:app; 100, identifier:ps; 101, identifier:jinja2; 102, identifier:register; 103, function_definition; 103, 104; 103, 105; 103, 108; 104, function_name:admurl; 105, parameters; 105, 106; 105, 107; 106, identifier:request; 107, identifier:prefix; 108, block; 108, 109; 108, 135; 108, 146; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:qs; 112, dictionary_comprehension; 112, 113; 112, 116; 112, 127; 113, pair; 113, 114; 113, 115; 114, identifier:k; 115, identifier:v; 116, for_in_clause; 116, 117; 116, 120; 117, pattern_list; 117, 118; 117, 119; 118, identifier:k; 119, identifier:v; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:request; 124, identifier:query; 125, identifier:items; 126, argument_list; 127, if_clause; 127, 128; 128, not_operator; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:k; 132, identifier:startswith; 133, argument_list; 133, 134; 134, identifier:prefix; 135, if_statement; 135, 136; 135, 138; 136, not_operator; 136, 137; 137, identifier:qs; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:qs; 142, dictionary; 142, 143; 143, pair; 143, 144; 143, 145; 144, string:'ap'; 145, integer:0; 146, return_statement; 146, 147; 147, binary_operator:%; 147, 148; 147, 149; 148, string:"%s?%s"; 149, tuple; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:request; 152, identifier:path; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:urlparse; 156, identifier:urlencode; 157, argument_list; 157, 158; 158, identifier:qs; 159, if_statement; 159, 160; 159, 167; 160, comparison_operator:is; 160, 161; 160, 166; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:cfg; 165, identifier:name; 166, None; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:cfg; 174, identifier:name; 175, binary_operator:%; 175, 176; 175, 177; 176, string:"%s admin"; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:app; 181, identifier:name; 182, identifier:title; 183, argument_list; 184, if_statement; 184, 185; 184, 194; 185, not_operator; 185, 186; 186, call; 186, 187; 186, 188; 187, identifier:callable; 188, argument_list; 188, 189; 189, attribute; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:cfg; 193, identifier:home; 194, block; 194, 195; 194, 226; 195, function_definition; 195, 196; 195, 197; 195, 199; 196, function_name:admin_home; 197, parameters; 197, 198; 198, identifier:request; 199, block; 199, 200; 199, 208; 200, expression_statement; 200, 201; 201, yield; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:authorize; 206, argument_list; 206, 207; 207, identifier:request; 208, return_statement; 208, 209; 209, call; 209, 210; 209, 217; 210, attribute; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:app; 214, identifier:ps; 215, identifier:jinja2; 216, identifier:render; 217, argument_list; 217, 218; 217, 223; 218, attribute; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:cfg; 222, identifier:template_home; 223, keyword_argument; 223, 224; 223, 225; 224, identifier:active; 225, None; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:cfg; 232, identifier:home; 233, identifier:admin_home; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 246; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:app; 239, identifier:register; 240, argument_list; 240, 241; 241, attribute; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:self; 244, identifier:cfg; 245, identifier:prefix; 246, argument_list; 246, 247; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:cfg; 251, identifier:home; 252, if_statement; 252, 253; 252, 259; 253, not_operator; 253, 254; 254, attribute; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:self; 257, identifier:cfg; 258, identifier:i18n; 259, block; 259, 260; 259, 306; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 273; 262, attribute; 262, 263; 262, 272; 263, attribute; 263, 264; 263, 271; 264, attribute; 264, 265; 264, 270; 265, attribute; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:app; 268, identifier:ps; 269, identifier:jinja2; 270, identifier:env; 271, identifier:globals; 272, identifier:update; 273, argument_list; 273, 274; 274, dictionary; 274, 275; 274, 281; 274, 287; 275, pair; 275, 276; 275, 277; 276, string:'_'; 277, lambda; 277, 278; 277, 280; 278, lambda_parameters; 278, 279; 279, identifier:s; 280, identifier:s; 281, pair; 281, 282; 281, 283; 282, string:'gettext'; 283, lambda; 283, 284; 283, 286; 284, lambda_parameters; 284, 285; 285, identifier:s; 286, identifier:s; 287, pair; 287, 288; 287, 289; 288, string:'ngettext'; 289, lambda; 289, 290; 289, 294; 290, lambda_parameters; 290, 291; 290, 292; 290, 293; 291, identifier:s; 292, identifier:p; 293, identifier:n; 294, subscript; 294, 295; 294, 305; 295, parenthesized_expression; 295, 296; 296, boolean_operator:or; 296, 297; 296, 303; 297, boolean_operator:and; 297, 298; 297, 301; 298, comparison_operator:!=; 298, 299; 298, 300; 299, identifier:n; 300, integer:1; 301, tuple; 301, 302; 302, identifier:p; 303, tuple; 303, 304; 304, identifier:s; 305, integer:0; 306, return_statement; 307, if_statement; 307, 308; 307, 324; 308, boolean_operator:or; 308, 309; 308, 314; 309, comparison_operator:not; 309, 310; 309, 311; 310, string:'babel'; 311, attribute; 311, 312; 311, 313; 312, identifier:app; 313, identifier:ps; 314, not_operator; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:isinstance; 317, argument_list; 317, 318; 317, 323; 318, attribute; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:app; 321, identifier:ps; 322, identifier:babel; 323, identifier:BPlugin; 324, block; 324, 325; 325, raise_statement; 325, 326; 326, call; 326, 327; 326, 328; 327, identifier:PluginException; 328, argument_list; 328, 329; 329, binary_operator:%; 329, 330; 329, 331; 330, string:'Plugin `%s` requires for plugin `%s` to be installed to the application.'; 331, tuple; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:name; 335, identifier:BPlugin; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 349; 338, attribute; 338, 339; 338, 348; 339, attribute; 339, 340; 339, 347; 340, attribute; 340, 341; 340, 346; 341, attribute; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:app; 344, identifier:ps; 345, identifier:babel; 346, identifier:cfg; 347, identifier:locales_dirs; 348, identifier:append; 349, argument_list; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:op; 353, identifier:join; 354, argument_list; 354, 355; 354, 356; 355, identifier:PLUGIN_ROOT; 356, string:'locales'; 357, if_statement; 357, 358; 357, 366; 358, not_operator; 358, 359; 359, attribute; 359, 360; 359, 365; 360, attribute; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:app; 363, identifier:ps; 364, identifier:babel; 365, identifier:locale_selector_func; 366, block; 366, 367; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 376; 369, attribute; 369, 370; 369, 375; 370, attribute; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:app; 373, identifier:ps; 374, identifier:babel; 375, identifier:locale_selector_func; 376, attribute; 376, 377; 376, 382; 377, attribute; 377, 378; 377, 381; 378, attribute; 378, 379; 378, 380; 379, identifier:app; 380, identifier:ps; 381, identifier:babel; 382, identifier:select_locale_by_request | def setup(self, app):
super().setup(app)
self.handlers = OrderedDict()
app.ps.jinja2.cfg.template_folders.append(op.join(PLUGIN_ROOT, 'templates'))
@app.ps.jinja2.filter
def admtest(value, a, b=None):
return a if value else b
@app.ps.jinja2.filter
def admeq(a, b, result=True):
return result if a == b else not result
@app.ps.jinja2.register
def admurl(request, prefix):
qs = {k: v for k, v in request.query.items() if not k.startswith(prefix)}
if not qs:
qs = {'ap': 0}
return "%s?%s" % (request.path, urlparse.urlencode(qs))
if self.cfg.name is None:
self.cfg.name = "%s admin" % app.name.title()
if not callable(self.cfg.home):
def admin_home(request):
yield from self.authorize(request)
return app.ps.jinja2.render(self.cfg.template_home, active=None)
self.cfg.home = admin_home
app.register(self.cfg.prefix)(self.cfg.home)
if not self.cfg.i18n:
app.ps.jinja2.env.globals.update({
'_': lambda s: s,
'gettext': lambda s: s,
'ngettext': lambda s, p, n: (n != 1 and (p,) or (s,))[0],
})
return
if 'babel' not in app.ps or not isinstance(app.ps.babel, BPlugin):
raise PluginException(
'Plugin `%s` requires for plugin `%s` to be installed to the application.' % (
self.name, BPlugin))
app.ps.babel.cfg.locales_dirs.append(op.join(PLUGIN_ROOT, 'locales'))
if not app.ps.babel.locale_selector_func:
app.ps.babel.locale_selector_func = app.ps.babel.select_locale_by_request |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:passageLoop; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:parent; 5, identifier:new_tree; 6, identifier:xpath1; 7, default_parameter; 7, 8; 7, 9; 8, identifier:xpath2; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:preceding_siblings; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:following_siblings; 15, False; 16, block; 16, 17; 16, 26; 16, 395; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, pattern_list; 19, 20; 19, 21; 20, identifier:current_1; 21, identifier:queue_1; 22, call; 22, 23; 22, 24; 23, identifier:__formatXpath__; 24, argument_list; 24, 25; 25, identifier:xpath1; 26, if_statement; 26, 27; 26, 30; 26, 152; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:xpath2; 29, None; 30, block; 30, 31; 30, 41; 30, 50; 30, 54; 30, 63; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, pattern_list; 33, 34; 33, 35; 34, identifier:result_1; 35, identifier:loop; 36, call; 36, 37; 36, 38; 37, identifier:performXpath; 38, argument_list; 38, 39; 38, 40; 39, identifier:parent; 40, identifier:current_1; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:loop; 44, True; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:queue_1; 49, identifier:xpath1; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:central; 53, None; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:has_no_queue; 57, comparison_operator:==; 57, 58; 57, 62; 58, call; 58, 59; 58, 60; 59, identifier:len; 60, argument_list; 60, 61; 61, identifier:queue_1; 62, integer:0; 63, if_statement; 63, 64; 63, 67; 64, boolean_operator:or; 64, 65; 64, 66; 65, identifier:preceding_siblings; 66, identifier:following_siblings; 67, block; 67, 68; 68, for_statement; 68, 69; 68, 70; 68, 74; 69, identifier:sibling; 70, call; 70, 71; 70, 72; 71, identifier:xmliter; 72, argument_list; 72, 73; 73, identifier:parent; 74, block; 74, 75; 75, if_statement; 75, 76; 75, 79; 75, 119; 75, 136; 76, comparison_operator:==; 76, 77; 76, 78; 77, identifier:sibling; 78, identifier:result_1; 79, block; 79, 80; 79, 84; 79, 97; 79, 115; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:central; 83, True; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:child; 87, call; 87, 88; 87, 89; 88, identifier:copyNode; 89, argument_list; 89, 90; 89, 91; 89, 94; 90, identifier:result_1; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:children; 93, identifier:has_no_queue; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:parent; 96, identifier:new_tree; 97, if_statement; 97, 98; 97, 100; 98, not_operator; 98, 99; 99, identifier:has_no_queue; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:passageLoop; 104, argument_list; 104, 105; 104, 106; 104, 107; 104, 108; 104, 109; 104, 112; 105, identifier:result_1; 106, identifier:child; 107, identifier:queue_1; 108, None; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:preceding_siblings; 111, identifier:preceding_siblings; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:following_siblings; 114, identifier:following_siblings; 115, if_statement; 115, 116; 115, 117; 116, identifier:preceding_siblings; 117, block; 117, 118; 118, break_statement; 119, elif_clause; 119, 120; 119, 124; 120, boolean_operator:and; 120, 121; 120, 123; 121, not_operator; 121, 122; 122, identifier:central; 123, identifier:preceding_siblings; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:copyNode; 128, argument_list; 128, 129; 128, 130; 128, 133; 129, identifier:sibling; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:parent; 132, identifier:new_tree; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:children; 135, True; 136, elif_clause; 136, 137; 136, 140; 137, boolean_operator:and; 137, 138; 137, 139; 138, identifier:central; 139, identifier:following_siblings; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:copyNode; 144, argument_list; 144, 145; 144, 146; 144, 149; 145, identifier:sibling; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:parent; 148, identifier:new_tree; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:children; 151, True; 152, else_clause; 152, 153; 153, block; 153, 154; 153, 164; 153, 208; 153, 238; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 159; 156, pattern_list; 156, 157; 156, 158; 157, identifier:result_1; 158, identifier:loop; 159, call; 159, 160; 159, 161; 160, identifier:performXpath; 161, argument_list; 161, 162; 161, 163; 162, identifier:parent; 163, identifier:current_1; 164, if_statement; 164, 165; 164, 168; 164, 197; 165, comparison_operator:is; 165, 166; 165, 167; 166, identifier:loop; 167, True; 168, block; 168, 169; 168, 173; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:queue_1; 172, identifier:xpath1; 173, if_statement; 173, 174; 173, 177; 173, 186; 174, comparison_operator:==; 174, 175; 174, 176; 175, identifier:xpath2; 176, identifier:xpath1; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, pattern_list; 180, 181; 180, 182; 181, identifier:current_2; 182, identifier:queue_2; 183, expression_list; 183, 184; 183, 185; 184, identifier:current_1; 185, identifier:queue_1; 186, else_clause; 186, 187; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, pattern_list; 190, 191; 190, 192; 191, identifier:current_2; 192, identifier:queue_2; 193, call; 193, 194; 193, 195; 194, identifier:__formatXpath__; 195, argument_list; 195, 196; 196, identifier:xpath2; 197, else_clause; 197, 198; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, pattern_list; 201, 202; 201, 203; 202, identifier:current_2; 203, identifier:queue_2; 204, call; 204, 205; 204, 206; 205, identifier:__formatXpath__; 206, argument_list; 206, 207; 207, identifier:xpath2; 208, if_statement; 208, 209; 208, 212; 208, 232; 209, comparison_operator:!=; 209, 210; 209, 211; 210, identifier:xpath1; 211, identifier:xpath2; 212, block; 212, 213; 212, 223; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 218; 215, pattern_list; 215, 216; 215, 217; 216, identifier:result_2; 217, identifier:loop; 218, call; 218, 219; 218, 220; 219, identifier:performXpath; 220, argument_list; 220, 221; 220, 222; 221, identifier:parent; 222, identifier:current_2; 223, if_statement; 223, 224; 223, 227; 224, comparison_operator:is; 224, 225; 224, 226; 225, identifier:loop; 226, True; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:queue_2; 231, identifier:xpath2; 232, else_clause; 232, 233; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:result_2; 237, identifier:result_1; 238, if_statement; 238, 239; 238, 242; 238, 277; 239, comparison_operator:==; 239, 240; 239, 241; 240, identifier:result_1; 241, identifier:result_2; 242, block; 242, 243; 242, 252; 242, 265; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:has_no_queue; 246, comparison_operator:==; 246, 247; 246, 251; 247, call; 247, 248; 247, 249; 248, identifier:len; 249, argument_list; 249, 250; 250, identifier:queue_1; 251, integer:0; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:child; 255, call; 255, 256; 255, 257; 256, identifier:copyNode; 257, argument_list; 257, 258; 257, 259; 257, 262; 258, identifier:result_1; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:children; 261, identifier:has_no_queue; 262, keyword_argument; 262, 263; 262, 264; 263, identifier:parent; 264, identifier:new_tree; 265, if_statement; 265, 266; 265, 268; 266, not_operator; 266, 267; 267, identifier:has_no_queue; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 272; 271, identifier:passageLoop; 272, argument_list; 272, 273; 272, 274; 272, 275; 272, 276; 273, identifier:result_1; 274, identifier:child; 275, identifier:queue_1; 276, identifier:queue_2; 277, else_clause; 277, 278; 278, block; 278, 279; 278, 283; 278, 358; 278, 367; 278, 380; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:start; 282, False; 283, for_statement; 283, 284; 283, 285; 283, 289; 284, identifier:sibling; 285, call; 285, 286; 285, 287; 286, identifier:xmliter; 287, argument_list; 287, 288; 288, identifier:parent; 289, block; 289, 290; 290, if_statement; 290, 291; 290, 292; 290, 312; 291, identifier:start; 292, block; 292, 293; 293, if_statement; 293, 294; 293, 297; 293, 299; 294, comparison_operator:==; 294, 295; 294, 296; 295, identifier:sibling; 296, identifier:result_2; 297, block; 297, 298; 298, break_statement; 299, else_clause; 299, 300; 300, block; 300, 301; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 304; 303, identifier:copyNode; 304, argument_list; 304, 305; 304, 306; 304, 309; 305, identifier:sibling; 306, keyword_argument; 306, 307; 306, 308; 307, identifier:parent; 308, identifier:new_tree; 309, keyword_argument; 309, 310; 309, 311; 310, identifier:children; 311, True; 312, elif_clause; 312, 313; 312, 316; 313, comparison_operator:==; 313, 314; 313, 315; 314, identifier:sibling; 315, identifier:result_1; 316, block; 316, 317; 316, 321; 316, 330; 316, 343; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:start; 320, True; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:has_no_queue_1; 324, comparison_operator:==; 324, 325; 324, 329; 325, call; 325, 326; 325, 327; 326, identifier:len; 327, argument_list; 327, 328; 328, identifier:queue_1; 329, integer:0; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:node; 333, call; 333, 334; 333, 335; 334, identifier:copyNode; 335, argument_list; 335, 336; 335, 337; 335, 340; 336, identifier:sibling; 337, keyword_argument; 337, 338; 337, 339; 338, identifier:children; 339, identifier:has_no_queue_1; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:parent; 342, identifier:new_tree; 343, if_statement; 343, 344; 343, 346; 344, not_operator; 344, 345; 345, identifier:has_no_queue_1; 346, block; 346, 347; 347, expression_statement; 347, 348; 348, call; 348, 349; 348, 350; 349, identifier:passageLoop; 350, argument_list; 350, 351; 350, 352; 350, 353; 350, 354; 350, 355; 351, identifier:sibling; 352, identifier:node; 353, identifier:queue_1; 354, None; 355, keyword_argument; 355, 356; 355, 357; 356, identifier:following_siblings; 357, True; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:continue_loop; 361, comparison_operator:==; 361, 362; 361, 366; 362, call; 362, 363; 362, 364; 363, identifier:len; 364, argument_list; 364, 365; 365, identifier:queue_2; 366, integer:0; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 370; 369, identifier:node; 370, call; 370, 371; 370, 372; 371, identifier:copyNode; 372, argument_list; 372, 373; 372, 374; 372, 377; 373, identifier:result_2; 374, keyword_argument; 374, 375; 374, 376; 375, identifier:children; 376, identifier:continue_loop; 377, keyword_argument; 377, 378; 377, 379; 378, identifier:parent; 379, identifier:new_tree; 380, if_statement; 380, 381; 380, 383; 381, not_operator; 381, 382; 382, identifier:continue_loop; 383, block; 383, 384; 384, expression_statement; 384, 385; 385, call; 385, 386; 385, 387; 386, identifier:passageLoop; 387, argument_list; 387, 388; 387, 389; 387, 390; 387, 391; 387, 392; 388, identifier:result_2; 389, identifier:node; 390, identifier:queue_2; 391, None; 392, keyword_argument; 392, 393; 392, 394; 393, identifier:preceding_siblings; 394, True; 395, return_statement; 395, 396; 396, identifier:new_tree | def passageLoop(parent, new_tree, xpath1, xpath2=None, preceding_siblings=False, following_siblings=False):
current_1, queue_1 = __formatXpath__(xpath1)
if xpath2 is None:
result_1, loop = performXpath(parent, current_1)
if loop is True:
queue_1 = xpath1
central = None
has_no_queue = len(queue_1) == 0
if preceding_siblings or following_siblings:
for sibling in xmliter(parent):
if sibling == result_1:
central = True
child = copyNode(result_1, children=has_no_queue, parent=new_tree)
if not has_no_queue:
passageLoop(
result_1,
child,
queue_1,
None,
preceding_siblings=preceding_siblings,
following_siblings=following_siblings
)
if preceding_siblings:
break
elif not central and preceding_siblings:
copyNode(sibling, parent=new_tree, children=True)
elif central and following_siblings:
copyNode(sibling, parent=new_tree, children=True)
else:
result_1, loop = performXpath(parent, current_1)
if loop is True:
queue_1 = xpath1
if xpath2 == xpath1:
current_2, queue_2 = current_1, queue_1
else:
current_2, queue_2 = __formatXpath__(xpath2)
else:
current_2, queue_2 = __formatXpath__(xpath2)
if xpath1 != xpath2:
result_2, loop = performXpath(parent, current_2)
if loop is True:
queue_2 = xpath2
else:
result_2 = result_1
if result_1 == result_2:
has_no_queue = len(queue_1) == 0
child = copyNode(result_1, children=has_no_queue, parent=new_tree)
if not has_no_queue:
passageLoop(
result_1,
child,
queue_1,
queue_2
)
else:
start = False
for sibling in xmliter(parent):
if start:
if sibling == result_2:
break
else:
copyNode(sibling, parent=new_tree, children=True)
elif sibling == result_1:
start = True
has_no_queue_1 = len(queue_1) == 0
node = copyNode(sibling, children=has_no_queue_1, parent=new_tree)
if not has_no_queue_1:
passageLoop(sibling, node, queue_1, None, following_siblings=True)
continue_loop = len(queue_2) == 0
node = copyNode(result_2, children=continue_loop, parent=new_tree)
if not continue_loop:
passageLoop(result_2, node, queue_2, None, preceding_siblings=True)
return new_tree |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 1, 21; 2, function_name:cancellable_wait; 3, parameters; 3, 4; 3, 5; 3, 14; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 8; 6, list_splat_pattern; 6, 7; 7, identifier:awaitables; 8, type; 8, 9; 9, generic_type; 9, 10; 9, 11; 10, identifier:Awaitable; 11, type_parameter; 11, 12; 12, type; 12, 13; 13, identifier:_R; 14, typed_default_parameter; 14, 15; 14, 16; 14, 18; 15, identifier:timeout; 16, type; 16, 17; 17, identifier:float; 18, None; 19, type; 19, 20; 20, identifier:_R; 21, block; 21, 22; 21, 47; 21, 92; 21, 102; 21, 110; 21, 139; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:futures; 25, list_comprehension; 25, 26; 25, 37; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:asyncio; 29, identifier:ensure_future; 30, argument_list; 30, 31; 30, 32; 31, identifier:a; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:loop; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:loop; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:a; 39, binary_operator:+; 39, 40; 39, 41; 40, identifier:awaitables; 41, tuple; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:wait; 46, argument_list; 47, try_statement; 47, 48; 47, 74; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, pattern_list; 51, 52; 51, 53; 52, identifier:done; 53, identifier:pending; 54, await; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:asyncio; 58, identifier:wait; 59, argument_list; 59, 60; 59, 61; 59, 64; 59, 69; 60, identifier:futures; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:timeout; 63, identifier:timeout; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:return_when; 66, attribute; 66, 67; 66, 68; 67, identifier:asyncio; 68, identifier:FIRST_COMPLETED; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:loop; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:loop; 74, except_clause; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:asyncio; 78, identifier:futures; 79, identifier:CancelledError; 80, block; 80, 81; 80, 91; 81, for_statement; 81, 82; 81, 83; 81, 84; 82, identifier:future; 83, identifier:futures; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:future; 89, identifier:cancel; 90, argument_list; 91, raise_statement; 92, for_statement; 92, 93; 92, 94; 92, 95; 93, identifier:task; 94, identifier:pending; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:task; 100, identifier:cancel; 101, argument_list; 102, if_statement; 102, 103; 102, 105; 103, not_operator; 103, 104; 104, identifier:done; 105, block; 105, 106; 106, raise_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:TimeoutError; 109, argument_list; 110, if_statement; 110, 111; 110, 116; 111, comparison_operator:is; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:triggered_token; 115, None; 116, block; 116, 117; 116, 127; 117, for_statement; 117, 118; 117, 119; 117, 120; 118, identifier:task; 119, identifier:done; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:task; 125, identifier:exception; 126, argument_list; 127, raise_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:OperationCancelled; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, string:"Cancellation requested by {} token"; 134, identifier:format; 135, argument_list; 135, 136; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:triggered_token; 139, return_statement; 139, 140; 140, call; 140, 141; 140, 148; 141, attribute; 141, 142; 141, 147; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:done; 145, identifier:pop; 146, argument_list; 147, identifier:result; 148, argument_list | async def cancellable_wait(self, *awaitables: Awaitable[_R], timeout: float = None) -> _R:
futures = [asyncio.ensure_future(a, loop=self.loop) for a in awaitables + (self.wait(),)]
try:
done, pending = await asyncio.wait(
futures,
timeout=timeout,
return_when=asyncio.FIRST_COMPLETED,
loop=self.loop,
)
except asyncio.futures.CancelledError:
for future in futures:
future.cancel()
raise
for task in pending:
task.cancel()
if not done:
raise TimeoutError()
if self.triggered_token is not None:
for task in done:
task.exception()
raise OperationCancelled(
"Cancellation requested by {} token".format(self.triggered_token)
)
return done.pop().result() |
0, module; 0, 1; 0, 10; 0, 12; 0, 23; 0, 29; 0, 33; 0, 37; 0, 210; 0, 218; 0, 227; 0, 245; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_tweets_count_times; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:twitter; 5, identifier:count; 6, default_parameter; 6, 7; 6, 8; 7, identifier:query; 8, None; 9, block:; 10, expression_statement; 10, 11; 11, identifier:r; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 17; 14, pattern_list; 14, 15; 14, 16; 15, identifier:oldest_id; 16, identifier:newest_id; 17, call; 17, 18; 17, 19; 18, identifier:_get_oldest_id; 19, argument_list; 19, 20; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:query; 22, identifier:query; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:newest_id; 26, boolean_operator:or; 26, 27; 26, 28; 27, identifier:newest_id; 28, identifier:oldest_id; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:all_tweets; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:i; 36, integer:0; 37, while_statement; 37, 38; 37, 41; 38, comparison_operator:<; 38, 39; 38, 40; 39, identifier:i; 40, identifier:count; 41, block; 41, 42; 41, 46; 41, 96; 41, 105; 41, 114; 41, 151; 41, 158; 41, 168; 41, 178; 41, 192; 42, expression_statement; 42, 43; 43, augmented_assignment:+=; 43, 44; 43, 45; 44, identifier:i; 45, integer:1; 46, if_statement; 46, 47; 46, 50; 46, 71; 47, comparison_operator:<=; 47, 48; 47, 49; 48, identifier:oldest_id; 49, identifier:newest_id; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:tweets; 54, call; 54, 55; 54, 56; 55, identifier:get_tweets; 56, argument_list; 56, 57; 56, 60; 56, 65; 56, 68; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:query; 59, identifier:query; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:max_id; 62, binary_operator:-; 62, 63; 62, 64; 63, identifier:oldest_id; 64, integer:1; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:count; 67, identifier:TWEETS_PER_SEARCH; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:twitter; 70, identifier:twitter; 71, else_clause; 71, 72; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:tweets; 76, call; 76, 77; 76, 78; 77, identifier:get_tweets; 78, argument_list; 78, 79; 78, 82; 78, 87; 78, 90; 78, 93; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:query; 81, identifier:query; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:max_id; 84, binary_operator:-; 84, 85; 84, 86; 85, identifier:oldest_id; 86, integer:1; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:since_id; 89, identifier:newest_id; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:count; 92, identifier:TWEETS_PER_SEARCH; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:twitter; 95, identifier:twitter; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:rate_limit_remaining; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:twitter; 102, identifier:get_lastfunction_header; 103, argument_list; 103, 104; 104, string:'x-rate-limit-remaining'; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:rate_limit_reset; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:twitter; 111, identifier:get_lastfunction_header; 112, argument_list; 112, 113; 113, string:'x-rate-limit-reset'; 114, if_statement; 114, 115; 114, 120; 114, 138; 115, not_operator; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:len; 118, argument_list; 118, 119; 119, identifier:tweets; 120, block; 120, 121; 120, 137; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:oldest_id; 124, binary_operator:+; 124, 125; 124, 126; 125, identifier:oldest_id; 126, binary_operator:*; 126, 127; 126, 136; 127, parenthesized_expression; 127, 128; 128, binary_operator:+; 128, 129; 128, 135; 129, binary_operator:-; 129, 130; 129, 134; 130, parenthesized_expression; 130, 131; 131, boolean_operator:or; 131, 132; 131, 133; 132, identifier:newest_id; 133, identifier:oldest_id; 134, identifier:oldest_id; 135, integer:1; 136, integer:10000; 137, break_statement; 138, elif_clause; 138, 139; 138, 144; 139, call; 139, 140; 139, 141; 140, identifier:isinstance; 141, argument_list; 141, 142; 141, 143; 142, identifier:tweets; 143, identifier:dict; 144, block; 144, 145; 144, 150; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:print; 148, argument_list; 148, 149; 149, identifier:tweets; 150, break_statement; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:all_tweets; 155, identifier:extend; 156, argument_list; 156, 157; 157, identifier:tweets; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:tweet_ids; 161, set_comprehension; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:t; 164, string:'id'; 165, for_in_clause; 165, 166; 165, 167; 166, identifier:t; 167, identifier:tweets; 168, if_statement; 168, 169; 168, 170; 169, identifier:oldest_id; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:tweet_ids; 175, identifier:add; 176, argument_list; 176, 177; 177, identifier:oldest_id; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, pattern_list; 180, 181; 180, 182; 181, identifier:oldest_id; 182, identifier:newest_id; 183, expression_list; 183, 184; 183, 188; 184, call; 184, 185; 184, 186; 185, identifier:min; 186, argument_list; 186, 187; 187, identifier:tweet_ids; 188, call; 188, 189; 188, 190; 189, identifier:max; 190, argument_list; 190, 191; 191, identifier:tweet_ids; 192, if_statement; 192, 193; 192, 196; 193, comparison_operator:==; 193, 194; 193, 195; 194, identifier:rate_limit_remaining; 195, integer:1; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:time; 201, identifier:sleep; 202, argument_list; 202, 203; 203, binary_operator:-; 203, 204; 203, 205; 204, identifier:rate_limit_reset; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:time; 208, identifier:time; 209, argument_list; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:save_tweets; 213, argument_list; 213, 214; 213, 215; 214, identifier:all_tweets; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:query; 217, identifier:query; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:_set_oldest_id; 221, argument_list; 221, 222; 221, 223; 221, 224; 222, identifier:oldest_id; 223, identifier:newest_id; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:query; 226, identifier:query; 227, if_statement; 227, 228; 227, 234; 228, comparison_operator:==; 228, 229; 228, 233; 229, call; 229, 230; 229, 231; 230, identifier:len; 231, argument_list; 231, 232; 232, identifier:all_tweets; 233, integer:0; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:os; 239, identifier:remove; 240, argument_list; 240, 241; 241, call; 241, 242; 241, 243; 242, identifier:make_oldest_id_path; 243, argument_list; 243, 244; 244, identifier:query; 245, return_statement; 245, 246; 246, expression_list; 246, 247; 246, 251; 247, call; 247, 248; 247, 249; 248, identifier:len; 249, argument_list; 249, 250; 250, identifier:all_tweets; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:twitter; 254, identifier:get_lastfunction_header; 255, argument_list; 255, 256; 256, string:'x-rate-limit-remaining' | def get_tweets_count_times(twitter, count, query=None):
r
oldest_id, newest_id = _get_oldest_id(query=query)
newest_id = newest_id or oldest_id
all_tweets = []
i = 0
while i < count:
i += 1
if oldest_id <= newest_id:
tweets = get_tweets(query=query, max_id=oldest_id - 1, count=TWEETS_PER_SEARCH, twitter=twitter)
else:
tweets = get_tweets(query=query, max_id=oldest_id - 1, since_id=newest_id, count=TWEETS_PER_SEARCH, twitter=twitter)
rate_limit_remaining = twitter.get_lastfunction_header('x-rate-limit-remaining')
rate_limit_reset = twitter.get_lastfunction_header('x-rate-limit-reset')
if not len(tweets):
oldest_id = oldest_id + ((newest_id or oldest_id) - oldest_id + 1) * 10000
break
elif isinstance(tweets, dict):
print(tweets)
break
all_tweets.extend(tweets)
tweet_ids = {t['id'] for t in tweets}
if oldest_id:
tweet_ids.add(oldest_id)
oldest_id, newest_id = min(tweet_ids), max(tweet_ids)
if rate_limit_remaining == 1:
time.sleep(rate_limit_reset - time.time())
save_tweets(all_tweets, query=query)
_set_oldest_id(oldest_id, newest_id, query=query)
if len(all_tweets) == 0:
os.remove(make_oldest_id_path(query))
return len(all_tweets), twitter.get_lastfunction_header('x-rate-limit-remaining') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:register; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:cls; 5, identifier:code; 6, identifier:name; 7, default_parameter; 7, 8; 7, 9; 8, identifier:hash_name; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:hash_new; 12, None; 13, block; 13, 14; 13, 26; 13, 42; 13, 70; 13, 84; 14, if_statement; 14, 15; 14, 20; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:_is_app_specific_func; 18, argument_list; 18, 19; 19, identifier:code; 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:"only application-specific functions can be registered"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:name_mapping_data; 29, list:[
(cls._func_from_name, name,
"function name is already registered for a different function"),
(cls._func_from_hash, hash_name,
"hashlib name is already registered for a different function")]; 29, 30; 29, 36; 30, tuple; 30, 31; 30, 34; 30, 35; 31, attribute; 31, 32; 31, 33; 32, identifier:cls; 33, identifier:_func_from_name; 34, identifier:name; 35, string:"function name is already registered for a different function"; 36, tuple; 36, 37; 36, 40; 36, 41; 37, attribute; 37, 38; 37, 39; 38, identifier:cls; 39, identifier:_func_from_hash; 40, identifier:hash_name; 41, string:"hashlib name is already registered for a different function"; 42, for_statement; 42, 43; 42, 47; 42, 48; 43, tuple_pattern; 43, 44; 43, 45; 43, 46; 44, identifier:mapping; 45, identifier:nameinmap; 46, identifier:errmsg; 47, identifier:name_mapping_data; 48, block; 48, 49; 48, 59; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:existing_func; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:mapping; 55, identifier:get; 56, argument_list; 56, 57; 56, 58; 57, identifier:nameinmap; 58, identifier:code; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:!=; 60, 61; 60, 62; 61, identifier:existing_func; 62, identifier:code; 63, block; 63, 64; 64, raise_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:ValueError; 67, argument_list; 67, 68; 67, 69; 68, identifier:errmsg; 69, identifier:existing_func; 70, if_statement; 70, 71; 70, 76; 71, comparison_operator:in; 71, 72; 71, 73; 72, identifier:code; 73, attribute; 73, 74; 73, 75; 74, identifier:cls; 75, identifier:_func_hash; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:cls; 81, identifier:unregister; 82, argument_list; 82, 83; 83, identifier:code; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:cls; 88, identifier:_do_register; 89, argument_list; 89, 90; 89, 91; 89, 92; 89, 93; 90, identifier:code; 91, identifier:name; 92, identifier:hash_name; 93, identifier:hash_new | def register(cls, code, name, hash_name=None, hash_new=None):
if not _is_app_specific_func(code):
raise ValueError(
"only application-specific functions can be registered")
name_mapping_data = [
(cls._func_from_name, name,
"function name is already registered for a different function"),
(cls._func_from_hash, hash_name,
"hashlib name is already registered for a different function")]
for (mapping, nameinmap, errmsg) in name_mapping_data:
existing_func = mapping.get(nameinmap, code)
if existing_func != code:
raise ValueError(errmsg, existing_func)
if code in cls._func_hash:
cls.unregister(code)
cls._do_register(code, name, hash_name, hash_new) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:compile_vocab; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:docs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:limit; 7, float:1e6; 8, default_parameter; 8, 9; 8, 10; 9, identifier:verbose; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:tokenizer; 13, call; 13, 14; 13, 15; 14, identifier:Tokenizer; 15, argument_list; 15, 16; 15, 19; 15, 22; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:stem; 18, None; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:lower; 21, None; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:strip; 24, None; 25, block; 25, 26; 25, 33; 25, 39; 25, 67; 25, 170; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:tokenizer; 29, call; 29, 30; 29, 31; 30, identifier:make_tokenizer; 31, argument_list; 31, 32; 32, identifier:tokenizer; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:d; 36, call; 36, 37; 36, 38; 37, identifier:Dictionary; 38, argument_list; 39, try_statement; 39, 40; 39, 61; 40, block; 40, 41; 40, 53; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:limit; 44, call; 44, 45; 44, 46; 45, identifier:min; 46, argument_list; 46, 47; 46, 48; 47, identifier:limit; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:docs; 51, identifier:count; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:docs; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:docs; 59, identifier:iterator; 60, argument_list; 61, except_clause; 61, 62; 61, 65; 62, tuple; 62, 63; 62, 64; 63, identifier:AttributeError; 64, identifier:TypeError; 65, block; 65, 66; 66, pass_statement; 67, for_statement; 67, 68; 67, 71; 67, 75; 68, pattern_list; 68, 69; 68, 70; 69, identifier:i; 70, identifier:doc; 71, call; 71, 72; 71, 73; 72, identifier:enumerate; 73, argument_list; 73, 74; 74, identifier:docs; 75, block; 75, 76; 75, 122; 75, 128; 75, 142; 76, try_statement; 76, 77; 76, 86; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:doc; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:doc; 84, identifier:values; 85, argument_list; 86, except_clause; 86, 87; 86, 88; 87, identifier:AttributeError; 88, block; 88, 89; 89, if_statement; 89, 90; 89, 96; 89, 113; 90, not_operator; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:isinstance; 93, argument_list; 93, 94; 93, 95; 94, identifier:doc; 95, identifier:str; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:doc; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, string:' '; 103, identifier:join; 104, argument_list; 104, 105; 105, list_comprehension; 105, 106; 105, 110; 106, call; 106, 107; 106, 108; 107, identifier:str; 108, argument_list; 108, 109; 109, identifier:v; 110, for_in_clause; 110, 111; 110, 112; 111, identifier:v; 112, identifier:doc; 113, else_clause; 113, 114; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:doc; 118, call; 118, 119; 118, 120; 119, identifier:str; 120, argument_list; 120, 121; 121, identifier:doc; 122, if_statement; 122, 123; 122, 126; 123, comparison_operator:>=; 123, 124; 123, 125; 124, identifier:i; 125, identifier:limit; 126, block; 126, 127; 127, break_statement; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:d; 132, identifier:add_documents; 133, argument_list; 133, 134; 134, list:[list(tokenizer(doc))]; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:list; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:tokenizer; 140, argument_list; 140, 141; 141, identifier:doc; 142, if_statement; 142, 143; 142, 149; 143, boolean_operator:and; 143, 144; 143, 145; 144, identifier:verbose; 145, not_operator; 145, 146; 146, binary_operator:%; 146, 147; 146, 148; 147, identifier:i; 148, integer:100; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:log; 154, identifier:info; 155, argument_list; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, string:'{}: {}'; 159, identifier:format; 160, argument_list; 160, 161; 160, 162; 161, identifier:i; 162, subscript; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:repr; 165, argument_list; 165, 166; 166, identifier:d; 167, slice; 167, 168; 167, 169; 168, colon; 169, integer:120; 170, return_statement; 170, 171; 171, identifier:d | def compile_vocab(docs, limit=1e6, verbose=0, tokenizer=Tokenizer(stem=None, lower=None, strip=None)):
tokenizer = make_tokenizer(tokenizer)
d = Dictionary()
try:
limit = min(limit, docs.count())
docs = docs.iterator()
except (AttributeError, TypeError):
pass
for i, doc in enumerate(docs):
try:
doc = doc.values()
except AttributeError:
if not isinstance(doc, str):
doc = ' '.join([str(v) for v in doc])
else:
doc = str(doc)
if i >= limit:
break
d.add_documents([list(tokenizer(doc))])
if verbose and not i % 100:
log.info('{}: {}'.format(i, repr(d)[:120]))
return d |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:resource; 6, block; 6, 7; 6, 11; 6, 15; 6, 19; 6, 61; 6, 118; 6, 141; 6, 155; 6, 162; 6, 172; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:textgroups; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:texts; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:invalids; 18, list:[]; 19, for_statement; 19, 20; 19, 21; 19, 22; 20, identifier:folder; 21, identifier:resource; 22, block; 22, 23; 22, 37; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:cts_files; 26, call; 26, 27; 26, 28; 27, identifier:glob; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, string:"{base_folder}/data/*/__cts__.xml"; 32, identifier:format; 33, argument_list; 33, 34; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:base_folder; 36, identifier:folder; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:cts_file; 39, identifier:cts_files; 40, block; 40, 41; 40, 52; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 46; 43, pattern_list; 43, 44; 43, 45; 44, identifier:textgroup; 45, identifier:cts_file; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_parse_textgroup; 50, argument_list; 50, 51; 51, identifier:cts_file; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:textgroups; 56, identifier:append; 57, argument_list; 57, 58; 58, tuple; 58, 59; 58, 60; 59, identifier:textgroup; 60, identifier:cts_file; 61, for_statement; 61, 62; 61, 65; 61, 66; 62, pattern_list; 62, 63; 62, 64; 63, identifier:textgroup; 64, identifier:cts_textgroup_file; 65, identifier:textgroups; 66, block; 66, 67; 66, 88; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:cts_work_files; 70, call; 70, 71; 70, 72; 71, identifier:glob; 72, argument_list; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, string:"{parent}/*/__cts__.xml"; 76, identifier:format; 77, argument_list; 77, 78; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:parent; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:os; 84, identifier:path; 85, identifier:dirname; 86, argument_list; 86, 87; 87, identifier:cts_textgroup_file; 88, for_statement; 88, 89; 88, 90; 88, 91; 89, identifier:cts_work_file; 90, identifier:cts_work_files; 91, block; 91, 92; 91, 105; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 98; 94, pattern_list; 94, 95; 94, 96; 94, 97; 95, identifier:_; 96, identifier:parsed_texts; 97, identifier:directory; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_parse_work; 102, argument_list; 102, 103; 102, 104; 103, identifier:cts_work_file; 104, identifier:textgroup; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:texts; 109, identifier:extend; 110, argument_list; 110, 111; 111, list_comprehension; 111, 112; 111, 115; 112, tuple; 112, 113; 112, 114; 113, identifier:text; 114, identifier:directory; 115, for_in_clause; 115, 116; 115, 117; 116, identifier:text; 117, identifier:parsed_texts; 118, for_statement; 118, 119; 118, 122; 118, 123; 119, pattern_list; 119, 120; 119, 121; 120, identifier:text; 121, identifier:directory; 122, identifier:texts; 123, block; 123, 124; 124, if_statement; 124, 125; 124, 133; 125, not_operator; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_parse_text; 130, argument_list; 130, 131; 130, 132; 131, identifier:text; 132, identifier:directory; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:invalids; 138, identifier:append; 139, argument_list; 139, 140; 140, identifier:text; 141, for_statement; 141, 142; 141, 145; 141, 146; 142, pattern_list; 142, 143; 142, 144; 143, identifier:textgroup; 144, identifier:textgroup_path; 145, identifier:textgroups; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:_dispatch_container; 152, argument_list; 152, 153; 152, 154; 153, identifier:textgroup; 154, identifier:textgroup_path; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:_clean_invalids; 160, argument_list; 160, 161; 161, identifier:invalids; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:inventory; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:dispatcher; 171, identifier:collection; 172, return_statement; 172, 173; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:inventory | def parse(self, resource):
textgroups = []
texts = []
invalids = []
for folder in resource:
cts_files = glob("{base_folder}/data/*/__cts__.xml".format(base_folder=folder))
for cts_file in cts_files:
textgroup, cts_file = self._parse_textgroup(cts_file)
textgroups.append((textgroup, cts_file))
for textgroup, cts_textgroup_file in textgroups:
cts_work_files = glob("{parent}/*/__cts__.xml".format(parent=os.path.dirname(cts_textgroup_file)))
for cts_work_file in cts_work_files:
_, parsed_texts, directory = self._parse_work(cts_work_file, textgroup)
texts.extend([(text, directory) for text in parsed_texts])
for text, directory in texts:
if not self._parse_text(text, directory):
invalids.append(text)
for textgroup, textgroup_path in textgroups:
self._dispatch_container(textgroup, textgroup_path)
self._clean_invalids(invalids)
self.inventory = self.dispatcher.collection
return self.inventory |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:generate_address_label; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 22; 5, 38; 5, 56; 5, 81; 5, 95; 5, 128; 5, 138; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:organisation_name; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:address_label; 17, identifier:append; 18, argument_list; 18, 19; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:organisation_name; 22, if_statement; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:department_name; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:address_label; 33, identifier:append; 34, argument_list; 34, 35; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:department_name; 38, if_statement; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:po_box_number; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:address_label; 49, identifier:append; 50, argument_list; 50, 51; 51, binary_operator:+; 51, 52; 51, 53; 52, string:'PO Box '; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:po_box_number; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:elements; 59, list:[
self.sub_building_name,
self.building_name,
self.building_number,
self.dependent_thoroughfare,
self.thoroughfare,
self.double_dependent_locality,
self.dependent_locality,
]; 59, 60; 59, 63; 59, 66; 59, 69; 59, 72; 59, 75; 59, 78; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:sub_building_name; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:building_name; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:building_number; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:dependent_thoroughfare; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:thoroughfare; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:double_dependent_locality; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:dependent_locality; 81, for_statement; 81, 82; 81, 83; 81, 84; 82, identifier:element; 83, identifier:elements; 84, block; 84, 85; 85, if_statement; 85, 86; 85, 87; 86, identifier:element; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_append_to_label; 93, argument_list; 93, 94; 94, identifier:element; 95, if_statement; 95, 96; 95, 104; 96, comparison_operator:<; 96, 97; 96, 103; 97, call; 97, 98; 97, 99; 98, identifier:len; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:address_label; 103, integer:7; 104, block; 104, 105; 105, for_statement; 105, 106; 105, 107; 105, 118; 106, identifier:i; 107, call; 107, 108; 107, 109; 108, identifier:range; 109, argument_list; 109, 110; 110, binary_operator:-; 110, 111; 110, 112; 111, integer:7; 112, call; 112, 113; 112, 114; 113, identifier:len; 114, argument_list; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:address_label; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:address_label; 125, identifier:append; 126, argument_list; 126, 127; 127, string:''; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 135; 130, subscript; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:address_label; 134, integer:5; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:post_town; 138, return_statement; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, string:", "; 142, identifier:join; 143, argument_list; 143, 144; 144, list_comprehension; 144, 145; 144, 146; 144, 151; 145, identifier:f; 146, for_in_clause; 146, 147; 146, 148; 147, identifier:f; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:address_label; 151, if_clause; 151, 152; 152, identifier:f | def generate_address_label(self):
if self.organisation_name:
self.address_label.append(self.organisation_name)
if self.department_name:
self.address_label.append(self.department_name)
if self.po_box_number:
self.address_label.append('PO Box ' + self.po_box_number)
elements = [
self.sub_building_name,
self.building_name,
self.building_number,
self.dependent_thoroughfare,
self.thoroughfare,
self.double_dependent_locality,
self.dependent_locality,
]
for element in elements:
if element:
self._append_to_label(element)
if len(self.address_label) < 7:
for i in range(7 - len(self.address_label)):
self.address_label.append('')
self.address_label[5] = self.post_town
return ", ".join([f for f in self.address_label if f]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:verify_token; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:token; 5, identifier:public_key_or_address; 6, default_parameter; 6, 7; 6, 8; 7, identifier:signing_algorithm; 8, string:"ES256K"; 9, block; 9, 10; 9, 17; 9, 23; 9, 33; 9, 45; 9, 55; 9, 67; 9, 77; 9, 88; 9, 95; 9, 102; 9, 109; 9, 184; 9, 215; 9, 221; 9, 240; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:decoded_token; 13, call; 13, 14; 13, 15; 14, identifier:decode_token; 15, argument_list; 15, 16; 16, identifier:token; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:decoded_token_payload; 20, subscript; 20, 21; 20, 22; 21, identifier:decoded_token; 22, string:"payload"; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:not; 24, 25; 24, 26; 25, string:"subject"; 26, identifier:decoded_token_payload; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:ValueError; 31, argument_list; 31, 32; 32, string:"Token doesn't have a subject"; 33, if_statement; 33, 34; 33, 39; 34, comparison_operator:not; 34, 35; 34, 36; 35, string:"publicKey"; 36, subscript; 36, 37; 36, 38; 37, identifier:decoded_token_payload; 38, string:"subject"; 39, block; 39, 40; 40, raise_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:ValueError; 43, argument_list; 43, 44; 44, string:"Token doesn't have a subject public key"; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:not; 46, 47; 46, 48; 47, string:"issuer"; 48, identifier:decoded_token_payload; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:ValueError; 53, argument_list; 53, 54; 54, string:"Token doesn't have an issuer"; 55, if_statement; 55, 56; 55, 61; 56, comparison_operator:not; 56, 57; 56, 58; 57, string:"publicKey"; 58, subscript; 58, 59; 58, 60; 59, identifier:decoded_token_payload; 60, string:"issuer"; 61, block; 61, 62; 62, raise_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:ValueError; 65, argument_list; 65, 66; 66, string:"Token doesn't have an issuer public key"; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:not; 68, 69; 68, 70; 69, string:"claim"; 70, identifier:decoded_token_payload; 71, block; 71, 72; 72, raise_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:ValueError; 75, argument_list; 75, 76; 76, string:"Token doesn't have a claim"; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:issuer_public_key; 80, call; 80, 81; 80, 82; 81, identifier:str; 82, argument_list; 82, 83; 83, subscript; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:decoded_token_payload; 86, string:"issuer"; 87, string:"publicKey"; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:public_key_object; 91, call; 91, 92; 91, 93; 92, identifier:ECPublicKey; 93, argument_list; 93, 94; 94, identifier:issuer_public_key; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:compressed_public_key; 98, call; 98, 99; 98, 100; 99, identifier:compress; 100, argument_list; 100, 101; 101, identifier:issuer_public_key; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:decompressed_public_key; 105, call; 105, 106; 105, 107; 106, identifier:decompress; 107, argument_list; 107, 108; 108, identifier:issuer_public_key; 109, if_statement; 109, 110; 109, 117; 109, 143; 109, 177; 110, comparison_operator:==; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:public_key_object; 113, identifier:_type; 114, attribute; 114, 115; 114, 116; 115, identifier:PubkeyType; 116, identifier:compressed; 117, block; 117, 118; 117, 126; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:compressed_address; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:public_key_object; 124, identifier:address; 125, argument_list; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:uncompressed_address; 129, call; 129, 130; 129, 131; 130, identifier:bin_hash160_to_address; 131, argument_list; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:bin_hash160; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:decompress; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:public_key_object; 141, identifier:to_bin; 142, argument_list; 143, elif_clause; 143, 144; 143, 151; 144, comparison_operator:==; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:public_key_object; 147, identifier:_type; 148, attribute; 148, 149; 148, 150; 149, identifier:PubkeyType; 150, identifier:uncompressed; 151, block; 151, 152; 151, 169; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:compressed_address; 155, call; 155, 156; 155, 157; 156, identifier:bin_hash160_to_address; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:bin_hash160; 160, argument_list; 160, 161; 161, call; 161, 162; 161, 163; 162, identifier:compress; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:public_key_object; 167, identifier:to_bin; 168, argument_list; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:uncompressed_address; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:public_key_object; 175, identifier:address; 176, argument_list; 177, else_clause; 177, 178; 178, block; 178, 179; 179, raise_statement; 179, 180; 180, call; 180, 181; 180, 182; 181, identifier:ValueError; 182, argument_list; 182, 183; 183, string:"Invalid issuer public key format"; 184, if_statement; 184, 185; 184, 188; 184, 190; 184, 196; 184, 202; 184, 208; 185, comparison_operator:==; 185, 186; 185, 187; 186, identifier:public_key_or_address; 187, identifier:compressed_public_key; 188, block; 188, 189; 189, pass_statement; 190, elif_clause; 190, 191; 190, 194; 191, comparison_operator:==; 191, 192; 191, 193; 192, identifier:public_key_or_address; 193, identifier:decompressed_public_key; 194, block; 194, 195; 195, pass_statement; 196, elif_clause; 196, 197; 196, 200; 197, comparison_operator:==; 197, 198; 197, 199; 198, identifier:public_key_or_address; 199, identifier:compressed_address; 200, block; 200, 201; 201, pass_statement; 202, elif_clause; 202, 203; 202, 206; 203, comparison_operator:==; 203, 204; 203, 205; 204, identifier:public_key_or_address; 205, identifier:uncompressed_address; 206, block; 206, 207; 207, pass_statement; 208, else_clause; 208, 209; 209, block; 209, 210; 210, raise_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:ValueError; 213, argument_list; 213, 214; 214, string:"Token public key doesn't match the verifying value"; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:token_verifier; 218, call; 218, 219; 218, 220; 219, identifier:TokenVerifier; 220, argument_list; 221, if_statement; 221, 222; 221, 234; 222, not_operator; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:token_verifier; 226, identifier:verify; 227, argument_list; 227, 228; 227, 229; 228, identifier:token; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:public_key_object; 232, identifier:to_pem; 233, argument_list; 234, block; 234, 235; 235, raise_statement; 235, 236; 236, call; 236, 237; 236, 238; 237, identifier:ValueError; 238, argument_list; 238, 239; 239, string:"Token was not signed by the issuer public key"; 240, return_statement; 240, 241; 241, identifier:decoded_token | def verify_token(token, public_key_or_address, signing_algorithm="ES256K"):
decoded_token = decode_token(token)
decoded_token_payload = decoded_token["payload"]
if "subject" not in decoded_token_payload:
raise ValueError("Token doesn't have a subject")
if "publicKey" not in decoded_token_payload["subject"]:
raise ValueError("Token doesn't have a subject public key")
if "issuer" not in decoded_token_payload:
raise ValueError("Token doesn't have an issuer")
if "publicKey" not in decoded_token_payload["issuer"]:
raise ValueError("Token doesn't have an issuer public key")
if "claim" not in decoded_token_payload:
raise ValueError("Token doesn't have a claim")
issuer_public_key = str(decoded_token_payload["issuer"]["publicKey"])
public_key_object = ECPublicKey(issuer_public_key)
compressed_public_key = compress(issuer_public_key)
decompressed_public_key = decompress(issuer_public_key)
if public_key_object._type == PubkeyType.compressed:
compressed_address = public_key_object.address()
uncompressed_address = bin_hash160_to_address(
bin_hash160(
decompress(public_key_object.to_bin())
)
)
elif public_key_object._type == PubkeyType.uncompressed:
compressed_address = bin_hash160_to_address(
bin_hash160(
compress(public_key_object.to_bin())
)
)
uncompressed_address = public_key_object.address()
else:
raise ValueError("Invalid issuer public key format")
if public_key_or_address == compressed_public_key:
pass
elif public_key_or_address == decompressed_public_key:
pass
elif public_key_or_address == compressed_address:
pass
elif public_key_or_address == uncompressed_address:
pass
else:
raise ValueError("Token public key doesn't match the verifying value")
token_verifier = TokenVerifier()
if not token_verifier.verify(token, public_key_object.to_pem()):
raise ValueError("Token was not signed by the issuer public key")
return decoded_token |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_translations; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:locale; 6, block; 6, 7; 6, 16; 6, 29; 6, 33; 6, 131; 6, 144; 6, 148; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:locale; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:normalize_locale; 14, argument_list; 14, 15; 15, identifier:locale; 16, if_statement; 16, 17; 16, 22; 17, comparison_operator:in; 17, 18; 17, 19; 18, identifier:locale; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:translations; 22, block; 22, 23; 23, return_statement; 23, 24; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:translations; 28, identifier:locale; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:translations; 32, dictionary; 33, for_statement; 33, 34; 33, 35; 33, 38; 34, identifier:path; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:dirs; 38, block; 38, 39; 38, 56; 38, 68; 38, 76; 38, 84; 38, 93; 38, 101; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:file; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:os; 46, identifier:path; 47, identifier:join; 48, argument_list; 48, 49; 48, 50; 49, identifier:path; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, string:'{}.py'; 53, identifier:format; 54, argument_list; 54, 55; 55, identifier:locale; 56, if_statement; 56, 57; 56, 66; 57, not_operator; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:os; 62, identifier:path; 63, identifier:isfile; 64, argument_list; 64, 65; 65, identifier:file; 66, block; 66, 67; 67, continue_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:loader; 71, call; 71, 72; 71, 73; 72, identifier:SourceFileLoader; 73, argument_list; 73, 74; 73, 75; 74, identifier:locale; 75, identifier:file; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:locale_dict; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:loader; 82, identifier:load_module; 83, argument_list; 84, if_statement; 84, 85; 84, 91; 85, not_operator; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:hasattr; 88, argument_list; 88, 89; 88, 90; 89, identifier:locale_dict; 90, string:'translations'; 91, block; 91, 92; 92, continue_statement; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:language; 96, call; 96, 97; 96, 98; 97, identifier:getattr; 98, argument_list; 98, 99; 98, 100; 99, identifier:locale_dict; 100, string:'translations'; 101, if_statement; 101, 102; 101, 103; 101, 108; 102, identifier:translations; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:translations; 107, identifier:language; 108, else_clause; 108, 109; 109, block; 109, 110; 109, 127; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:merged; 113, call; 113, 114; 113, 115; 114, identifier:dict; 115, argument_list; 115, 116; 116, binary_operator:|; 116, 117; 116, 122; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:translations; 120, identifier:items; 121, argument_list; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:language; 125, identifier:items; 126, argument_list; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:translations; 130, identifier:merged; 131, if_statement; 131, 132; 131, 133; 132, identifier:translations; 133, block; 133, 134; 133, 142; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 141; 136, subscript; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:translations; 140, identifier:locale; 141, identifier:translations; 142, return_statement; 142, 143; 143, identifier:translations; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:err; 147, string:'No translations found for locale [{}]'; 148, raise_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:NoTranslations; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:err; 155, identifier:format; 156, argument_list; 156, 157; 157, identifier:locale | def get_translations(self, locale):
locale = self.normalize_locale(locale)
if locale in self.translations:
return self.translations[locale]
translations = {}
for path in self.dirs:
file = os.path.join(path, '{}.py'.format(locale))
if not os.path.isfile(file):
continue
loader = SourceFileLoader(locale, file)
locale_dict = loader.load_module()
if not hasattr(locale_dict, 'translations'):
continue
language = getattr(locale_dict, 'translations')
if translations:
translations = language
else:
merged = dict(translations.items() | language.items())
translations = merged
if translations:
self.translations[locale] = translations
return translations
err = 'No translations found for locale [{}]'
raise NoTranslations(err.format(locale)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:process_request; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:session; 6, block; 6, 7; 6, 15; 6, 28; 6, 236; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:debugger; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:debugger; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:debugger_session_id; 18, conditional_expression:if; 18, 19; 18, 24; 18, 27; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:debugger; 22, identifier:session_id; 23, argument_list; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:debugger; 26, None; 27, None; 28, try_statement; 28, 29; 28, 211; 29, block; 29, 30; 29, 38; 29, 61; 29, 197; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:request; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:session; 36, identifier:read_request; 37, argument_list; 38, if_statement; 38, 39; 38, 42; 39, comparison_operator:is; 39, 40; 39, 41; 40, identifier:debugger_session_id; 41, None; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:debugger; 47, identifier:request; 48, argument_list; 48, 49; 48, 50; 48, 51; 48, 56; 49, identifier:debugger_session_id; 50, identifier:request; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:session; 54, identifier:protocol_version; 55, argument_list; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:session; 59, identifier:protocol; 60, argument_list; 61, try_statement; 61, 62; 61, 150; 62, block; 62, 63; 62, 77; 62, 90; 62, 137; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:target_route; 66, call; 66, 67; 66, 74; 67, attribute; 67, 68; 67, 73; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:route_map; 72, argument_list; 73, identifier:route; 74, argument_list; 74, 75; 74, 76; 75, identifier:request; 76, identifier:self; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:is; 78, 79; 78, 80; 79, identifier:debugger_session_id; 80, None; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:debugger; 86, identifier:target_route; 87, argument_list; 87, 88; 87, 89; 88, identifier:debugger_session_id; 89, identifier:target_route; 90, if_statement; 90, 91; 90, 94; 90, 105; 91, comparison_operator:is; 91, 92; 91, 93; 92, identifier:target_route; 93, None; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:response; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:execute; 102, argument_list; 102, 103; 102, 104; 103, identifier:request; 104, identifier:target_route; 105, else_clause; 105, 106; 106, block; 106, 107; 106, 119; 106, 126; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:presenter_cls; 110, call; 110, 111; 110, 118; 111, attribute; 111, 112; 111, 117; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:route_map; 116, argument_list; 117, identifier:error_presenter; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:presenter; 122, call; 122, 123; 122, 124; 123, identifier:presenter_cls; 124, argument_list; 124, 125; 125, identifier:request; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:response; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:presenter; 132, identifier:error_code; 133, argument_list; 133, 134; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:code; 136, integer:404; 137, if_statement; 137, 138; 137, 141; 138, comparison_operator:is; 138, 139; 138, 140; 139, identifier:debugger_session_id; 140, None; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:debugger; 146, identifier:response; 147, argument_list; 147, 148; 147, 149; 148, identifier:debugger_session_id; 149, identifier:response; 150, except_clause; 150, 151; 150, 155; 151, as_pattern; 151, 152; 151, 153; 152, identifier:Exception; 153, as_pattern_target; 153, 154; 154, identifier:e; 155, block; 155, 156; 155, 169; 155, 181; 155, 188; 156, if_statement; 156, 157; 156, 160; 157, comparison_operator:is; 157, 158; 157, 159; 158, identifier:debugger_session_id; 159, None; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:debugger; 165, identifier:exception; 166, argument_list; 166, 167; 166, 168; 167, identifier:debugger_session_id; 168, identifier:e; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:presenter_cls; 172, call; 172, 173; 172, 180; 173, attribute; 173, 174; 173, 179; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:route_map; 178, argument_list; 179, identifier:error_presenter; 180, argument_list; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:presenter; 184, call; 184, 185; 184, 186; 185, identifier:presenter_cls; 186, argument_list; 186, 187; 187, identifier:request; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:response; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:presenter; 194, identifier:exception_error; 195, argument_list; 195, 196; 196, identifier:e; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:session; 201, identifier:write_response; 202, argument_list; 202, 203; 202, 204; 202, 205; 203, identifier:request; 204, identifier:response; 205, list_splat; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:response; 209, identifier:__pushed_responses__; 210, argument_list; 211, except_clause; 211, 212; 211, 216; 212, as_pattern; 212, 213; 212, 214; 213, identifier:Exception; 214, as_pattern_target; 214, 215; 215, identifier:e; 216, block; 216, 217; 216, 230; 217, if_statement; 217, 218; 217, 221; 218, comparison_operator:is; 218, 219; 218, 220; 219, identifier:debugger_session_id; 220, None; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:debugger; 226, identifier:exception; 227, argument_list; 227, 228; 227, 229; 228, identifier:debugger_session_id; 229, identifier:e; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:session; 234, identifier:session_close; 235, argument_list; 236, if_statement; 236, 237; 236, 240; 237, comparison_operator:is; 237, 238; 237, 239; 238, identifier:debugger_session_id; 239, None; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:debugger; 245, identifier:finalize; 246, argument_list; 246, 247; 247, identifier:debugger_session_id | def process_request(self, session):
debugger = self.debugger()
debugger_session_id = debugger.session_id() if debugger is not None else None
try:
request = session.read_request()
if debugger_session_id is not None:
debugger.request(
debugger_session_id, request, session.protocol_version(), session.protocol()
)
try:
target_route = self.route_map().route(request, self)
if debugger_session_id is not None:
debugger.target_route(debugger_session_id, target_route)
if target_route is not None:
response = self.execute(request, target_route)
else:
presenter_cls = self.route_map().error_presenter()
presenter = presenter_cls(request)
response = presenter.error_code(code=404)
if debugger_session_id is not None:
debugger.response(debugger_session_id, response)
except Exception as e:
if debugger_session_id is not None:
debugger.exception(debugger_session_id, e)
presenter_cls = self.route_map().error_presenter()
presenter = presenter_cls(request)
response = presenter.exception_error(e)
session.write_response(request, response, *response.__pushed_responses__())
except Exception as e:
if debugger_session_id is not None:
debugger.exception(debugger_session_id, e)
session.session_close()
if debugger_session_id is not None:
debugger.finalize(debugger_session_id) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:find_point_in_section_list; 3, parameters; 3, 4; 3, 5; 4, identifier:point; 5, identifier:section_list; 6, block; 6, 7; 6, 23; 6, 65; 7, if_statement; 7, 8; 7, 20; 8, boolean_operator:or; 8, 9; 8, 14; 9, comparison_operator:<; 9, 10; 9, 11; 10, identifier:point; 11, subscript; 11, 12; 11, 13; 12, identifier:section_list; 13, integer:0; 14, comparison_operator:>; 14, 15; 14, 16; 15, identifier:point; 16, subscript; 16, 17; 16, 18; 17, identifier:section_list; 18, unary_operator:-; 18, 19; 19, integer:1; 20, block; 20, 21; 21, return_statement; 21, 22; 22, None; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:in; 24, 25; 24, 26; 25, identifier:point; 26, identifier:section_list; 27, block; 27, 28; 27, 41; 27, 52; 27, 61; 28, if_statement; 28, 29; 28, 35; 29, comparison_operator:==; 29, 30; 29, 31; 30, identifier:point; 31, subscript; 31, 32; 31, 33; 32, identifier:section_list; 33, unary_operator:-; 33, 34; 34, integer:1; 35, block; 35, 36; 36, return_statement; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:section_list; 39, unary_operator:-; 39, 40; 40, integer:2; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:ind; 44, binary_operator:-; 44, 45; 44, 51; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:section_list; 48, identifier:bisect; 49, argument_list; 49, 50; 50, identifier:point; 51, integer:1; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:==; 53, 54; 53, 55; 54, identifier:ind; 55, integer:0; 56, block; 56, 57; 57, return_statement; 57, 58; 58, subscript; 58, 59; 58, 60; 59, identifier:section_list; 60, integer:0; 61, return_statement; 61, 62; 62, subscript; 62, 63; 62, 64; 63, identifier:section_list; 64, identifier:ind; 65, try_statement; 65, 66; 65, 82; 66, block; 66, 67; 66, 76; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:ind; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:section_list; 73, identifier:bisect; 74, argument_list; 74, 75; 75, identifier:point; 76, return_statement; 76, 77; 77, subscript; 77, 78; 77, 79; 78, identifier:section_list; 79, binary_operator:-; 79, 80; 79, 81; 80, identifier:ind; 81, integer:1; 82, except_clause; 82, 83; 82, 84; 83, identifier:IndexError; 84, block; 84, 85; 85, return_statement; 85, 86; 86, None | def find_point_in_section_list(point, section_list):
if point < section_list[0] or point > section_list[-1]:
return None
if point in section_list:
if point == section_list[-1]:
return section_list[-2]
ind = section_list.bisect(point)-1
if ind == 0:
return section_list[0]
return section_list[ind]
try:
ind = section_list.bisect(point)
return section_list[ind-1]
except IndexError:
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:find_range_ix_in_section_list; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:start; 5, identifier:end; 6, identifier:section_list; 7, block; 7, 8; 7, 26; 7, 49; 7, 74; 8, if_statement; 8, 9; 8, 21; 9, boolean_operator:or; 9, 10; 9, 16; 10, comparison_operator:>; 10, 11; 10, 12; 11, identifier:start; 12, subscript; 12, 13; 12, 14; 13, identifier:section_list; 14, unary_operator:-; 14, 15; 15, integer:1; 16, comparison_operator:<; 16, 17; 16, 18; 17, identifier:end; 18, subscript; 18, 19; 18, 20; 19, identifier:section_list; 20, integer:0; 21, block; 21, 22; 22, return_statement; 22, 23; 23, list:[0, 0]; 23, 24; 23, 25; 24, integer:0; 25, integer:0; 26, if_statement; 26, 27; 26, 32; 26, 39; 27, comparison_operator:<; 27, 28; 27, 29; 28, identifier:start; 29, subscript; 29, 30; 29, 31; 30, identifier:section_list; 31, integer:0; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:start_section; 36, subscript; 36, 37; 36, 38; 37, identifier:section_list; 38, integer:0; 39, else_clause; 39, 40; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:start_section; 44, call; 44, 45; 44, 46; 45, identifier:find_point_in_section_list; 46, argument_list; 46, 47; 46, 48; 47, identifier:start; 48, identifier:section_list; 49, if_statement; 49, 50; 49, 56; 49, 64; 50, comparison_operator:>; 50, 51; 50, 52; 51, identifier:end; 52, subscript; 52, 53; 52, 54; 53, identifier:section_list; 54, unary_operator:-; 54, 55; 55, integer:1; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:end_section; 60, subscript; 60, 61; 60, 62; 61, identifier:section_list; 62, unary_operator:-; 62, 63; 63, integer:2; 64, else_clause; 64, 65; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:end_section; 69, call; 69, 70; 69, 71; 70, identifier:find_point_in_section_list; 71, argument_list; 71, 72; 71, 73; 72, identifier:end; 73, identifier:section_list; 74, return_statement; 74, 75; 75, list:[
section_list.index(start_section), section_list.index(end_section)+1]; 75, 76; 75, 82; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:section_list; 79, identifier:index; 80, argument_list; 80, 81; 81, identifier:start_section; 82, binary_operator:+; 82, 83; 82, 89; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:section_list; 86, identifier:index; 87, argument_list; 87, 88; 88, identifier:end_section; 89, integer:1 | def find_range_ix_in_section_list(start, end, section_list):
if start > section_list[-1] or end < section_list[0]:
return [0, 0]
if start < section_list[0]:
start_section = section_list[0]
else:
start_section = find_point_in_section_list(start, section_list)
if end > section_list[-1]:
end_section = section_list[-2]
else:
end_section = find_point_in_section_list(end, section_list)
return [
section_list.index(start_section), section_list.index(end_section)+1] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:find_range_in_section_list; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:start; 5, identifier:end; 6, identifier:section_list; 7, block; 7, 8; 7, 17; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:ind; 11, call; 11, 12; 11, 13; 12, identifier:find_range_ix_in_section_list; 13, argument_list; 13, 14; 13, 15; 13, 16; 14, identifier:start; 15, identifier:end; 16, identifier:section_list; 17, return_statement; 17, 18; 18, subscript; 18, 19; 18, 20; 19, identifier:section_list; 20, slice; 20, 21; 20, 24; 20, 25; 21, subscript; 21, 22; 21, 23; 22, identifier:ind; 23, integer:0; 24, colon; 25, subscript; 25, 26; 25, 27; 26, identifier:ind; 27, integer:1 | def find_range_in_section_list(start, end, section_list):
ind = find_range_ix_in_section_list(start, end, section_list)
return section_list[ind[0]: ind[1]] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:find_range_ix_in_point_list; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:start; 5, identifier:end; 6, identifier:point_list; 7, block; 7, 8; 8, return_statement; 8, 9; 9, list:[point_list.bisect_left(start), point_list.bisect_right(end)]; 9, 10; 9, 16; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:point_list; 13, identifier:bisect_left; 14, argument_list; 14, 15; 15, identifier:start; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:point_list; 19, identifier:bisect_right; 20, argument_list; 20, 21; 21, identifier:end | def find_range_ix_in_point_list(start, end, point_list):
return [point_list.bisect_left(start), point_list.bisect_right(end)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:check; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:type_spec; 6, identifier:arg_name; 7, identifier:decorated_function; 8, block; 8, 9; 8, 40; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:raise_exception; 11, parameters; 11, 12; 12, identifier:x_spec; 13, block; 13, 14; 13, 27; 13, 35; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:exc_text; 17, binary_operator:%; 17, 18; 17, 19; 18, string:'Argument "%s" for function "%s" has invalid type'; 19, tuple; 19, 20; 19, 21; 20, identifier:arg_name; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:Verifier; 24, identifier:function_name; 25, argument_list; 25, 26; 26, identifier:decorated_function; 27, expression_statement; 27, 28; 28, augmented_assignment:+=; 28, 29; 28, 30; 29, identifier:exc_text; 30, binary_operator:%; 30, 31; 30, 32; 31, string:' (%s should be %s)'; 32, tuple; 32, 33; 32, 34; 33, identifier:x_spec; 34, identifier:type_spec; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:TypeError; 38, argument_list; 38, 39; 39, identifier:exc_text; 40, if_statement; 40, 41; 40, 49; 40, 155; 40, 186; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 45; 44, identifier:type_spec; 45, tuple; 45, 46; 45, 47; 45, 48; 46, identifier:tuple; 47, identifier:list; 48, identifier:set; 49, block; 49, 50; 49, 72; 50, for_statement; 50, 51; 50, 52; 50, 53; 51, identifier:single_type; 52, identifier:type_spec; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 66; 55, boolean_operator:and; 55, 56; 55, 60; 56, parenthesized_expression; 56, 57; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:single_type; 59, None; 60, comparison_operator:is; 60, 61; 60, 65; 61, call; 61, 62; 61, 63; 62, identifier:isclass; 63, argument_list; 63, 64; 64, identifier:single_type; 65, False; 66, block; 66, 67; 67, raise_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:RuntimeError; 70, argument_list; 70, 71; 71, string:'Invalid specification. Must be type or tuple/list/set of types'; 72, if_statement; 72, 73; 72, 76; 72, 125; 73, comparison_operator:in; 73, 74; 73, 75; 74, None; 75, identifier:type_spec; 76, block; 76, 77; 76, 93; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:type_spec; 80, call; 80, 81; 80, 82; 81, identifier:tuple; 82, argument_list; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:filter; 85, argument_list; 85, 86; 85, 92; 86, lambda; 86, 87; 86, 89; 87, lambda_parameters; 87, 88; 88, identifier:x; 89, comparison_operator:is; 89, 90; 89, 91; 90, identifier:x; 91, None; 92, identifier:type_spec; 93, return_statement; 93, 94; 94, lambda; 94, 95; 94, 97; 95, lambda_parameters; 95, 96; 96, identifier:x; 97, conditional_expression:if; 97, 98; 97, 99; 97, 113; 97, 114; 98, None; 99, boolean_operator:or; 99, 100; 99, 103; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:x; 102, None; 103, comparison_operator:is; 103, 104; 103, 112; 104, call; 104, 105; 104, 106; 105, identifier:isinstance; 106, argument_list; 106, 107; 106, 108; 107, identifier:x; 108, call; 108, 109; 108, 110; 109, identifier:tuple; 110, argument_list; 110, 111; 111, identifier:type_spec; 112, True; 113, line_continuation:\; 114, call; 114, 115; 114, 116; 115, identifier:raise_exception; 116, argument_list; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:str; 119, argument_list; 119, 120; 120, parenthesized_expression; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:type; 123, argument_list; 123, 124; 124, identifier:x; 125, else_clause; 125, 126; 126, block; 126, 127; 127, return_statement; 127, 128; 128, lambda; 128, 129; 128, 131; 129, lambda_parameters; 129, 130; 130, identifier:x; 131, conditional_expression:if; 131, 132; 131, 133; 131, 143; 131, 144; 132, None; 133, comparison_operator:is; 133, 134; 133, 142; 134, call; 134, 135; 134, 136; 135, identifier:isinstance; 136, argument_list; 136, 137; 136, 138; 137, identifier:x; 138, call; 138, 139; 138, 140; 139, identifier:tuple; 140, argument_list; 140, 141; 141, identifier:type_spec; 142, True; 143, line_continuation:\; 144, call; 144, 145; 144, 146; 145, identifier:raise_exception; 146, argument_list; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:str; 149, argument_list; 149, 150; 150, parenthesized_expression; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:type; 153, argument_list; 153, 154; 154, identifier:x; 155, elif_clause; 155, 156; 155, 160; 156, call; 156, 157; 156, 158; 157, identifier:isclass; 158, argument_list; 158, 159; 159, identifier:type_spec; 160, block; 160, 161; 161, return_statement; 161, 162; 162, lambda; 162, 163; 162, 165; 163, lambda_parameters; 163, 164; 164, identifier:x; 165, conditional_expression:if; 165, 166; 165, 167; 165, 174; 165, 175; 166, None; 167, comparison_operator:is; 167, 168; 167, 173; 168, call; 168, 169; 168, 170; 169, identifier:isinstance; 170, argument_list; 170, 171; 170, 172; 171, identifier:x; 172, identifier:type_spec; 173, True; 174, line_continuation:\; 175, call; 175, 176; 175, 177; 176, identifier:raise_exception; 177, argument_list; 177, 178; 178, call; 178, 179; 178, 180; 179, identifier:str; 180, argument_list; 180, 181; 181, parenthesized_expression; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:type; 184, argument_list; 184, 185; 185, identifier:x; 186, else_clause; 186, 187; 187, block; 187, 188; 188, raise_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:RuntimeError; 191, argument_list; 191, 192; 192, string:'Invalid specification. Must be type or tuple/list/set of types' | def check(self, type_spec, arg_name, decorated_function):
def raise_exception(x_spec):
exc_text = 'Argument "%s" for function "%s" has invalid type' % (
arg_name, Verifier.function_name(decorated_function)
)
exc_text += ' (%s should be %s)' % (x_spec, type_spec)
raise TypeError(exc_text)
if isinstance(type_spec, (tuple, list, set)):
for single_type in type_spec:
if (single_type is not None) and isclass(single_type) is False:
raise RuntimeError(
'Invalid specification. Must be type or tuple/list/set of types'
)
if None in type_spec:
type_spec = tuple(filter(lambda x: x is not None, type_spec))
return lambda x: None if x is None or isinstance(x, tuple(type_spec)) is True else \
raise_exception(str((type(x))))
else:
return lambda x: None if isinstance(x, tuple(type_spec)) is True else \
raise_exception(str((type(x))))
elif isclass(type_spec):
return lambda x: None if isinstance(x, type_spec) is True else \
raise_exception(str((type(x))))
else:
raise RuntimeError('Invalid specification. Must be type or tuple/list/set of types') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:check; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:type_spec; 6, identifier:arg_name; 7, identifier:decorated_function; 8, block; 8, 9; 8, 38; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:raise_exception; 11, parameters; 11, 12; 12, identifier:text_spec; 13, block; 13, 14; 13, 27; 13, 33; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:exc_text; 17, binary_operator:%; 17, 18; 17, 19; 18, string:'Argument "%s" for function "%s" has invalid type'; 19, tuple; 19, 20; 19, 21; 20, identifier:arg_name; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:Verifier; 24, identifier:function_name; 25, argument_list; 25, 26; 26, identifier:decorated_function; 27, expression_statement; 27, 28; 28, augmented_assignment:+=; 28, 29; 28, 30; 29, identifier:exc_text; 30, binary_operator:%; 30, 31; 30, 32; 31, string:' (%s)'; 32, identifier:text_spec; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:TypeError; 36, argument_list; 36, 37; 37, identifier:exc_text; 38, if_statement; 38, 39; 38, 47; 38, 156; 38, 191; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:type_spec; 43, tuple; 43, 44; 43, 45; 43, 46; 44, identifier:tuple; 45, identifier:list; 46, identifier:set; 47, block; 47, 48; 47, 70; 48, for_statement; 48, 49; 48, 50; 48, 51; 49, identifier:single_type; 50, identifier:type_spec; 51, block; 51, 52; 52, if_statement; 52, 53; 52, 64; 53, boolean_operator:and; 53, 54; 53, 58; 54, parenthesized_expression; 54, 55; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:single_type; 57, None; 58, comparison_operator:is; 58, 59; 58, 63; 59, call; 59, 60; 59, 61; 60, identifier:isclass; 61, argument_list; 61, 62; 62, identifier:single_type; 63, False; 64, block; 64, 65; 65, raise_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:RuntimeError; 68, argument_list; 68, 69; 69, string:'Invalid specification. Must be type or tuple/list/set of types'; 70, if_statement; 70, 71; 70, 74; 70, 125; 71, comparison_operator:in; 71, 72; 71, 73; 72, None; 73, identifier:type_spec; 74, block; 74, 75; 74, 91; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:type_spec; 78, call; 78, 79; 78, 80; 79, identifier:tuple; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:filter; 83, argument_list; 83, 84; 83, 90; 84, lambda; 84, 85; 84, 87; 85, lambda_parameters; 85, 86; 86, identifier:x; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:x; 89, None; 90, identifier:type_spec; 91, return_statement; 91, 92; 92, lambda; 92, 93; 92, 95; 93, lambda_parameters; 93, 94; 94, identifier:x; 95, conditional_expression:if; 95, 96; 95, 97; 95, 98; 95, 117; 95, 118; 96, None; 97, line_continuation:\; 98, boolean_operator:or; 98, 99; 98, 102; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:x; 101, None; 102, parenthesized_expression; 102, 103; 103, boolean_operator:and; 103, 104; 103, 110; 104, comparison_operator:is; 104, 105; 104, 109; 105, call; 105, 106; 105, 107; 106, identifier:isclass; 107, argument_list; 107, 108; 108, identifier:x; 109, True; 110, comparison_operator:is; 110, 111; 110, 116; 111, call; 111, 112; 111, 113; 112, identifier:issubclass; 113, argument_list; 113, 114; 113, 115; 114, identifier:x; 115, identifier:type_spec; 116, True; 117, line_continuation:\; 118, call; 118, 119; 118, 120; 119, identifier:raise_exception; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:str; 123, argument_list; 123, 124; 124, identifier:x; 125, else_clause; 125, 126; 126, block; 126, 127; 127, return_statement; 127, 128; 128, lambda; 128, 129; 128, 131; 129, lambda_parameters; 129, 130; 130, identifier:x; 131, conditional_expression:if; 131, 132; 131, 133; 131, 148; 131, 149; 132, None; 133, parenthesized_expression; 133, 134; 134, boolean_operator:and; 134, 135; 134, 141; 135, comparison_operator:is; 135, 136; 135, 140; 136, call; 136, 137; 136, 138; 137, identifier:isclass; 138, argument_list; 138, 139; 139, identifier:x; 140, True; 141, comparison_operator:is; 141, 142; 141, 147; 142, call; 142, 143; 142, 144; 143, identifier:issubclass; 144, argument_list; 144, 145; 144, 146; 145, identifier:x; 146, identifier:type_spec; 147, True; 148, line_continuation:\; 149, call; 149, 150; 149, 151; 150, identifier:raise_exception; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:str; 154, argument_list; 154, 155; 155, identifier:x; 156, elif_clause; 156, 157; 156, 161; 157, call; 157, 158; 157, 159; 158, identifier:isclass; 159, argument_list; 159, 160; 160, identifier:type_spec; 161, block; 161, 162; 162, return_statement; 162, 163; 163, lambda; 163, 164; 163, 166; 164, lambda_parameters; 164, 165; 165, identifier:x; 166, conditional_expression:if; 166, 167; 166, 168; 166, 183; 166, 184; 167, None; 168, parenthesized_expression; 168, 169; 169, boolean_operator:and; 169, 170; 169, 176; 170, comparison_operator:is; 170, 171; 170, 175; 171, call; 171, 172; 171, 173; 172, identifier:isclass; 173, argument_list; 173, 174; 174, identifier:x; 175, True; 176, comparison_operator:is; 176, 177; 176, 182; 177, call; 177, 178; 177, 179; 178, identifier:issubclass; 179, argument_list; 179, 180; 179, 181; 180, identifier:x; 181, identifier:type_spec; 182, True; 183, line_continuation:\; 184, call; 184, 185; 184, 186; 185, identifier:raise_exception; 186, argument_list; 186, 187; 187, call; 187, 188; 187, 189; 188, identifier:str; 189, argument_list; 189, 190; 190, identifier:x; 191, else_clause; 191, 192; 192, block; 192, 193; 193, raise_statement; 193, 194; 194, call; 194, 195; 194, 196; 195, identifier:RuntimeError; 196, argument_list; 196, 197; 197, string:'Invalid specification. Must be type or tuple/list/set of types' | def check(self, type_spec, arg_name, decorated_function):
def raise_exception(text_spec):
exc_text = 'Argument "%s" for function "%s" has invalid type' % (
arg_name, Verifier.function_name(decorated_function)
)
exc_text += ' (%s)' % text_spec
raise TypeError(exc_text)
if isinstance(type_spec, (tuple, list, set)):
for single_type in type_spec:
if (single_type is not None) and isclass(single_type) is False:
raise RuntimeError(
'Invalid specification. Must be type or tuple/list/set of types'
)
if None in type_spec:
type_spec = tuple(filter(lambda x: x is not None, type_spec))
return lambda x: None if \
x is None or (isclass(x) is True and issubclass(x, type_spec) is True) else \
raise_exception(str(x))
else:
return lambda x: None if (isclass(x) is True and issubclass(x, type_spec) is True) else \
raise_exception(str(x))
elif isclass(type_spec):
return lambda x: None if (isclass(x) is True and issubclass(x, type_spec) is True) else \
raise_exception(str(x))
else:
raise RuntimeError('Invalid specification. Must be type or tuple/list/set of types') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:check; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:value_spec; 6, identifier:arg_name; 7, identifier:decorated_function; 8, block; 8, 9; 8, 38; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:raise_exception; 11, parameters; 11, 12; 12, identifier:text_spec; 13, block; 13, 14; 13, 27; 13, 33; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:exc_text; 17, binary_operator:%; 17, 18; 17, 19; 18, string:'Argument "%s" for function "%s" has invalid value'; 19, tuple; 19, 20; 19, 21; 20, identifier:arg_name; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:Verifier; 24, identifier:function_name; 25, argument_list; 25, 26; 26, identifier:decorated_function; 27, expression_statement; 27, 28; 28, augmented_assignment:+=; 28, 29; 28, 30; 29, identifier:exc_text; 30, binary_operator:%; 30, 31; 30, 32; 31, string:' (%s)'; 32, identifier:text_spec; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:ValueError; 36, argument_list; 36, 37; 37, identifier:exc_text; 38, if_statement; 38, 39; 38, 47; 38, 92; 38, 117; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:value_spec; 43, tuple; 43, 44; 43, 45; 43, 46; 44, identifier:tuple; 45, identifier:list; 46, identifier:set; 47, block; 47, 48; 47, 65; 47, 90; 48, for_statement; 48, 49; 48, 50; 48, 51; 49, identifier:single_value; 50, identifier:value_spec; 51, block; 51, 52; 52, if_statement; 52, 53; 52, 59; 53, comparison_operator:is; 53, 54; 53, 58; 54, call; 54, 55; 54, 56; 55, identifier:isfunction; 56, argument_list; 56, 57; 57, identifier:single_value; 58, False; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:RuntimeError; 63, argument_list; 63, 64; 64, string:'Invalid specification. Must be function or tuple/list/set of functions'; 65, function_definition; 65, 66; 65, 67; 65, 69; 66, function_name:check; 67, parameters; 67, 68; 68, identifier:x; 69, block; 69, 70; 70, for_statement; 70, 71; 70, 72; 70, 73; 71, identifier:f; 72, identifier:value_spec; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 81; 75, comparison_operator:is; 75, 76; 75, 80; 76, call; 76, 77; 76, 78; 77, identifier:f; 78, argument_list; 78, 79; 79, identifier:x; 80, True; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:raise_exception; 85, argument_list; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:str; 88, argument_list; 88, 89; 89, identifier:x; 90, return_statement; 90, 91; 91, identifier:check; 92, elif_clause; 92, 93; 92, 97; 93, call; 93, 94; 93, 95; 94, identifier:isfunction; 95, argument_list; 95, 96; 96, identifier:value_spec; 97, block; 97, 98; 98, return_statement; 98, 99; 99, lambda; 99, 100; 99, 102; 100, lambda_parameters; 100, 101; 101, identifier:x; 102, conditional_expression:if; 102, 103; 102, 104; 102, 110; 103, None; 104, comparison_operator:is; 104, 105; 104, 109; 105, call; 105, 106; 105, 107; 106, identifier:value_spec; 107, argument_list; 107, 108; 108, identifier:x; 109, True; 110, call; 110, 111; 110, 112; 111, identifier:raise_exception; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:str; 115, argument_list; 115, 116; 116, identifier:x; 117, else_clause; 117, 118; 118, block; 118, 119; 119, raise_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:RuntimeError; 122, argument_list; 122, 123; 123, string:'Invalid specification. Must be function or tuple/list/set of functions' | def check(self, value_spec, arg_name, decorated_function):
def raise_exception(text_spec):
exc_text = 'Argument "%s" for function "%s" has invalid value' % (
arg_name, Verifier.function_name(decorated_function)
)
exc_text += ' (%s)' % text_spec
raise ValueError(exc_text)
if isinstance(value_spec, (tuple, list, set)):
for single_value in value_spec:
if isfunction(single_value) is False:
raise RuntimeError(
'Invalid specification. Must be function or tuple/list/set of functions'
)
def check(x):
for f in value_spec:
if f(x) is not True:
raise_exception(str(x))
return check
elif isfunction(value_spec):
return lambda x: None if value_spec(x) is True else raise_exception(str(x))
else:
raise RuntimeError('Invalid specification. Must be function or tuple/list/set of functions') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:cache_control; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:validator; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:storage; 9, None; 10, block; 10, 11; 10, 21; 10, 30; 10, 41; 10, 128; 11, function_definition; 11, 12; 11, 13; 11, 18; 12, function_name:default_validator; 13, parameters; 13, 14; 13, 16; 14, list_splat_pattern; 14, 15; 15, identifier:args; 16, dictionary_splat_pattern; 16, 17; 17, identifier:kwargs; 18, block; 18, 19; 19, return_statement; 19, 20; 20, True; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:validator; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:validator; 29, identifier:default_validator; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:storage; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:storage; 38, call; 38, 39; 38, 40; 39, identifier:WGlobalSingletonCacheStorage; 40, argument_list; 41, function_definition; 41, 42; 41, 43; 41, 45; 42, function_name:first_level_decorator; 43, parameters; 43, 44; 44, identifier:decorated_function; 45, block; 45, 46; 45, 120; 46, function_definition; 46, 47; 46, 48; 46, 54; 47, function_name:second_level_decorator; 48, parameters; 48, 49; 48, 50; 48, 52; 49, identifier:original_function; 50, list_splat_pattern; 50, 51; 51, identifier:args; 52, dictionary_splat_pattern; 52, 53; 53, identifier:kwargs; 54, block; 54, 55; 54, 66; 54, 79; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:validator_check; 58, call; 58, 59; 58, 60; 59, identifier:validator; 60, argument_list; 60, 61; 60, 62; 60, 64; 61, identifier:original_function; 62, list_splat; 62, 63; 63, identifier:args; 64, dictionary_splat; 64, 65; 65, identifier:kwargs; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:cache_entry; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:storage; 72, identifier:get_cache; 73, argument_list; 73, 74; 73, 75; 73, 77; 74, identifier:original_function; 75, list_splat; 75, 76; 76, identifier:args; 77, dictionary_splat; 77, 78; 78, identifier:kwargs; 79, if_statement; 79, 80; 79, 89; 79, 114; 80, boolean_operator:or; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:validator_check; 83, True; 84, comparison_operator:is; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:cache_entry; 87, identifier:has_value; 88, False; 89, block; 89, 90; 89, 100; 89, 112; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:result; 93, call; 93, 94; 93, 95; 94, identifier:original_function; 95, argument_list; 95, 96; 95, 98; 96, list_splat; 96, 97; 97, identifier:args; 98, dictionary_splat; 98, 99; 99, identifier:kwargs; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:storage; 104, identifier:put; 105, argument_list; 105, 106; 105, 107; 105, 108; 105, 110; 106, identifier:result; 107, identifier:original_function; 108, list_splat; 108, 109; 109, identifier:args; 110, dictionary_splat; 110, 111; 111, identifier:kwargs; 112, return_statement; 112, 113; 113, identifier:result; 114, else_clause; 114, 115; 115, block; 115, 116; 116, return_statement; 116, 117; 117, attribute; 117, 118; 117, 119; 118, identifier:cache_entry; 119, identifier:cached_value; 120, return_statement; 120, 121; 121, call; 121, 122; 121, 126; 122, call; 122, 123; 122, 124; 123, identifier:decorator; 124, argument_list; 124, 125; 125, identifier:second_level_decorator; 126, argument_list; 126, 127; 127, identifier:decorated_function; 128, return_statement; 128, 129; 129, identifier:first_level_decorator | def cache_control(validator=None, storage=None):
def default_validator(*args, **kwargs):
return True
if validator is None:
validator = default_validator
if storage is None:
storage = WGlobalSingletonCacheStorage()
def first_level_decorator(decorated_function):
def second_level_decorator(original_function, *args, **kwargs):
validator_check = validator(original_function, *args, **kwargs)
cache_entry = storage.get_cache(original_function, *args, **kwargs)
if validator_check is not True or cache_entry.has_value is False:
result = original_function(*args, **kwargs)
storage.put(result, original_function, *args, **kwargs)
return result
else:
return cache_entry.cached_value
return decorator(second_level_decorator)(decorated_function)
return first_level_decorator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 1, 14; 2, function_name:parse_int_string; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:int_string; 6, type; 6, 7; 7, identifier:str; 8, type; 8, 9; 9, generic_type; 9, 10; 9, 11; 10, identifier:List; 11, type_parameter; 11, 12; 12, type; 12, 13; 13, identifier:int; 14, block; 14, 15; 14, 32; 14, 42; 14, 52; 14, 61; 14, 73; 14, 168; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:cleaned; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, string:" "; 21, identifier:join; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:int_string; 28, identifier:strip; 29, argument_list; 30, identifier:split; 31, argument_list; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:cleaned; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:cleaned; 38, identifier:replace; 39, argument_list; 39, 40; 39, 41; 40, string:" - "; 41, string:"-"; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:cleaned; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:cleaned; 48, identifier:replace; 49, argument_list; 49, 50; 49, 51; 50, string:","; 51, string:" "; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:tokens; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:cleaned; 58, identifier:split; 59, argument_list; 59, 60; 60, string:" "; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 62, 70; 63, identifier:indices; 64, type; 64, 65; 65, generic_type; 65, 66; 65, 67; 66, identifier:Set; 67, type_parameter; 67, 68; 68, type; 68, 69; 69, identifier:int; 70, call; 70, 71; 70, 72; 71, identifier:set; 72, argument_list; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:token; 75, identifier:tokens; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 81; 77, 144; 78, comparison_operator:in; 78, 79; 78, 80; 79, string:"-"; 80, identifier:token; 81, block; 81, 82; 81, 91; 81, 107; 81, 116; 81, 127; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:endpoints; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:token; 88, identifier:split; 89, argument_list; 89, 90; 90, string:"-"; 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:endpoints; 97, integer:2; 98, block; 98, 99; 98, 106; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:LOG; 103, identifier:info; 104, argument_list; 104, 105; 105, string:f"Dropping '{token}' as invalid - weird range."; 106, continue_statement; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:start; 110, call; 110, 111; 110, 112; 111, identifier:int; 112, argument_list; 112, 113; 113, subscript; 113, 114; 113, 115; 114, identifier:endpoints; 115, integer:0; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:end; 119, binary_operator:+; 119, 120; 119, 126; 120, call; 120, 121; 120, 122; 121, identifier:int; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 125; 124, identifier:endpoints; 125, integer:1; 126, integer:1; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:indices; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:indices; 133, identifier:union; 134, argument_list; 134, 135; 134, 136; 135, identifier:indices; 136, call; 136, 137; 136, 138; 137, identifier:set; 138, argument_list; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:range; 141, argument_list; 141, 142; 141, 143; 142, identifier:start; 143, identifier:end; 144, else_clause; 144, 145; 145, block; 145, 146; 146, try_statement; 146, 147; 146, 158; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:indices; 152, identifier:add; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:int; 156, argument_list; 156, 157; 157, identifier:token; 158, except_clause; 158, 159; 158, 160; 159, identifier:ValueError; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:LOG; 165, identifier:info; 166, argument_list; 166, 167; 167, string:f"Dropping '{token}' as invalid - not an int."; 168, return_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:list; 171, argument_list; 171, 172; 172, identifier:indices | def parse_int_string(int_string: str) -> List[int]:
cleaned = " ".join(int_string.strip().split())
cleaned = cleaned.replace(" - ", "-")
cleaned = cleaned.replace(",", " ")
tokens = cleaned.split(" ")
indices: Set[int] = set()
for token in tokens:
if "-" in token:
endpoints = token.split("-")
if len(endpoints) != 2:
LOG.info(f"Dropping '{token}' as invalid - weird range.")
continue
start = int(endpoints[0])
end = int(endpoints[1]) + 1
indices = indices.union(indices, set(range(start, end)))
else:
try:
indices.add(int(token))
except ValueError:
LOG.info(f"Dropping '{token}' as invalid - not an int.")
return list(indices) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:locations_within; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:a; 5, identifier:b; 6, identifier:tolerance; 7, block; 7, 8; 7, 12; 7, 19; 7, 82; 7, 101; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:ret; 11, string:''; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:b; 15, call; 15, 16; 15, 17; 16, identifier:dict; 17, argument_list; 17, 18; 18, identifier:b; 19, for_statement; 19, 20; 19, 23; 19, 28; 20, tuple_pattern; 20, 21; 20, 22; 21, identifier:key; 22, identifier:value; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:a; 26, identifier:items; 27, argument_list; 28, block; 28, 29; 28, 41; 28, 78; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:not; 30, 31; 30, 32; 31, identifier:key; 32, identifier:b; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ValueError; 37, argument_list; 37, 38; 38, binary_operator:+; 38, 39; 38, 40; 39, string:"b does not have the key: "; 40, identifier:key; 41, if_statement; 41, 42; 41, 58; 42, comparison_operator:>; 42, 43; 42, 57; 43, call; 43, 44; 43, 45; 44, identifier:abs; 45, argument_list; 45, 46; 46, binary_operator:-; 46, 47; 46, 51; 47, call; 47, 48; 47, 49; 48, identifier:int; 49, argument_list; 49, 50; 50, identifier:value; 51, call; 51, 52; 51, 53; 52, identifier:int; 53, argument_list; 53, 54; 54, subscript; 54, 55; 54, 56; 55, identifier:b; 56, identifier:key; 57, identifier:tolerance; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, augmented_assignment:+=; 60, 61; 60, 62; 61, identifier:ret; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, string:'key {0} differs: {1} {2}'; 65, identifier:format; 66, argument_list; 66, 67; 66, 68; 66, 72; 67, identifier:key; 68, call; 68, 69; 68, 70; 69, identifier:int; 70, argument_list; 70, 71; 71, identifier:value; 72, call; 72, 73; 72, 74; 73, identifier:int; 74, argument_list; 74, 75; 75, subscript; 75, 76; 75, 77; 76, identifier:b; 77, identifier:key; 78, delete_statement; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:b; 81, identifier:key; 82, if_statement; 82, 83; 82, 84; 83, identifier:b; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:ValueError; 88, argument_list; 88, 89; 89, binary_operator:+; 89, 90; 89, 91; 90, string:"keys in b not seen in a: "; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, string:", "; 94, identifier:join; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:b; 99, identifier:keys; 100, argument_list; 101, return_statement; 101, 102; 102, identifier:ret | def locations_within(a, b, tolerance):
ret = ''
b = dict(b)
for (key, value) in a.items():
if key not in b:
raise ValueError("b does not have the key: " + key)
if abs(int(value) - int(b[key])) > tolerance:
ret += 'key {0} differs: {1} {2}'.format(key, int(value),
int(b[key]))
del b[key]
if b:
raise ValueError("keys in b not seen in a: " + ", ".join(b.keys()))
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:persistence2stats; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:rev_docs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:min_persisted; 7, integer:5; 8, default_parameter; 8, 9; 8, 10; 9, identifier:min_visible; 10, integer:1209600; 11, default_parameter; 11, 12; 11, 13; 12, identifier:include; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:exclude; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:verbose; 19, False; 20, block; 20, 21; 20, 32; 20, 39; 20, 46; 20, 58; 20, 70; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:rev_docs; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:mwxml; 28, identifier:utilities; 29, identifier:normalize; 30, argument_list; 30, 31; 31, identifier:rev_docs; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:min_persisted; 35, call; 35, 36; 35, 37; 36, identifier:int; 37, argument_list; 37, 38; 38, identifier:min_persisted; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:min_visible; 42, call; 42, 43; 42, 44; 43, identifier:int; 44, argument_list; 44, 45; 45, identifier:min_visible; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:include; 49, conditional_expression:if; 49, 50; 49, 51; 49, 54; 50, identifier:include; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:include; 53, None; 54, lambda; 54, 55; 54, 57; 55, lambda_parameters; 55, 56; 56, identifier:t; 57, True; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:exclude; 61, conditional_expression:if; 61, 62; 61, 63; 61, 66; 62, identifier:exclude; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:exclude; 65, None; 66, lambda; 66, 67; 66, 69; 67, lambda_parameters; 67, 68; 68, identifier:t; 69, False; 70, for_statement; 70, 71; 70, 72; 70, 73; 71, identifier:rev_doc; 72, identifier:rev_docs; 73, block; 73, 74; 73, 80; 73, 108; 73, 133; 73, 294; 73, 314; 73, 323; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:persistence_doc; 77, subscript; 77, 78; 77, 79; 78, identifier:rev_doc; 79, string:'persistence'; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:stats_doc; 83, dictionary; 83, 84; 83, 87; 83, 90; 83, 93; 83, 96; 83, 99; 83, 102; 83, 105; 84, pair; 84, 85; 84, 86; 85, string:'tokens_added'; 86, integer:0; 87, pair; 87, 88; 87, 89; 88, string:'persistent_tokens'; 89, integer:0; 90, pair; 90, 91; 90, 92; 91, string:'non_self_persistent_tokens'; 92, integer:0; 93, pair; 93, 94; 93, 95; 94, string:'sum_log_persisted'; 95, integer:0; 96, pair; 96, 97; 96, 98; 97, string:'sum_log_non_self_persisted'; 98, integer:0; 99, pair; 99, 100; 99, 101; 100, string:'sum_log_seconds_visible'; 101, integer:0; 102, pair; 102, 103; 102, 104; 103, string:'censored'; 104, False; 105, pair; 105, 106; 105, 107; 106, string:'non_self_censored'; 107, False; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:filtered_docs; 111, generator_expression; 111, 112; 111, 113; 111, 118; 112, identifier:t; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:t; 115, subscript; 115, 116; 115, 117; 116, identifier:persistence_doc; 117, string:'tokens'; 118, if_clause; 118, 119; 119, boolean_operator:and; 119, 120; 119, 126; 120, call; 120, 121; 120, 122; 121, identifier:include; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 125; 124, identifier:t; 125, string:'text'; 126, not_operator; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:exclude; 129, argument_list; 129, 130; 130, subscript; 130, 131; 130, 132; 131, identifier:t; 132, string:'text'; 133, for_statement; 133, 134; 133, 135; 133, 136; 134, identifier:token_doc; 135, identifier:filtered_docs; 136, block; 136, 137; 136, 157; 136, 163; 136, 176; 136, 190; 136, 204; 137, if_statement; 137, 138; 137, 139; 138, identifier:verbose; 139, block; 139, 140; 139, 149; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:sys; 145, identifier:stderr; 146, identifier:write; 147, argument_list; 147, 148; 148, string:"."; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:sys; 154, identifier:stderr; 155, identifier:flush; 156, argument_list; 157, expression_statement; 157, 158; 158, augmented_assignment:+=; 158, 159; 158, 162; 159, subscript; 159, 160; 159, 161; 160, identifier:stats_doc; 161, string:'tokens_added'; 162, integer:1; 163, expression_statement; 163, 164; 164, augmented_assignment:+=; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:stats_doc; 167, string:'sum_log_persisted'; 168, call; 168, 169; 168, 170; 169, identifier:log; 170, argument_list; 170, 171; 171, binary_operator:+; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:token_doc; 174, string:'persisted'; 175, integer:1; 176, expression_statement; 176, 177; 177, augmented_assignment:+=; 177, 178; 177, 181; 177, 182; 178, subscript; 178, 179; 178, 180; 179, identifier:stats_doc; 180, string:'sum_log_non_self_persisted'; 181, line_continuation:\; 182, call; 182, 183; 182, 184; 183, identifier:log; 184, argument_list; 184, 185; 185, binary_operator:+; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:token_doc; 188, string:'non_self_persisted'; 189, integer:1; 190, expression_statement; 190, 191; 191, augmented_assignment:+=; 191, 192; 191, 195; 191, 196; 192, subscript; 192, 193; 192, 194; 193, identifier:stats_doc; 194, string:'sum_log_seconds_visible'; 195, line_continuation:\; 196, call; 196, 197; 196, 198; 197, identifier:log; 198, argument_list; 198, 199; 199, binary_operator:+; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:token_doc; 202, string:'seconds_visible'; 203, integer:1; 204, if_statement; 204, 205; 204, 210; 204, 223; 205, comparison_operator:>=; 205, 206; 205, 209; 206, subscript; 206, 207; 206, 208; 207, identifier:token_doc; 208, string:'seconds_visible'; 209, identifier:min_visible; 210, block; 210, 211; 210, 217; 211, expression_statement; 211, 212; 212, augmented_assignment:+=; 212, 213; 212, 216; 213, subscript; 213, 214; 213, 215; 214, identifier:stats_doc; 215, string:'persistent_tokens'; 216, integer:1; 217, expression_statement; 217, 218; 218, augmented_assignment:+=; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:stats_doc; 221, string:'non_self_persistent_tokens'; 222, integer:1; 223, else_clause; 223, 224; 224, block; 224, 225; 224, 236; 224, 247; 225, expression_statement; 225, 226; 226, augmented_assignment:+=; 226, 227; 226, 230; 226, 231; 227, subscript; 227, 228; 227, 229; 228, identifier:stats_doc; 229, string:'persistent_tokens'; 230, line_continuation:\; 231, comparison_operator:>=; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:token_doc; 234, string:'persisted'; 235, identifier:min_persisted; 236, expression_statement; 236, 237; 237, augmented_assignment:+=; 237, 238; 237, 241; 237, 242; 238, subscript; 238, 239; 238, 240; 239, identifier:stats_doc; 240, string:'non_self_persistent_tokens'; 241, line_continuation:\; 242, comparison_operator:>=; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:token_doc; 245, string:'non_self_persisted'; 246, identifier:min_persisted; 247, if_statement; 247, 248; 247, 253; 247, 266; 248, comparison_operator:<; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:persistence_doc; 251, string:'seconds_possible'; 252, identifier:min_visible; 253, block; 253, 254; 253, 260; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 259; 256, subscript; 256, 257; 256, 258; 257, identifier:stats_doc; 258, string:'censored'; 259, True; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:stats_doc; 264, string:'non_self_censored'; 265, True; 266, else_clause; 266, 267; 267, block; 267, 268; 267, 281; 268, if_statement; 268, 269; 268, 274; 269, comparison_operator:<; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:persistence_doc; 272, string:'revisions_processed'; 273, identifier:min_persisted; 274, block; 274, 275; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:stats_doc; 279, string:'censored'; 280, True; 281, if_statement; 281, 282; 281, 287; 282, comparison_operator:<; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:persistence_doc; 285, string:'non_self_processed'; 286, identifier:min_persisted; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 293; 290, subscript; 290, 291; 290, 292; 291, identifier:stats_doc; 292, string:'non_self_censored'; 293, True; 294, if_statement; 294, 295; 294, 296; 295, identifier:verbose; 296, block; 296, 297; 296, 306; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 304; 299, attribute; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:sys; 302, identifier:stderr; 303, identifier:write; 304, argument_list; 304, 305; 305, string:"\n"; 306, expression_statement; 306, 307; 307, call; 307, 308; 307, 313; 308, attribute; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:sys; 311, identifier:stderr; 312, identifier:flush; 313, argument_list; 314, expression_statement; 314, 315; 315, call; 315, 316; 315, 321; 316, attribute; 316, 317; 316, 320; 317, subscript; 317, 318; 317, 319; 318, identifier:rev_doc; 319, string:'persistence'; 320, identifier:update; 321, argument_list; 321, 322; 322, identifier:stats_doc; 323, expression_statement; 323, 324; 324, yield; 324, 325; 325, identifier:rev_doc | def persistence2stats(rev_docs, min_persisted=5, min_visible=1209600,
include=None, exclude=None, verbose=False):
rev_docs = mwxml.utilities.normalize(rev_docs)
min_persisted = int(min_persisted)
min_visible = int(min_visible)
include = include if include is not None else lambda t: True
exclude = exclude if exclude is not None else lambda t: False
for rev_doc in rev_docs:
persistence_doc = rev_doc['persistence']
stats_doc = {
'tokens_added': 0,
'persistent_tokens': 0,
'non_self_persistent_tokens': 0,
'sum_log_persisted': 0,
'sum_log_non_self_persisted': 0,
'sum_log_seconds_visible': 0,
'censored': False,
'non_self_censored': False
}
filtered_docs = (t for t in persistence_doc['tokens']
if include(t['text']) and not exclude(t['text']))
for token_doc in filtered_docs:
if verbose:
sys.stderr.write(".")
sys.stderr.flush()
stats_doc['tokens_added'] += 1
stats_doc['sum_log_persisted'] += log(token_doc['persisted'] + 1)
stats_doc['sum_log_non_self_persisted'] += \
log(token_doc['non_self_persisted'] + 1)
stats_doc['sum_log_seconds_visible'] += \
log(token_doc['seconds_visible'] + 1)
if token_doc['seconds_visible'] >= min_visible:
stats_doc['persistent_tokens'] += 1
stats_doc['non_self_persistent_tokens'] += 1
else:
stats_doc['persistent_tokens'] += \
token_doc['persisted'] >= min_persisted
stats_doc['non_self_persistent_tokens'] += \
token_doc['non_self_persisted'] >= min_persisted
if persistence_doc['seconds_possible'] < min_visible:
stats_doc['censored'] = True
stats_doc['non_self_censored'] = True
else:
if persistence_doc['revisions_processed'] < min_persisted:
stats_doc['censored'] = True
if persistence_doc['non_self_processed'] < min_persisted:
stats_doc['non_self_censored'] = True
if verbose:
sys.stderr.write("\n")
sys.stderr.flush()
rev_doc['persistence'].update(stats_doc)
yield rev_doc |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:update_index; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 106; 5, 112; 5, 116; 5, 185; 5, 207; 5, 213; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:idx; 9, dictionary; 10, for_statement; 10, 11; 10, 14; 10, 35; 11, pattern_list; 11, 12; 11, 13; 12, identifier:_; 13, identifier:p; 14, call; 14, 15; 14, 16; 15, identifier:sorted; 16, argument_list; 16, 17; 16, 24; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:permissions; 22, identifier:items; 23, argument_list; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:key; 26, lambda; 26, 27; 26, 29; 27, lambda_parameters; 27, 28; 28, identifier:x; 29, call; 29, 30; 29, 31; 30, identifier:str; 31, argument_list; 31, 32; 32, subscript; 32, 33; 32, 34; 33, identifier:x; 34, integer:0; 35, block; 35, 36; 35, 40; 35, 46; 35, 92; 35, 100; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:branch; 39, identifier:idx; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:parent_p; 43, attribute; 43, 44; 43, 45; 44, identifier:const; 45, identifier:PERM_DENY; 46, for_statement; 46, 47; 46, 48; 46, 53; 47, identifier:k; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:p; 51, identifier:namespace; 52, identifier:keys; 53, block; 53, 54; 53, 80; 53, 86; 54, if_statement; 54, 55; 54, 59; 55, not_operator; 55, 56; 56, comparison_operator:in; 56, 57; 56, 58; 57, identifier:k; 58, identifier:branch; 59, block; 59, 60; 59, 69; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:branch; 64, identifier:k; 65, dictionary; 65, 66; 66, pair; 66, 67; 66, 68; 67, string:"__"; 68, identifier:parent_p; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:branch; 74, identifier:k; 75, identifier:update; 76, argument_list; 76, 77; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:__implicit; 79, True; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:branch; 83, subscript; 83, 84; 83, 85; 84, identifier:branch; 85, identifier:k; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:parent_p; 89, subscript; 89, 90; 89, 91; 90, identifier:branch; 91, string:"__"; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:branch; 96, string:"__"; 97, attribute; 97, 98; 97, 99; 98, identifier:p; 99, identifier:value; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:branch; 104, string:"__implicit"; 105, False; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:index; 111, identifier:idx; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:ramap; 115, dictionary; 116, function_definition; 116, 117; 116, 118; 116, 120; 117, function_name:update_ramap; 118, parameters; 118, 119; 119, identifier:branch_idx; 120, block; 120, 121; 120, 128; 120, 159; 120, 183; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:r; 124, dictionary; 124, 125; 125, pair; 125, 126; 125, 127; 126, string:"__"; 127, False; 128, for_statement; 128, 129; 128, 132; 128, 140; 129, pattern_list; 129, 130; 129, 131; 130, identifier:k; 131, identifier:v; 132, call; 132, 133; 132, 134; 133, identifier:list; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:branch_idx; 138, identifier:items; 139, argument_list; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 149; 142, boolean_operator:and; 142, 143; 142, 146; 143, comparison_operator:!=; 143, 144; 143, 145; 144, identifier:k; 145, string:"__"; 146, comparison_operator:!=; 146, 147; 146, 148; 147, identifier:k; 148, string:"__implicit"; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:r; 154, identifier:k; 155, call; 155, 156; 155, 157; 156, identifier:update_ramap; 157, argument_list; 157, 158; 158, identifier:v; 159, if_statement; 159, 160; 159, 176; 160, boolean_operator:and; 160, 161; 160, 166; 161, comparison_operator:is; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:branch_idx; 164, string:"__"; 165, None; 166, comparison_operator:!=; 166, 167; 166, 175; 167, parenthesized_expression; 167, 168; 168, binary_operator:&; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:branch_idx; 171, string:"__"; 172, attribute; 172, 173; 172, 174; 173, identifier:const; 174, identifier:PERM_READ; 175, integer:0; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:r; 181, string:"__"; 182, True; 183, return_statement; 183, 184; 184, identifier:r; 185, for_statement; 185, 186; 185, 189; 185, 197; 186, pattern_list; 186, 187; 186, 188; 187, identifier:k; 188, identifier:v; 189, call; 189, 190; 189, 191; 190, identifier:list; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:idx; 195, identifier:items; 196, argument_list; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:ramap; 202, identifier:k; 203, call; 203, 204; 203, 205; 204, identifier:update_ramap; 205, argument_list; 205, 206; 206, identifier:v; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:read_access_map; 212, identifier:ramap; 213, return_statement; 213, 214; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:index | def update_index(self):
idx = {}
for _, p in sorted(self.permissions.items(), key=lambda x: str(x[0])):
branch = idx
parent_p = const.PERM_DENY
for k in p.namespace.keys:
if not k in branch:
branch[k] = {"__": parent_p}
branch[k].update(__implicit=True)
branch = branch[k]
parent_p = branch["__"]
branch["__"] = p.value
branch["__implicit"] = False
self.index = idx
ramap = {}
def update_ramap(branch_idx):
r = {"__": False}
for k, v in list(branch_idx.items()):
if k != "__" and k != "__implicit":
r[k] = update_ramap(v)
if branch_idx["__"] is not None and (branch_idx["__"] & const.PERM_READ) != 0:
r["__"] = True
return r
for k, v in list(idx.items()):
ramap[k] = update_ramap(v)
self.read_access_map = ramap
return self.index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:type_check; 3, parameters; 3, 4; 4, identifier:func_handle; 5, block; 5, 6; 5, 101; 5, 310; 6, function_definition; 6, 7; 6, 8; 6, 12; 7, function_name:checkType; 8, parameters; 8, 9; 8, 10; 8, 11; 9, identifier:var_name; 10, identifier:var_val; 11, identifier:annot; 12, block; 12, 13; 12, 78; 13, if_statement; 13, 14; 13, 17; 13, 68; 14, comparison_operator:in; 14, 15; 14, 16; 15, identifier:var_name; 16, identifier:annot; 17, block; 17, 18; 17, 24; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:var_anno; 21, subscript; 21, 22; 21, 23; 22, identifier:annot; 23, identifier:var_name; 24, if_statement; 24, 25; 24, 28; 24, 33; 24, 52; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:var_val; 27, None; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:type_ok; 32, True; 33, elif_clause; 33, 34; 33, 41; 34, parenthesized_expression; 34, 35; 35, comparison_operator:is; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:type; 38, argument_list; 38, 39; 39, identifier:var_val; 40, identifier:bool; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:type_ok; 45, parenthesized_expression; 45, 46; 46, comparison_operator:in; 46, 47; 46, 51; 47, call; 47, 48; 47, 49; 48, identifier:type; 49, argument_list; 49, 50; 50, identifier:var_val; 51, identifier:var_anno; 52, else_clause; 52, 53; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:type_ok; 57, comparison_operator:in; 57, 58; 57, 59; 58, True; 59, list_comprehension; 59, 60; 59, 65; 60, call; 60, 61; 60, 62; 61, identifier:isinstance; 62, argument_list; 62, 63; 62, 64; 63, identifier:var_val; 64, identifier:_; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:_; 67, identifier:var_anno; 68, else_clause; 68, 69; 69, block; 69, 70; 69, 74; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:var_anno; 73, string:'Unspecified'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:type_ok; 77, True; 78, if_statement; 78, 79; 78, 81; 79, not_operator; 79, 80; 80, identifier:type_ok; 81, block; 81, 82; 81, 95; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:args; 85, tuple; 85, 86; 85, 87; 85, 90; 85, 91; 86, identifier:var_name; 87, attribute; 87, 88; 87, 89; 88, identifier:func_handle; 89, identifier:__name__; 90, identifier:var_anno; 91, call; 91, 92; 91, 93; 92, identifier:type; 93, argument_list; 93, 94; 94, identifier:var_val; 95, raise_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:QtmacsArgumentError; 98, argument_list; 98, 99; 99, list_splat; 99, 100; 100, identifier:args; 101, decorated_definition; 101, 102; 101, 109; 102, decorator; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:functools; 106, identifier:wraps; 107, argument_list; 107, 108; 108, identifier:func_handle; 109, function_definition; 109, 110; 109, 111; 109, 116; 110, function_name:wrapper; 111, parameters; 111, 112; 111, 114; 112, list_splat_pattern; 112, 113; 113, identifier:args; 114, dictionary_splat_pattern; 114, 115; 115, identifier:kwds; 116, block; 116, 117; 116, 126; 116, 130; 116, 170; 116, 224; 116, 231; 116, 259; 116, 302; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:argspec; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:inspect; 123, identifier:getfullargspec; 124, argument_list; 124, 125; 125, identifier:func_handle; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:annot; 129, dictionary; 130, for_statement; 130, 131; 130, 134; 130, 141; 131, pattern_list; 131, 132; 131, 133; 132, identifier:key; 133, identifier:val; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:argspec; 138, identifier:annotations; 139, identifier:items; 140, argument_list; 141, block; 141, 142; 142, if_statement; 142, 143; 142, 154; 142, 161; 143, boolean_operator:or; 143, 144; 143, 149; 144, call; 144, 145; 144, 146; 145, identifier:isinstance; 146, argument_list; 146, 147; 146, 148; 147, identifier:val; 148, identifier:tuple; 149, call; 149, 150; 149, 151; 150, identifier:isinstance; 151, argument_list; 151, 152; 151, 153; 152, identifier:val; 153, identifier:list; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:annot; 159, identifier:key; 160, identifier:val; 161, else_clause; 161, 162; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:annot; 167, identifier:key; 168, expression_list; 168, 169; 169, identifier:val; 170, if_statement; 170, 171; 170, 176; 170, 192; 171, comparison_operator:is; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:argspec; 174, identifier:defaults; 175, None; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:defaults; 180, call; 180, 181; 180, 182; 181, identifier:tuple; 182, argument_list; 182, 183; 183, binary_operator:*; 183, 184; 183, 186; 184, list:[None]; 184, 185; 185, None; 186, call; 186, 187; 186, 188; 187, identifier:len; 188, argument_list; 188, 189; 189, attribute; 189, 190; 189, 191; 190, identifier:argspec; 191, identifier:args; 192, else_clause; 192, 193; 193, block; 193, 194; 193, 210; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:num_none; 197, binary_operator:-; 197, 198; 197, 204; 198, call; 198, 199; 198, 200; 199, identifier:len; 200, argument_list; 200, 201; 201, attribute; 201, 202; 201, 203; 202, identifier:argspec; 203, identifier:args; 204, call; 204, 205; 204, 206; 205, identifier:len; 206, argument_list; 206, 207; 207, attribute; 207, 208; 207, 209; 208, identifier:argspec; 209, identifier:defaults; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:defaults; 213, binary_operator:+; 213, 214; 213, 221; 214, call; 214, 215; 214, 216; 215, identifier:tuple; 216, argument_list; 216, 217; 217, binary_operator:*; 217, 218; 217, 220; 218, list:[None]; 218, 219; 219, None; 220, identifier:num_none; 221, attribute; 221, 222; 221, 223; 222, identifier:argspec; 223, identifier:defaults; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:ofs; 227, call; 227, 228; 227, 229; 228, identifier:len; 229, argument_list; 229, 230; 230, identifier:args; 231, for_statement; 231, 232; 231, 235; 231, 245; 232, pattern_list; 232, 233; 232, 234; 233, identifier:idx; 234, identifier:var_name; 235, call; 235, 236; 235, 237; 236, identifier:enumerate; 237, argument_list; 237, 238; 238, subscript; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:argspec; 241, identifier:args; 242, slice; 242, 243; 242, 244; 243, colon; 244, identifier:ofs; 245, block; 245, 246; 245, 252; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:var_val; 249, subscript; 249, 250; 249, 251; 250, identifier:args; 251, identifier:idx; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:checkType; 255, argument_list; 255, 256; 255, 257; 255, 258; 256, identifier:var_name; 257, identifier:var_val; 258, identifier:annot; 259, for_statement; 259, 260; 259, 263; 259, 273; 260, pattern_list; 260, 261; 260, 262; 261, identifier:idx; 262, identifier:var_name; 263, call; 263, 264; 263, 265; 264, identifier:enumerate; 265, argument_list; 265, 266; 266, subscript; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:argspec; 269, identifier:args; 270, slice; 270, 271; 270, 272; 271, identifier:ofs; 272, colon; 273, block; 273, 274; 273, 295; 274, if_statement; 274, 275; 274, 278; 274, 285; 275, comparison_operator:in; 275, 276; 275, 277; 276, identifier:var_name; 277, identifier:kwds; 278, block; 278, 279; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:var_val; 282, subscript; 282, 283; 282, 284; 283, identifier:kwds; 284, identifier:var_name; 285, else_clause; 285, 286; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:var_val; 290, subscript; 290, 291; 290, 292; 291, identifier:defaults; 292, binary_operator:+; 292, 293; 292, 294; 293, identifier:idx; 294, identifier:ofs; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 298; 297, identifier:checkType; 298, argument_list; 298, 299; 298, 300; 298, 301; 299, identifier:var_name; 300, identifier:var_val; 301, identifier:annot; 302, return_statement; 302, 303; 303, call; 303, 304; 303, 305; 304, identifier:func_handle; 305, argument_list; 305, 306; 305, 308; 306, list_splat; 306, 307; 307, identifier:args; 308, dictionary_splat; 308, 309; 309, identifier:kwds; 310, return_statement; 310, 311; 311, identifier:wrapper | def type_check(func_handle):
def checkType(var_name, var_val, annot):
if var_name in annot:
var_anno = annot[var_name]
if var_val is None:
type_ok = True
elif (type(var_val) is bool):
type_ok = (type(var_val) in var_anno)
else:
type_ok = True in [isinstance(var_val, _) for _ in var_anno]
else:
var_anno = 'Unspecified'
type_ok = True
if not type_ok:
args = (var_name, func_handle.__name__, var_anno, type(var_val))
raise QtmacsArgumentError(*args)
@functools.wraps(func_handle)
def wrapper(*args, **kwds):
argspec = inspect.getfullargspec(func_handle)
annot = {}
for key, val in argspec.annotations.items():
if isinstance(val, tuple) or isinstance(val, list):
annot[key] = val
else:
annot[key] = val,
if argspec.defaults is None:
defaults = tuple([None] * len(argspec.args))
else:
num_none = len(argspec.args) - len(argspec.defaults)
defaults = tuple([None] * num_none) + argspec.defaults
ofs = len(args)
for idx, var_name in enumerate(argspec.args[:ofs]):
var_val = args[idx]
checkType(var_name, var_val, annot)
for idx, var_name in enumerate(argspec.args[ofs:]):
if var_name in kwds:
var_val = kwds[var_name]
else:
var_val = defaults[idx + ofs]
checkType(var_name, var_val, annot)
return func_handle(*args, **kwds)
return wrapper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:qteProcessKey; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:event; 6, identifier:targetObj; 7, block; 7, 8; 7, 18; 7, 25; 7, 36; 7, 72; 7, 81; 7, 89; 7, 120; 7, 133; 7, 142; 7, 337; 7, 348; 7, 355; 7, 366; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:msgObj; 11, call; 11, 12; 11, 13; 12, identifier:QtmacsMessage; 13, argument_list; 13, 14; 13, 17; 14, tuple; 14, 15; 14, 16; 15, identifier:targetObj; 16, identifier:event; 17, None; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:msgObj; 22, identifier:setSignalName; 23, argument_list; 23, 24; 24, string:'qtesigKeypressed'; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 34; 27, attribute; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:qteMain; 32, identifier:qtesigKeypressed; 33, identifier:emit; 34, argument_list; 34, 35; 35, identifier:msgObj; 36, if_statement; 36, 37; 36, 69; 37, comparison_operator:in; 37, 38; 37, 43; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:event; 41, identifier:key; 42, argument_list; 43, tuple; 43, 44; 43, 49; 43, 54; 43, 59; 43, 64; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:QtCore; 47, identifier:Qt; 48, identifier:Key_Shift; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:QtCore; 52, identifier:Qt; 53, identifier:Key_Control; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:QtCore; 57, identifier:Qt; 58, identifier:Key_Meta; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:QtCore; 62, identifier:Qt; 63, identifier:Key_Alt; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:QtCore; 67, identifier:Qt; 68, identifier:Key_AltGr; 69, block; 69, 70; 70, return_statement; 70, 71; 71, False; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:_keysequence; 78, identifier:appendQKeyEvent; 79, argument_list; 79, 80; 80, identifier:event; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:isRegisteredWidget; 84, call; 84, 85; 84, 86; 85, identifier:hasattr; 86, argument_list; 86, 87; 86, 88; 87, identifier:targetObj; 88, string:'_qteAdmin'; 89, if_statement; 89, 90; 89, 99; 89, 108; 90, boolean_operator:and; 90, 91; 90, 92; 91, identifier:isRegisteredWidget; 92, call; 92, 93; 92, 94; 93, identifier:hasattr; 94, argument_list; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:targetObj; 97, identifier:_qteAdmin; 98, string:'keyMap'; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:keyMap; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:targetObj; 106, identifier:_qteAdmin; 107, identifier:keyMap; 108, else_clause; 108, 109; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:keyMap; 113, call; 113, 114; 113, 119; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:qteMain; 118, identifier:_qteGlobalKeyMapByReference; 119, argument_list; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, tuple_pattern; 122, 123; 122, 124; 123, identifier:macroName; 124, identifier:isPartialMatch; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:keyMap; 128, identifier:match; 129, argument_list; 129, 130; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_keysequence; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:keyseq_copy; 136, call; 136, 137; 136, 138; 137, identifier:QtmacsKeysequence; 138, argument_list; 138, 139; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:_keysequence; 142, if_statement; 142, 143; 142, 144; 142, 230; 143, identifier:isPartialMatch; 144, block; 144, 145; 145, if_statement; 145, 146; 145, 149; 145, 176; 146, comparison_operator:is; 146, 147; 146, 148; 147, identifier:macroName; 148, None; 149, block; 149, 150; 149, 158; 149, 165; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:msgObj; 153, call; 153, 154; 153, 155; 154, identifier:QtmacsMessage; 155, argument_list; 155, 156; 155, 157; 156, identifier:keyseq_copy; 157, None; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:msgObj; 162, identifier:setSignalName; 163, argument_list; 163, 164; 164, string:'qtesigKeyseqPartial'; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 174; 167, attribute; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:qteMain; 172, identifier:qtesigKeyseqPartial; 173, identifier:emit; 174, argument_list; 174, 175; 175, identifier:msgObj; 176, else_clause; 176, 177; 177, block; 177, 178; 177, 194; 177, 204; 177, 211; 177, 222; 178, if_statement; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:_qteFlagRunMacro; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:qteMain; 189, identifier:qteRunMacro; 190, argument_list; 190, 191; 190, 192; 190, 193; 191, identifier:macroName; 192, identifier:targetObj; 193, identifier:keyseq_copy; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:msgObj; 197, call; 197, 198; 197, 199; 198, identifier:QtmacsMessage; 199, argument_list; 199, 200; 199, 203; 200, tuple; 200, 201; 200, 202; 201, identifier:macroName; 202, identifier:keyseq_copy; 203, None; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:msgObj; 208, identifier:setSignalName; 209, argument_list; 209, 210; 210, string:'qtesigKeyseqComplete'; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 220; 213, attribute; 213, 214; 213, 219; 214, attribute; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:self; 217, identifier:qteMain; 218, identifier:qtesigKeyseqComplete; 219, identifier:emit; 220, argument_list; 220, 221; 221, identifier:msgObj; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 229; 224, attribute; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:_keysequence; 228, identifier:reset; 229, argument_list; 230, else_clause; 230, 231; 231, block; 231, 232; 231, 329; 232, if_statement; 232, 233; 232, 234; 232, 309; 233, identifier:isRegisteredWidget; 234, block; 234, 235; 234, 243; 234, 253; 234, 263; 234, 272; 234, 283; 234, 291; 234, 298; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:tmp; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:keyseq_copy; 241, identifier:toString; 242, argument_list; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:tmp; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:tmp; 249, identifier:replace; 250, argument_list; 250, 251; 250, 252; 251, string:'<'; 252, string:'<'; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:tmp; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:tmp; 259, identifier:replace; 260, argument_list; 260, 261; 260, 262; 261, string:'>'; 262, string:'>'; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:msg; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, string:'No macro is bound to <b>{}</b>.'; 269, identifier:format; 270, argument_list; 270, 271; 271, identifier:tmp; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 281; 274, attribute; 274, 275; 274, 280; 275, attribute; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:qteMain; 279, identifier:qteLogger; 280, identifier:warning; 281, argument_list; 281, 282; 282, identifier:msg; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:msgObj; 286, call; 286, 287; 286, 288; 287, identifier:QtmacsMessage; 288, argument_list; 288, 289; 288, 290; 289, identifier:keyseq_copy; 290, None; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:msgObj; 295, identifier:setSignalName; 296, argument_list; 296, 297; 297, string:'qtesigKeyseqInvalid'; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 307; 300, attribute; 300, 301; 300, 306; 301, attribute; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:self; 304, identifier:qteMain; 305, identifier:qtesigKeyseqInvalid; 306, identifier:emit; 307, argument_list; 307, 308; 308, identifier:msgObj; 309, else_clause; 309, 310; 310, block; 310, 311; 311, if_statement; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:self; 314, identifier:_qteFlagRunMacro; 315, block; 315, 316; 316, expression_statement; 316, 317; 317, call; 317, 318; 317, 323; 318, attribute; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:qteMain; 322, identifier:qteRunMacro; 323, argument_list; 323, 324; 323, 327; 323, 328; 324, attribute; 324, 325; 324, 326; 325, identifier:self; 326, identifier:QtDelivery; 327, identifier:targetObj; 328, identifier:keyseq_copy; 329, expression_statement; 329, 330; 330, call; 330, 331; 330, 336; 331, attribute; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:_keysequence; 335, identifier:reset; 336, argument_list; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:msgObj; 340, call; 340, 341; 340, 342; 341, identifier:QtmacsMessage; 342, argument_list; 342, 343; 342, 347; 343, tuple; 343, 344; 343, 345; 343, 346; 344, identifier:targetObj; 345, identifier:keyseq_copy; 346, identifier:macroName; 347, None; 348, expression_statement; 348, 349; 349, call; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:msgObj; 352, identifier:setSignalName; 353, argument_list; 353, 354; 354, string:'qtesigKeyparsed'; 355, expression_statement; 355, 356; 356, call; 356, 357; 356, 364; 357, attribute; 357, 358; 357, 363; 358, attribute; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:self; 361, identifier:qteMain; 362, identifier:qtesigKeyparsed; 363, identifier:emit; 364, argument_list; 364, 365; 365, identifier:msgObj; 366, return_statement; 366, 367; 367, identifier:isPartialMatch | def qteProcessKey(self, event, targetObj):
msgObj = QtmacsMessage((targetObj, event), None)
msgObj.setSignalName('qtesigKeypressed')
self.qteMain.qtesigKeypressed.emit(msgObj)
if event.key() in (QtCore.Qt.Key_Shift, QtCore.Qt.Key_Control,
QtCore.Qt.Key_Meta, QtCore.Qt.Key_Alt,
QtCore.Qt.Key_AltGr):
return False
self._keysequence.appendQKeyEvent(event)
isRegisteredWidget = hasattr(targetObj, '_qteAdmin')
if isRegisteredWidget and hasattr(targetObj._qteAdmin, 'keyMap'):
keyMap = targetObj._qteAdmin.keyMap
else:
keyMap = self.qteMain._qteGlobalKeyMapByReference()
(macroName, isPartialMatch) = keyMap.match(self._keysequence)
keyseq_copy = QtmacsKeysequence(self._keysequence)
if isPartialMatch:
if macroName is None:
msgObj = QtmacsMessage(keyseq_copy, None)
msgObj.setSignalName('qtesigKeyseqPartial')
self.qteMain.qtesigKeyseqPartial.emit(msgObj)
else:
if self._qteFlagRunMacro:
self.qteMain.qteRunMacro(macroName, targetObj, keyseq_copy)
msgObj = QtmacsMessage((macroName, keyseq_copy), None)
msgObj.setSignalName('qtesigKeyseqComplete')
self.qteMain.qtesigKeyseqComplete.emit(msgObj)
self._keysequence.reset()
else:
if isRegisteredWidget:
tmp = keyseq_copy.toString()
tmp = tmp.replace('<', '<')
tmp = tmp.replace('>', '>')
msg = 'No macro is bound to <b>{}</b>.'.format(tmp)
self.qteMain.qteLogger.warning(msg)
msgObj = QtmacsMessage(keyseq_copy, None)
msgObj.setSignalName('qtesigKeyseqInvalid')
self.qteMain.qtesigKeyseqInvalid.emit(msgObj)
else:
if self._qteFlagRunMacro:
self.qteMain.qteRunMacro(
self.QtDelivery, targetObj, keyseq_copy)
self._keysequence.reset()
msgObj = QtmacsMessage((targetObj, keyseq_copy, macroName), None)
msgObj.setSignalName('qtesigKeyparsed')
self.qteMain.qtesigKeyparsed.emit(msgObj)
return isPartialMatch |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:timerEvent; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:event; 6, block; 6, 7; 6, 18; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:killTimer; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:event; 16, identifier:timerId; 17, argument_list; 18, if_statement; 18, 19; 18, 28; 18, 159; 18, 171; 19, comparison_operator:==; 19, 20; 19, 25; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:event; 23, identifier:timerId; 24, argument_list; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_qteTimerRunMacro; 28, block; 28, 29; 28, 35; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_qteTimerRunMacro; 34, None; 35, while_statement; 35, 36; 35, 37; 36, True; 37, block; 37, 38; 37, 153; 38, if_statement; 38, 39; 38, 47; 38, 71; 38, 144; 39, comparison_operator:>; 39, 40; 39, 46; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_qteMacroQueue; 46, integer:0; 47, block; 47, 48; 47, 62; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 54; 50, tuple_pattern; 50, 51; 50, 52; 50, 53; 51, identifier:macroName; 52, identifier:qteWidget; 53, identifier:event; 54, call; 54, 55; 54, 60; 55, attribute; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_qteMacroQueue; 59, identifier:pop; 60, argument_list; 60, 61; 61, integer:0; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_qteRunQueuedMacro; 67, argument_list; 67, 68; 67, 69; 67, 70; 68, identifier:macroName; 69, identifier:qteWidget; 70, identifier:event; 71, elif_clause; 71, 72; 71, 80; 72, comparison_operator:>; 72, 73; 72, 79; 73, call; 73, 74; 73, 75; 74, identifier:len; 75, argument_list; 75, 76; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_qteKeyEmulationQueue; 79, integer:0; 80, block; 80, 81; 80, 123; 80, 134; 81, if_statement; 81, 82; 81, 87; 81, 96; 82, comparison_operator:is; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_qteActiveApplet; 86, None; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:receiver; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:qteActiveWindow; 95, argument_list; 96, else_clause; 96, 97; 97, block; 97, 98; 98, if_statement; 98, 99; 98, 106; 98, 113; 99, comparison_operator:is; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_qteActiveApplet; 104, identifier:_qteActiveWidget; 105, None; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:receiver; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:_qteActiveApplet; 113, else_clause; 113, 114; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:receiver; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:_qteActiveApplet; 122, identifier:_qteActiveWidget; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:keysequence; 126, call; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_qteKeyEmulationQueue; 131, identifier:pop; 132, argument_list; 132, 133; 133, integer:0; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:_qteEventFilter; 140, identifier:eventFilter; 141, argument_list; 141, 142; 141, 143; 142, identifier:receiver; 143, identifier:keysequence; 144, else_clause; 144, 145; 145, block; 145, 146; 145, 152; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:_qteFocusManager; 151, argument_list; 152, break_statement; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:_qteFocusManager; 158, argument_list; 159, elif_clause; 159, 160; 159, 169; 160, comparison_operator:==; 160, 161; 160, 166; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:event; 164, identifier:timerId; 165, argument_list; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:debugTimer; 169, block; 169, 170; 170, pass_statement; 171, else_clause; 171, 172; 172, block; 172, 173; 172, 178; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 176; 175, identifier:print; 176, argument_list; 176, 177; 177, string:'Unknown timer ID'; 178, pass_statement | def timerEvent(self, event):
self.killTimer(event.timerId())
if event.timerId() == self._qteTimerRunMacro:
self._qteTimerRunMacro = None
while True:
if len(self._qteMacroQueue) > 0:
(macroName, qteWidget, event) = self._qteMacroQueue.pop(0)
self._qteRunQueuedMacro(macroName, qteWidget, event)
elif len(self._qteKeyEmulationQueue) > 0:
if self._qteActiveApplet is None:
receiver = self.qteActiveWindow()
else:
if self._qteActiveApplet._qteActiveWidget is None:
receiver = self._qteActiveApplet
else:
receiver = self._qteActiveApplet._qteActiveWidget
keysequence = self._qteKeyEmulationQueue.pop(0)
self._qteEventFilter.eventFilter(receiver, keysequence)
else:
self._qteFocusManager()
break
self._qteFocusManager()
elif event.timerId() == self.debugTimer:
pass
else:
print('Unknown timer ID')
pass |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 37; 2, function_name:qteNextApplet; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 17; 3, 22; 3, 27; 3, 32; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:numSkip; 7, type; 7, 8; 8, identifier:int; 9, integer:1; 10, typed_default_parameter; 10, 11; 10, 12; 10, 16; 11, identifier:ofsApp; 12, type; 12, 13; 13, tuple; 13, 14; 13, 15; 14, identifier:QtmacsApplet; 15, identifier:str; 16, None; 17, typed_default_parameter; 17, 18; 17, 19; 17, 21; 18, identifier:skipInvisible; 19, type; 19, 20; 20, identifier:bool; 21, True; 22, typed_default_parameter; 22, 23; 22, 24; 22, 26; 23, identifier:skipVisible; 24, type; 24, 25; 25, identifier:bool; 26, False; 27, typed_default_parameter; 27, 28; 27, 29; 27, 31; 28, identifier:skipMiniApplet; 29, type; 29, 30; 30, identifier:bool; 31, True; 32, typed_default_parameter; 32, 33; 32, 34; 32, 36; 33, identifier:windowObj; 34, type; 34, 35; 35, identifier:QtmacsWindow; 36, None; 37, block; 37, 38; 37, 54; 37, 66; 37, 73; 37, 82; 37, 120; 37, 138; 37, 157; 37, 167; 37, 178; 37, 292; 37, 304; 38, if_statement; 38, 39; 38, 44; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:ofsApp; 43, identifier:str; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:ofsApp; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:qteGetAppletHandle; 52, argument_list; 52, 53; 53, identifier:ofsApp; 54, if_statement; 54, 55; 54, 63; 55, comparison_operator:==; 55, 56; 55, 62; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:_qteAppletList; 62, integer:0; 63, block; 63, 64; 64, return_statement; 64, 65; 65, None; 66, if_statement; 66, 67; 66, 70; 67, boolean_operator:and; 67, 68; 67, 69; 68, identifier:skipVisible; 69, identifier:skipInvisible; 70, block; 70, 71; 71, return_statement; 71, 72; 72, None; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:appList; 76, call; 76, 77; 76, 78; 77, identifier:list; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_qteAppletList; 82, if_statement; 82, 83; 82, 84; 83, identifier:skipInvisible; 84, block; 84, 85; 84, 99; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:appList; 88, list_comprehension; 88, 89; 88, 90; 88, 93; 89, identifier:app; 90, for_in_clause; 90, 91; 90, 92; 91, identifier:app; 92, identifier:appList; 93, if_clause; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:app; 97, identifier:qteIsVisible; 98, argument_list; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:windowObj; 102, None; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:appList; 107, list_comprehension; 107, 108; 107, 109; 107, 112; 108, identifier:app; 109, for_in_clause; 109, 110; 109, 111; 110, identifier:app; 111, identifier:appList; 112, if_clause; 112, 113; 113, comparison_operator:==; 113, 114; 113, 119; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:app; 117, identifier:qteParentWindow; 118, argument_list; 119, identifier:windowObj; 120, if_statement; 120, 121; 120, 122; 121, identifier:skipVisible; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:appList; 126, list_comprehension; 126, 127; 126, 128; 126, 131; 127, identifier:app; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:app; 130, identifier:appList; 131, if_clause; 131, 132; 132, not_operator; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:app; 136, identifier:qteIsVisible; 137, argument_list; 138, if_statement; 138, 139; 138, 140; 139, identifier:skipMiniApplet; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 147; 142, comparison_operator:in; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_qteMiniApplet; 146, identifier:appList; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:appList; 152, identifier:remove; 153, argument_list; 153, 154; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_qteMiniApplet; 157, if_statement; 157, 158; 157, 164; 158, comparison_operator:==; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:appList; 163, integer:0; 164, block; 164, 165; 165, return_statement; 165, 166; 166, None; 167, if_statement; 167, 168; 167, 171; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:ofsApp; 170, None; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:ofsApp; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:_qteActiveApplet; 178, if_statement; 178, 179; 178, 184; 178, 286; 179, comparison_operator:in; 179, 180; 179, 181; 180, identifier:ofsApp; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:_qteAppletList; 184, block; 184, 185; 185, if_statement; 185, 186; 185, 189; 185, 199; 186, comparison_operator:in; 186, 187; 186, 188; 187, identifier:ofsApp; 188, identifier:appList; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:ofsIdx; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:appList; 196, identifier:index; 197, argument_list; 197, 198; 198, identifier:ofsApp; 199, else_clause; 199, 200; 200, block; 200, 201; 200, 212; 200, 222; 200, 232; 200, 249; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:ofsIdx; 204, call; 204, 205; 204, 210; 205, attribute; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:_qteAppletList; 209, identifier:index; 210, argument_list; 210, 211; 211, identifier:ofsApp; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:glob_list; 215, subscript; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:_qteAppletList; 219, slice; 219, 220; 219, 221; 220, identifier:ofsIdx; 221, colon; 222, expression_statement; 222, 223; 223, augmented_assignment:+=; 223, 224; 223, 225; 224, identifier:glob_list; 225, subscript; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:self; 228, identifier:_qteAppletList; 229, slice; 229, 230; 229, 231; 230, colon; 231, identifier:ofsIdx; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:ofsIdx; 235, list_comprehension; 235, 236; 235, 242; 235, 245; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:appList; 239, identifier:index; 240, argument_list; 240, 241; 241, identifier:_; 242, for_in_clause; 242, 243; 242, 244; 243, identifier:_; 244, identifier:glob_list; 245, if_clause; 245, 246; 246, comparison_operator:in; 246, 247; 246, 248; 247, identifier:_; 248, identifier:appList; 249, if_statement; 249, 250; 249, 256; 249, 278; 250, comparison_operator:==; 250, 251; 250, 255; 251, call; 251, 252; 251, 253; 252, identifier:len; 253, argument_list; 253, 254; 254, identifier:ofsIdx; 255, integer:0; 256, block; 256, 257; 256, 264; 256, 276; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:msg; 260, parenthesized_expression; 260, 261; 261, concatenated_string; 261, 262; 261, 263; 262, string:'No match between global and local applet list'; 263, string:' --> Bug.'; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 271; 266, attribute; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:self; 269, identifier:qteLogger; 270, identifier:error; 271, argument_list; 271, 272; 271, 273; 272, identifier:msg; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:stack_info; 275, True; 276, return_statement; 276, 277; 277, None; 278, else_clause; 278, 279; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:ofsIdx; 283, subscript; 283, 284; 283, 285; 284, identifier:ofsIdx; 285, integer:0; 286, else_clause; 286, 287; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:ofsIdx; 291, integer:0; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:ofsIdx; 295, binary_operator:%; 295, 296; 295, 300; 296, parenthesized_expression; 296, 297; 297, binary_operator:+; 297, 298; 297, 299; 298, identifier:ofsIdx; 299, identifier:numSkip; 300, call; 300, 301; 300, 302; 301, identifier:len; 302, argument_list; 302, 303; 303, identifier:appList; 304, return_statement; 304, 305; 305, subscript; 305, 306; 305, 307; 306, identifier:appList; 307, identifier:ofsIdx | def qteNextApplet(self, numSkip: int=1, ofsApp: (QtmacsApplet, str)=None,
skipInvisible: bool=True, skipVisible: bool=False,
skipMiniApplet: bool=True,
windowObj: QtmacsWindow=None):
if isinstance(ofsApp, str):
ofsApp = self.qteGetAppletHandle(ofsApp)
if len(self._qteAppletList) == 0:
return None
if skipVisible and skipInvisible:
return None
appList = list(self._qteAppletList)
if skipInvisible:
appList = [app for app in appList if app.qteIsVisible()]
if windowObj is not None:
appList = [app for app in appList
if app.qteParentWindow() == windowObj]
if skipVisible:
appList = [app for app in appList if not app.qteIsVisible()]
if skipMiniApplet:
if self._qteMiniApplet in appList:
appList.remove(self._qteMiniApplet)
if len(appList) == 0:
return None
if ofsApp is None:
ofsApp = self._qteActiveApplet
if ofsApp in self._qteAppletList:
if ofsApp in appList:
ofsIdx = appList.index(ofsApp)
else:
ofsIdx = self._qteAppletList.index(ofsApp)
glob_list = self._qteAppletList[ofsIdx:]
glob_list += self._qteAppletList[:ofsIdx]
ofsIdx = [appList.index(_) for _ in glob_list if _ in appList]
if len(ofsIdx) == 0:
msg = ('No match between global and local applet list'
' --> Bug.')
self.qteLogger.error(msg, stack_info=True)
return None
else:
ofsIdx = ofsIdx[0]
else:
ofsIdx = 0
ofsIdx = (ofsIdx + numSkip) % len(appList)
return appList[ofsIdx] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:_qteRunQueuedMacro; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 16; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:macroName; 7, type; 7, 8; 8, identifier:str; 9, typed_default_parameter; 9, 10; 9, 11; 9, 15; 10, identifier:widgetObj; 11, type; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:QtGui; 14, identifier:QWidget; 15, None; 16, typed_default_parameter; 16, 17; 16, 18; 16, 20; 17, identifier:keysequence; 18, type; 18, 19; 19, identifier:QtmacsKeysequence; 20, None; 21, block; 21, 22; 21, 29; 21, 65; 21, 75; 21, 113; 21, 124; 21, 153; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:app; 25, call; 25, 26; 25, 27; 26, identifier:qteGetAppletFromWidget; 27, argument_list; 27, 28; 28, identifier:widgetObj; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:app; 32, None; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 41; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:sip; 38, identifier:isdeleted; 39, argument_list; 39, 40; 40, identifier:app; 41, block; 41, 42; 41, 46; 41, 55; 41, 64; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:msg; 45, string:'Ignored macro <b>{}</b> because it targeted a'; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 49; 48, identifier:msg; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, string:' nonexistent applet.'; 52, identifier:format; 53, argument_list; 53, 54; 54, identifier:macroName; 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:qteLogger; 61, identifier:warning; 62, argument_list; 62, 63; 63, identifier:msg; 64, return_statement; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:macroObj; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:qteGetMacroObject; 72, argument_list; 72, 73; 72, 74; 73, identifier:macroName; 74, identifier:widgetObj; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:is; 76, 77; 76, 78; 77, identifier:macroObj; 78, None; 79, block; 79, 80; 79, 84; 79, 103; 79, 112; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:msg; 83, string:'No <b>{}</b>-macro compatible with {}:{}-type applet'; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:msg; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:msg; 90, identifier:format; 91, argument_list; 91, 92; 91, 93; 91, 98; 92, identifier:macroName; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:app; 96, identifier:qteAppletSignature; 97, argument_list; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:widgetObj; 101, identifier:_qteAdmin; 102, identifier:widgetSignature; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:qteLogger; 109, identifier:warning; 110, argument_list; 110, 111; 111, identifier:msg; 112, return_statement; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:qteDefVar; 118, argument_list; 118, 119; 118, 120; 118, 121; 119, string:'last_key_sequence'; 120, identifier:keysequence; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:doc; 123, string:"Last valid key sequence that triggered a macro."; 124, if_statement; 124, 125; 124, 128; 124, 139; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:app; 127, None; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:macroObj; 133, identifier:qteApplet; 134, assignment; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:macroObj; 137, identifier:qteWidget; 138, None; 139, else_clause; 139, 140; 140, block; 140, 141; 140, 147; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:macroObj; 145, identifier:qteApplet; 146, identifier:app; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:macroObj; 151, identifier:qteWidget; 152, identifier:widgetObj; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:macroObj; 157, identifier:qtePrepareToRun; 158, argument_list | def _qteRunQueuedMacro(self, macroName: str,
widgetObj: QtGui.QWidget=None,
keysequence: QtmacsKeysequence=None):
app = qteGetAppletFromWidget(widgetObj)
if app is not None:
if sip.isdeleted(app):
msg = 'Ignored macro <b>{}</b> because it targeted a'
msg += ' nonexistent applet.'.format(macroName)
self.qteLogger.warning(msg)
return
macroObj = self.qteGetMacroObject(macroName, widgetObj)
if macroObj is None:
msg = 'No <b>{}</b>-macro compatible with {}:{}-type applet'
msg = msg.format(macroName, app.qteAppletSignature(),
widgetObj._qteAdmin.widgetSignature)
self.qteLogger.warning(msg)
return
self.qteDefVar('last_key_sequence', keysequence,
doc="Last valid key sequence that triggered a macro.")
if app is None:
macroObj.qteApplet = macroObj.qteWidget = None
else:
macroObj.qteApplet = app
macroObj.qteWidget = widgetObj
macroObj.qtePrepareToRun() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:qteNewApplet; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 14; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:appletName; 7, type; 7, 8; 8, identifier:str; 9, typed_default_parameter; 9, 10; 9, 11; 9, 13; 10, identifier:appletID; 11, type; 11, 12; 12, identifier:str; 13, None; 14, typed_default_parameter; 14, 15; 14, 16; 14, 18; 15, identifier:windowObj; 16, type; 16, 17; 17, identifier:QtmacsWindow; 18, None; 19, block; 19, 20; 19, 55; 19, 95; 19, 128; 19, 168; 19, 206; 19, 254; 19, 264; 19, 303; 19, 310; 19, 322; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:windowObj; 23, None; 24, block; 24, 25; 24, 33; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:windowObj; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:qteActiveWindow; 32, argument_list; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:windowObj; 36, None; 37, block; 37, 38; 37, 42; 37, 54; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:msg; 41, string:'Cannot determine the currently active window.'; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:qteLogger; 48, identifier:error; 49, argument_list; 49, 50; 49, 51; 50, identifier:msg; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:stack_info; 53, True; 54, return_statement; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:appletID; 58, None; 59, block; 59, 60; 59, 64; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:cnt; 63, integer:0; 64, while_statement; 64, 65; 64, 66; 65, True; 66, block; 66, 67; 66, 78; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:appletID; 70, binary_operator:+; 70, 71; 70, 74; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:appletName; 73, string:'_'; 74, call; 74, 75; 74, 76; 75, identifier:str; 76, argument_list; 76, 77; 77, identifier:cnt; 78, if_statement; 78, 79; 78, 87; 78, 89; 79, comparison_operator:is; 79, 80; 79, 86; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:qteGetAppletHandle; 84, argument_list; 84, 85; 85, identifier:appletID; 86, None; 87, block; 87, 88; 88, break_statement; 89, else_clause; 89, 90; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, augmented_assignment:+=; 92, 93; 92, 94; 93, identifier:cnt; 94, integer:1; 95, if_statement; 95, 96; 95, 104; 96, comparison_operator:is; 96, 97; 96, 103; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:qteGetAppletHandle; 101, argument_list; 101, 102; 102, identifier:appletID; 103, None; 104, block; 104, 105; 104, 114; 104, 126; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:msg; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, string:'Applet with ID <b>{}</b> already exists'; 111, identifier:format; 112, argument_list; 112, 113; 113, identifier:appletID; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:qteLogger; 120, identifier:error; 121, argument_list; 121, 122; 121, 123; 122, identifier:msg; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:stack_info; 125, True; 126, return_statement; 126, 127; 127, None; 128, if_statement; 128, 129; 128, 134; 128, 158; 129, comparison_operator:not; 129, 130; 129, 131; 130, identifier:appletName; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_qteRegistryApplets; 134, block; 134, 135; 134, 144; 134, 156; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:msg; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, string:'Unknown applet <b>{}</b>'; 141, identifier:format; 142, argument_list; 142, 143; 143, identifier:appletName; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:qteLogger; 150, identifier:error; 151, argument_list; 151, 152; 151, 153; 152, identifier:msg; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:stack_info; 155, True; 156, return_statement; 156, 157; 157, None; 158, else_clause; 158, 159; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:cls; 163, subscript; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:_qteRegistryApplets; 167, identifier:appletName; 168, try_statement; 168, 169; 168, 177; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:app; 173, call; 173, 174; 173, 175; 174, identifier:cls; 175, argument_list; 175, 176; 176, identifier:appletID; 177, except_clause; 177, 178; 177, 179; 178, identifier:Exception; 179, block; 179, 180; 179, 189; 179, 204; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:msg; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, string:'Applet <b>{}</b> has a faulty constructor.'; 186, identifier:format; 187, argument_list; 187, 188; 188, identifier:appletID; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:self; 194, identifier:qteLogger; 195, identifier:exception; 196, argument_list; 196, 197; 196, 198; 196, 201; 197, identifier:msg; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:exc_info; 200, True; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:stack_info; 203, True; 204, return_statement; 204, 205; 205, None; 206, if_statement; 206, 207; 206, 214; 207, comparison_operator:is; 207, 208; 207, 213; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:app; 211, identifier:qteAppletSignature; 212, argument_list; 213, None; 214, block; 214, 215; 214, 228; 214, 232; 214, 236; 214, 240; 214, 252; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:msg; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, string:'Cannot add applet <b>{}</b> '; 221, identifier:format; 222, argument_list; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:app; 226, identifier:qteAppletID; 227, argument_list; 228, expression_statement; 228, 229; 229, augmented_assignment:+=; 229, 230; 229, 231; 230, identifier:msg; 231, string:'because it has not applet signature.'; 232, expression_statement; 232, 233; 233, augmented_assignment:+=; 233, 234; 233, 235; 234, identifier:msg; 235, string:' Use self.qteSetAppletSignature in the constructor'; 236, expression_statement; 236, 237; 237, augmented_assignment:+=; 237, 238; 237, 239; 238, identifier:msg; 239, string:' of the class to fix this.'; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:qteLogger; 246, identifier:error; 247, argument_list; 247, 248; 247, 249; 248, identifier:msg; 249, keyword_argument; 249, 250; 249, 251; 250, identifier:stack_info; 251, True; 252, return_statement; 252, 253; 253, None; 254, expression_statement; 254, 255; 255, call; 255, 256; 255, 261; 256, attribute; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:_qteAppletList; 260, identifier:insert; 261, argument_list; 261, 262; 261, 263; 262, integer:0; 263, identifier:app; 264, if_statement; 264, 265; 264, 272; 265, comparison_operator:is; 265, 266; 265, 271; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:app; 269, identifier:layout; 270, argument_list; 271, None; 272, block; 272, 273; 272, 281; 272, 296; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:appLayout; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:QtGui; 279, identifier:QHBoxLayout; 280, argument_list; 281, for_statement; 281, 282; 281, 283; 281, 288; 282, identifier:handle; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:app; 286, identifier:_qteAdmin; 287, identifier:widgetList; 288, block; 288, 289; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:appLayout; 293, identifier:addWidget; 294, argument_list; 294, 295; 295, identifier:handle; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:app; 300, identifier:setLayout; 301, argument_list; 301, 302; 302, identifier:appLayout; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:app; 307, identifier:qteReparent; 308, argument_list; 308, 309; 309, None; 310, expression_statement; 310, 311; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:self; 314, identifier:qteRunHook; 315, argument_list; 315, 316; 315, 317; 316, string:'init'; 317, call; 317, 318; 317, 319; 318, identifier:QtmacsMessage; 319, argument_list; 319, 320; 319, 321; 320, None; 321, identifier:app; 322, return_statement; 322, 323; 323, identifier:app | def qteNewApplet(self, appletName: str, appletID: str=None,
windowObj: QtmacsWindow=None):
if windowObj is None:
windowObj = self.qteActiveWindow()
if windowObj is None:
msg = 'Cannot determine the currently active window.'
self.qteLogger.error(msg, stack_info=True)
return
if appletID is None:
cnt = 0
while True:
appletID = appletName + '_' + str(cnt)
if self.qteGetAppletHandle(appletID) is None:
break
else:
cnt += 1
if self.qteGetAppletHandle(appletID) is not None:
msg = 'Applet with ID <b>{}</b> already exists'.format(appletID)
self.qteLogger.error(msg, stack_info=True)
return None
if appletName not in self._qteRegistryApplets:
msg = 'Unknown applet <b>{}</b>'.format(appletName)
self.qteLogger.error(msg, stack_info=True)
return None
else:
cls = self._qteRegistryApplets[appletName]
try:
app = cls(appletID)
except Exception:
msg = 'Applet <b>{}</b> has a faulty constructor.'.format(appletID)
self.qteLogger.exception(msg, exc_info=True, stack_info=True)
return None
if app.qteAppletSignature() is None:
msg = 'Cannot add applet <b>{}</b> '.format(app.qteAppletID())
msg += 'because it has not applet signature.'
msg += ' Use self.qteSetAppletSignature in the constructor'
msg += ' of the class to fix this.'
self.qteLogger.error(msg, stack_info=True)
return None
self._qteAppletList.insert(0, app)
if app.layout() is None:
appLayout = QtGui.QHBoxLayout()
for handle in app._qteAdmin.widgetList:
appLayout.addWidget(handle)
app.setLayout(appLayout)
app.qteReparent(None)
self.qteRunHook('init', QtmacsMessage(None, app))
return app |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:qteAddMiniApplet; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:appletObj; 7, type; 7, 8; 8, identifier:QtmacsApplet; 9, block; 9, 10; 9, 32; 9, 71; 9, 79; 9, 85; 9, 91; 9, 99; 9, 107; 9, 115; 9, 117; 9, 129; 9, 140; 9, 149; 9, 162; 9, 171; 9, 180; 10, if_statement; 10, 11; 10, 16; 11, comparison_operator:is; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_qteMiniApplet; 15, None; 16, block; 16, 17; 16, 21; 16, 30; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:msg; 20, string:'Cannot replace mini applet more than once.'; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:qteLogger; 27, identifier:warning; 28, argument_list; 28, 29; 29, identifier:msg; 30, return_statement; 30, 31; 31, False; 32, if_statement; 32, 33; 32, 40; 33, comparison_operator:is; 33, 34; 33, 39; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:appletObj; 37, identifier:layout; 38, argument_list; 39, None; 40, block; 40, 41; 40, 49; 40, 64; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:appLayout; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:QtGui; 47, identifier:QHBoxLayout; 48, argument_list; 49, for_statement; 49, 50; 49, 51; 49, 56; 50, identifier:handle; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:appletObj; 54, identifier:_qteAdmin; 55, identifier:widgetList; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:appLayout; 61, identifier:addWidget; 62, argument_list; 62, 63; 63, identifier:handle; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:appletObj; 68, identifier:setLayout; 69, argument_list; 69, 70; 70, identifier:appLayout; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:appletObj; 76, identifier:_qteAdmin; 77, identifier:isMiniApplet; 78, True; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_qteMiniApplet; 84, identifier:appletObj; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:app; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_qteActiveApplet; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:appWin; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:qteActiveWindow; 98, argument_list; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_qteMiniApplet; 105, identifier:_qteCallingApplet; 106, identifier:app; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:_qteMiniApplet; 113, identifier:_qteCallingWindow; 114, identifier:appWin; 115, delete_statement; 115, 116; 116, identifier:app; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:_qteAppletList; 123, identifier:insert; 124, argument_list; 124, 125; 124, 126; 125, integer:0; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_qteMiniApplet; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:appWin; 134, identifier:qteLayoutSplitter; 135, identifier:addWidget; 136, argument_list; 136, 137; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:_qteMiniApplet; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_qteMiniApplet; 146, identifier:show; 147, argument_list; 147, 148; 148, True; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:wid; 152, call; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_qteMiniApplet; 157, identifier:qteNextWidget; 158, argument_list; 158, 159; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:numSkip; 161, integer:0; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:_qteMiniApplet; 168, identifier:qteMakeWidgetActive; 169, argument_list; 169, 170; 170, identifier:wid; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:qteMakeAppletActive; 176, argument_list; 176, 177; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:_qteMiniApplet; 180, return_statement; 180, 181; 181, True | def qteAddMiniApplet(self, appletObj: QtmacsApplet):
if self._qteMiniApplet is not None:
msg = 'Cannot replace mini applet more than once.'
self.qteLogger.warning(msg)
return False
if appletObj.layout() is None:
appLayout = QtGui.QHBoxLayout()
for handle in appletObj._qteAdmin.widgetList:
appLayout.addWidget(handle)
appletObj.setLayout(appLayout)
appletObj._qteAdmin.isMiniApplet = True
self._qteMiniApplet = appletObj
app = self._qteActiveApplet
appWin = self.qteActiveWindow()
self._qteMiniApplet._qteCallingApplet = app
self._qteMiniApplet._qteCallingWindow = appWin
del app
self._qteAppletList.insert(0, self._qteMiniApplet)
appWin.qteLayoutSplitter.addWidget(self._qteMiniApplet)
self._qteMiniApplet.show(True)
wid = self._qteMiniApplet.qteNextWidget(numSkip=0)
self._qteMiniApplet.qteMakeWidgetActive(wid)
self.qteMakeAppletActive(self._qteMiniApplet)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:qteKillMiniApplet; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 41; 5, 175; 5, 183; 5, 191; 6, if_statement; 6, 7; 6, 12; 7, comparison_operator:is; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:_qteMiniApplet; 11, None; 12, block; 12, 13; 13, return_statement; 14, if_statement; 14, 15; 14, 24; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:qteIsMiniApplet; 20, argument_list; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_qteMiniApplet; 24, block; 24, 25; 24, 32; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:msg; 28, parenthesized_expression; 28, 29; 29, concatenated_string; 29, 30; 29, 31; 30, string:'Mini applet does not have its mini applet flag set.'; 31, string:' Ignored.'; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:qteLogger; 38, identifier:warning; 39, argument_list; 39, 40; 40, identifier:msg; 41, if_statement; 41, 42; 41, 49; 41, 63; 42, comparison_operator:not; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_qteMiniApplet; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_qteAppletList; 49, block; 49, 50; 49, 54; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:msg; 53, string:'Custom mini applet not in applet list --> Bug.'; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:qteLogger; 60, identifier:warning; 61, argument_list; 61, 62; 62, identifier:msg; 63, else_clause; 63, 64; 64, block; 64, 65; 64, 97; 64, 105; 64, 116; 64, 164; 65, try_statement; 65, 66; 65, 75; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:_qteMiniApplet; 73, identifier:qteToBeKilled; 74, argument_list; 75, except_clause; 75, 76; 75, 77; 76, identifier:Exception; 77, block; 77, 78; 77, 82; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:msg; 81, string:'qteToBeKilledRoutine is faulty'; 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:qteLogger; 88, identifier:exception; 89, argument_list; 89, 90; 89, 91; 89, 94; 90, identifier:msg; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:exc_info; 93, True; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:stack_info; 96, True; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:win; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_qteMiniApplet; 104, identifier:_qteCallingWindow; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:app; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:qteNextApplet; 112, argument_list; 112, 113; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:windowObj; 115, identifier:win; 116, if_statement; 116, 117; 116, 120; 116, 128; 117, comparison_operator:is; 117, 118; 117, 119; 118, identifier:app; 119, None; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:qteMakeAppletActive; 126, argument_list; 126, 127; 127, identifier:app; 128, else_clause; 128, 129; 129, block; 129, 130; 129, 144; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:app; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:qteNextApplet; 137, argument_list; 137, 138; 137, 141; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:skipInvisible; 140, False; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:skipVisible; 143, True; 144, if_statement; 144, 145; 144, 148; 144, 156; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:app; 147, None; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:qteMakeAppletActive; 154, argument_list; 154, 155; 155, identifier:app; 156, else_clause; 156, 157; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:_qteActiveApplet; 163, None; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:_qteAppletList; 170, identifier:remove; 171, argument_list; 171, 172; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:_qteMiniApplet; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:_qteMiniApplet; 181, identifier:close; 182, argument_list; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:_qteMiniApplet; 189, identifier:deleteLater; 190, argument_list; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:_qteMiniApplet; 196, None | def qteKillMiniApplet(self):
if self._qteMiniApplet is None:
return
if not self.qteIsMiniApplet(self._qteMiniApplet):
msg = ('Mini applet does not have its mini applet flag set.'
' Ignored.')
self.qteLogger.warning(msg)
if self._qteMiniApplet not in self._qteAppletList:
msg = 'Custom mini applet not in applet list --> Bug.'
self.qteLogger.warning(msg)
else:
try:
self._qteMiniApplet.qteToBeKilled()
except Exception:
msg = 'qteToBeKilledRoutine is faulty'
self.qteLogger.exception(msg, exc_info=True, stack_info=True)
win = self._qteMiniApplet._qteCallingWindow
app = self.qteNextApplet(windowObj=win)
if app is not None:
self.qteMakeAppletActive(app)
else:
app = self.qteNextApplet(skipInvisible=False, skipVisible=True)
if app is not None:
self.qteMakeAppletActive(app)
else:
self._qteActiveApplet = None
self._qteAppletList.remove(self._qteMiniApplet)
self._qteMiniApplet.close()
self._qteMiniApplet.deleteLater()
self._qteMiniApplet = None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:qteSplitApplet; 3, parameters; 3, 4; 3, 5; 3, 12; 3, 17; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 11; 6, identifier:applet; 7, type; 7, 8; 8, tuple; 8, 9; 8, 10; 9, identifier:QtmacsApplet; 10, identifier:str; 11, None; 12, typed_default_parameter; 12, 13; 12, 14; 12, 16; 13, identifier:splitHoriz; 14, type; 14, 15; 15, identifier:bool; 16, True; 17, typed_default_parameter; 17, 18; 17, 19; 17, 21; 18, identifier:windowObj; 19, type; 19, 20; 20, identifier:QtmacsWindow; 21, None; 22, block; 22, 23; 22, 45; 22, 80; 22, 101; 22, 131; 22, 147; 22, 178; 22, 192; 22, 204; 22, 240; 22, 272; 22, 281; 22, 289; 22, 296; 22, 303; 22, 310; 22, 318; 22, 324; 23, if_statement; 23, 24; 23, 29; 23, 39; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:applet; 28, identifier:str; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:newAppObj; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:qteGetAppletHandle; 37, argument_list; 37, 38; 38, identifier:applet; 39, else_clause; 39, 40; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:newAppObj; 44, identifier:applet; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:windowObj; 48, None; 49, block; 49, 50; 49, 58; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:windowObj; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:qteActiveWindow; 57, argument_list; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:is; 59, 60; 59, 61; 60, identifier:windowObj; 61, None; 62, block; 62, 63; 62, 67; 62, 79; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:msg; 66, string:'Cannot determine the currently active window.'; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:qteLogger; 73, identifier:error; 74, argument_list; 74, 75; 74, 76; 75, identifier:msg; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:stack_info; 78, True; 79, return_statement; 80, if_statement; 80, 81; 80, 82; 80, 91; 81, identifier:splitHoriz; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:splitOrientation; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:QtCore; 89, identifier:Qt; 90, identifier:Horizontal; 91, else_clause; 91, 92; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:splitOrientation; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:QtCore; 99, identifier:Qt; 100, identifier:Vertical; 101, if_statement; 101, 102; 101, 105; 101, 120; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:newAppObj; 104, None; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:newAppObj; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:qteNextApplet; 113, argument_list; 113, 114; 113, 117; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:skipVisible; 116, True; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:skipInvisible; 119, False; 120, else_clause; 120, 121; 121, block; 121, 122; 122, if_statement; 122, 123; 122, 128; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:newAppObj; 126, identifier:qteIsVisible; 127, argument_list; 128, block; 128, 129; 129, return_statement; 129, 130; 130, False; 131, if_statement; 131, 132; 131, 135; 132, comparison_operator:is; 132, 133; 132, 134; 133, identifier:newAppObj; 134, None; 135, block; 135, 136; 135, 145; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:qteLogger; 142, identifier:warning; 143, argument_list; 143, 144; 144, string:'All applets are already visible.'; 145, return_statement; 145, 146; 146, False; 147, if_statement; 147, 148; 147, 157; 148, comparison_operator:==; 148, 149; 148, 156; 149, call; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:windowObj; 153, identifier:qteAppletSplitter; 154, identifier:count; 155, argument_list; 156, integer:0; 157, block; 157, 158; 157, 167; 157, 176; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 165; 160, attribute; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:windowObj; 163, identifier:qteAppletSplitter; 164, identifier:qteAddWidget; 165, argument_list; 165, 166; 166, identifier:newAppObj; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:windowObj; 172, identifier:qteAppletSplitter; 173, identifier:setOrientation; 174, argument_list; 174, 175; 175, identifier:splitOrientation; 176, return_statement; 176, 177; 177, True; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:curApp; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:qteNextApplet; 185, argument_list; 185, 186; 185, 189; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:numSkip; 188, integer:0; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:windowObj; 191, identifier:windowObj; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:split; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:_qteFindAppletInSplitter; 199, argument_list; 199, 200; 199, 201; 200, identifier:curApp; 201, attribute; 201, 202; 201, 203; 202, identifier:windowObj; 203, identifier:qteAppletSplitter; 204, if_statement; 204, 205; 204, 208; 205, comparison_operator:is; 205, 206; 205, 207; 206, identifier:split; 207, None; 208, block; 208, 209; 208, 213; 208, 226; 208, 238; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:msg; 212, string:'Active applet <b>{}</b> not in the layout.'; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:msg; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:msg; 219, identifier:format; 220, argument_list; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:curApp; 224, identifier:qteAppletID; 225, argument_list; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:qteLogger; 232, identifier:error; 233, argument_list; 233, 234; 233, 235; 234, identifier:msg; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:stack_info; 237, True; 238, return_statement; 238, 239; 239, False; 240, if_statement; 240, 241; 240, 246; 241, comparison_operator:is; 241, 242; 241, 243; 242, identifier:split; 243, attribute; 243, 244; 243, 245; 244, identifier:windowObj; 245, identifier:qteAppletSplitter; 246, block; 246, 247; 247, if_statement; 247, 248; 247, 255; 248, comparison_operator:==; 248, 249; 248, 254; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:split; 252, identifier:count; 253, argument_list; 254, integer:1; 255, block; 255, 256; 255, 263; 255, 270; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:split; 260, identifier:qteAddWidget; 261, argument_list; 261, 262; 262, identifier:newAppObj; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:split; 267, identifier:setOrientation; 268, argument_list; 268, 269; 269, identifier:splitOrientation; 270, return_statement; 270, 271; 271, True; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:curAppIdx; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:split; 278, identifier:indexOf; 279, argument_list; 279, 280; 280, identifier:curApp; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:newSplit; 284, call; 284, 285; 284, 286; 285, identifier:QtmacsSplitter; 286, argument_list; 286, 287; 286, 288; 287, identifier:splitOrientation; 288, identifier:windowObj; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:curApp; 293, identifier:setParent; 294, argument_list; 294, 295; 295, None; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:newSplit; 300, identifier:qteAddWidget; 301, argument_list; 301, 302; 302, identifier:curApp; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:newSplit; 307, identifier:qteAddWidget; 308, argument_list; 308, 309; 309, identifier:newAppObj; 310, expression_statement; 310, 311; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:split; 314, identifier:insertWidget; 315, argument_list; 315, 316; 315, 317; 316, identifier:curAppIdx; 317, identifier:newSplit; 318, expression_statement; 318, 319; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:split; 322, identifier:qteAdjustWidgetSizes; 323, argument_list; 324, return_statement; 324, 325; 325, True | def qteSplitApplet(self, applet: (QtmacsApplet, str)=None,
splitHoriz: bool=True,
windowObj: QtmacsWindow=None):
if isinstance(applet, str):
newAppObj = self.qteGetAppletHandle(applet)
else:
newAppObj = applet
if windowObj is None:
windowObj = self.qteActiveWindow()
if windowObj is None:
msg = 'Cannot determine the currently active window.'
self.qteLogger.error(msg, stack_info=True)
return
if splitHoriz:
splitOrientation = QtCore.Qt.Horizontal
else:
splitOrientation = QtCore.Qt.Vertical
if newAppObj is None:
newAppObj = self.qteNextApplet(skipVisible=True,
skipInvisible=False)
else:
if newAppObj.qteIsVisible():
return False
if newAppObj is None:
self.qteLogger.warning('All applets are already visible.')
return False
if windowObj.qteAppletSplitter.count() == 0:
windowObj.qteAppletSplitter.qteAddWidget(newAppObj)
windowObj.qteAppletSplitter.setOrientation(splitOrientation)
return True
curApp = self.qteNextApplet(numSkip=0, windowObj=windowObj)
split = self._qteFindAppletInSplitter(
curApp, windowObj.qteAppletSplitter)
if split is None:
msg = 'Active applet <b>{}</b> not in the layout.'
msg = msg.format(curApp.qteAppletID())
self.qteLogger.error(msg, stack_info=True)
return False
if split is windowObj.qteAppletSplitter:
if split.count() == 1:
split.qteAddWidget(newAppObj)
split.setOrientation(splitOrientation)
return True
curAppIdx = split.indexOf(curApp)
newSplit = QtmacsSplitter(splitOrientation, windowObj)
curApp.setParent(None)
newSplit.qteAddWidget(curApp)
newSplit.qteAddWidget(newAppObj)
split.insertWidget(curAppIdx, newSplit)
split.qteAdjustWidgetSizes()
return True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.