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:_find_cert_in_list; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cert; 5, identifier:issuer; 6, identifier:certificate_list; 7, identifier:crl_issuer; 8, block; 8, 9; 8, 17; 8, 23; 8, 29; 8, 40; 8, 46; 8, 123; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:revoked_certificates; 12, subscript; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:certificate_list; 15, string:'tbs_cert_list'; 16, string:'revoked_certificates'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:cert_serial; 20, attribute; 20, 21; 20, 22; 21, identifier:cert; 22, identifier:serial_number; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:issuer_name; 26, attribute; 26, 27; 26, 28; 27, identifier:issuer; 28, identifier:subject; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:known_extensions; 32, call; 32, 33; 32, 34; 33, identifier:set; 34, argument_list; 34, 35; 35, list:[
'crl_reason',
'hold_instruction_code',
'invalidity_date',
'certificate_issuer'
]; 35, 36; 35, 37; 35, 38; 35, 39; 36, string:'crl_reason'; 37, string:'hold_instruction_code'; 38, string:'invalidity_date'; 39, string:'certificate_issuer'; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:last_issuer_name; 43, attribute; 43, 44; 43, 45; 44, identifier:crl_issuer; 45, identifier:subject; 46, for_statement; 46, 47; 46, 48; 46, 49; 47, identifier:revoked_cert; 48, identifier:revoked_certificates; 49, block; 49, 50; 49, 61; 49, 78; 49, 84; 49, 94; 49, 117; 50, if_statement; 50, 51; 50, 56; 51, binary_operator:-; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:revoked_cert; 54, identifier:critical_extensions; 55, identifier:known_extensions; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:NotImplementedError; 60, argument_list; 61, if_statement; 61, 62; 61, 71; 62, boolean_operator:and; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:revoked_cert; 65, identifier:issuer_name; 66, comparison_operator:!=; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:revoked_cert; 69, identifier:issuer_name; 70, identifier:last_issuer_name; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:last_issuer_name; 75, attribute; 75, 76; 75, 77; 76, identifier:revoked_cert; 77, identifier:issuer_name; 78, if_statement; 78, 79; 78, 82; 79, comparison_operator:!=; 79, 80; 79, 81; 80, identifier:last_issuer_name; 81, identifier:issuer_name; 82, block; 82, 83; 83, continue_statement; 84, if_statement; 84, 85; 84, 92; 85, comparison_operator:!=; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:revoked_cert; 89, string:'user_certificate'; 90, identifier:native; 91, identifier:cert_serial; 92, block; 92, 93; 93, continue_statement; 94, if_statement; 94, 95; 94, 99; 94, 109; 95, not_operator; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:revoked_cert; 98, identifier:crl_reason_value; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:crl_reason; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:crl; 106, identifier:CRLReason; 107, argument_list; 107, 108; 108, string:'unspecified'; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:crl_reason; 114, attribute; 114, 115; 114, 116; 115, identifier:revoked_cert; 116, identifier:crl_reason_value; 117, return_statement; 117, 118; 118, tuple; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:revoked_cert; 121, string:'revocation_date'; 122, identifier:crl_reason; 123, return_statement; 123, 124; 124, tuple; 124, 125; 124, 126; 125, None; 126, None | def _find_cert_in_list(cert, issuer, certificate_list, crl_issuer):
revoked_certificates = certificate_list['tbs_cert_list']['revoked_certificates']
cert_serial = cert.serial_number
issuer_name = issuer.subject
known_extensions = set([
'crl_reason',
'hold_instruction_code',
'invalidity_date',
'certificate_issuer'
])
last_issuer_name = crl_issuer.subject
for revoked_cert in revoked_certificates:
if revoked_cert.critical_extensions - known_extensions:
raise NotImplementedError()
if revoked_cert.issuer_name and revoked_cert.issuer_name != last_issuer_name:
last_issuer_name = revoked_cert.issuer_name
if last_issuer_name != issuer_name:
continue
if revoked_cert['user_certificate'].native != cert_serial:
continue
if not revoked_cert.crl_reason_value:
crl_reason = crl.CRLReason('unspecified')
else:
crl_reason = revoked_cert.crl_reason_value
return (revoked_cert['revocation_date'], crl_reason)
return (None, None) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:derive_coordinates; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 68; 5, 72; 5, 76; 5, 80; 5, 108; 5, 289; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:_coordinates_resolved; 10, block; 10, 11; 11, return_statement; 12, if_statement; 12, 13; 12, 18; 12, 60; 13, comparison_operator:is; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:seg_map; 17, None; 18, block; 18, 19; 18, 39; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 29; 21, pattern_list; 21, 22; 21, 25; 21, 28; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:start; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:filename; 28, identifier:include_ref; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:seg_map; 34, identifier:derive_source_offset; 35, argument_list; 35, 36; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:start; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 47; 41, pattern_list; 41, 42; 41, 45; 41, 46; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:end; 45, identifier:end_filename; 46, identifier:_; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:seg_map; 52, identifier:derive_source_offset; 53, argument_list; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:end; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:is_end; 59, True; 60, else_clause; 60, 61; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:end_filename; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:filename; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:line_start; 71, integer:0; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:lineno; 75, integer:1; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:file_pos; 79, integer:0; 80, if_statement; 80, 81; 80, 86; 80, 91; 80, 102; 81, comparison_operator:!=; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:filename; 85, identifier:end_filename; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:get_end; 90, False; 91, elif_clause; 91, 92; 91, 97; 92, comparison_operator:is; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:end; 96, None; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:get_end; 101, False; 102, else_clause; 102, 103; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:get_end; 107, True; 108, if_statement; 108, 109; 108, 122; 109, boolean_operator:and; 109, 110; 109, 116; 110, parenthesized_expression; 110, 111; 111, comparison_operator:is; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:filename; 115, None; 116, parenthesized_expression; 116, 117; 117, comparison_operator:is; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:start; 121, None; 122, block; 122, 123; 122, 261; 123, with_statement; 123, 124; 123, 142; 124, with_clause; 124, 125; 125, with_item; 125, 126; 126, as_pattern; 126, 127; 126, 140; 127, call; 127, 128; 127, 129; 128, identifier:open; 129, argument_list; 129, 130; 129, 133; 129, 134; 129, 137; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:filename; 133, string:'r'; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:newline; 136, string:''; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:encoding; 139, string:'utf_8'; 140, as_pattern_target; 140, 141; 141, identifier:fp; 142, block; 142, 143; 143, while_statement; 143, 144; 143, 145; 144, True; 145, block; 145, 146; 145, 154; 145, 161; 145, 167; 145, 219; 145, 253; 145, 257; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:line_text; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:fp; 152, identifier:readline; 153, argument_list; 154, expression_statement; 154, 155; 155, augmented_assignment:+=; 155, 156; 155, 157; 156, identifier:file_pos; 157, call; 157, 158; 157, 159; 158, identifier:len; 159, argument_list; 159, 160; 160, identifier:line_text; 161, if_statement; 161, 162; 161, 165; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:line_text; 164, string:""; 165, block; 165, 166; 166, break_statement; 167, if_statement; 167, 168; 167, 181; 168, boolean_operator:and; 168, 169; 168, 175; 169, parenthesized_expression; 169, 170; 170, comparison_operator:is; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:start_line; 174, None; 175, parenthesized_expression; 175, 176; 176, comparison_operator:<; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:start; 180, identifier:file_pos; 181, block; 181, 182; 181, 188; 181, 198; 181, 214; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:start_line; 187, identifier:lineno; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:start_col; 193, binary_operator:-; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:start; 197, identifier:line_start; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:start_line_text; 203, call; 203, 204; 203, 212; 204, attribute; 204, 205; 204, 211; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:line_text; 208, identifier:rstrip; 209, argument_list; 209, 210; 210, string:"\n"; 211, identifier:rstrip; 212, argument_list; 212, 213; 213, string:"\r"; 214, if_statement; 214, 215; 214, 217; 215, not_operator; 215, 216; 216, identifier:get_end; 217, block; 217, 218; 218, break_statement; 219, if_statement; 219, 220; 219, 235; 220, boolean_operator:and; 220, 221; 220, 229; 221, boolean_operator:and; 221, 222; 221, 223; 222, identifier:get_end; 223, parenthesized_expression; 223, 224; 224, comparison_operator:is; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:end_line; 228, None; 229, parenthesized_expression; 229, 230; 230, comparison_operator:<; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:end; 234, identifier:file_pos; 235, block; 235, 236; 235, 242; 235, 252; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:end_line; 241, identifier:lineno; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:self; 246, identifier:end_col; 247, binary_operator:-; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:end; 251, identifier:line_start; 252, break_statement; 253, expression_statement; 253, 254; 254, augmented_assignment:+=; 254, 255; 254, 256; 255, identifier:lineno; 256, integer:1; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:line_start; 260, identifier:file_pos; 261, if_statement; 261, 262; 261, 264; 262, not_operator; 262, 263; 263, identifier:get_end; 264, block; 264, 265; 264, 273; 264, 281; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:self; 269, identifier:end_line; 270, attribute; 270, 271; 270, 272; 271, identifier:self; 272, identifier:start_line; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:self; 277, identifier:end_col; 278, attribute; 278, 279; 278, 280; 279, identifier:self; 280, identifier:start_col; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:self; 285, identifier:end; 286, attribute; 286, 287; 286, 288; 287, identifier:self; 288, identifier:start; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:self; 293, identifier:_coordinates_resolved; 294, True | def derive_coordinates(self):
if self._coordinates_resolved:
return
if self.seg_map is not None:
self.start, self.filename, include_ref = self.seg_map.derive_source_offset(self.start)
self.end, end_filename, _ = self.seg_map.derive_source_offset(self.end, is_end=True)
else:
end_filename = self.filename
line_start = 0
lineno = 1
file_pos = 0
if self.filename != end_filename:
get_end = False
elif self.end is None:
get_end = False
else:
get_end = True
if (self.filename is not None) and (self.start is not None):
with open(self.filename, 'r', newline='', encoding='utf_8') as fp:
while True:
line_text = fp.readline()
file_pos += len(line_text)
if line_text == "":
break
if (self.start_line is None) and (self.start < file_pos):
self.start_line = lineno
self.start_col = self.start - line_start
self.start_line_text = line_text.rstrip("\n").rstrip("\r")
if not get_end:
break
if get_end and (self.end_line is None) and (self.end < file_pos):
self.end_line = lineno
self.end_col = self.end - line_start
break
lineno += 1
line_start = file_pos
if not get_end:
self.end_line = self.start_line
self.end_col = self.start_col
self.end = self.start
self._coordinates_resolved = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:children; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:unroll; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:skip_not_present; 10, True; 11, block; 11, 12; 12, for_statement; 12, 13; 12, 14; 12, 19; 13, identifier:child_inst; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:inst; 18, identifier:children; 19, block; 19, 20; 19, 36; 20, if_statement; 20, 21; 20, 22; 21, identifier:skip_not_present; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 34; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:child_inst; 29, identifier:properties; 30, identifier:get; 31, argument_list; 31, 32; 31, 33; 32, string:'ispresent'; 33, True; 34, block; 34, 35; 35, continue_statement; 36, if_statement; 36, 37; 36, 50; 36, 96; 37, boolean_operator:and; 37, 38; 37, 47; 38, boolean_operator:and; 38, 39; 38, 40; 39, identifier:unroll; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:child_inst; 44, attribute; 44, 45; 44, 46; 45, identifier:comp; 46, identifier:AddressableComponent; 47, attribute; 47, 48; 47, 49; 48, identifier:child_inst; 49, identifier:is_array; 50, block; 50, 51; 50, 64; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:range_list; 54, list_comprehension; 54, 55; 54, 59; 55, call; 55, 56; 55, 57; 56, identifier:range; 57, argument_list; 57, 58; 58, identifier:n; 59, for_in_clause; 59, 60; 59, 61; 60, identifier:n; 61, attribute; 61, 62; 61, 63; 62, identifier:child_inst; 63, identifier:array_dimensions; 64, for_statement; 64, 65; 64, 66; 64, 73; 65, identifier:idxs; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:itertools; 69, identifier:product; 70, argument_list; 70, 71; 71, list_splat; 71, 72; 72, identifier:range_list; 73, block; 73, 74; 73, 87; 73, 93; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:N; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:Node; 80, identifier:_factory; 81, argument_list; 81, 82; 81, 83; 81, 86; 82, identifier:child_inst; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:env; 86, identifier:self; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:N; 91, identifier:current_idx; 92, identifier:idxs; 93, expression_statement; 93, 94; 94, yield; 94, 95; 95, identifier:N; 96, else_clause; 96, 97; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, yield; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:Node; 103, identifier:_factory; 104, argument_list; 104, 105; 104, 106; 104, 109; 105, identifier:child_inst; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:env; 109, identifier:self | def children(self, unroll=False, skip_not_present=True):
for child_inst in self.inst.children:
if skip_not_present:
if not child_inst.properties.get('ispresent', True):
continue
if unroll and isinstance(child_inst, comp.AddressableComponent) and child_inst.is_array:
range_list = [range(n) for n in child_inst.array_dimensions]
for idxs in itertools.product(*range_list):
N = Node._factory(child_inst, self.env, self)
N.current_idx = idxs
yield N
else:
yield Node._factory(child_inst, self.env, self) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:find_by_path; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:path; 6, block; 6, 7; 6, 16; 6, 20; 6, 173; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:pathparts; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:path; 13, identifier:split; 14, argument_list; 14, 15; 15, string:'.'; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:current_node; 19, identifier:self; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:pathpart; 22, identifier:pathparts; 23, block; 23, 24; 23, 34; 23, 43; 23, 55; 23, 73; 23, 82; 23, 89; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:m; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:re; 30, identifier:fullmatch; 31, argument_list; 31, 32; 31, 33; 32, string:r'^(\w+)((?:\[(?:\d+|0[xX][\da-fA-F]+)\])*)$'; 33, identifier:pathpart; 34, if_statement; 34, 35; 34, 37; 35, not_operator; 35, 36; 36, identifier:m; 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:"Invalid path"; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, pattern_list; 45, 46; 45, 47; 46, identifier:inst_name; 47, identifier:array_suffix; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:m; 51, identifier:group; 52, argument_list; 52, 53; 52, 54; 53, integer:1; 54, integer:2; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:idx_list; 58, list_comprehension; 58, 59; 58, 64; 59, call; 59, 60; 59, 61; 60, identifier:int; 61, argument_list; 61, 62; 61, 63; 62, identifier:s; 63, integer:0; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:s; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:re; 69, identifier:findall; 70, argument_list; 70, 71; 70, 72; 71, string:r'\[(\d+|0[xX][\da-fA-F]+)\]'; 72, identifier:array_suffix; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:current_node; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:current_node; 79, identifier:get_child_by_name; 80, argument_list; 80, 81; 81, identifier:inst_name; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:is; 83, 84; 83, 85; 84, identifier:current_node; 85, None; 86, block; 86, 87; 87, return_statement; 87, 88; 88, None; 89, if_statement; 89, 90; 89, 91; 90, identifier:idx_list; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 105; 92, 166; 93, boolean_operator:and; 93, 94; 93, 100; 94, parenthesized_expression; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:isinstance; 97, argument_list; 97, 98; 97, 99; 98, identifier:current_node; 99, identifier:AddressableNode; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:current_node; 103, identifier:inst; 104, identifier:is_array; 105, block; 105, 106; 105, 126; 105, 132; 106, if_statement; 106, 107; 106, 120; 107, comparison_operator:!=; 107, 108; 107, 112; 108, call; 108, 109; 108, 110; 109, identifier:len; 110, argument_list; 110, 111; 111, identifier:idx_list; 112, call; 112, 113; 112, 114; 113, identifier:len; 114, argument_list; 114, 115; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:current_node; 118, identifier:inst; 119, identifier:array_dimensions; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:IndexError; 124, argument_list; 124, 125; 125, string:"Wrong number of array dimensions"; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:current_node; 130, identifier:current_idx; 131, list:[]; 132, for_statement; 132, 133; 132, 136; 132, 140; 133, pattern_list; 133, 134; 133, 135; 134, identifier:i; 135, identifier:idx; 136, call; 136, 137; 136, 138; 137, identifier:enumerate; 138, argument_list; 138, 139; 139, identifier:idx_list; 140, block; 140, 141; 140, 157; 141, if_statement; 141, 142; 141, 151; 142, comparison_operator:>=; 142, 143; 142, 144; 143, identifier:idx; 144, subscript; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:current_node; 148, identifier:inst; 149, identifier:array_dimensions; 150, identifier:i; 151, block; 151, 152; 152, raise_statement; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:IndexError; 155, argument_list; 155, 156; 156, string:"Array index out of range"; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:current_node; 162, identifier:current_idx; 163, identifier:append; 164, argument_list; 164, 165; 165, identifier:idx; 166, else_clause; 166, 167; 167, block; 167, 168; 168, raise_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:IndexError; 171, argument_list; 171, 172; 172, string:"Index attempted on non-array component"; 173, return_statement; 173, 174; 174, identifier:current_node | def find_by_path(self, path):
pathparts = path.split('.')
current_node = self
for pathpart in pathparts:
m = re.fullmatch(r'^(\w+)((?:\[(?:\d+|0[xX][\da-fA-F]+)\])*)$', pathpart)
if not m:
raise ValueError("Invalid path")
inst_name, array_suffix = m.group(1,2)
idx_list = [ int(s,0) for s in re.findall(r'\[(\d+|0[xX][\da-fA-F]+)\]', array_suffix) ]
current_node = current_node.get_child_by_name(inst_name)
if current_node is None:
return None
if idx_list:
if (isinstance(current_node, AddressableNode)) and current_node.inst.is_array:
if len(idx_list) != len(current_node.inst.array_dimensions):
raise IndexError("Wrong number of array dimensions")
current_node.current_idx = []
for i,idx in enumerate(idx_list):
if idx >= current_node.inst.array_dimensions[i]:
raise IndexError("Array index out of range")
current_node.current_idx.append(idx)
else:
raise IndexError("Index attempted on non-array component")
return current_node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_property; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:prop_name; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 13; 8, 17; 8, 35; 8, 54; 8, 112; 8, 117; 8, 130; 8, 142; 8, 161; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:ovr_default; 12, False; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:default; 16, None; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:in; 18, 19; 18, 20; 19, string:'default'; 20, identifier:kwargs; 21, block; 21, 22; 21, 26; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:ovr_default; 25, True; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:default; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:kwargs; 32, identifier:pop; 33, argument_list; 33, 34; 34, string:'default'; 35, if_statement; 35, 36; 35, 37; 36, identifier:kwargs; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:TypeError; 41, argument_list; 41, 42; 42, binary_operator:%; 42, 43; 42, 44; 43, string:"got an unexpected keyword argument '%s'"; 44, subscript; 44, 45; 44, 53; 45, call; 45, 46; 45, 47; 46, identifier:list; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:kwargs; 51, identifier:keys; 52, argument_list; 53, integer:0; 54, if_statement; 54, 55; 54, 62; 55, comparison_operator:in; 55, 56; 55, 57; 56, identifier:prop_name; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:inst; 61, identifier:properties; 62, block; 62, 63; 62, 73; 62, 94; 62, 110; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:prop_value; 66, subscript; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:inst; 71, identifier:properties; 72, identifier:prop_name; 73, if_statement; 73, 74; 73, 81; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:prop_value; 78, attribute; 78, 79; 78, 80; 79, identifier:rdltypes; 80, identifier:ComponentRef; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:prop_value; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:prop_value; 88, identifier:build_node_ref; 89, argument_list; 89, 90; 89, 91; 90, identifier:self; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:env; 94, if_statement; 94, 95; 94, 102; 95, call; 95, 96; 95, 97; 96, identifier:isinstance; 97, argument_list; 97, 98; 97, 99; 98, identifier:prop_value; 99, attribute; 99, 100; 99, 101; 100, identifier:rdltypes; 101, identifier:PropertyReference; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:prop_value; 107, identifier:_resolve_node; 108, argument_list; 108, 109; 109, identifier:self; 110, return_statement; 110, 111; 111, identifier:prop_value; 112, if_statement; 112, 113; 112, 114; 113, identifier:ovr_default; 114, block; 114, 115; 115, return_statement; 115, 116; 116, identifier:default; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:rule; 120, call; 120, 121; 120, 128; 121, attribute; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:env; 126, identifier:property_rules; 127, identifier:lookup_property; 128, argument_list; 128, 129; 129, identifier:prop_name; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:is; 131, 132; 131, 133; 132, identifier:rule; 133, None; 134, block; 134, 135; 135, raise_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:LookupError; 138, argument_list; 138, 139; 139, binary_operator:%; 139, 140; 139, 141; 140, string:"Unknown property '%s'"; 141, identifier:prop_name; 142, if_statement; 142, 143; 142, 153; 143, comparison_operator:not; 143, 144; 143, 150; 144, call; 144, 145; 144, 146; 145, identifier:type; 146, argument_list; 146, 147; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:inst; 150, attribute; 150, 151; 150, 152; 151, identifier:rule; 152, identifier:bindable_to; 153, block; 153, 154; 154, raise_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:LookupError; 157, argument_list; 157, 158; 158, binary_operator:%; 158, 159; 158, 160; 159, string:"Unknown property '%s'"; 160, identifier:prop_name; 161, return_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:rule; 165, identifier:get_default; 166, argument_list; 166, 167; 167, identifier:self | def get_property(self, prop_name, **kwargs):
ovr_default = False
default = None
if 'default' in kwargs:
ovr_default = True
default = kwargs.pop('default')
if kwargs:
raise TypeError("got an unexpected keyword argument '%s'" % list(kwargs.keys())[0])
if prop_name in self.inst.properties:
prop_value = self.inst.properties[prop_name]
if isinstance(prop_value, rdltypes.ComponentRef):
prop_value = prop_value.build_node_ref(self, self.env)
if isinstance(prop_value, rdltypes.PropertyReference):
prop_value._resolve_node(self)
return prop_value
if ovr_default:
return default
rule = self.env.property_rules.lookup_property(prop_name)
if rule is None:
raise LookupError("Unknown property '%s'" % prop_name)
if type(self.inst) not in rule.bindable_to:
raise LookupError("Unknown property '%s'" % prop_name)
return rule.get_default(self) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:elaborate; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:top_def_name; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:inst_name; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:parameters; 13, None; 14, block; 14, 15; 14, 24; 14, 131; 14, 140; 14, 146; 14, 154; 14, 160; 14, 167; 14, 173; 14, 179; 14, 185; 14, 191; 14, 210; 14, 303; 14, 312; 14, 323; 14, 343; 14, 375; 14, 395; 14, 411; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:parameters; 18, None; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:parameters; 23, dictionary; 24, if_statement; 24, 25; 24, 28; 24, 80; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:top_def_name; 27, None; 28, block; 28, 29; 28, 49; 28, 59; 29, if_statement; 29, 30; 29, 37; 30, comparison_operator:not; 30, 31; 30, 32; 31, identifier:top_def_name; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:root; 36, identifier:comp_defs; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:msg; 44, identifier:fatal; 45, argument_list; 45, 46; 46, binary_operator:%; 46, 47; 46, 48; 47, string:"Elaboration target '%s' not found"; 48, identifier:top_def_name; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:top_def; 52, subscript; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:root; 57, identifier:comp_defs; 58, identifier:top_def_name; 59, if_statement; 59, 60; 59, 68; 60, not_operator; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:isinstance; 63, argument_list; 63, 64; 63, 65; 64, identifier:top_def; 65, attribute; 65, 66; 65, 67; 66, identifier:comp; 67, identifier:Addrmap; 68, block; 68, 69; 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:self; 74, identifier:msg; 75, identifier:fatal; 76, argument_list; 76, 77; 77, binary_operator:%; 77, 78; 77, 79; 78, string:"Elaboration target '%s' is not an 'addrmap' component"; 79, identifier:top_def_name; 80, else_clause; 80, 81; 81, block; 81, 82; 82, for_statement; 82, 83; 82, 84; 82, 99; 82, 120; 83, identifier:comp_def; 84, call; 84, 85; 84, 86; 85, identifier:reversed; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:list; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 98; 91, attribute; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:root; 96, identifier:comp_defs; 97, identifier:values; 98, argument_list; 99, block; 99, 100; 100, if_statement; 100, 101; 100, 108; 101, call; 101, 102; 101, 103; 102, identifier:isinstance; 103, argument_list; 103, 104; 103, 105; 104, identifier:comp_def; 105, attribute; 105, 106; 105, 107; 106, identifier:comp; 107, identifier:Addrmap; 108, block; 108, 109; 108, 113; 108, 119; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:top_def; 112, identifier:comp_def; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:top_def_name; 116, attribute; 116, 117; 116, 118; 117, identifier:comp_def; 118, identifier:type_name; 119, break_statement; 120, else_clause; 120, 121; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:msg; 128, identifier:fatal; 129, argument_list; 129, 130; 130, string:"Could not find any 'addrmap' components to elaborate"; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:root_inst; 134, call; 134, 135; 134, 136; 135, identifier:deepcopy; 136, argument_list; 136, 137; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:root; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:root_inst; 144, identifier:is_instance; 145, True; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:root_inst; 150, identifier:original_def; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:root; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:root_inst; 158, identifier:inst_name; 159, string:"$root"; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:top_inst; 163, call; 163, 164; 163, 165; 164, identifier:deepcopy; 165, argument_list; 165, 166; 166, identifier:top_def; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:top_inst; 171, identifier:is_instance; 172, True; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:top_inst; 177, identifier:original_def; 178, identifier:top_def; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:top_inst; 183, identifier:addr_offset; 184, integer:0; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:top_inst; 189, identifier:external; 190, True; 191, if_statement; 191, 192; 191, 195; 191, 202; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:inst_name; 194, None; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:top_inst; 200, identifier:inst_name; 201, identifier:inst_name; 202, else_clause; 202, 203; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:top_inst; 208, identifier:inst_name; 209, identifier:top_def_name; 210, for_statement; 210, 211; 210, 214; 210, 219; 211, pattern_list; 211, 212; 211, 213; 212, identifier:param_name; 213, identifier:value; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:parameters; 217, identifier:items; 218, argument_list; 219, block; 219, 220; 219, 224; 219, 251; 219, 263; 219, 271; 219, 283; 219, 297; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:parameter; 223, None; 224, for_statement; 224, 225; 224, 226; 224, 229; 224, 242; 225, identifier:p; 226, attribute; 226, 227; 226, 228; 227, identifier:top_inst; 228, identifier:parameters; 229, block; 229, 230; 230, if_statement; 230, 231; 230, 236; 231, comparison_operator:==; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:p; 234, identifier:name; 235, identifier:param_name; 236, block; 236, 237; 236, 241; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:parameter; 240, identifier:p; 241, break_statement; 242, else_clause; 242, 243; 243, block; 243, 244; 244, raise_statement; 244, 245; 245, call; 245, 246; 245, 247; 246, identifier:ValueError; 247, argument_list; 247, 248; 248, binary_operator:%; 248, 249; 248, 250; 249, string:"Parameter '%s' is not available for override"; 250, identifier:param_name; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:value_expr; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:expr; 257, identifier:ExternalLiteral; 258, argument_list; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:env; 262, identifier:value; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:value_type; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:value_expr; 269, identifier:predict_type; 270, argument_list; 271, if_statement; 271, 272; 271, 275; 272, comparison_operator:is; 272, 273; 272, 274; 273, identifier:value_type; 274, None; 275, block; 275, 276; 276, raise_statement; 276, 277; 277, call; 277, 278; 277, 279; 278, identifier:TypeError; 279, argument_list; 279, 280; 280, binary_operator:%; 280, 281; 280, 282; 281, string:"Override value for parameter '%s' is an unrecognized type"; 282, identifier:param_name; 283, if_statement; 283, 284; 283, 289; 284, comparison_operator:!=; 284, 285; 284, 286; 285, identifier:value_type; 286, attribute; 286, 287; 286, 288; 287, identifier:parameter; 288, identifier:param_type; 289, block; 289, 290; 290, raise_statement; 290, 291; 291, call; 291, 292; 291, 293; 292, identifier:TypeError; 293, argument_list; 293, 294; 294, binary_operator:%; 294, 295; 294, 296; 295, string:"Incorrect type for parameter '%s'"; 296, identifier:param_name; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:parameter; 301, identifier:expr; 302, identifier:value_expr; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 310; 305, attribute; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:root_inst; 308, identifier:children; 309, identifier:append; 310, argument_list; 310, 311; 311, identifier:top_inst; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:root_node; 315, call; 315, 316; 315, 317; 316, identifier:RootNode; 317, argument_list; 317, 318; 317, 319; 317, 322; 318, identifier:root_inst; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:env; 322, None; 323, expression_statement; 323, 324; 324, call; 324, 325; 324, 335; 325, attribute; 325, 326; 325, 334; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:walker; 329, identifier:RDLWalker; 330, argument_list; 330, 331; 331, keyword_argument; 331, 332; 331, 333; 332, identifier:skip_not_present; 333, False; 334, identifier:walk; 335, argument_list; 335, 336; 335, 337; 336, identifier:root_node; 337, call; 337, 338; 337, 339; 338, identifier:ElabExpressionsListener; 339, argument_list; 339, 340; 340, attribute; 340, 341; 340, 342; 341, identifier:self; 342, identifier:msg; 343, expression_statement; 343, 344; 344, call; 344, 345; 344, 355; 345, attribute; 345, 346; 345, 354; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:walker; 349, identifier:RDLWalker; 350, argument_list; 350, 351; 351, keyword_argument; 351, 352; 351, 353; 352, identifier:skip_not_present; 353, False; 354, identifier:walk; 355, argument_list; 355, 356; 355, 357; 355, 363; 355, 369; 356, identifier:root_node; 357, call; 357, 358; 357, 359; 358, identifier:PrePlacementValidateListener; 359, argument_list; 359, 360; 360, attribute; 360, 361; 360, 362; 361, identifier:self; 362, identifier:msg; 363, call; 363, 364; 363, 365; 364, identifier:StructuralPlacementListener; 365, argument_list; 365, 366; 366, attribute; 366, 367; 366, 368; 367, identifier:self; 368, identifier:msg; 369, call; 369, 370; 369, 371; 370, identifier:LateElabListener; 371, argument_list; 371, 372; 372, attribute; 372, 373; 372, 374; 373, identifier:self; 374, identifier:msg; 375, expression_statement; 375, 376; 376, call; 376, 377; 376, 387; 377, attribute; 377, 378; 377, 386; 378, call; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:walker; 381, identifier:RDLWalker; 382, argument_list; 382, 383; 383, keyword_argument; 383, 384; 383, 385; 384, identifier:skip_not_present; 385, True; 386, identifier:walk; 387, argument_list; 387, 388; 387, 389; 388, identifier:root_node; 389, call; 389, 390; 389, 391; 390, identifier:ValidateListener; 391, argument_list; 391, 392; 392, attribute; 392, 393; 392, 394; 393, identifier:self; 394, identifier:env; 395, if_statement; 395, 396; 395, 401; 396, attribute; 396, 397; 396, 400; 397, attribute; 397, 398; 397, 399; 398, identifier:self; 399, identifier:msg; 400, identifier:had_error; 401, block; 401, 402; 402, expression_statement; 402, 403; 403, call; 403, 404; 403, 409; 404, attribute; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:self; 407, identifier:msg; 408, identifier:fatal; 409, argument_list; 409, 410; 410, string:"Elaborate aborted due to previous errors"; 411, return_statement; 411, 412; 412, identifier:root_node | def elaborate(self, top_def_name=None, inst_name=None, parameters=None):
if parameters is None:
parameters = {}
if top_def_name is not None:
if top_def_name not in self.root.comp_defs:
self.msg.fatal("Elaboration target '%s' not found" % top_def_name)
top_def = self.root.comp_defs[top_def_name]
if not isinstance(top_def, comp.Addrmap):
self.msg.fatal("Elaboration target '%s' is not an 'addrmap' component" % top_def_name)
else:
for comp_def in reversed(list(self.root.comp_defs.values())):
if isinstance(comp_def, comp.Addrmap):
top_def = comp_def
top_def_name = comp_def.type_name
break
else:
self.msg.fatal("Could not find any 'addrmap' components to elaborate")
root_inst = deepcopy(self.root)
root_inst.is_instance = True
root_inst.original_def = self.root
root_inst.inst_name = "$root"
top_inst = deepcopy(top_def)
top_inst.is_instance = True
top_inst.original_def = top_def
top_inst.addr_offset = 0
top_inst.external = True
if inst_name is not None:
top_inst.inst_name = inst_name
else:
top_inst.inst_name = top_def_name
for param_name, value in parameters.items():
parameter = None
for p in top_inst.parameters:
if p.name == param_name:
parameter = p
break
else:
raise ValueError("Parameter '%s' is not available for override" % param_name)
value_expr = expr.ExternalLiteral(self.env, value)
value_type = value_expr.predict_type()
if value_type is None:
raise TypeError("Override value for parameter '%s' is an unrecognized type" % param_name)
if value_type != parameter.param_type:
raise TypeError("Incorrect type for parameter '%s'" % param_name)
parameter.expr = value_expr
root_inst.children.append(top_inst)
root_node = RootNode(root_inst, self.env, None)
walker.RDLWalker(skip_not_present=False).walk(
root_node,
ElabExpressionsListener(self.msg)
)
walker.RDLWalker(skip_not_present=False).walk(
root_node,
PrePlacementValidateListener(self.msg),
StructuralPlacementListener(self.msg),
LateElabListener(self.msg)
)
walker.RDLWalker(skip_not_present=True).walk(root_node, ValidateListener(self.env))
if self.msg.had_error:
self.msg.fatal("Elaborate aborted due to previous errors")
return root_node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:resolve_addresses; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:node; 6, block; 6, 7; 6, 16; 6, 25; 6, 29; 6, 258; 6, 282; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:prop_alignment; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:alignment_stack; 14, unary_operator:-; 14, 15; 15, integer:1; 16, if_statement; 16, 17; 16, 20; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:prop_alignment; 19, None; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:prop_alignment; 24, integer:1; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:prev_node; 28, None; 29, for_statement; 29, 30; 29, 31; 29, 39; 30, identifier:child_node; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:node; 34, identifier:children; 35, argument_list; 35, 36; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:skip_not_present; 38, False; 39, block; 39, 40; 39, 49; 39, 63; 39, 97; 39, 105; 39, 114; 39, 210; 39, 219; 39, 242; 39, 254; 40, if_statement; 40, 41; 40, 47; 41, not_operator; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:child_node; 46, identifier:AddressableNode; 47, block; 47, 48; 48, continue_statement; 49, if_statement; 49, 50; 49, 57; 50, comparison_operator:is; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:child_node; 54, identifier:inst; 55, identifier:addr_offset; 56, None; 57, block; 57, 58; 57, 62; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:prev_node; 61, identifier:child_node; 62, continue_statement; 63, if_statement; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:node; 67, identifier:env; 68, identifier:chk_implicit_addr; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 79; 72, attribute; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:node; 76, identifier:env; 77, identifier:msg; 78, identifier:message; 79, argument_list; 79, 80; 79, 85; 79, 92; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:node; 83, identifier:env; 84, identifier:chk_implicit_addr; 85, binary_operator:%; 85, 86; 85, 87; 86, string:"Address offset of component '%s' is not explicitly set"; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:child_node; 90, identifier:inst; 91, identifier:inst_name; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:child_node; 95, identifier:inst; 96, identifier:inst_src_ref; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:alloc_alignment; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:child_node; 103, identifier:inst; 104, identifier:addr_align; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:alloc_alignment; 108, None; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:alloc_alignment; 113, integer:1; 114, if_statement; 114, 115; 114, 127; 114, 152; 114, 179; 114, 206; 115, comparison_operator:==; 115, 116; 115, 122; 116, subscript; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:addressing_mode_stack; 120, unary_operator:-; 120, 121; 121, integer:1; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:rdltypes; 125, identifier:AddressingType; 126, identifier:compact; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 134; 128, 146; 129, call; 129, 130; 129, 131; 130, identifier:isinstance; 131, argument_list; 131, 132; 131, 133; 132, identifier:child_node; 133, identifier:RegNode; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:mode_alignment; 138, binary_operator://; 138, 139; 138, 145; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:child_node; 142, identifier:get_property; 143, argument_list; 143, 144; 144, string:'accesswidth'; 145, integer:8; 146, else_clause; 146, 147; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:mode_alignment; 151, integer:1; 152, elif_clause; 152, 153; 152, 165; 153, comparison_operator:==; 153, 154; 153, 160; 154, subscript; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:addressing_mode_stack; 158, unary_operator:-; 158, 159; 159, integer:1; 160, attribute; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:rdltypes; 163, identifier:AddressingType; 164, identifier:regalign; 165, block; 165, 166; 165, 172; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:mode_alignment; 169, attribute; 169, 170; 169, 171; 170, identifier:child_node; 171, identifier:size; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:mode_alignment; 175, call; 175, 176; 175, 177; 176, identifier:roundup_pow2; 177, argument_list; 177, 178; 178, identifier:mode_alignment; 179, elif_clause; 179, 180; 179, 192; 180, comparison_operator:==; 180, 181; 180, 187; 181, subscript; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:addressing_mode_stack; 185, unary_operator:-; 185, 186; 186, integer:1; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:rdltypes; 190, identifier:AddressingType; 191, identifier:fullalign; 192, block; 192, 193; 192, 199; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:mode_alignment; 196, attribute; 196, 197; 196, 198; 197, identifier:child_node; 198, identifier:total_size; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:mode_alignment; 202, call; 202, 203; 202, 204; 203, identifier:roundup_pow2; 204, argument_list; 204, 205; 205, identifier:mode_alignment; 206, else_clause; 206, 207; 207, block; 207, 208; 208, raise_statement; 208, 209; 209, identifier:RuntimeError; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:alignment; 213, call; 213, 214; 213, 215; 214, identifier:max; 215, argument_list; 215, 216; 215, 217; 215, 218; 216, identifier:prop_alignment; 217, identifier:alloc_alignment; 218, identifier:mode_alignment; 219, if_statement; 219, 220; 219, 223; 219, 228; 220, comparison_operator:is; 220, 221; 220, 222; 221, identifier:prev_node; 222, None; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:next_offset; 227, integer:0; 228, else_clause; 228, 229; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:next_offset; 233, binary_operator:+; 233, 234; 233, 239; 234, attribute; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:prev_node; 237, identifier:inst; 238, identifier:addr_offset; 239, attribute; 239, 240; 239, 241; 240, identifier:prev_node; 241, identifier:total_size; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 249; 244, attribute; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:child_node; 247, identifier:inst; 248, identifier:addr_offset; 249, call; 249, 250; 249, 251; 250, identifier:roundup_to; 251, argument_list; 251, 252; 251, 253; 252, identifier:next_offset; 253, identifier:alignment; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:prev_node; 257, identifier:child_node; 258, function_definition; 258, 259; 258, 260; 258, 262; 259, function_name:get_child_sort_key; 260, parameters; 260, 261; 261, identifier:inst; 262, block; 262, 263; 263, if_statement; 263, 264; 263, 272; 263, 276; 264, not_operator; 264, 265; 265, call; 265, 266; 265, 267; 266, identifier:isinstance; 267, argument_list; 267, 268; 267, 269; 268, identifier:inst; 269, attribute; 269, 270; 269, 271; 270, identifier:comp; 271, identifier:AddressableComponent; 272, block; 272, 273; 273, return_statement; 273, 274; 274, unary_operator:-; 274, 275; 275, integer:1; 276, else_clause; 276, 277; 277, block; 277, 278; 278, return_statement; 278, 279; 279, attribute; 279, 280; 279, 281; 280, identifier:inst; 281, identifier:addr_offset; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 291; 284, attribute; 284, 285; 284, 290; 285, attribute; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:node; 288, identifier:inst; 289, identifier:children; 290, identifier:sort; 291, argument_list; 291, 292; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:key; 294, identifier:get_child_sort_key | def resolve_addresses(self, node):
prop_alignment = self.alignment_stack[-1]
if prop_alignment is None:
prop_alignment = 1
prev_node = None
for child_node in node.children(skip_not_present=False):
if not isinstance(child_node, AddressableNode):
continue
if child_node.inst.addr_offset is not None:
prev_node = child_node
continue
if node.env.chk_implicit_addr:
node.env.msg.message(
node.env.chk_implicit_addr,
"Address offset of component '%s' is not explicitly set" % child_node.inst.inst_name,
child_node.inst.inst_src_ref
)
alloc_alignment = child_node.inst.addr_align
if alloc_alignment is None:
alloc_alignment = 1
if self.addressing_mode_stack[-1] == rdltypes.AddressingType.compact:
if isinstance(child_node, RegNode):
mode_alignment = child_node.get_property('accesswidth') // 8
else:
mode_alignment = 1
elif self.addressing_mode_stack[-1] == rdltypes.AddressingType.regalign:
mode_alignment = child_node.size
mode_alignment = roundup_pow2(mode_alignment)
elif self.addressing_mode_stack[-1] == rdltypes.AddressingType.fullalign:
mode_alignment = child_node.total_size
mode_alignment = roundup_pow2(mode_alignment)
else:
raise RuntimeError
alignment = max(prop_alignment, alloc_alignment, mode_alignment)
if prev_node is None:
next_offset = 0
else:
next_offset = prev_node.inst.addr_offset + prev_node.total_size
child_node.inst.addr_offset = roundup_to(next_offset, alignment)
prev_node = child_node
def get_child_sort_key(inst):
if not isinstance(inst, comp.AddressableComponent):
return -1
else:
return inst.addr_offset
node.inst.children.sort(key=get_child_sort_key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:parse_include; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:start; 6, block; 6, 7; 6, 11; 6, 32; 6, 36; 6, 88; 6, 97; 6, 109; 6, 139; 6, 155; 6, 166; 6, 175; 6, 184; 6, 253; 6, 321; 6, 357; 6, 363; 6, 410; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:i; 10, identifier:start; 11, while_statement; 11, 12; 11, 13; 12, identifier:i; 13, block; 13, 14; 13, 28; 14, if_statement; 14, 15; 14, 22; 15, comparison_operator:==; 15, 16; 15, 21; 16, subscript; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:text; 20, identifier:i; 21, string:'\n'; 22, block; 22, 23; 22, 27; 23, expression_statement; 23, 24; 24, augmented_assignment:+=; 24, 25; 24, 26; 25, identifier:i; 26, integer:1; 27, break_statement; 28, expression_statement; 28, 29; 29, augmented_assignment:-=; 29, 30; 29, 31; 30, identifier:i; 31, integer:1; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:line_start; 35, identifier:i; 36, if_statement; 36, 37; 36, 62; 37, not_operator; 37, 38; 38, parenthesized_expression; 38, 39; 39, boolean_operator:or; 39, 40; 39, 50; 40, comparison_operator:==; 40, 41; 40, 49; 41, subscript; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:text; 45, slice; 45, 46; 45, 47; 45, 48; 46, identifier:line_start; 47, colon; 48, identifier:start; 49, string:""; 50, call; 50, 51; 50, 61; 51, attribute; 51, 52; 51, 60; 52, subscript; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:text; 56, slice; 56, 57; 56, 58; 56, 59; 57, identifier:line_start; 58, colon; 59, identifier:start; 60, identifier:isspace; 61, argument_list; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 72; 65, attribute; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:env; 70, identifier:msg; 71, identifier:fatal; 72, argument_list; 72, 73; 72, 74; 73, string:"Unexpected text before include"; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:messages; 77, identifier:SourceRef; 78, argument_list; 78, 79; 78, 80; 78, 83; 79, identifier:line_start; 80, binary_operator:-; 80, 81; 80, 82; 81, identifier:start; 82, integer:1; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:filename; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:path; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:inc_regex; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:re; 94, identifier:compile; 95, argument_list; 95, 96; 96, string:r'`include\s+("([^\r\n]+)"|<([^\r\n]+)>)'; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:m_inc; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:inc_regex; 103, identifier:match; 104, argument_list; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:text; 108, identifier:start; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:m_inc; 112, None; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 123; 116, attribute; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:env; 121, identifier:msg; 122, identifier:fatal; 123, argument_list; 123, 124; 123, 125; 124, string:"Invalid usage of include directive"; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:messages; 128, identifier:SourceRef; 129, argument_list; 129, 130; 129, 131; 129, 134; 130, identifier:start; 131, binary_operator:+; 131, 132; 131, 133; 132, identifier:start; 133, integer:7; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:filename; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:path; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:incl_path_raw; 142, boolean_operator:or; 142, 143; 142, 149; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:m_inc; 146, identifier:group; 147, argument_list; 147, 148; 148, integer:2; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:m_inc; 152, identifier:group; 153, argument_list; 153, 154; 154, integer:3; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:end; 158, binary_operator:-; 158, 159; 158, 165; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:m_inc; 162, identifier:end; 163, argument_list; 163, 164; 164, integer:0; 165, integer:1; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:path_start; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:m_inc; 172, identifier:start; 173, argument_list; 173, 174; 174, integer:1; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:tail_regex; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:re; 181, identifier:compile; 182, argument_list; 182, 183; 183, string:r'(?:[ \t]*/\*[^\r\n]*?\*/)*[ \t]*(?://[^\r\n]*?|/\*[^\r\n]*?)?\r?\n'; 184, if_statement; 184, 185; 184, 197; 185, not_operator; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:tail_regex; 189, identifier:match; 190, argument_list; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:text; 194, binary_operator:+; 194, 195; 194, 196; 195, identifier:end; 196, integer:1; 197, block; 197, 198; 197, 207; 197, 221; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:tail_capture_regex; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:re; 204, identifier:compile; 205, argument_list; 205, 206; 206, string:r'[^\r\n]*?\r?\n'; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:m; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:tail_capture_regex; 213, identifier:match; 214, argument_list; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:self; 217, identifier:text; 218, binary_operator:+; 218, 219; 218, 220; 219, identifier:end; 220, integer:1; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 230; 223, attribute; 223, 224; 223, 229; 224, attribute; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:env; 228, identifier:msg; 229, identifier:fatal; 230, argument_list; 230, 231; 230, 232; 231, string:"Unexpected text after include"; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:messages; 235, identifier:SourceRef; 236, argument_list; 236, 237; 236, 240; 236, 248; 237, binary_operator:+; 237, 238; 237, 239; 238, identifier:end; 239, integer:1; 240, binary_operator:-; 240, 241; 240, 247; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:m; 244, identifier:end; 245, argument_list; 245, 246; 246, integer:0; 247, integer:1; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:filename; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:path; 253, if_statement; 253, 254; 253, 262; 253, 267; 254, call; 254, 255; 254, 260; 255, attribute; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:os; 258, identifier:path; 259, identifier:isabs; 260, argument_list; 260, 261; 261, identifier:incl_path_raw; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:incl_path; 266, identifier:incl_path_raw; 267, else_clause; 267, 268; 268, block; 268, 269; 269, for_statement; 269, 270; 269, 271; 269, 274; 269, 298; 270, identifier:search_path; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:search_paths; 274, block; 274, 275; 274, 287; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:incl_path; 278, call; 278, 279; 278, 284; 279, attribute; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:os; 282, identifier:path; 283, identifier:join; 284, argument_list; 284, 285; 284, 286; 285, identifier:search_path; 286, identifier:incl_path_raw; 287, if_statement; 287, 288; 287, 296; 288, call; 288, 289; 288, 294; 289, attribute; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:os; 292, identifier:path; 293, identifier:isfile; 294, argument_list; 294, 295; 295, identifier:incl_path; 296, block; 296, 297; 297, break_statement; 298, else_clause; 298, 299; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:incl_path; 303, call; 303, 304; 303, 309; 304, attribute; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:os; 307, identifier:path; 308, identifier:join; 309, argument_list; 309, 310; 309, 320; 310, call; 310, 311; 310, 316; 311, attribute; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:os; 314, identifier:path; 315, identifier:dirname; 316, argument_list; 316, 317; 317, attribute; 317, 318; 317, 319; 318, identifier:self; 319, identifier:path; 320, identifier:incl_path_raw; 321, if_statement; 321, 322; 321, 331; 322, not_operator; 322, 323; 323, call; 323, 324; 323, 329; 324, attribute; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:os; 327, identifier:path; 328, identifier:isfile; 329, argument_list; 329, 330; 330, identifier:incl_path; 331, block; 331, 332; 332, expression_statement; 332, 333; 333, call; 333, 334; 333, 341; 334, attribute; 334, 335; 334, 340; 335, attribute; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:self; 338, identifier:env; 339, identifier:msg; 340, identifier:fatal; 341, argument_list; 341, 342; 341, 345; 342, binary_operator:%; 342, 343; 342, 344; 343, string:"Could not find '%s' in include search paths"; 344, identifier:incl_path_raw; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:messages; 348, identifier:SourceRef; 349, argument_list; 349, 350; 349, 351; 349, 352; 350, identifier:path_start; 351, identifier:end; 352, keyword_argument; 352, 353; 352, 354; 353, identifier:filename; 354, attribute; 354, 355; 354, 356; 355, identifier:self; 356, identifier:path; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:incl_ref; 360, attribute; 360, 361; 360, 362; 361, identifier:self; 362, identifier:incl_ref; 363, while_statement; 363, 364; 363, 365; 364, identifier:incl_ref; 365, block; 365, 366; 365, 404; 366, if_statement; 366, 367; 366, 378; 367, call; 367, 368; 367, 373; 368, attribute; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:os; 371, identifier:path; 372, identifier:samefile; 373, argument_list; 373, 374; 373, 375; 374, identifier:incl_path; 375, attribute; 375, 376; 375, 377; 376, identifier:incl_ref; 377, identifier:path; 378, block; 378, 379; 379, expression_statement; 379, 380; 380, call; 380, 381; 380, 388; 381, attribute; 381, 382; 381, 387; 382, attribute; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:self; 385, identifier:env; 386, identifier:msg; 387, identifier:fatal; 388, argument_list; 388, 389; 388, 392; 389, binary_operator:%; 389, 390; 389, 391; 390, string:"Include of '%s' results in a circular reference"; 391, identifier:incl_path_raw; 392, call; 392, 393; 392, 396; 393, attribute; 393, 394; 393, 395; 394, identifier:messages; 395, identifier:SourceRef; 396, argument_list; 396, 397; 396, 398; 396, 399; 397, identifier:path_start; 398, identifier:end; 399, keyword_argument; 399, 400; 399, 401; 400, identifier:filename; 401, attribute; 401, 402; 401, 403; 402, identifier:self; 403, identifier:path; 404, expression_statement; 404, 405; 405, assignment; 405, 406; 405, 407; 406, identifier:incl_ref; 407, attribute; 407, 408; 407, 409; 408, identifier:incl_ref; 409, identifier:parent; 410, return_statement; 410, 411; 411, tuple; 411, 412; 411, 413; 412, identifier:end; 413, identifier:incl_path | def parse_include(self, start):
i = start
while i:
if self.text[i] == '\n':
i += 1
break
i -= 1
line_start = i
if not (self.text[line_start:start] == "" or self.text[line_start:start].isspace()):
self.env.msg.fatal(
"Unexpected text before include",
messages.SourceRef(line_start, start-1, filename=self.path)
)
inc_regex = re.compile(r'`include\s+("([^\r\n]+)"|<([^\r\n]+)>)')
m_inc = inc_regex.match(self.text, start)
if m_inc is None:
self.env.msg.fatal(
"Invalid usage of include directive",
messages.SourceRef(start, start+7, filename=self.path)
)
incl_path_raw = m_inc.group(2) or m_inc.group(3)
end = m_inc.end(0)-1
path_start = m_inc.start(1)
tail_regex = re.compile(r'(?:[ \t]*/\*[^\r\n]*?\*/)*[ \t]*(?://[^\r\n]*?|/\*[^\r\n]*?)?\r?\n')
if not tail_regex.match(self.text, end+1):
tail_capture_regex = re.compile(r'[^\r\n]*?\r?\n')
m = tail_capture_regex.match(self.text, end+1)
self.env.msg.fatal(
"Unexpected text after include",
messages.SourceRef(end+1, m.end(0)-1, filename=self.path)
)
if os.path.isabs(incl_path_raw):
incl_path = incl_path_raw
else:
for search_path in self.search_paths:
incl_path = os.path.join(search_path, incl_path_raw)
if os.path.isfile(incl_path):
break
else:
incl_path = os.path.join(os.path.dirname(self.path), incl_path_raw)
if not os.path.isfile(incl_path):
self.env.msg.fatal(
"Could not find '%s' in include search paths" % incl_path_raw,
messages.SourceRef(path_start, end, filename=self.path)
)
incl_ref = self.incl_ref
while incl_ref:
if os.path.samefile(incl_path, incl_ref.path):
self.env.msg.fatal(
"Include of '%s' results in a circular reference" % incl_path_raw,
messages.SourceRef(path_start, end, filename=self.path)
)
incl_ref = incl_ref.parent
return(end, incl_path) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_paths; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:patterns; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start_dirs; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:max_depth; 10, integer:1; 11, block; 11, 12; 11, 63; 11, 79; 12, if_statement; 12, 13; 12, 22; 13, boolean_operator:and; 13, 14; 13, 20; 14, comparison_operator:==; 14, 15; 14, 19; 15, call; 15, 16; 15, 17; 16, identifier:len; 17, argument_list; 17, 18; 18, identifier:patterns; 19, integer:1; 20, not_operator; 20, 21; 21, identifier:start_dirs; 22, block; 22, 23; 22, 29; 22, 40; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:pattern; 26, subscript; 26, 27; 26, 28; 27, identifier:patterns; 28, integer:0; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:directory; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:os; 36, identifier:path; 37, identifier:dirname; 38, argument_list; 38, 39; 39, identifier:pattern; 40, if_statement; 40, 41; 40, 42; 41, identifier:directory; 42, block; 42, 43; 42, 55; 42, 59; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:patterns; 46, list:[os.path.basename(pattern)]; 46, 47; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:os; 51, identifier:path; 52, identifier:basename; 53, argument_list; 53, 54; 54, identifier:pattern; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:start_dirs; 58, identifier:directory; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:max_depth; 62, integer:1; 63, if_statement; 63, 64; 63, 70; 64, boolean_operator:or; 64, 65; 64, 67; 65, not_operator; 65, 66; 66, identifier:start_dirs; 67, comparison_operator:==; 67, 68; 67, 69; 68, identifier:start_dirs; 69, string:'.'; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:start_dirs; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:os; 77, identifier:getcwd; 78, argument_list; 79, for_statement; 79, 80; 79, 81; 79, 87; 80, identifier:start_dir; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:start_dirs; 84, identifier:split; 85, argument_list; 85, 86; 86, string:','; 87, block; 87, 88; 88, for_statement; 88, 89; 88, 93; 88, 99; 89, pattern_list; 89, 90; 89, 91; 89, 92; 90, identifier:root; 91, identifier:dirs; 92, identifier:files; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:os; 96, identifier:walk; 97, argument_list; 97, 98; 98, identifier:start_dir; 99, block; 99, 100; 99, 139; 99, 143; 99, 157; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:max_depth; 103, None; 104, block; 104, 105; 104, 119; 104, 133; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:relpath; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:os; 112, identifier:path; 113, identifier:relpath; 114, argument_list; 114, 115; 114, 116; 115, identifier:root; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:start; 118, identifier:start_dir; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:depth; 122, call; 122, 123; 122, 124; 123, identifier:len; 124, argument_list; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:relpath; 128, identifier:split; 129, argument_list; 129, 130; 130, attribute; 130, 131; 130, 132; 131, identifier:os; 132, identifier:sep; 133, if_statement; 133, 134; 133, 137; 134, comparison_operator:>; 134, 135; 134, 136; 135, identifier:depth; 136, identifier:max_depth; 137, block; 137, 138; 138, continue_statement; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:names; 142, list:[]; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:pattern; 145, identifier:patterns; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, augmented_assignment:+=; 148, 149; 148, 150; 149, identifier:names; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:fnmatch; 153, identifier:filter; 154, argument_list; 154, 155; 154, 156; 155, identifier:files; 156, identifier:pattern; 157, for_statement; 157, 158; 157, 159; 157, 160; 158, identifier:name; 159, identifier:names; 160, block; 160, 161; 160, 173; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:path; 164, call; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:os; 168, identifier:path; 169, identifier:join; 170, argument_list; 170, 171; 170, 172; 171, identifier:root; 172, identifier:name; 173, expression_statement; 173, 174; 174, yield; 174, 175; 175, identifier:path | def get_paths(patterns, start_dirs=None, max_depth=1):
if len(patterns) == 1 and not start_dirs:
pattern = patterns[0]
directory = os.path.dirname(pattern)
if directory:
patterns = [os.path.basename(pattern)]
start_dirs = directory
max_depth = 1
if not start_dirs or start_dirs == '.':
start_dirs = os.getcwd()
for start_dir in start_dirs.split(','):
for root, dirs, files in os.walk(start_dir):
if max_depth is not None:
relpath = os.path.relpath(root, start=start_dir)
depth = len(relpath.split(os.sep))
if depth > max_depth:
continue
names = []
for pattern in patterns:
names += fnmatch.filter(files, pattern)
for name in names:
path = os.path.join(root, name)
yield path |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 34; 2, function_name:edit_files; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 28; 3, 31; 4, identifier:patterns; 5, default_parameter; 5, 6; 5, 7; 6, identifier:expressions; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:functions; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:executables; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:start_dirs; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:max_depth; 19, integer:1; 20, default_parameter; 20, 21; 20, 22; 21, identifier:dry_run; 22, True; 23, default_parameter; 23, 24; 23, 25; 24, identifier:output; 25, attribute; 25, 26; 25, 27; 26, identifier:sys; 27, identifier:stdout; 28, default_parameter; 28, 29; 28, 30; 29, identifier:encoding; 30, None; 31, default_parameter; 31, 32; 31, 33; 32, identifier:newline; 33, None; 34, block; 34, 35; 34, 47; 34, 61; 34, 75; 34, 89; 34, 104; 34, 114; 34, 124; 34, 134; 34, 138; 34, 255; 35, if_statement; 35, 36; 35, 41; 36, not_operator; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:is_list; 39, argument_list; 39, 40; 40, identifier:patterns; 41, block; 41, 42; 42, raise_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:TypeError; 45, argument_list; 45, 46; 46, string:"patterns should be a list"; 47, if_statement; 47, 48; 47, 55; 48, boolean_operator:and; 48, 49; 48, 50; 49, identifier:expressions; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:is_list; 53, argument_list; 53, 54; 54, identifier:expressions; 55, block; 55, 56; 56, raise_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:TypeError; 59, argument_list; 59, 60; 60, string:"expressions should be a list of exec expressions"; 61, if_statement; 61, 62; 61, 69; 62, boolean_operator:and; 62, 63; 62, 64; 63, identifier:functions; 64, not_operator; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:is_list; 67, argument_list; 67, 68; 68, identifier:functions; 69, block; 69, 70; 70, raise_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:TypeError; 73, argument_list; 73, 74; 74, string:"functions should be a list of functions"; 75, if_statement; 75, 76; 75, 83; 76, boolean_operator:and; 76, 77; 76, 78; 77, identifier:executables; 78, not_operator; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:is_list; 81, argument_list; 81, 82; 82, identifier:executables; 83, block; 83, 84; 84, raise_statement; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:TypeError; 87, argument_list; 87, 88; 88, string:"executables should be a list of program names"; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:editor; 92, call; 92, 93; 92, 94; 93, identifier:MassEdit; 94, argument_list; 94, 95; 94, 98; 94, 101; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:dry_run; 97, identifier:dry_run; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:encoding; 100, identifier:encoding; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:newline; 103, identifier:newline; 104, if_statement; 104, 105; 104, 106; 105, identifier:expressions; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:editor; 111, identifier:set_code_exprs; 112, argument_list; 112, 113; 113, identifier:expressions; 114, if_statement; 114, 115; 114, 116; 115, identifier:functions; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:editor; 121, identifier:set_functions; 122, argument_list; 122, 123; 123, identifier:functions; 124, if_statement; 124, 125; 124, 126; 125, identifier:executables; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:editor; 131, identifier:set_executables; 132, argument_list; 132, 133; 133, identifier:executables; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:processed_paths; 137, list:[]; 138, for_statement; 138, 139; 138, 140; 138, 150; 139, identifier:path; 140, call; 140, 141; 140, 142; 141, identifier:get_paths; 142, argument_list; 142, 143; 142, 144; 142, 147; 143, identifier:patterns; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:start_dirs; 146, identifier:start_dirs; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:max_depth; 149, identifier:max_depth; 150, block; 150, 151; 150, 241; 151, try_statement; 151, 152; 151, 225; 152, block; 152, 153; 152, 165; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:diffs; 156, call; 156, 157; 156, 158; 157, identifier:list; 158, argument_list; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:editor; 162, identifier:edit_file; 163, argument_list; 163, 164; 164, identifier:path; 165, if_statement; 165, 166; 165, 167; 166, identifier:dry_run; 167, block; 167, 168; 167, 177; 167, 182; 167, 188; 167, 218; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:diff; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, string:""; 174, identifier:join; 175, argument_list; 175, 176; 176, identifier:diffs; 177, if_statement; 177, 178; 177, 180; 178, not_operator; 178, 179; 179, identifier:diff; 180, block; 180, 181; 181, continue_statement; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:encoding; 185, attribute; 185, 186; 185, 187; 186, identifier:output; 187, identifier:encoding; 188, if_statement; 188, 189; 188, 190; 189, identifier:encoding; 190, block; 190, 191; 190, 205; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:bytes_diff; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:diff; 197, identifier:encode; 198, argument_list; 198, 199; 198, 202; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:encoding; 201, identifier:encoding; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:errors; 204, string:'ignore'; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:diff; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:bytes_diff; 211, identifier:decode; 212, argument_list; 212, 213; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:encoding; 215, attribute; 215, 216; 215, 217; 216, identifier:output; 217, identifier:encoding; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:output; 222, identifier:write; 223, argument_list; 223, 224; 224, identifier:diff; 225, except_clause; 225, 226; 225, 230; 226, as_pattern; 226, 227; 226, 228; 227, identifier:UnicodeDecodeError; 228, as_pattern_target; 228, 229; 229, identifier:err; 230, block; 230, 231; 230, 240; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:log; 235, identifier:error; 236, argument_list; 236, 237; 236, 238; 236, 239; 237, string:"failed to process %s: %s"; 238, identifier:path; 239, identifier:err; 240, continue_statement; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:processed_paths; 245, identifier:append; 246, argument_list; 246, 247; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:os; 251, identifier:path; 252, identifier:abspath; 253, argument_list; 253, 254; 254, identifier:path; 255, return_statement; 255, 256; 256, identifier:processed_paths | def edit_files(patterns, expressions=None,
functions=None, executables=None,
start_dirs=None, max_depth=1, dry_run=True,
output=sys.stdout, encoding=None, newline=None):
if not is_list(patterns):
raise TypeError("patterns should be a list")
if expressions and not is_list(expressions):
raise TypeError("expressions should be a list of exec expressions")
if functions and not is_list(functions):
raise TypeError("functions should be a list of functions")
if executables and not is_list(executables):
raise TypeError("executables should be a list of program names")
editor = MassEdit(dry_run=dry_run, encoding=encoding, newline=newline)
if expressions:
editor.set_code_exprs(expressions)
if functions:
editor.set_functions(functions)
if executables:
editor.set_executables(executables)
processed_paths = []
for path in get_paths(patterns, start_dirs=start_dirs,
max_depth=max_depth):
try:
diffs = list(editor.edit_file(path))
if dry_run:
diff = "".join(diffs)
if not diff:
continue
encoding = output.encoding
if encoding:
bytes_diff = diff.encode(encoding=encoding, errors='ignore')
diff = bytes_diff.decode(encoding=output.encoding)
output.write(diff)
except UnicodeDecodeError as err:
log.error("failed to process %s: %s", path, err)
continue
processed_paths.append(os.path.abspath(path))
return processed_paths |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:detect_events; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:dat; 5, identifier:method; 6, default_parameter; 6, 7; 6, 8; 7, identifier:value; 8, None; 9, block; 9, 10; 9, 200; 9, 243; 10, if_statement; 10, 11; 10, 18; 11, boolean_operator:or; 11, 12; 11, 15; 12, comparison_operator:in; 12, 13; 12, 14; 13, string:'thresh'; 14, identifier:method; 15, comparison_operator:==; 15, 16; 15, 17; 16, string:'custom'; 17, identifier:method; 18, block; 18, 19; 18, 37; 18, 55; 18, 91; 18, 103; 18, 110; 18, 155; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:==; 20, 21; 20, 22; 21, identifier:method; 22, string:'above_thresh'; 23, block; 23, 24; 23, 30; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:above_det; 27, comparison_operator:>=; 27, 28; 27, 29; 28, identifier:dat; 29, identifier:value; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:detected; 33, call; 33, 34; 33, 35; 34, identifier:_detect_start_end; 35, argument_list; 35, 36; 36, identifier:above_det; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:method; 40, string:'below_thresh'; 41, block; 41, 42; 41, 48; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:below_det; 45, comparison_operator:<; 45, 46; 45, 47; 46, identifier:dat; 47, identifier:value; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:detected; 51, call; 51, 52; 51, 53; 52, identifier:_detect_start_end; 53, argument_list; 53, 54; 54, identifier:below_det; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:method; 58, string:'between_thresh'; 59, block; 59, 60; 59, 68; 59, 76; 59, 84; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:above_det; 63, comparison_operator:>=; 63, 64; 63, 65; 64, identifier:dat; 65, subscript; 65, 66; 65, 67; 66, identifier:value; 67, integer:0; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:below_det; 71, comparison_operator:<; 71, 72; 71, 73; 72, identifier:dat; 73, subscript; 73, 74; 73, 75; 74, identifier:value; 75, integer:1; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:between_det; 79, call; 79, 80; 79, 81; 80, identifier:logical_and; 81, argument_list; 81, 82; 81, 83; 82, identifier:above_det; 83, identifier:below_det; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:detected; 87, call; 87, 88; 87, 89; 88, identifier:_detect_start_end; 89, argument_list; 89, 90; 90, identifier:between_det; 91, if_statement; 91, 92; 91, 95; 92, comparison_operator:==; 92, 93; 92, 94; 93, identifier:method; 94, string:'custom'; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:detected; 99, call; 99, 100; 99, 101; 100, identifier:_detect_start_end; 101, argument_list; 101, 102; 102, identifier:dat; 103, if_statement; 103, 104; 103, 107; 104, comparison_operator:is; 104, 105; 104, 106; 105, identifier:detected; 106, None; 107, block; 107, 108; 108, return_statement; 108, 109; 109, None; 110, if_statement; 110, 111; 110, 116; 111, comparison_operator:in; 111, 112; 111, 113; 112, identifier:method; 113, list:['above_thresh', 'custom']; 113, 114; 113, 115; 114, string:'above_thresh'; 115, string:'custom'; 116, block; 116, 117; 116, 129; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:detected; 120, call; 120, 121; 120, 122; 121, identifier:insert; 122, argument_list; 122, 123; 122, 124; 122, 125; 122, 126; 123, identifier:detected; 124, integer:1; 125, integer:0; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:axis; 128, integer:1; 129, for_statement; 129, 130; 129, 131; 129, 132; 130, identifier:i; 131, identifier:detected; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:i; 137, integer:1; 138, binary_operator:+; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:i; 141, integer:0; 142, call; 142, 143; 142, 144; 143, identifier:argmax; 144, argument_list; 144, 145; 145, subscript; 145, 146; 145, 147; 146, identifier:dat; 147, slice; 147, 148; 147, 151; 147, 152; 148, subscript; 148, 149; 148, 150; 149, identifier:i; 150, integer:0; 151, colon; 152, subscript; 152, 153; 152, 154; 153, identifier:i; 154, integer:2; 155, if_statement; 155, 156; 155, 161; 156, comparison_operator:in; 156, 157; 156, 158; 157, identifier:method; 158, list:['below_thresh', 'between_thresh']; 158, 159; 158, 160; 159, string:'below_thresh'; 160, string:'between_thresh'; 161, block; 161, 162; 161, 174; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:detected; 165, call; 165, 166; 165, 167; 166, identifier:insert; 167, argument_list; 167, 168; 167, 169; 167, 170; 167, 171; 168, identifier:detected; 169, integer:1; 170, integer:0; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:axis; 173, integer:1; 174, for_statement; 174, 175; 174, 176; 174, 177; 175, identifier:i; 176, identifier:detected; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:i; 182, integer:1; 183, binary_operator:+; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:i; 186, integer:0; 187, call; 187, 188; 187, 189; 188, identifier:argmin; 189, argument_list; 189, 190; 190, subscript; 190, 191; 190, 192; 191, identifier:dat; 192, slice; 192, 193; 192, 196; 192, 197; 193, subscript; 193, 194; 193, 195; 194, identifier:i; 195, integer:0; 196, colon; 197, subscript; 197, 198; 197, 199; 198, identifier:i; 199, integer:2; 200, if_statement; 200, 201; 200, 204; 201, comparison_operator:==; 201, 202; 201, 203; 202, identifier:method; 203, string:'maxima'; 204, block; 204, 205; 204, 214; 204, 226; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:peaks; 208, subscript; 208, 209; 208, 213; 209, call; 209, 210; 209, 211; 210, identifier:argrelmax; 211, argument_list; 211, 212; 212, identifier:dat; 213, integer:0; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:detected; 217, attribute; 217, 218; 217, 225; 218, call; 218, 219; 218, 220; 219, identifier:vstack; 220, argument_list; 220, 221; 221, tuple; 221, 222; 221, 223; 221, 224; 222, identifier:peaks; 223, identifier:peaks; 224, identifier:peaks; 225, identifier:T; 226, if_statement; 226, 227; 226, 230; 227, comparison_operator:is; 227, 228; 227, 229; 228, identifier:value; 229, None; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:detected; 234, subscript; 234, 235; 234, 236; 234, 241; 235, identifier:detected; 236, comparison_operator:>; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:dat; 239, identifier:peaks; 240, identifier:value; 241, slice; 241, 242; 242, colon; 243, return_statement; 243, 244; 244, identifier:detected | def detect_events(dat, method, value=None):
if 'thresh' in method or 'custom' == method:
if method == 'above_thresh':
above_det = dat >= value
detected = _detect_start_end(above_det)
if method == 'below_thresh':
below_det = dat < value
detected = _detect_start_end(below_det)
if method == 'between_thresh':
above_det = dat >= value[0]
below_det = dat < value[1]
between_det = logical_and(above_det, below_det)
detected = _detect_start_end(between_det)
if method == 'custom':
detected = _detect_start_end(dat)
if detected is None:
return None
if method in ['above_thresh', 'custom']:
detected = insert(detected, 1, 0, axis=1)
for i in detected:
i[1] = i[0] + argmax(dat[i[0]:i[2]])
if method in ['below_thresh', 'between_thresh']:
detected = insert(detected, 1, 0, axis=1)
for i in detected:
i[1] = i[0] + argmin(dat[i[0]:i[2]])
if method == 'maxima':
peaks = argrelmax(dat)[0]
detected = vstack((peaks, peaks, peaks)).T
if value is not None:
detected = detected[dat[peaks] > value, :]
return detected |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:merge_close; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:events; 5, identifier:min_interval; 6, default_parameter; 6, 7; 6, 8; 7, identifier:merge_to_longer; 8, False; 9, block; 9, 10; 9, 16; 9, 20; 9, 142; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:half_iv; 13, binary_operator:/; 13, 14; 13, 15; 14, identifier:min_interval; 15, integer:2; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:merged; 19, list:[]; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:higher; 22, identifier:events; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 27; 24, 35; 25, not_operator; 25, 26; 26, identifier:merged; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:merged; 32, identifier:append; 33, argument_list; 33, 34; 34, identifier:higher; 35, else_clause; 35, 36; 36, block; 36, 37; 36, 44; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:lower; 40, subscript; 40, 41; 40, 42; 41, identifier:merged; 42, unary_operator:-; 42, 43; 43, integer:1; 44, if_statement; 44, 45; 44, 56; 44, 133; 45, comparison_operator:<=; 45, 46; 45, 51; 46, binary_operator:-; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:higher; 49, string:'start'; 50, identifier:half_iv; 51, binary_operator:+; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:lower; 54, string:'end'; 55, identifier:half_iv; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 76; 57, 106; 58, boolean_operator:and; 58, 59; 58, 60; 59, identifier:merge_to_longer; 60, parenthesized_expression; 60, 61; 61, comparison_operator:>; 61, 62; 61, 69; 62, binary_operator:-; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:higher; 65, string:'end'; 66, subscript; 66, 67; 66, 68; 67, identifier:higher; 68, string:'start'; 69, binary_operator:-; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:lower; 72, string:'end'; 73, subscript; 73, 74; 73, 75; 74, identifier:lower; 75, string:'start'; 76, block; 76, 77; 76, 89; 76, 99; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:start; 80, call; 80, 81; 80, 82; 81, identifier:min; 82, argument_list; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:lower; 85, string:'start'; 86, subscript; 86, 87; 86, 88; 87, identifier:higher; 88, string:'start'; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:higher; 93, identifier:update; 94, argument_list; 94, 95; 95, dictionary; 95, 96; 96, pair; 96, 97; 96, 98; 97, string:'start'; 98, identifier:start; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 105; 101, subscript; 101, 102; 101, 103; 102, identifier:merged; 103, unary_operator:-; 103, 104; 104, integer:1; 105, identifier:higher; 106, else_clause; 106, 107; 107, block; 107, 108; 107, 120; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:end; 111, call; 111, 112; 111, 113; 112, identifier:max; 113, argument_list; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:lower; 116, string:'end'; 117, subscript; 117, 118; 117, 119; 118, identifier:higher; 119, string:'end'; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 128; 122, attribute; 122, 123; 122, 127; 123, subscript; 123, 124; 123, 125; 124, identifier:merged; 125, unary_operator:-; 125, 126; 126, integer:1; 127, identifier:update; 128, argument_list; 128, 129; 129, dictionary; 129, 130; 130, pair; 130, 131; 130, 132; 131, string:'end'; 132, identifier:end; 133, else_clause; 133, 134; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:merged; 139, identifier:append; 140, argument_list; 140, 141; 141, identifier:higher; 142, return_statement; 142, 143; 143, identifier:merged | def merge_close(events, min_interval, merge_to_longer=False):
half_iv = min_interval / 2
merged = []
for higher in events:
if not merged:
merged.append(higher)
else:
lower = merged[-1]
if higher['start'] - half_iv <= lower['end'] + half_iv:
if merge_to_longer and (higher['end'] - higher['start'] >
lower['end'] - lower['start']):
start = min(lower['start'], higher['start'])
higher.update({'start': start})
merged[-1] = higher
else:
end = max(lower['end'], higher['end'])
merged[-1].update({'end': end})
else:
merged.append(higher)
return merged |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_remove_duplicate; 3, parameters; 3, 4; 3, 5; 4, identifier:old_events; 5, identifier:dat; 6, block; 6, 7; 6, 17; 6, 42; 6, 46; 6, 59; 6, 75; 6, 98; 6, 102; 6, 106; 6, 185; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:diff_events; 10, call; 10, 11; 10, 12; 11, identifier:diff; 12, argument_list; 12, 13; 12, 14; 13, identifier:old_events; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:axis; 16, integer:0; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:dupl; 20, subscript; 20, 21; 20, 41; 21, call; 21, 22; 21, 23; 22, identifier:where; 23, argument_list; 23, 24; 24, binary_operator:&; 24, 25; 24, 33; 25, parenthesized_expression; 25, 26; 26, comparison_operator:==; 26, 27; 26, 32; 27, subscript; 27, 28; 27, 29; 27, 31; 28, identifier:diff_events; 29, slice; 29, 30; 30, colon; 31, integer:0; 32, integer:0; 33, parenthesized_expression; 33, 34; 34, comparison_operator:==; 34, 35; 34, 40; 35, subscript; 35, 36; 35, 37; 35, 39; 36, identifier:diff_events; 37, slice; 37, 38; 38, colon; 39, integer:2; 40, integer:0; 41, integer:0; 42, expression_statement; 42, 43; 43, augmented_assignment:+=; 43, 44; 43, 45; 44, identifier:dupl; 45, integer:1; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:n_nondupl_events; 49, binary_operator:-; 49, 50; 49, 55; 50, subscript; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:old_events; 53, identifier:shape; 54, integer:0; 55, call; 55, 56; 55, 57; 56, identifier:len; 57, argument_list; 57, 58; 58, identifier:dupl; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:new_events; 62, call; 62, 63; 62, 64; 63, identifier:zeros; 64, argument_list; 64, 65; 64, 72; 65, tuple; 65, 66; 65, 67; 66, identifier:n_nondupl_events; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:old_events; 70, identifier:shape; 71, integer:1; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:dtype; 74, string:'int'; 75, if_statement; 75, 76; 75, 80; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, identifier:dupl; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:lg; 85, identifier:debug; 86, argument_list; 86, 87; 87, binary_operator:+; 87, 88; 87, 97; 88, binary_operator:+; 88, 89; 88, 90; 89, string:'Removing '; 90, call; 90, 91; 90, 92; 91, identifier:str; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:dupl; 97, string:' duplicate events'; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:i; 101, integer:0; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:indices; 105, list:[]; 106, for_statement; 106, 107; 106, 110; 106, 114; 107, pattern_list; 107, 108; 107, 109; 108, identifier:i_old; 109, identifier:one_old_event; 110, call; 110, 111; 110, 112; 111, identifier:enumerate; 112, argument_list; 112, 113; 113, identifier:old_events; 114, block; 114, 115; 115, if_statement; 115, 116; 115, 119; 115, 139; 116, comparison_operator:not; 116, 117; 116, 118; 117, identifier:i_old; 118, identifier:dupl; 119, block; 119, 120; 119, 128; 119, 132; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 124; 122, 125; 123, identifier:new_events; 124, identifier:i; 125, slice; 125, 126; 126, colon; 127, identifier:one_old_event; 128, expression_statement; 128, 129; 129, augmented_assignment:+=; 129, 130; 129, 131; 130, identifier:i; 131, integer:1; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:indices; 136, identifier:append; 137, argument_list; 137, 138; 138, identifier:i_old; 139, else_clause; 139, 140; 140, block; 140, 141; 140, 150; 140, 156; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:peak_0; 144, subscript; 144, 145; 144, 146; 144, 149; 145, identifier:new_events; 146, binary_operator:-; 146, 147; 146, 148; 147, identifier:i; 148, integer:1; 149, integer:1; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:peak_1; 153, subscript; 153, 154; 153, 155; 154, identifier:one_old_event; 155, integer:1; 156, if_statement; 156, 157; 156, 164; 156, 174; 157, comparison_operator:>=; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:dat; 160, identifier:peak_0; 161, subscript; 161, 162; 161, 163; 162, identifier:dat; 163, identifier:peak_1; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 173; 167, subscript; 167, 168; 167, 169; 167, 172; 168, identifier:new_events; 169, binary_operator:-; 169, 170; 169, 171; 170, identifier:i; 171, integer:1; 172, integer:1; 173, identifier:peak_0; 174, else_clause; 174, 175; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 184; 178, subscript; 178, 179; 178, 180; 178, 183; 179, identifier:new_events; 180, binary_operator:-; 180, 181; 180, 182; 181, identifier:i; 182, integer:1; 183, integer:1; 184, identifier:peak_1; 185, return_statement; 185, 186; 186, expression_list; 186, 187; 186, 188; 187, identifier:indices; 188, identifier:new_events | def _remove_duplicate(old_events, dat):
diff_events = diff(old_events, axis=0)
dupl = where((diff_events[:, 0] == 0) & (diff_events[:, 2] == 0))[0]
dupl += 1
n_nondupl_events = old_events.shape[0] - len(dupl)
new_events = zeros((n_nondupl_events, old_events.shape[1]), dtype='int')
if len(dupl):
lg.debug('Removing ' + str(len(dupl)) + ' duplicate events')
i = 0
indices = []
for i_old, one_old_event in enumerate(old_events):
if i_old not in dupl:
new_events[i, :] = one_old_event
i += 1
indices.append(i_old)
else:
peak_0 = new_events[i - 1, 1]
peak_1 = one_old_event[1]
if dat[peak_0] >= dat[peak_1]:
new_events[i - 1, 1] = peak_0
else:
new_events[i - 1, 1] = peak_1
return indices, new_events |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:math; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:operator; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:operator_name; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:axis; 13, None; 14, block; 14, 15; 14, 31; 14, 73; 14, 84; 14, 88; 14, 193; 14, 201; 14, 215; 14, 219; 14, 422; 15, if_statement; 15, 16; 15, 23; 16, boolean_operator:and; 16, 17; 16, 20; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:operator; 19, None; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:operator_name; 22, None; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:TypeError; 27, argument_list; 27, 28; 28, concatenated_string; 28, 29; 28, 30; 29, string:'Parameters "operator" and "operator_name" are '; 30, string:'mutually exclusive'; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:operator_name; 34, None; 35, block; 35, 36; 35, 48; 35, 52; 35, 66; 36, if_statement; 36, 37; 36, 42; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:operator_name; 41, identifier:str; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:operator_name; 46, tuple; 46, 47; 47, identifier:operator_name; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:operators; 51, list:[]; 52, for_statement; 52, 53; 52, 54; 52, 55; 53, identifier:one_operator_name; 54, identifier:operator_name; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:operators; 60, identifier:append; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:eval; 64, argument_list; 64, 65; 65, identifier:one_operator_name; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:operator; 69, call; 69, 70; 69, 71; 70, identifier:tuple; 71, argument_list; 71, 72; 72, identifier:operators; 73, if_statement; 73, 74; 73, 78; 74, call; 74, 75; 74, 76; 75, identifier:callable; 76, argument_list; 76, 77; 77, identifier:operator; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:operator; 82, tuple; 82, 83; 83, identifier:operator; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:operations; 87, list:[]; 88, for_statement; 88, 89; 88, 90; 88, 91; 89, identifier:one_operator; 90, identifier:operator; 91, block; 91, 92; 91, 96; 91, 100; 91, 172; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:on_axis; 95, False; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:keepdims; 99, True; 100, try_statement; 100, 101; 100, 111; 100, 130; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:args; 105, attribute; 105, 106; 105, 110; 106, call; 106, 107; 106, 108; 107, identifier:getfullargspec; 108, argument_list; 108, 109; 109, identifier:one_operator; 110, identifier:args; 111, except_clause; 111, 112; 111, 113; 112, identifier:TypeError; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:lg; 118, identifier:debug; 119, argument_list; 119, 120; 120, binary_operator:+; 120, 121; 120, 127; 121, binary_operator:+; 121, 122; 121, 123; 122, string:'func '; 123, call; 123, 124; 123, 125; 124, identifier:str; 125, argument_list; 125, 126; 126, identifier:one_operator; 127, concatenated_string; 127, 128; 127, 129; 128, string:' is not a Python '; 129, string:'function'; 130, else_clause; 130, 131; 131, block; 131, 132; 131, 159; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:in; 133, 134; 133, 135; 134, string:'axis'; 135, identifier:args; 136, block; 136, 137; 136, 141; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:on_axis; 140, True; 141, if_statement; 141, 142; 141, 145; 142, comparison_operator:is; 142, 143; 142, 144; 143, identifier:axis; 144, None; 145, block; 145, 146; 146, raise_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:TypeError; 149, argument_list; 149, 150; 150, binary_operator:+; 150, 151; 150, 158; 151, binary_operator:+; 151, 152; 151, 155; 152, concatenated_string; 152, 153; 152, 154; 153, string:'You need to specify an axis if you '; 154, string:'use '; 155, attribute; 155, 156; 155, 157; 156, identifier:one_operator; 157, identifier:__name__; 158, string:' (which applies to an axis)'; 159, if_statement; 159, 160; 159, 167; 160, boolean_operator:or; 160, 161; 160, 164; 161, comparison_operator:in; 161, 162; 161, 163; 162, string:'keepdims'; 163, identifier:args; 164, comparison_operator:in; 164, 165; 164, 166; 165, identifier:one_operator; 166, identifier:NOKEEPDIM; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:keepdims; 171, False; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:operations; 176, identifier:append; 177, argument_list; 177, 178; 178, dictionary; 178, 179; 178, 184; 178, 187; 178, 190; 179, pair; 179, 180; 179, 181; 180, string:'name'; 181, attribute; 181, 182; 181, 183; 182, identifier:one_operator; 183, identifier:__name__; 184, pair; 184, 185; 184, 186; 185, string:'func'; 186, identifier:one_operator; 187, pair; 187, 188; 187, 189; 188, string:'on_axis'; 189, identifier:on_axis; 190, pair; 190, 191; 190, 192; 191, string:'keepdims'; 192, identifier:keepdims; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:output; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:data; 199, identifier:_copy; 200, argument_list; 201, if_statement; 201, 202; 201, 205; 202, comparison_operator:is; 202, 203; 202, 204; 203, identifier:axis; 204, None; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:idx_axis; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:data; 212, identifier:index_of; 213, argument_list; 213, 214; 214, identifier:axis; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:first_op; 218, True; 219, for_statement; 219, 220; 219, 221; 219, 222; 220, identifier:op; 221, identifier:operations; 222, block; 222, 223; 222, 229; 222, 250; 222, 402; 222, 406; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:func; 226, subscript; 226, 227; 226, 228; 227, identifier:op; 228, string:'func'; 229, if_statement; 229, 230; 229, 233; 230, comparison_operator:==; 230, 231; 230, 232; 231, identifier:func; 232, identifier:mode; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:func; 237, lambda; 237, 238; 237, 241; 238, lambda_parameters; 238, 239; 238, 240; 239, identifier:x; 240, identifier:axis; 241, subscript; 241, 242; 241, 249; 242, call; 242, 243; 242, 244; 243, identifier:mode; 244, argument_list; 244, 245; 244, 246; 245, identifier:x; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:axis; 248, identifier:axis; 249, integer:0; 250, for_statement; 250, 251; 250, 252; 250, 261; 251, identifier:i; 252, call; 252, 253; 252, 254; 253, identifier:range; 254, argument_list; 254, 255; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:output; 258, identifier:number_of; 259, argument_list; 259, 260; 260, string:'trial'; 261, block; 261, 262; 261, 285; 262, if_statement; 262, 263; 262, 264; 262, 274; 263, identifier:first_op; 264, block; 264, 265; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:x; 268, call; 268, 269; 268, 270; 269, identifier:data; 270, argument_list; 270, 271; 271, keyword_argument; 271, 272; 271, 273; 272, identifier:trial; 273, identifier:i; 274, else_clause; 274, 275; 275, block; 275, 276; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:x; 279, call; 279, 280; 279, 281; 280, identifier:output; 281, argument_list; 281, 282; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:trial; 284, identifier:i; 285, if_statement; 285, 286; 285, 289; 285, 376; 286, subscript; 286, 287; 286, 288; 287, identifier:op; 288, string:'on_axis'; 289, block; 289, 290; 289, 308; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:lg; 294, identifier:debug; 295, argument_list; 295, 296; 296, binary_operator:+; 296, 297; 296, 304; 297, binary_operator:+; 297, 298; 297, 303; 298, binary_operator:+; 298, 299; 298, 300; 299, string:'running '; 300, subscript; 300, 301; 300, 302; 301, identifier:op; 302, string:'name'; 303, string:' on '; 304, call; 304, 305; 304, 306; 305, identifier:str; 306, argument_list; 306, 307; 307, identifier:idx_axis; 308, try_statement; 308, 309; 308, 344; 309, block; 309, 310; 309, 330; 310, if_statement; 310, 311; 310, 314; 311, comparison_operator:==; 311, 312; 311, 313; 312, identifier:func; 313, identifier:diff; 314, block; 314, 315; 314, 322; 315, expression_statement; 315, 316; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:lg; 319, identifier:debug; 320, argument_list; 320, 321; 321, string:'Diff has one-point of zero padding'; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 325; 324, identifier:x; 325, call; 325, 326; 325, 327; 326, identifier:_pad_one_axis_one_value; 327, argument_list; 327, 328; 327, 329; 328, identifier:x; 329, identifier:idx_axis; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 337; 332, subscript; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:output; 335, identifier:data; 336, identifier:i; 337, call; 337, 338; 337, 339; 338, identifier:func; 339, argument_list; 339, 340; 339, 341; 340, identifier:x; 341, keyword_argument; 341, 342; 341, 343; 342, identifier:axis; 343, identifier:idx_axis; 344, except_clause; 344, 345; 344, 346; 345, identifier:IndexError; 346, block; 346, 347; 347, raise_statement; 347, 348; 348, call; 348, 349; 348, 350; 349, identifier:ValueError; 350, argument_list; 350, 351; 351, binary_operator:+; 351, 352; 351, 375; 352, binary_operator:+; 352, 353; 352, 360; 353, binary_operator:+; 353, 354; 353, 357; 354, binary_operator:+; 354, 355; 354, 356; 355, string:'The axis '; 356, identifier:axis; 357, concatenated_string; 357, 358; 357, 359; 358, string:' does not '; 359, string:'exist in ['; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, string:', '; 363, identifier:join; 364, argument_list; 364, 365; 365, call; 365, 366; 365, 367; 366, identifier:list; 367, argument_list; 367, 368; 368, call; 368, 369; 368, 374; 369, attribute; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:data; 372, identifier:axis; 373, identifier:keys; 374, argument_list; 375, string:']'; 376, else_clause; 376, 377; 377, block; 377, 378; 377, 391; 378, expression_statement; 378, 379; 379, call; 379, 380; 379, 383; 380, attribute; 380, 381; 380, 382; 381, identifier:lg; 382, identifier:debug; 383, argument_list; 383, 384; 384, binary_operator:+; 384, 385; 384, 390; 385, binary_operator:+; 385, 386; 385, 387; 386, string:'running '; 387, subscript; 387, 388; 387, 389; 388, identifier:op; 389, string:'name'; 390, string:' on each datapoint'; 391, expression_statement; 391, 392; 392, assignment; 392, 393; 392, 398; 393, subscript; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:output; 396, identifier:data; 397, identifier:i; 398, call; 398, 399; 398, 400; 399, identifier:func; 400, argument_list; 400, 401; 401, identifier:x; 402, expression_statement; 402, 403; 403, assignment; 403, 404; 403, 405; 404, identifier:first_op; 405, False; 406, if_statement; 406, 407; 406, 415; 407, boolean_operator:and; 407, 408; 407, 411; 408, subscript; 408, 409; 408, 410; 409, identifier:op; 410, string:'on_axis'; 411, not_operator; 411, 412; 412, subscript; 412, 413; 412, 414; 413, identifier:op; 414, string:'keepdims'; 415, block; 415, 416; 416, delete_statement; 416, 417; 417, subscript; 417, 418; 417, 421; 418, attribute; 418, 419; 418, 420; 419, identifier:output; 420, identifier:axis; 421, identifier:axis; 422, return_statement; 422, 423; 423, identifier:output | def math(data, operator=None, operator_name=None, axis=None):
if operator is not None and operator_name is not None:
raise TypeError('Parameters "operator" and "operator_name" are '
'mutually exclusive')
if operator_name is not None:
if isinstance(operator_name, str):
operator_name = (operator_name, )
operators = []
for one_operator_name in operator_name:
operators.append(eval(one_operator_name))
operator = tuple(operators)
if callable(operator):
operator = (operator, )
operations = []
for one_operator in operator:
on_axis = False
keepdims = True
try:
args = getfullargspec(one_operator).args
except TypeError:
lg.debug('func ' + str(one_operator) + ' is not a Python '
'function')
else:
if 'axis' in args:
on_axis = True
if axis is None:
raise TypeError('You need to specify an axis if you '
'use ' + one_operator.__name__ +
' (which applies to an axis)')
if 'keepdims' in args or one_operator in NOKEEPDIM:
keepdims = False
operations.append({'name': one_operator.__name__,
'func': one_operator,
'on_axis': on_axis,
'keepdims': keepdims,
})
output = data._copy()
if axis is not None:
idx_axis = data.index_of(axis)
first_op = True
for op in operations:
func = op['func']
if func == mode:
func = lambda x, axis: mode(x, axis=axis)[0]
for i in range(output.number_of('trial')):
if first_op:
x = data(trial=i)
else:
x = output(trial=i)
if op['on_axis']:
lg.debug('running ' + op['name'] + ' on ' + str(idx_axis))
try:
if func == diff:
lg.debug('Diff has one-point of zero padding')
x = _pad_one_axis_one_value(x, idx_axis)
output.data[i] = func(x, axis=idx_axis)
except IndexError:
raise ValueError('The axis ' + axis + ' does not '
'exist in [' +
', '.join(list(data.axis.keys())) + ']')
else:
lg.debug('running ' + op['name'] + ' on each datapoint')
output.data[i] = func(x)
first_op = False
if op['on_axis'] and not op['keepdims']:
del output.axis[axis]
return output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:detect_Massimini2004; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:dat_orig; 5, identifier:s_freq; 6, identifier:time; 7, identifier:opts; 8, block; 8, 9; 8, 19; 8, 31; 8, 42; 8, 46; 8, 129; 8, 144; 9, if_statement; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:opts; 12, identifier:invert; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:dat_orig; 17, unary_operator:-; 17, 18; 18, identifier:dat_orig; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:dat_det; 22, call; 22, 23; 22, 24; 23, identifier:transform_signal; 24, argument_list; 24, 25; 24, 26; 24, 27; 24, 28; 25, identifier:dat_orig; 26, identifier:s_freq; 27, string:'double_butter'; 28, attribute; 28, 29; 28, 30; 29, identifier:opts; 30, identifier:det_filt; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:above_zero; 34, call; 34, 35; 34, 36; 35, identifier:detect_events; 36, argument_list; 36, 37; 36, 38; 36, 39; 37, identifier:dat_det; 38, string:'above_thresh'; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:value; 41, float:0.; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:sw_in_chan; 45, list:[]; 46, if_statement; 46, 47; 46, 50; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:above_zero; 49, None; 50, block; 50, 51; 50, 62; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:troughs; 54, call; 54, 55; 54, 56; 55, identifier:within_duration; 56, argument_list; 56, 57; 56, 58; 56, 59; 57, identifier:above_zero; 58, identifier:time; 59, attribute; 59, 60; 59, 61; 60, identifier:opts; 61, identifier:trough_duration; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:troughs; 65, None; 66, block; 66, 67; 66, 78; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:troughs; 70, call; 70, 71; 70, 72; 71, identifier:select_peaks; 72, argument_list; 72, 73; 72, 74; 72, 75; 73, identifier:dat_det; 74, identifier:troughs; 75, attribute; 75, 76; 75, 77; 76, identifier:opts; 77, identifier:max_trough_amp; 78, if_statement; 78, 79; 78, 82; 79, comparison_operator:is; 79, 80; 79, 81; 80, identifier:troughs; 81, None; 82, block; 82, 83; 82, 93; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:events; 86, call; 86, 87; 86, 88; 87, identifier:_add_halfwave; 88, argument_list; 88, 89; 88, 90; 88, 91; 88, 92; 89, identifier:dat_det; 90, identifier:troughs; 91, identifier:s_freq; 92, identifier:opts; 93, if_statement; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:len; 96, argument_list; 96, 97; 97, identifier:events; 98, block; 98, 99; 98, 110; 98, 119; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:events; 102, call; 102, 103; 102, 104; 103, identifier:within_duration; 104, argument_list; 104, 105; 104, 106; 104, 107; 105, identifier:events; 106, identifier:time; 107, attribute; 107, 108; 107, 109; 108, identifier:opts; 109, identifier:duration; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:events; 113, call; 113, 114; 113, 115; 114, identifier:remove_straddlers; 115, argument_list; 115, 116; 115, 117; 115, 118; 116, identifier:events; 117, identifier:time; 118, identifier:s_freq; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:sw_in_chan; 122, call; 122, 123; 122, 124; 123, identifier:make_slow_waves; 124, argument_list; 124, 125; 124, 126; 124, 127; 124, 128; 125, identifier:events; 126, identifier:dat_det; 127, identifier:time; 128, identifier:s_freq; 129, if_statement; 129, 130; 129, 136; 130, comparison_operator:==; 130, 131; 130, 135; 131, call; 131, 132; 131, 133; 132, identifier:len; 133, argument_list; 133, 134; 134, identifier:sw_in_chan; 135, integer:0; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:lg; 141, identifier:info; 142, argument_list; 142, 143; 143, string:'No slow wave found'; 144, return_statement; 144, 145; 145, identifier:sw_in_chan | def detect_Massimini2004(dat_orig, s_freq, time, opts):
if opts.invert:
dat_orig = -dat_orig
dat_det = transform_signal(dat_orig, s_freq, 'double_butter',
opts.det_filt)
above_zero = detect_events(dat_det, 'above_thresh', value=0.)
sw_in_chan = []
if above_zero is not None:
troughs = within_duration(above_zero, time, opts.trough_duration)
if troughs is not None:
troughs = select_peaks(dat_det, troughs, opts.max_trough_amp)
if troughs is not None:
events = _add_halfwave(dat_det, troughs, s_freq, opts)
if len(events):
events = within_duration(events, time, opts.duration)
events = remove_straddlers(events, time, s_freq)
sw_in_chan = make_slow_waves(events, dat_det, time, s_freq)
if len(sw_in_chan) == 0:
lg.info('No slow wave found')
return sw_in_chan |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:filter_; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, string:'time'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:low_cut; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:high_cut; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:order; 16, integer:4; 17, default_parameter; 17, 18; 17, 19; 18, identifier:ftype; 19, string:'butter'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:Rs; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:notchfreq; 25, integer:50; 26, default_parameter; 26, 27; 26, 28; 27, identifier:notchquality; 28, integer:25; 29, block; 29, 30; 29, 38; 29, 42; 29, 135; 29, 149; 29, 158; 29, 222; 29, 230; 29, 281; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:nyquist; 33, binary_operator:/; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:data; 36, identifier:s_freq; 37, float:2.; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:btype; 41, None; 42, if_statement; 42, 43; 42, 50; 42, 81; 42, 108; 43, boolean_operator:and; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:low_cut; 46, None; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:high_cut; 49, None; 50, block; 50, 51; 50, 67; 50, 71; 51, if_statement; 51, 52; 51, 59; 52, boolean_operator:or; 52, 53; 52, 56; 53, comparison_operator:>; 53, 54; 53, 55; 54, identifier:low_cut; 55, identifier:nyquist; 56, comparison_operator:>; 56, 57; 56, 58; 57, identifier:high_cut; 58, identifier:nyquist; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:ValueError; 63, argument_list; 63, 64; 64, concatenated_string; 64, 65; 64, 66; 65, string:'cutoff has to be less than Nyquist '; 66, string:'frequency'; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:btype; 70, string:'bandpass'; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:Wn; 74, tuple; 74, 75; 74, 78; 75, binary_operator:/; 75, 76; 75, 77; 76, identifier:low_cut; 77, identifier:nyquist; 78, binary_operator:/; 78, 79; 78, 80; 79, identifier:high_cut; 80, identifier:nyquist; 81, elif_clause; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:low_cut; 84, None; 85, block; 85, 86; 85, 98; 85, 102; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:>; 87, 88; 87, 89; 88, identifier:low_cut; 89, identifier:nyquist; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:ValueError; 94, argument_list; 94, 95; 95, concatenated_string; 95, 96; 95, 97; 96, string:'cutoff has to be less than Nyquist '; 97, string:'frequency'; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:btype; 101, string:'highpass'; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:Wn; 105, binary_operator:/; 105, 106; 105, 107; 106, identifier:low_cut; 107, identifier:nyquist; 108, elif_clause; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:high_cut; 111, None; 112, block; 112, 113; 112, 125; 112, 129; 113, if_statement; 113, 114; 113, 117; 114, comparison_operator:>; 114, 115; 114, 116; 115, identifier:high_cut; 116, identifier:nyquist; 117, block; 117, 118; 118, raise_statement; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:ValueError; 121, argument_list; 121, 122; 122, concatenated_string; 122, 123; 122, 124; 123, string:'cutoff has to be less than Nyquist '; 124, string:'frequency'; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:btype; 128, string:'lowpass'; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:Wn; 132, binary_operator:/; 132, 133; 132, 134; 133, identifier:high_cut; 134, identifier:nyquist; 135, if_statement; 135, 136; 135, 143; 136, boolean_operator:and; 136, 137; 136, 140; 137, comparison_operator:is; 137, 138; 137, 139; 138, identifier:btype; 139, None; 140, comparison_operator:!=; 140, 141; 140, 142; 141, identifier:ftype; 142, string:'notch'; 143, block; 143, 144; 144, raise_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:TypeError; 147, argument_list; 147, 148; 148, string:'You should specify at least low_cut or high_cut'; 149, if_statement; 149, 150; 149, 153; 150, comparison_operator:is; 150, 151; 150, 152; 151, identifier:Rs; 152, None; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:Rs; 157, integer:40; 158, if_statement; 158, 159; 158, 162; 158, 182; 159, comparison_operator:==; 159, 160; 159, 161; 160, identifier:ftype; 161, string:'notch'; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:b_a; 166, list_comprehension; 166, 167; 166, 174; 167, call; 167, 168; 167, 169; 168, identifier:iirnotch; 169, argument_list; 169, 170; 169, 173; 170, binary_operator:/; 170, 171; 170, 172; 171, identifier:w0; 172, identifier:nyquist; 173, identifier:notchquality; 174, for_in_clause; 174, 175; 174, 176; 175, identifier:w0; 176, call; 176, 177; 176, 178; 177, identifier:arange; 178, argument_list; 178, 179; 178, 180; 178, 181; 179, identifier:notchfreq; 180, identifier:nyquist; 181, identifier:notchfreq; 182, else_clause; 182, 183; 183, block; 183, 184; 183, 204; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:lg; 188, identifier:debug; 189, argument_list; 189, 190; 190, call; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, concatenated_string; 192, 193; 192, 194; 193, string:'order {0: 2}, Wn {1}, btype {2}, ftype {3}'; 194, string:''; 195, identifier:format; 196, argument_list; 196, 197; 196, 198; 196, 202; 196, 203; 197, identifier:order; 198, call; 198, 199; 198, 200; 199, identifier:str; 200, argument_list; 200, 201; 201, identifier:Wn; 202, identifier:btype; 203, identifier:ftype; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:b_a; 207, list:[iirfilter(order, Wn, btype=btype, ftype=ftype, rs=Rs), ]; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:iirfilter; 210, argument_list; 210, 211; 210, 212; 210, 213; 210, 216; 210, 219; 211, identifier:order; 212, identifier:Wn; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:btype; 215, identifier:btype; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:ftype; 218, identifier:ftype; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:rs; 221, identifier:Rs; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:fdata; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:data; 228, identifier:_copy; 229, argument_list; 230, for_statement; 230, 231; 230, 232; 230, 241; 231, identifier:i; 232, call; 232, 233; 232, 234; 233, identifier:range; 234, argument_list; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:data; 238, identifier:number_of; 239, argument_list; 239, 240; 240, string:'trial'; 241, block; 241, 242; 241, 250; 241, 273; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:x; 245, subscript; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:data; 248, identifier:data; 249, identifier:i; 250, for_statement; 250, 251; 250, 254; 250, 255; 251, pattern_list; 251, 252; 251, 253; 252, identifier:b; 253, identifier:a; 254, identifier:b_a; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:x; 259, call; 259, 260; 259, 261; 260, identifier:filtfilt; 261, argument_list; 261, 262; 261, 263; 261, 264; 261, 265; 262, identifier:b; 263, identifier:a; 264, identifier:x; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:axis; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:data; 270, identifier:index_of; 271, argument_list; 271, 272; 272, identifier:axis; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 280; 275, subscript; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:fdata; 278, identifier:data; 279, identifier:i; 280, identifier:x; 281, return_statement; 281, 282; 282, identifier:fdata | def filter_(data, axis='time', low_cut=None, high_cut=None, order=4,
ftype='butter', Rs=None, notchfreq=50, notchquality=25):
nyquist = data.s_freq / 2.
btype = None
if low_cut is not None and high_cut is not None:
if low_cut > nyquist or high_cut > nyquist:
raise ValueError('cutoff has to be less than Nyquist '
'frequency')
btype = 'bandpass'
Wn = (low_cut / nyquist,
high_cut / nyquist)
elif low_cut is not None:
if low_cut > nyquist:
raise ValueError('cutoff has to be less than Nyquist '
'frequency')
btype = 'highpass'
Wn = low_cut / nyquist
elif high_cut is not None:
if high_cut > nyquist:
raise ValueError('cutoff has to be less than Nyquist '
'frequency')
btype = 'lowpass'
Wn = high_cut / nyquist
if btype is None and ftype != 'notch':
raise TypeError('You should specify at least low_cut or high_cut')
if Rs is None:
Rs = 40
if ftype == 'notch':
b_a = [iirnotch(w0 / nyquist, notchquality) for w0 in arange(notchfreq, nyquist, notchfreq)]
else:
lg.debug('order {0: 2}, Wn {1}, btype {2}, ftype {3}'
''.format(order, str(Wn), btype, ftype))
b_a = [iirfilter(order, Wn, btype=btype, ftype=ftype, rs=Rs), ]
fdata = data._copy()
for i in range(data.number_of('trial')):
x = data.data[i]
for b, a in b_a:
x = filtfilt(b, a, x, axis=data.index_of(axis))
fdata.data[i] = x
return fdata |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:select; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:trial; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:invert; 10, False; 11, dictionary_splat_pattern; 11, 12; 12, identifier:axes_to_select; 13, block; 13, 14; 13, 31; 13, 63; 13, 105; 13, 116; 13, 139; 13, 154; 13, 158; 13, 410; 14, if_statement; 14, 15; 14, 25; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:trial; 18, None; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:trial; 24, identifier:Iterable; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:TypeError; 29, argument_list; 29, 30; 30, string:'Trial needs to be iterable.'; 31, for_statement; 31, 32; 31, 35; 31, 40; 32, pattern_list; 32, 33; 32, 34; 33, identifier:axis_to_select; 34, identifier:values_to_select; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:axes_to_select; 38, identifier:items; 39, argument_list; 40, block; 40, 41; 41, if_statement; 41, 42; 41, 55; 42, parenthesized_expression; 42, 43; 43, boolean_operator:or; 43, 44; 43, 50; 44, not_operator; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:isinstance; 47, argument_list; 47, 48; 47, 49; 48, identifier:values_to_select; 49, identifier:Iterable; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:values_to_select; 54, identifier:str; 55, block; 55, 56; 56, raise_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:TypeError; 59, argument_list; 59, 60; 60, binary_operator:+; 60, 61; 60, 62; 61, identifier:axis_to_select; 62, string:' needs to be iterable.'; 63, if_statement; 63, 64; 63, 67; 63, 80; 64, comparison_operator:is; 64, 65; 64, 66; 65, identifier:trial; 66, None; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:trial; 71, call; 71, 72; 71, 73; 72, identifier:range; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:data; 77, identifier:number_of; 78, argument_list; 78, 79; 79, string:'trial'; 80, else_clause; 80, 81; 81, block; 81, 82; 81, 86; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:trial; 85, identifier:trial; 86, if_statement; 86, 87; 86, 88; 87, identifier:invert; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:trial; 92, call; 92, 93; 92, 94; 93, identifier:setdiff1d; 94, argument_list; 94, 95; 94, 104; 95, call; 95, 96; 95, 97; 96, identifier:range; 97, argument_list; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:data; 101, identifier:number_of; 102, argument_list; 102, 103; 103, string:'trial'; 104, identifier:trial; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:output; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:data; 111, identifier:_copy; 112, argument_list; 112, 113; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:axis; 115, False; 116, for_statement; 116, 117; 116, 118; 116, 121; 117, identifier:one_axis; 118, attribute; 118, 119; 118, 120; 119, identifier:output; 120, identifier:axis; 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:output; 127, identifier:axis; 128, identifier:one_axis; 129, call; 129, 130; 129, 131; 130, identifier:empty; 131, argument_list; 131, 132; 131, 136; 132, call; 132, 133; 132, 134; 133, identifier:len; 134, argument_list; 134, 135; 135, identifier:trial; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:dtype; 138, string:'O'; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:output; 143, identifier:data; 144, call; 144, 145; 144, 146; 145, identifier:empty; 146, argument_list; 146, 147; 146, 151; 147, call; 147, 148; 147, 149; 148, identifier:len; 149, argument_list; 149, 150; 150, identifier:trial; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:dtype; 153, string:'O'; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:to_select; 157, dictionary; 158, for_statement; 158, 159; 158, 162; 158, 166; 159, pattern_list; 159, 160; 159, 161; 160, identifier:cnt; 161, identifier:i; 162, call; 162, 163; 162, 164; 163, identifier:enumerate; 164, argument_list; 164, 165; 165, identifier:trial; 166, block; 166, 167; 166, 179; 166, 395; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:lg; 171, identifier:debug; 172, argument_list; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, string:'Selection on trial {0: 6}'; 176, identifier:format; 177, argument_list; 177, 178; 178, identifier:i; 179, for_statement; 179, 180; 179, 181; 179, 184; 180, identifier:one_axis; 181, attribute; 181, 182; 181, 183; 182, identifier:output; 183, identifier:axis; 184, block; 184, 185; 184, 195; 184, 385; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:values; 188, subscript; 188, 189; 188, 194; 189, subscript; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:data; 192, identifier:axis; 193, identifier:one_axis; 194, identifier:i; 195, if_statement; 195, 196; 195, 203; 195, 360; 196, comparison_operator:in; 196, 197; 196, 198; 197, identifier:one_axis; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:axes_to_select; 201, identifier:keys; 202, argument_list; 203, block; 203, 204; 203, 210; 203, 325; 203, 336; 203, 354; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:values_to_select; 207, subscript; 207, 208; 207, 209; 208, identifier:axes_to_select; 209, identifier:one_axis; 210, if_statement; 210, 211; 210, 217; 210, 222; 210, 241; 211, comparison_operator:==; 211, 212; 211, 216; 212, call; 212, 213; 212, 214; 213, identifier:len; 214, argument_list; 214, 215; 215, identifier:values_to_select; 216, integer:0; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:selected_values; 221, tuple; 222, elif_clause; 222, 223; 222, 230; 223, call; 223, 224; 223, 225; 224, identifier:isinstance; 225, argument_list; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:values_to_select; 228, integer:0; 229, identifier:str; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:selected_values; 234, call; 234, 235; 234, 236; 235, identifier:asarray; 236, argument_list; 236, 237; 236, 238; 237, identifier:values_to_select; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:dtype; 240, string:'U'; 241, else_clause; 241, 242; 242, block; 242, 243; 242, 319; 243, if_statement; 243, 244; 243, 256; 243, 270; 243, 285; 243, 300; 244, parenthesized_expression; 244, 245; 245, boolean_operator:and; 245, 246; 245, 251; 246, comparison_operator:is; 246, 247; 246, 250; 247, subscript; 247, 248; 247, 249; 248, identifier:values_to_select; 249, integer:0; 250, None; 251, comparison_operator:is; 251, 252; 251, 255; 252, subscript; 252, 253; 252, 254; 253, identifier:values_to_select; 254, integer:1; 255, None; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:bool_values; 260, call; 260, 261; 260, 262; 261, identifier:ones; 262, argument_list; 262, 263; 262, 267; 263, call; 263, 264; 263, 265; 264, identifier:len; 265, argument_list; 265, 266; 266, identifier:values; 267, keyword_argument; 267, 268; 267, 269; 268, identifier:dtype; 269, identifier:bool; 270, elif_clause; 270, 271; 270, 276; 271, comparison_operator:is; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:values_to_select; 274, integer:0; 275, None; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:bool_values; 280, comparison_operator:<; 280, 281; 280, 282; 281, identifier:values; 282, subscript; 282, 283; 282, 284; 283, identifier:values_to_select; 284, integer:1; 285, elif_clause; 285, 286; 285, 291; 286, comparison_operator:is; 286, 287; 286, 290; 287, subscript; 287, 288; 287, 289; 288, identifier:values_to_select; 289, integer:1; 290, None; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:bool_values; 295, comparison_operator:<=; 295, 296; 295, 299; 296, subscript; 296, 297; 296, 298; 297, identifier:values_to_select; 298, integer:0; 299, identifier:values; 300, else_clause; 300, 301; 301, block; 301, 302; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:bool_values; 305, parenthesized_expression; 305, 306; 306, binary_operator:&; 306, 307; 306, 313; 307, parenthesized_expression; 307, 308; 308, comparison_operator:<=; 308, 309; 308, 312; 309, subscript; 309, 310; 309, 311; 310, identifier:values_to_select; 311, integer:0; 312, identifier:values; 313, parenthesized_expression; 313, 314; 314, comparison_operator:<; 314, 315; 314, 316; 315, identifier:values; 316, subscript; 316, 317; 316, 318; 317, identifier:values_to_select; 318, integer:1; 319, expression_statement; 319, 320; 320, assignment; 320, 321; 320, 322; 321, identifier:selected_values; 322, subscript; 322, 323; 322, 324; 323, identifier:values; 324, identifier:bool_values; 325, if_statement; 325, 326; 325, 327; 326, identifier:invert; 327, block; 327, 328; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 331; 330, identifier:selected_values; 331, call; 331, 332; 331, 333; 332, identifier:setdiff1d; 333, argument_list; 333, 334; 333, 335; 334, identifier:values; 335, identifier:selected_values; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:lg; 340, identifier:debug; 341, argument_list; 341, 342; 342, call; 342, 343; 342, 348; 343, attribute; 343, 344; 343, 347; 344, concatenated_string; 344, 345; 344, 346; 345, string:'In axis {0}, selecting {1: 6} '; 346, string:'values'; 347, identifier:format; 348, argument_list; 348, 349; 348, 350; 349, identifier:one_axis; 350, call; 350, 351; 350, 352; 351, identifier:len; 352, argument_list; 352, 353; 353, identifier:selected_values; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 359; 356, subscript; 356, 357; 356, 358; 357, identifier:to_select; 358, identifier:one_axis; 359, identifier:selected_values; 360, else_clause; 360, 361; 361, block; 361, 362; 361, 375; 362, expression_statement; 362, 363; 363, call; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:lg; 366, identifier:debug; 367, argument_list; 367, 368; 368, binary_operator:+; 368, 369; 368, 372; 369, binary_operator:+; 369, 370; 369, 371; 370, string:'In axis '; 371, identifier:one_axis; 372, concatenated_string; 372, 373; 372, 374; 373, string:', selecting all the '; 374, string:'values'; 375, expression_statement; 375, 376; 376, assignment; 376, 377; 376, 378; 377, identifier:selected_values; 378, subscript; 378, 379; 378, 384; 379, subscript; 379, 380; 379, 383; 380, attribute; 380, 381; 380, 382; 381, identifier:data; 382, identifier:axis; 383, identifier:one_axis; 384, identifier:i; 385, expression_statement; 385, 386; 386, assignment; 386, 387; 386, 394; 387, subscript; 387, 388; 387, 393; 388, subscript; 388, 389; 388, 392; 389, attribute; 389, 390; 389, 391; 390, identifier:output; 391, identifier:axis; 392, identifier:one_axis; 393, identifier:cnt; 394, identifier:selected_values; 395, expression_statement; 395, 396; 396, assignment; 396, 397; 396, 402; 397, subscript; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:output; 400, identifier:data; 401, identifier:cnt; 402, call; 402, 403; 402, 404; 403, identifier:data; 404, argument_list; 404, 405; 404, 408; 405, keyword_argument; 405, 406; 405, 407; 406, identifier:trial; 407, identifier:i; 408, dictionary_splat; 408, 409; 409, identifier:to_select; 410, return_statement; 410, 411; 411, identifier:output | def select(data, trial=None, invert=False, **axes_to_select):
if trial is not None and not isinstance(trial, Iterable):
raise TypeError('Trial needs to be iterable.')
for axis_to_select, values_to_select in axes_to_select.items():
if (not isinstance(values_to_select, Iterable) or
isinstance(values_to_select, str)):
raise TypeError(axis_to_select + ' needs to be iterable.')
if trial is None:
trial = range(data.number_of('trial'))
else:
trial = trial
if invert:
trial = setdiff1d(range(data.number_of('trial')), trial)
output = data._copy(axis=False)
for one_axis in output.axis:
output.axis[one_axis] = empty(len(trial), dtype='O')
output.data = empty(len(trial), dtype='O')
to_select = {}
for cnt, i in enumerate(trial):
lg.debug('Selection on trial {0: 6}'.format(i))
for one_axis in output.axis:
values = data.axis[one_axis][i]
if one_axis in axes_to_select.keys():
values_to_select = axes_to_select[one_axis]
if len(values_to_select) == 0:
selected_values = ()
elif isinstance(values_to_select[0], str):
selected_values = asarray(values_to_select, dtype='U')
else:
if (values_to_select[0] is None and
values_to_select[1] is None):
bool_values = ones(len(values), dtype=bool)
elif values_to_select[0] is None:
bool_values = values < values_to_select[1]
elif values_to_select[1] is None:
bool_values = values_to_select[0] <= values
else:
bool_values = ((values_to_select[0] <= values) &
(values < values_to_select[1]))
selected_values = values[bool_values]
if invert:
selected_values = setdiff1d(values, selected_values)
lg.debug('In axis {0}, selecting {1: 6} '
'values'.format(one_axis,
len(selected_values)))
to_select[one_axis] = selected_values
else:
lg.debug('In axis ' + one_axis + ', selecting all the '
'values')
selected_values = data.axis[one_axis][i]
output.axis[one_axis][cnt] = selected_values
output.data[cnt] = data(trial=i, **to_select)
return output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 49; 2, function_name:fetch; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 3, 34; 3, 37; 3, 40; 3, 43; 3, 46; 4, identifier:dataset; 5, identifier:annot; 6, default_parameter; 6, 7; 6, 8; 7, identifier:cat; 8, tuple; 8, 9; 8, 10; 8, 11; 8, 12; 9, integer:0; 10, integer:0; 11, integer:0; 12, integer:0; 13, default_parameter; 13, 14; 13, 15; 14, identifier:evt_type; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:stage; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:cycle; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:chan_full; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:epoch; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:epoch_dur; 30, integer:30; 31, default_parameter; 31, 32; 31, 33; 32, identifier:epoch_overlap; 33, integer:0; 34, default_parameter; 34, 35; 34, 36; 35, identifier:epoch_step; 36, None; 37, default_parameter; 37, 38; 37, 39; 38, identifier:reject_epoch; 39, False; 40, default_parameter; 40, 41; 40, 42; 41, identifier:reject_artf; 42, False; 43, default_parameter; 43, 44; 43, 45; 44, identifier:min_dur; 45, integer:0; 46, default_parameter; 46, 47; 46, 48; 47, identifier:buffer; 48, integer:0; 49, block; 49, 50; 49, 75; 49, 102; 49, 179; 49, 186; 49, 192; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:bundles; 53, call; 53, 54; 53, 55; 54, identifier:get_times; 55, argument_list; 55, 56; 55, 57; 55, 60; 55, 63; 55, 66; 55, 69; 55, 72; 56, identifier:annot; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:evt_type; 59, identifier:evt_type; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:stage; 62, identifier:stage; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:cycle; 65, identifier:cycle; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:chan; 68, identifier:chan_full; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:exclude; 71, identifier:reject_epoch; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:buffer; 74, identifier:buffer; 75, if_statement; 75, 76; 75, 79; 76, boolean_operator:and; 76, 77; 76, 78; 77, identifier:reject_artf; 78, identifier:bundles; 79, block; 79, 80; 80, for_statement; 80, 81; 80, 82; 80, 83; 81, identifier:bund; 82, identifier:bundles; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:bund; 88, string:'times'; 89, call; 89, 90; 89, 91; 90, identifier:remove_artf_evts; 91, argument_list; 91, 92; 91, 95; 91, 96; 91, 99; 92, subscript; 92, 93; 92, 94; 93, identifier:bund; 94, string:'times'; 95, identifier:annot; 96, subscript; 96, 97; 96, 98; 97, identifier:bund; 98, string:'chan'; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:min_dur; 101, integer:0; 102, if_statement; 102, 103; 102, 104; 103, identifier:bundles; 104, block; 104, 105; 104, 171; 105, if_statement; 105, 106; 105, 109; 105, 117; 105, 159; 106, comparison_operator:==; 106, 107; 106, 108; 107, string:'locked'; 108, identifier:epoch; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:bundles; 113, call; 113, 114; 113, 115; 114, identifier:_divide_bundles; 115, argument_list; 115, 116; 116, identifier:bundles; 117, elif_clause; 117, 118; 117, 121; 118, comparison_operator:==; 118, 119; 118, 120; 119, string:'unlocked'; 120, identifier:epoch; 121, block; 121, 122; 121, 142; 121, 150; 122, if_statement; 122, 123; 122, 126; 122, 131; 123, comparison_operator:is; 123, 124; 123, 125; 124, identifier:epoch_step; 125, None; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:step; 130, identifier:epoch_step; 131, else_clause; 131, 132; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:step; 136, binary_operator:-; 136, 137; 136, 138; 137, identifier:epoch_dur; 138, parenthesized_expression; 138, 139; 139, binary_operator:*; 139, 140; 139, 141; 140, identifier:epoch_dur; 141, identifier:epoch_overlap; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:bundles; 145, call; 145, 146; 145, 147; 146, identifier:_concat; 147, argument_list; 147, 148; 147, 149; 148, identifier:bundles; 149, identifier:cat; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:bundles; 153, call; 153, 154; 153, 155; 154, identifier:_find_intervals; 155, argument_list; 155, 156; 155, 157; 155, 158; 156, identifier:bundles; 157, identifier:epoch_dur; 158, identifier:step; 159, elif_clause; 159, 160; 159, 162; 160, not_operator; 160, 161; 161, identifier:epoch; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:bundles; 166, call; 166, 167; 166, 168; 167, identifier:_concat; 168, argument_list; 168, 169; 168, 170; 169, identifier:bundles; 170, identifier:cat; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:bundles; 174, call; 174, 175; 174, 176; 175, identifier:_longer_than; 176, argument_list; 176, 177; 176, 178; 177, identifier:bundles; 178, identifier:min_dur; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:segments; 182, call; 182, 183; 182, 184; 183, identifier:Segments; 184, argument_list; 184, 185; 185, identifier:dataset; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:segments; 190, identifier:segments; 191, identifier:bundles; 192, return_statement; 192, 193; 193, identifier:segments | def fetch(dataset, annot, cat=(0, 0, 0, 0), evt_type=None, stage=None,
cycle=None, chan_full=None, epoch=None, epoch_dur=30,
epoch_overlap=0, epoch_step=None, reject_epoch=False,
reject_artf=False, min_dur=0, buffer=0):
bundles = get_times(annot, evt_type=evt_type, stage=stage, cycle=cycle,
chan=chan_full, exclude=reject_epoch, buffer=buffer)
if reject_artf and bundles:
for bund in bundles:
bund['times'] = remove_artf_evts(bund['times'], annot,
bund['chan'], min_dur=0)
if bundles:
if 'locked' == epoch:
bundles = _divide_bundles(bundles)
elif 'unlocked' == epoch:
if epoch_step is not None:
step = epoch_step
else:
step = epoch_dur - (epoch_dur * epoch_overlap)
bundles = _concat(bundles, cat)
bundles = _find_intervals(bundles, epoch_dur, step)
elif not epoch:
bundles = _concat(bundles, cat)
bundles = _longer_than(bundles, min_dur)
segments = Segments(dataset)
segments.segments = bundles
return segments |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:get_times; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:annot; 5, default_parameter; 5, 6; 5, 7; 6, identifier:evt_type; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:stage; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:cycle; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:chan; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:exclude; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:buffer; 22, integer:0; 23, block; 23, 24; 23, 30; 23, 36; 23, 46; 23, 56; 23, 66; 23, 113; 23, 117; 23, 124; 23, 128; 23, 250; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:getter; 27, attribute; 27, 28; 27, 29; 28, identifier:annot; 29, identifier:get_epochs; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:last; 33, attribute; 33, 34; 33, 35; 34, identifier:annot; 35, identifier:last_second; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:stage; 39, None; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:stage; 44, tuple; 44, 45; 45, None; 46, if_statement; 46, 47; 46, 50; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:cycle; 49, None; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:cycle; 54, tuple; 54, 55; 55, None; 56, if_statement; 56, 57; 56, 60; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:chan; 59, None; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:chan; 64, tuple; 64, 65; 65, None; 66, if_statement; 66, 67; 66, 70; 66, 76; 66, 104; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:evt_type; 69, None; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:evt_type; 74, tuple; 74, 75; 75, None; 76, elif_clause; 76, 77; 76, 84; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:evt_type; 82, integer:0; 83, identifier:str; 84, block; 84, 85; 84, 91; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:getter; 88, attribute; 88, 89; 88, 90; 89, identifier:annot; 90, identifier:get_events; 91, if_statement; 91, 92; 91, 96; 92, comparison_operator:!=; 92, 93; 92, 94; 93, identifier:chan; 94, tuple; 94, 95; 95, None; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:chan; 101, identifier:append; 102, argument_list; 102, 103; 103, string:''; 104, else_clause; 104, 105; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:lg; 110, identifier:error; 111, argument_list; 111, 112; 112, string:'Event type must be list/tuple of str or None'; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:qual; 116, None; 117, if_statement; 117, 118; 117, 119; 118, identifier:exclude; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:qual; 123, string:'Good'; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:bundles; 127, list:[]; 128, for_statement; 128, 129; 128, 130; 128, 131; 129, identifier:et; 130, identifier:evt_type; 131, block; 131, 132; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:ch; 134, identifier:chan; 135, block; 135, 136; 136, for_statement; 136, 137; 136, 138; 136, 139; 137, identifier:cyc; 138, identifier:cycle; 139, block; 139, 140; 140, for_statement; 140, 141; 140, 142; 140, 143; 141, identifier:ss; 142, identifier:stage; 143, block; 143, 144; 143, 148; 143, 158; 143, 180; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:st_input; 147, identifier:ss; 148, if_statement; 148, 149; 148, 152; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:ss; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:st_input; 156, tuple; 156, 157; 157, identifier:ss; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:evochs; 161, call; 161, 162; 161, 163; 162, identifier:getter; 163, argument_list; 163, 164; 163, 167; 163, 170; 163, 174; 163, 177; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:name; 166, identifier:et; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:time; 169, identifier:cyc; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:chan; 172, tuple; 172, 173; 173, identifier:ch; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:stage; 176, identifier:st_input; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:qual; 179, identifier:qual; 180, if_statement; 180, 181; 180, 182; 181, identifier:evochs; 182, block; 182, 183; 182, 209; 182, 224; 182, 243; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:times; 186, list_comprehension; 186, 187; 186, 206; 187, tuple; 187, 188; 187, 197; 188, call; 188, 189; 188, 190; 189, identifier:max; 190, argument_list; 190, 191; 190, 196; 191, binary_operator:-; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:e; 194, string:'start'; 195, identifier:buffer; 196, integer:0; 197, call; 197, 198; 197, 199; 198, identifier:min; 199, argument_list; 199, 200; 199, 205; 200, binary_operator:+; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:e; 203, string:'end'; 204, identifier:buffer; 205, identifier:last; 206, for_in_clause; 206, 207; 206, 208; 207, identifier:e; 208, identifier:evochs; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:times; 212, call; 212, 213; 212, 214; 213, identifier:sorted; 214, argument_list; 214, 215; 214, 216; 215, identifier:times; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:key; 218, lambda; 218, 219; 218, 221; 219, lambda_parameters; 219, 220; 220, identifier:x; 221, subscript; 221, 222; 221, 223; 222, identifier:x; 223, integer:0; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:one_bundle; 227, dictionary; 227, 228; 227, 231; 227, 234; 227, 237; 227, 240; 228, pair; 228, 229; 228, 230; 229, string:'times'; 230, identifier:times; 231, pair; 231, 232; 231, 233; 232, string:'stage'; 233, identifier:ss; 234, pair; 234, 235; 234, 236; 235, string:'cycle'; 236, identifier:cyc; 237, pair; 237, 238; 237, 239; 238, string:'chan'; 239, identifier:ch; 240, pair; 240, 241; 240, 242; 241, string:'name'; 242, identifier:et; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:bundles; 247, identifier:append; 248, argument_list; 248, 249; 249, identifier:one_bundle; 250, return_statement; 250, 251; 251, identifier:bundles | def get_times(annot, evt_type=None, stage=None, cycle=None, chan=None,
exclude=False, buffer=0):
getter = annot.get_epochs
last = annot.last_second
if stage is None:
stage = (None,)
if cycle is None:
cycle = (None,)
if chan is None:
chan = (None,)
if evt_type is None:
evt_type = (None,)
elif isinstance(evt_type[0], str):
getter = annot.get_events
if chan != (None,):
chan.append('')
else:
lg.error('Event type must be list/tuple of str or None')
qual = None
if exclude:
qual = 'Good'
bundles = []
for et in evt_type:
for ch in chan:
for cyc in cycle:
for ss in stage:
st_input = ss
if ss is not None:
st_input = (ss,)
evochs = getter(name=et, time=cyc, chan=(ch,),
stage=st_input, qual=qual)
if evochs:
times = [(
max(e['start'] - buffer, 0),
min(e['end'] + buffer, last)) for e in evochs]
times = sorted(times, key=lambda x: x[0])
one_bundle = {'times': times,
'stage': ss,
'cycle': cyc,
'chan': ch,
'name': et}
bundles.append(one_bundle)
return bundles |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:_concat; 3, parameters; 3, 4; 3, 5; 4, identifier:bundles; 5, default_parameter; 5, 6; 5, 7; 6, identifier:cat; 7, tuple; 7, 8; 7, 9; 7, 10; 7, 11; 8, integer:0; 9, integer:0; 10, integer:0; 11, integer:0; 12, block; 12, 13; 12, 29; 12, 45; 12, 61; 12, 77; 12, 81; 12, 85; 12, 89; 12, 112; 12, 128; 12, 144; 12, 154; 12, 164; 12, 174; 12, 178; 12, 299; 12, 407; 12, 419; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:chan; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:set; 21, argument_list; 21, 22; 22, list_comprehension; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:x; 25, string:'chan'; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:x; 28, identifier:bundles; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:cycle; 32, call; 32, 33; 32, 34; 33, identifier:sorted; 34, argument_list; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:set; 37, argument_list; 37, 38; 38, list_comprehension; 38, 39; 38, 42; 39, subscript; 39, 40; 39, 41; 40, identifier:x; 41, string:'cycle'; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:x; 44, identifier:bundles; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:stage; 48, call; 48, 49; 48, 50; 49, identifier:sorted; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:set; 53, argument_list; 53, 54; 54, list_comprehension; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:x; 57, string:'stage'; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:x; 60, identifier:bundles; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:evt_type; 64, call; 64, 65; 64, 66; 65, identifier:sorted; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:set; 69, argument_list; 69, 70; 70, list_comprehension; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:x; 73, string:'name'; 74, for_in_clause; 74, 75; 74, 76; 75, identifier:x; 76, identifier:bundles; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:all_cycle; 80, None; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:all_stage; 84, None; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:all_evt_type; 88, None; 89, if_statement; 89, 90; 89, 95; 90, comparison_operator:is; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:cycle; 93, integer:0; 94, None; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:all_cycle; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, string:', '; 102, identifier:join; 103, argument_list; 103, 104; 104, list_comprehension; 104, 105; 104, 109; 105, call; 105, 106; 105, 107; 106, identifier:str; 107, argument_list; 107, 108; 108, identifier:c; 109, for_in_clause; 109, 110; 109, 111; 110, identifier:c; 111, identifier:cycle; 112, if_statement; 112, 113; 112, 118; 113, comparison_operator:is; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:stage; 116, integer:0; 117, None; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:all_stage; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, string:', '; 125, identifier:join; 126, argument_list; 126, 127; 127, identifier:stage; 128, if_statement; 128, 129; 128, 134; 129, comparison_operator:is; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:evt_type; 132, integer:0; 133, None; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:all_evt_type; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, string:', '; 141, identifier:join; 142, argument_list; 142, 143; 143, identifier:evt_type; 144, if_statement; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:cat; 147, integer:0; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:cycle; 152, list:[all_cycle]; 152, 153; 153, identifier:all_cycle; 154, if_statement; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:cat; 157, integer:1; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:stage; 162, list:[all_stage]; 162, 163; 163, identifier:all_stage; 164, if_statement; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:cat; 167, integer:3; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:evt_type; 172, list:[all_evt_type]; 172, 173; 173, identifier:all_evt_type; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:to_concat; 177, list:[]; 178, for_statement; 178, 179; 178, 180; 178, 181; 179, identifier:ch; 180, identifier:chan; 181, block; 181, 182; 182, for_statement; 182, 183; 182, 184; 182, 185; 183, identifier:cyc; 184, identifier:cycle; 185, block; 185, 186; 186, for_statement; 186, 187; 186, 188; 186, 189; 187, identifier:st; 188, identifier:stage; 189, block; 189, 190; 190, for_statement; 190, 191; 190, 192; 190, 193; 191, identifier:et; 192, identifier:evt_type; 193, block; 193, 194; 193, 198; 193, 258; 193, 273; 193, 292; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:new_times; 197, list:[]; 198, for_statement; 198, 199; 198, 200; 198, 201; 199, identifier:bund; 200, identifier:bundles; 201, block; 201, 202; 201, 210; 201, 220; 201, 230; 201, 240; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:chan_cond; 205, comparison_operator:==; 205, 206; 205, 207; 206, identifier:ch; 207, subscript; 207, 208; 207, 209; 208, identifier:bund; 209, string:'chan'; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:cyc_cond; 213, comparison_operator:in; 213, 214; 213, 215; 214, identifier:cyc; 215, tuple; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:bund; 218, string:'cycle'; 219, identifier:all_cycle; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:st_cond; 223, comparison_operator:in; 223, 224; 223, 225; 224, identifier:st; 225, tuple; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:bund; 228, string:'stage'; 229, identifier:all_stage; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:et_cond; 233, comparison_operator:in; 233, 234; 233, 235; 234, identifier:et; 235, tuple; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:bund; 238, string:'name'; 239, identifier:all_evt_type; 240, if_statement; 240, 241; 240, 248; 241, boolean_operator:and; 241, 242; 241, 247; 242, boolean_operator:and; 242, 243; 242, 246; 243, boolean_operator:and; 243, 244; 243, 245; 244, identifier:chan_cond; 245, identifier:cyc_cond; 246, identifier:st_cond; 247, identifier:et_cond; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:new_times; 253, identifier:extend; 254, argument_list; 254, 255; 255, subscript; 255, 256; 255, 257; 256, identifier:bund; 257, string:'times'; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:new_times; 261, call; 261, 262; 261, 263; 262, identifier:sorted; 263, argument_list; 263, 264; 263, 265; 264, identifier:new_times; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:key; 267, lambda; 267, 268; 267, 270; 268, lambda_parameters; 268, 269; 269, identifier:x; 270, subscript; 270, 271; 270, 272; 271, identifier:x; 272, integer:0; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:new_bund; 276, dictionary; 276, 277; 276, 280; 276, 283; 276, 286; 276, 289; 277, pair; 277, 278; 277, 279; 278, string:'times'; 279, identifier:new_times; 280, pair; 280, 281; 280, 282; 281, string:'chan'; 282, identifier:ch; 283, pair; 283, 284; 283, 285; 284, string:'cycle'; 285, identifier:cyc; 286, pair; 286, 287; 286, 288; 287, string:'stage'; 288, identifier:st; 289, pair; 289, 290; 289, 291; 290, string:'name'; 291, identifier:et; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:to_concat; 296, identifier:append; 297, argument_list; 297, 298; 298, identifier:new_bund; 299, if_statement; 299, 300; 299, 304; 300, not_operator; 300, 301; 301, subscript; 301, 302; 301, 303; 302, identifier:cat; 303, integer:2; 304, block; 304, 305; 304, 309; 304, 403; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:to_concat_new; 308, list:[]; 309, for_statement; 309, 310; 309, 311; 309, 312; 310, identifier:bund; 311, identifier:to_concat; 312, block; 312, 313; 312, 317; 312, 328; 312, 332; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:last; 316, None; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 324; 319, attribute; 319, 320; 319, 323; 320, subscript; 320, 321; 320, 322; 321, identifier:bund; 322, string:'times'; 323, identifier:append; 324, argument_list; 324, 325; 325, tuple; 325, 326; 325, 327; 326, identifier:inf; 327, identifier:inf; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 331; 330, identifier:start; 331, integer:0; 332, for_statement; 332, 333; 332, 336; 332, 342; 333, pattern_list; 333, 334; 333, 335; 334, identifier:i; 335, identifier:j; 336, call; 336, 337; 336, 338; 337, identifier:enumerate; 338, argument_list; 338, 339; 339, subscript; 339, 340; 339, 341; 340, identifier:bund; 341, string:'times'; 342, block; 342, 343; 342, 397; 343, if_statement; 343, 344; 343, 347; 344, comparison_operator:is; 344, 345; 344, 346; 345, identifier:last; 346, None; 347, block; 347, 348; 348, if_statement; 348, 349; 348, 360; 349, not_operator; 349, 350; 350, call; 350, 351; 350, 352; 351, identifier:isclose; 352, argument_list; 352, 353; 352, 356; 352, 357; 353, subscript; 353, 354; 353, 355; 354, identifier:j; 355, integer:0; 356, identifier:last; 357, keyword_argument; 357, 358; 357, 359; 358, identifier:abs_tol; 359, float:0.01; 360, block; 360, 361; 360, 372; 360, 380; 360, 386; 360, 393; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 364; 363, identifier:new_times; 364, subscript; 364, 365; 364, 368; 365, subscript; 365, 366; 365, 367; 366, identifier:bund; 367, string:'times'; 368, slice; 368, 369; 368, 370; 368, 371; 369, identifier:start; 370, colon; 371, identifier:i; 372, expression_statement; 372, 373; 373, assignment; 373, 374; 373, 375; 374, identifier:new_bund; 375, call; 375, 376; 375, 379; 376, attribute; 376, 377; 376, 378; 377, identifier:bund; 378, identifier:copy; 379, argument_list; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 385; 382, subscript; 382, 383; 382, 384; 383, identifier:new_bund; 384, string:'times'; 385, identifier:new_times; 386, expression_statement; 386, 387; 387, call; 387, 388; 387, 391; 388, attribute; 388, 389; 388, 390; 389, identifier:to_concat_new; 390, identifier:append; 391, argument_list; 391, 392; 392, identifier:new_bund; 393, expression_statement; 393, 394; 394, assignment; 394, 395; 394, 396; 395, identifier:start; 396, identifier:i; 397, expression_statement; 397, 398; 398, assignment; 398, 399; 398, 400; 399, identifier:last; 400, subscript; 400, 401; 400, 402; 401, identifier:j; 402, integer:1; 403, expression_statement; 403, 404; 404, assignment; 404, 405; 404, 406; 405, identifier:to_concat; 406, identifier:to_concat_new; 407, expression_statement; 407, 408; 408, assignment; 408, 409; 408, 410; 409, identifier:to_concat; 410, list_comprehension; 410, 411; 410, 412; 410, 415; 411, identifier:x; 412, for_in_clause; 412, 413; 412, 414; 413, identifier:x; 414, identifier:to_concat; 415, if_clause; 415, 416; 416, subscript; 416, 417; 416, 418; 417, identifier:x; 418, string:'times'; 419, return_statement; 419, 420; 420, identifier:to_concat | def _concat(bundles, cat=(0, 0, 0, 0)):
chan = sorted(set([x['chan'] for x in bundles]))
cycle = sorted(set([x['cycle'] for x in bundles]))
stage = sorted(set([x['stage'] for x in bundles]))
evt_type = sorted(set([x['name'] for x in bundles]))
all_cycle = None
all_stage = None
all_evt_type = None
if cycle[0] is not None:
all_cycle = ', '.join([str(c) for c in cycle])
if stage[0] is not None:
all_stage = ', '.join(stage)
if evt_type[0] is not None:
all_evt_type = ', '.join(evt_type)
if cat[0]:
cycle = [all_cycle]
if cat[1]:
stage = [all_stage]
if cat[3]:
evt_type = [all_evt_type]
to_concat = []
for ch in chan:
for cyc in cycle:
for st in stage:
for et in evt_type:
new_times = []
for bund in bundles:
chan_cond = ch == bund['chan']
cyc_cond = cyc in (bund['cycle'], all_cycle)
st_cond = st in (bund['stage'], all_stage)
et_cond = et in (bund['name'], all_evt_type)
if chan_cond and cyc_cond and st_cond and et_cond:
new_times.extend(bund['times'])
new_times = sorted(new_times, key=lambda x: x[0])
new_bund = {'times': new_times,
'chan': ch,
'cycle': cyc,
'stage': st,
'name': et
}
to_concat.append(new_bund)
if not cat[2]:
to_concat_new = []
for bund in to_concat:
last = None
bund['times'].append((inf,inf))
start = 0
for i, j in enumerate(bund['times']):
if last is not None:
if not isclose(j[0], last, abs_tol=0.01):
new_times = bund['times'][start:i]
new_bund = bund.copy()
new_bund['times'] = new_times
to_concat_new.append(new_bund)
start = i
last = j[1]
to_concat = to_concat_new
to_concat = [x for x in to_concat if x['times']]
return to_concat |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:toggle_pac; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 93; 6, if_statement; 6, 7; 6, 10; 7, comparison_operator:is; 7, 8; 7, 9; 8, identifier:Pac; 9, None; 10, block; 10, 11; 10, 23; 10, 34; 10, 45; 10, 56; 10, 67; 10, 78; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:pac_on; 14, call; 14, 15; 14, 22; 15, attribute; 15, 16; 15, 21; 16, subscript; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:pac; 20, string:'pac_on'; 21, identifier:get_value; 22, argument_list; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 32; 25, attribute; 25, 26; 25, 31; 26, subscript; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:pac; 30, string:'prep'; 31, identifier:setEnabled; 32, argument_list; 32, 33; 33, identifier:pac_on; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 43; 36, attribute; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:pac; 41, string:'box_metric'; 42, identifier:setEnabled; 43, argument_list; 43, 44; 44, identifier:pac_on; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 54; 47, attribute; 47, 48; 47, 53; 48, subscript; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:pac; 52, string:'box_complex'; 53, identifier:setEnabled; 54, argument_list; 54, 55; 55, identifier:pac_on; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 65; 58, attribute; 58, 59; 58, 64; 59, subscript; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:pac; 63, string:'box_surro'; 64, identifier:setEnabled; 65, argument_list; 65, 66; 66, identifier:pac_on; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 76; 69, attribute; 69, 70; 69, 75; 70, subscript; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:pac; 74, string:'box_opts'; 75, identifier:setEnabled; 76, argument_list; 76, 77; 77, identifier:pac_on; 78, if_statement; 78, 79; 78, 81; 79, not_operator; 79, 80; 80, identifier:pac_on; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 91; 84, attribute; 84, 85; 84, 90; 85, subscript; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:pac; 89, string:'prep'; 90, identifier:set_value; 91, argument_list; 91, 92; 92, False; 93, if_statement; 93, 94; 93, 99; 94, boolean_operator:and; 94, 95; 94, 98; 95, comparison_operator:is; 95, 96; 95, 97; 96, identifier:Pac; 97, None; 98, identifier:pac_on; 99, block; 99, 100; 99, 106; 99, 116; 99, 126; 99, 161; 99, 172; 99, 183; 99, 242; 99, 297; 99, 309; 99, 328; 99, 340; 99, 352; 99, 362; 99, 401; 99, 414; 99, 427; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:pac; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:pac; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:hilb_on; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:pac; 113, string:'hilbert_on'; 114, identifier:isChecked; 115, argument_list; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:wav_on; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:pac; 123, string:'wavelet_on'; 124, identifier:isChecked; 125, argument_list; 126, for_statement; 126, 127; 126, 128; 126, 135; 127, identifier:button; 128, call; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:pac; 132, string:'hilbert'; 133, identifier:values; 134, argument_list; 135, block; 135, 136; 135, 145; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:button; 141, integer:0; 142, identifier:setEnabled; 143, argument_list; 143, 144; 144, identifier:hilb_on; 145, if_statement; 145, 146; 145, 151; 146, comparison_operator:is; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:button; 149, integer:1; 150, None; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:button; 157, integer:1; 158, identifier:setEnabled; 159, argument_list; 159, 160; 160, identifier:hilb_on; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 170; 163, attribute; 163, 164; 163, 169; 164, subscript; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:pac; 167, string:'wav_width'; 168, integer:0; 169, identifier:setEnabled; 170, argument_list; 170, 171; 171, identifier:wav_on; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 181; 174, attribute; 174, 175; 174, 180; 175, subscript; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:pac; 178, string:'wav_width'; 179, integer:1; 180, identifier:setEnabled; 181, argument_list; 181, 182; 182, identifier:wav_on; 183, if_statement; 183, 184; 183, 195; 183, 218; 184, comparison_operator:in; 184, 185; 184, 192; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:pac; 189, string:'metric'; 190, identifier:get_value; 191, argument_list; 192, list:[
'Kullback-Leibler Distance',
'Heights ratio']; 192, 193; 192, 194; 193, string:'Kullback-Leibler Distance'; 194, string:'Heights ratio'; 195, block; 195, 196; 195, 207; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 205; 198, attribute; 198, 199; 198, 204; 199, subscript; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:pac; 202, string:'nbin'; 203, integer:0; 204, identifier:setEnabled; 205, argument_list; 205, 206; 206, True; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 216; 209, attribute; 209, 210; 209, 215; 210, subscript; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:pac; 213, string:'nbin'; 214, integer:1; 215, identifier:setEnabled; 216, argument_list; 216, 217; 217, True; 218, else_clause; 218, 219; 219, block; 219, 220; 219, 231; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 229; 222, attribute; 222, 223; 222, 228; 223, subscript; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:pac; 226, string:'nbin'; 227, integer:0; 228, identifier:setEnabled; 229, argument_list; 229, 230; 230, False; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 240; 233, attribute; 233, 234; 233, 239; 234, subscript; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:pac; 237, string:'nbin'; 238, integer:1; 239, identifier:setEnabled; 240, argument_list; 240, 241; 241, False; 242, if_statement; 242, 243; 242, 248; 243, comparison_operator:==; 243, 244; 243, 247; 244, subscript; 244, 245; 244, 246; 245, identifier:pac; 246, string:'metric'; 247, string:'ndPac'; 248, block; 248, 249; 248, 284; 249, for_statement; 249, 250; 249, 251; 249, 258; 250, identifier:button; 251, call; 251, 252; 251, 257; 252, attribute; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:pac; 255, string:'surro'; 256, identifier:values; 257, argument_list; 258, block; 258, 259; 258, 268; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 266; 261, attribute; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:button; 264, integer:0; 265, identifier:setEnabled; 266, argument_list; 266, 267; 267, False; 268, if_statement; 268, 269; 268, 274; 269, comparison_operator:is; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:button; 272, integer:1; 273, None; 274, block; 274, 275; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, subscript; 278, 279; 278, 280; 279, identifier:button; 280, integer:1; 281, identifier:setEnabled; 282, argument_list; 282, 283; 283, False; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 295; 286, attribute; 286, 287; 286, 294; 287, subscript; 287, 288; 287, 293; 288, subscript; 288, 289; 288, 292; 289, subscript; 289, 290; 289, 291; 290, identifier:pac; 291, string:'surro'; 292, string:'pval'; 293, integer:0; 294, identifier:setEnabled; 295, argument_list; 295, 296; 296, True; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:ndpac_on; 300, comparison_operator:==; 300, 301; 300, 308; 301, call; 301, 302; 301, 307; 302, attribute; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:pac; 305, string:'metric'; 306, identifier:get_value; 307, argument_list; 308, string:'ndPac'; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:surro_on; 312, call; 312, 313; 312, 314; 313, identifier:logical_and; 314, argument_list; 314, 315; 314, 326; 315, comparison_operator:!=; 315, 316; 315, 323; 316, call; 316, 317; 316, 322; 317, attribute; 317, 318; 317, 321; 318, subscript; 318, 319; 318, 320; 319, identifier:pac; 320, string:'surro_method'; 321, identifier:get_value; 322, argument_list; 323, concatenated_string; 323, 324; 323, 325; 324, string:''; 325, string:'No surrogates'; 326, not_operator; 326, 327; 327, identifier:ndpac_on; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 331; 330, identifier:norm_on; 331, comparison_operator:!=; 331, 332; 331, 339; 332, call; 332, 333; 332, 338; 333, attribute; 333, 334; 333, 337; 334, subscript; 334, 335; 334, 336; 335, identifier:pac; 336, string:'surro_norm'; 337, identifier:get_value; 338, argument_list; 339, string:'No normalization'; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:blocks_on; 343, comparison_operator:in; 343, 344; 343, 345; 344, string:'across time'; 345, call; 345, 346; 345, 351; 346, attribute; 346, 347; 346, 350; 347, subscript; 347, 348; 347, 349; 348, identifier:pac; 349, string:'surro_method'; 350, identifier:get_value; 351, argument_list; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 359; 354, attribute; 354, 355; 354, 358; 355, subscript; 355, 356; 355, 357; 356, identifier:pac; 357, string:'surro_method'; 358, identifier:setEnabled; 359, argument_list; 359, 360; 360, not_operator; 360, 361; 361, identifier:ndpac_on; 362, for_statement; 362, 363; 362, 364; 362, 371; 363, identifier:button; 364, call; 364, 365; 364, 370; 365, attribute; 365, 366; 365, 369; 366, subscript; 366, 367; 366, 368; 367, identifier:pac; 368, string:'surro'; 369, identifier:values; 370, argument_list; 371, block; 371, 372; 371, 383; 372, expression_statement; 372, 373; 373, call; 373, 374; 373, 379; 374, attribute; 374, 375; 374, 378; 375, subscript; 375, 376; 375, 377; 376, identifier:button; 377, integer:0; 378, identifier:setEnabled; 379, argument_list; 379, 380; 380, boolean_operator:and; 380, 381; 380, 382; 381, identifier:surro_on; 382, identifier:norm_on; 383, if_statement; 383, 384; 383, 389; 384, comparison_operator:is; 384, 385; 384, 388; 385, subscript; 385, 386; 385, 387; 386, identifier:button; 387, integer:1; 388, None; 389, block; 389, 390; 390, expression_statement; 390, 391; 391, call; 391, 392; 391, 397; 392, attribute; 392, 393; 392, 396; 393, subscript; 393, 394; 393, 395; 394, identifier:button; 395, integer:1; 396, identifier:setEnabled; 397, argument_list; 397, 398; 398, boolean_operator:and; 398, 399; 398, 400; 399, identifier:surro_on; 400, identifier:norm_on; 401, expression_statement; 401, 402; 402, call; 402, 403; 402, 412; 403, attribute; 403, 404; 403, 411; 404, subscript; 404, 405; 404, 410; 405, subscript; 405, 406; 405, 409; 406, subscript; 406, 407; 406, 408; 407, identifier:pac; 408, string:'surro'; 409, string:'nblocks'; 410, integer:0; 411, identifier:setEnabled; 412, argument_list; 412, 413; 413, identifier:blocks_on; 414, expression_statement; 414, 415; 415, call; 415, 416; 415, 425; 416, attribute; 416, 417; 416, 424; 417, subscript; 417, 418; 417, 423; 418, subscript; 418, 419; 418, 422; 419, subscript; 419, 420; 419, 421; 420, identifier:pac; 421, string:'surro'; 422, string:'nblocks'; 423, integer:1; 424, identifier:setEnabled; 425, argument_list; 425, 426; 426, identifier:blocks_on; 427, if_statement; 427, 428; 427, 429; 428, identifier:ndpac_on; 429, block; 429, 430; 429, 439; 430, expression_statement; 430, 431; 431, call; 431, 432; 431, 437; 432, attribute; 432, 433; 432, 436; 433, subscript; 433, 434; 433, 435; 434, identifier:pac; 435, string:'surro_method'; 436, identifier:set_value; 437, argument_list; 437, 438; 438, string:'No surrogates'; 439, expression_statement; 439, 440; 440, call; 440, 441; 440, 450; 441, attribute; 441, 442; 441, 449; 442, subscript; 442, 443; 442, 448; 443, subscript; 443, 444; 443, 447; 444, subscript; 444, 445; 444, 446; 445, identifier:pac; 446, string:'surro'; 447, string:'pval'; 448, integer:0; 449, identifier:setEnabled; 450, argument_list; 450, 451; 451, True | def toggle_pac(self):
if Pac is not None:
pac_on = self.pac['pac_on'].get_value()
self.pac['prep'].setEnabled(pac_on)
self.pac['box_metric'].setEnabled(pac_on)
self.pac['box_complex'].setEnabled(pac_on)
self.pac['box_surro'].setEnabled(pac_on)
self.pac['box_opts'].setEnabled(pac_on)
if not pac_on:
self.pac['prep'].set_value(False)
if Pac is not None and pac_on:
pac = self.pac
hilb_on = pac['hilbert_on'].isChecked()
wav_on = pac['wavelet_on'].isChecked()
for button in pac['hilbert'].values():
button[0].setEnabled(hilb_on)
if button[1] is not None:
button[1].setEnabled(hilb_on)
pac['wav_width'][0].setEnabled(wav_on)
pac['wav_width'][1].setEnabled(wav_on)
if pac['metric'].get_value() in [
'Kullback-Leibler Distance',
'Heights ratio']:
pac['nbin'][0].setEnabled(True)
pac['nbin'][1].setEnabled(True)
else:
pac['nbin'][0].setEnabled(False)
pac['nbin'][1].setEnabled(False)
if pac['metric'] == 'ndPac':
for button in pac['surro'].values():
button[0].setEnabled(False)
if button[1] is not None:
button[1].setEnabled(False)
pac['surro']['pval'][0].setEnabled(True)
ndpac_on = pac['metric'].get_value() == 'ndPac'
surro_on = logical_and(pac['surro_method'].get_value() != ''
'No surrogates', not ndpac_on)
norm_on = pac['surro_norm'].get_value() != 'No normalization'
blocks_on = 'across time' in pac['surro_method'].get_value()
pac['surro_method'].setEnabled(not ndpac_on)
for button in pac['surro'].values():
button[0].setEnabled(surro_on and norm_on)
if button[1] is not None:
button[1].setEnabled(surro_on and norm_on)
pac['surro']['nblocks'][0].setEnabled(blocks_on)
pac['surro']['nblocks'][1].setEnabled(blocks_on)
if ndpac_on:
pac['surro_method'].set_value('No surrogates')
pac['surro']['pval'][0].setEnabled(True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_segments; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 28; 5, 38; 5, 50; 5, 62; 5, 66; 5, 70; 5, 120; 5, 130; 5, 137; 5, 141; 5, 145; 5, 212; 5, 224; 5, 234; 5, 270; 5, 292; 5, 320; 5, 330; 5, 378; 5, 388; 5, 398; 5, 412; 5, 468; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:chunk; 9, dictionary_comprehension; 9, 10; 9, 17; 10, pair; 10, 11; 10, 12; 11, identifier:k; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:v; 15, identifier:isChecked; 16, argument_list; 17, for_in_clause; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:k; 20, identifier:v; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:chunk; 26, identifier:items; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:lock_to_staging; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:lock_to_staging; 36, identifier:get_value; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:epoch_dur; 41, call; 41, 42; 41, 49; 42, attribute; 42, 43; 42, 48; 43, subscript; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:epoch_param; 47, string:'dur'; 48, identifier:get_value; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:epoch_overlap; 53, call; 53, 54; 53, 61; 54, attribute; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:epoch_param; 59, string:'overlap_val'; 60, identifier:value; 61, argument_list; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:epoch_step; 65, None; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:epoch; 69, None; 70, if_statement; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:chunk; 73, string:'epoch'; 74, block; 74, 75; 75, if_statement; 75, 76; 75, 77; 75, 82; 76, identifier:lock_to_staging; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:epoch; 81, string:'locked'; 82, else_clause; 82, 83; 83, block; 83, 84; 83, 88; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:epoch; 87, string:'unlocked'; 88, if_statement; 88, 89; 88, 98; 89, call; 89, 90; 89, 97; 90, attribute; 90, 91; 90, 96; 91, subscript; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:epoch_param; 95, string:'step'; 96, identifier:isChecked; 97, argument_list; 98, block; 98, 99; 98, 111; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:epoch_step; 102, call; 102, 103; 102, 110; 103, attribute; 103, 104; 103, 109; 104, subscript; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:epoch_param; 108, string:'step_val'; 109, identifier:get_value; 110, argument_list; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:<=; 112, 113; 112, 114; 113, identifier:epoch_step; 114, integer:0; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:epoch_step; 119, float:0.1; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:chan; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:get_channels; 129, argument_list; 130, if_statement; 130, 131; 130, 135; 131, not_operator; 131, 132; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:chan; 135, block; 135, 136; 136, return_statement; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:chan_full; 140, None; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:evt_type; 144, None; 145, if_statement; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:chunk; 148, string:'event'; 149, block; 149, 150; 149, 183; 149, 193; 150, if_statement; 150, 151; 150, 158; 151, call; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:evt_chan_only; 156, identifier:get_value; 157, argument_list; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:chan_full; 162, list_comprehension; 162, 163; 162, 178; 163, binary_operator:+; 163, 164; 163, 175; 164, binary_operator:+; 164, 165; 164, 168; 165, binary_operator:+; 165, 166; 165, 167; 166, identifier:i; 167, string:' ('; 168, call; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:idx_group; 173, identifier:currentText; 174, argument_list; 175, concatenated_string; 175, 176; 175, 177; 176, string:''; 177, string:')'; 178, for_in_clause; 178, 179; 178, 180; 179, identifier:i; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:chan; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:evt_type; 186, call; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:idx_evt_type; 191, identifier:selectedItems; 192, argument_list; 193, if_statement; 193, 194; 193, 196; 193, 198; 194, not_operator; 194, 195; 195, identifier:evt_type; 196, block; 196, 197; 197, return_statement; 198, else_clause; 198, 199; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:evt_type; 203, list_comprehension; 203, 204; 203, 209; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:x; 207, identifier:text; 208, argument_list; 209, for_in_clause; 209, 210; 209, 211; 210, identifier:x; 211, identifier:evt_type; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:cycle; 215, assignment; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:cycle; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:get_cycles; 223, argument_list; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:stage; 227, call; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:idx_stage; 232, identifier:selectedItems; 233, argument_list; 234, if_statement; 234, 235; 234, 237; 234, 246; 235, not_operator; 235, 236; 236, identifier:stage; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:stage; 241, assignment; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:self; 244, identifier:stage; 245, None; 246, else_clause; 246, 247; 247, block; 247, 248; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:stage; 251, assignment; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:stage; 255, list_comprehension; 255, 256; 255, 261; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:x; 259, identifier:text; 260, argument_list; 261, for_in_clause; 261, 262; 261, 263; 262, identifier:x; 263, call; 263, 264; 263, 269; 264, attribute; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:idx_stage; 268, identifier:selectedItems; 269, argument_list; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:cat; 273, dictionary_comprehension; 273, 274; 273, 281; 274, pair; 274, 275; 274, 276; 275, identifier:k; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:v; 279, identifier:get_value; 280, argument_list; 281, for_in_clause; 281, 282; 281, 285; 282, pattern_list; 282, 283; 282, 284; 283, identifier:k; 284, identifier:v; 285, call; 285, 286; 285, 291; 286, attribute; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:self; 289, identifier:cat; 290, identifier:items; 291, argument_list; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:cat; 295, tuple; 295, 296; 295, 302; 295, 308; 295, 314; 296, call; 296, 297; 296, 298; 297, identifier:int; 298, argument_list; 298, 299; 299, subscript; 299, 300; 299, 301; 300, identifier:cat; 301, string:'cycle'; 302, call; 302, 303; 302, 304; 303, identifier:int; 304, argument_list; 304, 305; 305, subscript; 305, 306; 305, 307; 306, identifier:cat; 307, string:'stage'; 308, call; 308, 309; 308, 310; 309, identifier:int; 310, argument_list; 310, 311; 311, subscript; 311, 312; 311, 313; 312, identifier:cat; 313, string:'discontinuous'; 314, call; 314, 315; 314, 316; 315, identifier:int; 316, argument_list; 316, 317; 317, subscript; 317, 318; 317, 319; 318, identifier:cat; 319, string:'evt_type'; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:reject_event; 323, call; 323, 324; 323, 329; 324, attribute; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:self; 327, identifier:reject_event; 328, identifier:get_value; 329, argument_list; 330, if_statement; 330, 331; 330, 334; 330, 363; 330, 372; 331, comparison_operator:==; 331, 332; 331, 333; 332, identifier:reject_event; 333, string:'channel-specific'; 334, block; 334, 335; 334, 359; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:chan_full; 338, list_comprehension; 338, 339; 338, 354; 339, binary_operator:+; 339, 340; 339, 351; 340, binary_operator:+; 340, 341; 340, 344; 341, binary_operator:+; 341, 342; 341, 343; 342, identifier:i; 343, string:' ('; 344, call; 344, 345; 344, 350; 345, attribute; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:self; 348, identifier:idx_group; 349, identifier:currentText; 350, argument_list; 351, concatenated_string; 351, 352; 351, 353; 352, string:''; 353, string:')'; 354, for_in_clause; 354, 355; 354, 356; 355, identifier:i; 356, attribute; 356, 357; 356, 358; 357, identifier:self; 358, identifier:chan; 359, expression_statement; 359, 360; 360, assignment; 360, 361; 360, 362; 361, identifier:reject_artf; 362, True; 363, elif_clause; 363, 364; 363, 367; 364, comparison_operator:==; 364, 365; 364, 366; 365, identifier:reject_event; 366, string:'from any channel'; 367, block; 367, 368; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:reject_artf; 371, True; 372, else_clause; 372, 373; 373, block; 373, 374; 374, expression_statement; 374, 375; 375, assignment; 375, 376; 375, 377; 376, identifier:reject_artf; 377, False; 378, expression_statement; 378, 379; 379, assignment; 379, 380; 379, 381; 380, identifier:min_dur; 381, call; 381, 382; 381, 387; 382, attribute; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:self; 385, identifier:min_dur; 386, identifier:get_value; 387, argument_list; 388, expression_statement; 388, 389; 389, assignment; 389, 390; 389, 391; 390, identifier:reject_epoch; 391, call; 391, 392; 391, 397; 392, attribute; 392, 393; 392, 396; 393, attribute; 393, 394; 393, 395; 394, identifier:self; 395, identifier:reject_epoch; 396, identifier:get_value; 397, argument_list; 398, expression_statement; 398, 399; 399, assignment; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:self; 402, identifier:title; 403, call; 403, 404; 403, 407; 404, attribute; 404, 405; 404, 406; 405, identifier:self; 406, identifier:make_title; 407, argument_list; 407, 408; 407, 409; 407, 410; 407, 411; 408, identifier:chan_full; 409, identifier:cycle; 410, identifier:stage; 411, identifier:evt_type; 412, expression_statement; 412, 413; 413, assignment; 413, 414; 413, 415; 414, identifier:segments; 415, call; 415, 416; 415, 417; 416, identifier:fetch; 417, argument_list; 417, 418; 417, 425; 417, 432; 417, 435; 417, 438; 417, 441; 417, 444; 417, 447; 417, 450; 417, 453; 417, 456; 417, 459; 417, 462; 417, 465; 418, attribute; 418, 419; 418, 424; 419, attribute; 419, 420; 419, 423; 420, attribute; 420, 421; 420, 422; 421, identifier:self; 422, identifier:parent; 423, identifier:info; 424, identifier:dataset; 425, attribute; 425, 426; 425, 431; 426, attribute; 426, 427; 426, 430; 427, attribute; 427, 428; 427, 429; 428, identifier:self; 429, identifier:parent; 430, identifier:notes; 431, identifier:annot; 432, keyword_argument; 432, 433; 432, 434; 433, identifier:cat; 434, identifier:cat; 435, keyword_argument; 435, 436; 435, 437; 436, identifier:evt_type; 437, identifier:evt_type; 438, keyword_argument; 438, 439; 438, 440; 439, identifier:stage; 440, identifier:stage; 441, keyword_argument; 441, 442; 441, 443; 442, identifier:cycle; 443, identifier:cycle; 444, keyword_argument; 444, 445; 444, 446; 445, identifier:chan_full; 446, identifier:chan_full; 447, keyword_argument; 447, 448; 447, 449; 448, identifier:epoch; 449, identifier:epoch; 450, keyword_argument; 450, 451; 450, 452; 451, identifier:epoch_dur; 452, identifier:epoch_dur; 453, keyword_argument; 453, 454; 453, 455; 454, identifier:epoch_overlap; 455, identifier:epoch_overlap; 456, keyword_argument; 456, 457; 456, 458; 457, identifier:epoch_step; 458, identifier:epoch_step; 459, keyword_argument; 459, 460; 459, 461; 460, identifier:reject_epoch; 461, identifier:reject_epoch; 462, keyword_argument; 462, 463; 462, 464; 463, identifier:reject_artf; 464, identifier:reject_artf; 465, keyword_argument; 465, 466; 465, 467; 466, identifier:min_dur; 467, identifier:min_dur; 468, return_statement; 468, 469; 469, identifier:segments | def get_segments(self):
chunk = {k: v.isChecked() for k, v in self.chunk.items()}
lock_to_staging = self.lock_to_staging.get_value()
epoch_dur = self.epoch_param['dur'].get_value()
epoch_overlap = self.epoch_param['overlap_val'].value()
epoch_step = None
epoch = None
if chunk['epoch']:
if lock_to_staging:
epoch = 'locked'
else:
epoch = 'unlocked'
if self.epoch_param['step'].isChecked():
epoch_step = self.epoch_param['step_val'].get_value()
if epoch_step <= 0:
epoch_step = 0.1
self.chan = self.get_channels()
if not self.chan:
return
chan_full = None
evt_type = None
if chunk['event']:
if self.evt_chan_only.get_value():
chan_full = [i + ' (' + self.idx_group.currentText() + ''
')' for i in self.chan]
evt_type = self.idx_evt_type.selectedItems()
if not evt_type:
return
else:
evt_type = [x.text() for x in evt_type]
cycle = self.cycle = self.get_cycles()
stage = self.idx_stage.selectedItems()
if not stage:
stage = self.stage = None
else:
stage = self.stage = [
x.text() for x in self.idx_stage.selectedItems()]
cat = {k: v.get_value() for k, v in self.cat.items()}
cat = (int(cat['cycle']), int(cat['stage']),
int(cat['discontinuous']), int(cat['evt_type']))
reject_event = self.reject_event.get_value()
if reject_event == 'channel-specific':
chan_full = [i + ' (' + self.idx_group.currentText() + ''
')' for i in self.chan]
reject_artf = True
elif reject_event == 'from any channel':
reject_artf = True
else:
reject_artf = False
min_dur = self.min_dur.get_value()
reject_epoch = self.reject_epoch.get_value()
self.title = self.make_title(chan_full, cycle, stage, evt_type)
segments = fetch(self.parent.info.dataset,
self.parent.notes.annot, cat=cat,
evt_type=evt_type, stage=stage, cycle=cycle,
chan_full=chan_full, epoch=epoch,
epoch_dur=epoch_dur, epoch_overlap=epoch_overlap,
epoch_step=epoch_step, reject_epoch=reject_epoch,
reject_artf=reject_artf, min_dur=min_dur)
return segments |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:compute_evt_params; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 34; 5, 58; 5, 82; 5, 104; 5, 114; 5, 124; 5, 132; 5, 138; 5, 153; 5, 175; 5, 179; 5, 183; 5, 197; 5, 270; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ev; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:event; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:glob; 15, dictionary_comprehension; 15, 16; 15, 23; 16, pair; 16, 17; 16, 18; 17, identifier:k; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:v; 21, identifier:get_value; 22, argument_list; 23, for_in_clause; 23, 24; 23, 27; 24, pattern_list; 24, 25; 24, 26; 25, identifier:k; 26, identifier:v; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:ev; 31, string:'global'; 32, identifier:items; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:params; 37, dictionary_comprehension; 37, 38; 37, 47; 38, pair; 38, 39; 38, 40; 39, identifier:k; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:v; 44, integer:0; 45, identifier:get_value; 46, argument_list; 47, for_in_clause; 47, 48; 47, 51; 48, pattern_list; 48, 49; 48, 50; 49, identifier:k; 50, identifier:v; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:ev; 55, string:'local'; 56, identifier:items; 57, argument_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:prep; 61, dictionary_comprehension; 61, 62; 61, 71; 62, pair; 62, 63; 62, 64; 63, identifier:k; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:v; 68, integer:1; 69, identifier:get_value; 70, argument_list; 71, for_in_clause; 71, 72; 71, 75; 72, pattern_list; 72, 73; 72, 74; 73, identifier:k; 74, identifier:v; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:ev; 79, string:'local'; 80, identifier:items; 81, argument_list; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:slopes; 85, dictionary_comprehension; 85, 86; 85, 93; 86, pair; 86, 87; 86, 88; 87, identifier:k; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:v; 91, identifier:get_value; 92, argument_list; 93, for_in_clause; 93, 94; 93, 97; 94, pattern_list; 94, 95; 94, 96; 95, identifier:k; 96, identifier:v; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:ev; 101, string:'sw'; 102, identifier:items; 103, argument_list; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:f1; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:ev; 111, string:'f1'; 112, identifier:get_value; 113, argument_list; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:f2; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:ev; 121, string:'f2'; 122, identifier:get_value; 123, argument_list; 124, if_statement; 124, 125; 124, 127; 125, not_operator; 125, 126; 126, identifier:f2; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:f2; 131, None; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:band; 135, tuple; 135, 136; 135, 137; 136, identifier:f1; 137, identifier:f2; 138, if_statement; 138, 139; 138, 148; 139, not_operator; 139, 140; 140, parenthesized_expression; 140, 141; 141, boolean_operator:or; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:slopes; 144, string:'avg_slope'; 145, subscript; 145, 146; 145, 147; 146, identifier:slopes; 147, string:'max_slope'; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:slopes; 152, None; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:evt_dat; 156, call; 156, 157; 156, 158; 157, identifier:event_params; 158, argument_list; 158, 159; 158, 162; 158, 163; 158, 166; 158, 169; 158, 172; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:data; 162, identifier:params; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:band; 165, identifier:band; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:slopes; 168, identifier:slopes; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:prep; 171, identifier:prep; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:parent; 174, identifier:self; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:count; 178, None; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:density; 182, None; 183, if_statement; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:glob; 186, string:'count'; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:count; 191, call; 191, 192; 191, 193; 192, identifier:len; 193, argument_list; 193, 194; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:data; 197, if_statement; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:glob; 200, string:'density'; 201, block; 201, 202; 201, 208; 201, 234; 201, 256; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:epoch_dur; 205, subscript; 205, 206; 205, 207; 206, identifier:glob; 207, string:'density_per'; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:poi; 211, call; 211, 212; 211, 213; 212, identifier:get_times; 213, argument_list; 213, 214; 213, 221; 213, 226; 213, 231; 214, attribute; 214, 215; 214, 220; 215, attribute; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:parent; 219, identifier:notes; 220, identifier:annot; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:stage; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:stage; 226, keyword_argument; 226, 227; 226, 228; 227, identifier:cycle; 228, attribute; 228, 229; 228, 230; 229, identifier:self; 230, identifier:cycle; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:exclude; 233, True; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:total_dur; 237, call; 237, 238; 237, 239; 238, identifier:sum; 239, argument_list; 239, 240; 240, list_comprehension; 240, 241; 240, 248; 240, 251; 241, binary_operator:-; 241, 242; 241, 245; 242, subscript; 242, 243; 242, 244; 243, identifier:x; 244, integer:1; 245, subscript; 245, 246; 245, 247; 246, identifier:x; 247, integer:0; 248, for_in_clause; 248, 249; 248, 250; 249, identifier:y; 250, identifier:poi; 251, for_in_clause; 251, 252; 251, 253; 252, identifier:x; 253, subscript; 253, 254; 253, 255; 254, identifier:y; 255, string:'times'; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:density; 259, binary_operator:/; 259, 260; 259, 266; 260, call; 260, 261; 260, 262; 261, identifier:len; 262, argument_list; 262, 263; 263, attribute; 263, 264; 263, 265; 264, identifier:self; 265, identifier:data; 266, parenthesized_expression; 266, 267; 267, binary_operator:/; 267, 268; 267, 269; 268, identifier:total_dur; 269, identifier:epoch_dur; 270, return_statement; 270, 271; 271, expression_list; 271, 272; 271, 273; 271, 274; 272, identifier:evt_dat; 273, identifier:count; 274, identifier:density | def compute_evt_params(self):
ev = self.event
glob = {k: v.get_value() for k, v in ev['global'].items()}
params = {k: v[0].get_value() for k, v in ev['local'].items()}
prep = {k: v[1].get_value() for k, v in ev['local'].items()}
slopes = {k: v.get_value() for k, v in ev['sw'].items()}
f1 = ev['f1'].get_value()
f2 = ev['f2'].get_value()
if not f2:
f2 = None
band = (f1, f2)
if not (slopes['avg_slope'] or slopes['max_slope']):
slopes = None
evt_dat = event_params(self.data, params, band=band, slopes=slopes,
prep=prep, parent=self)
count = None
density = None
if glob['count']:
count = len(self.data)
if glob['density']:
epoch_dur = glob['density_per']
poi = get_times(self.parent.notes.annot, stage=self.stage,
cycle=self.cycle, exclude=True)
total_dur = sum([x[1] - x[0] for y in poi for x in y['times']])
density = len(self.data) / (total_dur / epoch_dur)
return evt_dat, count, density |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:detect_format; 3, parameters; 3, 4; 4, identifier:filename; 5, block; 5, 6; 5, 13; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:filename; 9, call; 9, 10; 9, 11; 10, identifier:Path; 11, argument_list; 11, 12; 12, identifier:filename; 13, if_statement; 13, 14; 13, 19; 13, 105; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:filename; 17, identifier:is_dir; 18, argument_list; 19, block; 19, 20; 20, if_statement; 20, 21; 20, 40; 20, 43; 20, 55; 20, 67; 20, 80; 20, 93; 21, boolean_operator:and; 21, 22; 21, 31; 22, call; 22, 23; 22, 24; 23, identifier:list; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:filename; 28, identifier:glob; 29, argument_list; 29, 30; 30, string:'*.stc'; 31, call; 31, 32; 31, 33; 32, identifier:list; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:filename; 37, identifier:glob; 38, argument_list; 38, 39; 39, string:'*.erd'; 40, block; 40, 41; 41, return_statement; 41, 42; 42, identifier:Ktlx; 43, elif_clause; 43, 44; 43, 52; 44, call; 44, 45; 44, 51; 45, attribute; 45, 46; 45, 50; 46, parenthesized_expression; 46, 47; 47, binary_operator:/; 47, 48; 47, 49; 48, identifier:filename; 49, string:'patient.info'; 50, identifier:exists; 51, argument_list; 52, block; 52, 53; 53, return_statement; 53, 54; 54, identifier:Moberg; 55, elif_clause; 55, 56; 55, 64; 56, call; 56, 57; 56, 63; 57, attribute; 57, 58; 57, 62; 58, parenthesized_expression; 58, 59; 59, binary_operator:/; 59, 60; 59, 61; 60, identifier:filename; 61, string:'info.xml'; 62, identifier:exists; 63, argument_list; 64, block; 64, 65; 65, return_statement; 65, 66; 66, identifier:EgiMff; 67, elif_clause; 67, 68; 67, 77; 68, call; 68, 69; 68, 70; 69, identifier:list; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:filename; 74, identifier:glob; 75, argument_list; 75, 76; 76, string:'*.openephys'; 77, block; 77, 78; 78, return_statement; 78, 79; 79, identifier:OpenEphys; 80, elif_clause; 80, 81; 80, 90; 81, call; 81, 82; 81, 83; 82, identifier:list; 83, argument_list; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:filename; 87, identifier:glob; 88, argument_list; 88, 89; 89, string:'*.txt'; 90, block; 90, 91; 91, return_statement; 91, 92; 92, identifier:Text; 93, else_clause; 93, 94; 94, block; 94, 95; 95, raise_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:UnrecognizedFormat; 98, argument_list; 98, 99; 99, binary_operator:+; 99, 100; 99, 101; 100, string:'Unrecognized format for directory '; 101, call; 101, 102; 101, 103; 102, identifier:str; 103, argument_list; 103, 104; 104, identifier:filename; 105, else_clause; 105, 106; 106, block; 106, 107; 106, 116; 106, 129; 106, 138; 106, 147; 106, 156; 106, 171; 106, 195; 106, 238; 107, if_statement; 107, 108; 107, 113; 108, comparison_operator:==; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:filename; 111, identifier:suffix; 112, string:'.won'; 113, block; 113, 114; 114, return_statement; 114, 115; 115, identifier:Wonambi; 116, if_statement; 116, 117; 116, 126; 117, comparison_operator:==; 117, 118; 117, 125; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:filename; 122, identifier:suffix; 123, identifier:lower; 124, argument_list; 125, string:'.trc'; 126, block; 126, 127; 127, return_statement; 127, 128; 128, identifier:Micromed; 129, if_statement; 129, 130; 129, 135; 130, comparison_operator:==; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:filename; 133, identifier:suffix; 134, string:'.set'; 135, block; 135, 136; 136, return_statement; 136, 137; 137, identifier:EEGLAB; 138, if_statement; 138, 139; 138, 144; 139, comparison_operator:==; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:filename; 142, identifier:suffix; 143, string:'.edf'; 144, block; 144, 145; 145, return_statement; 145, 146; 146, identifier:Edf; 147, if_statement; 147, 148; 147, 153; 148, comparison_operator:==; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:filename; 151, identifier:suffix; 152, string:'.abf'; 153, block; 153, 154; 154, return_statement; 154, 155; 155, identifier:Abf; 156, if_statement; 156, 157; 156, 168; 157, boolean_operator:or; 157, 158; 157, 163; 158, comparison_operator:==; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:filename; 161, identifier:suffix; 162, string:'.vhdr'; 163, comparison_operator:==; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:filename; 166, identifier:suffix; 167, string:'.eeg'; 168, block; 168, 169; 169, return_statement; 169, 170; 170, identifier:BrainVision; 171, if_statement; 171, 172; 171, 177; 172, comparison_operator:==; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:filename; 175, identifier:suffix; 176, string:'.dat'; 177, block; 177, 178; 178, try_statement; 178, 179; 178, 185; 178, 191; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:_read_header_length; 183, argument_list; 183, 184; 184, identifier:filename; 185, except_clause; 185, 186; 185, 189; 186, tuple; 186, 187; 186, 188; 187, identifier:AttributeError; 188, identifier:ValueError; 189, block; 189, 190; 190, pass_statement; 191, else_clause; 191, 192; 192, block; 192, 193; 193, return_statement; 193, 194; 194, identifier:BCI2000; 195, with_statement; 195, 196; 195, 207; 196, with_clause; 196, 197; 197, with_item; 197, 198; 198, as_pattern; 198, 199; 198, 205; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:filename; 202, identifier:open; 203, argument_list; 203, 204; 204, string:'rb'; 205, as_pattern_target; 205, 206; 206, identifier:f; 207, block; 207, 208; 207, 217; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:file_header; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:f; 214, identifier:read; 215, argument_list; 215, 216; 216, integer:8; 217, if_statement; 217, 218; 217, 224; 217, 227; 218, comparison_operator:in; 218, 219; 218, 220; 219, identifier:file_header; 220, tuple; 220, 221; 220, 222; 220, 223; 221, string:b'NEURALCD'; 222, string:b'NEURALSG'; 223, string:b'NEURALEV'; 224, block; 224, 225; 225, return_statement; 225, 226; 226, identifier:BlackRock; 227, elif_clause; 227, 228; 227, 235; 228, comparison_operator:==; 228, 229; 228, 234; 229, subscript; 229, 230; 229, 231; 230, identifier:file_header; 231, slice; 231, 232; 231, 233; 232, colon; 233, integer:6; 234, string:b'MATLAB'; 235, block; 235, 236; 236, return_statement; 236, 237; 237, identifier:FieldTrip; 238, if_statement; 238, 239; 238, 248; 238, 282; 239, comparison_operator:==; 239, 240; 239, 247; 240, call; 240, 241; 240, 246; 241, attribute; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:filename; 244, identifier:suffix; 245, identifier:lower; 246, argument_list; 247, string:'.txt'; 248, block; 248, 249; 249, with_statement; 249, 250; 249, 261; 250, with_clause; 250, 251; 251, with_item; 251, 252; 252, as_pattern; 252, 253; 252, 259; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:filename; 256, identifier:open; 257, argument_list; 257, 258; 258, string:'rt'; 259, as_pattern_target; 259, 260; 260, identifier:f; 261, block; 261, 262; 261, 270; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:first_line; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:f; 268, identifier:readline; 269, argument_list; 270, if_statement; 270, 271; 270, 279; 271, comparison_operator:in; 271, 272; 271, 273; 272, string:'.rr'; 273, subscript; 273, 274; 273, 275; 274, identifier:first_line; 275, slice; 275, 276; 275, 278; 276, unary_operator:-; 276, 277; 277, integer:4; 278, colon; 279, block; 279, 280; 280, return_statement; 280, 281; 281, identifier:LyonRRI; 282, else_clause; 282, 283; 283, block; 283, 284; 284, raise_statement; 284, 285; 285, call; 285, 286; 285, 287; 286, identifier:UnrecognizedFormat; 287, argument_list; 287, 288; 288, binary_operator:+; 288, 289; 288, 290; 289, string:'Unrecognized format for file '; 290, call; 290, 291; 290, 292; 291, identifier:str; 292, argument_list; 292, 293; 293, identifier:filename | def detect_format(filename):
filename = Path(filename)
if filename.is_dir():
if list(filename.glob('*.stc')) and list(filename.glob('*.erd')):
return Ktlx
elif (filename / 'patient.info').exists():
return Moberg
elif (filename / 'info.xml').exists():
return EgiMff
elif list(filename.glob('*.openephys')):
return OpenEphys
elif list(filename.glob('*.txt')):
return Text
else:
raise UnrecognizedFormat('Unrecognized format for directory ' +
str(filename))
else:
if filename.suffix == '.won':
return Wonambi
if filename.suffix.lower() == '.trc':
return Micromed
if filename.suffix == '.set':
return EEGLAB
if filename.suffix == '.edf':
return Edf
if filename.suffix == '.abf':
return Abf
if filename.suffix == '.vhdr' or filename.suffix == '.eeg':
return BrainVision
if filename.suffix == '.dat':
try:
_read_header_length(filename)
except (AttributeError, ValueError):
pass
else:
return BCI2000
with filename.open('rb') as f:
file_header = f.read(8)
if file_header in (b'NEURALCD', b'NEURALSG', b'NEURALEV'):
return BlackRock
elif file_header[:6] == b'MATLAB':
return FieldTrip
if filename.suffix.lower() == '.txt':
with filename.open('rt') as f:
first_line = f.readline()
if '.rr' in first_line[-4:]:
return LyonRRI
else:
raise UnrecognizedFormat('Unrecognized format for file ' +
str(filename)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:read_videos; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:begtime; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:endtime; 10, None; 11, block; 11, 12; 11, 29; 11, 44; 11, 61; 11, 76; 11, 88; 12, if_statement; 12, 13; 12, 18; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:begtime; 17, identifier:datetime; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:begtime; 22, binary_operator:-; 22, 23; 22, 24; 23, identifier:begtime; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:header; 28, string:'start_time'; 29, if_statement; 29, 30; 29, 35; 30, call; 30, 31; 30, 32; 31, identifier:isinstance; 32, argument_list; 32, 33; 32, 34; 33, identifier:begtime; 34, identifier:timedelta; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:begtime; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:begtime; 42, identifier:total_seconds; 43, argument_list; 44, if_statement; 44, 45; 44, 50; 45, call; 45, 46; 45, 47; 46, identifier:isinstance; 47, argument_list; 47, 48; 47, 49; 48, identifier:endtime; 49, identifier:datetime; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:endtime; 54, binary_operator:-; 54, 55; 54, 56; 55, identifier:endtime; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:header; 60, string:'start_time'; 61, if_statement; 61, 62; 61, 67; 62, call; 62, 63; 62, 64; 63, identifier:isinstance; 64, argument_list; 64, 65; 64, 66; 65, identifier:endtime; 66, identifier:timedelta; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:endtime; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:endtime; 74, identifier:total_seconds; 75, argument_list; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:videos; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:dataset; 84, identifier:return_videos; 85, argument_list; 85, 86; 85, 87; 86, identifier:begtime; 87, identifier:endtime; 88, return_statement; 88, 89; 89, identifier:videos | def read_videos(self, begtime=None, endtime=None):
if isinstance(begtime, datetime):
begtime = begtime - self.header['start_time']
if isinstance(begtime, timedelta):
begtime = begtime.total_seconds()
if isinstance(endtime, datetime):
endtime = endtime - self.header['start_time']
if isinstance(endtime, timedelta):
endtime = endtime.total_seconds()
videos = self.dataset.return_videos(begtime, endtime)
return videos |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:read_data; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:chan; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:begtime; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:endtime; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:begsam; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:endsam; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:s_freq; 22, None; 23, block; 23, 24; 23, 30; 23, 40; 23, 55; 23, 68; 23, 88; 23, 92; 23, 116; 23, 133; 23, 146; 23, 163; 23, 200; 23, 237; 23, 250; 23, 263; 23, 281; 23, 288; 23, 302; 23, 316; 23, 328; 23, 451; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:data; 27, call; 27, 28; 27, 29; 28, identifier:ChanTime; 29, argument_list; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:data; 34, identifier:start_time; 35, subscript; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:header; 39, string:'start_time'; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:data; 44, identifier:s_freq; 45, assignment; 45, 46; 45, 47; 46, identifier:s_freq; 47, conditional_expression:if; 47, 48; 47, 49; 47, 50; 48, identifier:s_freq; 49, identifier:s_freq; 50, subscript; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:header; 54, string:'s_freq'; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:chan; 58, None; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:chan; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:header; 67, string:'chan_name'; 68, if_statement; 68, 69; 68, 82; 69, not_operator; 69, 70; 70, parenthesized_expression; 70, 71; 71, boolean_operator:or; 71, 72; 71, 77; 72, call; 72, 73; 72, 74; 73, identifier:isinstance; 74, argument_list; 74, 75; 74, 76; 75, identifier:chan; 76, identifier:list; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 81; 80, identifier:chan; 81, identifier:tuple; 82, block; 82, 83; 83, raise_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:TypeError; 86, argument_list; 86, 87; 87, string:'Parameter "chan" should be a list'; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:add_ref; 91, False; 92, if_statement; 92, 93; 92, 96; 93, comparison_operator:in; 93, 94; 93, 95; 94, string:'_REF'; 95, identifier:chan; 96, block; 96, 97; 96, 101; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:add_ref; 100, True; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 107; 103, subscript; 103, 104; 103, 105; 104, identifier:chan; 105, slice; 105, 106; 106, colon; 107, list_comprehension; 107, 108; 107, 109; 107, 112; 108, identifier:x; 109, for_in_clause; 109, 110; 109, 111; 110, identifier:x; 111, identifier:chan; 112, if_clause; 112, 113; 113, comparison_operator:!=; 113, 114; 113, 115; 114, identifier:x; 115, string:'_REF'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:idx_chan; 119, list_comprehension; 119, 120; 119, 130; 120, call; 120, 121; 120, 128; 121, attribute; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:header; 126, string:'chan_name'; 127, identifier:index; 128, argument_list; 128, 129; 129, identifier:x; 130, for_in_clause; 130, 131; 130, 132; 131, identifier:x; 132, identifier:chan; 133, if_statement; 133, 134; 133, 141; 134, boolean_operator:and; 134, 135; 134, 138; 135, comparison_operator:is; 135, 136; 135, 137; 136, identifier:begtime; 137, None; 138, comparison_operator:is; 138, 139; 138, 140; 139, identifier:begsam; 140, None; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:begsam; 145, integer:0; 146, if_statement; 146, 147; 146, 154; 147, boolean_operator:and; 147, 148; 147, 151; 148, comparison_operator:is; 148, 149; 148, 150; 149, identifier:endtime; 150, None; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:endsam; 153, None; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:endsam; 158, subscript; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:header; 162, string:'n_samples'; 163, if_statement; 163, 164; 163, 167; 164, comparison_operator:is; 164, 165; 164, 166; 165, identifier:begtime; 166, None; 167, block; 167, 168; 167, 181; 167, 185; 168, if_statement; 168, 169; 168, 175; 169, not_operator; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:isinstance; 172, argument_list; 172, 173; 172, 174; 173, identifier:begtime; 174, identifier:list; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:begtime; 179, list:[begtime]; 179, 180; 180, identifier:begtime; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:begsam; 184, list:[]; 185, for_statement; 185, 186; 185, 187; 185, 188; 186, identifier:one_begtime; 187, identifier:begtime; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:begsam; 193, identifier:append; 194, argument_list; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:_convert_time_to_sample; 197, argument_list; 197, 198; 197, 199; 198, identifier:one_begtime; 199, identifier:self; 200, if_statement; 200, 201; 200, 204; 201, comparison_operator:is; 201, 202; 201, 203; 202, identifier:endtime; 203, None; 204, block; 204, 205; 204, 218; 204, 222; 205, if_statement; 205, 206; 205, 212; 206, not_operator; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:isinstance; 209, argument_list; 209, 210; 209, 211; 210, identifier:endtime; 211, identifier:list; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:endtime; 216, list:[endtime]; 216, 217; 217, identifier:endtime; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:endsam; 221, list:[]; 222, for_statement; 222, 223; 222, 224; 222, 225; 223, identifier:one_endtime; 224, identifier:endtime; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:endsam; 230, identifier:append; 231, argument_list; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:_convert_time_to_sample; 234, argument_list; 234, 235; 234, 236; 235, identifier:one_endtime; 236, identifier:self; 237, if_statement; 237, 238; 237, 244; 238, not_operator; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:isinstance; 241, argument_list; 241, 242; 241, 243; 242, identifier:begsam; 243, identifier:list; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:begsam; 248, list:[begsam]; 248, 249; 249, identifier:begsam; 250, if_statement; 250, 251; 250, 257; 251, not_operator; 251, 252; 252, call; 252, 253; 252, 254; 253, identifier:isinstance; 254, argument_list; 254, 255; 254, 256; 255, identifier:endsam; 256, identifier:list; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:endsam; 261, list:[endsam]; 261, 262; 262, identifier:endsam; 263, if_statement; 263, 264; 263, 273; 264, comparison_operator:!=; 264, 265; 264, 269; 265, call; 265, 266; 265, 267; 266, identifier:len; 267, argument_list; 267, 268; 268, identifier:begsam; 269, call; 269, 270; 269, 271; 270, identifier:len; 271, argument_list; 271, 272; 272, identifier:endsam; 273, block; 273, 274; 274, raise_statement; 274, 275; 275, call; 275, 276; 275, 277; 276, identifier:ValueError; 277, argument_list; 277, 278; 278, binary_operator:+; 278, 279; 278, 280; 279, string:'There should be the same number of start and '; 280, string:'end point'; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:n_trl; 284, call; 284, 285; 284, 286; 285, identifier:len; 286, argument_list; 286, 287; 287, identifier:begsam; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 295; 290, subscript; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:data; 293, identifier:axis; 294, string:'chan'; 295, call; 295, 296; 295, 297; 296, identifier:empty; 297, argument_list; 297, 298; 297, 299; 298, identifier:n_trl; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:dtype; 301, string:'O'; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 309; 304, subscript; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:data; 307, identifier:axis; 308, string:'time'; 309, call; 309, 310; 309, 311; 310, identifier:empty; 311, argument_list; 311, 312; 311, 313; 312, identifier:n_trl; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:dtype; 315, string:'O'; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:data; 320, identifier:data; 321, call; 321, 322; 321, 323; 322, identifier:empty; 323, argument_list; 323, 324; 323, 325; 324, identifier:n_trl; 325, keyword_argument; 325, 326; 325, 327; 326, identifier:dtype; 327, string:'O'; 328, for_statement; 328, 329; 328, 333; 328, 342; 329, pattern_list; 329, 330; 329, 331; 329, 332; 330, identifier:i; 331, identifier:one_begsam; 332, identifier:one_endsam; 333, call; 333, 334; 333, 335; 334, identifier:zip; 335, argument_list; 335, 336; 335, 340; 335, 341; 336, call; 336, 337; 336, 338; 337, identifier:range; 338, argument_list; 338, 339; 339, identifier:n_trl; 340, identifier:begsam; 341, identifier:endsam; 342, block; 342, 343; 342, 349; 342, 362; 342, 373; 342, 377; 342, 410; 342, 418; 342, 434; 343, expression_statement; 343, 344; 344, assignment; 344, 345; 344, 346; 345, identifier:dataset; 346, attribute; 346, 347; 346, 348; 347, identifier:self; 348, identifier:dataset; 349, expression_statement; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:lg; 353, identifier:debug; 354, argument_list; 354, 355; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, string:'begsam {0: 6}, endsam {1: 6}'; 358, identifier:format; 359, argument_list; 359, 360; 359, 361; 360, identifier:one_begsam; 361, identifier:one_endsam; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 365; 364, identifier:dat; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:dataset; 368, identifier:return_dat; 369, argument_list; 369, 370; 369, 371; 369, 372; 370, identifier:idx_chan; 371, identifier:one_begsam; 372, identifier:one_endsam; 373, expression_statement; 373, 374; 374, assignment; 374, 375; 374, 376; 375, identifier:chan_in_dat; 376, identifier:chan; 377, if_statement; 377, 378; 377, 379; 378, identifier:add_ref; 379, block; 379, 380; 379, 391; 379, 403; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 383; 382, identifier:zero_ref; 383, call; 383, 384; 383, 385; 384, identifier:zeros; 385, argument_list; 385, 386; 386, tuple; 386, 387; 386, 388; 387, integer:1; 388, binary_operator:-; 388, 389; 388, 390; 389, identifier:one_endsam; 390, identifier:one_begsam; 391, expression_statement; 391, 392; 392, assignment; 392, 393; 392, 394; 393, identifier:dat; 394, call; 394, 395; 394, 396; 395, identifier:concatenate; 396, argument_list; 396, 397; 396, 400; 397, tuple; 397, 398; 397, 399; 398, identifier:dat; 399, identifier:zero_ref; 400, keyword_argument; 400, 401; 400, 402; 401, identifier:axis; 402, integer:0; 403, expression_statement; 403, 404; 404, call; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:chan_in_dat; 407, identifier:append; 408, argument_list; 408, 409; 409, string:'_REF'; 410, expression_statement; 410, 411; 411, assignment; 411, 412; 411, 417; 412, subscript; 412, 413; 412, 416; 413, attribute; 413, 414; 413, 415; 414, identifier:data; 415, identifier:data; 416, identifier:i; 417, identifier:dat; 418, expression_statement; 418, 419; 419, assignment; 419, 420; 419, 427; 420, subscript; 420, 421; 420, 426; 421, subscript; 421, 422; 421, 425; 422, attribute; 422, 423; 422, 424; 423, identifier:data; 424, identifier:axis; 425, string:'chan'; 426, identifier:i; 427, call; 427, 428; 427, 429; 428, identifier:asarray; 429, argument_list; 429, 430; 429, 431; 430, identifier:chan_in_dat; 431, keyword_argument; 431, 432; 431, 433; 432, identifier:dtype; 433, string:'U'; 434, expression_statement; 434, 435; 435, assignment; 435, 436; 435, 443; 436, subscript; 436, 437; 436, 442; 437, subscript; 437, 438; 437, 441; 438, attribute; 438, 439; 438, 440; 439, identifier:data; 440, identifier:axis; 441, string:'time'; 442, identifier:i; 443, parenthesized_expression; 443, 444; 444, binary_operator:/; 444, 445; 444, 450; 445, call; 445, 446; 445, 447; 446, identifier:arange; 447, argument_list; 447, 448; 447, 449; 448, identifier:one_begsam; 449, identifier:one_endsam; 450, identifier:s_freq; 451, return_statement; 451, 452; 452, identifier:data | def read_data(self, chan=None, begtime=None, endtime=None, begsam=None,
endsam=None, s_freq=None):
data = ChanTime()
data.start_time = self.header['start_time']
data.s_freq = s_freq = s_freq if s_freq else self.header['s_freq']
if chan is None:
chan = self.header['chan_name']
if not (isinstance(chan, list) or isinstance(chan, tuple)):
raise TypeError('Parameter "chan" should be a list')
add_ref = False
if '_REF' in chan:
add_ref = True
chan[:] = [x for x in chan if x != '_REF']
idx_chan = [self.header['chan_name'].index(x) for x in chan]
if begtime is None and begsam is None:
begsam = 0
if endtime is None and endsam is None:
endsam = self.header['n_samples']
if begtime is not None:
if not isinstance(begtime, list):
begtime = [begtime]
begsam = []
for one_begtime in begtime:
begsam.append(_convert_time_to_sample(one_begtime, self))
if endtime is not None:
if not isinstance(endtime, list):
endtime = [endtime]
endsam = []
for one_endtime in endtime:
endsam.append(_convert_time_to_sample(one_endtime, self))
if not isinstance(begsam, list):
begsam = [begsam]
if not isinstance(endsam, list):
endsam = [endsam]
if len(begsam) != len(endsam):
raise ValueError('There should be the same number of start and ' +
'end point')
n_trl = len(begsam)
data.axis['chan'] = empty(n_trl, dtype='O')
data.axis['time'] = empty(n_trl, dtype='O')
data.data = empty(n_trl, dtype='O')
for i, one_begsam, one_endsam in zip(range(n_trl), begsam, endsam):
dataset = self.dataset
lg.debug('begsam {0: 6}, endsam {1: 6}'.format(one_begsam,
one_endsam))
dat = dataset.return_dat(idx_chan, one_begsam, one_endsam)
chan_in_dat = chan
if add_ref:
zero_ref = zeros((1, one_endsam - one_begsam))
dat = concatenate((dat, zero_ref), axis=0)
chan_in_dat.append('_REF')
data.data[i] = dat
data.axis['chan'][i] = asarray(chan_in_dat, dtype='U')
data.axis['time'][i] = (arange(one_begsam, one_endsam) / s_freq)
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:export_freq_band; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:xfreq; 5, identifier:bands; 6, identifier:filename; 7, block; 7, 8; 7, 21; 7, 34; 7, 54; 7, 62; 7, 104; 7, 145; 7, 152; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:heading_row_1; 11, list:['Segment index',
'Start time',
'End time',
'Duration',
'Stitches',
'Stage',
'Cycle',
'Event type',
'Channel',
]; 11, 12; 11, 13; 11, 14; 11, 15; 11, 16; 11, 17; 11, 18; 11, 19; 11, 20; 12, string:'Segment index'; 13, string:'Start time'; 14, string:'End time'; 15, string:'Duration'; 16, string:'Stitches'; 17, string:'Stage'; 18, string:'Cycle'; 19, string:'Event type'; 20, string:'Channel'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:spacer; 24, binary_operator:*; 24, 25; 24, 27; 25, list:['']; 25, 26; 26, string:''; 27, parenthesized_expression; 27, 28; 28, binary_operator:-; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:heading_row_1; 33, integer:1; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:band_hdr; 37, list_comprehension; 37, 38; 37, 49; 38, binary_operator:+; 38, 39; 38, 45; 39, binary_operator:+; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:str; 42, argument_list; 42, 43; 43, identifier:b1; 44, string:'-'; 45, call; 45, 46; 45, 47; 46, identifier:str; 47, argument_list; 47, 48; 48, identifier:b2; 49, for_in_clause; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:b1; 52, identifier:b2; 53, identifier:bands; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:xband; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:xfreq; 60, identifier:copy; 61, argument_list; 62, for_statement; 62, 63; 62, 64; 62, 65; 63, identifier:seg; 64, identifier:xband; 65, block; 65, 66; 65, 70; 65, 98; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:bandlist; 69, list:[]; 70, for_statement; 70, 71; 70, 74; 70, 78; 71, pattern_list; 71, 72; 71, 73; 72, identifier:i; 73, identifier:b; 74, call; 74, 75; 74, 76; 75, identifier:enumerate; 76, argument_list; 76, 77; 77, identifier:bands; 78, block; 78, 79; 78, 91; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, pattern_list; 81, 82; 81, 83; 82, identifier:pwr; 83, identifier:_; 84, call; 84, 85; 84, 86; 85, identifier:band_power; 86, argument_list; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:seg; 89, string:'data'; 90, identifier:b; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:bandlist; 95, identifier:append; 96, argument_list; 96, 97; 97, identifier:pwr; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:seg; 102, string:'band'; 103, identifier:bandlist; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:as_matrix; 107, call; 107, 108; 107, 109; 108, identifier:asarray; 109, argument_list; 109, 110; 110, list_comprehension; 110, 111; 110, 130; 110, 131; 110, 134; 111, list_comprehension; 111, 112; 111, 119; 112, subscript; 112, 113; 112, 118; 113, subscript; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:x; 116, string:'band'; 117, identifier:y; 118, identifier:chan; 119, for_in_clause; 119, 120; 119, 121; 120, identifier:y; 121, call; 121, 122; 121, 123; 122, identifier:range; 123, argument_list; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:len; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 129; 128, identifier:x; 129, string:'band'; 130, line_continuation:\; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:x; 133, identifier:xband; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:chan; 136, call; 136, 137; 136, 144; 137, attribute; 137, 138; 137, 143; 138, subscript; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:x; 141, string:'band'; 142, integer:0; 143, identifier:keys; 144, argument_list; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:desc; 148, call; 148, 149; 148, 150; 149, identifier:get_descriptives; 150, argument_list; 150, 151; 151, identifier:as_matrix; 152, with_statement; 152, 153; 152, 166; 153, with_clause; 153, 154; 154, with_item; 154, 155; 155, as_pattern; 155, 156; 155, 164; 156, call; 156, 157; 156, 158; 157, identifier:open; 158, argument_list; 158, 159; 158, 160; 158, 161; 159, identifier:filename; 160, string:'w'; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:newline; 163, string:''; 164, as_pattern_target; 164, 165; 165, identifier:f; 166, block; 166, 167; 166, 179; 166, 186; 166, 199; 166, 208; 166, 225; 166, 242; 166, 259; 166, 276; 166, 280; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:lg; 171, identifier:info; 172, argument_list; 172, 173; 173, binary_operator:+; 173, 174; 173, 175; 174, string:'Writing to '; 175, call; 175, 176; 175, 177; 176, identifier:str; 177, argument_list; 177, 178; 178, identifier:filename; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:csv_file; 182, call; 182, 183; 182, 184; 183, identifier:writer; 184, argument_list; 184, 185; 185, identifier:f; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:csv_file; 190, identifier:writerow; 191, argument_list; 191, 192; 192, list:['Wonambi v{}'.format(__version__)]; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, string:'Wonambi v{}'; 196, identifier:format; 197, argument_list; 197, 198; 198, identifier:__version__; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:csv_file; 203, identifier:writerow; 204, argument_list; 204, 205; 205, binary_operator:+; 205, 206; 205, 207; 206, identifier:heading_row_1; 207, identifier:band_hdr; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:csv_file; 212, identifier:writerow; 213, argument_list; 213, 214; 214, binary_operator:+; 214, 215; 214, 219; 215, binary_operator:+; 215, 216; 215, 218; 216, list:['Mean']; 216, 217; 217, string:'Mean'; 218, identifier:spacer; 219, call; 219, 220; 219, 221; 220, identifier:list; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 223, identifier:desc; 224, string:'mean'; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:csv_file; 229, identifier:writerow; 230, argument_list; 230, 231; 231, binary_operator:+; 231, 232; 231, 236; 232, binary_operator:+; 232, 233; 232, 235; 233, list:['SD']; 233, 234; 234, string:'SD'; 235, identifier:spacer; 236, call; 236, 237; 236, 238; 237, identifier:list; 238, argument_list; 238, 239; 239, subscript; 239, 240; 239, 241; 240, identifier:desc; 241, string:'sd'; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:csv_file; 246, identifier:writerow; 247, argument_list; 247, 248; 248, binary_operator:+; 248, 249; 248, 253; 249, binary_operator:+; 249, 250; 249, 252; 250, list:['Mean of ln']; 250, 251; 251, string:'Mean of ln'; 252, identifier:spacer; 253, call; 253, 254; 253, 255; 254, identifier:list; 255, argument_list; 255, 256; 256, subscript; 256, 257; 256, 258; 257, identifier:desc; 258, string:'mean_log'; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:csv_file; 263, identifier:writerow; 264, argument_list; 264, 265; 265, binary_operator:+; 265, 266; 265, 270; 266, binary_operator:+; 266, 267; 266, 269; 267, list:['SD of ln']; 267, 268; 268, string:'SD of ln'; 269, identifier:spacer; 270, call; 270, 271; 270, 272; 271, identifier:list; 272, argument_list; 272, 273; 273, subscript; 273, 274; 273, 275; 274, identifier:desc; 275, string:'sd_log'; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:idx; 279, integer:0; 280, for_statement; 280, 281; 280, 282; 280, 283; 281, identifier:seg; 282, identifier:xband; 283, block; 283, 284; 284, for_statement; 284, 285; 284, 286; 284, 295; 285, identifier:chan; 286, call; 286, 287; 286, 294; 287, attribute; 287, 288; 287, 293; 288, subscript; 288, 289; 288, 292; 289, subscript; 289, 290; 289, 291; 290, identifier:seg; 291, string:'band'; 292, integer:0; 293, identifier:keys; 294, argument_list; 295, block; 295, 296; 295, 300; 295, 304; 295, 319; 295, 344; 296, expression_statement; 296, 297; 297, augmented_assignment:+=; 297, 298; 297, 299; 298, identifier:idx; 299, integer:1; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:cyc; 303, None; 304, if_statement; 304, 305; 304, 310; 305, comparison_operator:is; 305, 306; 305, 309; 306, subscript; 306, 307; 306, 308; 307, identifier:seg; 308, string:'cycle'; 309, None; 310, block; 310, 311; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:cyc; 314, subscript; 314, 315; 314, 318; 315, subscript; 315, 316; 315, 317; 316, identifier:seg; 317, string:'cycle'; 318, integer:2; 319, expression_statement; 319, 320; 320, assignment; 320, 321; 320, 322; 321, identifier:data_row; 322, call; 322, 323; 322, 324; 323, identifier:list; 324, argument_list; 324, 325; 325, list_comprehension; 325, 326; 325, 333; 326, subscript; 326, 327; 326, 332; 327, subscript; 327, 328; 327, 331; 328, subscript; 328, 329; 328, 330; 329, identifier:seg; 330, string:'band'; 331, identifier:x; 332, identifier:chan; 333, for_in_clause; 333, 334; 333, 335; 334, identifier:x; 335, call; 335, 336; 335, 337; 336, identifier:range; 337, argument_list; 337, 338; 338, call; 338, 339; 338, 340; 339, identifier:len; 340, argument_list; 340, 341; 341, subscript; 341, 342; 341, 343; 342, identifier:seg; 343, string:'band'; 344, expression_statement; 344, 345; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:csv_file; 348, identifier:writerow; 349, argument_list; 349, 350; 350, binary_operator:+; 350, 351; 350, 373; 351, list:[idx,
seg['start'],
seg['end'],
seg['duration'],
seg['n_stitch'],
seg['stage'],
cyc,
seg['name'],
chan,
]; 351, 352; 351, 353; 351, 356; 351, 359; 351, 362; 351, 365; 351, 368; 351, 369; 351, 372; 352, identifier:idx; 353, subscript; 353, 354; 353, 355; 354, identifier:seg; 355, string:'start'; 356, subscript; 356, 357; 356, 358; 357, identifier:seg; 358, string:'end'; 359, subscript; 359, 360; 359, 361; 360, identifier:seg; 361, string:'duration'; 362, subscript; 362, 363; 362, 364; 363, identifier:seg; 364, string:'n_stitch'; 365, subscript; 365, 366; 365, 367; 366, identifier:seg; 367, string:'stage'; 368, identifier:cyc; 369, subscript; 369, 370; 369, 371; 370, identifier:seg; 371, string:'name'; 372, identifier:chan; 373, identifier:data_row | def export_freq_band(xfreq, bands, filename):
heading_row_1 = ['Segment index',
'Start time',
'End time',
'Duration',
'Stitches',
'Stage',
'Cycle',
'Event type',
'Channel',
]
spacer = [''] * (len(heading_row_1) - 1)
band_hdr = [str(b1) + '-' + str(b2) for b1, b2 in bands]
xband = xfreq.copy()
for seg in xband:
bandlist = []
for i, b in enumerate(bands):
pwr, _ = band_power(seg['data'], b)
bandlist.append(pwr)
seg['band'] = bandlist
as_matrix = asarray([
[x['band'][y][chan] for y in range(len(x['band']))] \
for x in xband for chan in x['band'][0].keys()])
desc = get_descriptives(as_matrix)
with open(filename, 'w', newline='') as f:
lg.info('Writing to ' + str(filename))
csv_file = writer(f)
csv_file.writerow(['Wonambi v{}'.format(__version__)])
csv_file.writerow(heading_row_1 + band_hdr)
csv_file.writerow(['Mean'] + spacer + list(desc['mean']))
csv_file.writerow(['SD'] + spacer + list(desc['sd']))
csv_file.writerow(['Mean of ln'] + spacer + list(desc['mean_log']))
csv_file.writerow(['SD of ln'] + spacer + list(desc['sd_log']))
idx = 0
for seg in xband:
for chan in seg['band'][0].keys():
idx += 1
cyc = None
if seg['cycle'] is not None:
cyc = seg['cycle'][2]
data_row = list(
[seg['band'][x][chan] for x in range(
len(seg['band']))])
csv_file.writerow([idx,
seg['start'],
seg['end'],
seg['duration'],
seg['n_stitch'],
seg['stage'],
cyc,
seg['name'],
chan,
] + data_row) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_cycles; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 23; 5, 44; 5, 65; 5, 69; 5, 78; 5, 96; 5, 180; 5, 184; 5, 213; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:cycles; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:rater; 14, identifier:find; 15, argument_list; 15, 16; 16, string:'cycles'; 17, if_statement; 17, 18; 17, 20; 18, not_operator; 18, 19; 19, identifier:cycles; 20, block; 20, 21; 21, return_statement; 21, 22; 22, None; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:starts; 26, call; 26, 27; 26, 28; 27, identifier:sorted; 28, argument_list; 28, 29; 29, list_comprehension; 29, 30; 29, 36; 30, call; 30, 31; 30, 32; 31, identifier:float; 32, argument_list; 32, 33; 33, attribute; 33, 34; 33, 35; 34, identifier:mrkr; 35, identifier:text; 36, for_in_clause; 36, 37; 36, 38; 37, identifier:mrkr; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:cycles; 41, identifier:findall; 42, argument_list; 42, 43; 43, string:'cyc_start'; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ends; 47, call; 47, 48; 47, 49; 48, identifier:sorted; 49, argument_list; 49, 50; 50, list_comprehension; 50, 51; 50, 57; 51, call; 51, 52; 51, 53; 52, identifier:float; 53, argument_list; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:mrkr; 56, identifier:text; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:mrkr; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:cycles; 62, identifier:findall; 63, argument_list; 63, 64; 64, string:'cyc_end'; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:cyc_list; 68, list:[]; 69, if_statement; 69, 70; 69, 75; 70, boolean_operator:or; 70, 71; 70, 73; 71, not_operator; 71, 72; 72, identifier:starts; 73, not_operator; 73, 74; 74, identifier:ends; 75, block; 75, 76; 76, return_statement; 76, 77; 77, None; 78, if_statement; 78, 79; 78, 90; 79, call; 79, 80; 79, 81; 80, identifier:all; 81, generator_expression; 81, 82; 81, 87; 82, comparison_operator:<; 82, 83; 82, 84; 83, identifier:i; 84, subscript; 84, 85; 84, 86; 85, identifier:starts; 86, integer:0; 87, for_in_clause; 87, 88; 87, 89; 88, identifier:i; 89, identifier:ends; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:ValueError; 94, argument_list; 94, 95; 95, string:'First cycle has no start.'; 96, for_statement; 96, 97; 96, 100; 96, 112; 97, tuple_pattern; 97, 98; 97, 99; 98, identifier:this_start; 99, identifier:next_start; 100, call; 100, 101; 100, 102; 101, identifier:zip; 102, argument_list; 102, 103; 102, 104; 103, identifier:starts; 104, binary_operator:+; 104, 105; 104, 110; 105, subscript; 105, 106; 105, 107; 106, identifier:starts; 107, slice; 107, 108; 107, 109; 108, integer:1; 109, colon; 110, list:[inf]; 110, 111; 111, identifier:inf; 112, block; 112, 113; 112, 127; 112, 142; 112, 161; 112, 173; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:end_between_starts; 116, list_comprehension; 116, 117; 116, 118; 116, 121; 116, 122; 117, identifier:end; 118, for_in_clause; 118, 119; 118, 120; 119, identifier:end; 120, identifier:ends; 121, line_continuation:\; 122, if_clause; 122, 123; 123, comparison_operator:<; 123, 124; 123, 125; 123, 126; 124, identifier:this_start; 125, identifier:end; 126, identifier:next_start; 127, if_statement; 127, 128; 127, 134; 128, comparison_operator:>; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:end_between_starts; 133, integer:1; 134, block; 134, 135; 135, raise_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:ValueError; 138, argument_list; 138, 139; 139, concatenated_string; 139, 140; 139, 141; 140, string:'Found more than one cycle end for same '; 141, string:'cycle'; 142, if_statement; 142, 143; 142, 144; 142, 153; 143, identifier:end_between_starts; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:one_cycle; 148, tuple; 148, 149; 148, 150; 149, identifier:this_start; 150, subscript; 150, 151; 150, 152; 151, identifier:end_between_starts; 152, integer:0; 153, else_clause; 153, 154; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:one_cycle; 158, tuple; 158, 159; 158, 160; 159, identifier:this_start; 160, identifier:next_start; 161, if_statement; 161, 162; 161, 167; 162, comparison_operator:==; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:one_cycle; 165, integer:1; 166, identifier:inf; 167, block; 167, 168; 168, raise_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:ValueError; 171, argument_list; 171, 172; 172, string:'Last cycle has no end.'; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:cyc_list; 177, identifier:append; 178, argument_list; 178, 179; 179, identifier:one_cycle; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:output; 183, list:[]; 184, for_statement; 184, 185; 184, 188; 184, 192; 185, pattern_list; 185, 186; 185, 187; 186, identifier:i; 187, identifier:j; 188, call; 188, 189; 188, 190; 189, identifier:enumerate; 190, argument_list; 190, 191; 191, identifier:cyc_list; 192, block; 192, 193; 192, 206; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:cyc; 196, expression_list; 196, 197; 196, 200; 196, 203; 197, subscript; 197, 198; 197, 199; 198, identifier:j; 199, integer:0; 200, subscript; 200, 201; 200, 202; 201, identifier:j; 202, integer:1; 203, binary_operator:+; 203, 204; 203, 205; 204, identifier:i; 205, integer:1; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:output; 210, identifier:append; 211, argument_list; 211, 212; 212, identifier:cyc; 213, return_statement; 213, 214; 214, identifier:output | def get_cycles(self):
cycles = self.rater.find('cycles')
if not cycles:
return None
starts = sorted(
[float(mrkr.text) for mrkr in cycles.findall('cyc_start')])
ends = sorted(
[float(mrkr.text) for mrkr in cycles.findall('cyc_end')])
cyc_list = []
if not starts or not ends:
return None
if all(i < starts[0] for i in ends):
raise ValueError('First cycle has no start.')
for (this_start, next_start) in zip(starts, starts[1:] + [inf]):
end_between_starts = [end for end in ends \
if this_start < end <= next_start]
if len(end_between_starts) > 1:
raise ValueError('Found more than one cycle end for same '
'cycle')
if end_between_starts:
one_cycle = (this_start, end_between_starts[0])
else:
one_cycle = (this_start, next_start)
if one_cycle[1] == inf:
raise ValueError('Last cycle has no end.')
cyc_list.append(one_cycle)
output = []
for i, j in enumerate(cyc_list):
cyc = j[0], j[1], i + 1
output.append(cyc)
return output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_read_erd; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:erd_file; 5, identifier:begsam; 6, identifier:endsam; 7, block; 7, 8; 7, 15; 7, 21; 7, 27; 7, 34; 7, 44; 7, 61; 7, 74; 7, 80; 7, 89; 7, 96; 7, 108; 7, 114; 7, 126; 7, 162; 7, 278; 7, 331; 7, 338; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:hdr; 11, call; 11, 12; 11, 13; 12, identifier:_read_hdr_file; 13, argument_list; 13, 14; 14, identifier:erd_file; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:n_allchan; 18, subscript; 18, 19; 18, 20; 19, identifier:hdr; 20, string:'num_channels'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:shorted; 24, subscript; 24, 25; 24, 26; 25, identifier:hdr; 26, string:'shorted'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:n_shorted; 30, call; 30, 31; 30, 32; 31, identifier:sum; 32, argument_list; 32, 33; 33, identifier:shorted; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:>; 35, 36; 35, 37; 36, identifier:n_shorted; 37, integer:0; 38, block; 38, 39; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:NotImplementedError; 42, argument_list; 42, 43; 43, string:'shorted channels not tested yet'; 44, if_statement; 44, 45; 44, 51; 45, comparison_operator:in; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:hdr; 48, string:'file_schema'; 49, tuple; 49, 50; 50, integer:7; 51, block; 51, 52; 51, 56; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:abs_delta; 55, string:b'\x80'; 56, raise_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:NotImplementedError; 59, argument_list; 59, 60; 60, string:'schema 7 not tested yet'; 61, if_statement; 61, 62; 61, 69; 62, comparison_operator:in; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:hdr; 65, string:'file_schema'; 66, tuple; 66, 67; 66, 68; 67, integer:8; 68, integer:9; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:abs_delta; 73, string:b'\xff\xff'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:n_smp; 77, binary_operator:-; 77, 78; 77, 79; 78, identifier:endsam; 79, identifier:begsam; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:data; 83, call; 83, 84; 83, 85; 84, identifier:empty; 85, argument_list; 85, 86; 86, tuple; 86, 87; 86, 88; 87, identifier:n_allchan; 88, identifier:n_smp; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:data; 93, identifier:fill; 94, argument_list; 94, 95; 95, identifier:NaN; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:etc; 99, call; 99, 100; 99, 101; 100, identifier:_read_etc; 101, argument_list; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:erd_file; 105, identifier:with_suffix; 106, argument_list; 106, 107; 107, string:'.etc'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:all_beg; 111, subscript; 111, 112; 111, 113; 112, identifier:etc; 113, string:'samplestamp'; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:all_end; 117, binary_operator:-; 117, 118; 117, 125; 118, binary_operator:+; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:etc; 121, string:'samplestamp'; 122, subscript; 122, 123; 122, 124; 123, identifier:etc; 124, string:'sample_span'; 125, integer:1; 126, try_statement; 126, 127; 126, 157; 127, block; 127, 128; 127, 142; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:begrec; 131, subscript; 131, 132; 131, 141; 132, subscript; 132, 133; 132, 140; 133, call; 133, 134; 133, 135; 134, identifier:where; 135, argument_list; 135, 136; 136, parenthesized_expression; 136, 137; 137, comparison_operator:>=; 137, 138; 137, 139; 138, identifier:all_end; 139, identifier:begsam; 140, integer:0; 141, integer:0; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:endrec; 145, subscript; 145, 146; 145, 155; 146, subscript; 146, 147; 146, 154; 147, call; 147, 148; 147, 149; 148, identifier:where; 149, argument_list; 149, 150; 150, parenthesized_expression; 150, 151; 151, comparison_operator:<; 151, 152; 151, 153; 152, identifier:all_beg; 153, identifier:endsam; 154, integer:0; 155, unary_operator:-; 155, 156; 156, integer:1; 157, except_clause; 157, 158; 157, 159; 158, identifier:IndexError; 159, block; 159, 160; 160, return_statement; 160, 161; 161, identifier:data; 162, with_statement; 162, 163; 162, 174; 163, with_clause; 163, 164; 164, with_item; 164, 165; 165, as_pattern; 165, 166; 165, 172; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:erd_file; 169, identifier:open; 170, argument_list; 170, 171; 171, string:'rb'; 172, as_pattern_target; 172, 173; 173, identifier:f; 174, block; 174, 175; 175, for_statement; 175, 176; 175, 177; 175, 184; 176, identifier:rec; 177, call; 177, 178; 177, 179; 178, identifier:range; 179, argument_list; 179, 180; 179, 181; 180, identifier:begrec; 181, binary_operator:+; 181, 182; 181, 183; 182, identifier:endrec; 183, integer:1; 184, block; 184, 185; 184, 193; 184, 201; 184, 209; 184, 225; 184, 235; 184, 245; 184, 260; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:begpos_rec; 188, binary_operator:-; 188, 189; 188, 190; 189, identifier:begsam; 190, subscript; 190, 191; 190, 192; 191, identifier:all_beg; 192, identifier:rec; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:endpos_rec; 196, binary_operator:-; 196, 197; 196, 198; 197, identifier:endsam; 198, subscript; 198, 199; 198, 200; 199, identifier:all_beg; 200, identifier:rec; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:begpos_rec; 204, call; 204, 205; 204, 206; 205, identifier:max; 206, argument_list; 206, 207; 206, 208; 207, identifier:begpos_rec; 208, integer:0; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:endpos_rec; 212, call; 212, 213; 212, 214; 213, identifier:min; 214, argument_list; 214, 215; 214, 216; 215, identifier:endpos_rec; 216, binary_operator:+; 216, 217; 216, 224; 217, binary_operator:-; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:all_end; 220, identifier:rec; 221, subscript; 221, 222; 221, 223; 222, identifier:all_beg; 223, identifier:rec; 224, integer:1; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:d1; 228, binary_operator:-; 228, 229; 228, 234; 229, binary_operator:+; 229, 230; 229, 231; 230, identifier:begpos_rec; 231, subscript; 231, 232; 231, 233; 232, identifier:all_beg; 233, identifier:rec; 234, identifier:begsam; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:d2; 238, binary_operator:-; 238, 239; 238, 244; 239, binary_operator:+; 239, 240; 239, 241; 240, identifier:endpos_rec; 241, subscript; 241, 242; 241, 243; 242, identifier:all_beg; 243, identifier:rec; 244, identifier:begsam; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:dat; 248, call; 248, 249; 248, 250; 249, identifier:_read_packet; 250, argument_list; 250, 251; 250, 252; 250, 257; 250, 258; 250, 259; 251, identifier:f; 252, subscript; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:etc; 255, string:'offset'; 256, identifier:rec; 257, identifier:endpos_rec; 258, identifier:n_allchan; 259, identifier:abs_delta; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 270; 262, subscript; 262, 263; 262, 264; 262, 266; 263, identifier:data; 264, slice; 264, 265; 265, colon; 266, slice; 266, 267; 266, 268; 266, 269; 267, identifier:d1; 268, colon; 269, identifier:d2; 270, subscript; 270, 271; 270, 272; 270, 274; 271, identifier:dat; 272, slice; 272, 273; 273, colon; 274, slice; 274, 275; 274, 276; 274, 277; 275, identifier:begpos_rec; 276, colon; 277, identifier:endpos_rec; 278, if_statement; 278, 279; 278, 282; 278, 325; 279, comparison_operator:>; 279, 280; 279, 281; 280, identifier:n_shorted; 281, integer:0; 282, block; 282, 283; 282, 301; 282, 310; 282, 317; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:full_channels; 286, subscript; 286, 287; 286, 300; 287, call; 287, 288; 287, 289; 288, identifier:where; 289, argument_list; 289, 290; 290, call; 290, 291; 290, 292; 291, identifier:asarray; 292, argument_list; 292, 293; 293, list_comprehension; 293, 294; 293, 297; 294, comparison_operator:==; 294, 295; 294, 296; 295, identifier:x; 296, integer:0; 297, for_in_clause; 297, 298; 297, 299; 298, identifier:x; 299, identifier:shorted; 300, integer:0; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:output; 304, call; 304, 305; 304, 306; 305, identifier:empty; 306, argument_list; 306, 307; 307, tuple; 307, 308; 307, 309; 308, identifier:n_allchan; 309, identifier:n_smp; 310, expression_statement; 310, 311; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:output; 314, identifier:fill; 315, argument_list; 315, 316; 316, identifier:NaN; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 324; 319, subscript; 319, 320; 319, 321; 319, 322; 320, identifier:output; 321, identifier:full_channels; 322, slice; 322, 323; 323, colon; 324, identifier:data; 325, else_clause; 325, 326; 326, block; 326, 327; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:output; 330, identifier:data; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:factor; 334, call; 334, 335; 334, 336; 335, identifier:_calculate_conversion; 336, argument_list; 336, 337; 337, identifier:hdr; 338, return_statement; 338, 339; 339, binary_operator:*; 339, 340; 339, 345; 340, call; 340, 341; 340, 342; 341, identifier:expand_dims; 342, argument_list; 342, 343; 342, 344; 343, identifier:factor; 344, integer:1; 345, identifier:output | def _read_erd(erd_file, begsam, endsam):
hdr = _read_hdr_file(erd_file)
n_allchan = hdr['num_channels']
shorted = hdr['shorted']
n_shorted = sum(shorted)
if n_shorted > 0:
raise NotImplementedError('shorted channels not tested yet')
if hdr['file_schema'] in (7,):
abs_delta = b'\x80'
raise NotImplementedError('schema 7 not tested yet')
if hdr['file_schema'] in (8, 9):
abs_delta = b'\xff\xff'
n_smp = endsam - begsam
data = empty((n_allchan, n_smp))
data.fill(NaN)
etc = _read_etc(erd_file.with_suffix('.etc'))
all_beg = etc['samplestamp']
all_end = etc['samplestamp'] + etc['sample_span'] - 1
try:
begrec = where((all_end >= begsam))[0][0]
endrec = where((all_beg < endsam))[0][-1]
except IndexError:
return data
with erd_file.open('rb') as f:
for rec in range(begrec, endrec + 1):
begpos_rec = begsam - all_beg[rec]
endpos_rec = endsam - all_beg[rec]
begpos_rec = max(begpos_rec, 0)
endpos_rec = min(endpos_rec, all_end[rec] - all_beg[rec] + 1)
d1 = begpos_rec + all_beg[rec] - begsam
d2 = endpos_rec + all_beg[rec] - begsam
dat = _read_packet(f, etc['offset'][rec], endpos_rec, n_allchan,
abs_delta)
data[:, d1:d2] = dat[:, begpos_rec:endpos_rec]
if n_shorted > 0:
full_channels = where(asarray([x == 0 for x in shorted]))[0]
output = empty((n_allchan, n_smp))
output.fill(NaN)
output[full_channels, :] = data
else:
output = data
factor = _calculate_conversion(hdr)
return expand_dims(factor, 1) * output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:return_markers; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 36; 5, 318; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ent_file; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_filename; 14, identifier:with_suffix; 15, argument_list; 15, 16; 16, string:'.ent'; 17, if_statement; 17, 18; 17, 24; 18, not_operator; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:ent_file; 22, identifier:exists; 23, argument_list; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:ent_file; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_filename; 33, identifier:with_suffix; 34, argument_list; 34, 35; 35, string:'.ent.old'; 36, try_statement; 36, 37; 36, 45; 36, 54; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:ent_notes; 41, call; 41, 42; 41, 43; 42, identifier:_read_ent; 43, argument_list; 43, 44; 44, identifier:ent_file; 45, except_clause; 45, 46; 45, 49; 46, tuple; 46, 47; 46, 48; 47, identifier:FileNotFoundError; 48, identifier:PermissionError; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:markers; 53, list:[]; 54, else_clause; 54, 55; 55, block; 55, 56; 55, 60; 55, 102; 55, 112; 55, 116; 55, 120; 55, 124; 55, 128; 55, 273; 55, 277; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:allnote; 59, list:[]; 60, for_statement; 60, 61; 60, 62; 60, 63; 61, identifier:n; 62, identifier:ent_notes; 63, block; 63, 64; 64, try_statement; 64, 65; 64, 83; 65, block; 65, 66; 65, 74; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:n; 71, string:'value'; 72, identifier:keys; 73, argument_list; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:allnote; 78, identifier:append; 79, argument_list; 79, 80; 80, subscript; 80, 81; 80, 82; 81, identifier:n; 82, string:'value'; 83, except_clause; 83, 84; 83, 85; 84, identifier:AttributeError; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:lg; 90, identifier:debug; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, concatenated_string; 94, 95; 94, 96; 95, string:'Note of length {} was not '; 96, string:'converted to dict'; 97, identifier:format; 98, argument_list; 98, 99; 99, subscript; 99, 100; 99, 101; 100, identifier:n; 101, string:'length'; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:s_freq; 105, subscript; 105, 106; 105, 111; 106, subscript; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:_hdr; 110, string:'erd'; 111, string:'sample_freq'; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:pcname; 115, string:'0CFEBE72-DA20-4b3a-A8AC-CDD41BFE2F0D'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:note_time; 119, list:[]; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:note_name; 123, list:[]; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:note_note; 127, list:[]; 128, for_statement; 128, 129; 128, 130; 128, 131; 129, identifier:n; 130, identifier:allnote; 131, block; 131, 132; 131, 140; 131, 147; 131, 159; 131, 169; 131, 173; 131, 183; 131, 193; 131, 203; 131, 215; 131, 253; 131, 264; 132, if_statement; 132, 133; 132, 138; 133, comparison_operator:==; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:n; 136, string:'Text'; 137, string:'Analyzed Data Note'; 138, block; 138, 139; 139, continue_statement; 140, if_statement; 140, 141; 140, 145; 141, not_operator; 141, 142; 142, subscript; 142, 143; 142, 144; 143, identifier:n; 144, string:'Text'; 145, block; 145, 146; 146, continue_statement; 147, if_statement; 147, 148; 147, 157; 148, comparison_operator:not; 148, 149; 148, 150; 149, string:'User'; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:n; 154, string:'Data'; 155, identifier:keys; 156, argument_list; 157, block; 157, 158; 158, continue_statement; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:user1; 162, comparison_operator:==; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:n; 166, string:'Data'; 167, string:'User'; 168, string:'Persyst'; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:user2; 172, False; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:user3; 176, comparison_operator:==; 176, 177; 176, 182; 177, subscript; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:n; 180, string:'Data'; 181, string:'User'; 182, identifier:pcname; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:user4; 186, comparison_operator:==; 186, 187; 186, 192; 187, subscript; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:n; 190, string:'Data'; 191, string:'User'; 192, string:'XLSpike - Intracranial'; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:user5; 196, comparison_operator:==; 196, 197; 196, 202; 197, subscript; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:n; 200, string:'Data'; 201, string:'User'; 202, string:'XLEvent - Intracranial'; 203, if_statement; 203, 204; 203, 213; 204, boolean_operator:or; 204, 205; 204, 212; 205, boolean_operator:or; 205, 206; 205, 211; 206, boolean_operator:or; 206, 207; 206, 210; 207, boolean_operator:or; 207, 208; 207, 209; 208, identifier:user1; 209, identifier:user2; 210, identifier:user3; 211, identifier:user4; 212, identifier:user5; 213, block; 213, 214; 214, continue_statement; 215, if_statement; 215, 216; 215, 226; 215, 234; 216, comparison_operator:==; 216, 217; 216, 225; 217, call; 217, 218; 217, 219; 218, identifier:len; 219, argument_list; 219, 220; 220, subscript; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:n; 223, string:'Data'; 224, string:'User'; 225, integer:0; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:note_name; 231, identifier:append; 232, argument_list; 232, 233; 233, string:'-unknown-'; 234, else_clause; 234, 235; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:note_name; 240, identifier:append; 241, argument_list; 241, 242; 242, subscript; 242, 243; 242, 252; 243, call; 243, 244; 243, 251; 244, attribute; 244, 245; 244, 250; 245, subscript; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:n; 248, string:'Data'; 249, string:'User'; 250, identifier:split; 251, argument_list; 252, integer:0; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:note_time; 257, identifier:append; 258, argument_list; 258, 259; 259, binary_operator:/; 259, 260; 259, 263; 260, subscript; 260, 261; 260, 262; 261, identifier:n; 262, string:'Stamp'; 263, identifier:s_freq; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:note_note; 268, identifier:append; 269, argument_list; 269, 270; 270, subscript; 270, 271; 270, 272; 271, identifier:n; 272, string:'Text'; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:markers; 276, list:[]; 277, for_statement; 277, 278; 277, 282; 277, 288; 278, pattern_list; 278, 279; 278, 280; 278, 281; 279, identifier:time; 280, identifier:name; 281, identifier:note; 282, call; 282, 283; 282, 284; 283, identifier:zip; 284, argument_list; 284, 285; 284, 286; 284, 287; 285, identifier:note_time; 286, identifier:note_name; 287, identifier:note_note; 288, block; 288, 289; 288, 311; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:m; 292, dictionary; 292, 293; 292, 302; 292, 305; 292, 308; 293, pair; 293, 294; 293, 295; 294, string:'name'; 295, binary_operator:+; 295, 296; 295, 301; 296, binary_operator:+; 296, 297; 296, 300; 297, binary_operator:+; 297, 298; 297, 299; 298, identifier:note; 299, string:' ('; 300, identifier:name; 301, string:')'; 302, pair; 302, 303; 302, 304; 303, string:'start'; 304, identifier:time; 305, pair; 305, 306; 305, 307; 306, string:'end'; 307, identifier:time; 308, pair; 308, 309; 308, 310; 309, string:'chan'; 310, None; 311, expression_statement; 311, 312; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:markers; 315, identifier:append; 316, argument_list; 316, 317; 317, identifier:m; 318, return_statement; 318, 319; 319, identifier:markers | def return_markers(self):
ent_file = self._filename.with_suffix('.ent')
if not ent_file.exists():
ent_file = self._filename.with_suffix('.ent.old')
try:
ent_notes = _read_ent(ent_file)
except (FileNotFoundError, PermissionError):
markers = []
else:
allnote = []
for n in ent_notes:
try:
n['value'].keys()
allnote.append(n['value'])
except AttributeError:
lg.debug('Note of length {} was not '
'converted to dict'.format(n['length']))
s_freq = self._hdr['erd']['sample_freq']
pcname = '0CFEBE72-DA20-4b3a-A8AC-CDD41BFE2F0D'
note_time = []
note_name = []
note_note = []
for n in allnote:
if n['Text'] == 'Analyzed Data Note':
continue
if not n['Text']:
continue
if 'User' not in n['Data'].keys():
continue
user1 = n['Data']['User'] == 'Persyst'
user2 = False
user3 = n['Data']['User'] == pcname
user4 = n['Data']['User'] == 'XLSpike - Intracranial'
user5 = n['Data']['User'] == 'XLEvent - Intracranial'
if user1 or user2 or user3 or user4 or user5:
continue
if len(n['Data']['User']) == 0:
note_name.append('-unknown-')
else:
note_name.append(n['Data']['User'].split()[0])
note_time.append(n['Stamp'] / s_freq)
note_note.append(n['Text'])
markers = []
for time, name, note in zip(note_time, note_name, note_note):
m = {'name': note + ' (' + name + ')',
'start': time,
'end': time,
'chan': None,
}
markers.append(m)
return markers |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:band_power; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:data; 5, identifier:freq; 6, default_parameter; 6, 7; 6, 8; 7, identifier:scaling; 8, string:'power'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:n_fft; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:detrend; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:array_out; 17, False; 18, block; 18, 19; 18, 65; 18, 106; 18, 129; 18, 139; 18, 149; 18, 184; 18, 235; 18, 330; 19, if_statement; 19, 20; 19, 22; 19, 31; 20, not_operator; 20, 21; 21, identifier:array_out; 22, block; 22, 23; 22, 27; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:power; 26, dictionary; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:peakf; 30, dictionary; 31, else_clause; 31, 32; 32, block; 32, 33; 32, 49; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:power; 36, call; 36, 37; 36, 38; 37, identifier:zeros; 38, argument_list; 38, 39; 39, tuple; 39, 40; 39, 48; 40, subscript; 40, 41; 40, 47; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:data; 44, identifier:number_of; 45, argument_list; 45, 46; 46, string:'chan'; 47, integer:0; 48, integer:1; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:peakf; 52, call; 52, 53; 52, 54; 53, identifier:zeros; 54, argument_list; 54, 55; 55, tuple; 55, 56; 55, 64; 56, subscript; 56, 57; 56, 63; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:data; 60, identifier:number_of; 61, argument_list; 61, 62; 62, string:'chan'; 63, integer:0; 64, integer:1; 65, if_statement; 65, 66; 65, 71; 65, 76; 65, 99; 66, call; 66, 67; 66, 68; 67, identifier:isinstance; 68, argument_list; 68, 69; 68, 70; 69, identifier:data; 70, identifier:ChanFreq; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:Sxx; 75, identifier:data; 76, elif_clause; 76, 77; 76, 82; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 81; 80, identifier:data; 81, identifier:ChanTime; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:Sxx; 86, call; 86, 87; 86, 88; 87, identifier:frequency; 88, argument_list; 88, 89; 88, 90; 88, 93; 88, 96; 89, identifier:data; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:scaling; 92, identifier:scaling; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:n_fft; 95, identifier:n_fft; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:detrend; 98, identifier:detrend; 99, else_clause; 99, 100; 100, block; 100, 101; 101, raise_statement; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:ValueError; 104, argument_list; 104, 105; 105, string:'Invalid data type'; 106, if_statement; 106, 107; 106, 110; 107, comparison_operator:is; 107, 108; 107, 109; 108, identifier:detrend; 109, None; 110, block; 110, 111; 111, if_statement; 111, 112; 111, 115; 111, 120; 112, comparison_operator:==; 112, 113; 112, 114; 113, string:'power'; 114, identifier:scaling; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:detrend; 119, string:'linear'; 120, elif_clause; 120, 121; 120, 124; 121, comparison_operator:==; 121, 122; 121, 123; 122, string:'energy'; 123, identifier:scaling; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:detrend; 128, None; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:sf; 132, subscript; 132, 133; 132, 138; 133, subscript; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:Sxx; 136, identifier:axis; 137, string:'freq'; 138, integer:0; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:f_res; 142, binary_operator:-; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:sf; 145, integer:1; 146, subscript; 146, 147; 146, 148; 147, identifier:sf; 148, integer:0; 149, if_statement; 149, 150; 149, 155; 149, 178; 150, comparison_operator:is; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:freq; 153, integer:0; 154, None; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:idx_f1; 159, call; 159, 160; 159, 177; 160, attribute; 160, 161; 160, 176; 161, call; 161, 162; 161, 163; 162, identifier:asarray; 163, argument_list; 163, 164; 164, list_comprehension; 164, 165; 164, 173; 165, call; 165, 166; 165, 167; 166, identifier:abs; 167, argument_list; 167, 168; 168, binary_operator:-; 168, 169; 168, 170; 169, identifier:x; 170, subscript; 170, 171; 170, 172; 171, identifier:freq; 172, integer:0; 173, for_in_clause; 173, 174; 173, 175; 174, identifier:x; 175, identifier:sf; 176, identifier:argmin; 177, argument_list; 178, else_clause; 178, 179; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:idx_f1; 183, integer:0; 184, if_statement; 184, 185; 184, 190; 184, 224; 185, comparison_operator:is; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:freq; 188, integer:1; 189, None; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:idx_f2; 194, call; 194, 195; 194, 196; 195, identifier:min; 196, argument_list; 196, 197; 196, 218; 197, binary_operator:+; 197, 198; 197, 217; 198, call; 198, 199; 198, 216; 199, attribute; 199, 200; 199, 215; 200, call; 200, 201; 200, 202; 201, identifier:asarray; 202, argument_list; 202, 203; 203, list_comprehension; 203, 204; 203, 212; 204, call; 204, 205; 204, 206; 205, identifier:abs; 206, argument_list; 206, 207; 207, binary_operator:-; 207, 208; 207, 209; 208, identifier:x; 209, subscript; 209, 210; 209, 211; 210, identifier:freq; 211, integer:1; 212, for_in_clause; 212, 213; 212, 214; 213, identifier:x; 214, identifier:sf; 215, identifier:argmin; 216, argument_list; 217, integer:1; 218, binary_operator:-; 218, 219; 218, 223; 219, call; 219, 220; 219, 221; 220, identifier:len; 221, argument_list; 221, 222; 222, identifier:sf; 223, integer:1; 224, else_clause; 224, 225; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:idx_f2; 229, binary_operator:-; 229, 230; 229, 234; 230, call; 230, 231; 230, 232; 231, identifier:len; 232, argument_list; 232, 233; 233, identifier:sf; 234, integer:1; 235, for_statement; 235, 236; 235, 239; 235, 249; 236, pattern_list; 236, 237; 236, 238; 237, identifier:i; 238, identifier:chan; 239, call; 239, 240; 239, 241; 240, identifier:enumerate; 241, argument_list; 241, 242; 242, subscript; 242, 243; 242, 248; 243, subscript; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:Sxx; 246, identifier:axis; 247, string:'chan'; 248, integer:0; 249, block; 249, 250; 249, 261; 249, 275; 249, 288; 249, 299; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:s; 253, subscript; 253, 254; 253, 260; 254, call; 254, 255; 254, 256; 255, identifier:Sxx; 256, argument_list; 256, 257; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:chan; 259, identifier:chan; 260, integer:0; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:pw; 264, binary_operator:*; 264, 265; 264, 274; 265, call; 265, 266; 265, 267; 266, identifier:sum; 267, argument_list; 267, 268; 268, subscript; 268, 269; 268, 270; 269, identifier:s; 270, slice; 270, 271; 270, 272; 270, 273; 271, identifier:idx_f1; 272, colon; 273, identifier:idx_f2; 274, identifier:f_res; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:idx_peak; 278, call; 278, 279; 278, 287; 279, attribute; 279, 280; 279, 286; 280, subscript; 280, 281; 280, 282; 281, identifier:s; 282, slice; 282, 283; 282, 284; 282, 285; 283, identifier:idx_f1; 284, colon; 285, identifier:idx_f2; 286, identifier:argmax; 287, argument_list; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:pf; 291, subscript; 291, 292; 291, 298; 292, subscript; 292, 293; 292, 294; 293, identifier:sf; 294, slice; 294, 295; 294, 296; 294, 297; 295, identifier:idx_f1; 296, colon; 297, identifier:idx_f2; 298, identifier:idx_peak; 299, if_statement; 299, 300; 299, 301; 299, 316; 300, identifier:array_out; 301, block; 301, 302; 301, 309; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 308; 304, subscript; 304, 305; 304, 306; 304, 307; 305, identifier:power; 306, identifier:i; 307, integer:0; 308, identifier:pw; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 315; 311, subscript; 311, 312; 311, 313; 311, 314; 312, identifier:peakf; 313, identifier:i; 314, integer:0; 315, identifier:pf; 316, else_clause; 316, 317; 317, block; 317, 318; 317, 324; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 323; 320, subscript; 320, 321; 320, 322; 321, identifier:power; 322, identifier:chan; 323, identifier:pw; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 329; 326, subscript; 326, 327; 326, 328; 327, identifier:peakf; 328, identifier:chan; 329, identifier:pf; 330, return_statement; 330, 331; 331, expression_list; 331, 332; 331, 333; 332, identifier:power; 333, identifier:peakf | def band_power(data, freq, scaling='power', n_fft=None, detrend=None,
array_out=False):
if not array_out:
power = {}
peakf = {}
else:
power = zeros((data.number_of('chan')[0], 1))
peakf = zeros((data.number_of('chan')[0], 1))
if isinstance(data, ChanFreq):
Sxx = data
elif isinstance(data, ChanTime):
Sxx = frequency(data, scaling=scaling, n_fft=n_fft, detrend=detrend)
else:
raise ValueError('Invalid data type')
if detrend is None:
if 'power' == scaling:
detrend = 'linear'
elif 'energy' == scaling:
detrend = None
sf = Sxx.axis['freq'][0]
f_res = sf[1] - sf[0]
if freq[0] is not None:
idx_f1 = asarray([abs(x - freq[0]) for x in sf]).argmin()
else:
idx_f1 = 0
if freq[1] is not None:
idx_f2 = min(asarray([abs(x - freq[1]) for x in sf]).argmin() + 1,
len(sf) - 1)
else:
idx_f2 = len(sf) - 1
for i, chan in enumerate(Sxx.axis['chan'][0]):
s = Sxx(chan=chan)[0]
pw = sum(s[idx_f1:idx_f2]) * f_res
idx_peak = s[idx_f1:idx_f2].argmax()
pf = sf[idx_f1:idx_f2][idx_peak]
if array_out:
power[i, 0] = pw
peakf[i, 0] = pf
else:
power[chan] = pw
peakf[chan] = pf
return power, peakf |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 24; 2, function_name:morlet; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 4, identifier:freq; 5, identifier:s_freq; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ratio; 8, integer:5; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sigma_f; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:dur_in_sd; 14, integer:4; 15, default_parameter; 15, 16; 15, 17; 16, identifier:dur_in_s; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:normalization; 20, string:'peak'; 21, default_parameter; 21, 22; 21, 23; 22, identifier:zero_mean; 23, False; 24, block; 24, 25; 24, 44; 24, 55; 24, 72; 24, 85; 24, 101; 24, 116; 24, 133; 24, 150; 24, 195; 24, 212; 24, 242; 25, if_statement; 25, 26; 25, 29; 25, 36; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:sigma_f; 28, None; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:sigma_f; 33, binary_operator:/; 33, 34; 33, 35; 34, identifier:freq; 35, identifier:ratio; 36, else_clause; 36, 37; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:ratio; 41, binary_operator:/; 41, 42; 41, 43; 42, identifier:freq; 43, identifier:sigma_f; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:sigma_t; 47, binary_operator:/; 47, 48; 47, 49; 48, integer:1; 49, parenthesized_expression; 49, 50; 50, binary_operator:*; 50, 51; 50, 54; 51, binary_operator:*; 51, 52; 51, 53; 52, integer:2; 53, identifier:pi; 54, identifier:sigma_f; 55, if_statement; 55, 56; 55, 62; 56, boolean_operator:and; 56, 57; 56, 60; 57, comparison_operator:<; 57, 58; 57, 59; 58, identifier:ratio; 59, integer:5; 60, not_operator; 60, 61; 61, identifier:zero_mean; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:lg; 67, identifier:info; 68, argument_list; 68, 69; 69, concatenated_string; 69, 70; 69, 71; 70, string:'The wavelet won\'t have zero mean, set zero_mean=True to '; 71, string:'correct it'; 72, if_statement; 72, 73; 72, 76; 73, comparison_operator:is; 73, 74; 73, 75; 74, identifier:dur_in_s; 75, None; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:dur_in_s; 80, binary_operator:*; 80, 81; 80, 84; 81, binary_operator:*; 81, 82; 81, 83; 82, identifier:sigma_t; 83, identifier:dur_in_sd; 84, integer:2; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:t; 88, call; 88, 89; 88, 90; 89, identifier:arange; 90, argument_list; 90, 91; 90, 95; 90, 98; 91, binary_operator:/; 91, 92; 91, 94; 92, unary_operator:-; 92, 93; 93, identifier:dur_in_s; 94, integer:2; 95, binary_operator:/; 95, 96; 95, 97; 96, identifier:dur_in_s; 97, integer:2; 98, binary_operator:/; 98, 99; 98, 100; 99, integer:1; 100, identifier:s_freq; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:w; 104, call; 104, 105; 104, 106; 105, identifier:exp; 106, argument_list; 106, 107; 107, binary_operator:*; 107, 108; 107, 115; 108, binary_operator:*; 108, 109; 108, 114; 109, binary_operator:*; 109, 110; 109, 113; 110, binary_operator:*; 110, 111; 110, 112; 111, integer:1j; 112, integer:2; 113, identifier:pi; 114, identifier:freq; 115, identifier:t; 116, if_statement; 116, 117; 116, 118; 117, identifier:zero_mean; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, augmented_assignment:-=; 120, 121; 120, 122; 121, identifier:w; 122, call; 122, 123; 122, 124; 123, identifier:exp; 124, argument_list; 124, 125; 125, binary_operator:*; 125, 126; 125, 130; 126, binary_operator:/; 126, 127; 126, 129; 127, unary_operator:-; 127, 128; 128, integer:1; 129, integer:2; 130, binary_operator:**; 130, 131; 130, 132; 131, identifier:ratio; 132, integer:2; 133, expression_statement; 133, 134; 134, augmented_assignment:*=; 134, 135; 134, 136; 135, identifier:w; 136, call; 136, 137; 136, 138; 137, identifier:exp; 138, argument_list; 138, 139; 139, binary_operator:/; 139, 140; 139, 144; 140, unary_operator:-; 140, 141; 141, binary_operator:**; 141, 142; 141, 143; 142, identifier:t; 143, integer:2; 144, parenthesized_expression; 144, 145; 145, binary_operator:*; 145, 146; 145, 147; 146, integer:2; 147, binary_operator:**; 147, 148; 147, 149; 148, identifier:sigma_t; 149, integer:2; 150, if_statement; 150, 151; 150, 154; 150, 169; 150, 189; 151, comparison_operator:==; 151, 152; 151, 153; 152, identifier:normalization; 153, string:'area'; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, augmented_assignment:/=; 156, 157; 156, 158; 157, identifier:w; 158, call; 158, 159; 158, 160; 159, identifier:sqrt; 160, argument_list; 160, 161; 161, binary_operator:*; 161, 162; 161, 168; 162, binary_operator:*; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:sqrt; 165, argument_list; 165, 166; 166, identifier:pi; 167, identifier:sigma_t; 168, identifier:s_freq; 169, elif_clause; 169, 170; 169, 173; 170, comparison_operator:==; 170, 171; 170, 172; 171, identifier:normalization; 172, string:'max'; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, augmented_assignment:/=; 175, 176; 175, 177; 176, identifier:w; 177, binary_operator:/; 177, 178; 177, 188; 178, binary_operator:*; 178, 179; 178, 182; 179, binary_operator:*; 179, 180; 179, 181; 180, integer:2; 181, identifier:sigma_t; 182, call; 182, 183; 182, 184; 183, identifier:sqrt; 184, argument_list; 184, 185; 185, binary_operator:*; 185, 186; 185, 187; 186, integer:2; 187, identifier:pi; 188, identifier:s_freq; 189, elif_clause; 189, 190; 189, 193; 190, comparison_operator:==; 190, 191; 190, 192; 191, identifier:normalization; 192, string:'peak'; 193, block; 193, 194; 194, pass_statement; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:lg; 199, identifier:info; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 207; 202, attribute; 202, 203; 202, 206; 203, concatenated_string; 203, 204; 203, 205; 204, string:'At freq {0: 9.3f}Hz, sigma_f={1: 9.3f}Hz, sigma_t={2: 9.3f}s, '; 205, string:'total duration={3: 9.3f}s'; 206, identifier:format; 207, argument_list; 207, 208; 207, 209; 207, 210; 207, 211; 208, identifier:freq; 209, identifier:sigma_f; 210, identifier:sigma_t; 211, identifier:dur_in_s; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:lg; 216, identifier:debug; 217, argument_list; 217, 218; 218, call; 218, 219; 218, 224; 219, attribute; 219, 220; 219, 223; 220, concatenated_string; 220, 221; 220, 222; 221, string:' Real peak={0: 9.3f}, Mean={1: 12.6f}, '; 222, string:'Energy={2: 9.3f}'; 223, identifier:format; 224, argument_list; 224, 225; 224, 232; 224, 236; 225, call; 225, 226; 225, 227; 226, identifier:max; 227, argument_list; 227, 228; 228, call; 228, 229; 228, 230; 229, identifier:real; 230, argument_list; 230, 231; 231, identifier:w; 232, call; 232, 233; 232, 234; 233, identifier:mean; 234, argument_list; 234, 235; 235, identifier:w; 236, binary_operator:**; 236, 237; 236, 241; 237, call; 237, 238; 237, 239; 238, identifier:norm; 239, argument_list; 239, 240; 240, identifier:w; 241, integer:2; 242, return_statement; 242, 243; 243, identifier:w | def morlet(freq, s_freq, ratio=5, sigma_f=None, dur_in_sd=4, dur_in_s=None,
normalization='peak', zero_mean=False):
if sigma_f is None:
sigma_f = freq / ratio
else:
ratio = freq / sigma_f
sigma_t = 1 / (2 * pi * sigma_f)
if ratio < 5 and not zero_mean:
lg.info('The wavelet won\'t have zero mean, set zero_mean=True to '
'correct it')
if dur_in_s is None:
dur_in_s = sigma_t * dur_in_sd * 2
t = arange(-dur_in_s / 2, dur_in_s / 2, 1 / s_freq)
w = exp(1j * 2 * pi * freq * t)
if zero_mean:
w -= exp(-1 / 2 * ratio ** 2)
w *= exp(-t ** 2 / (2 * sigma_t ** 2))
if normalization == 'area':
w /= sqrt(sqrt(pi) * sigma_t * s_freq)
elif normalization == 'max':
w /= 2 * sigma_t * sqrt(2 * pi) / s_freq
elif normalization == 'peak':
pass
lg.info('At freq {0: 9.3f}Hz, sigma_f={1: 9.3f}Hz, sigma_t={2: 9.3f}s, '
'total duration={3: 9.3f}s'.format(freq, sigma_f, sigma_t,
dur_in_s))
lg.debug(' Real peak={0: 9.3f}, Mean={1: 12.6f}, '
'Energy={2: 9.3f}'.format(max(real(w)), mean(w), norm(w) ** 2))
return w |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_convert_timestr_to_seconds; 3, parameters; 3, 4; 3, 5; 4, identifier:time_str; 5, identifier:rec_start; 6, block; 6, 7; 6, 21; 6, 120; 7, if_statement; 7, 8; 7, 15; 8, not_operator; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:CHECK_TIME_STR; 12, identifier:match; 13, argument_list; 13, 14; 14, identifier:time_str; 15, block; 15, 16; 16, raise_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:ValueError; 19, argument_list; 19, 20; 20, string:'Input can only contain digits and colons'; 21, if_statement; 21, 22; 21, 25; 21, 111; 22, comparison_operator:in; 22, 23; 22, 24; 23, string:':'; 24, identifier:time_str; 25, block; 25, 26; 25, 42; 25, 57; 25, 65; 25, 79; 25, 97; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:time_split; 29, list_comprehension; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:int; 32, argument_list; 32, 33; 33, identifier:x; 34, for_in_clause; 34, 35; 34, 36; 35, identifier:x; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:time_str; 39, identifier:split; 40, argument_list; 40, 41; 41, string:':'; 42, if_statement; 42, 43; 42, 49; 43, comparison_operator:==; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:time_split; 48, integer:2; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:time_split; 54, identifier:append; 55, argument_list; 55, 56; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:clock_time; 60, call; 60, 61; 60, 62; 61, identifier:time; 62, argument_list; 62, 63; 63, list_splat; 63, 64; 64, identifier:time_split; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:chosen_start; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:datetime; 71, identifier:combine; 72, argument_list; 72, 73; 72, 78; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:rec_start; 76, identifier:date; 77, argument_list; 78, identifier:clock_time; 79, if_statement; 79, 80; 79, 87; 80, comparison_operator:<; 80, 81; 80, 82; 81, identifier:clock_time; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:rec_start; 85, identifier:time; 86, argument_list; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, augmented_assignment:+=; 89, 90; 89, 91; 90, identifier:chosen_start; 91, call; 91, 92; 91, 93; 92, identifier:timedelta; 93, argument_list; 93, 94; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:days; 96, integer:1; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:window_start; 100, call; 100, 101; 100, 102; 101, identifier:int; 102, argument_list; 102, 103; 103, call; 103, 104; 103, 110; 104, attribute; 104, 105; 104, 109; 105, parenthesized_expression; 105, 106; 106, binary_operator:-; 106, 107; 106, 108; 107, identifier:chosen_start; 108, identifier:rec_start; 109, identifier:total_seconds; 110, argument_list; 111, else_clause; 111, 112; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:window_start; 116, call; 116, 117; 116, 118; 117, identifier:int; 118, argument_list; 118, 119; 119, identifier:time_str; 120, return_statement; 120, 121; 121, identifier:window_start | def _convert_timestr_to_seconds(time_str, rec_start):
if not CHECK_TIME_STR.match(time_str):
raise ValueError('Input can only contain digits and colons')
if ':' in time_str:
time_split = [int(x) for x in time_str.split(':')]
if len(time_split) == 2:
time_split.append(0)
clock_time = time(*time_split)
chosen_start = datetime.combine(rec_start.date(), clock_time)
if clock_time < rec_start.time():
chosen_start += timedelta(days=1)
window_start = int((chosen_start - rec_start).total_seconds())
else:
window_start = int(time_str)
return window_start |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:mouseReleaseEvent; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:event; 6, block; 6, 7; 6, 14; 6, 20; 6, 32; 6, 39; 6, 55; 6, 71; 6, 82; 6, 362; 6, 368; 6, 376; 7, if_statement; 7, 8; 7, 12; 8, not_operator; 8, 9; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:scene; 12, block; 12, 13; 13, return_statement; 14, if_statement; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:event_sel; 18, block; 18, 19; 19, return_statement; 20, if_statement; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:deselect; 24, block; 24, 25; 24, 31; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:deselect; 30, False; 31, return_statement; 32, if_statement; 32, 33; 32, 37; 33, not_operator; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:ready; 37, block; 37, 38; 38, return_statement; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:chk_marker; 42, call; 42, 43; 42, 54; 43, attribute; 43, 44; 43, 53; 44, subscript; 44, 45; 44, 52; 45, attribute; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:parent; 50, identifier:notes; 51, identifier:action; 52, string:'new_bookmark'; 53, identifier:isChecked; 54, argument_list; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:chk_event; 58, call; 58, 59; 58, 70; 59, attribute; 59, 60; 59, 69; 60, subscript; 60, 61; 60, 68; 61, attribute; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:parent; 66, identifier:notes; 67, identifier:action; 68, string:'new_event'; 69, identifier:isChecked; 70, argument_list; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:y_distance; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:parent; 79, identifier:value; 80, argument_list; 80, 81; 81, string:'y_distance'; 82, if_statement; 82, 83; 82, 86; 82, 310; 83, boolean_operator:or; 83, 84; 83, 85; 84, identifier:chk_marker; 85, identifier:chk_event; 86, block; 86, 87; 86, 104; 86, 121; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:x_in_scene; 90, call; 90, 91; 90, 103; 91, attribute; 91, 92; 91, 102; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:mapToScene; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:event; 100, identifier:pos; 101, argument_list; 102, identifier:x; 103, argument_list; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:y_in_scene; 107, call; 107, 108; 107, 120; 108, attribute; 108, 109; 108, 119; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:mapToScene; 113, argument_list; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:event; 117, identifier:pos; 118, argument_list; 119, identifier:y; 120, argument_list; 121, if_statement; 121, 122; 121, 129; 122, comparison_operator:is; 122, 123; 122, 128; 123, subscript; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:sel_xy; 127, integer:0; 128, None; 129, block; 129, 130; 129, 144; 129, 158; 129, 169; 129, 176; 129, 197; 129, 216; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:s_freq; 133, subscript; 133, 134; 133, 143; 134, attribute; 134, 135; 134, 142; 135, attribute; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:parent; 140, identifier:info; 141, identifier:dataset; 142, identifier:header; 143, string:'s_freq'; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:at_s_freq; 147, lambda; 147, 148; 147, 150; 148, lambda_parameters; 148, 149; 149, identifier:x; 150, binary_operator:/; 150, 151; 150, 157; 151, call; 151, 152; 151, 153; 152, identifier:round; 153, argument_list; 153, 154; 154, binary_operator:*; 154, 155; 154, 156; 155, identifier:x; 156, identifier:s_freq; 157, identifier:s_freq; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:start; 161, call; 161, 162; 161, 163; 162, identifier:at_s_freq; 163, argument_list; 163, 164; 164, subscript; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:sel_xy; 168, integer:0; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:end; 172, call; 172, 173; 172, 174; 173, identifier:at_s_freq; 174, argument_list; 174, 175; 175, identifier:x_in_scene; 176, if_statement; 176, 177; 176, 192; 177, comparison_operator:<; 177, 178; 177, 184; 178, call; 178, 179; 178, 180; 179, identifier:abs; 180, argument_list; 180, 181; 181, binary_operator:-; 181, 182; 181, 183; 182, identifier:end; 183, identifier:start; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:parent; 189, identifier:value; 190, argument_list; 190, 191; 191, string:'min_marker_dur'; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:end; 196, identifier:start; 197, if_statement; 197, 198; 197, 201; 197, 208; 198, comparison_operator:<=; 198, 199; 198, 200; 199, identifier:start; 200, identifier:end; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:time; 205, tuple; 205, 206; 205, 207; 206, identifier:start; 207, identifier:end; 208, else_clause; 208, 209; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:time; 213, tuple; 213, 214; 213, 215; 214, identifier:end; 215, identifier:start; 216, if_statement; 216, 217; 216, 218; 216, 230; 217, identifier:chk_marker; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 228; 221, attribute; 221, 222; 221, 227; 222, attribute; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:parent; 226, identifier:notes; 227, identifier:add_bookmark; 228, argument_list; 228, 229; 229, identifier:time; 230, elif_clause; 230, 231; 230, 236; 231, boolean_operator:and; 231, 232; 231, 233; 232, identifier:chk_event; 233, comparison_operator:!=; 233, 234; 233, 235; 234, identifier:start; 235, identifier:end; 236, block; 236, 237; 236, 251; 236, 297; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:eventtype; 240, call; 240, 241; 240, 250; 241, attribute; 241, 242; 241, 249; 242, attribute; 242, 243; 242, 248; 243, attribute; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:self; 246, identifier:parent; 247, identifier:notes; 248, identifier:idx_eventtype; 249, identifier:currentText; 250, argument_list; 251, if_statement; 251, 252; 251, 266; 251, 271; 252, comparison_operator:>; 252, 253; 252, 263; 253, call; 253, 254; 253, 255; 254, identifier:abs; 255, argument_list; 255, 256; 256, binary_operator:-; 256, 257; 256, 258; 257, identifier:y_in_scene; 258, subscript; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:sel_xy; 262, integer:1; 263, binary_operator:*; 263, 264; 263, 265; 264, float:1.5; 265, identifier:y_distance; 266, block; 266, 267; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:chan; 270, string:''; 271, else_clause; 271, 272; 272, block; 272, 273; 272, 289; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:chan_idx; 276, call; 276, 277; 276, 278; 277, identifier:int; 278, argument_list; 278, 279; 279, call; 279, 280; 279, 281; 280, identifier:floor; 281, argument_list; 281, 282; 282, binary_operator:/; 282, 283; 282, 288; 283, subscript; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:sel_xy; 287, integer:1; 288, identifier:y_distance; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:chan; 292, subscript; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:self; 295, identifier:chan; 296, identifier:chan_idx; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 306; 299, attribute; 299, 300; 299, 305; 300, attribute; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:self; 303, identifier:parent; 304, identifier:notes; 305, identifier:add_event; 306, argument_list; 306, 307; 306, 308; 306, 309; 307, identifier:eventtype; 308, identifier:time; 309, identifier:chan; 310, else_clause; 310, 311; 311, block; 311, 312; 311, 336; 311, 342; 311, 352; 312, if_statement; 312, 313; 312, 324; 313, comparison_operator:in; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:idx_info; 317, call; 317, 318; 317, 323; 318, attribute; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:scene; 322, identifier:items; 323, argument_list; 324, block; 324, 325; 325, expression_statement; 325, 326; 326, call; 326, 327; 326, 332; 327, attribute; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:self; 330, identifier:scene; 331, identifier:removeItem; 332, argument_list; 332, 333; 333, attribute; 333, 334; 333, 335; 334, identifier:self; 335, identifier:idx_info; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:self; 340, identifier:idx_info; 341, None; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 351; 344, attribute; 344, 345; 344, 350; 345, attribute; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:self; 348, identifier:parent; 349, identifier:spectrum; 350, identifier:update; 351, argument_list; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 361; 354, attribute; 354, 355; 354, 360; 355, attribute; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:self; 358, identifier:parent; 359, identifier:spectrum; 360, identifier:display_window; 361, argument_list; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:self; 366, identifier:sel_chan; 367, None; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:self; 372, identifier:sel_xy; 373, tuple; 373, 374; 373, 375; 374, None; 375, None; 376, if_statement; 376, 377; 376, 388; 377, comparison_operator:in; 377, 378; 377, 381; 378, attribute; 378, 379; 378, 380; 379, identifier:self; 380, identifier:idx_sel; 381, call; 381, 382; 381, 387; 382, attribute; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:self; 385, identifier:scene; 386, identifier:items; 387, argument_list; 388, block; 388, 389; 388, 400; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 396; 391, attribute; 391, 392; 391, 395; 392, attribute; 392, 393; 392, 394; 393, identifier:self; 394, identifier:scene; 395, identifier:removeItem; 396, argument_list; 396, 397; 397, attribute; 397, 398; 397, 399; 398, identifier:self; 399, identifier:idx_sel; 400, expression_statement; 400, 401; 401, assignment; 401, 402; 401, 405; 402, attribute; 402, 403; 402, 404; 403, identifier:self; 404, identifier:idx_sel; 405, None | def mouseReleaseEvent(self, event):
if not self.scene:
return
if self.event_sel:
return
if self.deselect:
self.deselect = False
return
if not self.ready:
return
chk_marker = self.parent.notes.action['new_bookmark'].isChecked()
chk_event = self.parent.notes.action['new_event'].isChecked()
y_distance = self.parent.value('y_distance')
if chk_marker or chk_event:
x_in_scene = self.mapToScene(event.pos()).x()
y_in_scene = self.mapToScene(event.pos()).y()
if self.sel_xy[0] is not None:
s_freq = self.parent.info.dataset.header['s_freq']
at_s_freq = lambda x: round(x * s_freq) / s_freq
start = at_s_freq(self.sel_xy[0])
end = at_s_freq(x_in_scene)
if abs(end - start) < self.parent.value('min_marker_dur'):
end = start
if start <= end:
time = (start, end)
else:
time = (end, start)
if chk_marker:
self.parent.notes.add_bookmark(time)
elif chk_event and start != end:
eventtype = self.parent.notes.idx_eventtype.currentText()
if abs(y_in_scene - self.sel_xy[1]) > 1.5 * y_distance:
chan = ''
else:
chan_idx = int(floor(self.sel_xy[1] / y_distance))
chan = self.chan[chan_idx]
self.parent.notes.add_event(eventtype, time, chan)
else:
if self.idx_info in self.scene.items():
self.scene.removeItem(self.idx_info)
self.idx_info = None
self.parent.spectrum.update()
self.parent.spectrum.display_window()
self.sel_chan = None
self.sel_xy = (None, None)
if self.idx_sel in self.scene.items():
self.scene.removeItem(self.idx_sel)
self.idx_sel = None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:next_event; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:delete; 7, False; 8, block; 8, 9; 8, 65; 8, 71; 8, 77; 8, 85; 8, 129; 8, 141; 8, 160; 8, 216; 8, 230; 8, 292; 8, 298; 8, 307; 9, if_statement; 9, 10; 9, 11; 10, identifier:delete; 11, block; 11, 12; 11, 16; 11, 27; 11, 40; 11, 49; 11, 57; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:msg; 15, string:"Delete this event? This cannot be undone."; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:msgbox; 19, call; 19, 20; 19, 21; 20, identifier:QMessageBox; 21, argument_list; 21, 22; 21, 25; 21, 26; 22, attribute; 22, 23; 22, 24; 23, identifier:QMessageBox; 24, identifier:Question; 25, string:'Delete event'; 26, identifier:msg; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:msgbox; 31, identifier:setStandardButtons; 32, argument_list; 32, 33; 33, binary_operator:|; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:QMessageBox; 36, identifier:Yes; 37, attribute; 37, 38; 37, 39; 38, identifier:QMessageBox; 39, identifier:No; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:msgbox; 44, identifier:setDefaultButton; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:QMessageBox; 48, identifier:Yes; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:response; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:msgbox; 55, identifier:exec_; 56, argument_list; 57, if_statement; 57, 58; 57, 63; 58, comparison_operator:==; 58, 59; 58, 60; 59, identifier:response; 60, attribute; 60, 61; 60, 62; 61, identifier:QMessageBox; 62, identifier:No; 63, block; 63, 64; 64, return_statement; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:event_sel; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:event_sel; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:event_sel; 74, None; 75, block; 75, 76; 76, return_statement; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:notes; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:parent; 84, identifier:notes; 85, if_statement; 85, 86; 85, 90; 85, 121; 86, not_operator; 86, 87; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:current_event_row; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:row; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:notes; 97, identifier:find_row; 98, argument_list; 98, 99; 98, 106; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:event_sel; 103, identifier:marker; 104, identifier:x; 105, argument_list; 106, binary_operator:+; 106, 107; 106, 114; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:event_sel; 111, identifier:marker; 112, identifier:x; 113, argument_list; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:event_sel; 118, identifier:marker; 119, identifier:width; 120, argument_list; 121, else_clause; 121, 122; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:row; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:current_event_row; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:same_type; 132, call; 132, 133; 132, 140; 133, attribute; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:action; 138, string:'next_of_same_type'; 139, identifier:isChecked; 140, argument_list; 141, if_statement; 141, 142; 141, 143; 142, identifier:same_type; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:target; 147, call; 147, 148; 147, 159; 148, attribute; 148, 149; 148, 158; 149, call; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:notes; 153, identifier:idx_annot_list; 154, identifier:item; 155, argument_list; 155, 156; 155, 157; 156, identifier:row; 157, integer:2; 158, identifier:text; 159, argument_list; 160, if_statement; 160, 161; 160, 162; 161, identifier:delete; 162, block; 162, 163; 162, 169; 162, 199; 162, 212; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:notes; 167, identifier:delete_row; 168, argument_list; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:msg; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, string:'Deleted event from {} to {}.'; 175, identifier:format; 176, argument_list; 176, 177; 176, 184; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:event_sel; 181, identifier:marker; 182, identifier:x; 183, argument_list; 184, binary_operator:+; 184, 185; 184, 192; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:event_sel; 189, identifier:marker; 190, identifier:x; 191, argument_list; 192, call; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:event_sel; 196, identifier:marker; 197, identifier:width; 198, argument_list; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 210; 201, attribute; 201, 202; 201, 209; 202, call; 202, 203; 202, 208; 203, attribute; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:parent; 207, identifier:statusBar; 208, argument_list; 209, identifier:showMessage; 210, argument_list; 210, 211; 211, identifier:msg; 212, expression_statement; 212, 213; 213, augmented_assignment:-=; 213, 214; 213, 215; 214, identifier:row; 215, integer:1; 216, if_statement; 216, 217; 216, 228; 217, comparison_operator:==; 217, 218; 217, 221; 218, binary_operator:+; 218, 219; 218, 220; 219, identifier:row; 220, integer:1; 221, call; 221, 222; 221, 227; 222, attribute; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:notes; 225, identifier:idx_annot_list; 226, identifier:rowCount; 227, argument_list; 228, block; 228, 229; 229, return_statement; 230, if_statement; 230, 231; 230, 233; 230, 240; 231, not_operator; 231, 232; 232, identifier:same_type; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:next_row; 237, binary_operator:+; 237, 238; 237, 239; 238, identifier:row; 239, integer:1; 240, else_clause; 240, 241; 241, block; 241, 242; 241, 246; 241, 263; 241, 286; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:next_row; 245, None; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:types; 249, subscript; 249, 250; 249, 258; 250, call; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:notes; 254, identifier:idx_annot_list; 255, identifier:property; 256, argument_list; 256, 257; 257, string:'name'; 258, slice; 258, 259; 258, 262; 259, binary_operator:+; 259, 260; 259, 261; 260, identifier:row; 261, integer:1; 262, colon; 263, for_statement; 263, 264; 263, 267; 263, 271; 264, pattern_list; 264, 265; 264, 266; 265, identifier:i; 266, identifier:ty; 267, call; 267, 268; 267, 269; 268, identifier:enumerate; 269, argument_list; 269, 270; 270, identifier:types; 271, block; 271, 272; 272, if_statement; 272, 273; 272, 276; 273, comparison_operator:==; 273, 274; 273, 275; 274, identifier:ty; 275, identifier:target; 276, block; 276, 277; 276, 285; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:next_row; 280, binary_operator:+; 280, 281; 280, 284; 281, binary_operator:+; 281, 282; 281, 283; 282, identifier:row; 283, integer:1; 284, identifier:i; 285, break_statement; 286, if_statement; 286, 287; 286, 290; 287, comparison_operator:is; 287, 288; 287, 289; 288, identifier:next_row; 289, None; 290, block; 290, 291; 291, return_statement; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:self; 296, identifier:current_event_row; 297, identifier:next_row; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:notes; 302, identifier:go_to_marker; 303, argument_list; 303, 304; 303, 305; 303, 306; 304, identifier:next_row; 305, integer:0; 306, string:'annot'; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 314; 309, attribute; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:notes; 312, identifier:idx_annot_list; 313, identifier:setCurrentCell; 314, argument_list; 314, 315; 314, 316; 315, identifier:next_row; 316, integer:0 | def next_event(self, delete=False):
if delete:
msg = "Delete this event? This cannot be undone."
msgbox = QMessageBox(QMessageBox.Question, 'Delete event', msg)
msgbox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msgbox.setDefaultButton(QMessageBox.Yes)
response = msgbox.exec_()
if response == QMessageBox.No:
return
event_sel = self.event_sel
if event_sel is None:
return
notes = self.parent.notes
if not self.current_event_row:
row = notes.find_row(event_sel.marker.x(),
event_sel.marker.x() + event_sel.marker.width())
else:
row = self.current_event_row
same_type = self.action['next_of_same_type'].isChecked()
if same_type:
target = notes.idx_annot_list.item(row, 2).text()
if delete:
notes.delete_row()
msg = 'Deleted event from {} to {}.'.format(event_sel.marker.x(),
event_sel.marker.x() + event_sel.marker.width())
self.parent.statusBar().showMessage(msg)
row -= 1
if row + 1 == notes.idx_annot_list.rowCount():
return
if not same_type:
next_row = row + 1
else:
next_row = None
types = notes.idx_annot_list.property('name')[row + 1:]
for i, ty in enumerate(types):
if ty == target:
next_row = row + 1 + i
break
if next_row is None:
return
self.current_event_row = next_row
notes.go_to_marker(next_row, 0, 'annot')
notes.idx_annot_list.setCurrentCell(next_row, 0) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:montage; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ref_chan; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ref_to_avg; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:bipolar; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:method; 16, string:'average'; 17, block; 17, 18; 17, 32; 17, 66; 17, 75; 17, 150; 17, 329; 18, if_statement; 18, 19; 18, 24; 19, boolean_operator:and; 19, 20; 19, 21; 20, identifier:ref_to_avg; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:ref_chan; 23, None; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:TypeError; 28, argument_list; 28, 29; 29, concatenated_string; 29, 30; 29, 31; 30, string:'You cannot specify reference to the average and '; 31, string:'the channels to use as reference'; 32, if_statement; 32, 33; 32, 36; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:ref_chan; 35, None; 36, block; 36, 37; 37, if_statement; 37, 38; 37, 60; 38, parenthesized_expression; 38, 39; 39, boolean_operator:or; 39, 40; 39, 48; 40, not_operator; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 45; 44, identifier:ref_chan; 45, tuple; 45, 46; 45, 47; 46, identifier:list; 47, identifier:tuple; 48, not_operator; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:all; 51, generator_expression; 51, 52; 51, 57; 52, call; 52, 53; 52, 54; 53, identifier:isinstance; 54, argument_list; 54, 55; 54, 56; 55, identifier:x; 56, identifier:str; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:x; 59, identifier:ref_chan; 60, block; 60, 61; 61, raise_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:TypeError; 64, argument_list; 64, 65; 65, string:'chan should be a list of strings'; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:ref_chan; 69, None; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:ref_chan; 74, list:[]; 75, if_statement; 75, 76; 75, 77; 76, identifier:bipolar; 77, block; 77, 78; 77, 91; 77, 100; 77, 110; 77, 118; 77, 132; 77, 142; 78, if_statement; 78, 79; 78, 85; 79, not_operator; 79, 80; 80, subscript; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:data; 83, identifier:attr; 84, string:'chan'; 85, block; 85, 86; 86, raise_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:ValueError; 89, argument_list; 89, 90; 90, string:'Data should have Chan information in attr'; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:_assert_equal_channels; 94, argument_list; 94, 95; 95, subscript; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:data; 98, identifier:axis; 99, string:'chan'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:chan_in_data; 103, subscript; 103, 104; 103, 109; 104, subscript; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:data; 107, identifier:axis; 108, string:'chan'; 109, integer:0; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:chan; 113, subscript; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:data; 116, identifier:attr; 117, string:'chan'; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:chan; 121, call; 121, 122; 121, 123; 122, identifier:chan; 123, argument_list; 123, 124; 124, lambda; 124, 125; 124, 127; 125, lambda_parameters; 125, 126; 126, identifier:x; 127, comparison_operator:in; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:x; 130, identifier:label; 131, identifier:chan_in_data; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, pattern_list; 134, 135; 134, 136; 135, identifier:chan; 136, identifier:trans; 137, call; 137, 138; 137, 139; 138, identifier:create_bipolar_chan; 139, argument_list; 139, 140; 139, 141; 140, identifier:chan; 141, identifier:bipolar; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 149; 144, subscript; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:data; 147, identifier:attr; 148, string:'chan'; 149, identifier:chan; 150, if_statement; 150, 151; 150, 156; 150, 323; 151, boolean_operator:or; 151, 152; 151, 155; 152, boolean_operator:or; 152, 153; 152, 154; 153, identifier:ref_to_avg; 154, identifier:ref_chan; 155, identifier:bipolar; 156, block; 156, 157; 156, 165; 156, 174; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:mdata; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:data; 163, identifier:_copy; 164, argument_list; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:idx_chan; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:mdata; 171, identifier:index_of; 172, argument_list; 172, 173; 173, string:'chan'; 174, for_statement; 174, 175; 174, 176; 174, 185; 175, identifier:i; 176, call; 176, 177; 176, 178; 177, identifier:range; 178, argument_list; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:mdata; 182, identifier:number_of; 183, argument_list; 183, 184; 184, string:'trial'; 185, block; 185, 186; 186, if_statement; 186, 187; 186, 190; 186, 265; 187, boolean_operator:or; 187, 188; 187, 189; 188, identifier:ref_to_avg; 189, identifier:ref_chan; 190, block; 190, 191; 190, 204; 190, 216; 191, if_statement; 191, 192; 191, 193; 192, identifier:ref_to_avg; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:ref_chan; 197, subscript; 197, 198; 197, 203; 198, subscript; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:data; 201, identifier:axis; 202, string:'chan'; 203, identifier:i; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:ref_data; 207, call; 207, 208; 207, 209; 208, identifier:data; 209, argument_list; 209, 210; 209, 213; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:trial; 212, identifier:i; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:chan; 215, identifier:ref_chan; 216, if_statement; 216, 217; 216, 220; 216, 243; 217, comparison_operator:==; 217, 218; 217, 219; 218, identifier:method; 219, string:'average'; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 228; 223, subscript; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:mdata; 226, identifier:data; 227, identifier:i; 228, parenthesized_expression; 228, 229; 229, binary_operator:-; 229, 230; 229, 236; 230, call; 230, 231; 230, 232; 231, identifier:data; 232, argument_list; 232, 233; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:trial; 235, identifier:i; 236, call; 236, 237; 236, 238; 237, identifier:mean; 238, argument_list; 238, 239; 238, 240; 239, identifier:ref_data; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:axis; 242, identifier:idx_chan; 243, elif_clause; 243, 244; 243, 247; 244, comparison_operator:==; 244, 245; 244, 246; 245, identifier:method; 246, string:'regression'; 247, block; 247, 248; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 255; 250, subscript; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:mdata; 253, identifier:data; 254, identifier:i; 255, call; 255, 256; 255, 257; 256, identifier:compute_average_regress; 257, argument_list; 257, 258; 257, 264; 258, call; 258, 259; 258, 260; 259, identifier:data; 260, argument_list; 260, 261; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:trial; 263, identifier:i; 264, identifier:idx_chan; 265, elif_clause; 265, 266; 265, 267; 266, identifier:bipolar; 267, block; 267, 268; 267, 286; 267, 303; 268, if_statement; 268, 269; 268, 278; 269, not_operator; 269, 270; 270, comparison_operator:==; 270, 271; 270, 277; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:data; 274, identifier:index_of; 275, argument_list; 275, 276; 276, string:'chan'; 277, integer:0; 278, block; 278, 279; 279, raise_statement; 279, 280; 280, call; 280, 281; 280, 282; 281, identifier:ValueError; 282, argument_list; 282, 283; 283, concatenated_string; 283, 284; 283, 285; 284, string:'For matrix multiplication to work, '; 285, string:'the first dimension should be chan'; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 293; 288, subscript; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:mdata; 291, identifier:data; 292, identifier:i; 293, call; 293, 294; 293, 295; 294, identifier:dot; 295, argument_list; 295, 296; 295, 297; 296, identifier:trans; 297, call; 297, 298; 297, 299; 298, identifier:data; 299, argument_list; 299, 300; 300, keyword_argument; 300, 301; 300, 302; 301, identifier:trial; 302, identifier:i; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 312; 305, subscript; 305, 306; 305, 311; 306, subscript; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:mdata; 309, identifier:axis; 310, string:'chan'; 311, identifier:i; 312, call; 312, 313; 312, 314; 313, identifier:asarray; 314, argument_list; 314, 315; 314, 320; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:chan; 318, identifier:return_label; 319, argument_list; 320, keyword_argument; 320, 321; 320, 322; 321, identifier:dtype; 322, string:'U'; 323, else_clause; 323, 324; 324, block; 324, 325; 325, expression_statement; 325, 326; 326, assignment; 326, 327; 326, 328; 327, identifier:mdata; 328, identifier:data; 329, return_statement; 329, 330; 330, identifier:mdata | def montage(data, ref_chan=None, ref_to_avg=False, bipolar=None,
method='average'):
if ref_to_avg and ref_chan is not None:
raise TypeError('You cannot specify reference to the average and '
'the channels to use as reference')
if ref_chan is not None:
if (not isinstance(ref_chan, (list, tuple)) or
not all(isinstance(x, str) for x in ref_chan)):
raise TypeError('chan should be a list of strings')
if ref_chan is None:
ref_chan = []
if bipolar:
if not data.attr['chan']:
raise ValueError('Data should have Chan information in attr')
_assert_equal_channels(data.axis['chan'])
chan_in_data = data.axis['chan'][0]
chan = data.attr['chan']
chan = chan(lambda x: x.label in chan_in_data)
chan, trans = create_bipolar_chan(chan, bipolar)
data.attr['chan'] = chan
if ref_to_avg or ref_chan or bipolar:
mdata = data._copy()
idx_chan = mdata.index_of('chan')
for i in range(mdata.number_of('trial')):
if ref_to_avg or ref_chan:
if ref_to_avg:
ref_chan = data.axis['chan'][i]
ref_data = data(trial=i, chan=ref_chan)
if method == 'average':
mdata.data[i] = (data(trial=i) - mean(ref_data, axis=idx_chan))
elif method == 'regression':
mdata.data[i] = compute_average_regress(data(trial=i), idx_chan)
elif bipolar:
if not data.index_of('chan') == 0:
raise ValueError('For matrix multiplication to work, '
'the first dimension should be chan')
mdata.data[i] = dot(trans, data(trial=i))
mdata.axis['chan'][i] = asarray(chan.return_label(),
dtype='U')
else:
mdata = data
return mdata |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:remove_artf_evts; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:times; 5, identifier:annot; 6, default_parameter; 6, 7; 6, 8; 7, identifier:chan; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:min_dur; 11, float:0.1; 12, block; 12, 13; 12, 17; 12, 25; 12, 35; 12, 44; 12, 66; 12, 237; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:new_times; 16, identifier:times; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:beg; 20, subscript; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:times; 23, integer:0; 24, integer:0; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:end; 28, subscript; 28, 29; 28, 33; 29, subscript; 29, 30; 29, 31; 30, identifier:times; 31, unary_operator:-; 31, 32; 32, integer:1; 33, unary_operator:-; 33, 34; 34, integer:1; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:chan; 38, conditional_expression:if; 38, 39; 38, 42; 38, 43; 39, tuple; 39, 40; 39, 41; 40, identifier:chan; 41, string:''; 42, identifier:chan; 43, None; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:artefact; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:annot; 50, identifier:get_events; 51, argument_list; 51, 52; 51, 55; 51, 60; 51, 63; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:name; 54, string:'Artefact'; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:time; 57, tuple; 57, 58; 57, 59; 58, identifier:beg; 59, identifier:end; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:chan; 62, identifier:chan; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:qual; 65, string:'Good'; 66, if_statement; 66, 67; 66, 68; 67, identifier:artefact; 68, block; 68, 69; 68, 73; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:new_times; 72, list:[]; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:seg; 75, identifier:times; 76, block; 76, 77; 76, 81; 76, 85; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:reject; 80, False; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:new_seg; 84, True; 85, while_statement; 85, 86; 85, 89; 86, comparison_operator:is; 86, 87; 86, 88; 87, identifier:new_seg; 88, False; 89, block; 89, 90; 89, 102; 89, 108; 89, 215; 90, if_statement; 90, 91; 90, 97; 91, comparison_operator:is; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:type; 94, argument_list; 94, 95; 95, identifier:new_seg; 96, identifier:tuple; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:seg; 101, identifier:new_seg; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:end; 105, subscript; 105, 106; 105, 107; 106, identifier:seg; 107, integer:1; 108, for_statement; 108, 109; 108, 110; 108, 111; 109, identifier:artf; 110, identifier:artefact; 111, block; 111, 112; 111, 138; 111, 151; 111, 164; 111, 211; 112, if_statement; 112, 113; 112, 128; 113, boolean_operator:and; 113, 114; 113, 121; 114, comparison_operator:<=; 114, 115; 114, 118; 115, subscript; 115, 116; 115, 117; 116, identifier:artf; 117, string:'start'; 118, subscript; 118, 119; 118, 120; 119, identifier:seg; 120, integer:0; 121, comparison_operator:<=; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:seg; 124, integer:1; 125, subscript; 125, 126; 125, 127; 126, identifier:artf; 127, string:'end'; 128, block; 128, 129; 128, 133; 128, 137; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:reject; 132, True; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:new_seg; 136, False; 137, break_statement; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:a_starts_in_s; 141, comparison_operator:<=; 141, 142; 141, 145; 141, 148; 142, subscript; 142, 143; 142, 144; 143, identifier:seg; 144, integer:0; 145, subscript; 145, 146; 145, 147; 146, identifier:artf; 147, string:'start'; 148, subscript; 148, 149; 148, 150; 149, identifier:seg; 150, integer:1; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:a_ends_in_s; 154, comparison_operator:<=; 154, 155; 154, 158; 154, 161; 155, subscript; 155, 156; 155, 157; 156, identifier:seg; 157, integer:0; 158, subscript; 158, 159; 158, 160; 159, identifier:artf; 160, string:'end'; 161, subscript; 161, 162; 161, 163; 162, identifier:seg; 163, integer:1; 164, if_statement; 164, 165; 164, 169; 164, 180; 165, boolean_operator:and; 165, 166; 165, 167; 166, identifier:a_ends_in_s; 167, not_operator; 167, 168; 168, identifier:a_starts_in_s; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:seg; 173, expression_list; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:artf; 176, string:'end'; 177, subscript; 177, 178; 177, 179; 178, identifier:seg; 179, integer:1; 180, elif_clause; 180, 181; 180, 182; 181, identifier:a_starts_in_s; 182, block; 182, 183; 182, 193; 182, 210; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:seg; 186, expression_list; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:seg; 189, integer:0; 190, subscript; 190, 191; 190, 192; 191, identifier:artf; 192, string:'start'; 193, if_statement; 193, 194; 193, 195; 193, 204; 194, identifier:a_ends_in_s; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:new_seg; 199, expression_list; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:artf; 202, string:'end'; 203, identifier:end; 204, else_clause; 204, 205; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:new_seg; 209, False; 210, break_statement; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:new_seg; 214, False; 215, if_statement; 215, 216; 215, 229; 216, boolean_operator:and; 216, 217; 216, 220; 217, comparison_operator:is; 217, 218; 217, 219; 218, identifier:reject; 219, False; 220, comparison_operator:>=; 220, 221; 220, 228; 221, binary_operator:-; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:seg; 224, integer:1; 225, subscript; 225, 226; 225, 227; 226, identifier:seg; 227, integer:0; 228, identifier:min_dur; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:new_times; 234, identifier:append; 235, argument_list; 235, 236; 236, identifier:seg; 237, return_statement; 237, 238; 238, identifier:new_times | def remove_artf_evts(times, annot, chan=None, min_dur=0.1):
new_times = times
beg = times[0][0]
end = times[-1][-1]
chan = (chan, '') if chan else None
artefact = annot.get_events(name='Artefact', time=(beg, end), chan=chan,
qual='Good')
if artefact:
new_times = []
for seg in times:
reject = False
new_seg = True
while new_seg is not False:
if type(new_seg) is tuple:
seg = new_seg
end = seg[1]
for artf in artefact:
if artf['start'] <= seg[0] and seg[1] <= artf['end']:
reject = True
new_seg = False
break
a_starts_in_s = seg[0] <= artf['start'] <= seg[1]
a_ends_in_s = seg[0] <= artf['end'] <= seg[1]
if a_ends_in_s and not a_starts_in_s:
seg = artf['end'], seg[1]
elif a_starts_in_s:
seg = seg[0], artf['start']
if a_ends_in_s:
new_seg = artf['end'], end
else:
new_seg = False
break
new_seg = False
if reject is False and seg[1] - seg[0] >= min_dur:
new_times.append(seg)
return new_times |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_build_app_dict; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:site; 5, identifier:request; 6, default_parameter; 6, 7; 6, 8; 7, identifier:label; 8, None; 9, block; 9, 10; 9, 14; 9, 51; 9, 257; 9, 267; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:app_dict; 13, dictionary; 14, if_statement; 14, 15; 14, 16; 14, 43; 15, identifier:label; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:models; 20, dictionary_comprehension; 20, 21; 20, 24; 20, 35; 21, pair; 21, 22; 21, 23; 22, identifier:m; 23, identifier:m_a; 24, for_in_clause; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:m; 27, identifier:m_a; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:site; 32, identifier:_registry; 33, identifier:items; 34, argument_list; 35, if_clause; 35, 36; 36, comparison_operator:==; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:m; 40, identifier:_meta; 41, identifier:app_label; 42, identifier:label; 43, else_clause; 43, 44; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:models; 48, attribute; 48, 49; 48, 50; 49, identifier:site; 50, identifier:_registry; 51, for_statement; 51, 52; 51, 55; 51, 60; 52, pattern_list; 52, 53; 52, 54; 53, identifier:model; 54, identifier:model_admin; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:models; 58, identifier:items; 59, argument_list; 60, block; 60, 61; 60, 69; 60, 78; 60, 83; 60, 92; 60, 102; 60, 112; 60, 136; 60, 166; 60, 196; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:app_label; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:model; 67, identifier:_meta; 68, identifier:app_label; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:has_module_perms; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:model_admin; 75, identifier:has_module_permission; 76, argument_list; 76, 77; 77, identifier:request; 78, if_statement; 78, 79; 78, 81; 79, not_operator; 79, 80; 80, identifier:has_module_perms; 81, block; 81, 82; 82, continue_statement; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:perms; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:model_admin; 89, identifier:get_model_perms; 90, argument_list; 90, 91; 91, identifier:request; 92, if_statement; 92, 93; 92, 100; 93, comparison_operator:not; 93, 94; 93, 95; 94, True; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:perms; 98, identifier:values; 99, argument_list; 100, block; 100, 101; 101, continue_statement; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:info; 105, tuple; 105, 106; 105, 107; 106, identifier:app_label; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:model; 110, identifier:_meta; 111, identifier:model_name; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:model_dict; 115, dictionary; 115, 116; 115, 126; 115, 133; 116, pair; 116, 117; 116, 118; 117, string:'name'; 118, call; 118, 119; 118, 120; 119, identifier:capfirst; 120, argument_list; 120, 121; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:model; 124, identifier:_meta; 125, identifier:verbose_name_plural; 126, pair; 126, 127; 126, 128; 127, string:'object_name'; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:model; 131, identifier:_meta; 132, identifier:object_name; 133, pair; 133, 134; 133, 135; 134, string:'perms'; 135, identifier:perms; 136, if_statement; 136, 137; 136, 143; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:perms; 140, identifier:get; 141, argument_list; 141, 142; 142, string:'change'; 143, block; 143, 144; 144, try_statement; 144, 145; 144, 162; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:model_dict; 150, string:'admin_url'; 151, call; 151, 152; 151, 153; 152, identifier:reverse; 153, argument_list; 153, 154; 153, 157; 154, binary_operator:%; 154, 155; 154, 156; 155, string:'admin:%s_%s_changelist'; 156, identifier:info; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:current_app; 159, attribute; 159, 160; 159, 161; 160, identifier:site; 161, identifier:name; 162, except_clause; 162, 163; 162, 164; 163, identifier:NoReverseMatch; 164, block; 164, 165; 165, pass_statement; 166, if_statement; 166, 167; 166, 173; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:perms; 170, identifier:get; 171, argument_list; 171, 172; 172, string:'add'; 173, block; 173, 174; 174, try_statement; 174, 175; 174, 192; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:model_dict; 180, string:'add_url'; 181, call; 181, 182; 181, 183; 182, identifier:reverse; 183, argument_list; 183, 184; 183, 187; 184, binary_operator:%; 184, 185; 184, 186; 185, string:'admin:%s_%s_add'; 186, identifier:info; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:current_app; 189, attribute; 189, 190; 189, 191; 190, identifier:site; 191, identifier:name; 192, except_clause; 192, 193; 192, 194; 193, identifier:NoReverseMatch; 194, block; 194, 195; 195, pass_statement; 196, if_statement; 196, 197; 196, 200; 196, 212; 197, comparison_operator:in; 197, 198; 197, 199; 198, identifier:app_label; 199, identifier:app_dict; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 210; 203, attribute; 203, 204; 203, 209; 204, subscript; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:app_dict; 207, identifier:app_label; 208, string:'models'; 209, identifier:append; 210, argument_list; 210, 211; 211, identifier:model_dict; 212, else_clause; 212, 213; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:app_dict; 218, identifier:app_label; 219, dictionary; 219, 220; 219, 230; 219, 233; 219, 250; 219, 253; 220, pair; 220, 221; 220, 222; 221, string:'name'; 222, attribute; 222, 223; 222, 229; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:apps; 226, identifier:get_app_config; 227, argument_list; 227, 228; 228, identifier:app_label; 229, identifier:verbose_name; 230, pair; 230, 231; 230, 232; 231, string:'app_label'; 232, identifier:app_label; 233, pair; 233, 234; 233, 235; 234, string:'app_url'; 235, call; 235, 236; 235, 237; 236, identifier:reverse; 237, argument_list; 237, 238; 237, 239; 237, 245; 238, string:'admin:app_list'; 239, keyword_argument; 239, 240; 239, 241; 240, identifier:kwargs; 241, dictionary; 241, 242; 242, pair; 242, 243; 242, 244; 243, string:'app_label'; 244, identifier:app_label; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:current_app; 247, attribute; 247, 248; 247, 249; 248, identifier:site; 249, identifier:name; 250, pair; 250, 251; 250, 252; 251, string:'has_module_perms'; 252, identifier:has_module_perms; 253, pair; 253, 254; 253, 255; 254, string:'models'; 255, list:[model_dict]; 255, 256; 256, identifier:model_dict; 257, if_statement; 257, 258; 257, 259; 258, identifier:label; 259, block; 259, 260; 260, return_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:app_dict; 264, identifier:get; 265, argument_list; 265, 266; 266, identifier:label; 267, return_statement; 267, 268; 268, identifier:app_dict | def _build_app_dict(site, request, label=None):
app_dict = {}
if label:
models = {
m: m_a for m, m_a in site._registry.items()
if m._meta.app_label == label
}
else:
models = site._registry
for model, model_admin in models.items():
app_label = model._meta.app_label
has_module_perms = model_admin.has_module_permission(request)
if not has_module_perms:
continue
perms = model_admin.get_model_perms(request)
if True not in perms.values():
continue
info = (app_label, model._meta.model_name)
model_dict = {
'name': capfirst(model._meta.verbose_name_plural),
'object_name': model._meta.object_name,
'perms': perms,
}
if perms.get('change'):
try:
model_dict['admin_url'] = reverse('admin:%s_%s_changelist' % info, current_app=site.name)
except NoReverseMatch:
pass
if perms.get('add'):
try:
model_dict['add_url'] = reverse('admin:%s_%s_add' % info, current_app=site.name)
except NoReverseMatch:
pass
if app_label in app_dict:
app_dict[app_label]['models'].append(model_dict)
else:
app_dict[app_label] = {
'name': apps.get_app_config(app_label).verbose_name,
'app_label': app_label,
'app_url': reverse(
'admin:app_list',
kwargs={'app_label': app_label},
current_app=site.name,
),
'has_module_perms': has_module_perms,
'models': [model_dict],
}
if label:
return app_dict.get(label)
return app_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_app_list; 3, parameters; 3, 4; 3, 5; 4, identifier:site; 5, identifier:request; 6, block; 6, 7; 6, 15; 6, 38; 6, 58; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:app_dict; 10, call; 10, 11; 10, 12; 11, identifier:_build_app_dict; 12, argument_list; 12, 13; 12, 14; 13, identifier:site; 14, identifier:request; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:app_list; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 20, 26; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:app_dict; 24, identifier:values; 25, argument_list; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:key; 28, lambda; 28, 29; 28, 31; 29, lambda_parameters; 29, 30; 30, identifier:x; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:x; 35, string:'name'; 36, identifier:lower; 37, argument_list; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:app; 40, identifier:app_list; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:app; 47, string:'models'; 48, identifier:sort; 49, argument_list; 49, 50; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:key; 52, lambda; 52, 53; 52, 55; 53, lambda_parameters; 53, 54; 54, identifier:x; 55, subscript; 55, 56; 55, 57; 56, identifier:x; 57, string:'name'; 58, return_statement; 58, 59; 59, identifier:app_list | def get_app_list(site, request):
app_dict = _build_app_dict(site, request)
app_list = sorted(app_dict.values(), key=lambda x: x['name'].lower())
for app in app_list:
app['models'].sort(key=lambda x: x['name'])
return app_list |
0, module; 0, 1; 1, ERROR; 1, 2; 2, function_definition; 2, 3; 2, 4; 2, 8; 3, function_name:format_query_results; 4, parameters; 4, 5; 4, 6; 4, 7; 5, identifier:self; 6, identifier:r; 7, identifier:prop_nr; 8, block; 8, 9; 8, 18; 8, 114; 8, 187; 8, 248; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:prop_dt; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:get_prop_datatype; 16, argument_list; 16, 17; 17, identifier:prop_nr; 18, for_statement; 18, 19; 18, 20; 18, 21; 19, identifier:i; 20, identifier:r; 21, block; 21, 22; 21, 54; 22, for_statement; 22, 23; 22, 24; 22, 30; 23, identifier:value; 24, set; 24, 25; 24, 26; 24, 27; 24, 28; 24, 29; 25, string:'item'; 26, string:'sid'; 27, string:'pq'; 28, string:'pr'; 29, string:'ref'; 30, block; 30, 31; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:in; 32, 33; 32, 34; 33, identifier:value; 34, identifier:i; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:i; 40, identifier:value; 41, subscript; 41, 42; 41, 52; 42, call; 42, 43; 42, 50; 43, attribute; 43, 44; 43, 49; 44, subscript; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:i; 47, identifier:value; 48, string:'value'; 49, identifier:split; 50, argument_list; 50, 51; 51, string:'/'; 52, unary_operator:-; 52, 53; 53, integer:1; 54, for_statement; 54, 55; 54, 56; 54, 60; 55, identifier:value; 56, set; 56, 57; 56, 58; 56, 59; 57, string:'v'; 58, string:'qval'; 59, string:'rval'; 60, block; 60, 61; 61, if_statement; 61, 62; 61, 65; 61, 99; 62, comparison_operator:in; 62, 63; 62, 64; 63, identifier:value; 64, identifier:i; 65, ERROR; 65, 66; 65, 90; 66, if_statement; 66, 67; 66, 78; 66, 79; 67, comparison_operator:==; 67, 68; 67, 76; 67, 77; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:i; 72, identifier:value; 73, identifier:get; 74, argument_list; 74, 75; 75, string:"datatype"; 76, ERROR; 77, identifier:http; 78, ERROR; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, binary_operator:/; 81, 82; 81, 89; 82, binary_operator:/; 82, 83; 82, 88; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:www; 86, identifier:w3; 87, identifier:org; 88, integer:2001; 89, identifier:XMLSchema; 90, comparison_operator:in; 90, 91; 90, 98; 91, subscript; 91, 92; 91, 97; 92, subscript; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:i; 95, identifier:value; 96, string:'value'; 97, integer:0; 98, string:'+-'; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:i; 105, identifier:value; 106, string:'value'; 107, binary_operator:+; 107, 108; 107, 109; 108, string:'+'; 109, subscript; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:i; 112, identifier:value; 113, string:'value'; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:in; 115, 116; 115, 117; 116, string:'v'; 117, identifier:i; 118, block; 118, 119; 118, 162; 119, if_statement; 119, 120; 119, 131; 119, 150; 120, boolean_operator:and; 120, 121; 120, 128; 121, comparison_operator:==; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:i; 125, string:'v'; 126, string:'type'; 127, string:'uri'; 128, comparison_operator:==; 128, 129; 128, 130; 129, identifier:prop_dt; 130, string:'wikibase-item'; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:i; 136, string:'v'; 137, subscript; 137, 138; 137, 148; 138, call; 138, 139; 138, 146; 139, attribute; 139, 140; 139, 145; 140, subscript; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:i; 143, string:'v'; 144, string:'value'; 145, identifier:split; 146, argument_list; 146, 147; 147, string:'/'; 148, unary_operator:-; 148, 149; 149, integer:1; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 157; 154, subscript; 154, 155; 154, 156; 155, identifier:i; 156, string:'v'; 157, subscript; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:i; 160, string:'v'; 161, string:'value'; 162, if_statement; 162, 163; 162, 171; 163, comparison_operator:is; 163, 164; 163, 170; 164, call; 164, 165; 164, 166; 165, identifier:type; 166, argument_list; 166, 167; 167, subscript; 167, 168; 167, 169; 168, identifier:i; 169, string:'v'; 170, identifier:dict; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 183; 174, attribute; 174, 175; 174, 182; 175, subscript; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:rev_lookup; 179, subscript; 179, 180; 179, 181; 180, identifier:i; 181, string:'v'; 182, identifier:add; 183, argument_list; 183, 184; 184, subscript; 184, 185; 184, 186; 185, identifier:i; 186, string:'item'; 187, if_statement; 187, 188; 187, 191; 188, comparison_operator:in; 188, 189; 188, 190; 189, string:'qval'; 190, identifier:i; 191, block; 191, 192; 191, 205; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:qual_prop_dt; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:get_prop_datatype; 199, argument_list; 199, 200; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:prop_nr; 202, subscript; 202, 203; 202, 204; 203, identifier:i; 204, string:'pq'; 205, if_statement; 205, 206; 205, 217; 205, 236; 206, boolean_operator:and; 206, 207; 206, 214; 207, comparison_operator:==; 207, 208; 207, 213; 208, subscript; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:i; 211, string:'qval'; 212, string:'type'; 213, string:'uri'; 214, comparison_operator:==; 214, 215; 214, 216; 215, identifier:qual_prop_dt; 216, string:'wikibase-item'; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:i; 222, string:'qval'; 223, subscript; 223, 224; 223, 234; 224, call; 224, 225; 224, 232; 225, attribute; 225, 226; 225, 231; 226, subscript; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:i; 229, string:'qval'; 230, string:'value'; 231, identifier:split; 232, argument_list; 232, 233; 233, string:'/'; 234, unary_operator:-; 234, 235; 235, integer:1; 236, else_clause; 236, 237; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:i; 242, string:'qval'; 243, subscript; 243, 244; 243, 247; 244, subscript; 244, 245; 244, 246; 245, identifier:i; 246, string:'qval'; 247, string:'value'; 248, if_statement; 248, 249; 248, 252; 249, comparison_operator:in; 249, 250; 249, 251; 250, string:'rval'; 251, identifier:i; 252, block; 252, 253; 252, 266; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:ref_prop_dt; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:get_prop_datatype; 260, argument_list; 260, 261; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:prop_nr; 263, subscript; 263, 264; 263, 265; 264, identifier:i; 265, string:'pr'; 266, if_statement; 266, 267; 266, 278; 266, 297; 267, boolean_operator:and; 267, 268; 267, 275; 268, comparison_operator:==; 268, 269; 268, 274; 269, subscript; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:i; 272, string:'rval'; 273, string:'type'; 274, string:'uri'; 275, comparison_operator:==; 275, 276; 275, 277; 276, identifier:ref_prop_dt; 277, string:'wikibase-item'; 278, block; 278, 279; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 284; 281, subscript; 281, 282; 281, 283; 282, identifier:i; 283, string:'rval'; 284, subscript; 284, 285; 284, 295; 285, call; 285, 286; 285, 293; 286, attribute; 286, 287; 286, 292; 287, subscript; 287, 288; 287, 291; 288, subscript; 288, 289; 288, 290; 289, identifier:i; 290, string:'rval'; 291, string:'value'; 292, identifier:split; 293, argument_list; 293, 294; 294, string:'/'; 295, unary_operator:-; 295, 296; 296, integer:1; 297, else_clause; 297, 298; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 304; 301, subscript; 301, 302; 301, 303; 302, identifier:i; 303, string:'rval'; 304, subscript; 304, 305; 304, 308; 305, subscript; 305, 306; 305, 307; 306, identifier:i; 307, string:'rval'; 308, string:'value' | def format_query_results(self, r, prop_nr):
prop_dt = self.get_prop_datatype(prop_nr)
for i in r:
for value in {'item', 'sid', 'pq', 'pr', 'ref'}:
if value in i:
i[value] = i[value]['value'].split('/')[-1]
for value in {'v', 'qval', 'rval'}:
if value in i:
if i[value].get("datatype") == 'http://www.w3.org/2001/XMLSchema
i[value]['value'][0] in '+-':
i[value]['value'] = '+' + i[value]['value']
if 'v' in i:
if i['v']['type'] == 'uri' and prop_dt == 'wikibase-item':
i['v'] = i['v']['value'].split('/')[-1]
else:
i['v'] = i['v']['value']
if type(i['v']) is not dict:
self.rev_lookup[i['v']].add(i['item'])
if 'qval' in i:
qual_prop_dt = self.get_prop_datatype(prop_nr=i['pq'])
if i['qval']['type'] == 'uri' and qual_prop_dt == 'wikibase-item':
i['qval'] = i['qval']['value'].split('/')[-1]
else:
i['qval'] = i['qval']['value']
if 'rval' in i:
ref_prop_dt = self.get_prop_datatype(prop_nr=i['pr'])
if i['rval']['type'] == 'uri' and ref_prop_dt == 'wikibase-item':
i['rval'] = i['rval']['value'].split('/')[-1]
else:
i['rval'] = i['rval']['value'] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:times; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:p; 5, identifier:mint; 6, default_parameter; 6, 7; 6, 8; 7, identifier:maxt; 8, None; 9, block; 9, 10; 9, 12; 9, 19; 9, 153; 10, expression_statement; 10, 11; 11, string:'''Repeat a parser between `mint` and `maxt` times. DO AS MUCH MATCH AS IT CAN.
Return a list of values.'''; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:maxt; 15, conditional_expression:if; 15, 16; 15, 17; 15, 18; 16, identifier:maxt; 17, identifier:maxt; 18, identifier:mint; 19, decorated_definition; 19, 20; 19, 22; 20, decorator; 20, 21; 21, identifier:Parser; 22, function_definition; 22, 23; 22, 24; 22, 27; 23, function_name:times_parser; 24, parameters; 24, 25; 24, 26; 25, identifier:text; 26, identifier:index; 27, block; 27, 28; 27, 44; 27, 151; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 34; 30, pattern_list; 30, 31; 30, 32; 30, 33; 31, identifier:cnt; 32, identifier:values; 33, identifier:res; 34, expression_list; 34, 35; 34, 36; 34, 43; 35, integer:0; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:Value; 39, identifier:success; 40, argument_list; 40, 41; 40, 42; 41, identifier:index; 42, list:[]; 43, None; 44, while_statement; 44, 45; 44, 48; 45, comparison_operator:<; 45, 46; 45, 47; 46, identifier:cnt; 47, identifier:maxt; 48, block; 48, 49; 48, 57; 48, 106; 48, 112; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:res; 52, call; 52, 53; 52, 54; 53, identifier:p; 54, argument_list; 54, 55; 54, 56; 55, identifier:text; 56, identifier:index; 57, if_statement; 57, 58; 57, 61; 57, 94; 58, attribute; 58, 59; 58, 60; 59, identifier:res; 60, identifier:status; 61, block; 61, 62; 61, 82; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:values; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:values; 68, identifier:aggregate; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:Value; 73, identifier:success; 74, argument_list; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:res; 77, identifier:index; 78, list:[res.value]; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:res; 81, identifier:value; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, pattern_list; 84, 85; 84, 86; 85, identifier:index; 86, identifier:cnt; 87, expression_list; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:res; 90, identifier:index; 91, binary_operator:+; 91, 92; 91, 93; 92, identifier:cnt; 93, integer:1; 94, else_clause; 94, 95; 95, block; 95, 96; 96, if_statement; 96, 97; 96, 100; 96, 102; 97, comparison_operator:>=; 97, 98; 97, 99; 98, identifier:cnt; 99, identifier:mint; 100, block; 100, 101; 101, break_statement; 102, else_clause; 102, 103; 103, block; 103, 104; 104, return_statement; 104, 105; 105, identifier:res; 106, if_statement; 106, 107; 106, 110; 107, comparison_operator:>=; 107, 108; 107, 109; 108, identifier:cnt; 109, identifier:maxt; 110, block; 110, 111; 111, break_statement; 112, if_statement; 112, 113; 112, 119; 113, comparison_operator:>=; 113, 114; 113, 115; 114, identifier:index; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, identifier:text; 119, block; 119, 120; 120, if_statement; 120, 121; 120, 124; 120, 126; 121, comparison_operator:>=; 121, 122; 121, 123; 122, identifier:cnt; 123, identifier:mint; 124, block; 124, 125; 125, break_statement; 126, else_clause; 126, 127; 127, block; 127, 128; 127, 136; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:r; 131, call; 131, 132; 131, 133; 132, identifier:p; 133, argument_list; 133, 134; 133, 135; 134, identifier:text; 135, identifier:index; 136, if_statement; 136, 137; 136, 142; 137, comparison_operator:!=; 137, 138; 137, 139; 138, identifier:index; 139, attribute; 139, 140; 139, 141; 140, identifier:r; 141, identifier:index; 142, block; 142, 143; 143, return_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:Value; 147, identifier:failure; 148, argument_list; 148, 149; 148, 150; 149, identifier:index; 150, string:"already meets the end, no enough text"; 151, return_statement; 151, 152; 152, identifier:values; 153, return_statement; 153, 154; 154, identifier:times_parser | def times(p, mint, maxt=None):
'''Repeat a parser between `mint` and `maxt` times. DO AS MUCH MATCH AS IT CAN.
Return a list of values.'''
maxt = maxt if maxt else mint
@Parser
def times_parser(text, index):
cnt, values, res = 0, Value.success(index, []), None
while cnt < maxt:
res = p(text, index)
if res.status:
values = values.aggregate(
Value.success(res.index, [res.value]))
index, cnt = res.index, cnt + 1
else:
if cnt >= mint:
break
else:
return res
if cnt >= maxt:
break
if index >= len(text):
if cnt >= mint:
break
else:
r = p(text, index)
if index != r.index:
return Value.failure(index, "already meets the end, no enough text")
return values
return times_parser |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:separated; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:p; 5, identifier:sep; 6, identifier:mint; 7, default_parameter; 7, 8; 7, 9; 8, identifier:maxt; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:end; 12, None; 13, block; 13, 14; 13, 16; 13, 23; 13, 212; 14, expression_statement; 14, 15; 15, string:'''Repeat a parser `p` separated by `s` between `mint` and `maxt` times.
When `end` is None, a trailing separator is optional.
When `end` is True, a trailing separator is required.
When `end` is False, a trailing separator is not allowed.
MATCHES AS MUCH AS POSSIBLE.
Return list of values returned by `p`.'''; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:maxt; 19, conditional_expression:if; 19, 20; 19, 21; 19, 22; 20, identifier:maxt; 21, identifier:maxt; 22, identifier:mint; 23, decorated_definition; 23, 24; 23, 26; 24, decorator; 24, 25; 25, identifier:Parser; 26, function_definition; 26, 27; 26, 28; 26, 31; 27, function_name:sep_parser; 28, parameters; 28, 29; 28, 30; 29, identifier:text; 30, identifier:index; 31, block; 31, 32; 31, 48; 31, 210; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 38; 34, pattern_list; 34, 35; 34, 36; 34, 37; 35, identifier:cnt; 36, identifier:values; 37, identifier:res; 38, expression_list; 38, 39; 38, 40; 38, 47; 39, integer:0; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:Value; 43, identifier:success; 44, argument_list; 44, 45; 44, 46; 45, identifier:index; 46, list:[]; 47, None; 48, while_statement; 48, 49; 48, 52; 49, comparison_operator:<; 49, 50; 49, 51; 50, identifier:cnt; 51, identifier:maxt; 52, block; 52, 53; 52, 107; 52, 115; 52, 162; 52, 204; 53, if_statement; 53, 54; 53, 63; 54, boolean_operator:and; 54, 55; 54, 60; 55, comparison_operator:in; 55, 56; 55, 57; 56, identifier:end; 57, list:[False, None]; 57, 58; 57, 59; 58, False; 59, None; 60, comparison_operator:>; 60, 61; 60, 62; 61, identifier:cnt; 62, integer:0; 63, block; 63, 64; 63, 72; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:res; 67, call; 67, 68; 67, 69; 68, identifier:sep; 69, argument_list; 69, 70; 69, 71; 70, identifier:text; 71, identifier:index; 72, if_statement; 72, 73; 72, 76; 72, 97; 72, 104; 73, attribute; 73, 74; 73, 75; 74, identifier:res; 75, identifier:status; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, pattern_list; 79, 80; 79, 81; 80, identifier:index; 81, identifier:values; 82, expression_list; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:res; 85, identifier:index; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:Value; 89, identifier:success; 90, argument_list; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:res; 93, identifier:index; 94, attribute; 94, 95; 94, 96; 95, identifier:values; 96, identifier:value; 97, elif_clause; 97, 98; 97, 101; 98, comparison_operator:<; 98, 99; 98, 100; 99, identifier:cnt; 100, identifier:mint; 101, block; 101, 102; 102, return_statement; 102, 103; 103, identifier:res; 104, else_clause; 104, 105; 105, block; 105, 106; 106, break_statement; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:res; 110, call; 110, 111; 110, 112; 111, identifier:p; 112, argument_list; 112, 113; 112, 114; 113, identifier:text; 114, identifier:index; 115, if_statement; 115, 116; 115, 119; 115, 152; 115, 158; 116, attribute; 116, 117; 116, 118; 117, identifier:res; 118, identifier:status; 119, block; 119, 120; 119, 140; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:values; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:values; 126, identifier:aggregate; 127, argument_list; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:Value; 131, identifier:success; 132, argument_list; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:res; 135, identifier:index; 136, list:[res.value]; 136, 137; 137, attribute; 137, 138; 137, 139; 138, identifier:res; 139, identifier:value; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, pattern_list; 142, 143; 142, 144; 143, identifier:index; 144, identifier:cnt; 145, expression_list; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:res; 148, identifier:index; 149, binary_operator:+; 149, 150; 149, 151; 150, identifier:cnt; 151, integer:1; 152, elif_clause; 152, 153; 152, 156; 153, comparison_operator:>=; 153, 154; 153, 155; 154, identifier:cnt; 155, identifier:mint; 156, block; 156, 157; 157, break_statement; 158, else_clause; 158, 159; 159, block; 159, 160; 160, return_statement; 160, 161; 161, identifier:res; 162, if_statement; 162, 163; 162, 166; 163, comparison_operator:is; 163, 164; 163, 165; 164, identifier:end; 165, True; 166, block; 166, 167; 166, 175; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:res; 170, call; 170, 171; 170, 172; 171, identifier:sep; 172, argument_list; 172, 173; 172, 174; 173, identifier:text; 174, identifier:index; 175, if_statement; 175, 176; 175, 179; 175, 200; 176, attribute; 176, 177; 176, 178; 177, identifier:res; 178, identifier:status; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 185; 182, pattern_list; 182, 183; 182, 184; 183, identifier:index; 184, identifier:values; 185, expression_list; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:res; 188, identifier:index; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:Value; 192, identifier:success; 193, argument_list; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:res; 196, identifier:index; 197, attribute; 197, 198; 197, 199; 198, identifier:values; 199, identifier:value; 200, else_clause; 200, 201; 201, block; 201, 202; 202, return_statement; 202, 203; 203, identifier:res; 204, if_statement; 204, 205; 204, 208; 205, comparison_operator:>=; 205, 206; 205, 207; 206, identifier:cnt; 207, identifier:maxt; 208, block; 208, 209; 209, break_statement; 210, return_statement; 210, 211; 211, identifier:values; 212, return_statement; 212, 213; 213, identifier:sep_parser | def separated(p, sep, mint, maxt=None, end=None):
'''Repeat a parser `p` separated by `s` between `mint` and `maxt` times.
When `end` is None, a trailing separator is optional.
When `end` is True, a trailing separator is required.
When `end` is False, a trailing separator is not allowed.
MATCHES AS MUCH AS POSSIBLE.
Return list of values returned by `p`.'''
maxt = maxt if maxt else mint
@Parser
def sep_parser(text, index):
cnt, values, res = 0, Value.success(index, []), None
while cnt < maxt:
if end in [False, None] and cnt > 0:
res = sep(text, index)
if res.status:
index, values = res.index, Value.success(
res.index, values.value)
elif cnt < mint:
return res
else:
break
res = p(text, index)
if res.status:
values = values.aggregate(
Value.success(res.index, [res.value]))
index, cnt = res.index, cnt + 1
elif cnt >= mint:
break
else:
return res
if end is True:
res = sep(text, index)
if res.status:
index, values = res.index, Value.success(
res.index, values.value)
else:
return res
if cnt >= maxt:
break
return values
return sep_parser |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:route; 3, parameters; 3, 4; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, block; 6, 7; 6, 55; 6, 187; 6, 192; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:_validate_route; 9, parameters; 9, 10; 10, identifier:route; 11, block; 11, 12; 11, 29; 12, if_statement; 12, 13; 12, 21; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:isinstance; 16, argument_list; 16, 17; 16, 18; 17, identifier:route; 18, attribute; 18, 19; 18, 20; 19, identifier:six; 20, identifier:string_types; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:TypeError; 25, argument_list; 25, 26; 26, binary_operator:%; 26, 27; 26, 28; 27, string:'%s must be a string'; 28, identifier:route; 29, if_statement; 29, 30; 29, 44; 30, boolean_operator:or; 30, 31; 30, 36; 31, comparison_operator:in; 31, 32; 31, 33; 32, identifier:route; 33, tuple; 33, 34; 33, 35; 34, string:'.'; 35, string:'..'; 36, not_operator; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:re; 40, identifier:match; 41, argument_list; 41, 42; 41, 43; 42, string:'^[0-9a-zA-Z-_$\(\)\.~!,;:*+@=]+$'; 43, identifier:route; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:ValueError; 48, argument_list; 48, 49; 49, binary_operator:%; 49, 50; 49, 54; 50, concatenated_string; 50, 51; 50, 52; 50, 53; 51, string:'%s must be a valid path segment. Keep in mind '; 52, string:'that path segments should not contain path separators '; 53, string:'(e.g., /) '; 54, identifier:route; 55, if_statement; 55, 56; 55, 62; 55, 126; 55, 178; 56, comparison_operator:==; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:args; 61, integer:2; 62, block; 62, 63; 62, 69; 62, 81; 62, 95; 62, 105; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, pattern_list; 65, 66; 65, 67; 66, identifier:route; 67, identifier:handler; 68, identifier:args; 69, if_statement; 69, 70; 69, 74; 70, call; 70, 71; 70, 72; 71, identifier:ismethod; 72, argument_list; 72, 73; 73, identifier:handler; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:handler; 78, attribute; 78, 79; 78, 80; 79, identifier:handler; 80, identifier:__func__; 81, if_statement; 81, 82; 81, 87; 82, not_operator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:iscontroller; 85, argument_list; 85, 86; 86, identifier:handler; 87, block; 87, 88; 88, raise_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:TypeError; 91, argument_list; 91, 92; 92, binary_operator:%; 92, 93; 92, 94; 93, string:'%s must be a callable decorated with @pecan.expose'; 94, identifier:handler; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 101; 97, pattern_list; 97, 98; 97, 99; 97, 100; 98, identifier:obj; 99, identifier:attr; 100, identifier:value; 101, expression_list; 101, 102; 101, 103; 101, 104; 102, identifier:handler; 103, string:'custom_route'; 104, identifier:route; 105, if_statement; 105, 106; 105, 114; 106, comparison_operator:in; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:handler; 109, identifier:__name__; 110, tuple; 110, 111; 110, 112; 110, 113; 111, string:'_lookup'; 112, string:'_default'; 113, string:'_route'; 114, block; 114, 115; 115, raise_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:ValueError; 118, argument_list; 118, 119; 119, binary_operator:%; 119, 120; 119, 123; 120, concatenated_string; 120, 121; 120, 122; 121, string:'%s is a special method in pecan and cannot be used in '; 122, string:'combination with custom path segments.'; 123, attribute; 123, 124; 123, 125; 124, identifier:handler; 125, identifier:__name__; 126, elif_clause; 126, 127; 126, 133; 127, comparison_operator:==; 127, 128; 127, 132; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:args; 132, integer:3; 133, block; 133, 134; 133, 141; 133, 148; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 140; 136, pattern_list; 136, 137; 136, 138; 136, 139; 137, identifier:_; 138, identifier:route; 139, identifier:handler; 140, identifier:args; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 147; 143, pattern_list; 143, 144; 143, 145; 143, 146; 144, identifier:obj; 145, identifier:attr; 146, identifier:value; 147, identifier:args; 148, if_statement; 148, 149; 148, 154; 149, call; 149, 150; 149, 151; 150, identifier:hasattr; 151, argument_list; 151, 152; 151, 153; 152, identifier:obj; 153, identifier:attr; 154, block; 154, 155; 155, raise_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:RuntimeError; 158, argument_list; 158, 159; 159, parenthesized_expression; 159, 160; 160, binary_operator:%; 160, 161; 160, 164; 161, concatenated_string; 161, 162; 161, 163; 162, string:"%(module)s.%(class)s already has an "; 163, string:"existing attribute named \"%(route)s\"."; 164, dictionary; 164, 165; 164, 170; 164, 175; 165, pair; 165, 166; 165, 167; 166, string:'module'; 167, attribute; 167, 168; 167, 169; 168, identifier:obj; 169, identifier:__module__; 170, pair; 170, 171; 170, 172; 171, string:'class'; 172, attribute; 172, 173; 172, 174; 173, identifier:obj; 174, identifier:__name__; 175, pair; 175, 176; 175, 177; 176, string:'route'; 177, identifier:attr; 178, else_clause; 178, 179; 179, block; 179, 180; 180, raise_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:TypeError; 183, argument_list; 183, 184; 184, concatenated_string; 184, 185; 184, 186; 185, string:'pecan.route should be called in the format '; 186, string:'route(ParentController, "path-segment", SubController())'; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:_validate_route; 190, argument_list; 190, 191; 191, identifier:route; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:setattr; 195, argument_list; 195, 196; 195, 197; 195, 198; 196, identifier:obj; 197, identifier:attr; 198, identifier:value | def route(*args):
def _validate_route(route):
if not isinstance(route, six.string_types):
raise TypeError('%s must be a string' % route)
if route in ('.', '..') or not re.match(
'^[0-9a-zA-Z-_$\(\)\.~!,;:*+@=]+$', route
):
raise ValueError(
'%s must be a valid path segment. Keep in mind '
'that path segments should not contain path separators '
'(e.g., /) ' % route
)
if len(args) == 2:
route, handler = args
if ismethod(handler):
handler = handler.__func__
if not iscontroller(handler):
raise TypeError(
'%s must be a callable decorated with @pecan.expose' % handler
)
obj, attr, value = handler, 'custom_route', route
if handler.__name__ in ('_lookup', '_default', '_route'):
raise ValueError(
'%s is a special method in pecan and cannot be used in '
'combination with custom path segments.' % handler.__name__
)
elif len(args) == 3:
_, route, handler = args
obj, attr, value = args
if hasattr(obj, attr):
raise RuntimeError(
(
"%(module)s.%(class)s already has an "
"existing attribute named \"%(route)s\"." % {
'module': obj.__module__,
'class': obj.__name__,
'route': attr
}
),
)
else:
raise TypeError(
'pecan.route should be called in the format '
'route(ParentController, "path-segment", SubController())'
)
_validate_route(route)
setattr(obj, attr, value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:find_object; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:obj; 5, identifier:remainder; 6, identifier:notfound_handlers; 7, identifier:request; 8, block; 8, 9; 8, 11; 8, 15; 9, expression_statement; 9, 10; 10, string:'''
'Walks' the url path in search of an action for which a controller is
implemented and returns that controller object along with what's left
of the remainder.
'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:prev_obj; 14, None; 15, while_statement; 15, 16; 15, 17; 16, True; 17, block; 17, 18; 17, 25; 17, 45; 17, 50; 17, 83; 17, 89; 17, 153; 17, 162; 17, 178; 17, 187; 17, 203; 17, 212; 17, 286; 17, 292; 17, 296; 17, 300; 17, 304; 17, 322; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:obj; 21, None; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, identifier:PecanNotFound; 25, if_statement; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:iscontroller; 28, argument_list; 28, 29; 29, identifier:obj; 30, block; 30, 31; 31, if_statement; 31, 32; 31, 40; 32, comparison_operator:is; 32, 33; 32, 39; 33, call; 33, 34; 33, 35; 34, identifier:getattr; 35, argument_list; 35, 36; 35, 37; 35, 38; 36, identifier:obj; 37, string:'custom_route'; 38, None; 39, None; 40, block; 40, 41; 41, return_statement; 41, 42; 42, expression_list; 42, 43; 42, 44; 43, identifier:obj; 44, identifier:remainder; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:_detect_custom_path_segments; 48, argument_list; 48, 49; 49, identifier:obj; 50, if_statement; 50, 51; 50, 52; 51, identifier:remainder; 52, block; 52, 53; 52, 68; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:custom_route; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:__custom_routes__; 59, identifier:get; 60, argument_list; 60, 61; 61, tuple; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:obj; 64, identifier:__class__; 65, subscript; 65, 66; 65, 67; 66, identifier:remainder; 67, integer:0; 68, if_statement; 68, 69; 68, 70; 69, identifier:custom_route; 70, block; 70, 71; 71, return_statement; 71, 72; 72, expression_list; 72, 73; 72, 78; 73, call; 73, 74; 73, 75; 74, identifier:getattr; 75, argument_list; 75, 76; 75, 77; 76, identifier:obj; 77, identifier:custom_route; 78, subscript; 78, 79; 78, 80; 79, identifier:remainder; 80, slice; 80, 81; 80, 82; 81, integer:1; 82, colon; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:cross_boundary; 86, argument_list; 86, 87; 86, 88; 87, identifier:prev_obj; 88, identifier:obj; 89, try_statement; 89, 90; 89, 129; 90, block; 90, 91; 90, 105; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, pattern_list; 93, 94; 93, 95; 94, identifier:next_obj; 95, identifier:rest; 96, expression_list; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:remainder; 99, integer:0; 100, subscript; 100, 101; 100, 102; 101, identifier:remainder; 102, slice; 102, 103; 102, 104; 103, integer:1; 104, colon; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:==; 106, 107; 106, 108; 107, identifier:next_obj; 108, string:''; 109, block; 109, 110; 109, 119; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:index; 113, call; 113, 114; 113, 115; 114, identifier:getattr; 115, argument_list; 115, 116; 115, 117; 115, 118; 116, identifier:obj; 117, string:'index'; 118, None; 119, if_statement; 119, 120; 119, 124; 120, call; 120, 121; 120, 122; 121, identifier:iscontroller; 122, argument_list; 122, 123; 123, identifier:index; 124, block; 124, 125; 125, return_statement; 125, 126; 126, expression_list; 126, 127; 126, 128; 127, identifier:index; 128, identifier:rest; 129, except_clause; 129, 130; 129, 131; 130, identifier:IndexError; 131, block; 131, 132; 131, 141; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:index; 135, call; 135, 136; 135, 137; 136, identifier:getattr; 137, argument_list; 137, 138; 137, 139; 137, 140; 138, identifier:obj; 139, string:'index'; 140, None; 141, if_statement; 141, 142; 141, 146; 142, call; 142, 143; 142, 144; 143, identifier:iscontroller; 144, argument_list; 144, 145; 145, identifier:index; 146, block; 146, 147; 147, raise_statement; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:NonCanonicalPath; 150, argument_list; 150, 151; 150, 152; 151, identifier:index; 152, list:[]; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:default; 156, call; 156, 157; 156, 158; 157, identifier:getattr; 158, argument_list; 158, 159; 158, 160; 158, 161; 159, identifier:obj; 160, string:'_default'; 161, None; 162, if_statement; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:iscontroller; 165, argument_list; 165, 166; 166, identifier:default; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:notfound_handlers; 172, identifier:append; 173, argument_list; 173, 174; 174, tuple; 174, 175; 174, 176; 174, 177; 175, string:'_default'; 176, identifier:default; 177, identifier:remainder; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:lookup; 181, call; 181, 182; 181, 183; 182, identifier:getattr; 183, argument_list; 183, 184; 183, 185; 183, 186; 184, identifier:obj; 185, string:'_lookup'; 186, None; 187, if_statement; 187, 188; 187, 192; 188, call; 188, 189; 188, 190; 189, identifier:iscontroller; 190, argument_list; 190, 191; 191, identifier:lookup; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:notfound_handlers; 197, identifier:append; 198, argument_list; 198, 199; 199, tuple; 199, 200; 199, 201; 199, 202; 200, string:'_lookup'; 201, identifier:lookup; 202, identifier:remainder; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:route; 206, call; 206, 207; 206, 208; 207, identifier:getattr; 208, argument_list; 208, 209; 208, 210; 208, 211; 209, identifier:obj; 210, string:'_route'; 211, None; 212, if_statement; 212, 213; 212, 217; 213, call; 213, 214; 213, 215; 214, identifier:iscontroller; 215, argument_list; 215, 216; 216, identifier:route; 217, block; 217, 218; 217, 276; 217, 282; 218, if_statement; 218, 219; 218, 230; 218, 264; 219, comparison_operator:==; 219, 220; 219, 229; 220, call; 220, 221; 220, 222; 221, identifier:len; 222, argument_list; 222, 223; 223, attribute; 223, 224; 223, 228; 224, call; 224, 225; 224, 226; 225, identifier:getargspec; 226, argument_list; 226, 227; 227, identifier:route; 228, identifier:args; 229, integer:2; 230, block; 230, 231; 230, 255; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:warnings; 235, identifier:warn; 236, argument_list; 236, 237; 236, 254; 237, parenthesized_expression; 237, 238; 238, binary_operator:%; 238, 239; 238, 243; 239, concatenated_string; 239, 240; 239, 241; 239, 242; 240, string:"The function signature for %s.%s._route is changing "; 241, string:"in the next version of pecan.\nPlease update to: "; 242, string:"`def _route(self, args, request)`."; 243, tuple; 243, 244; 243, 249; 244, attribute; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:obj; 247, identifier:__class__; 248, identifier:__module__; 249, attribute; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:obj; 252, identifier:__class__; 253, identifier:__name__; 254, identifier:DeprecationWarning; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 260; 257, pattern_list; 257, 258; 257, 259; 258, identifier:next_obj; 259, identifier:next_remainder; 260, call; 260, 261; 260, 262; 261, identifier:route; 262, argument_list; 262, 263; 263, identifier:remainder; 264, else_clause; 264, 265; 265, block; 265, 266; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 271; 268, pattern_list; 268, 269; 268, 270; 269, identifier:next_obj; 270, identifier:next_remainder; 271, call; 271, 272; 271, 273; 272, identifier:route; 273, argument_list; 273, 274; 273, 275; 274, identifier:remainder; 275, identifier:request; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 279; 278, identifier:cross_boundary; 279, argument_list; 279, 280; 279, 281; 280, identifier:route; 281, identifier:next_obj; 282, return_statement; 282, 283; 283, expression_list; 283, 284; 283, 285; 284, identifier:next_obj; 285, identifier:next_remainder; 286, if_statement; 286, 287; 286, 289; 287, not_operator; 287, 288; 288, identifier:remainder; 289, block; 289, 290; 290, raise_statement; 290, 291; 291, identifier:PecanNotFound; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:prev_remainder; 295, identifier:remainder; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:prev_obj; 299, identifier:obj; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:remainder; 303, identifier:rest; 304, try_statement; 304, 305; 304, 315; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 309; 308, identifier:obj; 309, call; 309, 310; 309, 311; 310, identifier:getattr; 311, argument_list; 311, 312; 311, 313; 311, 314; 312, identifier:obj; 313, identifier:next_obj; 314, None; 315, except_clause; 315, 316; 315, 317; 316, identifier:UnicodeEncodeError; 317, block; 317, 318; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:obj; 321, None; 322, if_statement; 322, 323; 322, 334; 323, boolean_operator:and; 323, 324; 323, 329; 324, boolean_operator:and; 324, 325; 324, 327; 325, not_operator; 325, 326; 326, identifier:obj; 327, not_operator; 327, 328; 328, identifier:notfound_handlers; 329, call; 329, 330; 329, 331; 330, identifier:hasattr; 331, argument_list; 331, 332; 331, 333; 332, identifier:prev_obj; 333, string:'index'; 334, block; 334, 335; 335, if_statement; 335, 336; 335, 352; 336, comparison_operator:in; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:request; 339, identifier:method; 340, call; 340, 341; 340, 349; 341, attribute; 341, 342; 341, 348; 342, call; 342, 343; 342, 344; 343, identifier:_cfg; 344, argument_list; 344, 345; 345, attribute; 345, 346; 345, 347; 346, identifier:prev_obj; 347, identifier:index; 348, identifier:get; 349, argument_list; 349, 350; 349, 351; 350, string:'generic_handlers'; 351, dictionary; 352, block; 352, 353; 353, return_statement; 353, 354; 354, expression_list; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:prev_obj; 357, identifier:index; 358, identifier:prev_remainder | def find_object(obj, remainder, notfound_handlers, request):
'''
'Walks' the url path in search of an action for which a controller is
implemented and returns that controller object along with what's left
of the remainder.
'''
prev_obj = None
while True:
if obj is None:
raise PecanNotFound
if iscontroller(obj):
if getattr(obj, 'custom_route', None) is None:
return obj, remainder
_detect_custom_path_segments(obj)
if remainder:
custom_route = __custom_routes__.get((obj.__class__, remainder[0]))
if custom_route:
return getattr(obj, custom_route), remainder[1:]
cross_boundary(prev_obj, obj)
try:
next_obj, rest = remainder[0], remainder[1:]
if next_obj == '':
index = getattr(obj, 'index', None)
if iscontroller(index):
return index, rest
except IndexError:
index = getattr(obj, 'index', None)
if iscontroller(index):
raise NonCanonicalPath(index, [])
default = getattr(obj, '_default', None)
if iscontroller(default):
notfound_handlers.append(('_default', default, remainder))
lookup = getattr(obj, '_lookup', None)
if iscontroller(lookup):
notfound_handlers.append(('_lookup', lookup, remainder))
route = getattr(obj, '_route', None)
if iscontroller(route):
if len(getargspec(route).args) == 2:
warnings.warn(
(
"The function signature for %s.%s._route is changing "
"in the next version of pecan.\nPlease update to: "
"`def _route(self, args, request)`." % (
obj.__class__.__module__,
obj.__class__.__name__
)
),
DeprecationWarning
)
next_obj, next_remainder = route(remainder)
else:
next_obj, next_remainder = route(remainder, request)
cross_boundary(route, next_obj)
return next_obj, next_remainder
if not remainder:
raise PecanNotFound
prev_remainder = remainder
prev_obj = obj
remainder = rest
try:
obj = getattr(obj, next_obj, None)
except UnicodeEncodeError:
obj = None
if not obj and not notfound_handlers and hasattr(prev_obj, 'index'):
if request.method in _cfg(prev_obj.index).get('generic_handlers',
{}):
return prev_obj.index, prev_remainder |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:make_app; 3, parameters; 3, 4; 3, 5; 4, identifier:root; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kw; 7, block; 7, 8; 7, 10; 7, 20; 7, 30; 7, 91; 7, 100; 7, 110; 7, 120; 7, 137; 7, 152; 7, 163; 7, 173; 7, 250; 7, 274; 8, expression_statement; 8, 9; 9, string:'''
Utility for creating the Pecan application object. This function should
generally be called from the ``setup_app`` function in your project's
``app.py`` file.
:param root: A string representing a root controller object (e.g.,
"myapp.controller.root.RootController")
:param static_root: The relative path to a directory containing static
files. Serving static files is only enabled when
debug mode is set.
:param debug: A flag to enable debug mode. This enables the debug
middleware and serving static files.
:param wrap_app: A function or middleware class to wrap the Pecan app.
This must either be a wsgi middleware class or a
function that returns a wsgi application. This wrapper
is applied first before wrapping the application in
other middlewares such as Pecan's debug middleware.
This should be used if you want to use middleware to
perform authentication or intercept all requests before
they are routed to the root controller.
:param logging: A dictionary used to configure logging. This uses
``logging.config.dictConfig``.
All other keyword arguments are passed in to the Pecan app constructor.
:returns: a ``Pecan`` object.
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:logging; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:kw; 16, identifier:get; 17, argument_list; 17, 18; 17, 19; 18, string:'logging'; 19, dictionary; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:debug; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:kw; 26, identifier:get; 27, argument_list; 27, 28; 27, 29; 28, string:'debug'; 29, False; 30, if_statement; 30, 31; 30, 32; 31, identifier:logging; 32, block; 32, 33; 32, 60; 32, 75; 32, 86; 33, if_statement; 33, 34; 33, 35; 34, identifier:debug; 35, block; 35, 36; 36, try_statement; 36, 37; 36, 56; 37, block; 37, 38; 37, 43; 37, 48; 38, import_from_statement; 38, 39; 38, 41; 39, dotted_name; 39, 40; 40, identifier:logging; 41, dotted_name; 41, 42; 42, identifier:captureWarnings; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:captureWarnings; 46, argument_list; 46, 47; 47, True; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:warnings; 52, identifier:simplefilter; 53, argument_list; 53, 54; 53, 55; 54, string:"default"; 55, identifier:DeprecationWarning; 56, except_clause; 56, 57; 56, 58; 57, identifier:ImportError; 58, block; 58, 59; 59, pass_statement; 60, if_statement; 60, 61; 60, 66; 61, call; 61, 62; 61, 63; 62, identifier:isinstance; 63, argument_list; 63, 64; 63, 65; 64, identifier:logging; 65, identifier:Config; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:logging; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:logging; 73, identifier:to_dict; 74, argument_list; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:not; 76, 77; 76, 78; 77, string:'version'; 78, identifier:logging; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:logging; 84, string:'version'; 85, integer:1; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:load_logging_config; 89, argument_list; 89, 90; 90, identifier:logging; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:app; 94, call; 94, 95; 94, 96; 95, identifier:Pecan; 96, argument_list; 96, 97; 96, 98; 97, identifier:root; 98, dictionary_splat; 98, 99; 99, identifier:kw; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:wrap_app; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:kw; 106, identifier:get; 107, argument_list; 107, 108; 107, 109; 108, string:'wrap_app'; 109, None; 110, if_statement; 110, 111; 110, 112; 111, identifier:wrap_app; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:app; 116, call; 116, 117; 116, 118; 117, identifier:wrap_app; 118, argument_list; 118, 119; 119, identifier:app; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:errors; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:kw; 126, identifier:get; 127, argument_list; 127, 128; 127, 129; 128, string:'errors'; 129, call; 129, 130; 129, 131; 130, identifier:getattr; 131, argument_list; 131, 132; 131, 135; 131, 136; 132, attribute; 132, 133; 132, 134; 133, identifier:conf; 134, identifier:app; 135, string:'errors'; 136, dictionary; 137, if_statement; 137, 138; 137, 139; 138, identifier:errors; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:app; 143, call; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:middleware; 147, identifier:errordocument; 148, identifier:ErrorDocumentMiddleware; 149, argument_list; 149, 150; 149, 151; 150, identifier:app; 151, identifier:errors; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:app; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:middleware; 159, identifier:recursive; 160, identifier:RecursiveMiddleware; 161, argument_list; 161, 162; 162, identifier:app; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:static_root; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:kw; 169, identifier:get; 170, argument_list; 170, 171; 170, 172; 171, string:'static_root'; 172, None; 173, if_statement; 173, 174; 173, 175; 173, 239; 174, identifier:debug; 175, block; 175, 176; 175, 185; 175, 215; 175, 224; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:debug_kwargs; 179, call; 179, 180; 179, 181; 180, identifier:getattr; 181, argument_list; 181, 182; 181, 183; 181, 184; 182, identifier:conf; 183, string:'debug'; 184, dictionary; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 196; 187, attribute; 187, 188; 187, 195; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:debug_kwargs; 191, identifier:setdefault; 192, argument_list; 192, 193; 192, 194; 193, string:'context_injectors'; 194, list:[]; 195, identifier:append; 196, argument_list; 196, 197; 197, lambda; 197, 198; 197, 200; 198, lambda_parameters; 198, 199; 199, identifier:environ; 200, dictionary; 200, 201; 201, pair; 201, 202; 201, 203; 202, string:'request'; 203, call; 203, 204; 203, 213; 204, attribute; 204, 205; 204, 212; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:environ; 208, identifier:get; 209, argument_list; 209, 210; 209, 211; 210, string:'pecan.locals'; 211, dictionary; 212, identifier:get; 213, argument_list; 213, 214; 214, string:'request'; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:app; 218, call; 218, 219; 218, 220; 219, identifier:DebugMiddleware; 220, argument_list; 220, 221; 220, 222; 221, identifier:app; 222, dictionary_splat; 222, 223; 223, identifier:debug_kwargs; 224, if_statement; 224, 225; 224, 226; 225, identifier:static_root; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:app; 230, call; 230, 231; 230, 236; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:middleware; 234, identifier:static; 235, identifier:StaticFileMiddleware; 236, argument_list; 236, 237; 236, 238; 237, identifier:app; 238, identifier:static_root; 239, elif_clause; 239, 240; 239, 241; 240, identifier:static_root; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:warnings; 246, identifier:warn; 247, argument_list; 247, 248; 247, 249; 248, string:"`static_root` is only used when `debug` is True, ignoring"; 249, identifier:RuntimeWarning; 250, if_statement; 250, 251; 250, 256; 251, call; 251, 252; 251, 253; 252, identifier:hasattr; 253, argument_list; 253, 254; 253, 255; 254, identifier:conf; 255, string:'requestviewer'; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:warnings; 261, identifier:warn; 262, argument_list; 262, 263; 262, 273; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, string:''; 266, identifier:join; 267, argument_list; 267, 268; 268, list:[
"`pecan.conf.requestviewer` is deprecated. To apply the ",
"`RequestViewerHook` to your application, add it to ",
"`pecan.conf.app.hooks` or manually in your project's `app.py` ",
"file."]; 268, 269; 268, 270; 268, 271; 268, 272; 269, string:"`pecan.conf.requestviewer` is deprecated. To apply the "; 270, string:"`RequestViewerHook` to your application, add it to "; 271, string:"`pecan.conf.app.hooks` or manually in your project's `app.py` "; 272, string:"file."; 273, identifier:DeprecationWarning; 274, return_statement; 274, 275; 275, identifier:app | def make_app(root, **kw):
'''
Utility for creating the Pecan application object. This function should
generally be called from the ``setup_app`` function in your project's
``app.py`` file.
:param root: A string representing a root controller object (e.g.,
"myapp.controller.root.RootController")
:param static_root: The relative path to a directory containing static
files. Serving static files is only enabled when
debug mode is set.
:param debug: A flag to enable debug mode. This enables the debug
middleware and serving static files.
:param wrap_app: A function or middleware class to wrap the Pecan app.
This must either be a wsgi middleware class or a
function that returns a wsgi application. This wrapper
is applied first before wrapping the application in
other middlewares such as Pecan's debug middleware.
This should be used if you want to use middleware to
perform authentication or intercept all requests before
they are routed to the root controller.
:param logging: A dictionary used to configure logging. This uses
``logging.config.dictConfig``.
All other keyword arguments are passed in to the Pecan app constructor.
:returns: a ``Pecan`` object.
'''
logging = kw.get('logging', {})
debug = kw.get('debug', False)
if logging:
if debug:
try:
from logging import captureWarnings
captureWarnings(True)
warnings.simplefilter("default", DeprecationWarning)
except ImportError:
pass
if isinstance(logging, Config):
logging = logging.to_dict()
if 'version' not in logging:
logging['version'] = 1
load_logging_config(logging)
app = Pecan(root, **kw)
wrap_app = kw.get('wrap_app', None)
if wrap_app:
app = wrap_app(app)
errors = kw.get('errors', getattr(conf.app, 'errors', {}))
if errors:
app = middleware.errordocument.ErrorDocumentMiddleware(app, errors)
app = middleware.recursive.RecursiveMiddleware(app)
static_root = kw.get('static_root', None)
if debug:
debug_kwargs = getattr(conf, 'debug', {})
debug_kwargs.setdefault('context_injectors', []).append(
lambda environ: {
'request': environ.get('pecan.locals', {}).get('request')
}
)
app = DebugMiddleware(
app,
**debug_kwargs
)
if static_root:
app = middleware.static.StaticFileMiddleware(app, static_root)
elif static_root:
warnings.warn(
"`static_root` is only used when `debug` is True, ignoring",
RuntimeWarning
)
if hasattr(conf, 'requestviewer'):
warnings.warn(''.join([
"`pecan.conf.requestviewer` is deprecated. To apply the ",
"`RequestViewerHook` to your application, add it to ",
"`pecan.conf.app.hooks` or manually in your project's `app.py` ",
"file."]),
DeprecationWarning
)
return app |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:redirect; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 4, default_parameter; 4, 5; 4, 6; 5, identifier:location; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:internal; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:code; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:headers; 15, dictionary; 16, default_parameter; 16, 17; 16, 18; 17, identifier:add_slash; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:request; 21, None; 22, block; 22, 23; 22, 25; 22, 33; 22, 110; 22, 118; 22, 146; 22, 155; 23, expression_statement; 23, 24; 24, string:'''
Perform a redirect, either internal or external. An internal redirect
performs the redirect server-side, while the external redirect utilizes
an HTTP 302 status code.
:param location: The HTTP location to redirect to.
:param internal: A boolean indicating whether the redirect should be
internal.
:param code: The HTTP status code to use for the redirect. Defaults to 302.
:param headers: Any HTTP headers to send with the response, as a
dictionary.
:param request: The :class:`pecan.Request` instance to use.
'''; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:request; 28, boolean_operator:or; 28, 29; 28, 30; 29, identifier:request; 30, attribute; 30, 31; 30, 32; 31, identifier:state; 32, identifier:request; 33, if_statement; 33, 34; 33, 35; 34, identifier:add_slash; 35, block; 35, 36; 35, 86; 35, 101; 36, if_statement; 36, 37; 36, 40; 36, 75; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:location; 39, None; 40, block; 40, 41; 40, 55; 40, 69; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:split_url; 44, call; 44, 45; 44, 46; 45, identifier:list; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:urlparse; 50, identifier:urlsplit; 51, argument_list; 51, 52; 52, attribute; 52, 53; 52, 54; 53, identifier:request; 54, identifier:url; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:new_proto; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:request; 62, identifier:environ; 63, identifier:get; 64, argument_list; 64, 65; 64, 66; 65, string:'HTTP_X_FORWARDED_PROTO'; 66, subscript; 66, 67; 66, 68; 67, identifier:split_url; 68, integer:0; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:split_url; 73, integer:0; 74, identifier:new_proto; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:split_url; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:urlparse; 83, identifier:urlsplit; 84, argument_list; 84, 85; 85, identifier:location; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:split_url; 90, integer:2; 91, binary_operator:+; 91, 92; 91, 100; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:split_url; 96, integer:2; 97, identifier:rstrip; 98, argument_list; 98, 99; 99, string:'/'; 100, string:'/'; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:location; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:urlparse; 107, identifier:urlunsplit; 108, argument_list; 108, 109; 109, identifier:split_url; 110, if_statement; 110, 111; 110, 113; 111, not_operator; 111, 112; 112, identifier:headers; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:headers; 117, dictionary; 118, if_statement; 118, 119; 118, 120; 119, identifier:internal; 120, block; 120, 121; 120, 131; 120, 141; 121, if_statement; 121, 122; 121, 125; 122, comparison_operator:is; 122, 123; 122, 124; 123, identifier:code; 124, None; 125, block; 125, 126; 126, raise_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:ValueError; 129, argument_list; 129, 130; 130, string:'Cannot specify a code for internal redirects'; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 138; 133, subscript; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:request; 136, identifier:environ; 137, string:'pecan.recursive.context'; 138, attribute; 138, 139; 138, 140; 139, identifier:request; 140, identifier:context; 141, raise_statement; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:ForwardRequestException; 144, argument_list; 144, 145; 145, identifier:location; 146, if_statement; 146, 147; 146, 150; 147, comparison_operator:is; 147, 148; 147, 149; 148, identifier:code; 149, None; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:code; 154, integer:302; 155, raise_statement; 155, 156; 156, call; 156, 157; 156, 162; 157, subscript; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:exc; 160, identifier:status_map; 161, identifier:code; 162, argument_list; 162, 163; 162, 166; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:location; 165, identifier:location; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:headers; 168, identifier:headers | def redirect(location=None, internal=False, code=None, headers={},
add_slash=False, request=None):
'''
Perform a redirect, either internal or external. An internal redirect
performs the redirect server-side, while the external redirect utilizes
an HTTP 302 status code.
:param location: The HTTP location to redirect to.
:param internal: A boolean indicating whether the redirect should be
internal.
:param code: The HTTP status code to use for the redirect. Defaults to 302.
:param headers: Any HTTP headers to send with the response, as a
dictionary.
:param request: The :class:`pecan.Request` instance to use.
'''
request = request or state.request
if add_slash:
if location is None:
split_url = list(urlparse.urlsplit(request.url))
new_proto = request.environ.get(
'HTTP_X_FORWARDED_PROTO', split_url[0]
)
split_url[0] = new_proto
else:
split_url = urlparse.urlsplit(location)
split_url[2] = split_url[2].rstrip('/') + '/'
location = urlparse.urlunsplit(split_url)
if not headers:
headers = {}
if internal:
if code is not None:
raise ValueError('Cannot specify a code for internal redirects')
request.environ['pecan.recursive.context'] = request.context
raise ForwardRequestException(location)
if code is None:
code = 302
raise exc.status_map[code](location=location, headers=headers) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_args; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:state; 6, identifier:all_params; 7, identifier:remainder; 8, identifier:argspec; 9, identifier:im_self; 10, block; 10, 11; 10, 13; 10, 17; 10, 21; 10, 27; 10, 36; 10, 53; 10, 61; 10, 71; 10, 83; 10, 103; 10, 144; 10, 171; 10, 209; 10, 247; 10, 276; 11, expression_statement; 11, 12; 12, string:'''
Determines the arguments for a controller based upon parameters
passed the argument specification for the controller.
'''; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:args; 16, list:[]; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:varargs; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:kwargs; 24, call; 24, 25; 24, 26; 25, identifier:dict; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:valid_args; 30, subscript; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:argspec; 33, identifier:args; 34, slice; 34, 35; 35, colon; 36, if_statement; 36, 37; 36, 45; 37, boolean_operator:or; 37, 38; 37, 44; 38, call; 38, 39; 38, 40; 39, identifier:ismethod; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 43; 42, identifier:state; 43, identifier:controller; 44, identifier:im_self; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:valid_args; 50, identifier:pop; 51, argument_list; 51, 52; 52, integer:0; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:pecan_state; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:state; 59, identifier:request; 60, identifier:pecan; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:remainder; 64, list_comprehension; 64, 65; 64, 66; 64, 69; 65, identifier:x; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:x; 68, identifier:remainder; 69, if_clause; 69, 70; 70, identifier:x; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:im_self; 74, None; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:args; 80, identifier:append; 81, argument_list; 81, 82; 82, identifier:im_self; 83, if_statement; 83, 84; 83, 87; 84, comparison_operator:in; 84, 85; 84, 86; 85, string:'routing_args'; 86, identifier:pecan_state; 87, block; 87, 88; 87, 99; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:remainder; 91, binary_operator:+; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:pecan_state; 94, string:'routing_args'; 95, call; 95, 96; 95, 97; 96, identifier:list; 97, argument_list; 97, 98; 98, identifier:remainder; 99, delete_statement; 99, 100; 100, subscript; 100, 101; 100, 102; 101, identifier:pecan_state; 102, string:'routing_args'; 103, if_statement; 103, 104; 103, 107; 104, boolean_operator:and; 104, 105; 104, 106; 105, identifier:valid_args; 106, identifier:remainder; 107, block; 107, 108; 107, 122; 107, 133; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:args; 112, identifier:extend; 113, argument_list; 113, 114; 114, subscript; 114, 115; 114, 116; 115, identifier:remainder; 116, slice; 116, 117; 116, 118; 117, colon; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:valid_args; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:remainder; 125, subscript; 125, 126; 125, 127; 126, identifier:remainder; 127, slice; 127, 128; 127, 132; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:valid_args; 132, colon; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:valid_args; 136, subscript; 136, 137; 136, 138; 137, identifier:valid_args; 138, slice; 138, 139; 138, 143; 139, call; 139, 140; 139, 141; 140, identifier:len; 141, argument_list; 141, 142; 142, identifier:args; 143, colon; 144, if_statement; 144, 145; 144, 152; 145, list_comprehension; 145, 146; 145, 147; 145, 150; 146, identifier:i; 147, for_in_clause; 147, 148; 147, 149; 148, identifier:i; 149, identifier:remainder; 150, if_clause; 150, 151; 151, identifier:i; 152, block; 152, 153; 152, 164; 153, if_statement; 153, 154; 153, 158; 154, not_operator; 154, 155; 155, subscript; 155, 156; 155, 157; 156, identifier:argspec; 157, integer:1; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:abort; 162, argument_list; 162, 163; 163, integer:404; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:varargs; 168, identifier:extend; 169, argument_list; 169, 170; 170, identifier:remainder; 171, if_statement; 171, 172; 171, 175; 171, 201; 172, subscript; 172, 173; 172, 174; 173, identifier:argspec; 174, integer:3; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:defaults; 179, call; 179, 180; 179, 181; 180, identifier:dict; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:izip; 184, argument_list; 184, 185; 184, 198; 185, subscript; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:argspec; 188, integer:0; 189, slice; 189, 190; 189, 197; 190, unary_operator:-; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:len; 193, argument_list; 193, 194; 194, subscript; 194, 195; 194, 196; 195, identifier:argspec; 196, integer:3; 197, colon; 198, subscript; 198, 199; 198, 200; 199, identifier:argspec; 200, integer:3; 201, else_clause; 201, 202; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:defaults; 206, call; 206, 207; 206, 208; 207, identifier:dict; 208, argument_list; 209, for_statement; 209, 210; 209, 211; 209, 212; 210, identifier:name; 211, identifier:valid_args; 212, block; 212, 213; 213, if_statement; 213, 214; 213, 217; 213, 230; 213, 244; 214, comparison_operator:in; 214, 215; 214, 216; 215, identifier:name; 216, identifier:all_params; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:args; 222, identifier:append; 223, argument_list; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:all_params; 227, identifier:pop; 228, argument_list; 228, 229; 229, identifier:name; 230, elif_clause; 230, 231; 230, 234; 231, comparison_operator:in; 231, 232; 231, 233; 232, identifier:name; 233, identifier:defaults; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:args; 239, identifier:append; 240, argument_list; 240, 241; 241, subscript; 241, 242; 241, 243; 242, identifier:defaults; 243, identifier:name; 244, else_clause; 244, 245; 245, block; 245, 246; 246, break_statement; 247, if_statement; 247, 248; 247, 251; 248, subscript; 248, 249; 248, 250; 249, identifier:argspec; 250, integer:2; 251, block; 251, 252; 252, for_statement; 252, 253; 252, 256; 252, 262; 253, pattern_list; 253, 254; 253, 255; 254, identifier:name; 255, identifier:value; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:six; 259, identifier:iteritems; 260, argument_list; 260, 261; 261, identifier:all_params; 262, block; 262, 263; 263, if_statement; 263, 264; 263, 269; 264, comparison_operator:not; 264, 265; 264, 266; 265, identifier:name; 266, subscript; 266, 267; 266, 268; 267, identifier:argspec; 268, integer:0; 269, block; 269, 270; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:kwargs; 274, identifier:name; 275, identifier:value; 276, return_statement; 276, 277; 277, expression_list; 277, 278; 277, 279; 277, 280; 278, identifier:args; 279, identifier:varargs; 280, identifier:kwargs | def get_args(self, state, all_params, remainder, argspec, im_self):
'''
Determines the arguments for a controller based upon parameters
passed the argument specification for the controller.
'''
args = []
varargs = []
kwargs = dict()
valid_args = argspec.args[:]
if ismethod(state.controller) or im_self:
valid_args.pop(0)
pecan_state = state.request.pecan
remainder = [x for x in remainder if x]
if im_self is not None:
args.append(im_self)
if 'routing_args' in pecan_state:
remainder = pecan_state['routing_args'] + list(remainder)
del pecan_state['routing_args']
if valid_args and remainder:
args.extend(remainder[:len(valid_args)])
remainder = remainder[len(valid_args):]
valid_args = valid_args[len(args):]
if [i for i in remainder if i]:
if not argspec[1]:
abort(404)
varargs.extend(remainder)
if argspec[3]:
defaults = dict(izip(argspec[0][-len(argspec[3]):], argspec[3]))
else:
defaults = dict()
for name in valid_args:
if name in all_params:
args.append(all_params.pop(name))
elif name in defaults:
args.append(defaults[name])
else:
break
if argspec[2]:
for name, value in six.iteritems(all_params):
if name not in argspec[0]:
kwargs[name] = value
return args, varargs, kwargs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_route; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:args; 6, default_parameter; 6, 7; 6, 8; 7, identifier:request; 8, None; 9, block; 9, 10; 9, 12; 9, 22; 9, 40; 9, 58; 9, 68; 9, 73; 9, 86; 9, 267; 10, expression_statement; 10, 11; 11, string:'''
Routes a request to the appropriate controller and returns its result.
Performs a bit of validation - refuses to route delete and put actions
via a GET request).
'''; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:request; 15, None; 16, block; 16, 17; 17, import_from_statement; 17, 18; 17, 20; 18, dotted_name; 18, 19; 19, identifier:pecan; 20, dotted_name; 20, 21; 21, identifier:request; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:method; 25, call; 25, 26; 25, 39; 26, attribute; 26, 27; 26, 38; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:request; 31, identifier:params; 32, identifier:get; 33, argument_list; 33, 34; 33, 35; 34, string:'_method'; 35, attribute; 35, 36; 35, 37; 36, identifier:request; 37, identifier:method; 38, identifier:lower; 39, argument_list; 40, if_statement; 40, 41; 40, 52; 41, boolean_operator:and; 41, 42; 41, 47; 42, comparison_operator:==; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:request; 45, identifier:method; 46, string:'GET'; 47, comparison_operator:in; 47, 48; 47, 49; 48, identifier:method; 49, tuple; 49, 50; 49, 51; 50, string:'delete'; 51, string:'put'; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:abort; 56, argument_list; 56, 57; 57, integer:405; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:result; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_find_sub_controllers; 65, argument_list; 65, 66; 65, 67; 66, identifier:args; 67, identifier:request; 68, if_statement; 68, 69; 68, 70; 69, identifier:result; 70, block; 70, 71; 71, return_statement; 71, 72; 72, identifier:result; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:handler; 76, call; 76, 77; 76, 78; 77, identifier:getattr; 78, argument_list; 78, 79; 78, 80; 78, 83; 79, identifier:self; 80, binary_operator:%; 80, 81; 80, 82; 81, string:'_handle_%s'; 82, identifier:method; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_handle_unknown_method; 86, try_statement; 86, 87; 86, 161; 87, block; 87, 88; 87, 120; 87, 131; 87, 138; 88, if_statement; 88, 89; 88, 100; 88, 109; 89, comparison_operator:==; 89, 90; 89, 99; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:getargspec; 96, argument_list; 96, 97; 97, identifier:handler; 98, identifier:args; 99, integer:3; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:result; 104, call; 104, 105; 104, 106; 105, identifier:handler; 106, argument_list; 106, 107; 106, 108; 107, identifier:method; 108, identifier:args; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:result; 114, call; 114, 115; 114, 116; 115, identifier:handler; 116, argument_list; 116, 117; 116, 118; 116, 119; 117, identifier:method; 118, identifier:args; 119, identifier:request; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:argspec; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_get_args_for_controller; 127, argument_list; 127, 128; 128, subscript; 128, 129; 128, 130; 129, identifier:result; 130, integer:0; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:num_args; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, identifier:argspec; 138, if_statement; 138, 139; 138, 145; 139, comparison_operator:<; 139, 140; 139, 141; 140, identifier:num_args; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, identifier:args; 145, block; 145, 146; 145, 156; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:_lookup_result; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_handle_lookup; 153, argument_list; 153, 154; 153, 155; 154, identifier:args; 155, identifier:request; 156, if_statement; 156, 157; 156, 158; 157, identifier:_lookup_result; 158, block; 158, 159; 159, return_statement; 159, 160; 160, identifier:_lookup_result; 161, except_clause; 161, 162; 161, 175; 162, as_pattern; 162, 163; 162, 173; 163, tuple; 163, 164; 163, 167; 163, 170; 164, attribute; 164, 165; 164, 166; 165, identifier:exc; 166, identifier:HTTPClientError; 167, attribute; 167, 168; 167, 169; 168, identifier:exc; 169, identifier:HTTPNotFound; 170, attribute; 170, 171; 170, 172; 171, identifier:exc; 172, identifier:HTTPMethodNotAllowed; 173, as_pattern_target; 173, 174; 174, identifier:e; 175, block; 175, 176; 175, 186; 175, 191; 175, 266; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:_lookup_result; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:_handle_lookup; 183, argument_list; 183, 184; 183, 185; 184, identifier:args; 185, identifier:request; 186, if_statement; 186, 187; 186, 188; 187, identifier:_lookup_result; 188, block; 188, 189; 189, return_statement; 189, 190; 190, identifier:_lookup_result; 191, if_statement; 191, 192; 191, 199; 192, call; 192, 193; 192, 194; 193, identifier:isinstance; 194, argument_list; 194, 195; 194, 196; 195, identifier:e; 196, attribute; 196, 197; 196, 198; 197, identifier:exc; 198, identifier:HTTPMethodNotAllowed; 199, block; 199, 200; 199, 255; 200, function_definition; 200, 201; 200, 202; 200, 203; 201, function_name:method_iter; 202, parameters; 203, block; 203, 204; 203, 226; 204, for_statement; 204, 205; 204, 206; 204, 213; 205, identifier:func; 206, tuple; 206, 207; 206, 208; 206, 209; 206, 210; 206, 211; 206, 212; 207, string:'get'; 208, string:'get_one'; 209, string:'get_all'; 210, string:'new'; 211, string:'edit'; 212, string:'get_delete'; 213, block; 213, 214; 214, if_statement; 214, 215; 214, 221; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:_find_controller; 219, argument_list; 219, 220; 220, identifier:func; 221, block; 221, 222; 221, 225; 222, expression_statement; 222, 223; 223, yield; 223, 224; 224, string:'GET'; 225, break_statement; 226, for_statement; 226, 227; 226, 228; 226, 235; 227, identifier:method; 228, tuple; 228, 229; 228, 230; 228, 231; 228, 232; 228, 233; 228, 234; 229, string:'HEAD'; 230, string:'POST'; 231, string:'PUT'; 232, string:'DELETE'; 233, string:'TRACE'; 234, string:'PATCH'; 235, block; 235, 236; 235, 244; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:func; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:method; 242, identifier:lower; 243, argument_list; 244, if_statement; 244, 245; 244, 251; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:_find_controller; 249, argument_list; 249, 250; 250, identifier:func; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, yield; 253, 254; 254, identifier:method; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:e; 259, identifier:allow; 260, call; 260, 261; 260, 262; 261, identifier:sorted; 262, argument_list; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:method_iter; 265, argument_list; 266, raise_statement; 267, return_statement; 267, 268; 268, identifier:result | def _route(self, args, request=None):
'''
Routes a request to the appropriate controller and returns its result.
Performs a bit of validation - refuses to route delete and put actions
via a GET request).
'''
if request is None:
from pecan import request
method = request.params.get('_method', request.method).lower()
if request.method == 'GET' and method in ('delete', 'put'):
abort(405)
result = self._find_sub_controllers(args, request)
if result:
return result
handler = getattr(
self,
'_handle_%s' % method,
self._handle_unknown_method
)
try:
if len(getargspec(handler).args) == 3:
result = handler(method, args)
else:
result = handler(method, args, request)
argspec = self._get_args_for_controller(result[0])
num_args = len(argspec)
if num_args < len(args):
_lookup_result = self._handle_lookup(args, request)
if _lookup_result:
return _lookup_result
except (exc.HTTPClientError, exc.HTTPNotFound,
exc.HTTPMethodNotAllowed) as e:
_lookup_result = self._handle_lookup(args, request)
if _lookup_result:
return _lookup_result
if isinstance(e, exc.HTTPMethodNotAllowed):
def method_iter():
for func in ('get', 'get_one', 'get_all', 'new', 'edit',
'get_delete'):
if self._find_controller(func):
yield 'GET'
break
for method in ('HEAD', 'POST', 'PUT', 'DELETE', 'TRACE',
'PATCH'):
func = method.lower()
if self._find_controller(func):
yield method
e.allow = sorted(method_iter())
raise
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_handle_get; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:method; 6, identifier:remainder; 7, default_parameter; 7, 8; 7, 9; 8, identifier:request; 9, None; 10, block; 10, 11; 10, 13; 10, 27; 10, 82; 10, 89; 10, 127; 10, 138; 10, 143; 10, 154; 10, 174; 10, 184; 10, 200; 11, expression_statement; 11, 12; 12, string:'''
Routes ``GET`` actions to the appropriate controller.
'''; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:request; 16, None; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_raise_method_deprecation_warning; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_handle_get; 27, if_statement; 27, 28; 27, 35; 28, boolean_operator:or; 28, 29; 28, 31; 29, not_operator; 29, 30; 30, identifier:remainder; 31, comparison_operator:==; 31, 32; 31, 33; 32, identifier:remainder; 33, list:['']; 33, 34; 34, string:''; 35, block; 35, 36; 35, 51; 35, 61; 35, 77; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:remainder; 39, call; 39, 40; 39, 41; 40, identifier:list; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:six; 46, identifier:moves; 47, identifier:filter; 48, argument_list; 48, 49; 48, 50; 49, identifier:bool; 50, identifier:remainder; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:controller; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:_find_controller; 58, argument_list; 58, 59; 58, 60; 59, string:'get_all'; 60, string:'get'; 61, if_statement; 61, 62; 61, 63; 62, identifier:controller; 63, block; 63, 64; 63, 73; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_handle_bad_rest_arguments; 69, argument_list; 69, 70; 69, 71; 69, 72; 70, identifier:controller; 71, identifier:remainder; 72, identifier:request; 73, return_statement; 73, 74; 74, expression_list; 74, 75; 74, 76; 75, identifier:controller; 76, list:[]; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:abort; 80, argument_list; 80, 81; 81, integer:405; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:method_name; 85, subscript; 85, 86; 85, 87; 86, identifier:remainder; 87, unary_operator:-; 87, 88; 88, integer:1; 89, if_statement; 89, 90; 89, 96; 90, comparison_operator:in; 90, 91; 90, 92; 91, identifier:method_name; 92, tuple; 92, 93; 92, 94; 92, 95; 93, string:'new'; 94, string:'edit'; 95, string:'delete'; 96, block; 96, 97; 96, 106; 96, 115; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:==; 98, 99; 98, 100; 99, identifier:method_name; 100, string:'delete'; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:method_name; 105, string:'get_delete'; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:controller; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:_find_controller; 113, argument_list; 113, 114; 114, identifier:method_name; 115, if_statement; 115, 116; 115, 117; 116, identifier:controller; 117, block; 117, 118; 118, return_statement; 118, 119; 119, expression_list; 119, 120; 119, 121; 120, identifier:controller; 121, subscript; 121, 122; 121, 123; 122, identifier:remainder; 123, slice; 123, 124; 123, 125; 124, colon; 125, unary_operator:-; 125, 126; 126, integer:1; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:match; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_handle_custom_action; 134, argument_list; 134, 135; 134, 136; 134, 137; 135, identifier:method; 136, identifier:remainder; 137, identifier:request; 138, if_statement; 138, 139; 138, 140; 139, identifier:match; 140, block; 140, 141; 141, return_statement; 141, 142; 142, identifier:match; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:controller; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_lookup_child; 150, argument_list; 150, 151; 151, subscript; 151, 152; 151, 153; 152, identifier:remainder; 153, integer:0; 154, if_statement; 154, 155; 154, 162; 155, boolean_operator:and; 155, 156; 155, 157; 156, identifier:controller; 157, not_operator; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:ismethod; 160, argument_list; 160, 161; 161, identifier:controller; 162, block; 162, 163; 163, return_statement; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:lookup_controller; 166, argument_list; 166, 167; 166, 168; 166, 173; 167, identifier:controller; 168, subscript; 168, 169; 168, 170; 169, identifier:remainder; 170, slice; 170, 171; 170, 172; 171, integer:1; 172, colon; 173, identifier:request; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:controller; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:_find_controller; 181, argument_list; 181, 182; 181, 183; 182, string:'get_one'; 183, string:'get'; 184, if_statement; 184, 185; 184, 186; 185, identifier:controller; 186, block; 186, 187; 186, 196; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_handle_bad_rest_arguments; 192, argument_list; 192, 193; 192, 194; 192, 195; 193, identifier:controller; 194, identifier:remainder; 195, identifier:request; 196, return_statement; 196, 197; 197, expression_list; 197, 198; 197, 199; 198, identifier:controller; 199, identifier:remainder; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:abort; 203, argument_list; 203, 204; 204, integer:405 | def _handle_get(self, method, remainder, request=None):
'''
Routes ``GET`` actions to the appropriate controller.
'''
if request is None:
self._raise_method_deprecation_warning(self._handle_get)
if not remainder or remainder == ['']:
remainder = list(six.moves.filter(bool, remainder))
controller = self._find_controller('get_all', 'get')
if controller:
self._handle_bad_rest_arguments(controller, remainder, request)
return controller, []
abort(405)
method_name = remainder[-1]
if method_name in ('new', 'edit', 'delete'):
if method_name == 'delete':
method_name = 'get_delete'
controller = self._find_controller(method_name)
if controller:
return controller, remainder[:-1]
match = self._handle_custom_action(method, remainder, request)
if match:
return match
controller = self._lookup_child(remainder[0])
if controller and not ismethod(controller):
return lookup_controller(controller, remainder[1:], request)
controller = self._find_controller('get_one', 'get')
if controller:
self._handle_bad_rest_arguments(controller, remainder, request)
return controller, remainder
abort(405) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_handle_delete; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:method; 6, identifier:remainder; 7, default_parameter; 7, 8; 7, 9; 8, identifier:request; 9, None; 10, block; 10, 11; 10, 13; 10, 27; 10, 77; 10, 87; 10, 94; 10, 137; 11, expression_statement; 11, 12; 12, string:'''
Routes ``DELETE`` actions to the appropriate controller.
'''; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:request; 16, None; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_raise_method_deprecation_warning; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_handle_delete; 27, if_statement; 27, 28; 27, 29; 28, identifier:remainder; 29, block; 29, 30; 29, 41; 29, 46; 29, 57; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:match; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_handle_custom_action; 37, argument_list; 37, 38; 37, 39; 37, 40; 38, identifier:method; 39, identifier:remainder; 40, identifier:request; 41, if_statement; 41, 42; 41, 43; 42, identifier:match; 43, block; 43, 44; 44, return_statement; 44, 45; 45, identifier:match; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:controller; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_lookup_child; 53, argument_list; 53, 54; 54, subscript; 54, 55; 54, 56; 55, identifier:remainder; 56, integer:0; 57, if_statement; 57, 58; 57, 65; 58, boolean_operator:and; 58, 59; 58, 60; 59, identifier:controller; 60, not_operator; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:ismethod; 63, argument_list; 63, 64; 64, identifier:controller; 65, block; 65, 66; 66, return_statement; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:lookup_controller; 69, argument_list; 69, 70; 69, 71; 69, 76; 70, identifier:controller; 71, subscript; 71, 72; 71, 73; 72, identifier:remainder; 73, slice; 73, 74; 73, 75; 74, integer:1; 75, colon; 76, identifier:request; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:controller; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_find_controller; 84, argument_list; 84, 85; 84, 86; 85, string:'post_delete'; 86, string:'delete'; 87, if_statement; 87, 88; 87, 89; 88, identifier:controller; 89, block; 89, 90; 90, return_statement; 90, 91; 91, expression_list; 91, 92; 91, 93; 92, identifier:controller; 93, identifier:remainder; 94, if_statement; 94, 95; 94, 96; 95, identifier:remainder; 96, block; 96, 97; 96, 112; 96, 123; 97, if_statement; 97, 98; 97, 106; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_find_controller; 102, argument_list; 102, 103; 103, subscript; 103, 104; 103, 105; 104, identifier:remainder; 105, integer:0; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:abort; 110, argument_list; 110, 111; 111, integer:405; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:sub_controller; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_lookup_child; 119, argument_list; 119, 120; 120, subscript; 120, 121; 120, 122; 121, identifier:remainder; 122, integer:0; 123, if_statement; 123, 124; 123, 125; 124, identifier:sub_controller; 125, block; 125, 126; 126, return_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:lookup_controller; 129, argument_list; 129, 130; 129, 131; 129, 136; 130, identifier:sub_controller; 131, subscript; 131, 132; 131, 133; 132, identifier:remainder; 133, slice; 133, 134; 133, 135; 134, integer:1; 135, colon; 136, identifier:request; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:abort; 140, argument_list; 140, 141; 141, integer:405 | def _handle_delete(self, method, remainder, request=None):
'''
Routes ``DELETE`` actions to the appropriate controller.
'''
if request is None:
self._raise_method_deprecation_warning(self._handle_delete)
if remainder:
match = self._handle_custom_action(method, remainder, request)
if match:
return match
controller = self._lookup_child(remainder[0])
if controller and not ismethod(controller):
return lookup_controller(controller, remainder[1:], request)
controller = self._find_controller('post_delete', 'delete')
if controller:
return controller, remainder
if remainder:
if self._find_controller(remainder[0]):
abort(405)
sub_controller = self._lookup_child(remainder[0])
if sub_controller:
return lookup_controller(sub_controller, remainder[1:],
request)
abort(405) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:gunicorn_run; 3, parameters; 4, block; 4, 5; 4, 53; 4, 230; 5, try_statement; 5, 6; 5, 14; 6, block; 6, 7; 7, import_from_statement; 7, 8; 7, 12; 8, dotted_name; 8, 9; 8, 10; 8, 11; 9, identifier:gunicorn; 10, identifier:app; 11, identifier:wsgiapp; 12, dotted_name; 12, 13; 13, identifier:WSGIApplication; 14, except_clause; 14, 15; 14, 19; 15, as_pattern; 15, 16; 15, 17; 16, identifier:ImportError; 17, as_pattern_target; 17, 18; 18, identifier:exc; 19, block; 19, 20; 19, 26; 19, 35; 19, 39; 19, 52; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:args; 23, attribute; 23, 24; 23, 25; 24, identifier:exc; 25, identifier:args; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:arg0; 29, conditional_expression:if; 29, 30; 29, 33; 29, 34; 30, subscript; 30, 31; 30, 32; 31, identifier:args; 32, integer:0; 33, identifier:args; 34, string:''; 35, expression_statement; 35, 36; 36, augmented_assignment:+=; 36, 37; 36, 38; 37, identifier:arg0; 38, string:' (are you sure `gunicorn` is installed?)'; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:exc; 43, identifier:args; 44, binary_operator:+; 44, 45; 44, 47; 45, tuple; 45, 46; 46, identifier:arg0; 47, subscript; 47, 48; 47, 49; 48, identifier:args; 49, slice; 49, 50; 49, 51; 50, integer:1; 51, colon; 52, raise_statement; 53, class_definition; 53, 54; 53, 55; 53, 57; 54, identifier:PecanApplication; 55, argument_list; 55, 56; 56, identifier:WSGIApplication; 57, block; 57, 58; 57, 212; 58, function_definition; 58, 59; 58, 60; 58, 65; 59, function_name:init; 60, parameters; 60, 61; 60, 62; 60, 63; 60, 64; 61, identifier:self; 62, identifier:parser; 63, identifier:opts; 64, identifier:args; 65, block; 65, 66; 65, 81; 65, 108; 65, 123; 65, 147; 65, 155; 65, 165; 65, 169; 65, 210; 66, if_statement; 66, 67; 66, 73; 67, comparison_operator:!=; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:len; 70, argument_list; 70, 71; 71, identifier:args; 72, integer:1; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:parser; 78, identifier:error; 79, argument_list; 79, 80; 80, string:"No configuration file was specified."; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:cfgfname; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:os; 90, identifier:path; 91, identifier:normpath; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:os; 97, identifier:path; 98, identifier:join; 99, argument_list; 99, 100; 99, 105; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:os; 103, identifier:getcwd; 104, argument_list; 105, subscript; 105, 106; 105, 107; 106, identifier:args; 107, integer:0; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:cfgfname; 113, call; 113, 114; 113, 119; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:os; 117, identifier:path; 118, identifier:abspath; 119, argument_list; 119, 120; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:cfgfname; 123, if_statement; 123, 124; 123, 135; 124, not_operator; 124, 125; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:os; 129, identifier:path; 130, identifier:exists; 131, argument_list; 131, 132; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:cfgfname; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:parser; 140, identifier:error; 141, argument_list; 141, 142; 142, binary_operator:%; 142, 143; 142, 144; 143, string:"Config file not found: %s"; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:cfgfname; 147, import_from_statement; 147, 148; 147, 151; 147, 153; 148, dotted_name; 148, 149; 148, 150; 149, identifier:pecan; 150, identifier:configuration; 151, dotted_name; 151, 152; 152, identifier:_runtime_conf; 153, dotted_name; 153, 154; 154, identifier:set_config; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:set_config; 158, argument_list; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:cfgfname; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:overwrite; 164, True; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:cfg; 168, dictionary; 169, if_statement; 169, 170; 169, 176; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:_runtime_conf; 173, identifier:get; 174, argument_list; 174, 175; 175, string:'server'; 176, block; 176, 177; 176, 183; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:server; 180, subscript; 180, 181; 180, 182; 181, identifier:_runtime_conf; 182, string:'server'; 183, if_statement; 183, 184; 183, 195; 184, boolean_operator:and; 184, 185; 184, 190; 185, call; 185, 186; 185, 187; 186, identifier:hasattr; 187, argument_list; 187, 188; 187, 189; 188, identifier:server; 189, string:'host'; 190, call; 190, 191; 190, 192; 191, identifier:hasattr; 192, argument_list; 192, 193; 192, 194; 193, identifier:server; 194, string:'port'; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:cfg; 200, string:'bind'; 201, binary_operator:%; 201, 202; 201, 203; 202, string:'%s:%s'; 203, tuple; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:server; 206, identifier:host; 207, attribute; 207, 208; 207, 209; 208, identifier:server; 209, identifier:port; 210, return_statement; 210, 211; 211, identifier:cfg; 212, function_definition; 212, 213; 212, 214; 212, 216; 213, function_name:load; 214, parameters; 214, 215; 215, identifier:self; 216, block; 216, 217; 216, 223; 217, import_from_statement; 217, 218; 217, 221; 218, dotted_name; 218, 219; 218, 220; 219, identifier:pecan; 220, identifier:deploy; 221, dotted_name; 221, 222; 222, identifier:deploy; 223, return_statement; 223, 224; 224, call; 224, 225; 224, 226; 225, identifier:deploy; 226, argument_list; 226, 227; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:cfgfname; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 238; 232, attribute; 232, 233; 232, 237; 233, call; 233, 234; 233, 235; 234, identifier:PecanApplication; 235, argument_list; 235, 236; 236, string:"%(prog)s [OPTIONS] config.py"; 237, identifier:run; 238, argument_list | def gunicorn_run():
try:
from gunicorn.app.wsgiapp import WSGIApplication
except ImportError as exc:
args = exc.args
arg0 = args[0] if args else ''
arg0 += ' (are you sure `gunicorn` is installed?)'
exc.args = (arg0,) + args[1:]
raise
class PecanApplication(WSGIApplication):
def init(self, parser, opts, args):
if len(args) != 1:
parser.error("No configuration file was specified.")
self.cfgfname = os.path.normpath(
os.path.join(os.getcwd(), args[0])
)
self.cfgfname = os.path.abspath(self.cfgfname)
if not os.path.exists(self.cfgfname):
parser.error("Config file not found: %s" % self.cfgfname)
from pecan.configuration import _runtime_conf, set_config
set_config(self.cfgfname, overwrite=True)
cfg = {}
if _runtime_conf.get('server'):
server = _runtime_conf['server']
if hasattr(server, 'host') and hasattr(server, 'port'):
cfg['bind'] = '%s:%s' % (
server.host, server.port
)
return cfg
def load(self):
from pecan.deploy import deploy
return deploy(self.cfgfname)
PecanApplication("%(prog)s [OPTIONS] config.py").run() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:expose; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:template; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:generic; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:route; 12, None; 13, dictionary_splat_pattern; 13, 14; 14, identifier:kw; 15, block; 15, 16; 15, 18; 15, 28; 15, 37; 15, 192; 16, expression_statement; 16, 17; 17, string:'''
Decorator used to flag controller methods as being "exposed" for
access via HTTP, and to configure that access.
:param template: The path to a template, relative to the base template
directory. Can also be passed a string representing
a special or custom renderer, such as ``'json'`` for
:ref:`expose_json`.
:param content_type: The content-type to use for this template.
:param generic: A boolean which flags this as a "generic" controller,
which uses generic functions based upon
``functools.singledispatch`` generic functions. Allows you
to split a single controller into multiple paths based upon
HTTP method.
:param route: The name of the path segment to match (excluding
separator characters, like `/`). Defaults to the name of
the function itself, but this can be used to resolve paths
which are not valid Python function names, e.g., if you
wanted to route a function to `some-special-path'.
'''; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:content_type; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:kw; 24, identifier:get; 25, argument_list; 25, 26; 25, 27; 26, string:'content_type'; 27, string:'text/html'; 28, if_statement; 28, 29; 28, 32; 29, comparison_operator:==; 29, 30; 29, 31; 30, identifier:template; 31, string:'json'; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:content_type; 36, string:'application/json'; 37, function_definition; 37, 38; 37, 39; 37, 41; 38, function_name:decorate; 39, parameters; 39, 40; 40, identifier:f; 41, block; 41, 42; 41, 48; 41, 55; 41, 63; 41, 94; 41, 100; 41, 113; 41, 125; 41, 181; 41, 190; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:f; 46, identifier:exposed; 47, True; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:cfg; 51, call; 51, 52; 51, 53; 52, identifier:_cfg; 53, argument_list; 53, 54; 54, identifier:f; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:cfg; 59, string:'explicit_content_type'; 60, comparison_operator:in; 60, 61; 60, 62; 61, string:'content_type'; 62, identifier:kw; 63, if_statement; 63, 64; 63, 65; 64, identifier:route; 65, block; 65, 66; 65, 71; 65, 86; 66, import_from_statement; 66, 67; 66, 69; 67, dotted_name; 67, 68; 68, identifier:pecan; 69, dotted_name; 69, 70; 70, identifier:routing; 71, if_statement; 71, 72; 71, 78; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:cfg; 75, identifier:get; 76, argument_list; 76, 77; 77, string:'generic_handler'; 78, block; 78, 79; 79, raise_statement; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:ValueError; 82, argument_list; 82, 83; 83, concatenated_string; 83, 84; 83, 85; 84, string:'Path segments cannot be overridden for generic '; 85, string:'controllers.'; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:routing; 90, identifier:route; 91, argument_list; 91, 92; 91, 93; 92, identifier:route; 93, identifier:f; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:cfg; 98, string:'content_type'; 99, identifier:content_type; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 111; 102, attribute; 102, 103; 102, 110; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:cfg; 106, identifier:setdefault; 107, argument_list; 107, 108; 107, 109; 108, string:'template'; 109, list:[]; 110, identifier:append; 111, argument_list; 111, 112; 112, identifier:template; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 124; 115, subscript; 115, 116; 115, 123; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:cfg; 119, identifier:setdefault; 120, argument_list; 120, 121; 120, 122; 121, string:'content_types'; 122, dictionary; 123, identifier:content_type; 124, identifier:template; 125, if_statement; 125, 126; 125, 127; 126, identifier:generic; 127, block; 127, 128; 127, 149; 127, 155; 127, 166; 127, 172; 128, if_statement; 128, 129; 128, 137; 129, comparison_operator:in; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:f; 132, identifier:__name__; 133, tuple; 133, 134; 133, 135; 133, 136; 134, string:'_default'; 135, string:'_lookup'; 136, string:'_route'; 137, block; 137, 138; 138, raise_statement; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:ValueError; 141, argument_list; 141, 142; 142, binary_operator:%; 142, 143; 142, 146; 143, concatenated_string; 143, 144; 143, 145; 144, string:'The special method %s cannot be used as a generic '; 145, string:'controller'; 146, attribute; 146, 147; 146, 148; 147, identifier:f; 148, identifier:__name__; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:cfg; 153, string:'generic'; 154, True; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:cfg; 159, string:'generic_handlers'; 160, call; 160, 161; 160, 162; 161, identifier:dict; 162, argument_list; 162, 163; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:DEFAULT; 165, identifier:f; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:cfg; 170, string:'allowed_methods'; 171, list:[]; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:f; 176, identifier:when; 177, call; 177, 178; 177, 179; 178, identifier:when_for; 179, argument_list; 179, 180; 180, identifier:f; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:cfg; 185, string:'argspec'; 186, call; 186, 187; 186, 188; 187, identifier:getargspec; 188, argument_list; 188, 189; 189, identifier:f; 190, return_statement; 190, 191; 191, identifier:f; 192, return_statement; 192, 193; 193, identifier:decorate | def expose(template=None,
generic=False,
route=None,
**kw):
'''
Decorator used to flag controller methods as being "exposed" for
access via HTTP, and to configure that access.
:param template: The path to a template, relative to the base template
directory. Can also be passed a string representing
a special or custom renderer, such as ``'json'`` for
:ref:`expose_json`.
:param content_type: The content-type to use for this template.
:param generic: A boolean which flags this as a "generic" controller,
which uses generic functions based upon
``functools.singledispatch`` generic functions. Allows you
to split a single controller into multiple paths based upon
HTTP method.
:param route: The name of the path segment to match (excluding
separator characters, like `/`). Defaults to the name of
the function itself, but this can be used to resolve paths
which are not valid Python function names, e.g., if you
wanted to route a function to `some-special-path'.
'''
content_type = kw.get('content_type', 'text/html')
if template == 'json':
content_type = 'application/json'
def decorate(f):
f.exposed = True
cfg = _cfg(f)
cfg['explicit_content_type'] = 'content_type' in kw
if route:
from pecan import routing
if cfg.get('generic_handler'):
raise ValueError(
'Path segments cannot be overridden for generic '
'controllers.'
)
routing.route(route, f)
cfg['content_type'] = content_type
cfg.setdefault('template', []).append(template)
cfg.setdefault('content_types', {})[content_type] = template
if generic:
if f.__name__ in ('_default', '_lookup', '_route'):
raise ValueError(
'The special method %s cannot be used as a generic '
'controller' % f.__name__
)
cfg['generic'] = True
cfg['generic_handlers'] = dict(DEFAULT=f)
cfg['allowed_methods'] = []
f.when = when_for(f)
cfg['argspec'] = getargspec(f)
return f
return decorate |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:add_operations_bulk; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:payload; 6, block; 6, 7; 6, 19; 6, 29; 6, 33; 6, 37; 6, 41; 6, 134; 6, 144; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 13; 9, pattern_list; 9, 10; 9, 11; 9, 12; 10, identifier:valid_indices; 11, identifier:_; 12, identifier:_; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_check_agent_id_bulk; 17, argument_list; 17, 18; 18, identifier:payload; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:valid_payload; 22, list_comprehension; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:payload; 25, identifier:i; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:i; 28, identifier:valid_indices; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:chunked_data; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:current_chunk; 36, list:[]; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:current_chunk_size; 40, integer:0; 41, for_statement; 41, 42; 41, 43; 41, 44; 42, identifier:agent; 43, identifier:valid_payload; 44, block; 44, 45; 45, if_statement; 45, 46; 45, 58; 46, parenthesized_expression; 46, 47; 47, boolean_operator:and; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:agent; 50, string:"operations"; 51, call; 51, 52; 51, 53; 52, identifier:isinstance; 53, argument_list; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:agent; 56, string:"operations"; 57, identifier:list; 58, block; 58, 59; 58, 90; 59, if_statement; 59, 60; 59, 74; 60, comparison_operator:>; 60, 61; 60, 69; 61, binary_operator:+; 61, 62; 61, 63; 62, identifier:current_chunk_size; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:agent; 68, string:"operations"; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:config; 73, string:"operationsChunksSize"; 74, block; 74, 75; 74, 82; 74, 86; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:chunked_data; 79, identifier:append; 80, argument_list; 80, 81; 81, identifier:current_chunk; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:current_chunk_size; 85, integer:0; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:current_chunk; 89, list:[]; 90, if_statement; 90, 91; 90, 103; 90, 116; 91, comparison_operator:>; 91, 92; 91, 98; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, subscript; 95, 96; 95, 97; 96, identifier:agent; 97, string:"operations"; 98, subscript; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:config; 102, string:"operationsChunksSize"; 103, block; 103, 104; 103, 112; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:chunked_data; 108, identifier:append; 109, argument_list; 109, 110; 110, list:[agent]; 110, 111; 111, identifier:agent; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:current_chunk_size; 115, integer:0; 116, else_clause; 116, 117; 117, block; 117, 118; 117, 127; 118, expression_statement; 118, 119; 119, augmented_assignment:+=; 119, 120; 119, 121; 120, identifier:current_chunk_size; 121, call; 121, 122; 121, 123; 122, identifier:len; 123, argument_list; 123, 124; 124, subscript; 124, 125; 124, 126; 125, identifier:agent; 126, string:"operations"; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:current_chunk; 131, identifier:append; 132, argument_list; 132, 133; 133, identifier:agent; 134, if_statement; 134, 135; 134, 136; 135, identifier:current_chunk; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:chunked_data; 141, identifier:append; 142, argument_list; 142, 143; 143, identifier:current_chunk; 144, return_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:_add_operations_bulk; 149, argument_list; 149, 150; 150, identifier:chunked_data | def add_operations_bulk(self, payload):
valid_indices, _, _ = self._check_agent_id_bulk(payload)
valid_payload = [payload[i] for i in valid_indices]
chunked_data = []
current_chunk = []
current_chunk_size = 0
for agent in valid_payload:
if (agent["operations"] and isinstance(agent["operations"], list)):
if current_chunk_size + len(agent["operations"]) > self.config["operationsChunksSize"]:
chunked_data.append(current_chunk)
current_chunk_size = 0
current_chunk = []
if len(agent["operations"]) > self.config["operationsChunksSize"]:
chunked_data.append([agent])
current_chunk_size = 0
else:
current_chunk_size += len(agent["operations"])
current_chunk.append(agent)
if current_chunk:
chunked_data.append(current_chunk)
return self._add_operations_bulk(chunked_data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:line; 6, default_parameter; 6, 7; 6, 8; 7, identifier:encoding; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:pydle; 11, identifier:protocol; 12, identifier:DEFAULT_ENCODING; 13, block; 13, 14; 13, 18; 13, 45; 13, 59; 13, 107; 13, 124; 13, 165; 13, 212; 13, 227; 13, 333; 13, 353; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:valid; 17, True; 18, try_statement; 18, 19; 18, 29; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:message; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:line; 26, identifier:decode; 27, argument_list; 27, 28; 28, identifier:encoding; 29, except_clause; 29, 30; 29, 31; 30, identifier:UnicodeDecodeError; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:message; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:line; 38, identifier:decode; 39, argument_list; 39, 40; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:pydle; 43, identifier:protocol; 44, identifier:FALLBACK_ENCODING; 45, if_statement; 45, 46; 45, 54; 46, comparison_operator:>; 46, 47; 46, 51; 47, call; 47, 48; 47, 49; 48, identifier:len; 49, argument_list; 49, 50; 50, identifier:message; 51, attribute; 51, 52; 51, 53; 52, identifier:protocol; 53, identifier:MESSAGE_LENGTH_LIMIT; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:valid; 58, False; 59, if_statement; 59, 60; 59, 68; 59, 83; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:message; 63, identifier:endswith; 64, argument_list; 64, 65; 65, attribute; 65, 66; 65, 67; 66, identifier:protocol; 67, identifier:LINE_SEPARATOR; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:message; 72, subscript; 72, 73; 72, 74; 73, identifier:message; 74, slice; 74, 75; 74, 76; 75, colon; 76, unary_operator:-; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:protocol; 82, identifier:LINE_SEPARATOR; 83, elif_clause; 83, 84; 83, 92; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:message; 87, identifier:endswith; 88, argument_list; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:protocol; 91, identifier:MINIMAL_LINE_SEPARATOR; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:message; 96, subscript; 96, 97; 96, 98; 97, identifier:message; 98, slice; 98, 99; 98, 100; 99, colon; 100, unary_operator:-; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:len; 103, argument_list; 103, 104; 104, attribute; 104, 105; 104, 106; 105, identifier:protocol; 106, identifier:MINIMAL_LINE_SEPARATOR; 107, if_statement; 107, 108; 107, 119; 108, call; 108, 109; 108, 110; 109, identifier:any; 110, generator_expression; 110, 111; 110, 114; 111, comparison_operator:in; 111, 112; 111, 113; 112, identifier:ch; 113, identifier:message; 114, for_in_clause; 114, 115; 114, 116; 115, identifier:ch; 116, attribute; 116, 117; 116, 118; 117, identifier:protocol; 118, identifier:FORBIDDEN_CHARACTERS; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:valid; 123, False; 124, if_statement; 124, 125; 124, 131; 124, 148; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:message; 128, identifier:startswith; 129, argument_list; 129, 130; 130, string:':'; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:parts; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:protocol; 139, identifier:ARGUMENT_SEPARATOR; 140, identifier:split; 141, argument_list; 141, 142; 141, 147; 142, subscript; 142, 143; 142, 144; 143, identifier:message; 144, slice; 144, 145; 144, 146; 145, integer:1; 146, colon; 147, integer:2; 148, else_clause; 148, 149; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:parts; 153, binary_operator:+; 153, 154; 153, 156; 154, list:[ None ]; 154, 155; 155, None; 156, call; 156, 157; 156, 162; 157, attribute; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:protocol; 160, identifier:ARGUMENT_SEPARATOR; 161, identifier:split; 162, argument_list; 162, 163; 162, 164; 163, identifier:message; 164, integer:1; 165, if_statement; 165, 166; 165, 172; 165, 180; 165, 198; 166, comparison_operator:==; 166, 167; 166, 171; 167, call; 167, 168; 167, 169; 168, identifier:len; 169, argument_list; 169, 170; 170, identifier:parts; 171, integer:3; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 179; 175, pattern_list; 175, 176; 175, 177; 175, 178; 176, identifier:source; 177, identifier:command; 178, identifier:raw_params; 179, identifier:parts; 180, elif_clause; 180, 181; 180, 187; 181, comparison_operator:==; 181, 182; 181, 186; 182, call; 182, 183; 182, 184; 183, identifier:len; 184, argument_list; 184, 185; 185, identifier:parts; 186, integer:2; 187, block; 187, 188; 187, 194; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, pattern_list; 190, 191; 190, 192; 191, identifier:source; 192, identifier:command; 193, identifier:parts; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:raw_params; 197, string:''; 198, else_clause; 198, 199; 199, block; 199, 200; 200, raise_statement; 200, 201; 201, call; 201, 202; 201, 207; 202, attribute; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:pydle; 205, identifier:protocol; 206, identifier:ProtocolViolation; 207, argument_list; 207, 208; 207, 209; 208, string:'Improper IRC message format: not enough elements.'; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:message; 211, identifier:message; 212, if_statement; 212, 213; 212, 222; 213, not_operator; 213, 214; 214, call; 214, 215; 214, 220; 215, attribute; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:protocol; 218, identifier:COMMAND_PATTERN; 219, identifier:match; 220, argument_list; 220, 221; 221, identifier:command; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:valid; 226, False; 227, if_statement; 227, 228; 227, 236; 227, 251; 227, 313; 227, 327; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:raw_params; 231, identifier:startswith; 232, argument_list; 232, 233; 233, attribute; 233, 234; 233, 235; 234, identifier:protocol; 235, identifier:TRAILING_PREFIX; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:params; 240, list:[ raw_params[len(protocol.TRAILING_PREFIX):] ]; 240, 241; 241, subscript; 241, 242; 241, 243; 242, identifier:raw_params; 243, slice; 243, 244; 243, 250; 244, call; 244, 245; 244, 246; 245, identifier:len; 246, argument_list; 246, 247; 247, attribute; 247, 248; 247, 249; 248, identifier:protocol; 249, identifier:TRAILING_PREFIX; 250, colon; 251, elif_clause; 251, 252; 251, 259; 252, comparison_operator:in; 252, 253; 252, 258; 253, binary_operator:+; 253, 254; 253, 255; 254, string:' '; 255, attribute; 255, 256; 255, 257; 256, identifier:protocol; 257, identifier:TRAILING_PREFIX; 258, identifier:raw_params; 259, block; 259, 260; 259, 273; 259, 293; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:index; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:raw_params; 266, identifier:find; 267, argument_list; 267, 268; 268, binary_operator:+; 268, 269; 268, 270; 269, string:' '; 270, attribute; 270, 271; 270, 272; 271, identifier:protocol; 272, identifier:TRAILING_PREFIX; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:params; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:protocol; 280, identifier:ARGUMENT_SEPARATOR; 281, identifier:split; 282, argument_list; 282, 283; 283, call; 283, 284; 283, 291; 284, attribute; 284, 285; 284, 290; 285, subscript; 285, 286; 285, 287; 286, identifier:raw_params; 287, slice; 287, 288; 287, 289; 288, colon; 289, identifier:index; 290, identifier:rstrip; 291, argument_list; 291, 292; 292, string:' '; 293, expression_statement; 293, 294; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:params; 297, identifier:append; 298, argument_list; 298, 299; 299, subscript; 299, 300; 299, 301; 300, identifier:raw_params; 301, slice; 301, 302; 301, 312; 302, binary_operator:+; 302, 303; 302, 311; 303, binary_operator:+; 303, 304; 303, 305; 304, identifier:index; 305, call; 305, 306; 305, 307; 306, identifier:len; 307, argument_list; 307, 308; 308, attribute; 308, 309; 308, 310; 309, identifier:protocol; 310, identifier:TRAILING_PREFIX; 311, integer:1; 312, colon; 313, elif_clause; 313, 314; 313, 315; 314, identifier:raw_params; 315, block; 315, 316; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:params; 319, call; 319, 320; 319, 325; 320, attribute; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:protocol; 323, identifier:ARGUMENT_SEPARATOR; 324, identifier:split; 325, argument_list; 325, 326; 326, identifier:raw_params; 327, else_clause; 327, 328; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:params; 332, list:[]; 333, try_statement; 333, 334; 333, 342; 334, block; 334, 335; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:command; 338, call; 338, 339; 338, 340; 339, identifier:int; 340, argument_list; 340, 341; 341, identifier:command; 342, except_clause; 342, 343; 342, 344; 343, identifier:ValueError; 344, block; 344, 345; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 348; 347, identifier:command; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:command; 351, identifier:upper; 352, argument_list; 353, return_statement; 353, 354; 354, call; 354, 355; 354, 356; 355, identifier:RFC1459Message; 356, argument_list; 356, 357; 356, 358; 356, 359; 356, 362; 356, 365; 357, identifier:command; 358, identifier:params; 359, keyword_argument; 359, 360; 359, 361; 360, identifier:source; 361, identifier:source; 362, keyword_argument; 362, 363; 362, 364; 363, identifier:_valid; 364, identifier:valid; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:_raw; 367, identifier:message | def parse(cls, line, encoding=pydle.protocol.DEFAULT_ENCODING):
valid = True
try:
message = line.decode(encoding)
except UnicodeDecodeError:
message = line.decode(pydle.protocol.FALLBACK_ENCODING)
if len(message) > protocol.MESSAGE_LENGTH_LIMIT:
valid = False
if message.endswith(protocol.LINE_SEPARATOR):
message = message[:-len(protocol.LINE_SEPARATOR)]
elif message.endswith(protocol.MINIMAL_LINE_SEPARATOR):
message = message[:-len(protocol.MINIMAL_LINE_SEPARATOR)]
if any(ch in message for ch in protocol.FORBIDDEN_CHARACTERS):
valid = False
if message.startswith(':'):
parts = protocol.ARGUMENT_SEPARATOR.split(message[1:], 2)
else:
parts = [ None ] + protocol.ARGUMENT_SEPARATOR.split(message, 1)
if len(parts) == 3:
source, command, raw_params = parts
elif len(parts) == 2:
source, command = parts
raw_params = ''
else:
raise pydle.protocol.ProtocolViolation('Improper IRC message format: not enough elements.', message=message)
if not protocol.COMMAND_PATTERN.match(command):
valid = False
if raw_params.startswith(protocol.TRAILING_PREFIX):
params = [ raw_params[len(protocol.TRAILING_PREFIX):] ]
elif ' ' + protocol.TRAILING_PREFIX in raw_params:
index = raw_params.find(' ' + protocol.TRAILING_PREFIX)
params = protocol.ARGUMENT_SEPARATOR.split(raw_params[:index].rstrip(' '))
params.append(raw_params[index + len(protocol.TRAILING_PREFIX) + 1:])
elif raw_params:
params = protocol.ARGUMENT_SEPARATOR.split(raw_params)
else:
params = []
try:
command = int(command)
except ValueError:
command = command.upper()
return RFC1459Message(command, params, source=source, _valid=valid, _raw=message) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:construct; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:force; 7, False; 8, block; 8, 9; 8, 18; 8, 55; 8, 63; 8, 73; 8, 143; 8, 160; 8, 202; 8, 208; 8, 248; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:command; 12, call; 12, 13; 12, 14; 13, identifier:str; 14, argument_list; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:command; 18, if_statement; 18, 19; 18, 31; 19, boolean_operator:and; 19, 20; 19, 29; 20, not_operator; 20, 21; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:protocol; 25, identifier:COMMAND_PATTERN; 26, identifier:match; 27, argument_list; 27, 28; 28, identifier:command; 29, not_operator; 29, 30; 30, identifier:force; 31, block; 31, 32; 32, raise_statement; 32, 33; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:pydle; 37, identifier:protocol; 38, identifier:ProtocolViolation; 39, argument_list; 39, 40; 39, 52; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, string:'The constructed command does not follow the command pattern ({pat})'; 43, identifier:format; 44, argument_list; 44, 45; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:pat; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:protocol; 50, identifier:COMMAND_PATTERN; 51, identifier:pattern; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:message; 54, identifier:command; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:message; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:command; 61, identifier:upper; 62, argument_list; 63, if_statement; 63, 64; 63, 68; 64, not_operator; 64, 65; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:params; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, augmented_assignment:+=; 70, 71; 70, 72; 71, identifier:message; 72, string:' '; 73, for_statement; 73, 74; 73, 77; 73, 83; 74, pattern_list; 74, 75; 74, 76; 75, identifier:idx; 76, identifier:param; 77, call; 77, 78; 77, 79; 78, identifier:enumerate; 79, argument_list; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:params; 83, block; 83, 84; 84, if_statement; 84, 85; 84, 97; 84, 135; 85, boolean_operator:or; 85, 86; 85, 92; 86, boolean_operator:or; 86, 87; 86, 89; 87, not_operator; 87, 88; 88, identifier:param; 89, comparison_operator:in; 89, 90; 89, 91; 90, string:' '; 91, identifier:param; 92, comparison_operator:==; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:param; 95, integer:0; 96, string:':'; 97, block; 97, 98; 97, 125; 98, if_statement; 98, 99; 98, 112; 99, boolean_operator:and; 99, 100; 99, 110; 100, comparison_operator:<; 100, 101; 100, 104; 101, binary_operator:+; 101, 102; 101, 103; 102, identifier:idx; 103, integer:1; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:params; 110, not_operator; 110, 111; 111, identifier:force; 112, block; 112, 113; 113, raise_statement; 113, 114; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:pydle; 118, identifier:protocol; 119, identifier:ProtocolViolation; 120, argument_list; 120, 121; 120, 122; 121, string:'Only the final parameter of an IRC message can be trailing and thus contain spaces, or start with a colon.'; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:message; 124, identifier:param; 125, expression_statement; 125, 126; 126, augmented_assignment:+=; 126, 127; 126, 128; 127, identifier:message; 128, binary_operator:+; 128, 129; 128, 134; 129, binary_operator:+; 129, 130; 129, 131; 130, string:' '; 131, attribute; 131, 132; 131, 133; 132, identifier:protocol; 133, identifier:TRAILING_PREFIX; 134, identifier:param; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, augmented_assignment:+=; 138, 139; 138, 140; 139, identifier:message; 140, binary_operator:+; 140, 141; 140, 142; 141, string:' '; 142, identifier:param; 143, if_statement; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:source; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:message; 151, binary_operator:+; 151, 152; 151, 159; 152, binary_operator:+; 152, 153; 152, 158; 153, binary_operator:+; 153, 154; 153, 155; 154, string:':'; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:source; 158, string:' '; 159, identifier:message; 160, if_statement; 160, 161; 160, 175; 161, boolean_operator:and; 161, 162; 161, 173; 162, call; 162, 163; 162, 164; 163, identifier:any; 164, generator_expression; 164, 165; 164, 168; 165, comparison_operator:in; 165, 166; 165, 167; 166, identifier:ch; 167, identifier:message; 168, for_in_clause; 168, 169; 168, 170; 169, identifier:ch; 170, attribute; 170, 171; 170, 172; 171, identifier:protocol; 172, identifier:FORBIDDEN_CHARACTERS; 173, not_operator; 173, 174; 174, identifier:force; 175, block; 175, 176; 176, raise_statement; 176, 177; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:pydle; 181, identifier:protocol; 182, identifier:ProtocolViolation; 183, argument_list; 183, 184; 183, 199; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, string:'The constructed message contains forbidden characters ({chs}).'; 187, identifier:format; 188, argument_list; 188, 189; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:chs; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, string:', '; 194, identifier:join; 195, argument_list; 195, 196; 196, attribute; 196, 197; 196, 198; 197, identifier:protocol; 198, identifier:FORBIDDEN_CHARACTERS; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:message; 201, identifier:message; 202, expression_statement; 202, 203; 203, augmented_assignment:+=; 203, 204; 203, 205; 204, identifier:message; 205, attribute; 205, 206; 205, 207; 206, identifier:protocol; 207, identifier:LINE_SEPARATOR; 208, if_statement; 208, 209; 208, 220; 209, boolean_operator:and; 209, 210; 209, 218; 210, comparison_operator:>; 210, 211; 210, 215; 211, call; 211, 212; 211, 213; 212, identifier:len; 213, argument_list; 213, 214; 214, identifier:message; 215, attribute; 215, 216; 215, 217; 216, identifier:protocol; 217, identifier:MESSAGE_LENGTH_LIMIT; 218, not_operator; 218, 219; 219, identifier:force; 220, block; 220, 221; 221, raise_statement; 221, 222; 222, call; 222, 223; 222, 228; 223, attribute; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:pydle; 226, identifier:protocol; 227, identifier:ProtocolViolation; 228, argument_list; 228, 229; 228, 245; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, string:'The constructed message is too long. ({len} > {maxlen})'; 232, identifier:format; 233, argument_list; 233, 234; 233, 240; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:len; 236, call; 236, 237; 236, 238; 237, identifier:len; 238, argument_list; 238, 239; 239, identifier:message; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:maxlen; 242, attribute; 242, 243; 242, 244; 243, identifier:protocol; 244, identifier:MESSAGE_LENGTH_LIMIT; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:message; 247, identifier:message; 248, return_statement; 248, 249; 249, identifier:message | def construct(self, force=False):
command = str(self.command)
if not protocol.COMMAND_PATTERN.match(command) and not force:
raise pydle.protocol.ProtocolViolation('The constructed command does not follow the command pattern ({pat})'.format(pat=protocol.COMMAND_PATTERN.pattern), message=command)
message = command.upper()
if not self.params:
message += ' '
for idx, param in enumerate(self.params):
if not param or ' ' in param or param[0] == ':':
if idx + 1 < len(self.params) and not force:
raise pydle.protocol.ProtocolViolation('Only the final parameter of an IRC message can be trailing and thus contain spaces, or start with a colon.', message=param)
message += ' ' + protocol.TRAILING_PREFIX + param
else:
message += ' ' + param
if self.source:
message = ':' + self.source + ' ' + message
if any(ch in message for ch in protocol.FORBIDDEN_CHARACTERS) and not force:
raise pydle.protocol.ProtocolViolation('The constructed message contains forbidden characters ({chs}).'.format(chs=', '.join(protocol.FORBIDDEN_CHARACTERS)), message=message)
message += protocol.LINE_SEPARATOR
if len(message) > protocol.MESSAGE_LENGTH_LIMIT and not force:
raise pydle.protocol.ProtocolViolation('The constructed message is too long. ({len} > {maxlen})'.format(len=len(message), maxlen=protocol.MESSAGE_LENGTH_LIMIT), message=message)
return message |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 244; 1, 262; 1, 267; 1, 275; 1, 276; 1, 280; 1, 281; 1, 285; 1, 286; 1, 314; 1, 318; 1, 328; 1, 331; 1, 337; 1, 341; 1, 342; 2, function_definition; 2, 3; 2, 4; 2, 6; 2, 132; 3, function_name:split; 4, parameters; 4, 5; 5, identifier:url; 6, ERROR; 6, 7; 6, 19; 6, 28; 6, 37; 6, 51; 6, 97; 6, 105; 6, 114; 6, 123; 6, 124; 6, 127; 6, 129; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:scheme; 10, assignment; 10, 11; 10, 12; 11, identifier:netloc; 12, assignment; 12, 13; 12, 14; 13, identifier:path; 14, assignment; 14, 15; 14, 16; 15, identifier:query; 16, assignment; 16, 17; 16, 18; 17, identifier:fragment; 18, string:''; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:ip6_start; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:url; 25, identifier:find; 26, argument_list; 26, 27; 27, string:'['; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:scheme_end; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:url; 34, identifier:find; 35, argument_list; 35, 36; 36, string:':'; 37, if_statement; 37, 38; 37, 45; 38, boolean_operator:and; 38, 39; 38, 42; 39, comparison_operator:>; 39, 40; 39, 41; 40, identifier:ip6_start; 41, integer:0; 42, comparison_operator:<; 42, 43; 42, 44; 43, identifier:ip6_start; 44, identifier:scheme_end; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:scheme_end; 49, unary_operator:-; 49, 50; 50, integer:1; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:>; 52, 53; 52, 54; 53, identifier:scheme_end; 54, integer:0; 55, block; 55, 56; 56, for_statement; 56, 57; 56, 58; 56, 63; 56, 70; 57, identifier:c; 58, subscript; 58, 59; 58, 60; 59, identifier:url; 60, slice; 60, 61; 60, 62; 61, colon; 62, identifier:scheme_end; 63, block; 63, 64; 64, if_statement; 64, 65; 64, 68; 65, comparison_operator:not; 65, 66; 65, 67; 66, identifier:c; 67, identifier:SCHEME_CHARS; 68, block; 68, 69; 69, break_statement; 70, else_clause; 70, 71; 71, block; 71, 72; 71, 84; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:scheme; 75, call; 75, 76; 75, 83; 76, attribute; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 79; 78, identifier:url; 79, slice; 79, 80; 79, 81; 80, colon; 81, identifier:scheme_end; 82, identifier:lower; 83, argument_list; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:rest; 87, call; 87, 88; 87, 95; 88, attribute; 88, 89; 88, 94; 89, subscript; 89, 90; 89, 91; 90, identifier:url; 91, slice; 91, 92; 91, 93; 92, identifier:scheme_end; 93, colon; 94, identifier:lstrip; 95, argument_list; 95, 96; 96, string:':/'; 97, if_statement; 97, 98; 97, 100; 98, not_operator; 98, 99; 99, identifier:scheme; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:rest; 104, identifier:url; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:l_path; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:rest; 111, identifier:find; 112, argument_list; 112, 113; 113, string:'/'; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:l_query; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:rest; 120, identifier:find; 121, argument_list; 121, 122; 122, string:'?'; 123, identifier:l_frag; 124, attribute; 124, 125; 124, 126; 125, identifier:rest; 126, identifier:find; 127, ERROR; 127, 128; 128, identifier:if; 129, comparison_operator:>; 129, 130; 129, 131; 130, identifier:l_path; 131, integer:0; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 141; 133, 163; 133, 204; 133, 226; 134, boolean_operator:and; 134, 135; 134, 138; 135, comparison_operator:>; 135, 136; 135, 137; 136, identifier:l_query; 137, integer:0; 138, comparison_operator:>; 138, 139; 138, 140; 139, identifier:l_frag; 140, integer:0; 141, block; 141, 142; 141, 150; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:netloc; 145, subscript; 145, 146; 145, 147; 146, identifier:rest; 147, slice; 147, 148; 147, 149; 148, colon; 149, identifier:l_path; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:path; 153, subscript; 153, 154; 153, 155; 154, identifier:rest; 155, slice; 155, 156; 155, 157; 155, 158; 156, identifier:l_path; 157, colon; 158, call; 158, 159; 158, 160; 159, identifier:min; 160, argument_list; 160, 161; 160, 162; 161, identifier:l_query; 162, identifier:l_frag; 163, elif_clause; 163, 164; 163, 167; 164, comparison_operator:>; 164, 165; 164, 166; 165, identifier:l_query; 166, integer:0; 167, block; 167, 168; 168, if_statement; 168, 169; 168, 172; 168, 190; 169, comparison_operator:>; 169, 170; 169, 171; 170, identifier:l_query; 171, identifier:l_path; 172, block; 172, 173; 172, 181; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:netloc; 176, subscript; 176, 177; 176, 178; 177, identifier:rest; 178, slice; 178, 179; 178, 180; 179, colon; 180, identifier:l_path; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:path; 184, subscript; 184, 185; 184, 186; 185, identifier:rest; 186, slice; 186, 187; 186, 188; 186, 189; 187, identifier:l_path; 188, colon; 189, identifier:l_query; 190, else_clause; 190, 191; 191, block; 191, 192; 191, 200; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:netloc; 195, subscript; 195, 196; 195, 197; 196, identifier:rest; 197, slice; 197, 198; 197, 199; 198, colon; 199, identifier:l_query; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:path; 203, string:''; 204, elif_clause; 204, 205; 204, 208; 205, comparison_operator:>; 205, 206; 205, 207; 206, identifier:l_frag; 207, integer:0; 208, block; 208, 209; 208, 217; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:netloc; 212, subscript; 212, 213; 212, 214; 213, identifier:rest; 214, slice; 214, 215; 214, 216; 215, colon; 216, identifier:l_path; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:path; 220, subscript; 220, 221; 220, 222; 221, identifier:rest; 222, slice; 222, 223; 222, 224; 222, 225; 223, identifier:l_path; 224, colon; 225, identifier:l_frag; 226, else_clause; 226, 227; 227, block; 227, 228; 227, 236; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:netloc; 231, subscript; 231, 232; 231, 233; 232, identifier:rest; 233, slice; 233, 234; 233, 235; 234, colon; 235, identifier:l_path; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:path; 239, subscript; 239, 240; 239, 241; 240, identifier:rest; 241, slice; 241, 242; 241, 243; 242, identifier:l_path; 243, colon; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 245, 249; 245, 257; 246, identifier:else; 247, ERROR; 247, 248; 248, identifier:if; 249, type; 249, 250; 250, constrained_type; 250, 251; 250, 255; 251, type; 251, 252; 252, comparison_operator:>; 252, 253; 252, 254; 253, identifier:l_query; 254, integer:0; 255, type; 255, 256; 256, identifier:netloc; 257, subscript; 257, 258; 257, 259; 258, identifier:rest; 259, slice; 259, 260; 259, 261; 260, colon; 261, identifier:l_query; 262, ERROR; 262, 263; 262, 264; 263, identifier:elif; 264, comparison_operator:>; 264, 265; 264, 266; 265, identifier:l_frag; 266, integer:0; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:netloc; 270, subscript; 270, 271; 270, 272; 271, identifier:rest; 272, slice; 272, 273; 272, 274; 273, colon; 274, identifier:l_frag; 275, ERROR; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:netloc; 279, identifier:rest; 280, ERROR; 281, expression_statement; 281, 282; 282, comparison_operator:>; 282, 283; 282, 284; 283, identifier:l_query; 284, integer:0; 285, ERROR; 286, if_statement; 286, 287; 286, 290; 286, 302; 287, comparison_operator:>; 287, 288; 287, 289; 288, identifier:l_frag; 289, integer:0; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:query; 294, subscript; 294, 295; 294, 296; 295, identifier:rest; 296, slice; 296, 297; 296, 300; 296, 301; 297, binary_operator:+; 297, 298; 297, 299; 298, identifier:l_query; 299, integer:1; 300, colon; 301, identifier:l_frag; 302, else_clause; 302, 303; 303, block; 303, 304; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:query; 307, subscript; 307, 308; 307, 309; 308, identifier:rest; 309, slice; 309, 310; 309, 313; 310, binary_operator:+; 310, 311; 310, 312; 311, identifier:l_query; 312, integer:1; 313, colon; 314, ERROR; 314, 315; 315, comparison_operator:>; 315, 316; 315, 317; 316, identifier:l_frag; 317, integer:0; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:fragment; 321, subscript; 321, 322; 321, 323; 322, identifier:rest; 323, slice; 323, 324; 323, 327; 324, binary_operator:+; 324, 325; 324, 326; 325, identifier:l_frag; 326, integer:1; 327, colon; 328, ERROR; 328, 329; 329, not_operator; 329, 330; 330, identifier:scheme; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:path; 334, binary_operator:+; 334, 335; 334, 336; 335, identifier:netloc; 336, identifier:path; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:netloc; 340, string:''; 341, ERROR; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 345; 344, identifier:SplitResult; 345, argument_list; 345, 346; 345, 347; 345, 348; 345, 349; 345, 350; 346, identifier:scheme; 347, identifier:netloc; 348, identifier:path; 349, identifier:query; 350, identifier:fragment | def split(url):
scheme = netloc = path = query = fragment = ''
ip6_start = url.find('[')
scheme_end = url.find(':')
if ip6_start > 0 and ip6_start < scheme_end:
scheme_end = -1
if scheme_end > 0:
for c in url[:scheme_end]:
if c not in SCHEME_CHARS:
break
else:
scheme = url[:scheme_end].lower()
rest = url[scheme_end:].lstrip(':/')
if not scheme:
rest = url
l_path = rest.find('/')
l_query = rest.find('?')
l_frag = rest.find('
if l_path > 0:
if l_query > 0 and l_frag > 0:
netloc = rest[:l_path]
path = rest[l_path:min(l_query, l_frag)]
elif l_query > 0:
if l_query > l_path:
netloc = rest[:l_path]
path = rest[l_path:l_query]
else:
netloc = rest[:l_query]
path = ''
elif l_frag > 0:
netloc = rest[:l_path]
path = rest[l_path:l_frag]
else:
netloc = rest[:l_path]
path = rest[l_path:]
else:
if l_query > 0:
netloc = rest[:l_query]
elif l_frag > 0:
netloc = rest[:l_frag]
else:
netloc = rest
if l_query > 0:
if l_frag > 0:
query = rest[l_query+1:l_frag]
else:
query = rest[l_query+1:]
if l_frag > 0:
fragment = rest[l_frag+1:]
if not scheme:
path = netloc + path
netloc = ''
return SplitResult(scheme, netloc, path, query, fragment) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:issue_cmd; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:cmd; 6, identifier:value; 7, default_parameter; 7, 8; 7, 9; 8, identifier:retry; 9, integer:3; 10, block; 10, 11; 11, with_statement; 11, 12; 11, 17; 12, with_clause; 12, 13; 13, with_item; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_cmd_lock; 17, block; 17, 18; 17, 33; 17, 60; 17, 69; 17, 89; 17, 115; 17, 155; 17, 338; 18, if_statement; 18, 19; 18, 23; 19, not_operator; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:connected; 23, block; 23, 24; 23, 32; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:_LOGGER; 28, identifier:debug; 29, argument_list; 29, 30; 29, 31; 30, string:"Serial transport closed, not sending command %s"; 31, identifier:cmd; 32, return_statement; 33, while_statement; 33, 34; 33, 42; 34, not_operator; 34, 35; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_cmdq; 40, identifier:empty; 41, argument_list; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:_LOGGER; 47, identifier:debug; 48, argument_list; 48, 49; 48, 52; 49, concatenated_string; 49, 50; 49, 51; 50, string:"Clearing leftover message from command queue:"; 51, string:" %s"; 52, await; 52, 53; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:_cmdq; 58, identifier:get; 59, argument_list; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:_LOGGER; 64, identifier:debug; 65, argument_list; 65, 66; 65, 67; 65, 68; 66, string:"Sending command: %s with value %s"; 67, identifier:cmd; 68, identifier:value; 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:self; 74, identifier:transport; 75, identifier:write; 76, argument_list; 76, 77; 77, call; 77, 78; 77, 87; 78, attribute; 78, 79; 78, 86; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, string:'{}={}\r\n'; 82, identifier:format; 83, argument_list; 83, 84; 83, 85; 84, identifier:cmd; 85, identifier:value; 86, identifier:encode; 87, argument_list; 87, 88; 88, string:'ascii'; 89, if_statement; 89, 90; 89, 93; 89, 104; 90, comparison_operator:==; 90, 91; 90, 92; 91, identifier:cmd; 92, identifier:OTGW_CMD_REPORT; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:expect; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, string:r'^{}:\s*([A-Z]{{2}}|{}=[^$]+)$'; 100, identifier:format; 101, argument_list; 101, 102; 101, 103; 102, identifier:cmd; 103, identifier:value; 104, else_clause; 104, 105; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:expect; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, string:r'^{}:\s*([^$]+)$'; 112, identifier:format; 113, argument_list; 113, 114; 114, identifier:cmd; 115, function_definition; 115, 116; 115, 117; 115, 119; 116, function_name:send_again; 117, parameters; 117, 118; 118, identifier:err; 119, block; 119, 120; 119, 122; 119, 131; 119, 135; 120, nonlocal_statement; 120, 121; 121, identifier:retry; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:_LOGGER; 126, identifier:warning; 127, argument_list; 127, 128; 127, 129; 127, 130; 128, string:"Command %s failed with %s, retrying..."; 129, identifier:cmd; 130, identifier:err; 131, expression_statement; 131, 132; 132, augmented_assignment:-=; 132, 133; 132, 134; 133, identifier:retry; 134, integer:1; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 142; 137, attribute; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:transport; 141, identifier:write; 142, argument_list; 142, 143; 143, call; 143, 144; 143, 153; 144, attribute; 144, 145; 144, 152; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, string:'{}={}\r\n'; 148, identifier:format; 149, argument_list; 149, 150; 149, 151; 150, identifier:cmd; 151, identifier:value; 152, identifier:encode; 153, argument_list; 153, 154; 154, string:'ascii'; 155, function_definition; 155, 156; 155, 157; 155, 159; 156, function_name:process; 157, parameters; 157, 158; 158, identifier:msg; 159, block; 159, 160; 159, 169; 159, 190; 159, 222; 159, 232; 159, 303; 159, 324; 159, 332; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:_LOGGER; 164, identifier:debug; 165, argument_list; 165, 166; 165, 167; 165, 168; 166, string:"Got possible response for command %s: %s"; 167, identifier:cmd; 168, identifier:msg; 169, if_statement; 169, 170; 169, 173; 170, comparison_operator:in; 170, 171; 170, 172; 171, identifier:msg; 172, identifier:OTGW_ERRS; 173, block; 173, 174; 173, 183; 173, 189; 174, if_statement; 174, 175; 174, 178; 175, comparison_operator:==; 175, 176; 175, 177; 176, identifier:retry; 177, integer:0; 178, block; 178, 179; 179, raise_statement; 179, 180; 180, subscript; 180, 181; 180, 182; 181, identifier:OTGW_ERRS; 182, identifier:msg; 183, expression_statement; 183, 184; 184, await; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:send_again; 187, argument_list; 187, 188; 188, identifier:msg; 189, return_statement; 190, if_statement; 190, 191; 190, 198; 191, boolean_operator:and; 191, 192; 191, 195; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:cmd; 194, identifier:OTGW_CMD_MODE; 195, comparison_operator:==; 195, 196; 195, 197; 196, identifier:value; 197, string:'R'; 198, block; 198, 199; 198, 220; 199, while_statement; 199, 200; 199, 208; 200, not_operator; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:re; 204, identifier:match; 205, argument_list; 205, 206; 205, 207; 206, string:r'OpenTherm Gateway \d+\.\d+\.\d+'; 207, identifier:msg; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:msg; 212, await; 212, 213; 213, call; 213, 214; 213, 219; 214, attribute; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:self; 217, identifier:_cmdq; 218, identifier:get; 219, argument_list; 220, return_statement; 220, 221; 221, True; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:match; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:re; 228, identifier:match; 229, argument_list; 229, 230; 229, 231; 230, identifier:expect; 231, identifier:msg; 232, if_statement; 232, 233; 232, 234; 233, identifier:match; 234, block; 234, 235; 234, 266; 234, 275; 234, 301; 235, if_statement; 235, 236; 235, 244; 236, comparison_operator:in; 236, 237; 236, 243; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:match; 240, identifier:group; 241, argument_list; 241, 242; 242, integer:1; 243, identifier:OTGW_ERRS; 244, block; 244, 245; 244, 259; 244, 265; 245, if_statement; 245, 246; 245, 249; 246, comparison_operator:==; 246, 247; 246, 248; 247, identifier:retry; 248, integer:0; 249, block; 249, 250; 250, raise_statement; 250, 251; 251, subscript; 251, 252; 251, 253; 252, identifier:OTGW_ERRS; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:match; 256, identifier:group; 257, argument_list; 257, 258; 258, integer:1; 259, expression_statement; 259, 260; 260, await; 260, 261; 261, call; 261, 262; 261, 263; 262, identifier:send_again; 263, argument_list; 263, 264; 264, identifier:msg; 265, return_statement; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:ret; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:match; 272, identifier:group; 273, argument_list; 273, 274; 274, integer:1; 275, if_statement; 275, 276; 275, 283; 276, boolean_operator:and; 276, 277; 276, 280; 277, comparison_operator:==; 277, 278; 277, 279; 278, identifier:cmd; 279, identifier:OTGW_CMD_SUMMARY; 280, comparison_operator:==; 280, 281; 280, 282; 281, identifier:ret; 282, string:'1'; 283, block; 283, 284; 283, 295; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:part2; 287, await; 287, 288; 288, call; 288, 289; 288, 294; 289, attribute; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:self; 292, identifier:_cmdq; 293, identifier:get; 294, argument_list; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:ret; 298, list:[ret, part2]; 298, 299; 298, 300; 299, identifier:ret; 300, identifier:part2; 301, return_statement; 301, 302; 302, identifier:ret; 303, if_statement; 303, 304; 303, 311; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:re; 307, identifier:match; 308, argument_list; 308, 309; 308, 310; 309, string:r'Error 0[1-4]'; 310, identifier:msg; 311, block; 311, 312; 311, 323; 312, expression_statement; 312, 313; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:_LOGGER; 316, identifier:warning; 317, argument_list; 317, 318; 317, 322; 318, concatenated_string; 318, 319; 318, 320; 318, 321; 319, string:"Received %s. If this happens during a "; 320, string:"reset of the gateway it can be safely "; 321, string:"ignored."; 322, identifier:msg; 323, return_statement; 324, expression_statement; 324, 325; 325, call; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:_LOGGER; 328, identifier:warning; 329, argument_list; 329, 330; 329, 331; 330, string:"Unknown message in command queue: %s"; 331, identifier:msg; 332, expression_statement; 332, 333; 333, await; 333, 334; 334, call; 334, 335; 334, 336; 335, identifier:send_again; 336, argument_list; 336, 337; 337, identifier:msg; 338, while_statement; 338, 339; 338, 340; 339, True; 340, block; 340, 341; 340, 352; 340, 360; 341, expression_statement; 341, 342; 342, assignment; 342, 343; 342, 344; 343, identifier:msg; 344, await; 344, 345; 345, call; 345, 346; 345, 351; 346, attribute; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:self; 349, identifier:_cmdq; 350, identifier:get; 351, argument_list; 352, expression_statement; 352, 353; 353, assignment; 353, 354; 353, 355; 354, identifier:ret; 355, await; 355, 356; 356, call; 356, 357; 356, 358; 357, identifier:process; 358, argument_list; 358, 359; 359, identifier:msg; 360, if_statement; 360, 361; 360, 364; 361, comparison_operator:is; 361, 362; 361, 363; 362, identifier:ret; 363, None; 364, block; 364, 365; 365, return_statement; 365, 366; 366, identifier:ret | async def issue_cmd(self, cmd, value, retry=3):
async with self._cmd_lock:
if not self.connected:
_LOGGER.debug(
"Serial transport closed, not sending command %s", cmd)
return
while not self._cmdq.empty():
_LOGGER.debug("Clearing leftover message from command queue:"
" %s", await self._cmdq.get())
_LOGGER.debug("Sending command: %s with value %s", cmd, value)
self.transport.write(
'{}={}\r\n'.format(cmd, value).encode('ascii'))
if cmd == OTGW_CMD_REPORT:
expect = r'^{}:\s*([A-Z]{{2}}|{}=[^$]+)$'.format(cmd, value)
else:
expect = r'^{}:\s*([^$]+)$'.format(cmd)
async def send_again(err):
nonlocal retry
_LOGGER.warning("Command %s failed with %s, retrying...", cmd,
err)
retry -= 1
self.transport.write(
'{}={}\r\n'.format(cmd, value).encode('ascii'))
async def process(msg):
_LOGGER.debug("Got possible response for command %s: %s", cmd,
msg)
if msg in OTGW_ERRS:
if retry == 0:
raise OTGW_ERRS[msg]
await send_again(msg)
return
if cmd == OTGW_CMD_MODE and value == 'R':
while not re.match(
r'OpenTherm Gateway \d+\.\d+\.\d+', msg):
msg = await self._cmdq.get()
return True
match = re.match(expect, msg)
if match:
if match.group(1) in OTGW_ERRS:
if retry == 0:
raise OTGW_ERRS[match.group(1)]
await send_again(msg)
return
ret = match.group(1)
if cmd == OTGW_CMD_SUMMARY and ret == '1':
part2 = await self._cmdq.get()
ret = [ret, part2]
return ret
if re.match(r'Error 0[1-4]', msg):
_LOGGER.warning("Received %s. If this happens during a "
"reset of the gateway it can be safely "
"ignored.", msg)
return
_LOGGER.warning("Unknown message in command queue: %s", msg)
await send_again(msg)
while True:
msg = await self._cmdq.get()
ret = await process(msg)
if ret is not None:
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_reports; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 14; 5, 55; 5, 115; 5, 124; 5, 150; 5, 159; 5, 187; 5, 196; 5, 238; 5, 247; 5, 275; 5, 284; 5, 302; 5, 311; 5, 329; 5, 354; 5, 361; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:cmd; 9, identifier:OTGW_CMD_REPORT; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:reports; 13, dictionary; 14, for_statement; 14, 15; 14, 16; 14, 21; 15, identifier:value; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:OTGW_REPORTS; 19, identifier:keys; 20, argument_list; 21, block; 21, 22; 21, 33; 21, 45; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:ret; 25, await; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_wait_for_cmd; 30, argument_list; 30, 31; 30, 32; 31, identifier:cmd; 32, identifier:value; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:ret; 36, None; 37, block; 37, 38; 37, 44; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:reports; 42, identifier:value; 43, None; 44, continue_statement; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:reports; 49, identifier:value; 50, subscript; 50, 51; 50, 52; 51, identifier:ret; 52, slice; 52, 53; 52, 54; 53, integer:2; 54, colon; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:status; 58, dictionary; 58, 59; 58, 67; 58, 75; 58, 83; 58, 91; 58, 99; 58, 107; 59, pair; 59, 60; 59, 61; 60, identifier:OTGW_ABOUT; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:reports; 64, identifier:get; 65, argument_list; 65, 66; 66, identifier:OTGW_REPORT_ABOUT; 67, pair; 67, 68; 67, 69; 68, identifier:OTGW_BUILD; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:reports; 72, identifier:get; 73, argument_list; 73, 74; 74, identifier:OTGW_REPORT_BUILDDATE; 75, pair; 75, 76; 75, 77; 76, identifier:OTGW_CLOCKMHZ; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:reports; 80, identifier:get; 81, argument_list; 81, 82; 82, identifier:OTGW_REPORT_CLOCKMHZ; 83, pair; 83, 84; 83, 85; 84, identifier:OTGW_MODE; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:reports; 88, identifier:get; 89, argument_list; 89, 90; 90, identifier:OTGW_REPORT_GW_MODE; 91, pair; 91, 92; 91, 93; 92, identifier:OTGW_SMART_PWR; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:reports; 96, identifier:get; 97, argument_list; 97, 98; 98, identifier:OTGW_REPORT_SMART_PWR; 99, pair; 99, 100; 99, 101; 100, identifier:OTGW_THRM_DETECT; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:reports; 104, identifier:get; 105, argument_list; 105, 106; 106, identifier:OTGW_REPORT_THERMOSTAT_DETECT; 107, pair; 107, 108; 107, 109; 108, identifier:OTGW_DHW_OVRD; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:reports; 112, identifier:get; 113, argument_list; 113, 114; 114, identifier:OTGW_REPORT_DHW_SETTING; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:ovrd_mode; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:reports; 121, identifier:get; 122, argument_list; 122, 123; 123, identifier:OTGW_REPORT_SETPOINT_OVRD; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:ovrd_mode; 127, None; 128, block; 128, 129; 128, 140; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:ovrd_mode; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:str; 135, identifier:upper; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:ovrd_mode; 139, integer:0; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:status; 144, identifier:update; 145, argument_list; 145, 146; 146, dictionary; 146, 147; 147, pair; 147, 148; 147, 149; 148, identifier:OTGW_SETP_OVRD_MODE; 149, identifier:ovrd_mode; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:gpio_funcs; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:reports; 156, identifier:get; 157, argument_list; 157, 158; 158, identifier:OTGW_REPORT_GPIO_FUNCS; 159, if_statement; 159, 160; 159, 163; 160, comparison_operator:is; 160, 161; 160, 162; 161, identifier:gpio_funcs; 162, None; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:status; 168, identifier:update; 169, argument_list; 169, 170; 170, dictionary; 170, 171; 170, 179; 171, pair; 171, 172; 171, 173; 172, identifier:OTGW_GPIO_A; 173, call; 173, 174; 173, 175; 174, identifier:int; 175, argument_list; 175, 176; 176, subscript; 176, 177; 176, 178; 177, identifier:gpio_funcs; 178, integer:0; 179, pair; 179, 180; 179, 181; 180, identifier:OTGW_GPIO_B; 181, call; 181, 182; 181, 183; 182, identifier:int; 183, argument_list; 183, 184; 184, subscript; 184, 185; 184, 186; 185, identifier:gpio_funcs; 186, integer:1; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:led_funcs; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:reports; 193, identifier:get; 194, argument_list; 194, 195; 195, identifier:OTGW_REPORT_LED_FUNCS; 196, if_statement; 196, 197; 196, 200; 197, comparison_operator:is; 197, 198; 197, 199; 198, identifier:led_funcs; 199, None; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:status; 205, identifier:update; 206, argument_list; 206, 207; 207, dictionary; 207, 208; 207, 213; 207, 218; 207, 223; 207, 228; 207, 233; 208, pair; 208, 209; 208, 210; 209, identifier:OTGW_LED_A; 210, subscript; 210, 211; 210, 212; 211, identifier:led_funcs; 212, integer:0; 213, pair; 213, 214; 213, 215; 214, identifier:OTGW_LED_B; 215, subscript; 215, 216; 215, 217; 216, identifier:led_funcs; 217, integer:1; 218, pair; 218, 219; 218, 220; 219, identifier:OTGW_LED_C; 220, subscript; 220, 221; 220, 222; 221, identifier:led_funcs; 222, integer:2; 223, pair; 223, 224; 223, 225; 224, identifier:OTGW_LED_D; 225, subscript; 225, 226; 225, 227; 226, identifier:led_funcs; 227, integer:3; 228, pair; 228, 229; 228, 230; 229, identifier:OTGW_LED_E; 230, subscript; 230, 231; 230, 232; 231, identifier:led_funcs; 232, integer:4; 233, pair; 233, 234; 233, 235; 234, identifier:OTGW_LED_F; 235, subscript; 235, 236; 235, 237; 236, identifier:led_funcs; 237, integer:5; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:tweaks; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:reports; 244, identifier:get; 245, argument_list; 245, 246; 246, identifier:OTGW_REPORT_TWEAKS; 247, if_statement; 247, 248; 247, 251; 248, comparison_operator:is; 248, 249; 248, 250; 249, identifier:tweaks; 250, None; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:status; 256, identifier:update; 257, argument_list; 257, 258; 258, dictionary; 258, 259; 258, 267; 259, pair; 259, 260; 259, 261; 260, identifier:OTGW_IGNORE_TRANSITIONS; 261, call; 261, 262; 261, 263; 262, identifier:int; 263, argument_list; 263, 264; 264, subscript; 264, 265; 264, 266; 265, identifier:tweaks; 266, integer:0; 267, pair; 267, 268; 267, 269; 268, identifier:OTGW_OVRD_HB; 269, call; 269, 270; 269, 271; 270, identifier:int; 271, argument_list; 271, 272; 272, subscript; 272, 273; 272, 274; 273, identifier:tweaks; 274, integer:1; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:sb_temp; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:reports; 281, identifier:get; 282, argument_list; 282, 283; 283, identifier:OTGW_REPORT_SETBACK_TEMP; 284, if_statement; 284, 285; 284, 288; 285, comparison_operator:is; 285, 286; 285, 287; 286, identifier:sb_temp; 287, None; 288, block; 288, 289; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:status; 293, identifier:update; 294, argument_list; 294, 295; 295, dictionary; 295, 296; 296, pair; 296, 297; 296, 298; 297, identifier:OTGW_SB_TEMP; 298, call; 298, 299; 298, 300; 299, identifier:float; 300, argument_list; 300, 301; 301, identifier:sb_temp; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:vref; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:reports; 308, identifier:get; 309, argument_list; 309, 310; 310, identifier:OTGW_REPORT_VREF; 311, if_statement; 311, 312; 311, 315; 312, comparison_operator:is; 312, 313; 312, 314; 313, identifier:vref; 314, None; 315, block; 315, 316; 316, expression_statement; 316, 317; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:status; 320, identifier:update; 321, argument_list; 321, 322; 322, dictionary; 322, 323; 323, pair; 323, 324; 323, 325; 324, identifier:OTGW_VREF; 325, call; 325, 326; 325, 327; 326, identifier:int; 327, argument_list; 327, 328; 328, identifier:vref; 329, if_statement; 329, 330; 329, 338; 330, parenthesized_expression; 330, 331; 331, boolean_operator:and; 331, 332; 331, 335; 332, comparison_operator:is; 332, 333; 332, 334; 333, identifier:ovrd_mode; 334, None; 335, comparison_operator:!=; 335, 336; 335, 337; 336, identifier:ovrd_mode; 337, identifier:OTGW_SETP_OVRD_DISABLED; 338, block; 338, 339; 339, expression_statement; 339, 340; 340, assignment; 340, 341; 340, 344; 341, subscript; 341, 342; 341, 343; 342, identifier:status; 343, identifier:DATA_ROOM_SETPOINT_OVRD; 344, call; 344, 345; 344, 346; 345, identifier:float; 346, argument_list; 346, 347; 347, subscript; 347, 348; 347, 351; 348, subscript; 348, 349; 348, 350; 349, identifier:reports; 350, identifier:OTGW_REPORT_SETPOINT_OVRD; 351, slice; 351, 352; 351, 353; 352, integer:1; 353, colon; 354, expression_statement; 354, 355; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:self; 358, identifier:_update_status; 359, argument_list; 359, 360; 360, identifier:status; 361, return_statement; 361, 362; 362, call; 362, 363; 362, 364; 363, identifier:dict; 364, argument_list; 364, 365; 365, attribute; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:self; 368, identifier:_protocol; 369, identifier:status | async def get_reports(self):
cmd = OTGW_CMD_REPORT
reports = {}
for value in OTGW_REPORTS.keys():
ret = await self._wait_for_cmd(cmd, value)
if ret is None:
reports[value] = None
continue
reports[value] = ret[2:]
status = {
OTGW_ABOUT: reports.get(OTGW_REPORT_ABOUT),
OTGW_BUILD: reports.get(OTGW_REPORT_BUILDDATE),
OTGW_CLOCKMHZ: reports.get(OTGW_REPORT_CLOCKMHZ),
OTGW_MODE: reports.get(OTGW_REPORT_GW_MODE),
OTGW_SMART_PWR: reports.get(OTGW_REPORT_SMART_PWR),
OTGW_THRM_DETECT: reports.get(OTGW_REPORT_THERMOSTAT_DETECT),
OTGW_DHW_OVRD: reports.get(OTGW_REPORT_DHW_SETTING),
}
ovrd_mode = reports.get(OTGW_REPORT_SETPOINT_OVRD)
if ovrd_mode is not None:
ovrd_mode = str.upper(ovrd_mode[0])
status.update({OTGW_SETP_OVRD_MODE: ovrd_mode})
gpio_funcs = reports.get(OTGW_REPORT_GPIO_FUNCS)
if gpio_funcs is not None:
status.update({
OTGW_GPIO_A: int(gpio_funcs[0]),
OTGW_GPIO_B: int(gpio_funcs[1]),
})
led_funcs = reports.get(OTGW_REPORT_LED_FUNCS)
if led_funcs is not None:
status.update({
OTGW_LED_A: led_funcs[0],
OTGW_LED_B: led_funcs[1],
OTGW_LED_C: led_funcs[2],
OTGW_LED_D: led_funcs[3],
OTGW_LED_E: led_funcs[4],
OTGW_LED_F: led_funcs[5],
})
tweaks = reports.get(OTGW_REPORT_TWEAKS)
if tweaks is not None:
status.update({
OTGW_IGNORE_TRANSITIONS: int(tweaks[0]),
OTGW_OVRD_HB: int(tweaks[1]),
})
sb_temp = reports.get(OTGW_REPORT_SETBACK_TEMP)
if sb_temp is not None:
status.update({OTGW_SB_TEMP: float(sb_temp)})
vref = reports.get(OTGW_REPORT_VREF)
if vref is not None:
status.update({OTGW_VREF: int(vref)})
if (ovrd_mode is not None and ovrd_mode != OTGW_SETP_OVRD_DISABLED):
status[DATA_ROOM_SETPOINT_OVRD] = float(
reports[OTGW_REPORT_SETPOINT_OVRD][1:])
self._update_status(status)
return dict(self._protocol.status) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:build; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:client; 6, default_parameter; 6, 7; 6, 8; 7, identifier:nobuild; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:usecache; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:pull; 14, False; 15, block; 15, 16; 15, 33; 15, 41; 15, 57; 15, 77; 15, 93; 15, 227; 15, 233; 16, if_statement; 16, 17; 16, 19; 17, not_operator; 17, 18; 18, identifier:nobuild; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:update_source_images; 25, argument_list; 25, 26; 25, 27; 25, 30; 26, identifier:client; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:usecache; 29, identifier:usecache; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:pull; 32, identifier:pull; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:width; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:utils; 39, identifier:get_console_width; 40, argument_list; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:cprint; 44, argument_list; 44, 45; 44, 50; 44, 53; 45, binary_operator:+; 45, 46; 45, 47; 46, string:'\n'; 47, binary_operator:*; 47, 48; 47, 49; 48, string:'='; 49, identifier:width; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:color; 52, string:'white'; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:attrs; 55, list:['bold']; 55, 56; 56, string:'bold'; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:line; 60, binary_operator:%; 60, 61; 60, 62; 61, string:'STARTING BUILD for "%s" (image definition "%s" from %s)\n'; 62, tuple; 62, 63; 62, 66; 62, 69; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:targetname; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:imagename; 69, attribute; 69, 70; 69, 76; 70, subscript; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:steps; 74, unary_operator:-; 74, 75; 75, integer:1; 76, identifier:sourcefile; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:cprint; 80, argument_list; 80, 81; 80, 86; 80, 89; 81, call; 81, 82; 81, 83; 82, identifier:_centered; 83, argument_list; 83, 84; 83, 85; 84, identifier:line; 85, identifier:width; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:color; 88, string:'blue'; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:attrs; 91, list:['bold']; 91, 92; 92, string:'bold'; 93, for_statement; 93, 94; 93, 97; 93, 103; 94, pattern_list; 94, 95; 94, 96; 95, identifier:istep; 96, identifier:step; 97, call; 97, 98; 97, 99; 98, identifier:enumerate; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:steps; 103, block; 103, 104; 103, 153; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:print; 107, argument_list; 107, 108; 107, 113; 107, 133; 107, 140; 108, call; 108, 109; 108, 110; 109, identifier:colored; 110, argument_list; 110, 111; 110, 112; 111, string:'* Step'; 112, string:'blue'; 113, call; 113, 114; 113, 115; 114, identifier:colored; 115, argument_list; 115, 116; 115, 128; 115, 129; 116, binary_operator:%; 116, 117; 116, 118; 117, string:'%d/%d'; 118, tuple; 118, 119; 118, 122; 119, binary_operator:+; 119, 120; 119, 121; 120, identifier:istep; 121, integer:1; 122, call; 122, 123; 122, 124; 123, identifier:len; 124, argument_list; 124, 125; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:steps; 128, string:'blue'; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:attrs; 131, list:['bold']; 131, 132; 132, string:'bold'; 133, call; 133, 134; 133, 135; 134, identifier:colored; 135, argument_list; 135, 136; 135, 137; 136, string:'for image'; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:color; 139, string:'blue'; 140, call; 140, 141; 140, 142; 141, identifier:colored; 142, argument_list; 142, 143; 142, 146; 142, 149; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:imagename; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:color; 148, string:'blue'; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:attrs; 151, list:['bold']; 151, 152; 152, string:'bold'; 153, if_statement; 153, 154; 153, 156; 154, not_operator; 154, 155; 155, identifier:nobuild; 156, block; 156, 157; 156, 182; 156, 192; 156, 215; 157, if_statement; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:step; 160, identifier:bust_cache; 161, block; 161, 162; 161, 171; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:stackkey; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:_get_stack_key; 169, argument_list; 169, 170; 170, identifier:istep; 171, if_statement; 171, 172; 171, 175; 172, comparison_operator:in; 172, 173; 172, 174; 173, identifier:stackkey; 174, identifier:_rebuilt; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:step; 180, identifier:bust_cache; 181, False; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:step; 186, identifier:build; 187, argument_list; 187, 188; 187, 189; 188, identifier:client; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:usecache; 191, identifier:usecache; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:print; 195, argument_list; 195, 196; 195, 201; 195, 212; 196, call; 196, 197; 196, 198; 197, identifier:colored; 198, argument_list; 198, 199; 198, 200; 199, string:"* Created intermediate image"; 200, string:'green'; 201, call; 201, 202; 201, 203; 202, identifier:colored; 203, argument_list; 203, 204; 203, 207; 203, 208; 204, attribute; 204, 205; 204, 206; 205, identifier:step; 206, identifier:buildname; 207, string:'green'; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:attrs; 210, list:['bold']; 210, 211; 211, string:'bold'; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:end; 214, string:'\n\n'; 215, if_statement; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:step; 218, identifier:bust_cache; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:_rebuilt; 224, identifier:add; 225, argument_list; 225, 226; 226, identifier:stackkey; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:finalimage; 230, attribute; 230, 231; 230, 232; 231, identifier:step; 232, identifier:buildname; 233, if_statement; 233, 234; 233, 236; 234, not_operator; 234, 235; 235, identifier:nobuild; 236, block; 236, 237; 236, 245; 236, 265; 236, 281; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:finalizenames; 242, argument_list; 242, 243; 242, 244; 243, identifier:client; 244, identifier:finalimage; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:line; 248, binary_operator:%; 248, 249; 248, 250; 249, string:'FINISHED BUILDING "%s" (image definition "%s" from %s)'; 250, tuple; 250, 251; 250, 254; 250, 257; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:targetname; 254, attribute; 254, 255; 254, 256; 255, identifier:self; 256, identifier:imagename; 257, attribute; 257, 258; 257, 264; 258, subscript; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:steps; 262, unary_operator:-; 262, 263; 263, integer:1; 264, identifier:sourcefile; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 268; 267, identifier:cprint; 268, argument_list; 268, 269; 268, 274; 268, 277; 269, call; 269, 270; 269, 271; 270, identifier:_centered; 271, argument_list; 271, 272; 271, 273; 272, identifier:line; 273, identifier:width; 274, keyword_argument; 274, 275; 274, 276; 275, identifier:color; 276, string:'green'; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:attrs; 279, list:['bold']; 279, 280; 280, string:'bold'; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:cprint; 284, argument_list; 284, 285; 284, 288; 284, 291; 284, 295; 285, binary_operator:*; 285, 286; 285, 287; 286, string:'='; 287, identifier:width; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:color; 290, string:'white'; 291, keyword_argument; 291, 292; 291, 293; 292, identifier:attrs; 293, list:['bold']; 293, 294; 294, string:'bold'; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:end; 297, string:'\n\n' | def build(self, client,
nobuild=False,
usecache=True,
pull=False):
if not nobuild:
self.update_source_images(client,
usecache=usecache,
pull=pull)
width = utils.get_console_width()
cprint('\n' + '='*width,
color='white', attrs=['bold'])
line = 'STARTING BUILD for "%s" (image definition "%s" from %s)\n' % (
self.targetname, self.imagename, self.steps[-1].sourcefile)
cprint(_centered(line, width), color='blue', attrs=['bold'])
for istep, step in enumerate(self.steps):
print(colored('* Step','blue'),
colored('%d/%d' % (istep+1, len(self.steps)), 'blue', attrs=['bold']),
colored('for image', color='blue'),
colored(self.imagename, color='blue', attrs=['bold']))
if not nobuild:
if step.bust_cache:
stackkey = self._get_stack_key(istep)
if stackkey in _rebuilt:
step.bust_cache = False
step.build(client, usecache=usecache)
print(colored("* Created intermediate image", 'green'),
colored(step.buildname, 'green', attrs=['bold']),
end='\n\n')
if step.bust_cache:
_rebuilt.add(stackkey)
finalimage = step.buildname
if not nobuild:
self.finalizenames(client, finalimage)
line = 'FINISHED BUILDING "%s" (image definition "%s" from %s)'%(
self.targetname, self.imagename, self.steps[-1].sourcefile)
cprint(_centered(line, width),
color='green', attrs=['bold'])
cprint('=' * width, color='white', attrs=['bold'], end='\n\n') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_check_yaml_and_paths; 3, parameters; 3, 4; 3, 5; 4, identifier:ymlfilepath; 5, identifier:yamldefs; 6, block; 6, 7; 6, 18; 6, 29; 6, 47; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:relpath; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:os; 14, identifier:path; 15, identifier:relpath; 16, argument_list; 16, 17; 17, identifier:ymlfilepath; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:not; 19, 20; 19, 21; 20, string:'/'; 21, identifier:relpath; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:relpath; 26, binary_operator:%; 26, 27; 26, 28; 27, string:'./%s'; 28, identifier:relpath; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:pathroot; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:os; 36, identifier:path; 37, identifier:abspath; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:os; 43, identifier:path; 44, identifier:dirname; 45, argument_list; 45, 46; 46, identifier:ymlfilepath; 47, for_statement; 47, 48; 47, 51; 47, 55; 48, pattern_list; 48, 49; 48, 50; 49, identifier:imagename; 50, identifier:defn; 51, call; 51, 52; 51, 53; 52, identifier:iteritems; 53, argument_list; 53, 54; 54, identifier:yamldefs; 55, block; 55, 56; 55, 91; 55, 115; 55, 186; 55, 192; 55, 212; 55, 235; 55, 263; 56, if_statement; 56, 57; 56, 60; 56, 85; 57, comparison_operator:==; 57, 58; 57, 59; 58, identifier:imagename; 59, string:'_SOURCES_'; 60, block; 60, 61; 60, 84; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:yamldefs; 65, string:'_SOURCES_'; 66, list_comprehension; 66, 67; 66, 79; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:os; 71, identifier:path; 72, identifier:relpath; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:_get_abspath; 76, argument_list; 76, 77; 76, 78; 77, identifier:pathroot; 78, identifier:p; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:p; 81, subscript; 81, 82; 81, 83; 82, identifier:yamldefs; 83, string:'_SOURCES_'; 84, continue_statement; 85, elif_clause; 85, 86; 85, 89; 86, comparison_operator:in; 86, 87; 86, 88; 87, identifier:imagename; 88, identifier:SPECIAL_FIELDS; 89, block; 89, 90; 90, continue_statement; 91, for_statement; 91, 92; 91, 93; 91, 97; 92, identifier:key; 93, tuple; 93, 94; 93, 95; 93, 96; 94, string:'build_directory'; 95, string:'FROM_DOCKERFILE'; 96, string:'ignorefile'; 97, block; 97, 98; 98, if_statement; 98, 99; 98, 102; 99, comparison_operator:in; 99, 100; 99, 101; 100, identifier:key; 101, identifier:defn; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:defn; 107, identifier:key; 108, call; 108, 109; 108, 110; 109, identifier:_get_abspath; 110, argument_list; 110, 111; 110, 112; 111, identifier:pathroot; 112, subscript; 112, 113; 112, 114; 113, identifier:defn; 114, identifier:key; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:in; 116, 117; 116, 118; 117, string:'copy_from'; 118, identifier:defn; 119, block; 119, 120; 119, 146; 120, if_statement; 120, 121; 120, 129; 121, not_operator; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:isinstance; 124, argument_list; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:defn; 127, string:'copy_from'; 128, identifier:dict; 129, block; 129, 130; 130, raise_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:errors; 134, identifier:ParsingFailure; 135, argument_list; 135, 136; 136, binary_operator:%; 136, 137; 136, 143; 137, parenthesized_expression; 137, 138; 138, binary_operator:+; 138, 139; 138, 140; 139, string:'Syntax error in file "%s": \n'; 140, concatenated_string; 140, 141; 140, 142; 141, string:'The "copy_from" field in image definition "%s" is not \n'; 142, string:'a key:value list.'; 143, tuple; 143, 144; 143, 145; 144, identifier:ymlfilepath; 145, identifier:imagename; 146, for_statement; 146, 147; 146, 150; 146, 161; 147, pattern_list; 147, 148; 147, 149; 148, identifier:otherimg; 149, identifier:value; 150, call; 150, 151; 150, 160; 151, attribute; 151, 152; 151, 159; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:defn; 155, identifier:get; 156, argument_list; 156, 157; 156, 158; 157, string:'copy_from'; 158, dictionary; 159, identifier:items; 160, argument_list; 161, block; 161, 162; 162, if_statement; 162, 163; 162, 169; 163, not_operator; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:isinstance; 166, argument_list; 166, 167; 166, 168; 167, identifier:value; 168, identifier:dict; 169, block; 169, 170; 170, raise_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:errors; 174, identifier:ParsingFailure; 175, argument_list; 175, 176; 176, binary_operator:%; 176, 177; 176, 182; 177, parenthesized_expression; 177, 178; 178, concatenated_string; 178, 179; 178, 180; 178, 181; 179, string:'Syntax error in field:\n'; 180, string:' %s . copy_from . %s\nin file "%s". \n'; 181, string:'All entries must be of the form "sourcepath: destpath"'; 182, tuple; 182, 183; 182, 184; 182, 185; 183, identifier:imagename; 184, identifier:otherimg; 185, identifier:ymlfilepath; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:defn; 190, string:'_sourcefile'; 191, identifier:relpath; 192, if_statement; 192, 193; 192, 200; 193, boolean_operator:and; 193, 194; 193, 197; 194, comparison_operator:in; 194, 195; 194, 196; 195, string:'ignore'; 196, identifier:defn; 197, comparison_operator:in; 197, 198; 197, 199; 198, string:'ignorefile'; 199, identifier:defn; 200, block; 200, 201; 201, raise_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:errors; 205, identifier:MultipleIgnoreError; 206, argument_list; 206, 207; 207, binary_operator:+; 207, 208; 207, 211; 208, binary_operator:%; 208, 209; 208, 210; 209, string:'Image "%s" has both "ignore" AND "ignorefile" fields.'; 210, identifier:imagename; 211, string:' At most ONE of these should be defined'; 212, if_statement; 212, 213; 212, 225; 213, boolean_operator:and; 213, 214; 213, 217; 214, comparison_operator:in; 214, 215; 214, 216; 215, string:'secret_files'; 216, identifier:defn; 217, not_operator; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:defn; 221, identifier:get; 222, argument_list; 222, 223; 222, 224; 223, string:'squash'; 224, True; 225, block; 225, 226; 226, raise_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:errors; 230, identifier:ParsingFailure; 231, argument_list; 231, 232; 232, binary_operator:%; 232, 233; 232, 234; 233, string:"Step '%s' defines secret_files, so 'squash' cannot be set to 'false'"; 234, identifier:imagename; 235, if_statement; 235, 236; 235, 251; 236, boolean_operator:and; 236, 237; 236, 244; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:defn; 240, identifier:get; 241, argument_list; 241, 242; 241, 243; 242, string:'secret_files'; 243, None; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:defn; 247, identifier:get; 248, argument_list; 248, 249; 248, 250; 249, string:'copy_from'; 250, False; 251, block; 251, 252; 252, raise_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:errors; 256, identifier:ParsingFailure; 257, argument_list; 257, 258; 258, binary_operator:%; 258, 259; 258, 262; 259, concatenated_string; 259, 260; 259, 261; 260, string:'`secret_files` currently is not implmemented to handle `copy_from`'; 261, string:' (step %s)'; 262, identifier:imagename; 263, for_statement; 263, 264; 263, 265; 263, 266; 264, identifier:key; 265, identifier:defn; 266, block; 266, 267; 267, if_statement; 267, 268; 267, 271; 268, comparison_operator:not; 268, 269; 268, 270; 269, identifier:key; 270, identifier:RECOGNIZED_KEYS; 271, block; 271, 272; 272, raise_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:errors; 276, identifier:UnrecognizedKeyError; 277, argument_list; 277, 278; 278, binary_operator:%; 278, 279; 278, 280; 279, string:'Field "%s" in image "%s" in file "%s" not recognized'; 280, tuple; 280, 281; 280, 282; 280, 283; 281, identifier:key; 282, identifier:imagename; 283, identifier:relpath | def _check_yaml_and_paths(ymlfilepath, yamldefs):
relpath = os.path.relpath(ymlfilepath)
if '/' not in relpath:
relpath = './%s' % relpath
pathroot = os.path.abspath(os.path.dirname(ymlfilepath))
for imagename, defn in iteritems(yamldefs):
if imagename == '_SOURCES_':
yamldefs['_SOURCES_'] = [os.path.relpath(_get_abspath(pathroot, p))
for p in yamldefs['_SOURCES_']]
continue
elif imagename in SPECIAL_FIELDS:
continue
for key in ('build_directory', 'FROM_DOCKERFILE', 'ignorefile'):
if key in defn:
defn[key] = _get_abspath(pathroot, defn[key])
if 'copy_from' in defn:
if not isinstance(defn['copy_from'], dict):
raise errors.ParsingFailure((
'Syntax error in file "%s": \n' +
'The "copy_from" field in image definition "%s" is not \n'
'a key:value list.') % (ymlfilepath, imagename))
for otherimg, value in defn.get('copy_from', {}).items():
if not isinstance(value, dict):
raise errors.ParsingFailure((
'Syntax error in field:\n'
' %s . copy_from . %s\nin file "%s". \n'
'All entries must be of the form "sourcepath: destpath"')%
(imagename, otherimg, ymlfilepath))
defn['_sourcefile'] = relpath
if 'ignore' in defn and 'ignorefile' in defn:
raise errors.MultipleIgnoreError(
'Image "%s" has both "ignore" AND "ignorefile" fields.' % imagename +
' At most ONE of these should be defined')
if 'secret_files' in defn and not defn.get('squash', True):
raise errors.ParsingFailure(
"Step '%s' defines secret_files, so 'squash' cannot be set to 'false'"
% imagename)
if defn.get('secret_files', None) and defn.get('copy_from', False):
raise errors.ParsingFailure(
'`secret_files` currently is not implmemented to handle `copy_from`'
' (step %s)' % imagename)
for key in defn:
if key not in RECOGNIZED_KEYS:
raise errors.UnrecognizedKeyError(
'Field "%s" in image "%s" in file "%s" not recognized' %
(key, imagename, relpath)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:generate_build; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 4, identifier:self; 5, identifier:image; 6, identifier:targetname; 7, default_parameter; 7, 8; 7, 9; 8, identifier:rebuilds; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:cache_repo; 12, string:''; 13, default_parameter; 13, 14; 13, 15; 14, identifier:cache_tag; 15, string:''; 16, default_parameter; 16, 17; 16, 18; 17, identifier:buildargs; 18, None; 19, dictionary_splat_pattern; 19, 20; 20, identifier:kwargs; 21, block; 21, 22; 21, 31; 21, 53; 21, 67; 21, 94; 21, 98; 21, 102; 21, 108; 21, 126; 21, 313; 21, 335; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:from_image; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:get_external_base_image; 29, argument_list; 29, 30; 30, identifier:image; 31, if_statement; 31, 32; 31, 35; 31, 47; 32, boolean_operator:or; 32, 33; 32, 34; 33, identifier:cache_repo; 34, identifier:cache_tag; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:cache_from; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:utils; 42, identifier:generate_name; 43, argument_list; 43, 44; 43, 45; 43, 46; 44, identifier:image; 45, identifier:cache_repo; 46, identifier:cache_tag; 47, else_clause; 47, 48; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:cache_from; 52, None; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:from_image; 56, None; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:errors; 62, identifier:NoBaseError; 63, argument_list; 63, 64; 64, binary_operator:%; 64, 65; 64, 66; 65, string:"No base image found in %s's dependencies"; 66, identifier:image; 67, if_statement; 67, 68; 67, 73; 67, 84; 68, call; 68, 69; 68, 70; 69, identifier:isinstance; 70, argument_list; 70, 71; 70, 72; 71, identifier:from_image; 72, identifier:ExternalDockerfile; 73, block; 73, 74; 73, 78; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:build_first; 77, identifier:from_image; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:base_image; 81, attribute; 81, 82; 81, 83; 82, identifier:from_image; 83, identifier:tag; 84, else_clause; 84, 85; 85, block; 85, 86; 85, 90; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:base_image; 89, identifier:from_image; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:build_first; 93, None; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:build_steps; 97, list:[]; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:istep; 101, integer:0; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:sourceimages; 105, call; 105, 106; 105, 107; 106, identifier:set; 107, argument_list; 108, if_statement; 108, 109; 108, 112; 108, 117; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:rebuilds; 111, None; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:rebuilds; 116, list:[]; 117, else_clause; 117, 118; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:rebuilds; 122, call; 122, 123; 122, 124; 123, identifier:set; 124, argument_list; 124, 125; 125, identifier:rebuilds; 126, for_statement; 126, 127; 126, 128; 126, 134; 127, identifier:base_name; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:sort_dependencies; 132, argument_list; 132, 133; 133, identifier:image; 134, block; 134, 135; 134, 139; 134, 147; 134, 161; 134, 178; 134, 219; 134, 223; 134, 227; 135, expression_statement; 135, 136; 136, augmented_assignment:+=; 136, 137; 136, 138; 137, identifier:istep; 138, integer:1; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:buildname; 142, binary_operator:%; 142, 143; 142, 144; 143, string:'dmkbuild_%s_%d'; 144, tuple; 144, 145; 144, 146; 145, identifier:image; 146, identifier:istep; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:secret_files; 150, call; 150, 151; 150, 158; 151, attribute; 151, 152; 151, 157; 152, subscript; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:ymldefs; 156, identifier:base_name; 157, identifier:get; 158, argument_list; 158, 159; 158, 160; 159, string:'secret_files'; 160, None; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:squash; 164, call; 164, 165; 164, 172; 165, attribute; 165, 166; 165, 171; 166, subscript; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:ymldefs; 170, identifier:base_name; 171, identifier:get; 172, argument_list; 172, 173; 172, 174; 173, string:'squash'; 174, call; 174, 175; 174, 176; 175, identifier:bool; 176, argument_list; 176, 177; 177, identifier:secret_files; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:build_steps; 182, identifier:append; 183, argument_list; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:dockermake; 188, identifier:step; 189, identifier:BuildStep; 190, argument_list; 190, 191; 190, 192; 190, 193; 190, 198; 190, 199; 190, 204; 190, 207; 190, 210; 190, 213; 190, 216; 191, identifier:base_name; 192, identifier:base_image; 193, subscript; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:ymldefs; 197, identifier:base_name; 198, identifier:buildname; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:bust_cache; 201, comparison_operator:in; 201, 202; 201, 203; 202, identifier:base_name; 203, identifier:rebuilds; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:build_first; 206, identifier:build_first; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:cache_from; 209, identifier:cache_from; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:buildargs; 212, identifier:buildargs; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:squash; 215, identifier:squash; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:secret_files; 218, identifier:secret_files; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:base_image; 222, identifier:buildname; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:build_first; 226, None; 227, for_statement; 227, 228; 227, 231; 227, 245; 228, pattern_list; 228, 229; 228, 230; 229, identifier:sourceimage; 230, identifier:files; 231, call; 231, 232; 231, 233; 232, identifier:iteritems; 233, argument_list; 233, 234; 234, call; 234, 235; 234, 242; 235, attribute; 235, 236; 235, 241; 236, subscript; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:ymldefs; 240, identifier:base_name; 241, identifier:get; 242, argument_list; 242, 243; 242, 244; 243, string:'copy_from'; 244, dictionary; 245, block; 245, 246; 245, 253; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:sourceimages; 250, identifier:add; 251, argument_list; 251, 252; 252, identifier:sourceimage; 253, for_statement; 253, 254; 253, 257; 253, 261; 254, pattern_list; 254, 255; 254, 256; 255, identifier:sourcepath; 256, identifier:destpath; 257, call; 257, 258; 257, 259; 258, identifier:iteritems; 259, argument_list; 259, 260; 260, identifier:files; 261, block; 261, 262; 261, 266; 261, 274; 261, 309; 262, expression_statement; 262, 263; 263, augmented_assignment:+=; 263, 264; 263, 265; 264, identifier:istep; 265, integer:1; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:buildname; 269, binary_operator:%; 269, 270; 269, 271; 270, string:'dmkbuild_%s_%d'; 271, tuple; 271, 272; 271, 273; 272, identifier:image; 273, identifier:istep; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:build_steps; 278, identifier:append; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 286; 281, attribute; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:dockermake; 284, identifier:step; 285, identifier:FileCopyStep; 286, argument_list; 286, 287; 286, 288; 286, 289; 286, 290; 286, 291; 286, 292; 286, 297; 286, 298; 286, 303; 286, 306; 287, identifier:sourceimage; 288, identifier:sourcepath; 289, identifier:destpath; 290, identifier:base_name; 291, identifier:base_image; 292, subscript; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:self; 295, identifier:ymldefs; 296, identifier:base_name; 297, identifier:buildname; 298, keyword_argument; 298, 299; 298, 300; 299, identifier:bust_cache; 300, comparison_operator:in; 300, 301; 300, 302; 301, identifier:base_name; 302, identifier:rebuilds; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:build_first; 305, identifier:build_first; 306, keyword_argument; 306, 307; 306, 308; 307, identifier:cache_from; 308, identifier:cache_from; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:base_image; 312, identifier:buildname; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:sourcebuilds; 316, list_comprehension; 316, 317; 316, 332; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:self; 320, identifier:generate_build; 321, argument_list; 321, 322; 321, 323; 321, 324; 321, 327; 321, 330; 322, identifier:img; 323, identifier:img; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:cache_repo; 326, identifier:cache_repo; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:cache_tag; 329, identifier:cache_tag; 330, dictionary_splat; 330, 331; 331, identifier:kwargs; 332, for_in_clause; 332, 333; 332, 334; 333, identifier:img; 334, identifier:sourceimages; 335, return_statement; 335, 336; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:builds; 339, identifier:BuildTarget; 340, argument_list; 340, 341; 340, 344; 340, 347; 340, 350; 340, 353; 340, 356; 341, keyword_argument; 341, 342; 341, 343; 342, identifier:imagename; 343, identifier:image; 344, keyword_argument; 344, 345; 344, 346; 345, identifier:targetname; 346, identifier:targetname; 347, keyword_argument; 347, 348; 347, 349; 348, identifier:steps; 349, identifier:build_steps; 350, keyword_argument; 350, 351; 350, 352; 351, identifier:sourcebuilds; 352, identifier:sourcebuilds; 353, keyword_argument; 353, 354; 353, 355; 354, identifier:from_image; 355, identifier:from_image; 356, dictionary_splat; 356, 357; 357, identifier:kwargs | def generate_build(self, image, targetname, rebuilds=None, cache_repo='', cache_tag='',
buildargs=None, **kwargs):
from_image = self.get_external_base_image(image)
if cache_repo or cache_tag:
cache_from = utils.generate_name(image, cache_repo, cache_tag)
else:
cache_from = None
if from_image is None:
raise errors.NoBaseError("No base image found in %s's dependencies" % image)
if isinstance(from_image, ExternalDockerfile):
build_first = from_image
base_image = from_image.tag
else:
base_image = from_image
build_first = None
build_steps = []
istep = 0
sourceimages = set()
if rebuilds is None:
rebuilds = []
else:
rebuilds = set(rebuilds)
for base_name in self.sort_dependencies(image):
istep += 1
buildname = 'dmkbuild_%s_%d' % (image, istep)
secret_files = self.ymldefs[base_name].get('secret_files', None)
squash = self.ymldefs[base_name].get('squash', bool(secret_files))
build_steps.append(
dockermake.step.BuildStep(
base_name,
base_image,
self.ymldefs[base_name],
buildname,
bust_cache=base_name in rebuilds,
build_first=build_first, cache_from=cache_from,
buildargs=buildargs,
squash=squash,
secret_files=secret_files))
base_image = buildname
build_first = None
for sourceimage, files in iteritems(self.ymldefs[base_name].get('copy_from', {})):
sourceimages.add(sourceimage)
for sourcepath, destpath in iteritems(files):
istep += 1
buildname = 'dmkbuild_%s_%d' % (image, istep)
build_steps.append(
dockermake.step.FileCopyStep(
sourceimage, sourcepath, destpath,
base_name, base_image, self.ymldefs[base_name],
buildname, bust_cache=base_name in rebuilds,
build_first=build_first, cache_from=cache_from))
base_image = buildname
sourcebuilds = [self.generate_build(img,
img,
cache_repo=cache_repo,
cache_tag=cache_tag,
**kwargs)
for img in sourceimages]
return builds.BuildTarget(imagename=image,
targetname=targetname,
steps=build_steps,
sourcebuilds=sourcebuilds,
from_image=from_image,
**kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort_dependencies; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:image; 6, default_parameter; 6, 7; 6, 8; 7, identifier:dependencies; 8, None; 9, block; 9, 10; 9, 21; 9, 27; 9, 41; 9, 53; 9, 59; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:dependencies; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:dependencies; 18, call; 18, 19; 18, 20; 19, identifier:OrderedDict; 20, argument_list; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:in; 22, 23; 22, 24; 23, identifier:image; 24, identifier:dependencies; 25, block; 25, 26; 26, return_statement; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:requires; 30, call; 30, 31; 30, 38; 31, attribute; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:ymldefs; 36, identifier:image; 37, identifier:get; 38, argument_list; 38, 39; 38, 40; 39, string:'requires'; 40, list:[]; 41, for_statement; 41, 42; 41, 43; 41, 44; 42, identifier:dep; 43, identifier:requires; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:sort_dependencies; 50, argument_list; 50, 51; 50, 52; 51, identifier:dep; 52, identifier:dependencies; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:dependencies; 57, identifier:image; 58, None; 59, return_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:dependencies; 63, identifier:keys; 64, argument_list | def sort_dependencies(self, image, dependencies=None):
if dependencies is None:
dependencies = OrderedDict()
if image in dependencies:
return
requires = self.ymldefs[image].get('requires', [])
for dep in requires:
self.sort_dependencies(dep, dependencies)
dependencies[image] = None
return dependencies.keys() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_external_base_image; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:image; 6, default_parameter; 6, 7; 6, 8; 7, identifier:stack; 8, None; 9, block; 9, 10; 9, 21; 9, 29; 9, 55; 9, 62; 9, 82; 9, 136; 9, 146; 9, 163; 9, 224; 9, 232; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:stack; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:stack; 18, call; 18, 19; 18, 20; 19, identifier:list; 20, argument_list; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:mydef; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:ymldefs; 28, identifier:image; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:in; 30, 31; 30, 32; 31, identifier:image; 32, identifier:stack; 33, block; 33, 34; 33, 41; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:stack; 38, identifier:append; 39, argument_list; 39, 40; 40, identifier:image; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:errors; 45, identifier:CircularDependencyError; 46, argument_list; 46, 47; 47, binary_operator:+; 47, 48; 47, 49; 48, string:'Circular dependency found:\n'; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, string:'->'; 52, identifier:join; 53, argument_list; 53, 54; 54, identifier:stack; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:stack; 59, identifier:append; 60, argument_list; 60, 61; 61, identifier:image; 62, if_statement; 62, 63; 62, 70; 63, boolean_operator:and; 63, 64; 63, 67; 64, comparison_operator:in; 64, 65; 64, 66; 65, string:'FROM'; 66, identifier:mydef; 67, comparison_operator:in; 67, 68; 67, 69; 68, string:'FROM_DOCKERFILE'; 69, identifier:mydef; 70, block; 70, 71; 71, raise_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:errors; 75, identifier:MultipleBaseError; 76, argument_list; 76, 77; 77, binary_operator:+; 77, 78; 77, 81; 78, binary_operator:%; 78, 79; 78, 80; 79, string:'ERROR: Image "%s" has both a "FROM" and a "FROM_DOCKERFILE" field.'; 80, identifier:image; 81, string:' It should have at most ONE of these fields.'; 82, if_statement; 82, 83; 82, 86; 82, 93; 82, 130; 83, comparison_operator:in; 83, 84; 83, 85; 84, string:'FROM'; 85, identifier:mydef; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:externalbase; 90, subscript; 90, 91; 90, 92; 91, identifier:mydef; 92, string:'FROM'; 93, elif_clause; 93, 94; 93, 97; 94, comparison_operator:in; 94, 95; 94, 96; 95, string:'FROM_DOCKERFILE'; 96, identifier:mydef; 97, block; 97, 98; 97, 104; 97, 122; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:path; 101, subscript; 101, 102; 101, 103; 102, identifier:mydef; 103, string:'FROM_DOCKERFILE'; 104, if_statement; 104, 105; 104, 110; 105, comparison_operator:not; 105, 106; 105, 107; 106, identifier:path; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:_external_dockerfiles; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 118; 113, subscript; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:_external_dockerfiles; 117, identifier:path; 118, call; 118, 119; 118, 120; 119, identifier:ExternalDockerfile; 120, argument_list; 120, 121; 121, identifier:path; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:externalbase; 125, subscript; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_external_dockerfiles; 129, identifier:path; 130, else_clause; 130, 131; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:externalbase; 135, None; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:requires; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:mydef; 142, identifier:get; 143, argument_list; 143, 144; 143, 145; 144, string:'requires'; 145, list:[]; 146, if_statement; 146, 147; 146, 153; 147, not_operator; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:isinstance; 150, argument_list; 150, 151; 150, 152; 151, identifier:requires; 152, identifier:list; 153, block; 153, 154; 154, raise_statement; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:errors; 158, identifier:InvalidRequiresList; 159, argument_list; 159, 160; 160, binary_operator:%; 160, 161; 160, 162; 161, string:'Requirements for image "%s" are not a list'; 162, identifier:image; 163, for_statement; 163, 164; 163, 165; 163, 166; 164, identifier:base; 165, identifier:requires; 166, block; 166, 167; 166, 183; 167, try_statement; 167, 168; 167, 179; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:otherexternal; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:get_external_base_image; 176, argument_list; 176, 177; 176, 178; 177, identifier:base; 178, identifier:stack; 179, except_clause; 179, 180; 179, 181; 180, identifier:ValueError; 181, block; 181, 182; 182, continue_statement; 183, if_statement; 183, 184; 183, 187; 183, 192; 183, 198; 184, comparison_operator:is; 184, 185; 184, 186; 185, identifier:externalbase; 186, None; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:externalbase; 191, identifier:otherexternal; 192, elif_clause; 192, 193; 192, 196; 193, comparison_operator:is; 193, 194; 193, 195; 194, identifier:otherexternal; 195, None; 196, block; 196, 197; 197, continue_statement; 198, elif_clause; 198, 199; 198, 202; 199, comparison_operator:!=; 199, 200; 199, 201; 200, identifier:externalbase; 201, identifier:otherexternal; 202, block; 202, 203; 203, raise_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:errors; 207, identifier:ConflictingBaseError; 208, argument_list; 208, 209; 209, binary_operator:+; 209, 210; 209, 219; 210, binary_operator:+; 210, 211; 210, 214; 211, binary_operator:%; 211, 212; 211, 213; 212, string:'Multiple external dependencies: definition "%s" depends on:\n'; 213, identifier:image; 214, binary_operator:%; 214, 215; 214, 216; 215, string:' %s (FROM: %s), and\n'; 216, tuple; 216, 217; 216, 218; 217, identifier:image; 218, identifier:externalbase; 219, binary_operator:%; 219, 220; 219, 221; 220, string:' %s (FROM: %s).'; 221, tuple; 221, 222; 221, 223; 222, identifier:base; 223, identifier:otherexternal; 224, assert_statement; 224, 225; 225, comparison_operator:==; 225, 226; 225, 231; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:stack; 229, identifier:pop; 230, argument_list; 231, identifier:image; 232, return_statement; 232, 233; 233, identifier:externalbase | def get_external_base_image(self, image, stack=None):
if stack is None:
stack = list()
mydef = self.ymldefs[image]
if image in stack:
stack.append(image)
raise errors.CircularDependencyError('Circular dependency found:\n' + '->'.join(stack))
stack.append(image)
if 'FROM' in mydef and 'FROM_DOCKERFILE' in mydef:
raise errors.MultipleBaseError(
'ERROR: Image "%s" has both a "FROM" and a "FROM_DOCKERFILE" field.' % image +
' It should have at most ONE of these fields.')
if 'FROM' in mydef:
externalbase = mydef['FROM']
elif 'FROM_DOCKERFILE' in mydef:
path = mydef['FROM_DOCKERFILE']
if path not in self._external_dockerfiles:
self._external_dockerfiles[path] = ExternalDockerfile(path)
externalbase = self._external_dockerfiles[path]
else:
externalbase = None
requires = mydef.get('requires', [])
if not isinstance(requires, list):
raise errors.InvalidRequiresList('Requirements for image "%s" are not a list' % image)
for base in requires:
try:
otherexternal = self.get_external_base_image(base, stack)
except ValueError:
continue
if externalbase is None:
externalbase = otherexternal
elif otherexternal is None:
continue
elif externalbase != otherexternal:
raise errors.ConflictingBaseError(
'Multiple external dependencies: definition "%s" depends on:\n' % image +
' %s (FROM: %s), and\n' % (image, externalbase) +
' %s (FROM: %s).' % (base, otherexternal))
assert stack.pop() == image
return externalbase |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_htmlRenderDict; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:pathParts; 5, identifier:statDict; 6, identifier:output; 7, block; 7, 8; 7, 19; 7, 25; 7, 29; 7, 36; 7, 173; 7, 187; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:keys; 11, call; 11, 12; 11, 13; 12, identifier:list; 13, argument_list; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:statDict; 17, identifier:keys; 18, argument_list; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:keys; 23, identifier:sort; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:links; 28, list:[]; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:output; 33, identifier:write; 34, argument_list; 34, 35; 35, string:'<div class="level">'; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:key; 38, identifier:keys; 39, block; 39, 40; 39, 52; 39, 58; 39, 71; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:keyStr; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:cgi; 46, identifier:escape; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:_utf8str; 50, argument_list; 50, 51; 51, identifier:key; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:value; 55, subscript; 55, 56; 55, 57; 56, identifier:statDict; 57, identifier:key; 58, if_statement; 58, 59; 58, 64; 59, call; 59, 60; 59, 61; 60, identifier:hasattr; 61, argument_list; 61, 62; 61, 63; 62, identifier:value; 63, string:'__call__'; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:value; 68, call; 68, 69; 68, 70; 69, identifier:value; 70, argument_list; 71, if_statement; 71, 72; 71, 77; 71, 140; 72, call; 72, 73; 72, 74; 73, identifier:hasattr; 74, argument_list; 74, 75; 74, 76; 75, identifier:value; 76, string:'keys'; 77, block; 77, 78; 77, 85; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:valuePath; 81, binary_operator:+; 81, 82; 81, 83; 82, identifier:pathParts; 83, tuple; 83, 84; 84, identifier:keyStr; 85, if_statement; 85, 86; 85, 99; 85, 122; 86, boolean_operator:and; 86, 87; 86, 94; 87, call; 87, 88; 87, 89; 88, identifier:isinstance; 89, argument_list; 89, 90; 89, 91; 90, identifier:value; 91, attribute; 91, 92; 91, 93; 92, identifier:scales; 93, identifier:StatContainer; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:value; 97, identifier:isCollapsed; 98, argument_list; 99, block; 99, 100; 99, 111; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:link; 103, binary_operator:+; 103, 104; 103, 105; 104, string:'/status/'; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, string:'/'; 108, identifier:join; 109, argument_list; 109, 110; 110, identifier:valuePath; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:links; 115, identifier:append; 116, argument_list; 116, 117; 117, binary_operator:%; 117, 118; 117, 119; 118, string:'<div class="key"><a href="%s">%s</a></div>'; 119, tuple; 119, 120; 119, 121; 120, identifier:link; 121, identifier:keyStr; 122, else_clause; 122, 123; 123, block; 123, 124; 123, 133; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:output; 128, identifier:write; 129, argument_list; 129, 130; 130, binary_operator:%; 130, 131; 130, 132; 131, string:'<div class="key">%s</div>'; 132, identifier:keyStr; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:_htmlRenderDict; 136, argument_list; 136, 137; 136, 138; 136, 139; 137, identifier:valuePath; 138, identifier:value; 139, identifier:output; 140, else_clause; 140, 141; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:output; 146, identifier:write; 147, argument_list; 147, 148; 148, binary_operator:%; 148, 149; 148, 150; 149, string:'<div><span class="key">%s</span> <span class="%s">%s</span></div>'; 150, tuple; 150, 151; 150, 152; 150, 158; 151, identifier:keyStr; 152, attribute; 152, 153; 152, 157; 153, call; 153, 154; 153, 155; 154, identifier:type; 155, argument_list; 155, 156; 156, identifier:value; 157, identifier:__name__; 158, call; 158, 159; 158, 170; 159, attribute; 159, 160; 159, 169; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:cgi; 163, identifier:escape; 164, argument_list; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:_utf8str; 167, argument_list; 167, 168; 168, identifier:value; 169, identifier:replace; 170, argument_list; 170, 171; 170, 172; 171, string:'\n'; 172, string:'<br/>'; 173, if_statement; 173, 174; 173, 175; 174, identifier:links; 175, block; 175, 176; 176, for_statement; 176, 177; 176, 178; 176, 179; 177, identifier:link; 178, identifier:links; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:output; 184, identifier:write; 185, argument_list; 185, 186; 186, identifier:link; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:output; 191, identifier:write; 192, argument_list; 192, 193; 193, string:'</div>' | def _htmlRenderDict(pathParts, statDict, output):
keys = list(statDict.keys())
keys.sort()
links = []
output.write('<div class="level">')
for key in keys:
keyStr = cgi.escape(_utf8str(key))
value = statDict[key]
if hasattr(value, '__call__'):
value = value()
if hasattr(value, 'keys'):
valuePath = pathParts + (keyStr,)
if isinstance(value, scales.StatContainer) and value.isCollapsed():
link = '/status/' + '/'.join(valuePath)
links.append('<div class="key"><a href="%s">%s</a></div>' % (link, keyStr))
else:
output.write('<div class="key">%s</div>' % keyStr)
_htmlRenderDict(valuePath, value, output)
else:
output.write('<div><span class="key">%s</span> <span class="%s">%s</span></div>' %
(keyStr, type(value).__name__, cgi.escape(_utf8str(value)).replace('\n', '<br/>')))
if links:
for link in links:
output.write(link)
output.write('</div>') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 96; 1, 98; 2, function_name:create_session; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 14; 3, 23; 3, 32; 3, 41; 3, 46; 3, 51; 3, 56; 3, 61; 3, 66; 3, 75; 3, 80; 3, 85; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:kind; 7, type; 7, 8; 8, identifier:SessionKind; 9, typed_default_parameter; 9, 10; 9, 11; 9, 13; 10, identifier:proxy_user; 11, type; 11, 12; 12, identifier:str; 13, None; 14, typed_default_parameter; 14, 15; 14, 16; 14, 22; 15, identifier:jars; 16, type; 16, 17; 17, generic_type; 17, 18; 17, 19; 18, identifier:List; 19, type_parameter; 19, 20; 20, type; 20, 21; 21, identifier:str; 22, None; 23, typed_default_parameter; 23, 24; 23, 25; 23, 31; 24, identifier:py_files; 25, type; 25, 26; 26, generic_type; 26, 27; 26, 28; 27, identifier:List; 28, type_parameter; 28, 29; 29, type; 29, 30; 30, identifier:str; 31, None; 32, typed_default_parameter; 32, 33; 32, 34; 32, 40; 33, identifier:files; 34, type; 34, 35; 35, generic_type; 35, 36; 35, 37; 36, identifier:List; 37, type_parameter; 37, 38; 38, type; 38, 39; 39, identifier:str; 40, None; 41, typed_default_parameter; 41, 42; 41, 43; 41, 45; 42, identifier:driver_memory; 43, type; 43, 44; 44, identifier:str; 45, None; 46, typed_default_parameter; 46, 47; 46, 48; 46, 50; 47, identifier:driver_cores; 48, type; 48, 49; 49, identifier:int; 50, None; 51, typed_default_parameter; 51, 52; 51, 53; 51, 55; 52, identifier:executor_memory; 53, type; 53, 54; 54, identifier:str; 55, None; 56, typed_default_parameter; 56, 57; 56, 58; 56, 60; 57, identifier:executor_cores; 58, type; 58, 59; 59, identifier:int; 60, None; 61, typed_default_parameter; 61, 62; 61, 63; 61, 65; 62, identifier:num_executors; 63, type; 63, 64; 64, identifier:int; 65, None; 66, typed_default_parameter; 66, 67; 66, 68; 66, 74; 67, identifier:archives; 68, type; 68, 69; 69, generic_type; 69, 70; 69, 71; 70, identifier:List; 71, type_parameter; 71, 72; 72, type; 72, 73; 73, identifier:str; 74, None; 75, typed_default_parameter; 75, 76; 75, 77; 75, 79; 76, identifier:queue; 77, type; 77, 78; 78, identifier:str; 79, None; 80, typed_default_parameter; 80, 81; 80, 82; 80, 84; 81, identifier:name; 82, type; 82, 83; 83, identifier:str; 84, None; 85, typed_default_parameter; 85, 86; 85, 87; 85, 95; 86, identifier:spark_conf; 87, type; 87, 88; 88, generic_type; 88, 89; 88, 90; 89, identifier:Dict; 90, type_parameter; 90, 91; 90, 93; 91, type; 91, 92; 92, identifier:str; 93, type; 93, 94; 94, identifier:Any; 95, None; 96, type; 96, 97; 97, identifier:Session; 98, block; 98, 99; 98, 116; 98, 128; 98, 137; 98, 148; 98, 159; 98, 170; 98, 181; 98, 192; 98, 203; 98, 214; 98, 225; 98, 236; 98, 247; 98, 258; 98, 269; 98, 280; 98, 294; 99, if_statement; 99, 100; 99, 105; 99, 110; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:legacy_server; 104, argument_list; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:valid_kinds; 109, identifier:VALID_LEGACY_SESSION_KINDS; 110, else_clause; 110, 111; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:valid_kinds; 115, identifier:VALID_SESSION_KINDS; 116, if_statement; 116, 117; 116, 120; 117, comparison_operator:not; 117, 118; 117, 119; 118, identifier:kind; 119, identifier:valid_kinds; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:ValueError; 124, argument_list; 124, 125; 125, concatenated_string; 125, 126; 125, 127; 126, string:f"{kind} is not a valid session kind for a Livy server of "; 127, string:f"this version (should be one of {valid_kinds})"; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:body; 131, dictionary; 131, 132; 132, pair; 132, 133; 132, 134; 133, string:"kind"; 134, attribute; 134, 135; 134, 136; 135, identifier:kind; 136, identifier:value; 137, if_statement; 137, 138; 137, 141; 138, comparison_operator:is; 138, 139; 138, 140; 139, identifier:proxy_user; 140, None; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:body; 146, string:"proxyUser"; 147, identifier:proxy_user; 148, if_statement; 148, 149; 148, 152; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:jars; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:body; 157, string:"jars"; 158, identifier:jars; 159, if_statement; 159, 160; 159, 163; 160, comparison_operator:is; 160, 161; 160, 162; 161, identifier:py_files; 162, None; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 169; 166, subscript; 166, 167; 166, 168; 167, identifier:body; 168, string:"pyFiles"; 169, identifier:py_files; 170, if_statement; 170, 171; 170, 174; 171, comparison_operator:is; 171, 172; 171, 173; 172, identifier:files; 173, None; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:body; 179, string:"files"; 180, identifier:files; 181, if_statement; 181, 182; 181, 185; 182, comparison_operator:is; 182, 183; 182, 184; 183, identifier:driver_memory; 184, None; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:body; 190, string:"driverMemory"; 191, identifier:driver_memory; 192, if_statement; 192, 193; 192, 196; 193, comparison_operator:is; 193, 194; 193, 195; 194, identifier:driver_cores; 195, None; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:body; 201, string:"driverCores"; 202, identifier:driver_cores; 203, if_statement; 203, 204; 203, 207; 204, comparison_operator:is; 204, 205; 204, 206; 205, identifier:executor_memory; 206, None; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:body; 212, string:"executorMemory"; 213, identifier:executor_memory; 214, if_statement; 214, 215; 214, 218; 215, comparison_operator:is; 215, 216; 215, 217; 216, identifier:executor_cores; 217, None; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:body; 223, string:"executorCores"; 224, identifier:executor_cores; 225, if_statement; 225, 226; 225, 229; 226, comparison_operator:is; 226, 227; 226, 228; 227, identifier:num_executors; 228, None; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:body; 234, string:"numExecutors"; 235, identifier:num_executors; 236, if_statement; 236, 237; 236, 240; 237, comparison_operator:is; 237, 238; 237, 239; 238, identifier:archives; 239, None; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:body; 245, string:"archives"; 246, identifier:archives; 247, if_statement; 247, 248; 247, 251; 248, comparison_operator:is; 248, 249; 248, 250; 249, identifier:queue; 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:body; 256, string:"queue"; 257, identifier:queue; 258, if_statement; 258, 259; 258, 262; 259, comparison_operator:is; 259, 260; 259, 261; 260, identifier:name; 261, None; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 268; 265, subscript; 265, 266; 265, 267; 266, identifier:body; 267, string:"name"; 268, identifier:name; 269, if_statement; 269, 270; 269, 273; 270, comparison_operator:is; 270, 271; 270, 272; 271, identifier:spark_conf; 272, None; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 279; 276, subscript; 276, 277; 276, 278; 277, identifier:body; 278, string:"conf"; 279, identifier:spark_conf; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:data; 283, call; 283, 284; 283, 289; 284, attribute; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:self; 287, identifier:_client; 288, identifier:post; 289, argument_list; 289, 290; 289, 291; 290, string:"/sessions"; 291, keyword_argument; 291, 292; 291, 293; 292, identifier:data; 293, identifier:body; 294, return_statement; 294, 295; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:Session; 298, identifier:from_json; 299, argument_list; 299, 300; 300, identifier:data | def create_session(
self,
kind: SessionKind,
proxy_user: str = None,
jars: List[str] = None,
py_files: List[str] = None,
files: List[str] = None,
driver_memory: str = None,
driver_cores: int = None,
executor_memory: str = None,
executor_cores: int = None,
num_executors: int = None,
archives: List[str] = None,
queue: str = None,
name: str = None,
spark_conf: Dict[str, Any] = None,
) -> Session:
if self.legacy_server():
valid_kinds = VALID_LEGACY_SESSION_KINDS
else:
valid_kinds = VALID_SESSION_KINDS
if kind not in valid_kinds:
raise ValueError(
f"{kind} is not a valid session kind for a Livy server of "
f"this version (should be one of {valid_kinds})"
)
body = {"kind": kind.value}
if proxy_user is not None:
body["proxyUser"] = proxy_user
if jars is not None:
body["jars"] = jars
if py_files is not None:
body["pyFiles"] = py_files
if files is not None:
body["files"] = files
if driver_memory is not None:
body["driverMemory"] = driver_memory
if driver_cores is not None:
body["driverCores"] = driver_cores
if executor_memory is not None:
body["executorMemory"] = executor_memory
if executor_cores is not None:
body["executorCores"] = executor_cores
if num_executors is not None:
body["numExecutors"] = num_executors
if archives is not None:
body["archives"] = archives
if queue is not None:
body["queue"] = queue
if name is not None:
body["name"] = name
if spark_conf is not None:
body["conf"] = spark_conf
data = self._client.post("/sessions", data=body)
return Session.from_json(data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:sine_psd; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:data; 5, identifier:delta; 6, default_parameter; 6, 7; 6, 8; 7, identifier:number_of_tapers; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:number_of_iterations; 11, integer:2; 12, default_parameter; 12, 13; 12, 14; 13, identifier:degree_of_smoothing; 14, float:1.0; 15, default_parameter; 15, 16; 15, 17; 16, identifier:statistics; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:verbose; 20, False; 21, block; 21, 22; 21, 47; 21, 56; 21, 63; 21, 83; 21, 90; 21, 101; 21, 110; 21, 119; 21, 179; 21, 277; 21, 283; 21, 297; 22, if_statement; 22, 23; 22, 26; 22, 41; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:verbose; 25, True; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:verbose; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:C; 33, identifier:byref; 34, argument_list; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:C; 38, identifier:c_char; 39, argument_list; 39, 40; 40, string:'y'; 41, else_clause; 41, 42; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:verbose; 46, None; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:number_of_tapers; 50, None; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:number_of_tapers; 55, integer:0; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:mt; 59, call; 59, 60; 59, 61; 60, identifier:_MtspecType; 61, argument_list; 61, 62; 62, string:"float32"; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:data; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:np; 69, identifier:require; 70, argument_list; 70, 71; 70, 72; 70, 77; 71, identifier:data; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:dtype; 74, attribute; 74, 75; 74, 76; 75, identifier:mt; 76, identifier:float; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:requirements; 79, list:[mt.order]; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:mt; 82, identifier:order; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:npts; 86, call; 86, 87; 86, 88; 87, identifier:len; 88, argument_list; 88, 89; 89, identifier:data; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:number_of_frequency_bins; 93, binary_operator:+; 93, 94; 93, 100; 94, call; 94, 95; 94, 96; 95, identifier:int; 96, argument_list; 96, 97; 97, binary_operator:/; 97, 98; 97, 99; 98, identifier:npts; 99, integer:2; 100, integer:1; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:frequency_bins; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:mt; 107, identifier:empty; 108, argument_list; 108, 109; 109, identifier:number_of_frequency_bins; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:spectrum; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:mt; 116, identifier:empty; 117, argument_list; 117, 118; 118, identifier:number_of_frequency_bins; 119, if_statement; 119, 120; 119, 123; 119, 171; 120, comparison_operator:is; 120, 121; 120, 122; 121, identifier:statistics; 122, True; 123, block; 123, 124; 123, 141; 123, 160; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:tapers_per_freq_point; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:np; 130, identifier:empty; 131, argument_list; 131, 132; 131, 133; 131, 136; 132, identifier:number_of_frequency_bins; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:dtype; 135, string:'int32'; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:order; 138, attribute; 138, 139; 138, 140; 139, identifier:mt; 140, identifier:order; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 142, 145; 143, identifier:tapers_per_freq_point_p; 144, line_continuation:\; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:tapers_per_freq_point; 149, identifier:ctypes; 150, identifier:data_as; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:C; 155, identifier:POINTER; 156, argument_list; 156, 157; 157, attribute; 157, 158; 157, 159; 158, identifier:C; 159, identifier:c_int; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:errors; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:mt; 166, identifier:empty; 167, argument_list; 167, 168; 168, tuple; 168, 169; 168, 170; 169, identifier:number_of_frequency_bins; 170, integer:2; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:tapers_per_freq_point_p; 176, assignment; 176, 177; 176, 178; 177, identifier:errors; 178, None; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:mtspeclib; 183, identifier:sine_psd_; 184, argument_list; 184, 185; 184, 196; 184, 207; 184, 213; 184, 224; 184, 235; 184, 246; 184, 257; 184, 263; 184, 269; 184, 270; 184, 276; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:C; 188, identifier:byref; 189, argument_list; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:C; 193, identifier:c_int; 194, argument_list; 194, 195; 195, identifier:npts; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:C; 199, identifier:byref; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:C; 204, identifier:c_float; 205, argument_list; 205, 206; 206, identifier:delta; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:mt; 210, identifier:p; 211, argument_list; 211, 212; 212, identifier:data; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:C; 216, identifier:byref; 217, argument_list; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:C; 221, identifier:c_int; 222, argument_list; 222, 223; 223, identifier:number_of_tapers; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:C; 227, identifier:byref; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:C; 232, identifier:c_int; 233, argument_list; 233, 234; 234, identifier:number_of_iterations; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:C; 238, identifier:byref; 239, argument_list; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:C; 243, identifier:c_float; 244, argument_list; 244, 245; 245, identifier:degree_of_smoothing; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:C; 249, identifier:byref; 250, argument_list; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:C; 254, identifier:c_int; 255, argument_list; 255, 256; 256, identifier:number_of_frequency_bins; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:mt; 260, identifier:p; 261, argument_list; 261, 262; 262, identifier:frequency_bins; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:mt; 266, identifier:p; 267, argument_list; 267, 268; 268, identifier:spectrum; 269, identifier:tapers_per_freq_point_p; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:mt; 273, identifier:p; 274, argument_list; 274, 275; 275, identifier:errors; 276, identifier:verbose; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:return_values; 280, list:[spectrum, frequency_bins]; 280, 281; 280, 282; 281, identifier:spectrum; 282, identifier:frequency_bins; 283, if_statement; 283, 284; 283, 287; 284, comparison_operator:is; 284, 285; 284, 286; 285, identifier:statistics; 286, True; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:return_values; 292, identifier:extend; 293, argument_list; 293, 294; 294, list:[errors, tapers_per_freq_point]; 294, 295; 294, 296; 295, identifier:errors; 296, identifier:tapers_per_freq_point; 297, return_statement; 297, 298; 298, identifier:return_values | def sine_psd(data, delta, number_of_tapers=None, number_of_iterations=2,
degree_of_smoothing=1.0, statistics=False, verbose=False):
if verbose is True:
verbose = C.byref(C.c_char('y'))
else:
verbose = None
if number_of_tapers is None:
number_of_tapers = 0
mt = _MtspecType("float32")
data = np.require(data, dtype=mt.float, requirements=[mt.order])
npts = len(data)
number_of_frequency_bins = int(npts / 2) + 1
frequency_bins = mt.empty(number_of_frequency_bins)
spectrum = mt.empty(number_of_frequency_bins)
if statistics is True:
tapers_per_freq_point = np.empty(number_of_frequency_bins,
dtype='int32', order=mt.order)
tapers_per_freq_point_p = \
tapers_per_freq_point.ctypes.data_as(C.POINTER(C.c_int))
errors = mt.empty((number_of_frequency_bins, 2))
else:
tapers_per_freq_point_p = errors = None
mtspeclib.sine_psd_(
C.byref(C.c_int(npts)),
C.byref(C.c_float(delta)), mt.p(data),
C.byref(C.c_int(number_of_tapers)),
C.byref(C.c_int(number_of_iterations)),
C.byref(C.c_float(degree_of_smoothing)),
C.byref(C.c_int(number_of_frequency_bins)),
mt.p(frequency_bins), mt.p(spectrum),
tapers_per_freq_point_p, mt.p(errors), verbose)
return_values = [spectrum, frequency_bins]
if statistics is True:
return_values.extend([errors, tapers_per_freq_point])
return return_values |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:mt_deconvolve; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:data_a; 5, identifier:data_b; 6, identifier:delta; 7, default_parameter; 7, 8; 7, 9; 8, identifier:nfft; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:time_bandwidth; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:number_of_tapers; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:weights; 18, string:"adaptive"; 19, default_parameter; 19, 20; 19, 21; 20, identifier:demean; 21, True; 22, default_parameter; 22, 23; 22, 24; 23, identifier:fmax; 24, float:0.0; 25, block; 25, 26; 25, 33; 25, 46; 25, 67; 25, 74; 25, 90; 25, 108; 25, 126; 25, 134; 25, 147; 25, 172; 25, 181; 25, 190; 25, 199; 25, 208; 25, 217; 25, 382; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:npts; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:data_a; 33, if_statement; 33, 34; 33, 40; 34, comparison_operator:!=; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, identifier:data_b; 39, identifier:npts; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:ValueError; 44, argument_list; 44, 45; 45, string:"Input arrays must have the same length!"; 46, if_statement; 46, 47; 46, 50; 46, 55; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:nfft; 49, None; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:nfft; 54, identifier:npts; 55, elif_clause; 55, 56; 55, 59; 56, comparison_operator:<; 56, 57; 56, 58; 57, identifier:nfft; 58, identifier:npts; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:ValueError; 63, argument_list; 63, 64; 64, concatenated_string; 64, 65; 64, 66; 65, string:"nfft must be larger then the number of samples in "; 66, string:"the array."; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:mt; 70, call; 70, 71; 70, 72; 71, identifier:_MtspecType; 72, argument_list; 72, 73; 73, string:"float32"; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:number_of_tapers; 77, None; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:number_of_tapers; 82, binary_operator:-; 82, 83; 82, 89; 83, call; 83, 84; 83, 85; 84, identifier:int; 85, argument_list; 85, 86; 86, binary_operator:*; 86, 87; 86, 88; 87, integer:2; 88, identifier:time_bandwidth; 89, integer:1; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:data_a; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:require; 97, argument_list; 97, 98; 97, 99; 97, 102; 98, identifier:data_a; 99, attribute; 99, 100; 99, 101; 100, identifier:mt; 101, identifier:float; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:requirements; 104, list:[mt.order]; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:mt; 107, identifier:order; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:data_b; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:np; 114, identifier:require; 115, argument_list; 115, 116; 115, 117; 115, 120; 116, identifier:data_b; 117, attribute; 117, 118; 117, 119; 118, identifier:mt; 119, identifier:float; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:requirements; 122, list:[mt.order]; 122, 123; 123, attribute; 123, 124; 123, 125; 124, identifier:mt; 125, identifier:order; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:nf; 129, binary_operator:+; 129, 130; 129, 133; 130, binary_operator://; 130, 131; 130, 132; 131, identifier:nfft; 132, integer:2; 133, integer:1; 134, if_statement; 134, 135; 134, 136; 134, 141; 135, identifier:demean; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:demean; 140, integer:1; 141, else_clause; 141, 142; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:demean; 146, integer:0; 147, if_statement; 147, 148; 147, 151; 147, 156; 147, 165; 148, comparison_operator:==; 148, 149; 148, 150; 149, identifier:weights; 150, string:"constant"; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:adaptive; 155, integer:1; 156, elif_clause; 156, 157; 156, 160; 157, comparison_operator:==; 157, 158; 157, 159; 158, identifier:weights; 159, string:"adaptive"; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:adaptive; 164, integer:0; 165, else_clause; 165, 166; 166, block; 166, 167; 167, raise_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:ValueError; 170, argument_list; 170, 171; 171, string:'Weights must be either "adaptive" or "constant".'; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:tfun; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:mt; 178, identifier:empty; 179, argument_list; 179, 180; 180, identifier:nfft; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:freq; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:mt; 187, identifier:empty; 188, argument_list; 188, 189; 189, identifier:nf; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:spec_ratio; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:mt; 196, identifier:empty; 197, argument_list; 197, 198; 198, identifier:nf; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:speci; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:mt; 205, identifier:empty; 206, argument_list; 206, 207; 207, identifier:nf; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:specj; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:mt; 214, identifier:empty; 215, argument_list; 215, 216; 216, identifier:nf; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:mtspeclib; 221, identifier:mt_deconv_; 222, argument_list; 222, 223; 222, 237; 222, 251; 222, 265; 222, 271; 222, 277; 222, 291; 222, 305; 222, 319; 222, 330; 222, 336; 222, 342; 222, 348; 222, 354; 222, 360; 222, 371; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:C; 226, identifier:byref; 227, argument_list; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:C; 231, identifier:c_int; 232, argument_list; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:int; 235, argument_list; 235, 236; 236, identifier:npts; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:C; 240, identifier:byref; 241, argument_list; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:C; 245, identifier:c_int; 246, argument_list; 246, 247; 247, call; 247, 248; 247, 249; 248, identifier:int; 249, argument_list; 249, 250; 250, identifier:nfft; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:C; 254, identifier:byref; 255, argument_list; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:C; 259, identifier:c_float; 260, argument_list; 260, 261; 261, call; 261, 262; 261, 263; 262, identifier:float; 263, argument_list; 263, 264; 264, identifier:delta; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:mt; 268, identifier:p; 269, argument_list; 269, 270; 270, identifier:data_a; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:mt; 274, identifier:p; 275, argument_list; 275, 276; 276, identifier:data_b; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:C; 280, identifier:byref; 281, argument_list; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:C; 285, identifier:c_float; 286, argument_list; 286, 287; 287, call; 287, 288; 287, 289; 288, identifier:float; 289, argument_list; 289, 290; 290, identifier:time_bandwidth; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:C; 294, identifier:byref; 295, argument_list; 295, 296; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:C; 299, identifier:c_int; 300, argument_list; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:int; 303, argument_list; 303, 304; 304, identifier:number_of_tapers; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:C; 308, identifier:byref; 309, argument_list; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:C; 313, identifier:c_int; 314, argument_list; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:int; 317, argument_list; 317, 318; 318, identifier:nf; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:C; 322, identifier:byref; 323, argument_list; 323, 324; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:C; 327, identifier:c_int; 328, argument_list; 328, 329; 329, identifier:adaptive; 330, call; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:mt; 333, identifier:p; 334, argument_list; 334, 335; 335, identifier:freq; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:mt; 339, identifier:p; 340, argument_list; 340, 341; 341, identifier:tfun; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:mt; 345, identifier:p; 346, argument_list; 346, 347; 347, identifier:spec_ratio; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:mt; 351, identifier:p; 352, argument_list; 352, 353; 353, identifier:speci; 354, call; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:mt; 357, identifier:p; 358, argument_list; 358, 359; 359, identifier:specj; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:C; 363, identifier:byref; 364, argument_list; 364, 365; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:C; 368, identifier:c_int; 369, argument_list; 369, 370; 370, identifier:demean; 371, call; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:C; 374, identifier:byref; 375, argument_list; 375, 376; 376, call; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:C; 379, identifier:c_float; 380, argument_list; 380, 381; 381, identifier:fmax; 382, return_statement; 382, 383; 383, dictionary; 383, 384; 383, 387; 383, 390; 383, 393; 383, 396; 384, pair; 384, 385; 384, 386; 385, string:"frequencies"; 386, identifier:freq; 387, pair; 387, 388; 387, 389; 388, string:"deconvolved"; 389, identifier:tfun; 390, pair; 390, 391; 390, 392; 391, string:"spectral_ratio"; 392, identifier:spec_ratio; 393, pair; 393, 394; 393, 395; 394, string:"spectrum_a"; 395, identifier:speci; 396, pair; 396, 397; 396, 398; 397, string:"spectrum_b"; 398, identifier:specj | def mt_deconvolve(data_a, data_b, delta, nfft=None, time_bandwidth=None,
number_of_tapers=None, weights="adaptive", demean=True,
fmax=0.0):
npts = len(data_a)
if len(data_b) != npts:
raise ValueError("Input arrays must have the same length!")
if nfft is None:
nfft = npts
elif nfft < npts:
raise ValueError("nfft must be larger then the number of samples in "
"the array.")
mt = _MtspecType("float32")
if number_of_tapers is None:
number_of_tapers = int(2 * time_bandwidth) - 1
data_a = np.require(data_a, mt.float, requirements=[mt.order])
data_b = np.require(data_b, mt.float, requirements=[mt.order])
nf = nfft // 2 + 1
if demean:
demean = 1
else:
demean = 0
if weights == "constant":
adaptive = 1
elif weights == "adaptive":
adaptive = 0
else:
raise ValueError('Weights must be either "adaptive" or "constant".')
tfun = mt.empty(nfft)
freq = mt.empty(nf)
spec_ratio = mt.empty(nf)
speci = mt.empty(nf)
specj = mt.empty(nf)
mtspeclib.mt_deconv_(
C.byref(C.c_int(int(npts))),
C.byref(C.c_int(int(nfft))),
C.byref(C.c_float(float(delta))),
mt.p(data_a),
mt.p(data_b),
C.byref(C.c_float(float(time_bandwidth))),
C.byref(C.c_int(int(number_of_tapers))),
C.byref(C.c_int(int(nf))),
C.byref(C.c_int(adaptive)),
mt.p(freq),
mt.p(tfun),
mt.p(spec_ratio),
mt.p(speci),
mt.p(specj),
C.byref(C.c_int(demean)),
C.byref(C.c_float(fmax)))
return {
"frequencies": freq,
"deconvolved": tfun,
"spectral_ratio": spec_ratio,
"spectrum_a": speci,
"spectrum_b": specj
} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:create_server; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:loop; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:as_coroutine; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:protocol_factory; 13, None; 14, dictionary_splat_pattern; 14, 15; 15, identifier:server_config; 16, block; 16, 17; 16, 33; 16, 50; 16, 67; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:loop; 20, None; 21, block; 21, 22; 21, 25; 22, import_statement; 22, 23; 23, dotted_name; 23, 24; 24, identifier:asyncio; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:loop; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:asyncio; 31, identifier:get_event_loop; 32, argument_list; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:protocol_factory; 36, None; 37, block; 37, 38; 37, 44; 38, import_from_statement; 38, 39; 38, 42; 39, dotted_name; 39, 40; 39, 41; 40, identifier:growler; 41, identifier:aio; 42, dotted_name; 42, 43; 43, identifier:GrowlerHTTPProtocol; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:protocol_factory; 47, attribute; 47, 48; 47, 49; 48, identifier:GrowlerHTTPProtocol; 49, identifier:get_factory; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:create_server; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:loop; 56, identifier:create_server; 57, argument_list; 57, 58; 57, 65; 58, call; 58, 59; 58, 60; 59, identifier:protocol_factory; 60, argument_list; 60, 61; 60, 62; 61, identifier:self; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:loop; 64, identifier:loop; 65, dictionary_splat; 65, 66; 66, identifier:server_config; 67, if_statement; 67, 68; 67, 69; 67, 72; 68, identifier:as_coroutine; 69, block; 69, 70; 70, return_statement; 70, 71; 71, identifier:create_server; 72, else_clause; 72, 73; 73, block; 73, 74; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:loop; 78, identifier:run_until_complete; 79, argument_list; 79, 80; 80, identifier:create_server | def create_server(self,
loop=None,
as_coroutine=False,
protocol_factory=None,
**server_config):
if loop is None:
import asyncio
loop = asyncio.get_event_loop()
if protocol_factory is None:
from growler.aio import GrowlerHTTPProtocol
protocol_factory = GrowlerHTTPProtocol.get_factory
create_server = loop.create_server(
protocol_factory(self, loop=loop),
**server_config
)
if as_coroutine:
return create_server
else:
return loop.run_until_complete(create_server) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:event_emitter; 3, parameters; 3, 4; 3, 7; 3, 8; 4, default_parameter; 4, 5; 4, 6; 5, identifier:cls_; 6, None; 7, keyword_separator; 8, default_parameter; 8, 9; 8, 10; 9, identifier:events; 10, tuple; 10, 11; 11, string:'*'; 12, block; 12, 13; 12, 23; 12, 35; 12, 150; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:event_dict; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:dict; 19, identifier:fromkeys; 20, argument_list; 20, 21; 20, 22; 21, identifier:events; 22, list:[]; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:allow_any_eventname; 26, comparison_operator:==; 26, 27; 26, 34; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:event_dict; 30, identifier:pop; 31, argument_list; 31, 32; 31, 33; 32, string:'*'; 33, False; 34, list:[]; 35, function_definition; 35, 36; 35, 37; 35, 39; 36, function_name:_event_emitter; 37, parameters; 37, 38; 38, identifier:cls; 39, block; 39, 40; 39, 109; 39, 136; 39, 142; 39, 148; 40, function_definition; 40, 41; 40, 42; 40, 46; 41, function_name:on; 42, parameters; 42, 43; 42, 44; 42, 45; 43, identifier:self; 44, identifier:name; 45, identifier:callback; 46, block; 46, 47; 46, 67; 46, 107; 47, if_statement; 47, 48; 47, 59; 48, not_operator; 48, 49; 49, parenthesized_expression; 49, 50; 50, boolean_operator:or; 50, 51; 50, 55; 51, call; 51, 52; 51, 53; 52, identifier:callable; 53, argument_list; 53, 54; 54, identifier:callback; 55, call; 55, 56; 55, 57; 56, identifier:isawaitable; 57, argument_list; 57, 58; 58, identifier:callback; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:ValueError; 63, argument_list; 63, 64; 64, binary_operator:%; 64, 65; 64, 66; 65, string:"Callback not callable: %r"; 66, identifier:callback; 67, try_statement; 67, 68; 67, 78; 68, block; 68, 69; 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:event_dict; 74, identifier:name; 75, identifier:append; 76, argument_list; 76, 77; 77, identifier:callback; 78, except_clause; 78, 79; 78, 80; 79, identifier:KeyError; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 83; 81, 91; 82, identifier:allow_any_eventname; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:event_dict; 88, identifier:name; 89, list:[callback]; 89, 90; 90, identifier:callback; 91, else_clause; 91, 92; 92, block; 92, 93; 92, 102; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:msg; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, string:"Event Emitter has no event {!r}"; 99, identifier:format; 100, argument_list; 100, 101; 101, identifier:name; 102, raise_statement; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:KeyError; 105, argument_list; 105, 106; 106, identifier:msg; 107, return_statement; 107, 108; 108, identifier:self; 109, function_definition; 109, 110; 109, 111; 109, 114; 110, function_name:emit; 111, parameters; 111, 112; 111, 113; 112, identifier:self; 113, identifier:name; 114, block; 114, 115; 115, for_statement; 115, 116; 115, 117; 115, 120; 116, identifier:cb; 117, subscript; 117, 118; 117, 119; 118, identifier:event_dict; 119, identifier:name; 120, block; 120, 121; 121, if_statement; 121, 122; 121, 126; 121, 130; 122, call; 122, 123; 122, 124; 123, identifier:isawaitable; 124, argument_list; 124, 125; 125, identifier:cb; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, await; 128, 129; 129, identifier:cb; 130, else_clause; 130, 131; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:cb; 135, argument_list; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:cls; 140, identifier:on; 141, identifier:on; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:cls; 146, identifier:emit; 147, identifier:emit; 148, return_statement; 148, 149; 149, identifier:cls; 150, if_statement; 150, 151; 150, 154; 150, 157; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:cls_; 153, None; 154, block; 154, 155; 155, return_statement; 155, 156; 156, identifier:_event_emitter; 157, else_clause; 157, 158; 158, block; 158, 159; 159, return_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:_event_emitter; 162, argument_list; 162, 163; 163, identifier:cls_ | def event_emitter(cls_=None, *, events=('*', )):
event_dict = dict.fromkeys(events, [])
allow_any_eventname = event_dict.pop('*', False) == []
def _event_emitter(cls):
def on(self, name, callback):
if not (callable(callback) or isawaitable(callback)):
raise ValueError("Callback not callable: %r" % callback)
try:
event_dict[name].append(callback)
except KeyError:
if allow_any_eventname:
event_dict[name] = [callback]
else:
msg = "Event Emitter has no event {!r}".format(name)
raise KeyError(msg)
return self
async def emit(self, name):
for cb in event_dict[name]:
if isawaitable(cb):
await cb
else:
cb()
cls.on = on
cls.emit = emit
return cls
if cls_ is None:
return _event_emitter
else:
return _event_emitter(cls_) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_build_production_name; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:glyph; 6, block; 6, 7; 6, 32; 6, 38; 6, 56; 6, 68; 6, 103; 6, 115; 6, 157; 6, 237; 7, if_statement; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:_postscriptNames; 11, block; 11, 12; 11, 25; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:production_name; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_postscriptNames; 20, identifier:get; 21, argument_list; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:glyph; 24, identifier:name; 25, return_statement; 25, 26; 26, conditional_expression:if; 26, 27; 26, 28; 26, 29; 27, identifier:production_name; 28, identifier:production_name; 29, attribute; 29, 30; 29, 31; 30, identifier:glyph; 31, identifier:name; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:unicode_val; 35, attribute; 35, 36; 35, 37; 36, identifier:glyph; 37, identifier:unicode; 38, if_statement; 38, 39; 38, 44; 39, comparison_operator:is; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:glyph; 42, identifier:unicode; 43, None; 44, block; 44, 45; 45, return_statement; 45, 46; 46, binary_operator:%; 46, 47; 46, 48; 47, string:'%s%04X'; 48, tuple; 48, 49; 48, 55; 49, conditional_expression:if; 49, 50; 49, 51; 49, 54; 50, string:'u'; 51, comparison_operator:>; 51, 52; 51, 53; 52, identifier:unicode_val; 53, integer:0xffff; 54, string:'uni'; 55, identifier:unicode_val; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:parts; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:glyph; 63, identifier:name; 64, identifier:rsplit; 65, argument_list; 65, 66; 65, 67; 66, string:'.'; 67, integer:1; 68, if_statement; 68, 69; 68, 83; 69, boolean_operator:and; 69, 70; 69, 76; 70, comparison_operator:==; 70, 71; 70, 75; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:parts; 75, integer:2; 76, comparison_operator:in; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:parts; 79, integer:0; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:glyphSet; 83, block; 83, 84; 84, return_statement; 84, 85; 85, binary_operator:%; 85, 86; 85, 87; 86, string:'%s.%s'; 87, tuple; 87, 88; 87, 100; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_build_production_name; 92, argument_list; 92, 93; 93, subscript; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:glyphSet; 97, subscript; 97, 98; 97, 99; 98, identifier:parts; 99, integer:0; 100, subscript; 100, 101; 100, 102; 101, identifier:parts; 102, integer:1; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:parts; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:glyph; 110, identifier:name; 111, identifier:split; 112, argument_list; 112, 113; 112, 114; 113, string:'.'; 114, integer:1; 115, if_statement; 115, 116; 115, 122; 115, 144; 116, comparison_operator:==; 116, 117; 116, 121; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, identifier:parts; 121, integer:2; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:liga_parts; 126, list_comprehension; 126, 127; 126, 134; 127, binary_operator:%; 127, 128; 127, 129; 128, string:'%s.%s'; 129, tuple; 129, 130; 129, 131; 130, identifier:n; 131, subscript; 131, 132; 131, 133; 132, identifier:parts; 133, integer:1; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:n; 136, call; 136, 137; 136, 142; 137, attribute; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:parts; 140, integer:0; 141, identifier:split; 142, argument_list; 142, 143; 143, string:'_'; 144, else_clause; 144, 145; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:liga_parts; 149, call; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:glyph; 153, identifier:name; 154, identifier:split; 155, argument_list; 155, 156; 156, string:'_'; 157, if_statement; 157, 158; 157, 176; 158, boolean_operator:and; 158, 159; 158, 165; 159, comparison_operator:>; 159, 160; 159, 164; 160, call; 160, 161; 160, 162; 161, identifier:len; 162, argument_list; 162, 163; 163, identifier:liga_parts; 164, integer:1; 165, call; 165, 166; 165, 167; 166, identifier:all; 167, generator_expression; 167, 168; 167, 173; 168, comparison_operator:in; 168, 169; 168, 170; 169, identifier:n; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:glyphSet; 173, for_in_clause; 173, 174; 173, 175; 174, identifier:n; 175, identifier:liga_parts; 176, block; 176, 177; 176, 191; 176, 218; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:unicode_vals; 180, list_comprehension; 180, 181; 180, 188; 181, attribute; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:glyphSet; 186, identifier:n; 187, identifier:unicode; 188, for_in_clause; 188, 189; 188, 190; 189, identifier:n; 190, identifier:liga_parts; 191, if_statement; 191, 192; 191, 203; 192, call; 192, 193; 192, 194; 193, identifier:all; 194, generator_expression; 194, 195; 194, 200; 195, boolean_operator:and; 195, 196; 195, 197; 196, identifier:v; 197, comparison_operator:<=; 197, 198; 197, 199; 198, identifier:v; 199, integer:0xffff; 200, for_in_clause; 200, 201; 200, 202; 201, identifier:v; 202, identifier:unicode_vals; 203, block; 203, 204; 204, return_statement; 204, 205; 205, binary_operator:+; 205, 206; 205, 207; 206, string:'uni'; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, string:''; 210, identifier:join; 211, generator_expression; 211, 212; 211, 215; 212, binary_operator:%; 212, 213; 212, 214; 213, string:'%04X'; 214, identifier:v; 215, for_in_clause; 215, 216; 215, 217; 216, identifier:v; 217, identifier:unicode_vals; 218, return_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, string:'_'; 222, identifier:join; 223, generator_expression; 223, 224; 223, 234; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:_build_production_name; 228, argument_list; 228, 229; 229, subscript; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:glyphSet; 233, identifier:n; 234, for_in_clause; 234, 235; 234, 236; 235, identifier:n; 236, identifier:liga_parts; 237, return_statement; 237, 238; 238, attribute; 238, 239; 238, 240; 239, identifier:glyph; 240, identifier:name | def _build_production_name(self, glyph):
if self._postscriptNames:
production_name = self._postscriptNames.get(glyph.name)
return production_name if production_name else glyph.name
unicode_val = glyph.unicode
if glyph.unicode is not None:
return '%s%04X' % (
'u' if unicode_val > 0xffff else 'uni', unicode_val)
parts = glyph.name.rsplit('.', 1)
if len(parts) == 2 and parts[0] in self.glyphSet:
return '%s.%s' % (
self._build_production_name(self.glyphSet[parts[0]]), parts[1])
parts = glyph.name.split('.', 1)
if len(parts) == 2:
liga_parts = ['%s.%s' % (n, parts[1]) for n in parts[0].split('_')]
else:
liga_parts = glyph.name.split('_')
if len(liga_parts) > 1 and all(n in self.glyphSet for n in liga_parts):
unicode_vals = [self.glyphSet[n].unicode for n in liga_parts]
if all(v and v <= 0xffff for v in unicode_vals):
return 'uni' + ''.join('%04X' % v for v in unicode_vals)
return '_'.join(
self._build_production_name(self.glyphSet[n]) for n in liga_parts)
return glyph.name |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:makeOfficialGlyphOrder; 3, parameters; 3, 4; 3, 5; 4, identifier:font; 5, default_parameter; 5, 6; 5, 7; 6, identifier:glyphOrder; 7, None; 8, block; 8, 9; 8, 23; 8, 34; 8, 38; 8, 57; 8, 81; 8, 91; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:glyphOrder; 12, None; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:glyphOrder; 17, call; 17, 18; 17, 19; 18, identifier:getattr; 19, argument_list; 19, 20; 19, 21; 19, 22; 20, identifier:font; 21, string:"glyphOrder"; 22, tuple; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:names; 26, call; 26, 27; 26, 28; 27, identifier:set; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:font; 32, identifier:keys; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:order; 37, list:[]; 38, if_statement; 38, 39; 38, 42; 39, comparison_operator:in; 39, 40; 39, 41; 40, string:".notdef"; 41, identifier:names; 42, block; 42, 43; 42, 50; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:names; 47, identifier:remove; 48, argument_list; 48, 49; 49, string:".notdef"; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:order; 54, identifier:append; 55, argument_list; 55, 56; 56, string:".notdef"; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:name; 59, identifier:glyphOrder; 60, block; 60, 61; 60, 67; 60, 74; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:not; 62, 63; 62, 64; 63, identifier:name; 64, identifier:names; 65, block; 65, 66; 66, continue_statement; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:names; 71, identifier:remove; 72, argument_list; 72, 73; 73, identifier:name; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:order; 78, identifier:append; 79, argument_list; 79, 80; 80, identifier:name; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:order; 85, identifier:extend; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:sorted; 89, argument_list; 89, 90; 90, identifier:names; 91, return_statement; 91, 92; 92, identifier:order | def makeOfficialGlyphOrder(font, glyphOrder=None):
if glyphOrder is None:
glyphOrder = getattr(font, "glyphOrder", ())
names = set(font.keys())
order = []
if ".notdef" in names:
names.remove(".notdef")
order.append(".notdef")
for name in glyphOrder:
if name not in names:
continue
names.remove(name)
order.append(name)
order.extend(sorted(names))
return order |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:from_layer; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:cls; 5, identifier:font; 6, default_parameter; 6, 7; 6, 8; 7, identifier:layerName; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:copy; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:skipExportGlyphs; 14, None; 15, block; 15, 16; 15, 39; 15, 87; 15, 190; 15, 203; 16, if_statement; 16, 17; 16, 20; 16, 29; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:layerName; 19, None; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:layer; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:font; 27, identifier:layers; 28, identifier:layerName; 29, else_clause; 29, 30; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:layer; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:font; 37, identifier:layers; 38, identifier:defaultLayer; 39, if_statement; 39, 40; 39, 41; 39, 63; 40, identifier:copy; 41, block; 41, 42; 41, 52; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:self; 45, call; 45, 46; 45, 47; 46, identifier:_copyLayer; 47, argument_list; 47, 48; 47, 49; 48, identifier:layer; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:obj_type; 51, identifier:cls; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:lib; 57, call; 57, 58; 57, 59; 58, identifier:deepcopy; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:layer; 62, identifier:lib; 63, else_clause; 63, 64; 64, block; 64, 65; 64, 79; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:self; 68, call; 68, 69; 68, 70; 69, identifier:cls; 70, generator_expression; 70, 71; 70, 76; 71, tuple; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:g; 74, identifier:name; 75, identifier:g; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:g; 78, identifier:layer; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:lib; 84, attribute; 84, 85; 84, 86; 85, identifier:layer; 86, identifier:lib; 87, if_statement; 87, 88; 87, 89; 88, identifier:skipExportGlyphs; 89, block; 89, 90; 89, 177; 90, for_statement; 90, 91; 90, 92; 90, 97; 91, identifier:glyph; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:values; 96, argument_list; 97, block; 97, 98; 98, if_statement; 98, 99; 98, 112; 99, call; 99, 100; 99, 101; 100, identifier:any; 101, generator_expression; 101, 102; 101, 107; 102, comparison_operator:in; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:c; 105, identifier:baseGlyph; 106, identifier:skipExportGlyphs; 107, for_in_clause; 107, 108; 107, 109; 108, identifier:c; 109, attribute; 109, 110; 109, 111; 110, identifier:glyph; 111, identifier:components; 112, block; 112, 113; 112, 124; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:deepCopyContours; 116, argument_list; 116, 117; 116, 118; 116, 119; 116, 120; 116, 123; 117, identifier:self; 118, identifier:glyph; 119, identifier:glyph; 120, call; 120, 121; 120, 122; 121, identifier:Transform; 122, argument_list; 123, identifier:skipExportGlyphs; 124, if_statement; 124, 125; 124, 130; 124, 154; 125, call; 125, 126; 125, 127; 126, identifier:hasattr; 127, argument_list; 127, 128; 127, 129; 128, identifier:glyph; 129, string:"removeComponent"; 130, block; 130, 131; 131, for_statement; 131, 132; 131, 133; 131, 146; 132, identifier:c; 133, list_comprehension; 133, 134; 133, 135; 133, 140; 134, identifier:component; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:component; 137, attribute; 137, 138; 137, 139; 138, identifier:glyph; 139, identifier:components; 140, if_clause; 140, 141; 141, comparison_operator:in; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:component; 144, identifier:baseGlyph; 145, identifier:skipExportGlyphs; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:glyph; 151, identifier:removeComponent; 152, argument_list; 152, 153; 153, identifier:c; 154, else_clause; 154, 155; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 164; 158, subscript; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:glyph; 161, identifier:components; 162, slice; 162, 163; 163, colon; 164, list_comprehension; 164, 165; 164, 166; 164, 171; 165, identifier:c; 166, for_in_clause; 166, 167; 166, 168; 167, identifier:c; 168, attribute; 168, 169; 168, 170; 169, identifier:glyph; 170, identifier:components; 171, if_clause; 171, 172; 172, comparison_operator:not; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:c; 175, identifier:baseGlyph; 176, identifier:skipExportGlyphs; 177, for_statement; 177, 178; 177, 179; 177, 180; 178, identifier:glyph_name; 179, identifier:skipExportGlyphs; 180, block; 180, 181; 181, if_statement; 181, 182; 181, 185; 182, comparison_operator:in; 182, 183; 182, 184; 183, identifier:glyph_name; 184, identifier:self; 185, block; 185, 186; 186, delete_statement; 186, 187; 187, subscript; 187, 188; 187, 189; 188, identifier:self; 189, identifier:glyph_name; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:self; 194, identifier:name; 195, conditional_expression:if; 195, 196; 195, 199; 195, 202; 196, attribute; 196, 197; 196, 198; 197, identifier:layer; 198, identifier:name; 199, comparison_operator:is; 199, 200; 199, 201; 200, identifier:layerName; 201, None; 202, None; 203, return_statement; 203, 204; 204, identifier:self | def from_layer(cls, font, layerName=None, copy=False, skipExportGlyphs=None):
if layerName is not None:
layer = font.layers[layerName]
else:
layer = font.layers.defaultLayer
if copy:
self = _copyLayer(layer, obj_type=cls)
self.lib = deepcopy(layer.lib)
else:
self = cls((g.name, g) for g in layer)
self.lib = layer.lib
if skipExportGlyphs:
for glyph in self.values():
if any(c.baseGlyph in skipExportGlyphs for c in glyph.components):
deepCopyContours(self, glyph, glyph, Transform(), skipExportGlyphs)
if hasattr(glyph, "removeComponent"):
for c in [
component
for component in glyph.components
if component.baseGlyph in skipExportGlyphs
]:
glyph.removeComponent(c)
else:
glyph.components[:] = [
c
for c in glyph.components
if c.baseGlyph not in skipExportGlyphs
]
for glyph_name in skipExportGlyphs:
if glyph_name in self:
del self[glyph_name]
self.name = layer.name if layerName is not None else None
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:compileInterpolatableTTFs; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 4, identifier:ufos; 5, default_parameter; 5, 6; 5, 7; 6, identifier:preProcessorClass; 7, identifier:TTFInterpolatablePreProcessor; 8, default_parameter; 8, 9; 8, 10; 9, identifier:outlineCompilerClass; 10, identifier:OutlineTTFCompiler; 11, default_parameter; 11, 12; 11, 13; 12, identifier:featureCompilerClass; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:featureWriters; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:glyphOrder; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:useProductionNames; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:cubicConversionError; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:reverseDirection; 28, True; 29, default_parameter; 29, 30; 29, 31; 30, identifier:inplace; 31, False; 32, default_parameter; 32, 33; 32, 34; 33, identifier:layerNames; 34, None; 35, default_parameter; 35, 36; 35, 37; 36, identifier:skipExportGlyphs; 37, None; 38, block; 38, 39; 38, 45; 38, 60; 38, 70; 38, 100; 38, 107; 38, 129; 38, 137; 39, import_from_statement; 39, 40; 39, 43; 40, dotted_name; 40, 41; 40, 42; 41, identifier:ufo2ft; 42, identifier:util; 43, dotted_name; 43, 44; 44, identifier:_LazyFontName; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:layerNames; 48, None; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:layerNames; 53, binary_operator:*; 53, 54; 53, 56; 54, list:[None]; 54, 55; 55, None; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:ufos; 60, assert_statement; 60, 61; 61, comparison_operator:==; 61, 62; 61, 66; 62, call; 62, 63; 62, 64; 63, identifier:len; 64, argument_list; 64, 65; 65, identifier:ufos; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:layerNames; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:skipExportGlyphs; 73, None; 74, block; 74, 75; 74, 81; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:skipExportGlyphs; 78, call; 78, 79; 78, 80; 79, identifier:set; 80, argument_list; 81, for_statement; 81, 82; 81, 83; 81, 84; 82, identifier:ufo; 83, identifier:ufos; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:skipExportGlyphs; 89, identifier:update; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:ufo; 95, identifier:lib; 96, identifier:get; 97, argument_list; 97, 98; 97, 99; 98, string:"public.skipExportGlyphs"; 99, list:[]; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:logger; 104, identifier:info; 105, argument_list; 105, 106; 106, string:"Pre-processing glyphs"; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:preProcessor; 110, call; 110, 111; 110, 112; 111, identifier:preProcessorClass; 112, argument_list; 112, 113; 112, 114; 112, 117; 112, 120; 112, 123; 112, 126; 113, identifier:ufos; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:inplace; 116, identifier:inplace; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:conversionError; 119, identifier:cubicConversionError; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:reverseDirection; 122, identifier:reverseDirection; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:layerNames; 125, identifier:layerNames; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:skipExportGlyphs; 128, identifier:skipExportGlyphs; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:glyphSets; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:preProcessor; 135, identifier:process; 136, argument_list; 137, for_statement; 137, 138; 137, 142; 137, 148; 138, pattern_list; 138, 139; 138, 140; 138, 141; 139, identifier:ufo; 140, identifier:glyphSet; 141, identifier:layerName; 142, call; 142, 143; 142, 144; 143, identifier:zip; 144, argument_list; 144, 145; 144, 146; 144, 147; 145, identifier:ufos; 146, identifier:glyphSets; 147, identifier:layerNames; 148, block; 148, 149; 148, 156; 148, 180; 148, 199; 148, 207; 148, 227; 148, 238; 148, 247; 148, 270; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:fontName; 152, call; 152, 153; 152, 154; 153, identifier:_LazyFontName; 154, argument_list; 154, 155; 155, identifier:ufo; 156, if_statement; 156, 157; 156, 160; 156, 170; 157, comparison_operator:is; 157, 158; 157, 159; 158, identifier:layerName; 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:logger; 165, identifier:info; 166, argument_list; 166, 167; 166, 168; 166, 169; 167, string:"Building OpenType tables for %s-%s"; 168, identifier:fontName; 169, identifier:layerName; 170, else_clause; 170, 171; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:logger; 176, identifier:info; 177, argument_list; 177, 178; 177, 179; 178, string:"Building OpenType tables for %s"; 179, identifier:fontName; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:outlineCompiler; 183, call; 183, 184; 183, 185; 184, identifier:outlineCompilerClass; 185, argument_list; 185, 186; 185, 187; 185, 190; 185, 193; 186, identifier:ufo; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:glyphSet; 189, identifier:glyphSet; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:glyphOrder; 192, identifier:glyphOrder; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:tables; 195, conditional_expression:if; 195, 196; 195, 197; 195, 198; 196, identifier:SPARSE_TTF_MASTER_TABLES; 197, identifier:layerName; 198, None; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:ttf; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:outlineCompiler; 205, identifier:compile; 206, argument_list; 207, if_statement; 207, 208; 207, 211; 208, comparison_operator:is; 208, 209; 208, 210; 209, identifier:layerName; 210, None; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 215; 214, identifier:compileFeatures; 215, argument_list; 215, 216; 215, 217; 215, 218; 215, 221; 215, 224; 216, identifier:ufo; 217, identifier:ttf; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:glyphSet; 220, identifier:glyphSet; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:featureWriters; 223, identifier:featureWriters; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:featureCompilerClass; 226, identifier:featureCompilerClass; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:postProcessor; 230, call; 230, 231; 230, 232; 231, identifier:PostProcessor; 232, argument_list; 232, 233; 232, 234; 232, 235; 233, identifier:ttf; 234, identifier:ufo; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:glyphSet; 237, identifier:glyphSet; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:ttf; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:postProcessor; 244, identifier:process; 245, argument_list; 245, 246; 246, identifier:useProductionNames; 247, if_statement; 247, 248; 247, 251; 248, comparison_operator:is; 248, 249; 248, 250; 249, identifier:layerName; 250, None; 251, block; 251, 252; 251, 261; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 259; 254, attribute; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:ttf; 257, string:"post"; 258, identifier:underlinePosition; 259, unary_operator:-; 259, 260; 260, integer:0x8000; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 268; 263, attribute; 263, 264; 263, 267; 264, subscript; 264, 265; 264, 266; 265, identifier:ttf; 266, string:"post"; 267, identifier:underlineThickness; 268, unary_operator:-; 268, 269; 269, integer:0x8000; 270, expression_statement; 270, 271; 271, yield; 271, 272; 272, identifier:ttf | def compileInterpolatableTTFs(
ufos,
preProcessorClass=TTFInterpolatablePreProcessor,
outlineCompilerClass=OutlineTTFCompiler,
featureCompilerClass=None,
featureWriters=None,
glyphOrder=None,
useProductionNames=None,
cubicConversionError=None,
reverseDirection=True,
inplace=False,
layerNames=None,
skipExportGlyphs=None,
):
from ufo2ft.util import _LazyFontName
if layerNames is None:
layerNames = [None] * len(ufos)
assert len(ufos) == len(layerNames)
if skipExportGlyphs is None:
skipExportGlyphs = set()
for ufo in ufos:
skipExportGlyphs.update(ufo.lib.get("public.skipExportGlyphs", []))
logger.info("Pre-processing glyphs")
preProcessor = preProcessorClass(
ufos,
inplace=inplace,
conversionError=cubicConversionError,
reverseDirection=reverseDirection,
layerNames=layerNames,
skipExportGlyphs=skipExportGlyphs,
)
glyphSets = preProcessor.process()
for ufo, glyphSet, layerName in zip(ufos, glyphSets, layerNames):
fontName = _LazyFontName(ufo)
if layerName is not None:
logger.info("Building OpenType tables for %s-%s", fontName, layerName)
else:
logger.info("Building OpenType tables for %s", fontName)
outlineCompiler = outlineCompilerClass(
ufo,
glyphSet=glyphSet,
glyphOrder=glyphOrder,
tables=SPARSE_TTF_MASTER_TABLES if layerName else None,
)
ttf = outlineCompiler.compile()
if layerName is None:
compileFeatures(
ufo,
ttf,
glyphSet=glyphSet,
featureWriters=featureWriters,
featureCompilerClass=featureCompilerClass,
)
postProcessor = PostProcessor(ttf, ufo, glyphSet=glyphSet)
ttf = postProcessor.process(useProductionNames)
if layerName is not None:
ttf["post"].underlinePosition = -0x8000
ttf["post"].underlineThickness = -0x8000
yield ttf |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_propagate_glyph_anchors; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:glyphSet; 5, identifier:composite; 6, identifier:processed; 7, block; 7, 8; 7, 16; 7, 25; 7, 32; 7, 36; 7, 40; 7, 46; 7, 50; 7, 143; 7, 222; 7, 253; 7, 264; 8, if_statement; 8, 9; 8, 14; 9, comparison_operator:in; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:composite; 12, identifier:name; 13, identifier:processed; 14, block; 14, 15; 15, return_statement; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:processed; 20, identifier:add; 21, argument_list; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:composite; 24, identifier:name; 25, if_statement; 25, 26; 25, 30; 26, not_operator; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:composite; 29, identifier:components; 30, block; 30, 31; 31, return_statement; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:base_components; 35, list:[]; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:mark_components; 39, list:[]; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:anchor_names; 43, call; 43, 44; 43, 45; 44, identifier:set; 45, argument_list; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:to_add; 49, dictionary; 50, for_statement; 50, 51; 50, 52; 50, 55; 51, identifier:component; 52, attribute; 52, 53; 52, 54; 53, identifier:composite; 54, identifier:components; 55, block; 55, 56; 56, try_statement; 56, 57; 56, 66; 56, 88; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:glyph; 61, subscript; 61, 62; 61, 63; 62, identifier:glyphSet; 63, attribute; 63, 64; 63, 65; 64, identifier:component; 65, identifier:baseGlyph; 66, except_clause; 66, 67; 66, 68; 67, identifier:KeyError; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:logger; 73, identifier:warning; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, concatenated_string; 77, 78; 77, 79; 78, string:'Anchors not propagated for inexistent component {} '; 79, string:'in glyph {}'; 80, identifier:format; 81, argument_list; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:component; 84, identifier:baseGlyph; 85, attribute; 85, 86; 85, 87; 86, identifier:composite; 87, identifier:name; 88, else_clause; 88, 89; 89, block; 89, 90; 89, 97; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:_propagate_glyph_anchors; 93, argument_list; 93, 94; 93, 95; 93, 96; 94, identifier:glyphSet; 95, identifier:glyph; 96, identifier:processed; 97, if_statement; 97, 98; 97, 114; 97, 122; 98, call; 98, 99; 98, 100; 99, identifier:any; 100, generator_expression; 100, 101; 100, 109; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:a; 105, identifier:name; 106, identifier:startswith; 107, argument_list; 107, 108; 108, string:'_'; 109, for_in_clause; 109, 110; 109, 111; 110, identifier:a; 111, attribute; 111, 112; 111, 113; 112, identifier:glyph; 113, identifier:anchors; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:mark_components; 119, identifier:append; 120, argument_list; 120, 121; 121, identifier:component; 122, else_clause; 122, 123; 123, block; 123, 124; 123, 131; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:base_components; 128, identifier:append; 129, argument_list; 129, 130; 130, identifier:component; 131, expression_statement; 131, 132; 132, augmented_assignment:|=; 132, 133; 132, 134; 133, identifier:anchor_names; 134, set_comprehension; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:a; 137, identifier:name; 138, for_in_clause; 138, 139; 138, 140; 139, identifier:a; 140, attribute; 140, 141; 140, 142; 141, identifier:glyph; 142, identifier:anchors; 143, if_statement; 143, 144; 143, 153; 144, boolean_operator:and; 144, 145; 144, 149; 145, boolean_operator:and; 145, 146; 145, 147; 146, identifier:mark_components; 147, not_operator; 147, 148; 148, identifier:base_components; 149, call; 149, 150; 149, 151; 150, identifier:_is_ligature_mark; 151, argument_list; 151, 152; 152, identifier:composite; 153, block; 153, 154; 153, 188; 153, 195; 153, 202; 153, 210; 154, try_statement; 154, 155; 154, 164; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:component; 159, call; 159, 160; 159, 161; 160, identifier:_component_closest_to_origin; 161, argument_list; 161, 162; 161, 163; 162, identifier:mark_components; 163, identifier:glyphSet; 164, except_clause; 164, 165; 164, 169; 165, as_pattern; 165, 166; 165, 167; 166, identifier:Exception; 167, as_pattern_target; 167, 168; 168, identifier:e; 169, block; 169, 170; 170, raise_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:Exception; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 180; 175, attribute; 175, 176; 175, 179; 176, concatenated_string; 176, 177; 176, 178; 177, string:"Error while determining which component of composite "; 178, string:"'{}' is the lowest: {}"; 179, identifier:format; 180, argument_list; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:composite; 183, identifier:name; 184, call; 184, 185; 184, 186; 185, identifier:str; 186, argument_list; 186, 187; 187, identifier:e; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:mark_components; 192, identifier:remove; 193, argument_list; 193, 194; 194, identifier:component; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:base_components; 199, identifier:append; 200, argument_list; 200, 201; 201, identifier:component; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:glyph; 205, subscript; 205, 206; 205, 207; 206, identifier:glyphSet; 207, attribute; 207, 208; 207, 209; 208, identifier:component; 209, identifier:baseGlyph; 210, expression_statement; 210, 211; 211, augmented_assignment:|=; 211, 212; 211, 213; 212, identifier:anchor_names; 213, set_comprehension; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:a; 216, identifier:name; 217, for_in_clause; 217, 218; 217, 219; 218, identifier:a; 219, attribute; 219, 220; 219, 221; 220, identifier:glyph; 221, identifier:anchors; 222, for_statement; 222, 223; 222, 224; 222, 225; 223, identifier:anchor_name; 224, identifier:anchor_names; 225, block; 225, 226; 226, if_statement; 226, 227; 226, 244; 227, not_operator; 227, 228; 228, call; 228, 229; 228, 230; 229, identifier:any; 230, generator_expression; 230, 231; 230, 239; 231, call; 231, 232; 231, 237; 232, attribute; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:a; 235, identifier:name; 236, identifier:startswith; 237, argument_list; 237, 238; 238, identifier:anchor_name; 239, for_in_clause; 239, 240; 239, 241; 240, identifier:a; 241, attribute; 241, 242; 241, 243; 242, identifier:composite; 243, identifier:anchors; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:_get_anchor_data; 248, argument_list; 248, 249; 248, 250; 248, 251; 248, 252; 249, identifier:to_add; 250, identifier:glyphSet; 251, identifier:base_components; 252, identifier:anchor_name; 253, for_statement; 253, 254; 253, 255; 253, 256; 254, identifier:component; 255, identifier:mark_components; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:_adjust_anchors; 260, argument_list; 260, 261; 260, 262; 260, 263; 261, identifier:to_add; 262, identifier:glyphSet; 263, identifier:component; 264, for_statement; 264, 265; 264, 270; 264, 278; 265, pattern_list; 265, 266; 265, 267; 266, identifier:name; 267, tuple_pattern; 267, 268; 267, 269; 268, identifier:x; 269, identifier:y; 270, call; 270, 271; 270, 272; 271, identifier:sorted; 272, argument_list; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:to_add; 276, identifier:items; 277, argument_list; 278, block; 278, 279; 278, 292; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:anchor_dict; 282, dictionary; 282, 283; 282, 286; 282, 289; 283, pair; 283, 284; 283, 285; 284, string:'name'; 285, identifier:name; 286, pair; 286, 287; 286, 288; 287, string:'x'; 288, identifier:x; 289, pair; 289, 290; 289, 291; 290, string:'y'; 291, identifier:y; 292, try_statement; 292, 293; 292, 301; 293, block; 293, 294; 294, expression_statement; 294, 295; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:composite; 298, identifier:appendAnchor; 299, argument_list; 299, 300; 300, identifier:anchor_dict; 301, except_clause; 301, 302; 301, 303; 302, identifier:TypeError; 303, block; 303, 304; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:composite; 308, identifier:appendAnchor; 309, argument_list; 309, 310; 309, 311; 310, identifier:name; 311, tuple; 311, 312; 311, 313; 312, identifier:x; 313, identifier:y | def _propagate_glyph_anchors(glyphSet, composite, processed):
if composite.name in processed:
return
processed.add(composite.name)
if not composite.components:
return
base_components = []
mark_components = []
anchor_names = set()
to_add = {}
for component in composite.components:
try:
glyph = glyphSet[component.baseGlyph]
except KeyError:
logger.warning(
'Anchors not propagated for inexistent component {} '
'in glyph {}'.format(component.baseGlyph, composite.name))
else:
_propagate_glyph_anchors(glyphSet, glyph, processed)
if any(a.name.startswith('_') for a in glyph.anchors):
mark_components.append(component)
else:
base_components.append(component)
anchor_names |= {a.name for a in glyph.anchors}
if mark_components and not base_components and _is_ligature_mark(composite):
try:
component = _component_closest_to_origin(mark_components, glyphSet)
except Exception as e:
raise Exception(
"Error while determining which component of composite "
"'{}' is the lowest: {}".format(composite.name, str(e))
)
mark_components.remove(component)
base_components.append(component)
glyph = glyphSet[component.baseGlyph]
anchor_names |= {a.name for a in glyph.anchors}
for anchor_name in anchor_names:
if not any(a.name.startswith(anchor_name) for a in composite.anchors):
_get_anchor_data(to_add, glyphSet, base_components, anchor_name)
for component in mark_components:
_adjust_anchors(to_add, glyphSet, component)
for name, (x, y) in sorted(to_add.items()):
anchor_dict = {'name': name, 'x': x, 'y': y}
try:
composite.appendAnchor(anchor_dict)
except TypeError:
composite.appendAnchor(name, (x, y)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:setupTable_name; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 20; 5, 33; 5, 39; 5, 96; 5, 106; 5, 120; 5, 130; 5, 140; 5, 148; 5, 275; 5, 288; 5, 301; 5, 317; 6, if_statement; 6, 7; 6, 12; 7, comparison_operator:not; 7, 8; 7, 9; 8, string:"name"; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:tables; 12, block; 12, 13; 13, return_statement; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:font; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:ufo; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 27; 22, subscript; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:otf; 26, string:"name"; 27, assignment; 27, 28; 27, 29; 28, identifier:name; 29, call; 29, 30; 29, 31; 30, identifier:newTable; 31, argument_list; 31, 32; 32, string:"name"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:name; 37, identifier:names; 38, list:[]; 39, for_statement; 39, 40; 39, 41; 39, 48; 40, identifier:nameRecord; 41, call; 41, 42; 41, 43; 42, identifier:getAttrWithFallback; 43, argument_list; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:font; 46, identifier:info; 47, string:"openTypeNameRecords"; 48, block; 48, 49; 48, 55; 48, 61; 48, 67; 48, 73; 48, 85; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:nameId; 52, subscript; 52, 53; 52, 54; 53, identifier:nameRecord; 54, string:"nameID"; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:platformId; 58, subscript; 58, 59; 58, 60; 59, identifier:nameRecord; 60, string:"platformID"; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:platEncId; 64, subscript; 64, 65; 64, 66; 65, identifier:nameRecord; 66, string:"encodingID"; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:langId; 70, subscript; 70, 71; 70, 72; 71, identifier:nameRecord; 72, string:"languageID"; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:nameVal; 76, call; 76, 77; 76, 78; 77, identifier:tounicode; 78, argument_list; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:nameRecord; 81, string:"string"; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:encoding; 84, string:'ascii'; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:name; 89, identifier:setName; 90, argument_list; 90, 91; 90, 92; 90, 93; 90, 94; 90, 95; 91, identifier:nameVal; 92, identifier:nameId; 93, identifier:platformId; 94, identifier:platEncId; 95, identifier:langId; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:familyName; 99, call; 99, 100; 99, 101; 100, identifier:getAttrWithFallback; 101, argument_list; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:font; 104, identifier:info; 105, string:"styleMapFamilyName"; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:styleName; 109, call; 109, 110; 109, 119; 110, attribute; 110, 111; 110, 118; 111, call; 111, 112; 111, 113; 112, identifier:getAttrWithFallback; 113, argument_list; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:font; 116, identifier:info; 117, string:"styleMapStyleName"; 118, identifier:title; 119, argument_list; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:preferredFamilyName; 123, call; 123, 124; 123, 125; 124, identifier:getAttrWithFallback; 125, argument_list; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:font; 128, identifier:info; 129, string:"openTypeNamePreferredFamilyName"; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:preferredSubfamilyName; 133, call; 133, 134; 133, 135; 134, identifier:getAttrWithFallback; 135, argument_list; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:font; 138, identifier:info; 139, string:"openTypeNamePreferredSubfamilyName"; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:fullName; 143, binary_operator:%; 143, 144; 143, 145; 144, string:"%s %s"; 145, tuple; 145, 146; 145, 147; 146, identifier:preferredFamilyName; 147, identifier:preferredSubfamilyName; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:nameVals; 151, dictionary; 151, 152; 151, 161; 151, 164; 151, 167; 151, 176; 151, 179; 151, 188; 151, 197; 151, 206; 151, 215; 151, 224; 151, 233; 151, 242; 151, 251; 151, 260; 151, 269; 151, 272; 152, pair; 152, 153; 152, 154; 153, integer:0; 154, call; 154, 155; 154, 156; 155, identifier:getAttrWithFallback; 156, argument_list; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:font; 159, identifier:info; 160, string:"copyright"; 161, pair; 161, 162; 161, 163; 162, integer:1; 163, identifier:familyName; 164, pair; 164, 165; 164, 166; 165, integer:2; 166, identifier:styleName; 167, pair; 167, 168; 167, 169; 168, integer:3; 169, call; 169, 170; 169, 171; 170, identifier:getAttrWithFallback; 171, argument_list; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:font; 174, identifier:info; 175, string:"openTypeNameUniqueID"; 176, pair; 176, 177; 176, 178; 177, integer:4; 178, identifier:fullName; 179, pair; 179, 180; 179, 181; 180, integer:5; 181, call; 181, 182; 181, 183; 182, identifier:getAttrWithFallback; 183, argument_list; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:font; 186, identifier:info; 187, string:"openTypeNameVersion"; 188, pair; 188, 189; 188, 190; 189, integer:6; 190, call; 190, 191; 190, 192; 191, identifier:getAttrWithFallback; 192, argument_list; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:font; 195, identifier:info; 196, string:"postscriptFontName"; 197, pair; 197, 198; 197, 199; 198, integer:7; 199, call; 199, 200; 199, 201; 200, identifier:getAttrWithFallback; 201, argument_list; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:font; 204, identifier:info; 205, string:"trademark"; 206, pair; 206, 207; 206, 208; 207, integer:8; 208, call; 208, 209; 208, 210; 209, identifier:getAttrWithFallback; 210, argument_list; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:font; 213, identifier:info; 214, string:"openTypeNameManufacturer"; 215, pair; 215, 216; 215, 217; 216, integer:9; 217, call; 217, 218; 217, 219; 218, identifier:getAttrWithFallback; 219, argument_list; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:font; 222, identifier:info; 223, string:"openTypeNameDesigner"; 224, pair; 224, 225; 224, 226; 225, integer:10; 226, call; 226, 227; 226, 228; 227, identifier:getAttrWithFallback; 228, argument_list; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:font; 231, identifier:info; 232, string:"openTypeNameDescription"; 233, pair; 233, 234; 233, 235; 234, integer:11; 235, call; 235, 236; 235, 237; 236, identifier:getAttrWithFallback; 237, argument_list; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:font; 240, identifier:info; 241, string:"openTypeNameManufacturerURL"; 242, pair; 242, 243; 242, 244; 243, integer:12; 244, call; 244, 245; 244, 246; 245, identifier:getAttrWithFallback; 246, argument_list; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:font; 249, identifier:info; 250, string:"openTypeNameDesignerURL"; 251, pair; 251, 252; 251, 253; 252, integer:13; 253, call; 253, 254; 253, 255; 254, identifier:getAttrWithFallback; 255, argument_list; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:font; 258, identifier:info; 259, string:"openTypeNameLicense"; 260, pair; 260, 261; 260, 262; 261, integer:14; 262, call; 262, 263; 262, 264; 263, identifier:getAttrWithFallback; 264, argument_list; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:font; 267, identifier:info; 268, string:"openTypeNameLicenseURL"; 269, pair; 269, 270; 269, 271; 270, integer:16; 271, identifier:preferredFamilyName; 272, pair; 272, 273; 272, 274; 273, integer:17; 274, identifier:preferredSubfamilyName; 275, if_statement; 275, 276; 275, 283; 276, comparison_operator:==; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:nameVals; 279, integer:1; 280, subscript; 280, 281; 280, 282; 281, identifier:nameVals; 282, integer:16; 283, block; 283, 284; 284, delete_statement; 284, 285; 285, subscript; 285, 286; 285, 287; 286, identifier:nameVals; 287, integer:16; 288, if_statement; 288, 289; 288, 296; 289, comparison_operator:==; 289, 290; 289, 293; 290, subscript; 290, 291; 290, 292; 291, identifier:nameVals; 292, integer:2; 293, subscript; 293, 294; 293, 295; 294, identifier:nameVals; 295, integer:17; 296, block; 296, 297; 297, delete_statement; 297, 298; 298, subscript; 298, 299; 298, 300; 299, identifier:nameVals; 300, integer:17; 301, if_statement; 301, 302; 301, 305; 302, subscript; 302, 303; 302, 304; 303, identifier:nameVals; 304, integer:6; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 311; 308, subscript; 308, 309; 308, 310; 309, identifier:nameVals; 310, integer:6; 311, call; 311, 312; 311, 313; 312, identifier:normalizeStringForPostscript; 313, argument_list; 313, 314; 314, subscript; 314, 315; 314, 316; 315, identifier:nameVals; 316, integer:6; 317, for_statement; 317, 318; 317, 319; 317, 327; 318, identifier:nameId; 319, call; 319, 320; 319, 321; 320, identifier:sorted; 321, argument_list; 321, 322; 322, call; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:nameVals; 325, identifier:keys; 326, argument_list; 327, block; 327, 328; 327, 334; 327, 339; 327, 349; 327, 353; 327, 363; 327, 367; 327, 379; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 331; 330, identifier:nameVal; 331, subscript; 331, 332; 331, 333; 332, identifier:nameVals; 333, identifier:nameId; 334, if_statement; 334, 335; 334, 337; 335, not_operator; 335, 336; 336, identifier:nameVal; 337, block; 337, 338; 338, continue_statement; 339, expression_statement; 339, 340; 340, assignment; 340, 341; 340, 342; 341, identifier:nameVal; 342, call; 342, 343; 342, 344; 343, identifier:tounicode; 344, argument_list; 344, 345; 344, 346; 345, identifier:nameVal; 346, keyword_argument; 346, 347; 346, 348; 347, identifier:encoding; 348, string:'ascii'; 349, expression_statement; 349, 350; 350, assignment; 350, 351; 350, 352; 351, identifier:platformId; 352, integer:3; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 356; 355, identifier:platEncId; 356, conditional_expression:if; 356, 357; 356, 358; 356, 362; 357, integer:10; 358, call; 358, 359; 358, 360; 359, identifier:_isNonBMP; 360, argument_list; 360, 361; 361, identifier:nameVal; 362, integer:1; 363, expression_statement; 363, 364; 364, assignment; 364, 365; 364, 366; 365, identifier:langId; 366, integer:0x409; 367, if_statement; 367, 368; 367, 377; 368, call; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:name; 371, identifier:getName; 372, argument_list; 372, 373; 372, 374; 372, 375; 372, 376; 373, identifier:nameId; 374, identifier:platformId; 375, identifier:platEncId; 376, identifier:langId; 377, block; 377, 378; 378, continue_statement; 379, expression_statement; 379, 380; 380, call; 380, 381; 380, 384; 381, attribute; 381, 382; 381, 383; 382, identifier:name; 383, identifier:setName; 384, argument_list; 384, 385; 384, 386; 384, 387; 384, 388; 384, 389; 385, identifier:nameVal; 386, identifier:nameId; 387, identifier:platformId; 388, identifier:platEncId; 389, identifier:langId | def setupTable_name(self):
if "name" not in self.tables:
return
font = self.ufo
self.otf["name"] = name = newTable("name")
name.names = []
for nameRecord in getAttrWithFallback(
font.info, "openTypeNameRecords"):
nameId = nameRecord["nameID"]
platformId = nameRecord["platformID"]
platEncId = nameRecord["encodingID"]
langId = nameRecord["languageID"]
nameVal = tounicode(nameRecord["string"], encoding='ascii')
name.setName(nameVal, nameId, platformId, platEncId, langId)
familyName = getAttrWithFallback(font.info, "styleMapFamilyName")
styleName = getAttrWithFallback(font.info, "styleMapStyleName").title()
preferredFamilyName = getAttrWithFallback(
font.info, "openTypeNamePreferredFamilyName")
preferredSubfamilyName = getAttrWithFallback(
font.info, "openTypeNamePreferredSubfamilyName")
fullName = "%s %s" % (preferredFamilyName, preferredSubfamilyName)
nameVals = {
0: getAttrWithFallback(font.info, "copyright"),
1: familyName,
2: styleName,
3: getAttrWithFallback(font.info, "openTypeNameUniqueID"),
4: fullName,
5: getAttrWithFallback(font.info, "openTypeNameVersion"),
6: getAttrWithFallback(font.info, "postscriptFontName"),
7: getAttrWithFallback(font.info, "trademark"),
8: getAttrWithFallback(font.info, "openTypeNameManufacturer"),
9: getAttrWithFallback(font.info, "openTypeNameDesigner"),
10: getAttrWithFallback(font.info, "openTypeNameDescription"),
11: getAttrWithFallback(font.info, "openTypeNameManufacturerURL"),
12: getAttrWithFallback(font.info, "openTypeNameDesignerURL"),
13: getAttrWithFallback(font.info, "openTypeNameLicense"),
14: getAttrWithFallback(font.info, "openTypeNameLicenseURL"),
16: preferredFamilyName,
17: preferredSubfamilyName,
}
if nameVals[1] == nameVals[16]:
del nameVals[16]
if nameVals[2] == nameVals[17]:
del nameVals[17]
if nameVals[6]:
nameVals[6] = normalizeStringForPostscript(nameVals[6])
for nameId in sorted(nameVals.keys()):
nameVal = nameVals[nameId]
if not nameVal:
continue
nameVal = tounicode(nameVal, encoding='ascii')
platformId = 3
platEncId = 10 if _isNonBMP(nameVal) else 1
langId = 0x409
if name.getName(nameId, platformId, platEncId, langId):
continue
name.setName(nameVal, nameId, platformId, platEncId, langId) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:setupTable_cmap; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 22; 5, 46; 5, 84; 5, 91; 5, 97; 5, 103; 5, 109; 5, 115; 5, 122; 5, 128; 5, 134; 5, 140; 5, 146; 5, 159; 5, 165; 5, 173; 6, if_statement; 6, 7; 6, 12; 7, comparison_operator:not; 7, 8; 7, 9; 8, string:"cmap"; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:tables; 12, block; 12, 13; 13, return_statement; 14, import_from_statement; 14, 15; 14, 20; 15, dotted_name; 15, 16; 15, 17; 15, 18; 15, 19; 16, identifier:fontTools; 17, identifier:ttLib; 18, identifier:tables; 19, identifier:_c_m_a_p; 20, dotted_name; 20, 21; 21, identifier:cmap_format_4; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:nonBMP; 25, call; 25, 26; 25, 27; 26, identifier:dict; 27, generator_expression; 27, 28; 27, 31; 27, 42; 28, tuple; 28, 29; 28, 30; 29, identifier:k; 30, identifier:v; 31, for_in_clause; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:k; 34, identifier:v; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:unicodeToGlyphNameMapping; 40, identifier:items; 41, argument_list; 42, if_clause; 42, 43; 43, comparison_operator:>; 43, 44; 43, 45; 44, identifier:k; 45, integer:65535; 46, if_statement; 46, 47; 46, 48; 46, 73; 47, identifier:nonBMP; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:mapping; 52, call; 52, 53; 52, 54; 53, identifier:dict; 54, generator_expression; 54, 55; 54, 58; 54, 69; 55, tuple; 55, 56; 55, 57; 56, identifier:k; 57, identifier:v; 58, for_in_clause; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:k; 61, identifier:v; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:unicodeToGlyphNameMapping; 67, identifier:items; 68, argument_list; 69, if_clause; 69, 70; 70, comparison_operator:<=; 70, 71; 70, 72; 71, identifier:k; 72, integer:65535; 73, else_clause; 73, 74; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:mapping; 78, call; 78, 79; 78, 80; 79, identifier:dict; 80, argument_list; 80, 81; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:unicodeToGlyphNameMapping; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:cmap4_0_3; 87, call; 87, 88; 87, 89; 88, identifier:cmap_format_4; 89, argument_list; 89, 90; 90, integer:4; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:cmap4_0_3; 95, identifier:platformID; 96, integer:0; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:cmap4_0_3; 101, identifier:platEncID; 102, integer:3; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:cmap4_0_3; 107, identifier:language; 108, integer:0; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:cmap4_0_3; 113, identifier:cmap; 114, identifier:mapping; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:cmap4_3_1; 118, call; 118, 119; 118, 120; 119, identifier:cmap_format_4; 120, argument_list; 120, 121; 121, integer:4; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:cmap4_3_1; 126, identifier:platformID; 127, integer:3; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:cmap4_3_1; 132, identifier:platEncID; 133, integer:1; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:cmap4_3_1; 138, identifier:language; 139, integer:0; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:cmap4_3_1; 144, identifier:cmap; 145, identifier:mapping; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 153; 148, subscript; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:otf; 152, string:"cmap"; 153, assignment; 153, 154; 153, 155; 154, identifier:cmap; 155, call; 155, 156; 155, 157; 156, identifier:newTable; 157, argument_list; 157, 158; 158, string:"cmap"; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:cmap; 163, identifier:tableVersion; 164, integer:0; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:cmap; 169, identifier:tables; 170, list:[cmap4_0_3, cmap4_3_1]; 170, 171; 170, 172; 171, identifier:cmap4_0_3; 172, identifier:cmap4_3_1; 173, if_statement; 173, 174; 173, 175; 174, identifier:nonBMP; 175, block; 175, 176; 175, 184; 175, 191; 175, 198; 175, 204; 175, 210; 175, 216; 175, 222; 175, 229; 175, 235; 175, 241; 175, 247; 175, 253; 176, import_from_statement; 176, 177; 176, 182; 177, dotted_name; 177, 178; 177, 179; 177, 180; 177, 181; 178, identifier:fontTools; 179, identifier:ttLib; 180, identifier:tables; 181, identifier:_c_m_a_p; 182, dotted_name; 182, 183; 183, identifier:cmap_format_12; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:nonBMP; 188, identifier:update; 189, argument_list; 189, 190; 190, identifier:mapping; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:cmap12_0_4; 194, call; 194, 195; 194, 196; 195, identifier:cmap_format_12; 196, argument_list; 196, 197; 197, integer:12; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:cmap12_0_4; 202, identifier:platformID; 203, integer:0; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:cmap12_0_4; 208, identifier:platEncID; 209, integer:4; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:cmap12_0_4; 214, identifier:language; 215, integer:0; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:cmap12_0_4; 220, identifier:cmap; 221, identifier:nonBMP; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:cmap12_3_10; 225, call; 225, 226; 225, 227; 226, identifier:cmap_format_12; 227, argument_list; 227, 228; 228, integer:12; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:cmap12_3_10; 233, identifier:platformID; 234, integer:3; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:cmap12_3_10; 239, identifier:platEncID; 240, integer:10; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:cmap12_3_10; 245, identifier:language; 246, integer:0; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:cmap12_3_10; 251, identifier:cmap; 252, identifier:nonBMP; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:cmap; 257, identifier:tables; 258, list:[cmap4_0_3, cmap4_3_1, cmap12_0_4, cmap12_3_10]; 258, 259; 258, 260; 258, 261; 258, 262; 259, identifier:cmap4_0_3; 260, identifier:cmap4_3_1; 261, identifier:cmap12_0_4; 262, identifier:cmap12_3_10 | def setupTable_cmap(self):
if "cmap" not in self.tables:
return
from fontTools.ttLib.tables._c_m_a_p import cmap_format_4
nonBMP = dict((k,v) for k,v in self.unicodeToGlyphNameMapping.items() if k > 65535)
if nonBMP:
mapping = dict((k,v) for k,v in self.unicodeToGlyphNameMapping.items() if k <= 65535)
else:
mapping = dict(self.unicodeToGlyphNameMapping)
cmap4_0_3 = cmap_format_4(4)
cmap4_0_3.platformID = 0
cmap4_0_3.platEncID = 3
cmap4_0_3.language = 0
cmap4_0_3.cmap = mapping
cmap4_3_1 = cmap_format_4(4)
cmap4_3_1.platformID = 3
cmap4_3_1.platEncID = 1
cmap4_3_1.language = 0
cmap4_3_1.cmap = mapping
self.otf["cmap"] = cmap = newTable("cmap")
cmap.tableVersion = 0
cmap.tables = [cmap4_0_3, cmap4_3_1]
if nonBMP:
from fontTools.ttLib.tables._c_m_a_p import cmap_format_12
nonBMP.update(mapping)
cmap12_0_4 = cmap_format_12(12)
cmap12_0_4.platformID = 0
cmap12_0_4.platEncID = 4
cmap12_0_4.language = 0
cmap12_0_4.cmap = nonBMP
cmap12_3_10 = cmap_format_12(12)
cmap12_3_10.platformID = 3
cmap12_3_10.platEncID = 10
cmap12_3_10.language = 0
cmap12_3_10.cmap = nonBMP
cmap.tables = [cmap4_0_3, cmap4_3_1, cmap12_0_4, cmap12_3_10] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_setupTable_hhea_or_vhea; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:tag; 6, block; 6, 7; 6, 15; 6, 30; 6, 43; 6, 58; 6, 64; 6, 81; 6, 91; 6, 110; 6, 144; 6, 170; 6, 174; 6, 178; 6, 182; 6, 186; 6, 294; 6, 313; 6, 332; 6, 351; 6, 370; 6, 390; 6, 403; 6, 409; 7, if_statement; 7, 8; 7, 13; 8, comparison_operator:not; 8, 9; 8, 10; 9, identifier:tag; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:tables; 13, block; 13, 14; 14, return_statement; 15, if_statement; 15, 16; 15, 19; 15, 24; 16, comparison_operator:==; 16, 17; 16, 18; 17, identifier:tag; 18, string:"hhea"; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:isHhea; 23, True; 24, else_clause; 24, 25; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:isHhea; 29, False; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:otf; 36, identifier:tag; 37, assignment; 37, 38; 37, 39; 38, identifier:table; 39, call; 39, 40; 39, 41; 40, identifier:newTable; 41, argument_list; 41, 42; 42, identifier:tag; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:mtxTable; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:otf; 51, identifier:get; 52, argument_list; 52, 53; 53, binary_operator:+; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:tag; 56, integer:0; 57, string:"mtx"; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:font; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:ufo; 64, if_statement; 64, 65; 64, 66; 64, 73; 65, identifier:isHhea; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:table; 71, identifier:tableVersion; 72, integer:0x00010000; 73, else_clause; 73, 74; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:table; 79, identifier:tableVersion; 80, integer:0x00011000; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:commonPrefix; 84, binary_operator:%; 84, 85; 84, 86; 85, string:"openType%s"; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:tag; 89, identifier:title; 90, argument_list; 91, if_statement; 91, 92; 91, 93; 91, 98; 92, identifier:isHhea; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:metricsPrefix; 97, identifier:commonPrefix; 98, else_clause; 98, 99; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:metricsPrefix; 103, binary_operator:%; 103, 104; 103, 105; 104, string:"openType%sVertTypo"; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:tag; 108, identifier:title; 109, argument_list; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:metricsDict; 113, dictionary; 113, 114; 113, 119; 113, 124; 113, 129; 113, 134; 113, 139; 114, pair; 114, 115; 114, 116; 115, string:"ascent"; 116, binary_operator:%; 116, 117; 116, 118; 117, string:"%sAscender"; 118, identifier:metricsPrefix; 119, pair; 119, 120; 119, 121; 120, string:"descent"; 121, binary_operator:%; 121, 122; 121, 123; 122, string:"%sDescender"; 123, identifier:metricsPrefix; 124, pair; 124, 125; 124, 126; 125, string:"lineGap"; 126, binary_operator:%; 126, 127; 126, 128; 127, string:"%sLineGap"; 128, identifier:metricsPrefix; 129, pair; 129, 130; 129, 131; 130, string:"caretSlopeRise"; 131, binary_operator:%; 131, 132; 131, 133; 132, string:"%sCaretSlopeRise"; 133, identifier:commonPrefix; 134, pair; 134, 135; 134, 136; 135, string:"caretSlopeRun"; 136, binary_operator:%; 136, 137; 136, 138; 137, string:"%sCaretSlopeRun"; 138, identifier:commonPrefix; 139, pair; 139, 140; 139, 141; 140, string:"caretOffset"; 141, binary_operator:%; 141, 142; 141, 143; 142, string:"%sCaretOffset"; 143, identifier:commonPrefix; 144, for_statement; 144, 145; 144, 148; 144, 153; 145, pattern_list; 145, 146; 145, 147; 146, identifier:otfName; 147, identifier:ufoName; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:metricsDict; 151, identifier:items; 152, argument_list; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:setattr; 157, argument_list; 157, 158; 157, 159; 157, 160; 158, identifier:table; 159, identifier:otfName; 160, call; 160, 161; 160, 162; 161, identifier:otRound; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:getAttrWithFallback; 165, argument_list; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:font; 168, identifier:info; 169, identifier:ufoName; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:advances; 173, list:[]; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:firstSideBearings; 177, list:[]; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:secondSideBearings; 181, list:[]; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:extents; 185, list:[]; 186, if_statement; 186, 187; 186, 190; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:mtxTable; 189, None; 190, block; 190, 191; 191, for_statement; 191, 192; 191, 193; 191, 196; 192, identifier:glyphName; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:allGlyphs; 196, block; 196, 197; 196, 205; 196, 212; 196, 220; 196, 226; 196, 265; 196, 273; 196, 280; 196, 287; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, pattern_list; 199, 200; 199, 201; 200, identifier:advance; 201, identifier:firstSideBearing; 202, subscript; 202, 203; 202, 204; 203, identifier:mtxTable; 204, identifier:glyphName; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:advances; 209, identifier:append; 210, argument_list; 210, 211; 211, identifier:advance; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:bounds; 215, subscript; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:glyphBoundingBoxes; 219, identifier:glyphName; 220, if_statement; 220, 221; 220, 224; 221, comparison_operator:is; 221, 222; 221, 223; 222, identifier:bounds; 223, None; 224, block; 224, 225; 225, continue_statement; 226, if_statement; 226, 227; 226, 228; 226, 246; 227, identifier:isHhea; 228, block; 228, 229; 228, 240; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:boundsAdvance; 232, parenthesized_expression; 232, 233; 233, binary_operator:-; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:bounds; 236, identifier:xMax; 237, attribute; 237, 238; 237, 239; 238, identifier:bounds; 239, identifier:xMin; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:extent; 243, binary_operator:+; 243, 244; 243, 245; 244, identifier:firstSideBearing; 245, identifier:boundsAdvance; 246, else_clause; 246, 247; 247, block; 247, 248; 247, 259; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:boundsAdvance; 251, parenthesized_expression; 251, 252; 252, binary_operator:-; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:bounds; 255, identifier:yMax; 256, attribute; 256, 257; 256, 258; 257, identifier:bounds; 258, identifier:yMin; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:extent; 262, binary_operator:+; 262, 263; 262, 264; 263, identifier:firstSideBearing; 264, identifier:boundsAdvance; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:secondSideBearing; 268, binary_operator:-; 268, 269; 268, 272; 269, binary_operator:-; 269, 270; 269, 271; 270, identifier:advance; 271, identifier:firstSideBearing; 272, identifier:boundsAdvance; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:firstSideBearings; 277, identifier:append; 278, argument_list; 278, 279; 279, identifier:firstSideBearing; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:secondSideBearings; 284, identifier:append; 285, argument_list; 285, 286; 286, identifier:secondSideBearing; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:extents; 291, identifier:append; 292, argument_list; 292, 293; 293, identifier:extent; 294, expression_statement; 294, 295; 295, call; 295, 296; 295, 297; 296, identifier:setattr; 297, argument_list; 297, 298; 297, 299; 297, 306; 298, identifier:table; 299, binary_operator:%; 299, 300; 299, 301; 300, string:"advance%sMax"; 301, parenthesized_expression; 301, 302; 302, conditional_expression:if; 302, 303; 302, 304; 302, 305; 303, string:"Width"; 304, identifier:isHhea; 305, string:"Height"; 306, conditional_expression:if; 306, 307; 306, 311; 306, 312; 307, call; 307, 308; 307, 309; 308, identifier:max; 309, argument_list; 309, 310; 310, identifier:advances; 311, identifier:advances; 312, integer:0; 313, expression_statement; 313, 314; 314, call; 314, 315; 314, 316; 315, identifier:setattr; 316, argument_list; 316, 317; 316, 318; 316, 325; 317, identifier:table; 318, binary_operator:%; 318, 319; 318, 320; 319, string:"min%sSideBearing"; 320, parenthesized_expression; 320, 321; 321, conditional_expression:if; 321, 322; 321, 323; 321, 324; 322, string:"Left"; 323, identifier:isHhea; 324, string:"Top"; 325, conditional_expression:if; 325, 326; 325, 330; 325, 331; 326, call; 326, 327; 326, 328; 327, identifier:min; 328, argument_list; 328, 329; 329, identifier:firstSideBearings; 330, identifier:firstSideBearings; 331, integer:0; 332, expression_statement; 332, 333; 333, call; 333, 334; 333, 335; 334, identifier:setattr; 335, argument_list; 335, 336; 335, 337; 335, 344; 336, identifier:table; 337, binary_operator:%; 337, 338; 337, 339; 338, string:"min%sSideBearing"; 339, parenthesized_expression; 339, 340; 340, conditional_expression:if; 340, 341; 340, 342; 340, 343; 341, string:"Right"; 342, identifier:isHhea; 343, string:"Bottom"; 344, conditional_expression:if; 344, 345; 344, 349; 344, 350; 345, call; 345, 346; 345, 347; 346, identifier:min; 347, argument_list; 347, 348; 348, identifier:secondSideBearings; 349, identifier:secondSideBearings; 350, integer:0; 351, expression_statement; 351, 352; 352, call; 352, 353; 352, 354; 353, identifier:setattr; 354, argument_list; 354, 355; 354, 356; 354, 363; 355, identifier:table; 356, binary_operator:%; 356, 357; 356, 358; 357, string:"%sMaxExtent"; 358, parenthesized_expression; 358, 359; 359, conditional_expression:if; 359, 360; 359, 361; 359, 362; 360, string:"x"; 361, identifier:isHhea; 362, string:"y"; 363, conditional_expression:if; 363, 364; 363, 368; 363, 369; 364, call; 364, 365; 364, 366; 365, identifier:max; 366, argument_list; 366, 367; 367, identifier:extents; 368, identifier:extents; 369, integer:0; 370, if_statement; 370, 371; 370, 372; 370, 380; 371, identifier:isHhea; 372, block; 372, 373; 373, expression_statement; 373, 374; 374, assignment; 374, 375; 374, 376; 375, identifier:reserved; 376, call; 376, 377; 376, 378; 377, identifier:range; 378, argument_list; 378, 379; 379, integer:4; 380, else_clause; 380, 381; 381, block; 381, 382; 382, expression_statement; 382, 383; 383, assignment; 383, 384; 383, 385; 384, identifier:reserved; 385, call; 385, 386; 385, 387; 386, identifier:range; 387, argument_list; 387, 388; 387, 389; 388, integer:1; 389, integer:5; 390, for_statement; 390, 391; 390, 392; 390, 393; 391, identifier:i; 392, identifier:reserved; 393, block; 393, 394; 394, expression_statement; 394, 395; 395, call; 395, 396; 395, 397; 396, identifier:setattr; 397, argument_list; 397, 398; 397, 399; 397, 402; 398, identifier:table; 399, binary_operator:%; 399, 400; 399, 401; 400, string:"reserved%i"; 401, identifier:i; 402, integer:0; 403, expression_statement; 403, 404; 404, assignment; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:table; 407, identifier:metricDataFormat; 408, integer:0; 409, expression_statement; 409, 410; 410, call; 410, 411; 410, 412; 411, identifier:setattr; 412, argument_list; 412, 413; 412, 414; 412, 421; 413, identifier:table; 414, binary_operator:%; 414, 415; 414, 416; 415, string:"numberOf%sMetrics"; 416, parenthesized_expression; 416, 417; 417, conditional_expression:if; 417, 418; 417, 419; 417, 420; 418, string:"H"; 419, identifier:isHhea; 420, string:"V"; 421, call; 421, 422; 421, 423; 422, identifier:len; 423, argument_list; 423, 424; 424, attribute; 424, 425; 424, 426; 425, identifier:self; 426, identifier:allGlyphs | def _setupTable_hhea_or_vhea(self, tag):
if tag not in self.tables:
return
if tag == "hhea":
isHhea = True
else:
isHhea = False
self.otf[tag] = table = newTable(tag)
mtxTable = self.otf.get(tag[0] + "mtx")
font = self.ufo
if isHhea:
table.tableVersion = 0x00010000
else:
table.tableVersion = 0x00011000
commonPrefix = "openType%s" % tag.title()
if isHhea:
metricsPrefix = commonPrefix
else:
metricsPrefix = "openType%sVertTypo" % tag.title()
metricsDict = {
"ascent": "%sAscender" % metricsPrefix,
"descent": "%sDescender" % metricsPrefix,
"lineGap": "%sLineGap" % metricsPrefix,
"caretSlopeRise": "%sCaretSlopeRise" % commonPrefix,
"caretSlopeRun": "%sCaretSlopeRun" % commonPrefix,
"caretOffset": "%sCaretOffset" % commonPrefix,
}
for otfName, ufoName in metricsDict.items():
setattr(table, otfName,
otRound(getAttrWithFallback(font.info, ufoName)))
advances = []
firstSideBearings = []
secondSideBearings = []
extents = []
if mtxTable is not None:
for glyphName in self.allGlyphs:
advance, firstSideBearing = mtxTable[glyphName]
advances.append(advance)
bounds = self.glyphBoundingBoxes[glyphName]
if bounds is None:
continue
if isHhea:
boundsAdvance = (bounds.xMax - bounds.xMin)
extent = firstSideBearing + boundsAdvance
else:
boundsAdvance = (bounds.yMax - bounds.yMin)
extent = firstSideBearing + boundsAdvance
secondSideBearing = advance - firstSideBearing - boundsAdvance
firstSideBearings.append(firstSideBearing)
secondSideBearings.append(secondSideBearing)
extents.append(extent)
setattr(table,
"advance%sMax" % ("Width" if isHhea else "Height"),
max(advances) if advances else 0)
setattr(table,
"min%sSideBearing" % ("Left" if isHhea else "Top"),
min(firstSideBearings) if firstSideBearings else 0)
setattr(table,
"min%sSideBearing" % ("Right" if isHhea else "Bottom"),
min(secondSideBearings) if secondSideBearings else 0)
setattr(table,
"%sMaxExtent" % ("x" if isHhea else "y"),
max(extents) if extents else 0)
if isHhea:
reserved = range(4)
else:
reserved = range(1, 5)
for i in reserved:
setattr(table, "reserved%i" % i, 0)
table.metricDataFormat = 0
setattr(table,
"numberOf%sMetrics" % ("H" if isHhea else "V"),
len(self.allGlyphs)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:dir; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:methods; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:showall; 10, True; 11, block; 11, 12; 11, 15; 11, 51; 11, 56; 11, 63; 11, 65; 12, import_statement; 12, 13; 13, dotted_name; 13, 14; 14, identifier:inspect; 15, for_statement; 15, 16; 15, 19; 15, 29; 16, pattern_list; 16, 17; 16, 18; 17, identifier:k; 18, identifier:v; 19, call; 19, 20; 19, 21; 20, identifier:sorted; 21, argument_list; 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:__dict__; 27, identifier:items; 28, argument_list; 29, block; 29, 30; 29, 39; 30, if_statement; 30, 31; 30, 37; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:k; 34, identifier:startswith; 35, argument_list; 35, 36; 36, string:"_"; 37, block; 37, 38; 38, continue_statement; 39, print_statement; 39, 40; 39, 49; 39, 50; 40, call; 40, 41; 40, 42; 41, identifier:makeminlength; 42, argument_list; 42, 43; 42, 46; 43, binary_operator:+; 43, 44; 43, 45; 44, string:"."; 45, identifier:k; 46, attribute; 46, 47; 46, 48; 47, identifier:being; 48, identifier:linelen; 49, string:"\t"; 50, identifier:v; 51, if_statement; 51, 52; 51, 54; 52, not_operator; 52, 53; 53, identifier:methods; 54, block; 54, 55; 55, return_statement; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:entmethods; 59, call; 59, 60; 59, 61; 60, identifier:dir; 61, argument_list; 61, 62; 62, identifier:entity; 63, expression_statement; 63, 64; 64, identifier:print; 65, for_statement; 65, 66; 65, 67; 65, 101; 66, identifier:x; 67, list_comprehension; 67, 68; 67, 69; 67, 75; 68, identifier:x; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:x; 71, call; 71, 72; 71, 73; 72, identifier:dir; 73, argument_list; 73, 74; 74, identifier:self; 75, if_clause; 75, 76; 76, boolean_operator:and; 76, 77; 76, 94; 77, parenthesized_expression; 77, 78; 78, comparison_operator:in; 78, 79; 78, 86; 79, binary_operator:+; 79, 80; 79, 81; 80, string:"bound method "; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:classname; 85, argument_list; 86, call; 86, 87; 86, 88; 87, identifier:str; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:getattr; 91, argument_list; 91, 92; 91, 93; 92, identifier:self; 93, identifier:x; 94, not_operator; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:x; 98, identifier:startswith; 99, argument_list; 99, 100; 100, string:"_"; 101, block; 101, 102; 101, 113; 101, 121; 101, 127; 101, 135; 101, 142; 101, 173; 101, 191; 102, if_statement; 102, 103; 102, 111; 103, boolean_operator:and; 103, 104; 103, 107; 104, parenthesized_expression; 104, 105; 105, not_operator; 105, 106; 106, identifier:showall; 107, parenthesized_expression; 107, 108; 108, comparison_operator:in; 108, 109; 108, 110; 109, identifier:x; 110, identifier:entmethods; 111, block; 111, 112; 112, continue_statement; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:attr; 116, call; 116, 117; 116, 118; 117, identifier:getattr; 118, argument_list; 118, 119; 118, 120; 119, identifier:self; 120, identifier:x; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:doc; 124, attribute; 124, 125; 124, 126; 125, identifier:attr; 126, identifier:__doc__; 127, if_statement; 127, 128; 127, 130; 128, not_operator; 128, 129; 129, identifier:doc; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:doc; 134, string:""; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:y; 138, call; 138, 139; 138, 140; 139, identifier:describe_func; 140, argument_list; 140, 141; 141, identifier:attr; 142, if_statement; 142, 143; 142, 145; 142, 150; 143, not_operator; 143, 144; 144, identifier:y; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:y; 149, string:""; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:y; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, string:", "; 158, identifier:join; 159, generator_expression; 159, 160; 159, 168; 160, binary_operator:+; 160, 161; 160, 164; 161, binary_operator:+; 161, 162; 161, 163; 162, identifier:a; 163, string:"="; 164, call; 164, 165; 164, 166; 165, identifier:str; 166, argument_list; 166, 167; 167, identifier:b; 168, for_in_clause; 168, 169; 168, 172; 169, tuple_pattern; 169, 170; 169, 171; 170, identifier:a; 171, identifier:b; 172, identifier:y; 173, print_statement; 173, 174; 173, 189; 173, 190; 174, call; 174, 175; 174, 176; 175, identifier:makeminlength; 176, argument_list; 176, 177; 176, 186; 177, binary_operator:+; 177, 178; 177, 185; 178, binary_operator:+; 178, 179; 178, 184; 179, binary_operator:+; 179, 180; 179, 183; 180, binary_operator:+; 180, 181; 180, 182; 181, string:"."; 182, identifier:x; 183, string:"("; 184, identifier:y; 185, string:")"; 186, attribute; 186, 187; 186, 188; 187, identifier:being; 188, identifier:linelen; 189, string:"\t"; 190, identifier:doc; 191, if_statement; 191, 192; 191, 193; 192, identifier:showall; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, identifier:print | def dir(self,methods=True,showall=True):
import inspect
for k,v in sorted(self.__dict__.items()):
if k.startswith("_"): continue
print makeminlength("."+k,being.linelen),"\t",v
if not methods:
return
entmethods=dir(entity)
print
for x in [x for x in dir(self) if ("bound method "+self.classname() in str(getattr(self,x))) and not x.startswith("_")]:
if (not showall) and (x in entmethods): continue
attr=getattr(self,x)
doc = attr.__doc__
if not doc:
doc=""
y=describe_func(attr)
if not y:
y=""
else:
y=", ".join(a+"="+str(b) for (a,b) in y)
print makeminlength("."+x+"("+y+")",being.linelen),"\t", doc
if showall: print |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:tree; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:offset; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:prefix_inherited; 10, string:""; 11, default_parameter; 11, 12; 11, 13; 12, identifier:nofeatsplease; 13, list:['Phoneme']; 13, 14; 14, string:'Phoneme'; 15, block; 15, 16; 15, 20; 15, 24; 15, 332; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:tree; 19, string:""; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:numchild; 23, integer:0; 24, for_statement; 24, 25; 24, 26; 24, 29; 25, identifier:child; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:children; 29, block; 29, 30; 29, 47; 29, 51; 29, 59; 29, 86; 29, 111; 29, 115; 29, 119; 29, 131; 29, 135; 29, 139; 29, 156; 29, 169; 29, 186; 29, 316; 29, 320; 30, if_statement; 30, 31; 30, 40; 31, comparison_operator:==; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:type; 34, argument_list; 34, 35; 35, identifier:child; 36, call; 36, 37; 36, 38; 37, identifier:type; 38, argument_list; 38, 39; 39, list:[]; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:child; 44, subscript; 44, 45; 44, 46; 45, identifier:child; 46, integer:0; 47, expression_statement; 47, 48; 48, augmented_assignment:+=; 48, 49; 48, 50; 49, identifier:numchild; 50, integer:1; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:classname; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:child; 57, identifier:classname; 58, argument_list; 59, if_statement; 59, 60; 59, 63; 59, 68; 59, 77; 60, comparison_operator:==; 60, 61; 60, 62; 61, identifier:classname; 62, string:"Word"; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, augmented_assignment:+=; 65, 66; 65, 67; 66, identifier:tree; 67, string:"\n\n"; 68, elif_clause; 68, 69; 68, 72; 69, comparison_operator:==; 69, 70; 69, 71; 70, identifier:classname; 71, string:"Line"; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, augmented_assignment:+=; 74, 75; 74, 76; 75, identifier:tree; 76, string:"\n\n\n"; 77, elif_clause; 77, 78; 77, 81; 78, comparison_operator:==; 78, 79; 78, 80; 79, identifier:classname; 80, string:"Stanza"; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, augmented_assignment:+=; 83, 84; 83, 85; 84, identifier:tree; 85, string:"\n\n\n\n"; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:!=; 87, 88; 87, 89; 88, identifier:offset; 89, integer:0; 90, block; 90, 91; 90, 95; 90, 107; 91, expression_statement; 91, 92; 92, augmented_assignment:+=; 92, 93; 92, 94; 93, identifier:tree; 94, string:"\n"; 95, for_statement; 95, 96; 95, 97; 95, 102; 96, identifier:i; 97, call; 97, 98; 97, 99; 98, identifier:range; 99, argument_list; 99, 100; 99, 101; 100, integer:0; 101, identifier:offset; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, augmented_assignment:+=; 104, 105; 104, 106; 105, identifier:tree; 106, string:" "; 107, expression_statement; 107, 108; 108, augmented_assignment:+=; 108, 109; 108, 110; 109, identifier:tree; 110, string:"|"; 111, expression_statement; 111, 112; 112, augmented_assignment:+=; 112, 113; 112, 114; 113, identifier:tree; 114, string:"\n"; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:newline; 118, string:""; 119, for_statement; 119, 120; 119, 121; 119, 126; 120, identifier:i; 121, call; 121, 122; 121, 123; 122, identifier:range; 123, argument_list; 123, 124; 123, 125; 124, integer:0; 125, identifier:offset; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, augmented_assignment:+=; 128, 129; 128, 130; 129, identifier:newline; 130, string:" "; 131, expression_statement; 131, 132; 132, augmented_assignment:+=; 132, 133; 132, 134; 133, identifier:newline; 134, string:"|"; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:cname; 138, string:""; 139, for_statement; 139, 140; 139, 141; 139, 142; 140, identifier:letter; 141, identifier:classname; 142, block; 142, 143; 143, if_statement; 143, 144; 143, 151; 144, comparison_operator:==; 144, 145; 144, 146; 145, identifier:letter; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:letter; 149, identifier:upper; 150, argument_list; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, augmented_assignment:+=; 153, 154; 153, 155; 154, identifier:cname; 155, identifier:letter; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:prefix; 159, binary_operator:+; 159, 160; 159, 168; 160, binary_operator:+; 160, 161; 160, 164; 161, binary_operator:+; 161, 162; 161, 163; 162, identifier:prefix_inherited; 163, identifier:cname; 164, call; 164, 165; 164, 166; 165, identifier:str; 166, argument_list; 166, 167; 167, identifier:numchild; 168, string:"."; 169, expression_statement; 169, 170; 170, augmented_assignment:+=; 170, 171; 170, 172; 171, identifier:newline; 172, binary_operator:+; 172, 173; 172, 185; 173, binary_operator:+; 173, 174; 173, 184; 174, binary_operator:+; 174, 175; 174, 183; 175, binary_operator:+; 175, 176; 175, 177; 176, string:"-----| ("; 177, subscript; 177, 178; 177, 179; 178, identifier:prefix; 179, slice; 179, 180; 179, 181; 180, colon; 181, unary_operator:-; 181, 182; 182, integer:1; 183, string:") <"; 184, identifier:classname; 185, string:">"; 186, if_statement; 186, 187; 186, 192; 186, 197; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:child; 190, identifier:isBroken; 191, argument_list; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, augmented_assignment:+=; 194, 195; 194, 196; 195, identifier:newline; 196, string:"<<broken>>"; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 208; 198, 244; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:string; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:u2s; 206, argument_list; 206, 207; 207, identifier:child; 208, if_statement; 208, 209; 208, 214; 208, 231; 209, parenthesized_expression; 209, 210; 210, not_operator; 210, 211; 211, comparison_operator:in; 211, 212; 211, 213; 212, string:"<"; 213, identifier:string; 214, block; 214, 215; 214, 223; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:newline; 218, call; 218, 219; 218, 220; 219, identifier:makeminlength; 220, argument_list; 220, 221; 220, 222; 221, identifier:newline; 222, integer:99; 223, expression_statement; 223, 224; 224, augmented_assignment:+=; 224, 225; 224, 226; 225, identifier:newline; 226, binary_operator:+; 226, 227; 226, 230; 227, binary_operator:+; 227, 228; 227, 229; 228, string:"["; 229, identifier:string; 230, string:"]"; 231, elif_clause; 231, 232; 231, 237; 232, comparison_operator:!=; 232, 233; 232, 236; 233, subscript; 233, 234; 233, 235; 234, identifier:string; 235, integer:0; 236, string:"<"; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, augmented_assignment:+=; 239, 240; 239, 241; 240, identifier:newline; 241, binary_operator:+; 241, 242; 241, 243; 242, string:"\t"; 243, identifier:string; 244, if_statement; 244, 245; 244, 251; 245, call; 245, 246; 245, 247; 246, identifier:len; 247, argument_list; 247, 248; 248, attribute; 248, 249; 248, 250; 249, identifier:child; 250, identifier:feats; 251, block; 251, 252; 252, if_statement; 252, 253; 252, 262; 253, parenthesized_expression; 253, 254; 254, not_operator; 254, 255; 255, comparison_operator:in; 255, 256; 255, 261; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:child; 259, identifier:classname; 260, argument_list; 261, identifier:nofeatsplease; 262, block; 262, 263; 263, for_statement; 263, 264; 263, 267; 263, 277; 264, pattern_list; 264, 265; 264, 266; 265, identifier:k; 266, identifier:v; 267, call; 267, 268; 267, 269; 268, identifier:sorted; 269, argument_list; 269, 270; 270, call; 270, 271; 270, 276; 271, attribute; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:child; 274, identifier:feats; 275, identifier:items; 276, argument_list; 277, block; 277, 278; 277, 284; 277, 288; 277, 302; 277, 306; 278, if_statement; 278, 279; 278, 282; 279, comparison_operator:==; 279, 280; 279, 281; 280, identifier:v; 281, None; 282, block; 282, 283; 283, continue_statement; 284, expression_statement; 284, 285; 285, augmented_assignment:+=; 285, 286; 285, 287; 286, identifier:newline; 287, string:"\n"; 288, for_statement; 288, 289; 288, 290; 288, 297; 289, identifier:i; 290, call; 290, 291; 290, 292; 291, identifier:range; 292, argument_list; 292, 293; 292, 294; 293, integer:0; 294, binary_operator:+; 294, 295; 294, 296; 295, identifier:offset; 296, integer:1; 297, block; 297, 298; 298, expression_statement; 298, 299; 299, augmented_assignment:+=; 299, 300; 299, 301; 300, identifier:newline; 301, string:" "; 302, expression_statement; 302, 303; 303, augmented_assignment:+=; 303, 304; 303, 305; 304, identifier:newline; 305, string:"| "; 306, expression_statement; 306, 307; 307, augmented_assignment:+=; 307, 308; 307, 309; 308, identifier:newline; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:self; 312, identifier:showFeat; 313, argument_list; 313, 314; 313, 315; 314, identifier:k; 315, identifier:v; 316, expression_statement; 316, 317; 317, augmented_assignment:+=; 317, 318; 317, 319; 318, identifier:tree; 319, identifier:newline; 320, expression_statement; 320, 321; 321, augmented_assignment:+=; 321, 322; 321, 323; 322, identifier:tree; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:child; 326, identifier:tree; 327, argument_list; 327, 328; 327, 331; 328, binary_operator:+; 328, 329; 328, 330; 329, identifier:offset; 330, integer:1; 331, identifier:prefix; 332, return_statement; 332, 333; 333, identifier:tree | def tree(self,offset=0,prefix_inherited="",nofeatsplease=['Phoneme']):
tree = ""
numchild=0
for child in self.children:
if type(child)==type([]):
child=child[0]
numchild+=1
classname=child.classname()
if classname=="Word":
tree+="\n\n"
elif classname=="Line":
tree+="\n\n\n"
elif classname=="Stanza":
tree+="\n\n\n\n"
if offset!=0:
tree+="\n"
for i in range(0,offset):
tree+=" "
tree+="|"
tree+="\n"
newline=""
for i in range(0,offset):
newline+=" "
newline+="|"
cname=""
for letter in classname:
if letter==letter.upper():
cname+=letter
prefix=prefix_inherited+cname+str(numchild) + "."
newline+="-----| ("+prefix[:-1]+") <"+classname+">"
if child.isBroken():
newline+="<<broken>>"
else:
string=self.u2s(child)
if (not "<" in string):
newline=makeminlength(newline,99)
newline+="["+string+"]"
elif string[0]!="<":
newline+="\t"+string
if len(child.feats):
if (not child.classname() in nofeatsplease):
for k,v in sorted(child.feats.items()):
if v==None:
continue
newline+="\n"
for i in range(0,offset+1):
newline+=" "
newline+="| "
newline+=self.showFeat(k,v)
tree+=newline
tree+=child.tree(offset+1,prefix)
return tree |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:stats_positions; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:meter; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:all_parses; 10, False; 11, block; 11, 12; 11, 38; 11, 42; 11, 130; 11, 293; 11, 305; 11, 324; 11, 360; 11, 371; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:parses; 15, conditional_expression:if; 15, 16; 15, 24; 15, 25; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:allParses; 20, argument_list; 20, 21; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:meter; 23, identifier:meter; 24, identifier:all_parses; 25, list_comprehension; 25, 26; 25, 28; 26, list:[parse]; 26, 27; 27, identifier:parse; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:parse; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:bestParses; 34, argument_list; 34, 35; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:meter; 37, identifier:meter; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:dx; 41, dictionary; 42, for_statement; 42, 43; 42, 44; 42, 45; 43, identifier:parselist; 44, identifier:parses; 45, block; 45, 46; 46, for_statement; 46, 47; 46, 48; 46, 49; 47, identifier:parse; 48, identifier:parselist; 49, block; 49, 50; 49, 55; 49, 59; 50, if_statement; 50, 51; 50, 53; 51, not_operator; 51, 52; 52, identifier:parse; 53, block; 53, 54; 54, continue_statement; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:slot_i; 58, integer:0; 59, for_statement; 59, 60; 59, 61; 59, 64; 60, identifier:pos; 61, attribute; 61, 62; 61, 63; 62, identifier:parse; 63, identifier:positions; 64, block; 64, 65; 65, for_statement; 65, 66; 65, 67; 65, 70; 66, identifier:slot; 67, attribute; 67, 68; 67, 69; 68, identifier:pos; 69, identifier:slots; 70, block; 70, 71; 70, 75; 70, 88; 71, expression_statement; 71, 72; 72, augmented_assignment:+=; 72, 73; 72, 74; 73, identifier:slot_i; 74, integer:1; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:feat_dicts; 78, list:[slot.feats, pos.constraintScores, pos.feats]; 78, 79; 78, 82; 78, 85; 79, attribute; 79, 80; 79, 81; 80, identifier:slot; 81, identifier:feats; 82, attribute; 82, 83; 82, 84; 83, identifier:pos; 84, identifier:constraintScores; 85, attribute; 85, 86; 85, 87; 86, identifier:pos; 87, identifier:feats; 88, for_statement; 88, 89; 88, 90; 88, 91; 89, identifier:feat_dict; 90, identifier:feat_dicts; 91, block; 91, 92; 92, for_statement; 92, 93; 92, 96; 92, 101; 93, pattern_list; 93, 94; 93, 95; 94, identifier:k; 95, identifier:v; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:feat_dict; 99, identifier:items; 100, argument_list; 101, block; 101, 102; 101, 111; 101, 123; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:dk; 105, tuple; 105, 106; 105, 107; 106, identifier:slot_i; 107, call; 107, 108; 107, 109; 108, identifier:str; 109, argument_list; 109, 110; 110, identifier:k; 111, if_statement; 111, 112; 111, 116; 112, not_operator; 112, 113; 113, comparison_operator:in; 113, 114; 113, 115; 114, identifier:dk; 115, identifier:dx; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:dx; 121, identifier:dk; 122, list:[]; 123, expression_statement; 123, 124; 124, augmented_assignment:+=; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:dx; 127, identifier:dk; 128, list:[v]; 128, 129; 129, identifier:v; 130, function_definition; 130, 131; 130, 132; 130, 133; 131, function_name:_writegen; 132, parameters; 133, block; 133, 134; 134, for_statement; 134, 135; 134, 140; 134, 148; 135, tuple_pattern; 135, 136; 135, 139; 136, tuple_pattern; 136, 137; 136, 138; 137, identifier:slot_i; 138, identifier:k; 139, identifier:l; 140, call; 140, 141; 140, 142; 141, identifier:sorted; 142, argument_list; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:dx; 146, identifier:items; 147, argument_list; 148, block; 148, 149; 148, 153; 148, 221; 148, 226; 148, 241; 148, 248; 148, 255; 148, 279; 148, 290; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:l2; 152, list:[]; 153, for_statement; 153, 154; 153, 155; 153, 156; 154, identifier:x; 155, identifier:l; 156, block; 156, 157; 156, 207; 156, 216; 157, if_statement; 157, 158; 157, 164; 157, 172; 157, 187; 157, 198; 158, comparison_operator:==; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:type; 161, argument_list; 161, 162; 162, identifier:x; 163, identifier:bool; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:x; 168, conditional_expression:if; 168, 169; 168, 170; 168, 171; 169, integer:1; 170, identifier:x; 171, integer:0; 172, elif_clause; 172, 173; 172, 182; 173, comparison_operator:==; 173, 174; 173, 178; 174, call; 174, 175; 174, 176; 175, identifier:type; 176, argument_list; 176, 177; 177, identifier:x; 178, call; 178, 179; 178, 180; 179, identifier:type; 180, argument_list; 180, 181; 181, None; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:x; 186, integer:0; 187, elif_clause; 187, 188; 187, 196; 188, comparison_operator:in; 188, 189; 188, 193; 189, call; 189, 190; 189, 191; 190, identifier:type; 191, argument_list; 191, 192; 192, identifier:x; 193, list:[str,unicode]; 193, 194; 193, 195; 194, identifier:str; 195, identifier:unicode; 196, block; 196, 197; 197, continue_statement; 198, else_clause; 198, 199; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:x; 203, call; 203, 204; 203, 205; 204, identifier:float; 205, argument_list; 205, 206; 206, identifier:x; 207, if_statement; 207, 208; 207, 211; 208, comparison_operator:>; 208, 209; 208, 210; 209, identifier:x; 210, integer:1; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:x; 215, integer:1; 216, expression_statement; 216, 217; 217, augmented_assignment:+=; 217, 218; 217, 219; 218, identifier:l2; 219, list:[x]; 219, 220; 220, identifier:x; 221, if_statement; 221, 222; 221, 224; 222, not_operator; 222, 223; 223, identifier:l2; 224, block; 224, 225; 225, continue_statement; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:avg; 229, binary_operator:/; 229, 230; 229, 234; 230, call; 230, 231; 230, 232; 231, identifier:sum; 232, argument_list; 232, 233; 233, identifier:l2; 234, call; 234, 235; 234, 236; 235, identifier:float; 236, argument_list; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:len; 239, argument_list; 239, 240; 240, identifier:l2; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:count; 244, call; 244, 245; 244, 246; 245, identifier:sum; 246, argument_list; 246, 247; 247, identifier:l2; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:chances; 251, call; 251, 252; 251, 253; 252, identifier:len; 253, argument_list; 253, 254; 254, identifier:l2; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:odx; 258, dictionary; 258, 259; 258, 262; 258, 265; 258, 268; 258, 271; 258, 274; 259, pair; 259, 260; 259, 261; 260, string:'slot_num'; 261, identifier:slot_i; 262, pair; 262, 263; 262, 264; 263, string:'statistic'; 264, identifier:k; 265, pair; 265, 266; 265, 267; 266, string:'average'; 267, identifier:avg; 268, pair; 268, 269; 268, 270; 269, string:'count'; 270, identifier:count; 271, pair; 271, 272; 271, 273; 272, string:'chances'; 273, identifier:chances; 274, pair; 274, 275; 274, 276; 275, string:'text'; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:name; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 284; 281, subscript; 281, 282; 281, 283; 282, identifier:odx; 283, string:'header'; 284, list:['slot_num', 'statistic','count','chances','average']; 284, 285; 284, 286; 284, 287; 284, 288; 284, 289; 285, string:'slot_num'; 286, string:'statistic'; 287, string:'count'; 288, string:'chances'; 289, string:'average'; 290, expression_statement; 290, 291; 291, yield; 291, 292; 292, identifier:odx; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:name; 296, call; 296, 297; 296, 302; 297, attribute; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:self; 300, identifier:name; 301, identifier:replace; 302, argument_list; 302, 303; 302, 304; 303, string:'.txt'; 304, string:''; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:ofn; 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, 318; 314, 319; 314, 320; 314, 321; 315, attribute; 315, 316; 315, 317; 316, identifier:self; 317, identifier:dir_results; 318, string:'stats'; 319, string:'texts'; 320, identifier:name; 321, binary_operator:+; 321, 322; 321, 323; 322, identifier:name; 323, string:'.positions.csv'; 324, if_statement; 324, 325; 324, 343; 325, not_operator; 325, 326; 326, call; 326, 327; 326, 332; 327, attribute; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:os; 330, identifier:path; 331, identifier:exists; 332, argument_list; 332, 333; 333, subscript; 333, 334; 333, 342; 334, call; 334, 335; 334, 340; 335, attribute; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:os; 338, identifier:path; 339, identifier:split; 340, argument_list; 340, 341; 341, identifier:ofn; 342, integer:0; 343, block; 343, 344; 344, expression_statement; 344, 345; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:os; 348, identifier:makedirs; 349, argument_list; 349, 350; 350, subscript; 350, 351; 350, 359; 351, call; 351, 352; 351, 357; 352, attribute; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:os; 355, identifier:path; 356, identifier:split; 357, argument_list; 357, 358; 358, identifier:ofn; 359, integer:0; 360, for_statement; 360, 361; 360, 362; 360, 367; 361, identifier:dx; 362, call; 362, 363; 362, 364; 363, identifier:writegengen; 364, argument_list; 364, 365; 364, 366; 365, identifier:ofn; 366, identifier:_writegen; 367, block; 367, 368; 368, expression_statement; 368, 369; 369, yield; 369, 370; 370, identifier:dx; 371, print_statement; 371, 372; 371, 373; 372, string:'>> saved:'; 373, identifier:ofn | def stats_positions(self,meter=None,all_parses=False):
parses = self.allParses(meter=meter) if all_parses else [[parse] for parse in self.bestParses(meter=meter)]
dx={}
for parselist in parses:
for parse in parselist:
if not parse: continue
slot_i=0
for pos in parse.positions:
for slot in pos.slots:
slot_i+=1
feat_dicts = [slot.feats, pos.constraintScores, pos.feats]
for feat_dict in feat_dicts:
for k,v in feat_dict.items():
dk = (slot_i,str(k))
if not dk in dx: dx[dk]=[]
dx[dk]+=[v]
def _writegen():
for ((slot_i,k),l) in sorted(dx.items()):
l2=[]
for x in l:
if type(x)==bool:
x=1 if x else 0
elif type(x)==type(None):
x=0
elif type(x) in [str,unicode]:
continue
else:
x=float(x)
if x>1: x=1
l2+=[x]
if not l2: continue
avg=sum(l2) / float(len(l2))
count=sum(l2)
chances=len(l2)
odx={'slot_num':slot_i, 'statistic':k, 'average':avg, 'count':count, 'chances':chances, 'text':self.name}
odx['header']=['slot_num', 'statistic','count','chances','average']
yield odx
name=self.name.replace('.txt','')
ofn=os.path.join(self.dir_results, 'stats','texts',name, name+'.positions.csv')
if not os.path.exists(os.path.split(ofn)[0]): os.makedirs(os.path.split(ofn)[0])
for dx in writegengen(ofn, _writegen):
yield dx
print '>> saved:',ofn |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:iparse; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:meter; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:num_processes; 10, integer:1; 11, default_parameter; 11, 12; 11, 13; 12, identifier:arbiter; 13, string:'Line'; 14, default_parameter; 14, 15; 14, 16; 15, identifier:line_lim; 16, None; 17, block; 17, 18; 17, 29; 17, 34; 17, 43; 17, 53; 17, 63; 17, 73; 17, 83; 17, 91; 17, 99; 17, 106; 17, 110; 17, 119; 17, 131; 17, 143; 17, 163; 17, 175; 17, 182; 17, 190; 17, 202; 17, 322; 18, import_from_statement; 18, 19; 18, 21; 18, 23; 18, 25; 18, 27; 19, dotted_name; 19, 20; 20, identifier:Meter; 21, dotted_name; 21, 22; 22, identifier:Meter; 23, dotted_name; 23, 24; 24, identifier:genDefault; 25, dotted_name; 25, 26; 26, identifier:parse_ent; 27, dotted_name; 27, 28; 28, identifier:parse_ent_mp; 29, import_statement; 29, 30; 30, aliased_import; 30, 31; 30, 33; 31, dotted_name; 31, 32; 32, identifier:multiprocessing; 33, identifier:mp; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:meter; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:get_meter; 41, argument_list; 41, 42; 42, identifier:meter; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 52; 45, subscript; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:__parses; 49, attribute; 49, 50; 49, 51; 50, identifier:meter; 51, identifier:id; 52, list:[]; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 62; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:__bestparses; 59, attribute; 59, 60; 59, 61; 60, identifier:meter; 61, identifier:id; 62, list:[]; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 72; 65, subscript; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:__boundParses; 69, attribute; 69, 70; 69, 71; 70, identifier:meter; 71, identifier:id; 72, list:[]; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 82; 75, subscript; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:__parsed_ents; 79, attribute; 79, 80; 79, 81; 80, identifier:meter; 81, identifier:id; 82, list:[]; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:lines; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:lines; 90, argument_list; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:lines; 94, subscript; 94, 95; 94, 96; 95, identifier:lines; 96, slice; 96, 97; 96, 98; 97, colon; 98, identifier:line_lim; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:numlines; 102, call; 102, 103; 102, 104; 103, identifier:len; 104, argument_list; 104, 105; 105, identifier:lines; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:init; 109, identifier:self; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:ents; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:ents; 117, argument_list; 117, 118; 118, identifier:arbiter; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:smax; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:config; 127, identifier:get; 128, argument_list; 128, 129; 128, 130; 129, string:'line_maxsylls'; 130, integer:100; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:smin; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:config; 139, identifier:get; 140, argument_list; 140, 141; 140, 142; 141, string:'line_minsylls'; 142, integer:0; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:ents; 146, list_comprehension; 146, 147; 146, 148; 146, 151; 147, identifier:e; 148, for_in_clause; 148, 149; 148, 150; 149, identifier:e; 150, identifier:ents; 151, if_clause; 151, 152; 152, boolean_operator:and; 152, 153; 152, 158; 153, comparison_operator:>=; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:e; 156, identifier:num_syll; 157, identifier:smin; 158, comparison_operator:<=; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:e; 161, identifier:num_syll; 162, identifier:smax; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:scansion_prepare; 168, argument_list; 168, 169; 168, 172; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:meter; 171, identifier:meter; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:conscious; 174, True; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:numents; 178, call; 178, 179; 178, 180; 179, identifier:len; 180, argument_list; 180, 181; 181, identifier:ents; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:toprint; 185, subscript; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:config; 189, string:'print_to_screen'; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:objects; 193, list_comprehension; 193, 194; 193, 199; 194, tuple; 194, 195; 194, 196; 194, 197; 194, 198; 195, identifier:ent; 196, identifier:meter; 197, identifier:init; 198, False; 199, for_in_clause; 199, 200; 199, 201; 200, identifier:ent; 201, identifier:ents; 202, if_statement; 202, 203; 202, 206; 202, 250; 203, comparison_operator:>; 203, 204; 203, 205; 204, identifier:num_processes; 205, integer:1; 206, block; 206, 207; 206, 209; 206, 218; 206, 233; 207, print_statement; 207, 208; 208, string:'!! MULTIPROCESSING PARSING IS NOT WORKING YET !!'; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:pool; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:mp; 215, identifier:Pool; 216, argument_list; 216, 217; 217, identifier:num_processes; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:jobs; 221, list_comprehension; 221, 222; 221, 230; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:pool; 225, identifier:apply_async; 226, argument_list; 226, 227; 226, 228; 227, identifier:parse_ent_mp; 228, tuple; 228, 229; 229, identifier:x; 230, for_in_clause; 230, 231; 230, 232; 231, identifier:x; 232, identifier:objects; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:j; 235, identifier:jobs; 236, block; 236, 237; 236, 243; 237, print_statement; 237, 238; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:j; 241, identifier:get; 242, argument_list; 243, expression_statement; 243, 244; 244, yield; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:j; 248, identifier:get; 249, argument_list; 250, else_clause; 250, 251; 251, block; 251, 252; 251, 260; 251, 264; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:now; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:time; 258, identifier:time; 259, argument_list; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:clock_snum; 263, integer:0; 264, for_statement; 264, 265; 264, 268; 264, 272; 265, pattern_list; 265, 266; 265, 267; 266, identifier:ei; 267, identifier:objectx; 268, call; 268, 269; 268, 270; 269, identifier:enumerate; 270, argument_list; 270, 271; 271, identifier:objects; 272, block; 272, 273; 272, 279; 272, 316; 273, expression_statement; 273, 274; 274, augmented_assignment:+=; 274, 275; 274, 276; 275, identifier:clock_snum; 276, attribute; 276, 277; 276, 278; 277, identifier:ent; 278, identifier:num_syll; 279, if_statement; 279, 280; 279, 286; 280, boolean_operator:and; 280, 281; 280, 282; 281, identifier:ei; 282, not_operator; 282, 283; 283, binary_operator:%; 283, 284; 283, 285; 284, identifier:ei; 285, integer:100; 286, block; 286, 287; 286, 295; 286, 308; 286, 312; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:nownow; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:time; 293, identifier:time; 294, argument_list; 295, if_statement; 295, 296; 295, 301; 296, subscript; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:self; 299, identifier:config; 300, string:'print_to_screen'; 301, block; 301, 302; 302, print_statement; 302, 303; 302, 304; 303, ERROR; 304, chevron; 304, 305; 304, 307; 305, ERROR; 305, 306; 306, identifier:parsing; 307, identifier:line; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:now; 311, identifier:nownow; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:clock_snum; 315, integer:0; 316, expression_statement; 316, 317; 317, yield; 317, 318; 318, call; 318, 319; 318, 320; 319, identifier:parse_ent_mp; 320, argument_list; 320, 321; 321, identifier:objectx; 322, if_statement; 322, 323; 322, 328; 323, subscript; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:self; 326, identifier:config; 327, string:'print_to_screen'; 328, block; 328, 329; 329, print_statement; 329, 330; 329, 331; 329, 338; 330, string:'>> parsing complete in:'; 331, binary_operator:-; 331, 332; 331, 337; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:time; 335, identifier:time; 336, argument_list; 337, identifier:now; 338, string:'seconds' | def iparse(self,meter=None,num_processes=1,arbiter='Line',line_lim=None):
from Meter import Meter,genDefault,parse_ent,parse_ent_mp
import multiprocessing as mp
meter=self.get_meter(meter)
self.__parses[meter.id]=[]
self.__bestparses[meter.id]=[]
self.__boundParses[meter.id]=[]
self.__parsed_ents[meter.id]=[]
lines = self.lines()
lines=lines[:line_lim]
numlines = len(lines)
init=self
ents=self.ents(arbiter)
smax=self.config.get('line_maxsylls',100)
smin=self.config.get('line_minsylls',0)
ents = [e for e in ents if e.num_syll >= smin and e.num_syll<=smax]
self.scansion_prepare(meter=meter,conscious=True)
numents=len(ents)
toprint=self.config['print_to_screen']
objects = [(ent,meter,init,False) for ent in ents]
if num_processes>1:
print '!! MULTIPROCESSING PARSING IS NOT WORKING YET !!'
pool = mp.Pool(num_processes)
jobs = [pool.apply_async(parse_ent_mp,(x,)) for x in objects]
for j in jobs:
print j.get()
yield j.get()
else:
now=time.time()
clock_snum=0
for ei,objectx in enumerate(objects):
clock_snum+=ent.num_syll
if ei and not ei%100:
nownow=time.time()
if self.config['print_to_screen']:
print '>> parsing line
now=nownow
clock_snum=0
yield parse_ent_mp(objectx)
if self.config['print_to_screen']:
print '>> parsing complete in:',time.time()-now,'seconds' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:from_representation; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:representation; 6, block; 6, 7; 6, 11; 6, 15; 6, 169; 6, 198; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:object_dict; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:failed; 14, dictionary; 15, for_statement; 15, 16; 15, 19; 15, 26; 16, pattern_list; 16, 17; 16, 18; 17, identifier:name; 18, identifier:field; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:fields; 24, identifier:items; 25, argument_list; 26, block; 26, 27; 26, 33; 27, if_statement; 27, 28; 27, 31; 28, comparison_operator:not; 28, 29; 28, 30; 29, identifier:name; 30, identifier:representation; 31, block; 31, 32; 32, continue_statement; 33, try_statement; 33, 34; 33, 154; 34, block; 34, 35; 34, 57; 34, 65; 34, 71; 35, if_statement; 35, 36; 35, 51; 36, parenthesized_expression; 36, 37; 37, boolean_operator:and; 37, 38; 37, 48; 38, not_operator; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:representation; 44, identifier:name; 45, tuple; 45, 46; 45, 47; 46, identifier:list; 47, identifier:tuple; 48, attribute; 48, 49; 48, 50; 49, identifier:field; 50, identifier:many; 51, block; 51, 52; 52, raise_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:ValueError; 55, argument_list; 55, 56; 56, string:"field should be sequence"; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:source; 60, call; 60, 61; 60, 62; 61, identifier:_source; 62, argument_list; 62, 63; 62, 64; 63, identifier:name; 64, identifier:field; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:value; 68, subscript; 68, 69; 68, 70; 69, identifier:representation; 70, identifier:name; 71, if_statement; 71, 72; 71, 75; 71, 119; 72, attribute; 72, 73; 72, 74; 73, identifier:field; 74, identifier:many; 75, block; 75, 76; 76, if_statement; 76, 77; 76, 81; 76, 97; 77, not_operator; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:field; 80, identifier:allow_null; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:object_dict; 86, identifier:source; 87, list_comprehension; 87, 88; 87, 94; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:field; 91, identifier:from_representation; 92, argument_list; 92, 93; 93, identifier:single_value; 94, for_in_clause; 94, 95; 94, 96; 95, identifier:single_value; 96, identifier:value; 97, else_clause; 97, 98; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:object_dict; 103, identifier:source; 104, list_comprehension; 104, 105; 104, 116; 105, conditional_expression:if; 105, 106; 105, 112; 105, 115; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:field; 109, identifier:from_representation; 110, argument_list; 110, 111; 111, identifier:single_value; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:single_value; 114, None; 115, None; 116, for_in_clause; 116, 117; 116, 118; 117, identifier:single_value; 118, identifier:value; 119, else_clause; 119, 120; 120, block; 120, 121; 121, if_statement; 121, 122; 121, 126; 121, 138; 122, not_operator; 122, 123; 123, attribute; 123, 124; 123, 125; 124, identifier:field; 125, identifier:allow_null; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:object_dict; 131, identifier:source; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:field; 135, identifier:from_representation; 136, argument_list; 136, 137; 137, identifier:value; 138, else_clause; 138, 139; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:object_dict; 144, identifier:source; 145, conditional_expression:if; 145, 146; 145, 152; 145, 153; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:field; 149, identifier:from_representation; 150, argument_list; 150, 151; 151, identifier:value; 152, identifier:value; 153, None; 154, except_clause; 154, 155; 154, 159; 155, as_pattern; 155, 156; 155, 157; 156, identifier:ValueError; 157, as_pattern_target; 157, 158; 158, identifier:err; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:failed; 164, identifier:name; 165, call; 165, 166; 165, 167; 166, identifier:str; 167, argument_list; 167, 168; 168, identifier:err; 169, if_statement; 169, 170; 169, 171; 170, identifier:failed; 171, block; 171, 172; 172, try_statement; 172, 173; 172, 185; 173, block; 173, 174; 173, 181; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:validate; 179, argument_list; 179, 180; 180, identifier:object_dict; 181, raise_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:DeserializationError; 184, argument_list; 185, except_clause; 185, 186; 185, 190; 186, as_pattern; 186, 187; 186, 188; 187, identifier:DeserializationError; 188, as_pattern_target; 188, 189; 189, identifier:err; 190, block; 190, 191; 190, 197; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:err; 195, identifier:failed; 196, identifier:failed; 197, raise_statement; 198, return_statement; 198, 199; 199, identifier:object_dict | def from_representation(self, representation):
object_dict = {}
failed = {}
for name, field in self.fields.items():
if name not in representation:
continue
try:
if (
not isinstance(representation[name], (list, tuple)) and
field.many
):
raise ValueError("field should be sequence")
source = _source(name, field)
value = representation[name]
if field.many:
if not field.allow_null:
object_dict[source] = [
field.from_representation(single_value)
for single_value in value
]
else:
object_dict[source] = [
field.from_representation(single_value)
if single_value is not None else None
for single_value in value
]
else:
if not field.allow_null:
object_dict[source] = field.from_representation(value)
else:
object_dict[source] = field.from_representation(
value) if value else None
except ValueError as err:
failed[name] = str(err)
if failed:
try:
self.validate(object_dict)
raise DeserializationError()
except DeserializationError as err:
err.failed = failed
raise
return object_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:require_params; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:req; 6, block; 6, 7; 6, 11; 6, 185; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:params; 10, dictionary; 11, for_statement; 11, 12; 11, 15; 11, 22; 12, pattern_list; 12, 13; 12, 14; 13, identifier:name; 14, identifier:param; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:params; 20, identifier:items; 21, argument_list; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 33; 23, 77; 24, boolean_operator:and; 24, 25; 24, 30; 25, comparison_operator:not; 25, 26; 25, 27; 26, identifier:name; 27, attribute; 27, 28; 27, 29; 28, identifier:req; 29, identifier:params; 30, attribute; 30, 31; 30, 32; 31, identifier:param; 32, identifier:required; 33, block; 33, 34; 33, 65; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:missing; 37, binary_operator:-; 37, 38; 37, 55; 38, call; 38, 39; 38, 40; 39, identifier:set; 40, generator_expression; 40, 41; 40, 42; 40, 47; 41, identifier:p; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:p; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:params; 47, if_clause; 47, 48; 48, attribute; 48, 49; 48, 54; 49, subscript; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:params; 53, identifier:p; 54, identifier:required; 55, call; 55, 56; 55, 57; 56, identifier:set; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:req; 62, identifier:params; 63, identifier:keys; 64, argument_list; 65, raise_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:errors; 69, identifier:HTTPMissingParam; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, string:", "; 74, identifier:join; 75, argument_list; 75, 76; 76, identifier:missing; 77, elif_clause; 77, 78; 77, 87; 78, boolean_operator:or; 78, 79; 78, 84; 79, comparison_operator:in; 79, 80; 79, 81; 80, identifier:name; 81, attribute; 81, 82; 81, 83; 82, identifier:req; 83, identifier:params; 84, attribute; 84, 85; 84, 86; 85, identifier:param; 86, identifier:default; 87, block; 87, 88; 88, try_statement; 88, 89; 88, 155; 88, 168; 89, block; 89, 90; 90, if_statement; 90, 91; 90, 94; 90, 132; 91, attribute; 91, 92; 91, 93; 92, identifier:param; 93, identifier:many; 94, block; 94, 95; 94, 121; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:values; 98, boolean_operator:or; 98, 99; 98, 108; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:req; 102, identifier:get_param_as_list; 103, argument_list; 103, 104; 103, 105; 104, identifier:name; 105, attribute; 105, 106; 105, 107; 106, identifier:param; 107, identifier:validated_value; 108, list:[
param.default and
param.validated_value(param.default)
]; 108, 109; 109, boolean_operator:and; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:param; 112, identifier:default; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:param; 116, identifier:validated_value; 117, argument_list; 117, 118; 118, attribute; 118, 119; 118, 120; 119, identifier:param; 120, identifier:default; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:params; 125, identifier:name; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:param; 129, identifier:container; 130, argument_list; 130, 131; 131, identifier:values; 132, else_clause; 132, 133; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:params; 138, identifier:name; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:param; 142, identifier:validated_value; 143, argument_list; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:req; 147, identifier:get_param; 148, argument_list; 148, 149; 148, 150; 149, identifier:name; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:default; 152, attribute; 152, 153; 152, 154; 153, identifier:param; 154, identifier:default; 155, except_clause; 155, 156; 155, 160; 156, as_pattern; 156, 157; 156, 158; 157, identifier:ValidationError; 158, as_pattern_target; 158, 159; 159, identifier:err; 160, block; 160, 161; 161, raise_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:err; 165, identifier:as_invalid_param; 166, argument_list; 166, 167; 167, identifier:name; 168, except_clause; 168, 169; 168, 173; 169, as_pattern; 169, 170; 169, 171; 170, identifier:ValueError; 171, as_pattern_target; 171, 172; 172, identifier:err; 173, block; 173, 174; 174, raise_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:errors; 178, identifier:HTTPInvalidParam; 179, argument_list; 179, 180; 179, 184; 180, call; 180, 181; 180, 182; 181, identifier:str; 182, argument_list; 182, 183; 183, identifier:err; 184, identifier:name; 185, return_statement; 185, 186; 186, identifier:params | def require_params(self, req):
params = {}
for name, param in self.params.items():
if name not in req.params and param.required:
missing = set(
p for p in self.params
if self.params[p].required
) - set(req.params.keys())
raise errors.HTTPMissingParam(", ".join(missing))
elif name in req.params or param.default:
try:
if param.many:
values = req.get_param_as_list(
name, param.validated_value
) or [
param.default and
param.validated_value(param.default)
]
params[name] = param.container(values)
else:
params[name] = param.validated_value(
req.get_param(name, default=param.default)
)
except ValidationError as err:
raise err.as_invalid_param(name)
except ValueError as err:
raise errors.HTTPInvalidParam(str(err), name)
return params |
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:celf; 5, identifier:s; 6, block; 6, 7; 6, 9; 6, 271; 6, 280; 6, 287; 7, expression_statement; 7, 8; 8, string:"generates an Introspection tree from the given XML string description."; 9, function_definition; 9, 10; 9, 11; 9, 15; 10, function_name:from_string_elts; 11, parameters; 11, 12; 11, 13; 11, 14; 12, identifier:celf; 13, identifier:attrs; 14, identifier:tree; 15, block; 15, 16; 15, 30; 15, 59; 15, 63; 15, 203; 15, 264; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:elts; 19, call; 19, 20; 19, 21; 20, identifier:dict; 21, generator_expression; 21, 22; 21, 27; 22, tuple; 22, 23; 22, 24; 23, identifier:k; 24, subscript; 24, 25; 24, 26; 25, identifier:attrs; 26, identifier:k; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:k; 29, identifier:attrs; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:child_tags; 33, call; 33, 34; 33, 35; 33, 36; 34, identifier:dict; 35, line_continuation:\; 36, generator_expression; 36, 37; 36, 42; 37, tuple; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:childclass; 40, identifier:tag_name; 41, identifier:childclass; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:childclass; 44, binary_operator:+; 44, 45; 44, 55; 45, call; 45, 46; 45, 47; 46, identifier:tuple; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:celf; 52, identifier:tag_elts; 53, identifier:values; 54, argument_list; 55, tuple; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:Introspection; 58, identifier:Annotation; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:children; 62, list:[]; 63, for_statement; 63, 64; 63, 65; 63, 66; 64, identifier:child; 65, identifier:tree; 66, block; 66, 67; 66, 83; 66, 91; 66, 95; 66, 158; 66, 191; 67, if_statement; 67, 68; 67, 73; 68, comparison_operator:not; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:child; 71, identifier:tag; 72, identifier:child_tags; 73, block; 73, 74; 74, raise_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:KeyError; 77, argument_list; 77, 78; 78, binary_operator:%; 78, 79; 78, 80; 79, string:"unrecognized tag %s"; 80, attribute; 80, 81; 80, 82; 81, identifier:child; 82, identifier:tag; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:childclass; 86, subscript; 86, 87; 86, 88; 87, identifier:child_tags; 88, attribute; 88, 89; 88, 90; 89, identifier:child; 90, identifier:tag; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:childattrs; 94, dictionary; 95, for_statement; 95, 96; 95, 97; 95, 100; 96, identifier:attrname; 97, attribute; 97, 98; 97, 99; 98, identifier:childclass; 99, identifier:tag_attrs; 100, block; 100, 101; 101, if_statement; 101, 102; 101, 113; 101, 128; 102, boolean_operator:and; 102, 103; 102, 108; 103, call; 103, 104; 103, 105; 104, identifier:hasattr; 105, argument_list; 105, 106; 105, 107; 106, identifier:childclass; 107, string:"tag_attrs_optional"; 108, comparison_operator:in; 108, 109; 108, 110; 109, identifier:attrname; 110, attribute; 110, 111; 110, 112; 111, identifier:childclass; 112, identifier:tag_attrs_optional; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:childattrs; 118, identifier:attrname; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:child; 123, identifier:attrib; 124, identifier:get; 125, argument_list; 125, 126; 125, 127; 126, identifier:attrname; 127, None; 128, else_clause; 128, 129; 129, block; 129, 130; 129, 148; 130, if_statement; 130, 131; 130, 136; 131, comparison_operator:not; 131, 132; 131, 133; 132, identifier:attrname; 133, attribute; 133, 134; 133, 135; 134, identifier:child; 135, identifier:attrib; 136, block; 136, 137; 137, raise_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:ValueError; 140, argument_list; 140, 141; 141, binary_operator:%; 141, 142; 141, 143; 142, string:"missing %s attribute for %s tag"; 143, tuple; 143, 144; 143, 145; 144, identifier:attrname; 145, attribute; 145, 146; 145, 147; 146, identifier:child; 147, identifier:tag; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:childattrs; 152, identifier:attrname; 153, subscript; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:child; 156, identifier:attrib; 157, identifier:attrname; 158, if_statement; 158, 159; 158, 164; 159, call; 159, 160; 159, 161; 160, identifier:hasattr; 161, argument_list; 161, 162; 161, 163; 162, identifier:childclass; 163, string:"attr_convert"; 164, block; 164, 165; 165, for_statement; 165, 166; 165, 167; 165, 170; 166, identifier:attr; 167, attribute; 167, 168; 167, 169; 168, identifier:childclass; 169, identifier:attr_convert; 170, block; 170, 171; 171, if_statement; 171, 172; 171, 175; 172, comparison_operator:in; 172, 173; 172, 174; 173, identifier:attr; 174, identifier:childattrs; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:childattrs; 180, identifier:attr; 181, call; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:childclass; 185, identifier:attr_convert; 186, identifier:attr; 187, argument_list; 187, 188; 188, subscript; 188, 189; 188, 190; 189, identifier:childattrs; 190, identifier:attr; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:children; 195, identifier:append; 196, argument_list; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:from_string_elts; 199, argument_list; 199, 200; 199, 201; 199, 202; 200, identifier:childclass; 201, identifier:childattrs; 202, identifier:child; 203, for_statement; 203, 204; 203, 207; 203, 232; 204, pattern_list; 204, 205; 204, 206; 205, identifier:child_tag; 206, identifier:childclass; 207, binary_operator:+; 207, 208; 207, 218; 208, call; 208, 209; 208, 210; 209, identifier:tuple; 210, argument_list; 210, 211; 211, call; 211, 212; 211, 217; 212, attribute; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:celf; 215, identifier:tag_elts; 216, identifier:items; 217, argument_list; 218, subscript; 218, 219; 218, 227; 219, tuple; 219, 220; 219, 221; 220, tuple; 221, tuple; 221, 222; 222, tuple; 222, 223; 222, 224; 223, string:"annotations"; 224, attribute; 224, 225; 224, 226; 225, identifier:Introspection; 226, identifier:Annotation; 227, comparison_operator:!=; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:tree; 230, identifier:tag; 231, string:"annotation"; 232, block; 232, 233; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:child; 235, identifier:children; 236, block; 236, 237; 237, if_statement; 237, 238; 237, 243; 238, call; 238, 239; 238, 240; 239, identifier:isinstance; 240, argument_list; 240, 241; 240, 242; 241, identifier:child; 242, identifier:childclass; 243, block; 243, 244; 243, 255; 244, if_statement; 244, 245; 244, 248; 245, comparison_operator:not; 245, 246; 245, 247; 246, identifier:child_tag; 247, identifier:elts; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:elts; 253, identifier:child_tag; 254, list:[]; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, subscript; 258, 259; 258, 260; 259, identifier:elts; 260, identifier:child_tag; 261, identifier:append; 262, argument_list; 262, 263; 263, identifier:child; 264, return_statement; 264, 265; 264, 266; 265, line_continuation:\; 266, call; 266, 267; 266, 268; 267, identifier:celf; 268, argument_list; 268, 269; 269, dictionary_splat; 269, 270; 270, identifier:elts; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:tree; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:XMLElementTree; 277, identifier:fromstring; 278, argument_list; 278, 279; 279, identifier:s; 280, assert_statement; 280, 281; 280, 286; 281, comparison_operator:==; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:tree; 284, identifier:tag; 285, string:"node"; 286, string:"root of introspection tree must be <node> tag"; 287, return_statement; 287, 288; 287, 289; 288, line_continuation:\; 289, call; 289, 290; 289, 291; 290, identifier:from_string_elts; 291, argument_list; 291, 292; 291, 293; 291, 294; 292, identifier:Introspection; 293, dictionary; 294, identifier:tree | def parse(celf, s) :
"generates an Introspection tree from the given XML string description."
def from_string_elts(celf, attrs, tree) :
elts = dict((k, attrs[k]) for k in attrs)
child_tags = dict \
(
(childclass.tag_name, childclass)
for childclass in tuple(celf.tag_elts.values()) + (Introspection.Annotation,)
)
children = []
for child in tree :
if child.tag not in child_tags :
raise KeyError("unrecognized tag %s" % child.tag)
childclass = child_tags[child.tag]
childattrs = {}
for attrname in childclass.tag_attrs :
if hasattr(childclass, "tag_attrs_optional") and attrname in childclass.tag_attrs_optional :
childattrs[attrname] = child.attrib.get(attrname, None)
else :
if attrname not in child.attrib :
raise ValueError("missing %s attribute for %s tag" % (attrname, child.tag))
childattrs[attrname] = child.attrib[attrname]
if hasattr(childclass, "attr_convert") :
for attr in childclass.attr_convert :
if attr in childattrs :
childattrs[attr] = childclass.attr_convert[attr](childattrs[attr])
children.append(from_string_elts(childclass, childattrs, child))
for child_tag, childclass in tuple(celf.tag_elts.items()) + ((), (("annotations", Introspection.Annotation),))[tree.tag != "annotation"] :
for child in children :
if isinstance(child, childclass) :
if child_tag not in elts :
elts[child_tag] = []
elts[child_tag].append(child)
return \
celf(**elts)
tree = XMLElementTree.fromstring(s)
assert tree.tag == "node", "root of introspection tree must be <node> tag"
return \
from_string_elts(Introspection, {}, tree) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:unparse; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:indent_step; 7, integer:4; 8, default_parameter; 8, 9; 8, 10; 9, identifier:max_linelen; 10, integer:72; 11, block; 11, 12; 11, 14; 11, 22; 11, 352; 11, 361; 11, 368; 11, 389; 11, 396; 11, 408; 11, 420; 11, 427; 12, expression_statement; 12, 13; 13, string:"returns an XML string description of this Introspection tree."; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:out; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:io; 20, identifier:StringIO; 21, argument_list; 22, function_definition; 22, 23; 22, 24; 22, 27; 23, function_name:to_string; 24, parameters; 24, 25; 24, 26; 25, identifier:obj; 26, identifier:indent; 27, block; 27, 28; 27, 34; 27, 38; 27, 125; 27, 169; 27, 182; 27, 284; 27, 295; 27, 302; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:tag_name; 31, attribute; 31, 32; 31, 33; 32, identifier:obj; 33, identifier:tag_name; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:attrs; 37, list:[]; 38, for_statement; 38, 39; 38, 40; 38, 43; 39, identifier:attrname; 40, attribute; 40, 41; 40, 42; 41, identifier:obj; 42, identifier:tag_attrs; 43, block; 43, 44; 43, 52; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:attr; 47, call; 47, 48; 47, 49; 48, identifier:getattr; 49, argument_list; 49, 50; 49, 51; 50, identifier:obj; 51, identifier:attrname; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:!=; 53, 54; 53, 55; 54, identifier:attr; 55, None; 56, block; 56, 57; 56, 111; 57, if_statement; 57, 58; 57, 65; 57, 72; 57, 86; 58, call; 58, 59; 58, 60; 59, identifier:isinstance; 60, argument_list; 60, 61; 60, 62; 61, identifier:attr; 62, attribute; 62, 63; 62, 64; 63, identifier:enum; 64, identifier:Enum; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:attr; 69, attribute; 69, 70; 69, 71; 70, identifier:attr; 71, identifier:value; 72, elif_clause; 72, 73; 72, 78; 73, call; 73, 74; 73, 75; 74, identifier:isinstance; 75, argument_list; 75, 76; 75, 77; 76, identifier:attr; 77, identifier:Type; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:attr; 82, call; 82, 83; 82, 84; 83, identifier:unparse_signature; 84, argument_list; 84, 85; 85, identifier:attr; 86, elif_clause; 86, 87; 86, 93; 87, not_operator; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:attr; 92, identifier:str; 93, block; 93, 94; 94, raise_statement; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:TypeError; 97, argument_list; 97, 98; 98, binary_operator:%; 98, 99; 98, 100; 99, string:"unexpected attribute type %s for %s"; 100, tuple; 100, 101; 100, 107; 101, attribute; 101, 102; 101, 106; 102, call; 102, 103; 102, 104; 103, identifier:type; 104, argument_list; 104, 105; 105, identifier:attr; 106, identifier:__name__; 107, call; 107, 108; 107, 109; 108, identifier:repr; 109, argument_list; 109, 110; 110, identifier:attr; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:attrs; 115, identifier:append; 116, argument_list; 116, 117; 117, binary_operator:%; 117, 118; 117, 119; 118, string:"%s=%s"; 119, tuple; 119, 120; 119, 121; 120, identifier:attrname; 121, call; 121, 122; 121, 123; 122, identifier:quote_xml_attr; 123, argument_list; 123, 124; 124, identifier:attr; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 126, 129; 127, identifier:has_elts; 128, line_continuation:\; 129, parenthesized_expression; 129, 130; 130, comparison_operator:!=; 130, 131; 130, 168; 131, call; 131, 132; 131, 133; 132, identifier:sum; 133, generator_expression; 133, 134; 133, 142; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:getattr; 139, argument_list; 139, 140; 139, 141; 140, identifier:obj; 141, identifier:attrname; 142, for_in_clause; 142, 143; 142, 144; 143, identifier:attrname; 144, binary_operator:+; 144, 145; 144, 155; 145, call; 145, 146; 145, 147; 146, identifier:tuple; 147, argument_list; 147, 148; 148, call; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:obj; 152, identifier:tag_elts; 153, identifier:keys; 154, argument_list; 155, subscript; 155, 156; 155, 160; 156, tuple; 156, 157; 156, 158; 157, tuple; 158, tuple; 158, 159; 159, string:"annotations"; 160, not_operator; 160, 161; 161, call; 161, 162; 161, 163; 162, identifier:isinstance; 163, argument_list; 163, 164; 163, 165; 164, identifier:obj; 165, attribute; 165, 166; 165, 167; 166, identifier:Introspection; 167, identifier:Annotation; 168, integer:0; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:out; 173, identifier:write; 174, argument_list; 174, 175; 175, binary_operator:+; 175, 176; 175, 181; 176, binary_operator:+; 176, 177; 176, 180; 177, binary_operator:*; 177, 178; 177, 179; 178, string:" "; 179, identifier:indent; 180, string:"<"; 181, identifier:tag_name; 182, if_statement; 182, 183; 182, 217; 182, 264; 183, parenthesized_expression; 183, 184; 184, boolean_operator:and; 184, 185; 184, 188; 185, comparison_operator:!=; 185, 186; 185, 187; 186, identifier:max_linelen; 187, None; 188, comparison_operator:>; 188, 189; 188, 216; 189, binary_operator:+; 189, 190; 189, 212; 190, binary_operator:+; 190, 191; 190, 211; 191, binary_operator:+; 191, 192; 191, 198; 192, binary_operator:+; 192, 193; 192, 194; 193, identifier:indent; 194, call; 194, 195; 194, 196; 195, identifier:len; 196, argument_list; 196, 197; 197, identifier:tag_name; 198, call; 198, 199; 198, 200; 199, identifier:sum; 200, generator_expression; 200, 201; 200, 208; 201, parenthesized_expression; 201, 202; 202, binary_operator:+; 202, 203; 202, 207; 203, call; 203, 204; 203, 205; 204, identifier:len; 205, argument_list; 205, 206; 206, identifier:s; 207, integer:1; 208, for_in_clause; 208, 209; 208, 210; 209, identifier:s; 210, identifier:attrs; 211, integer:2; 212, call; 212, 213; 212, 214; 213, identifier:int; 214, argument_list; 214, 215; 215, identifier:has_elts; 216, identifier:max_linelen; 217, block; 217, 218; 217, 225; 217, 255; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:out; 222, identifier:write; 223, argument_list; 223, 224; 224, string:"\n"; 225, for_statement; 225, 226; 225, 227; 225, 228; 226, identifier:attr; 227, identifier:attrs; 228, block; 228, 229; 228, 241; 228, 248; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:out; 233, identifier:write; 234, argument_list; 234, 235; 235, binary_operator:*; 235, 236; 235, 237; 236, string:" "; 237, parenthesized_expression; 237, 238; 238, binary_operator:+; 238, 239; 238, 240; 239, identifier:indent; 240, identifier:indent_step; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:out; 245, identifier:write; 246, argument_list; 246, 247; 247, identifier:attr; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:out; 252, identifier:write; 253, argument_list; 253, 254; 254, string:"\n"; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:out; 259, identifier:write; 260, argument_list; 260, 261; 261, binary_operator:*; 261, 262; 261, 263; 262, string:" "; 263, identifier:indent; 264, else_clause; 264, 265; 265, block; 265, 266; 266, for_statement; 266, 267; 266, 268; 266, 269; 267, identifier:attr; 268, identifier:attrs; 269, block; 269, 270; 269, 277; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:out; 274, identifier:write; 275, argument_list; 275, 276; 276, string:" "; 277, expression_statement; 277, 278; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:out; 281, identifier:write; 282, argument_list; 282, 283; 283, identifier:attr; 284, if_statement; 284, 285; 284, 287; 285, not_operator; 285, 286; 286, identifier:has_elts; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:out; 292, identifier:write; 293, argument_list; 293, 294; 294, string:"/"; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:out; 299, identifier:write; 300, argument_list; 300, 301; 301, string:">\n"; 302, if_statement; 302, 303; 302, 304; 303, identifier:has_elts; 304, block; 304, 305; 304, 337; 305, for_statement; 305, 306; 305, 307; 305, 320; 306, identifier:attrname; 307, binary_operator:+; 307, 308; 307, 318; 308, call; 308, 309; 308, 310; 309, identifier:sorted; 310, argument_list; 310, 311; 311, call; 311, 312; 311, 317; 312, attribute; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:obj; 315, identifier:tag_elts; 316, identifier:keys; 317, argument_list; 318, list:["annotations"]; 318, 319; 319, string:"annotations"; 320, block; 320, 321; 321, for_statement; 321, 322; 321, 323; 321, 328; 322, identifier:elt; 323, call; 323, 324; 323, 325; 324, identifier:getattr; 325, argument_list; 325, 326; 325, 327; 326, identifier:obj; 327, identifier:attrname; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, call; 330, 331; 330, 332; 331, identifier:to_string; 332, argument_list; 332, 333; 332, 334; 333, identifier:elt; 334, binary_operator:+; 334, 335; 334, 336; 335, identifier:indent; 336, identifier:indent_step; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:out; 341, identifier:write; 342, argument_list; 342, 343; 343, binary_operator:+; 343, 344; 343, 351; 344, binary_operator:+; 344, 345; 344, 350; 345, binary_operator:+; 345, 346; 345, 349; 346, binary_operator:*; 346, 347; 346, 348; 347, string:" "; 348, identifier:indent; 349, string:"</"; 350, identifier:tag_name; 351, string:">\n"; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:out; 356, identifier:write; 357, argument_list; 357, 358; 358, attribute; 358, 359; 358, 360; 359, identifier:DBUS; 360, identifier:INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE; 361, expression_statement; 361, 362; 362, call; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:out; 365, identifier:write; 366, argument_list; 366, 367; 367, string:"<node"; 368, if_statement; 368, 369; 368, 374; 369, comparison_operator:!=; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:self; 372, identifier:name; 373, None; 374, block; 374, 375; 375, expression_statement; 375, 376; 376, call; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:out; 379, identifier:write; 380, argument_list; 380, 381; 381, binary_operator:%; 381, 382; 381, 383; 382, string:" name=%s"; 383, call; 383, 384; 383, 385; 384, identifier:quote_xml_attr; 385, argument_list; 385, 386; 386, attribute; 386, 387; 386, 388; 387, identifier:self; 388, identifier:name; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:out; 393, identifier:write; 394, argument_list; 394, 395; 395, string:">\n"; 396, for_statement; 396, 397; 396, 398; 396, 401; 397, identifier:elt; 398, attribute; 398, 399; 398, 400; 399, identifier:self; 400, identifier:interfaces; 401, block; 401, 402; 402, expression_statement; 402, 403; 403, call; 403, 404; 403, 405; 404, identifier:to_string; 405, argument_list; 405, 406; 405, 407; 406, identifier:elt; 407, identifier:indent_step; 408, for_statement; 408, 409; 408, 410; 408, 413; 409, identifier:elt; 410, attribute; 410, 411; 410, 412; 411, identifier:self; 412, identifier:nodes; 413, block; 413, 414; 414, expression_statement; 414, 415; 415, call; 415, 416; 415, 417; 416, identifier:to_string; 417, argument_list; 417, 418; 417, 419; 418, identifier:elt; 419, identifier:indent_step; 420, expression_statement; 420, 421; 421, call; 421, 422; 421, 425; 422, attribute; 422, 423; 422, 424; 423, identifier:out; 424, identifier:write; 425, argument_list; 425, 426; 426, string:"</node>\n"; 427, return_statement; 427, 428; 427, 429; 428, line_continuation:\; 429, call; 429, 430; 429, 433; 430, attribute; 430, 431; 430, 432; 431, identifier:out; 432, identifier:getvalue; 433, argument_list | def unparse(self, indent_step = 4, max_linelen = 72) :
"returns an XML string description of this Introspection tree."
out = io.StringIO()
def to_string(obj, indent) :
tag_name = obj.tag_name
attrs = []
for attrname in obj.tag_attrs :
attr = getattr(obj, attrname)
if attr != None :
if isinstance(attr, enum.Enum) :
attr = attr.value
elif isinstance(attr, Type) :
attr = unparse_signature(attr)
elif not isinstance(attr, str) :
raise TypeError("unexpected attribute type %s for %s" % (type(attr).__name__, repr(attr)))
attrs.append("%s=%s" % (attrname, quote_xml_attr(attr)))
has_elts = \
(
sum
(
len(getattr(obj, attrname))
for attrname in
tuple(obj.tag_elts.keys())
+
((), ("annotations",))
[not isinstance(obj, Introspection.Annotation)]
)
!=
0
)
out.write(" " * indent + "<" + tag_name)
if (
max_linelen != None
and
indent
+
len(tag_name)
+
sum((len(s) + 1) for s in attrs)
+
2
+
int(has_elts)
>
max_linelen
) :
out.write("\n")
for attr in attrs :
out.write(" " * (indent + indent_step))
out.write(attr)
out.write("\n")
out.write(" " * indent)
else :
for attr in attrs :
out.write(" ")
out.write(attr)
if not has_elts :
out.write("/")
out.write(">\n")
if has_elts :
for attrname in sorted(obj.tag_elts.keys()) + ["annotations"] :
for elt in getattr(obj, attrname) :
to_string(elt, indent + indent_step)
out.write(" " * indent + "</" + tag_name + ">\n")
out.write(DBUS.INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE)
out.write("<node")
if self.name != None :
out.write(" name=%s" % quote_xml_attr(self.name))
out.write(">\n")
for elt in self.interfaces :
to_string(elt, indent_step)
for elt in self.nodes :
to_string(elt, indent_step)
out.write("</node>\n")
return \
out.getvalue() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:AddMethod; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:interface; 6, identifier:name; 7, identifier:in_sig; 8, identifier:out_sig; 9, identifier:code; 10, block; 10, 11; 10, 13; 10, 23; 10, 35; 10, 58; 10, 75; 10, 84; 10, 90; 10, 108; 10, 124; 11, expression_statement; 11, 12; 12, string:'''Add a method to this object
interface: D-Bus interface to add this to. For convenience you can
specify '' here to add the method to the object's main
interface (as specified on construction).
name: Name of the method
in_sig: Signature of input arguments; for example "ias" for a method
that takes an int32 and a string array as arguments; see
http://dbus.freedesktop.org/doc/dbus-specification.html
out_sig: Signature of output arguments; for example "s" for a method
that returns a string; use '' for methods that do not return
anything.
code: Python 3 code to run in the method call; you have access to the
arguments through the "args" list, and can set the return value
by assigning a value to the "ret" variable. You can also read the
global "objects" variable, which is a dictionary mapping object
paths to DBusMockObject instances.
For keeping state across method calls, you are free to use normal
Python members of the "self" object, which will be persistent for
the whole mock's life time. E. g. you can have a method with
"self.my_state = True", and another method that returns it with
"ret = self.my_state".
When specifying '', the method will not do anything (except
logging) and return None.
'''; 13, if_statement; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:interface; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:interface; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:interface; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:n_args; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:dbus; 32, identifier:Signature; 33, argument_list; 33, 34; 34, identifier:in_sig; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:method; 38, lambda; 38, 39; 38, 45; 39, lambda_parameters; 39, 40; 39, 41; 39, 43; 40, identifier:self; 41, list_splat_pattern; 41, 42; 42, identifier:args; 43, dictionary_splat_pattern; 43, 44; 44, identifier:kwargs; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:DBusMockObject; 48, identifier:mock_method; 49, argument_list; 49, 50; 49, 51; 49, 52; 49, 53; 49, 54; 49, 56; 50, identifier:self; 51, identifier:interface; 52, identifier:name; 53, identifier:in_sig; 54, list_splat; 54, 55; 55, identifier:args; 56, dictionary_splat; 56, 57; 57, identifier:kwargs; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:dbus_method; 61, call; 61, 62; 61, 73; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:dbus; 66, identifier:service; 67, identifier:method; 68, argument_list; 68, 69; 68, 70; 69, identifier:interface; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:out_signature; 72, identifier:out_sig; 73, argument_list; 73, 74; 74, identifier:method; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:dbus_method; 79, identifier:__name__; 80, call; 80, 81; 80, 82; 81, identifier:str; 82, argument_list; 82, 83; 83, identifier:name; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:dbus_method; 88, identifier:_dbus_in_signature; 89, identifier:in_sig; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:dbus_method; 94, identifier:_dbus_args; 95, list_comprehension; 95, 96; 95, 99; 96, binary_operator:%; 96, 97; 96, 98; 97, string:'arg%i'; 98, identifier:i; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:i; 101, call; 101, 102; 101, 103; 102, identifier:range; 103, argument_list; 103, 104; 103, 105; 104, integer:1; 105, binary_operator:+; 105, 106; 105, 107; 106, identifier:n_args; 107, integer:1; 108, if_statement; 108, 109; 108, 114; 109, comparison_operator:==; 109, 110; 109, 111; 110, identifier:interface; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:interface; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:setattr; 118, argument_list; 118, 119; 118, 122; 118, 123; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:__class__; 122, identifier:name; 123, identifier:dbus_method; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 140; 126, subscript; 126, 127; 126, 136; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:methods; 132, identifier:setdefault; 133, argument_list; 133, 134; 133, 135; 134, identifier:interface; 135, dictionary; 136, call; 136, 137; 136, 138; 137, identifier:str; 138, argument_list; 138, 139; 139, identifier:name; 140, tuple; 140, 141; 140, 142; 140, 143; 140, 144; 141, identifier:in_sig; 142, identifier:out_sig; 143, identifier:code; 144, identifier:dbus_method | def AddMethod(self, interface, name, in_sig, out_sig, code):
'''Add a method to this object
interface: D-Bus interface to add this to. For convenience you can
specify '' here to add the method to the object's main
interface (as specified on construction).
name: Name of the method
in_sig: Signature of input arguments; for example "ias" for a method
that takes an int32 and a string array as arguments; see
http://dbus.freedesktop.org/doc/dbus-specification.html
out_sig: Signature of output arguments; for example "s" for a method
that returns a string; use '' for methods that do not return
anything.
code: Python 3 code to run in the method call; you have access to the
arguments through the "args" list, and can set the return value
by assigning a value to the "ret" variable. You can also read the
global "objects" variable, which is a dictionary mapping object
paths to DBusMockObject instances.
For keeping state across method calls, you are free to use normal
Python members of the "self" object, which will be persistent for
the whole mock's life time. E. g. you can have a method with
"self.my_state = True", and another method that returns it with
"ret = self.my_state".
When specifying '', the method will not do anything (except
logging) and return None.
'''
if not interface:
interface = self.interface
n_args = len(dbus.Signature(in_sig))
method = lambda self, *args, **kwargs: DBusMockObject.mock_method(
self, interface, name, in_sig, *args, **kwargs)
dbus_method = dbus.service.method(interface,
out_signature=out_sig)(method)
dbus_method.__name__ = str(name)
dbus_method._dbus_in_signature = in_sig
dbus_method._dbus_args = ['arg%i' % i for i in range(1, n_args + 1)]
if interface == self.interface:
setattr(self.__class__, name, dbus_method)
self.methods.setdefault(interface, {})[str(name)] = (in_sig, out_sig, code, dbus_method) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:AddTemplate; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:template; 6, identifier:parameters; 7, block; 7, 8; 7, 10; 7, 44; 7, 61; 7, 134; 7, 143; 7, 151; 7, 157; 8, expression_statement; 8, 9; 9, string:'''Load a template into the mock.
python-dbusmock ships a set of standard mocks for common system
services such as UPower and NetworkManager. With these the actual tests
become a lot simpler, as they only have to set up the particular
properties for the tests, and not the skeleton of common properties,
interfaces, and methods.
template: Name of the template to load or the full path to a *.py file
for custom templates. See "pydoc dbusmock.templates" for a
list of available templates from python-dbusmock package, and
"pydoc dbusmock.templates.NAME" for documentation about
template NAME.
parameters: A parameter (string) → value (variant) map, for
parameterizing templates. Each template can define their
own, see documentation of that particular template for
details.
'''; 10, try_statement; 10, 11; 10, 19; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:module; 15, call; 15, 16; 15, 17; 16, identifier:load_module; 17, argument_list; 17, 18; 18, identifier:template; 19, except_clause; 19, 20; 19, 24; 20, as_pattern; 20, 21; 20, 22; 21, identifier:ImportError; 22, as_pattern_target; 22, 23; 23, identifier:e; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:dbus; 30, identifier:exceptions; 31, identifier:DBusException; 32, argument_list; 32, 33; 32, 41; 33, binary_operator:%; 33, 34; 33, 35; 34, string:'Cannot add template %s: %s'; 35, tuple; 35, 36; 35, 37; 36, identifier:template; 37, call; 37, 38; 37, 39; 38, identifier:str; 39, argument_list; 39, 40; 40, identifier:e; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:name; 43, string:'org.freedesktop.DBus.Mock.TemplateError'; 44, if_statement; 44, 45; 44, 54; 45, boolean_operator:and; 45, 46; 45, 51; 46, call; 46, 47; 46, 48; 47, identifier:hasattr; 48, argument_list; 48, 49; 48, 50; 49, identifier:module; 50, string:'IS_OBJECT_MANAGER'; 51, attribute; 51, 52; 51, 53; 52, identifier:module; 53, identifier:IS_OBJECT_MANAGER; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_set_up_object_manager; 60, argument_list; 61, for_statement; 61, 62; 61, 63; 61, 67; 62, identifier:symbol; 63, call; 63, 64; 63, 65; 64, identifier:dir; 65, argument_list; 65, 66; 66, identifier:module; 67, block; 67, 68; 67, 76; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:fn; 71, call; 71, 72; 71, 73; 72, identifier:getattr; 73, argument_list; 73, 74; 73, 75; 74, identifier:module; 75, identifier:symbol; 76, if_statement; 76, 77; 76, 97; 77, parenthesized_expression; 77, 78; 78, boolean_operator:and; 78, 79; 78, 85; 79, comparison_operator:in; 79, 80; 79, 81; 80, string:'_dbus_interface'; 81, call; 81, 82; 81, 83; 82, identifier:dir; 83, argument_list; 83, 84; 84, identifier:fn; 85, parenthesized_expression; 85, 86; 86, boolean_operator:or; 86, 87; 86, 93; 87, comparison_operator:not; 87, 88; 87, 89; 88, string:'_dbus_is_signal'; 89, call; 89, 90; 89, 91; 90, identifier:dir; 91, argument_list; 91, 92; 92, identifier:fn; 93, not_operator; 93, 94; 94, attribute; 94, 95; 94, 96; 95, identifier:fn; 96, identifier:_dbus_is_signal; 97, block; 97, 98; 97, 107; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:setattr; 101, argument_list; 101, 102; 101, 105; 101, 106; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:__class__; 105, identifier:symbol; 106, identifier:fn; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 125; 109, subscript; 109, 110; 109, 121; 110, call; 110, 111; 110, 116; 111, attribute; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:methods; 115, identifier:setdefault; 116, argument_list; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:fn; 119, identifier:_dbus_interface; 120, dictionary; 121, call; 121, 122; 121, 123; 122, identifier:str; 123, argument_list; 123, 124; 124, identifier:symbol; 125, tuple; 125, 126; 125, 129; 125, 132; 125, 133; 126, attribute; 126, 127; 126, 128; 127, identifier:fn; 128, identifier:_dbus_in_signature; 129, attribute; 129, 130; 129, 131; 130, identifier:fn; 131, identifier:_dbus_out_signature; 132, string:''; 133, identifier:fn; 134, if_statement; 134, 135; 134, 138; 135, comparison_operator:is; 135, 136; 135, 137; 136, identifier:parameters; 137, None; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:parameters; 142, dictionary; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:module; 147, identifier:load; 148, argument_list; 148, 149; 148, 150; 149, identifier:self; 150, identifier:parameters; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:_template; 156, identifier:template; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:_template_parameters; 162, identifier:parameters | def AddTemplate(self, template, parameters):
'''Load a template into the mock.
python-dbusmock ships a set of standard mocks for common system
services such as UPower and NetworkManager. With these the actual tests
become a lot simpler, as they only have to set up the particular
properties for the tests, and not the skeleton of common properties,
interfaces, and methods.
template: Name of the template to load or the full path to a *.py file
for custom templates. See "pydoc dbusmock.templates" for a
list of available templates from python-dbusmock package, and
"pydoc dbusmock.templates.NAME" for documentation about
template NAME.
parameters: A parameter (string) → value (variant) map, for
parameterizing templates. Each template can define their
own, see documentation of that particular template for
details.
'''
try:
module = load_module(template)
except ImportError as e:
raise dbus.exceptions.DBusException('Cannot add template %s: %s' % (template, str(e)),
name='org.freedesktop.DBus.Mock.TemplateError')
if hasattr(module, 'IS_OBJECT_MANAGER') and module.IS_OBJECT_MANAGER:
self._set_up_object_manager()
for symbol in dir(module):
fn = getattr(module, symbol)
if ('_dbus_interface' in dir(fn) and ('_dbus_is_signal' not in dir(fn) or not fn._dbus_is_signal)):
setattr(self.__class__, symbol, fn)
self.methods.setdefault(fn._dbus_interface, {})[str(symbol)] = (
fn._dbus_in_signature,
fn._dbus_out_signature, '', fn
)
if parameters is None:
parameters = {}
module.load(self, parameters)
self._template = template
self._template_parameters = parameters |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:format_args; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:args; 6, block; 6, 7; 6, 9; 6, 195; 6, 199; 6, 217; 6, 226; 7, expression_statement; 7, 8; 8, string:'''Format a D-Bus argument tuple into an appropriate logging string.'''; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:format_arg; 11, parameters; 11, 12; 12, identifier:a; 13, block; 13, 14; 13, 31; 13, 48; 13, 66; 13, 82; 13, 109; 13, 134; 13, 190; 14, if_statement; 14, 15; 14, 22; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:a; 19, attribute; 19, 20; 19, 21; 20, identifier:dbus; 21, identifier:Boolean; 22, block; 22, 23; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:str; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:bool; 29, argument_list; 29, 30; 30, identifier:a; 31, if_statement; 31, 32; 31, 39; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:a; 36, attribute; 36, 37; 36, 38; 37, identifier:dbus; 38, identifier:Byte; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:str; 43, argument_list; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:int; 46, argument_list; 46, 47; 47, identifier:a; 48, if_statement; 48, 49; 48, 60; 49, boolean_operator:or; 49, 50; 49, 55; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:a; 54, identifier:int; 55, call; 55, 56; 55, 57; 56, identifier:isinstance; 57, argument_list; 57, 58; 57, 59; 58, identifier:a; 59, identifier:long; 60, block; 60, 61; 61, return_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:str; 64, argument_list; 64, 65; 65, identifier:a; 66, if_statement; 66, 67; 66, 72; 67, call; 67, 68; 67, 69; 68, identifier:isinstance; 69, argument_list; 69, 70; 69, 71; 70, identifier:a; 71, identifier:str; 72, block; 72, 73; 73, return_statement; 73, 74; 74, binary_operator:+; 74, 75; 74, 81; 75, binary_operator:+; 75, 76; 75, 77; 76, string:'"'; 77, call; 77, 78; 77, 79; 78, identifier:str; 79, argument_list; 79, 80; 80, identifier:a; 81, string:'"'; 82, if_statement; 82, 83; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 87; 86, identifier:a; 87, identifier:unicode; 88, block; 88, 89; 89, return_statement; 89, 90; 90, binary_operator:+; 90, 91; 90, 108; 91, binary_operator:+; 91, 92; 91, 93; 92, string:'"'; 93, subscript; 93, 94; 93, 103; 94, call; 94, 95; 94, 96; 95, identifier:repr; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:a; 100, identifier:encode; 101, argument_list; 101, 102; 102, string:'UTF-8'; 103, slice; 103, 104; 103, 105; 103, 106; 104, integer:1; 105, colon; 106, unary_operator:-; 106, 107; 107, integer:1; 108, string:'"'; 109, if_statement; 109, 110; 109, 115; 110, call; 110, 111; 110, 112; 111, identifier:isinstance; 112, argument_list; 112, 113; 112, 114; 113, identifier:a; 114, identifier:list; 115, block; 115, 116; 116, return_statement; 116, 117; 117, binary_operator:+; 117, 118; 117, 133; 118, binary_operator:+; 118, 119; 118, 120; 119, string:'['; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, string:', '; 123, identifier:join; 124, argument_list; 124, 125; 125, list_comprehension; 125, 126; 125, 130; 126, call; 126, 127; 126, 128; 127, identifier:format_arg; 128, argument_list; 128, 129; 129, identifier:x; 130, for_in_clause; 130, 131; 130, 132; 131, identifier:x; 132, identifier:a; 133, string:']'; 134, if_statement; 134, 135; 134, 140; 135, call; 135, 136; 135, 137; 136, identifier:isinstance; 137, argument_list; 137, 138; 137, 139; 138, identifier:a; 139, identifier:dict; 140, block; 140, 141; 140, 145; 140, 149; 140, 186; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:fmta; 144, string:'{'; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:first; 148, True; 149, for_statement; 149, 150; 149, 153; 149, 158; 150, pattern_list; 150, 151; 150, 152; 151, identifier:k; 152, identifier:v; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:a; 156, identifier:items; 157, argument_list; 158, block; 158, 159; 158, 172; 159, if_statement; 159, 160; 159, 161; 159, 166; 160, identifier:first; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:first; 165, False; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, augmented_assignment:+=; 169, 170; 169, 171; 170, identifier:fmta; 171, string:', '; 172, expression_statement; 172, 173; 173, augmented_assignment:+=; 173, 174; 173, 175; 174, identifier:fmta; 175, binary_operator:+; 175, 176; 175, 182; 176, binary_operator:+; 176, 177; 176, 181; 177, call; 177, 178; 177, 179; 178, identifier:format_arg; 179, argument_list; 179, 180; 180, identifier:k; 181, string:': '; 182, call; 182, 183; 182, 184; 183, identifier:format_arg; 184, argument_list; 184, 185; 185, identifier:v; 186, return_statement; 186, 187; 187, binary_operator:+; 187, 188; 187, 189; 188, identifier:fmta; 189, string:'}'; 190, return_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:repr; 193, argument_list; 193, 194; 194, identifier:a; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:s; 198, string:''; 199, for_statement; 199, 200; 199, 201; 199, 202; 200, identifier:a; 201, identifier:args; 202, block; 202, 203; 202, 210; 203, if_statement; 203, 204; 203, 205; 204, identifier:s; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, augmented_assignment:+=; 207, 208; 207, 209; 208, identifier:s; 209, string:' '; 210, expression_statement; 210, 211; 211, augmented_assignment:+=; 211, 212; 211, 213; 212, identifier:s; 213, call; 213, 214; 213, 215; 214, identifier:format_arg; 215, argument_list; 215, 216; 216, identifier:a; 217, if_statement; 217, 218; 217, 219; 218, identifier:s; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:s; 223, binary_operator:+; 223, 224; 223, 225; 224, string:' '; 225, identifier:s; 226, return_statement; 226, 227; 227, identifier:s | def format_args(self, args):
'''Format a D-Bus argument tuple into an appropriate logging string.'''
def format_arg(a):
if isinstance(a, dbus.Boolean):
return str(bool(a))
if isinstance(a, dbus.Byte):
return str(int(a))
if isinstance(a, int) or isinstance(a, long):
return str(a)
if isinstance(a, str):
return '"' + str(a) + '"'
if isinstance(a, unicode):
return '"' + repr(a.encode('UTF-8'))[1:-1] + '"'
if isinstance(a, list):
return '[' + ', '.join([format_arg(x) for x in a]) + ']'
if isinstance(a, dict):
fmta = '{'
first = True
for k, v in a.items():
if first:
first = False
else:
fmta += ', '
fmta += format_arg(k) + ': ' + format_arg(v)
return fmta + '}'
return repr(a)
s = ''
for a in args:
if s:
s += ' '
s += format_arg(a)
if s:
s = ' ' + s
return s |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:Introspect; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:object_path; 6, identifier:connection; 7, block; 7, 8; 7, 10; 7, 26; 7, 34; 7, 42; 7, 78; 7, 86; 7, 101; 7, 110; 7, 207; 7, 227; 7, 235; 8, expression_statement; 8, 9; 9, string:'''Return XML description of this object's interfaces, methods and signals.
This wraps dbus-python's Introspect() method to include the dynamic
methods and properties.
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:cls; 13, binary_operator:+; 13, 14; 13, 21; 14, binary_operator:+; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:__class__; 19, identifier:__module__; 20, string:'.'; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:__class__; 25, identifier:__name__; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:orig_interfaces; 29, subscript; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_dbus_class_table; 33, identifier:cls; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:mock_interfaces; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:orig_interfaces; 40, identifier:copy; 41, argument_list; 42, for_statement; 42, 43; 42, 46; 42, 53; 43, pattern_list; 43, 44; 43, 45; 44, identifier:interface; 45, identifier:methods; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:methods; 51, identifier:items; 52, argument_list; 53, block; 53, 54; 54, for_statement; 54, 55; 54, 56; 54, 57; 55, identifier:method; 56, identifier:methods; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 69; 60, subscript; 60, 61; 60, 68; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:mock_interfaces; 64, identifier:setdefault; 65, argument_list; 65, 66; 65, 67; 66, identifier:interface; 67, dictionary; 68, identifier:method; 69, subscript; 69, 70; 69, 77; 70, subscript; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:methods; 75, identifier:interface; 76, identifier:method; 77, integer:3; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 85; 80, subscript; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_dbus_class_table; 84, identifier:cls; 85, identifier:mock_interfaces; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:xml; 89, call; 89, 90; 89, 97; 90, attribute; 90, 91; 90, 96; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:dbus; 94, identifier:service; 95, identifier:Object; 96, identifier:Introspect; 97, argument_list; 97, 98; 97, 99; 97, 100; 98, identifier:self; 99, identifier:object_path; 100, identifier:connection; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:tree; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:ElementTree; 107, identifier:fromstring; 108, argument_list; 108, 109; 109, identifier:xml; 110, for_statement; 110, 111; 110, 112; 110, 115; 111, identifier:name; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:props; 115, block; 115, 116; 115, 127; 115, 152; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:interface; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:tree; 122, identifier:find; 123, argument_list; 123, 124; 124, binary_operator:%; 124, 125; 124, 126; 125, string:".//interface[@name='%s']"; 126, identifier:name; 127, if_statement; 127, 128; 127, 131; 128, comparison_operator:is; 128, 129; 128, 130; 129, identifier:interface; 130, None; 131, block; 131, 132; 131, 145; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:interface; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:ElementTree; 138, identifier:Element; 139, argument_list; 139, 140; 139, 141; 140, string:"interface"; 141, dictionary; 141, 142; 142, pair; 142, 143; 142, 144; 143, string:"name"; 144, identifier:name; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:tree; 149, identifier:append; 150, argument_list; 150, 151; 151, identifier:interface; 152, for_statement; 152, 153; 152, 156; 152, 165; 153, pattern_list; 153, 154; 153, 155; 154, identifier:prop; 155, identifier:val; 156, call; 156, 157; 156, 164; 157, attribute; 157, 158; 157, 163; 158, subscript; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:props; 162, identifier:name; 163, identifier:items; 164, argument_list; 165, block; 165, 166; 165, 172; 165, 200; 166, if_statement; 166, 167; 166, 170; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:val; 169, None; 170, block; 170, 171; 171, continue_statement; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:elem; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:ElementTree; 178, identifier:Element; 179, argument_list; 179, 180; 179, 181; 180, string:"property"; 181, dictionary; 181, 182; 181, 185; 181, 197; 182, pair; 182, 183; 182, 184; 183, string:"name"; 184, identifier:prop; 185, pair; 185, 186; 185, 187; 186, string:"type"; 187, call; 187, 188; 187, 195; 188, attribute; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:dbus; 192, identifier:lowlevel; 193, identifier:Message; 194, identifier:guess_signature; 195, argument_list; 195, 196; 196, identifier:val; 197, pair; 197, 198; 197, 199; 198, string:"access"; 199, string:"readwrite"; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:interface; 204, identifier:append; 205, argument_list; 205, 206; 206, identifier:elem; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:xml; 210, call; 210, 211; 210, 225; 211, attribute; 211, 212; 211, 224; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:ElementTree; 215, identifier:tostring; 216, argument_list; 216, 217; 216, 218; 216, 221; 217, identifier:tree; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:encoding; 220, string:'utf8'; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:method; 223, string:'xml'; 224, identifier:decode; 225, argument_list; 225, 226; 226, string:'utf8'; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 234; 229, subscript; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:_dbus_class_table; 233, identifier:cls; 234, identifier:orig_interfaces; 235, return_statement; 235, 236; 236, identifier:xml | def Introspect(self, object_path, connection):
'''Return XML description of this object's interfaces, methods and signals.
This wraps dbus-python's Introspect() method to include the dynamic
methods and properties.
'''
cls = self.__class__.__module__ + '.' + self.__class__.__name__
orig_interfaces = self._dbus_class_table[cls]
mock_interfaces = orig_interfaces.copy()
for interface, methods in self.methods.items():
for method in methods:
mock_interfaces.setdefault(interface, {})[method] = self.methods[interface][method][3]
self._dbus_class_table[cls] = mock_interfaces
xml = dbus.service.Object.Introspect(self, object_path, connection)
tree = ElementTree.fromstring(xml)
for name in self.props:
interface = tree.find(".//interface[@name='%s']" % name)
if interface is None:
interface = ElementTree.Element("interface", {"name": name})
tree.append(interface)
for prop, val in self.props[name].items():
if val is None:
continue
elem = ElementTree.Element("property", {
"name": prop,
"type": dbus.lowlevel.Message.guess_signature(val),
"access": "readwrite"})
interface.append(elem)
xml = ElementTree.tostring(tree, encoding='utf8', method='xml').decode('utf8')
self._dbus_class_table[cls] = orig_interfaces
return xml |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:argument; 3, parameters; 3, 4; 3, 6; 3, 9; 4, list_splat_pattern; 4, 5; 5, identifier:param_decls; 6, default_parameter; 6, 7; 6, 8; 7, identifier:cls; 8, None; 9, dictionary_splat_pattern; 9, 10; 10, identifier:attrs; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:click; 16, identifier:argument; 17, argument_list; 17, 18; 17, 20; 17, 25; 18, list_splat; 18, 19; 19, identifier:param_decls; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:cls; 22, boolean_operator:or; 22, 23; 22, 24; 23, identifier:cls; 24, identifier:Argument; 25, dictionary_splat; 25, 26; 26, identifier:attrs | def argument(*param_decls, cls=None, **attrs):
return click.argument(*param_decls, cls=cls or Argument, **attrs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:option; 3, parameters; 3, 4; 3, 6; 3, 9; 4, list_splat_pattern; 4, 5; 5, identifier:param_decls; 6, default_parameter; 6, 7; 6, 8; 7, identifier:cls; 8, None; 9, dictionary_splat_pattern; 9, 10; 10, identifier:attrs; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:click; 16, identifier:option; 17, argument_list; 17, 18; 17, 20; 17, 25; 18, list_splat; 18, 19; 19, identifier:param_decls; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:cls; 22, boolean_operator:or; 22, 23; 22, 24; 23, identifier:cls; 24, identifier:Option; 25, dictionary_splat; 25, 26; 26, identifier:attrs | def option(*param_decls, cls=None, **attrs):
return click.option(*param_decls, cls=cls or Option, **attrs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:add_to_loader_class; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:cls; 5, default_parameter; 5, 6; 5, 7; 6, identifier:loader_class; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:tag; 10, None; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 13, 23; 13, 31; 13, 41; 13, 55; 13, 63; 13, 101; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:tag; 17, None; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:tag; 22, string:''; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:tag; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:tag; 29, identifier:strip; 30, argument_list; 31, if_statement; 31, 32; 31, 34; 32, not_operator; 32, 33; 33, identifier:tag; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:tag; 38, attribute; 38, 39; 38, 40; 39, identifier:cls; 40, identifier:DEFAULT_TAG_NAME; 41, if_statement; 41, 42; 41, 49; 42, not_operator; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:tag; 46, identifier:startswith; 47, argument_list; 47, 48; 48, string:'!'; 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:'`tag` argument should start with character "!"'; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:instance; 58, call; 58, 59; 58, 60; 59, identifier:cls; 60, argument_list; 60, 61; 61, dictionary_splat; 61, 62; 62, identifier:kwargs; 63, if_statement; 63, 64; 63, 67; 63, 90; 64, comparison_operator:is; 64, 65; 64, 66; 65, identifier:loader_class; 66, None; 67, block; 67, 68; 68, if_statement; 68, 69; 68, 70; 68, 80; 69, identifier:FullLoader; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:yaml; 75, identifier:add_constructor; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:tag; 78, identifier:instance; 79, identifier:FullLoader; 80, else_clause; 80, 81; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:yaml; 86, identifier:add_constructor; 87, argument_list; 87, 88; 87, 89; 88, identifier:tag; 89, identifier:instance; 90, else_clause; 90, 91; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:yaml; 96, identifier:add_constructor; 97, argument_list; 97, 98; 97, 99; 97, 100; 98, identifier:tag; 99, identifier:instance; 100, identifier:loader_class; 101, return_statement; 101, 102; 102, identifier:instance | def add_to_loader_class(cls, loader_class=None, tag=None, **kwargs):
if tag is None:
tag = ''
tag = tag.strip()
if not tag:
tag = cls.DEFAULT_TAG_NAME
if not tag.startswith('!'):
raise ValueError('`tag` argument should start with character "!"')
instance = cls(**kwargs)
if loader_class is None:
if FullLoader:
yaml.add_constructor(tag, instance, FullLoader)
else:
yaml.add_constructor(tag, instance)
else:
yaml.add_constructor(tag, instance, loader_class)
return instance |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 1, 28; 2, function_name:print_table; 3, parameters; 3, 4; 3, 8; 3, 12; 3, 21; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:column_names; 6, type; 6, 7; 7, identifier:IterableOfStrings; 8, typed_parameter; 8, 9; 8, 10; 9, identifier:rows; 10, type; 10, 11; 11, identifier:IterableOfTuples; 12, typed_default_parameter; 12, 13; 12, 14; 12, 20; 13, identifier:column_alignments; 14, type; 14, 15; 15, generic_type; 15, 16; 15, 17; 16, identifier:Optional; 17, type_parameter; 17, 18; 18, type; 18, 19; 19, identifier:IterableOfStrings; 20, None; 21, typed_default_parameter; 21, 22; 21, 23; 21, 25; 22, identifier:primary_column_idx; 23, type; 23, 24; 24, identifier:int; 25, integer:0; 26, type; 26, 27; 27, None; 28, block; 28, 29; 28, 33; 28, 37; 28, 41; 28, 54; 28, 73; 28, 83; 28, 105; 28, 145; 28, 208; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:header_template; 32, string:''; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:row_template; 36, string:''; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:table_width; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:type_formatters; 44, dictionary; 44, 45; 44, 48; 44, 51; 45, pair; 45, 46; 45, 47; 46, identifier:int; 47, string:'d'; 48, pair; 48, 49; 48, 50; 49, identifier:float; 50, string:'f'; 51, pair; 51, 52; 51, 53; 52, identifier:str; 53, string:'s'; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:types; 57, list_comprehension; 57, 58; 57, 68; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:type_formatters; 61, identifier:get; 62, argument_list; 62, 63; 62, 67; 63, call; 63, 64; 63, 65; 64, identifier:type; 65, argument_list; 65, 66; 66, identifier:x; 67, string:'r'; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:x; 70, subscript; 70, 71; 70, 72; 71, identifier:rows; 72, integer:0; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:alignments; 76, dictionary; 76, 77; 76, 80; 77, pair; 77, 78; 77, 79; 78, identifier:int; 79, string:'>'; 80, pair; 80, 81; 80, 82; 81, identifier:float; 82, string:'>'; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:column_alignments; 86, parenthesized_expression; 86, 87; 87, boolean_operator:or; 87, 88; 87, 89; 88, identifier:column_alignments; 89, list_comprehension; 89, 90; 89, 100; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:alignments; 93, identifier:get; 94, argument_list; 94, 95; 94, 99; 95, call; 95, 96; 95, 97; 96, identifier:type; 97, argument_list; 97, 98; 98, identifier:x; 99, string:'<'; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:x; 102, subscript; 102, 103; 102, 104; 103, identifier:rows; 104, integer:0; 105, function_definition; 105, 106; 105, 107; 105, 109; 106, function_name:get_column_width; 107, parameters; 107, 108; 108, identifier:idx; 109, block; 109, 110; 109, 119; 109, 137; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:header_length; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, subscript; 116, 117; 116, 118; 117, identifier:column_names; 118, identifier:idx; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:content_length; 122, call; 122, 123; 122, 124; 123, identifier:max; 124, generator_expression; 124, 125; 124, 134; 125, call; 125, 126; 125, 127; 126, identifier:len; 127, argument_list; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:str; 130, argument_list; 130, 131; 131, subscript; 131, 132; 131, 133; 132, identifier:row; 133, identifier:idx; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:row; 136, identifier:rows; 137, return_statement; 137, 138; 138, parenthesized_expression; 138, 139; 139, conditional_expression:if; 139, 140; 139, 141; 139, 144; 140, identifier:content_length; 141, comparison_operator:>; 141, 142; 141, 143; 142, identifier:content_length; 143, identifier:header_length; 144, identifier:header_length; 145, for_statement; 145, 146; 145, 147; 145, 155; 146, identifier:i; 147, call; 147, 148; 147, 149; 148, identifier:range; 149, argument_list; 149, 150; 149, 151; 150, integer:0; 151, call; 151, 152; 151, 153; 152, identifier:len; 153, argument_list; 153, 154; 154, identifier:column_names; 155, block; 155, 156; 155, 163; 155, 167; 155, 171; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:col_width; 159, call; 159, 160; 159, 161; 160, identifier:get_column_width; 161, argument_list; 161, 162; 162, identifier:i; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:header_col_template; 166, string:f'{{:{col_width}}}'; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:col_template; 170, string:f'{{:{column_alignments[i]}{col_width}{types[i]}}}'; 171, if_statement; 171, 172; 171, 175; 171, 188; 172, comparison_operator:==; 172, 173; 172, 174; 173, identifier:i; 174, integer:0; 175, block; 175, 176; 175, 180; 175, 184; 176, expression_statement; 176, 177; 177, augmented_assignment:+=; 177, 178; 177, 179; 178, identifier:header_template; 179, identifier:header_col_template; 180, expression_statement; 180, 181; 181, augmented_assignment:+=; 181, 182; 181, 183; 182, identifier:row_template; 183, identifier:col_template; 184, expression_statement; 184, 185; 185, augmented_assignment:+=; 185, 186; 185, 187; 186, identifier:table_width; 187, identifier:col_width; 188, else_clause; 188, 189; 189, block; 189, 190; 189, 196; 189, 202; 190, expression_statement; 190, 191; 191, augmented_assignment:+=; 191, 192; 191, 193; 192, identifier:header_template; 193, binary_operator:+; 193, 194; 193, 195; 194, string:' '; 195, identifier:header_col_template; 196, expression_statement; 196, 197; 197, augmented_assignment:+=; 197, 198; 197, 199; 198, identifier:row_template; 199, binary_operator:+; 199, 200; 199, 201; 200, string:' '; 201, identifier:col_template; 202, expression_statement; 202, 203; 203, augmented_assignment:+=; 203, 204; 203, 205; 204, identifier:table_width; 205, binary_operator:+; 205, 206; 205, 207; 206, integer:2; 207, identifier:col_width; 208, if_statement; 208, 209; 208, 214; 208, 267; 209, comparison_operator:<; 209, 210; 209, 211; 210, identifier:table_width; 211, call; 211, 212; 211, 213; 212, identifier:get_terminal_width; 213, argument_list; 214, block; 214, 215; 214, 228; 214, 237; 215, expression_statement; 215, 216; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:click; 219, identifier:echo; 220, argument_list; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:header_template; 224, identifier:format; 225, argument_list; 225, 226; 226, list_splat; 226, 227; 227, identifier:column_names; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:click; 232, identifier:echo; 233, argument_list; 233, 234; 234, binary_operator:*; 234, 235; 234, 236; 235, string:'-'; 236, identifier:table_width; 237, for_statement; 237, 238; 237, 239; 237, 240; 238, identifier:row; 239, identifier:rows; 240, block; 240, 241; 241, try_statement; 241, 242; 241, 256; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:click; 247, identifier:echo; 248, argument_list; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:row_template; 252, identifier:format; 253, argument_list; 253, 254; 254, list_splat; 254, 255; 255, identifier:row; 256, except_clause; 256, 257; 256, 261; 257, as_pattern; 257, 258; 257, 259; 258, identifier:TypeError; 259, as_pattern_target; 259, 260; 260, identifier:e; 261, block; 261, 262; 262, raise_statement; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:TypeError; 265, argument_list; 265, 266; 266, string:f'{e}: {row!r}'; 267, else_clause; 267, 268; 268, block; 268, 269; 268, 284; 268, 303; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:max_label_width; 272, call; 272, 273; 272, 274; 273, identifier:max; 274, argument_list; 274, 275; 275, list_splat; 275, 276; 276, list_comprehension; 276, 277; 276, 281; 277, call; 277, 278; 277, 279; 278, identifier:len; 279, argument_list; 279, 280; 280, identifier:label; 281, for_in_clause; 281, 282; 281, 283; 282, identifier:label; 283, identifier:column_names; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:non_primary_columns; 287, list_comprehension; 287, 288; 287, 291; 287, 299; 288, tuple; 288, 289; 288, 290; 289, identifier:i; 290, identifier:col; 291, for_in_clause; 291, 292; 291, 295; 292, pattern_list; 292, 293; 292, 294; 293, identifier:i; 294, identifier:col; 295, call; 295, 296; 295, 297; 296, identifier:enumerate; 297, argument_list; 297, 298; 298, identifier:column_names; 299, if_clause; 299, 300; 300, comparison_operator:!=; 300, 301; 300, 302; 301, identifier:i; 302, identifier:primary_column_idx; 303, for_statement; 303, 304; 303, 305; 303, 306; 304, identifier:row; 305, identifier:rows; 306, block; 306, 307; 306, 313; 306, 317; 306, 334; 306, 359; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:type_; 310, subscript; 310, 311; 310, 312; 311, identifier:types; 312, identifier:primary_column_idx; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:row_template; 316, string:f'{{:>{max_label_width}s}}: {{:{type_}}}'; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:click; 321, identifier:echo; 322, argument_list; 322, 323; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:row_template; 326, identifier:format; 327, argument_list; 327, 328; 327, 331; 328, subscript; 328, 329; 328, 330; 329, identifier:column_names; 330, identifier:primary_column_idx; 331, subscript; 331, 332; 331, 333; 332, identifier:row; 333, identifier:primary_column_idx; 334, for_statement; 334, 335; 334, 338; 334, 339; 335, pattern_list; 335, 336; 335, 337; 336, identifier:i; 337, identifier:label; 338, identifier:non_primary_columns; 339, block; 339, 340; 339, 344; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:row_template; 343, string:f'{{:>{max_label_width}s}}: {{:{types[i]}}}'; 344, expression_statement; 344, 345; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:click; 348, identifier:echo; 349, argument_list; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:row_template; 353, identifier:format; 354, argument_list; 354, 355; 354, 356; 355, identifier:label; 356, subscript; 356, 357; 356, 358; 357, identifier:row; 358, identifier:i; 359, expression_statement; 359, 360; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:click; 363, identifier:echo; 364, argument_list | def print_table(column_names: IterableOfStrings,
rows: IterableOfTuples,
column_alignments: Optional[IterableOfStrings] = None,
primary_column_idx: int = 0,
) -> None:
header_template = ''
row_template = ''
table_width = 0
type_formatters = {int: 'd', float: 'f', str: 's'}
types = [type_formatters.get(type(x), 'r') for x in rows[0]]
alignments = {int: '>', float: '>'}
column_alignments = (column_alignments or
[alignments.get(type(x), '<') for x in rows[0]])
def get_column_width(idx):
header_length = len(column_names[idx])
content_length = max(len(str(row[idx])) for row in rows)
return (content_length if content_length > header_length
else header_length)
for i in range(0, len(column_names)):
col_width = get_column_width(i)
header_col_template = f'{{:{col_width}}}'
col_template = f'{{:{column_alignments[i]}{col_width}{types[i]}}}'
if i == 0:
header_template += header_col_template
row_template += col_template
table_width += col_width
else:
header_template += ' ' + header_col_template
row_template += ' ' + col_template
table_width += 2 + col_width
if table_width < get_terminal_width():
click.echo(header_template.format(*column_names))
click.echo('-' * table_width)
for row in rows:
try:
click.echo(row_template.format(*row))
except TypeError as e:
raise TypeError(f'{e}: {row!r}')
else:
max_label_width = max(*[len(label) for label in column_names])
non_primary_columns = [(i, col) for i, col in enumerate(column_names)
if i != primary_column_idx]
for row in rows:
type_ = types[primary_column_idx]
row_template = f'{{:>{max_label_width}s}}: {{:{type_}}}'
click.echo(row_template.format(column_names[primary_column_idx],
row[primary_column_idx]))
for i, label in non_primary_columns:
row_template = f'{{:>{max_label_width}s}}: {{:{types[i]}}}'
click.echo(row_template.format(label, row[i]))
click.echo() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:model_fields; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:model; 5, default_parameter; 5, 6; 5, 7; 6, identifier:db_session; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:only; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:exclude; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:field_args; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:converter; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:exclude_pk; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:exclude_fk; 25, False; 26, block; 26, 27; 26, 35; 26, 43; 26, 49; 26, 53; 26, 102; 26, 138; 26, 142; 26, 177; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:mapper; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:model; 33, identifier:_sa_class_manager; 34, identifier:mapper; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:converter; 38, boolean_operator:or; 38, 39; 38, 40; 39, identifier:converter; 40, call; 40, 41; 40, 42; 41, identifier:_ModelConverter; 42, argument_list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:field_args; 46, boolean_operator:or; 46, 47; 46, 48; 47, identifier:field_args; 48, dictionary; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:properties; 52, list:[]; 53, for_statement; 53, 54; 53, 55; 53, 58; 54, identifier:prop; 55, attribute; 55, 56; 55, 57; 56, identifier:mapper; 57, identifier:iterate_properties; 58, block; 58, 59; 58, 91; 59, if_statement; 59, 60; 59, 66; 60, call; 60, 61; 60, 62; 61, identifier:getattr; 62, argument_list; 62, 63; 62, 64; 62, 65; 63, identifier:prop; 64, string:'columns'; 65, None; 66, block; 66, 67; 67, if_statement; 67, 68; 67, 77; 67, 79; 68, boolean_operator:and; 68, 69; 68, 70; 69, identifier:exclude_fk; 70, attribute; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:prop; 74, identifier:columns; 75, integer:0; 76, identifier:foreign_keys; 77, block; 77, 78; 78, continue_statement; 79, elif_clause; 79, 80; 79, 89; 80, boolean_operator:and; 80, 81; 80, 82; 81, identifier:exclude_pk; 82, attribute; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:prop; 86, identifier:columns; 87, integer:0; 88, identifier:primary_key; 89, block; 89, 90; 90, continue_statement; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:properties; 95, identifier:append; 96, argument_list; 96, 97; 97, tuple; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:prop; 100, identifier:key; 101, identifier:prop; 102, if_statement; 102, 103; 102, 106; 102, 121; 103, comparison_operator:is; 103, 104; 103, 105; 104, identifier:only; 105, None; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:properties; 110, generator_expression; 110, 111; 110, 112; 110, 115; 111, identifier:x; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:x; 114, identifier:properties; 115, if_clause; 115, 116; 116, comparison_operator:in; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:x; 119, integer:0; 120, identifier:only; 121, elif_clause; 121, 122; 121, 123; 122, identifier:exclude; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:properties; 127, generator_expression; 127, 128; 127, 129; 127, 132; 128, identifier:x; 129, for_in_clause; 129, 130; 129, 131; 130, identifier:x; 131, identifier:properties; 132, if_clause; 132, 133; 133, comparison_operator:not; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:x; 136, integer:0; 137, identifier:exclude; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:field_dict; 141, dictionary; 142, for_statement; 142, 143; 142, 146; 142, 147; 143, pattern_list; 143, 144; 143, 145; 144, identifier:name; 145, identifier:prop; 146, identifier:properties; 147, block; 147, 148; 147, 166; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:field; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:converter; 154, identifier:convert; 155, argument_list; 155, 156; 155, 157; 155, 158; 155, 159; 155, 165; 156, identifier:model; 157, identifier:mapper; 158, identifier:prop; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:field_args; 162, identifier:get; 163, argument_list; 163, 164; 164, identifier:name; 165, identifier:db_session; 166, if_statement; 166, 167; 166, 170; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:field; 169, None; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 176; 173, subscript; 173, 174; 173, 175; 174, identifier:field_dict; 175, identifier:name; 176, identifier:field; 177, return_statement; 177, 178; 178, identifier:field_dict | def model_fields(model, db_session=None, only=None, exclude=None,
field_args=None, converter=None, exclude_pk=False,
exclude_fk=False):
mapper = model._sa_class_manager.mapper
converter = converter or _ModelConverter()
field_args = field_args or {}
properties = []
for prop in mapper.iterate_properties:
if getattr(prop, 'columns', None):
if exclude_fk and prop.columns[0].foreign_keys:
continue
elif exclude_pk and prop.columns[0].primary_key:
continue
properties.append((prop.key, prop))
if only is not None:
properties = (x for x in properties if x[0] in only)
elif exclude:
properties = (x for x in properties if x[0] not in exclude)
field_dict = {}
for name, prop in properties:
field = converter.convert(
model, mapper, prop,
field_args.get(name), db_session
)
if field is not None:
field_dict[name] = field
return field_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:singularize; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:word; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pos; 7, identifier:NOUN; 8, default_parameter; 8, 9; 8, 10; 9, identifier:custom; 10, None; 11, block; 11, 12; 11, 23; 11, 73; 11, 93; 11, 101; 11, 115; 11, 129; 11, 150; 11, 177; 11, 249; 12, if_statement; 12, 13; 12, 18; 13, boolean_operator:and; 13, 14; 13, 15; 14, identifier:custom; 15, comparison_operator:in; 15, 16; 15, 17; 16, identifier:word; 17, identifier:custom; 18, block; 18, 19; 19, return_statement; 19, 20; 20, subscript; 20, 21; 20, 22; 21, identifier:custom; 22, identifier:word; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:in; 24, 25; 24, 26; 25, string:"-"; 26, identifier:word; 27, block; 27, 28; 27, 37; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:w; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:word; 34, identifier:split; 35, argument_list; 35, 36; 36, string:"-"; 37, if_statement; 37, 38; 37, 50; 38, boolean_operator:and; 38, 39; 38, 45; 39, comparison_operator:>; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:w; 44, integer:1; 45, comparison_operator:in; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:w; 48, integer:1; 49, identifier:plural_prepositions; 50, block; 50, 51; 51, return_statement; 51, 52; 52, binary_operator:+; 52, 53; 52, 63; 53, binary_operator:+; 53, 54; 53, 62; 54, call; 54, 55; 54, 56; 55, identifier:singularize; 56, argument_list; 56, 57; 56, 60; 56, 61; 57, subscript; 57, 58; 57, 59; 58, identifier:w; 59, integer:0; 60, identifier:pos; 61, identifier:custom; 62, string:"-"; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, string:"-"; 66, identifier:join; 67, argument_list; 67, 68; 68, subscript; 68, 69; 68, 70; 69, identifier:w; 70, slice; 70, 71; 70, 72; 71, integer:1; 72, colon; 73, if_statement; 73, 74; 73, 80; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:word; 77, identifier:endswith; 78, argument_list; 78, 79; 79, string:"'"; 80, block; 80, 81; 81, return_statement; 81, 82; 82, binary_operator:+; 82, 83; 82, 92; 83, call; 83, 84; 83, 85; 84, identifier:singularize; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 88; 87, identifier:word; 88, slice; 88, 89; 88, 90; 89, colon; 90, unary_operator:-; 90, 91; 91, integer:1; 92, string:"'s"; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:w; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:word; 99, identifier:lower; 100, argument_list; 101, for_statement; 101, 102; 101, 103; 101, 104; 102, identifier:x; 103, identifier:singular_uninflected; 104, block; 104, 105; 105, if_statement; 105, 106; 105, 112; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:x; 109, identifier:endswith; 110, argument_list; 110, 111; 111, identifier:w; 112, block; 112, 113; 113, return_statement; 113, 114; 114, identifier:word; 115, for_statement; 115, 116; 115, 117; 115, 118; 116, identifier:x; 117, identifier:singular_uncountable; 118, block; 118, 119; 119, if_statement; 119, 120; 119, 126; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:x; 123, identifier:endswith; 124, argument_list; 124, 125; 125, identifier:w; 126, block; 126, 127; 127, return_statement; 127, 128; 128, identifier:word; 129, for_statement; 129, 130; 129, 131; 129, 132; 130, identifier:x; 131, identifier:singular_ie; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 142; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:w; 137, identifier:endswith; 138, argument_list; 138, 139; 139, binary_operator:+; 139, 140; 139, 141; 140, identifier:x; 141, string:"s"; 142, block; 142, 143; 143, return_statement; 143, 144; 144, subscript; 144, 145; 144, 146; 145, identifier:w; 146, slice; 146, 147; 146, 148; 147, colon; 148, unary_operator:-; 148, 149; 149, integer:1; 150, for_statement; 150, 151; 150, 152; 150, 153; 151, identifier:x; 152, identifier:singular_irregular; 153, block; 153, 154; 154, if_statement; 154, 155; 154, 161; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:w; 158, identifier:endswith; 159, argument_list; 159, 160; 160, identifier:x; 161, block; 161, 162; 162, return_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:re; 166, identifier:sub; 167, argument_list; 167, 168; 167, 173; 167, 176; 168, binary_operator:+; 168, 169; 168, 172; 169, binary_operator:+; 169, 170; 169, 171; 170, string:'(?i)'; 171, identifier:x; 172, string:'$'; 173, subscript; 173, 174; 173, 175; 174, identifier:singular_irregular; 175, identifier:x; 176, identifier:word; 177, for_statement; 177, 178; 177, 181; 177, 182; 178, pattern_list; 178, 179; 178, 180; 179, identifier:suffix; 180, identifier:inflection; 181, identifier:singular_rules; 182, block; 182, 183; 182, 192; 182, 204; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:m; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:suffix; 189, identifier:search; 190, argument_list; 190, 191; 191, identifier:word; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:g; 195, boolean_operator:or; 195, 196; 195, 203; 196, boolean_operator:and; 196, 197; 196, 198; 197, identifier:m; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:m; 201, identifier:groups; 202, argument_list; 203, list:[]; 204, if_statement; 204, 205; 204, 206; 205, identifier:m; 206, block; 206, 207; 206, 241; 207, for_statement; 207, 208; 207, 209; 207, 216; 208, identifier:k; 209, call; 209, 210; 209, 211; 210, identifier:range; 211, argument_list; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:len; 214, argument_list; 214, 215; 215, identifier:g; 216, block; 216, 217; 217, if_statement; 217, 218; 217, 223; 218, comparison_operator:is; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:g; 221, identifier:k; 222, None; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:inflection; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:inflection; 230, identifier:replace; 231, argument_list; 231, 232; 231, 240; 232, binary_operator:+; 232, 233; 232, 234; 233, string:'\\'; 234, call; 234, 235; 234, 236; 235, identifier:str; 236, argument_list; 236, 237; 237, binary_operator:+; 237, 238; 237, 239; 238, identifier:k; 239, integer:1; 240, string:''; 241, return_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:suffix; 245, identifier:sub; 246, argument_list; 246, 247; 246, 248; 247, identifier:inflection; 248, identifier:word; 249, return_statement; 249, 250; 250, identifier:word | def singularize(word, pos=NOUN, custom=None):
if custom and word in custom:
return custom[word]
if "-" in word:
w = word.split("-")
if len(w) > 1 and w[1] in plural_prepositions:
return singularize(w[0], pos, custom) + "-" + "-".join(w[1:])
if word.endswith("'"):
return singularize(word[:-1]) + "'s"
w = word.lower()
for x in singular_uninflected:
if x.endswith(w):
return word
for x in singular_uncountable:
if x.endswith(w):
return word
for x in singular_ie:
if w.endswith(x + "s"):
return w[:-1]
for x in singular_irregular:
if w.endswith(x):
return re.sub('(?i)' + x + '$', singular_irregular[x], word)
for suffix, inflection in singular_rules:
m = suffix.search(word)
g = m and m.groups() or []
if m:
for k in range(len(g)):
if g[k] is None:
inflection = inflection.replace('\\' + str(k + 1), '')
return suffix.sub(inflection, word)
return word |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 37; 1, 39; 2, function_name:login_user; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 18; 3, 27; 3, 32; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:user; 7, type; 7, 8; 8, identifier:User; 9, typed_default_parameter; 9, 10; 9, 11; 9, 17; 10, identifier:remember; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:Optional; 14, type_parameter; 14, 15; 15, type; 15, 16; 16, identifier:bool; 17, None; 18, typed_default_parameter; 18, 19; 18, 20; 18, 26; 19, identifier:duration; 20, type; 20, 21; 21, generic_type; 21, 22; 21, 23; 22, identifier:Optional; 23, type_parameter; 23, 24; 24, type; 24, 25; 25, identifier:timedelta; 26, None; 27, typed_default_parameter; 27, 28; 27, 29; 27, 31; 28, identifier:force; 29, type; 29, 30; 30, identifier:bool; 31, False; 32, typed_default_parameter; 32, 33; 32, 34; 32, 36; 33, identifier:fresh; 34, type; 34, 35; 35, identifier:bool; 36, True; 37, type; 37, 38; 38, identifier:bool; 39, block; 39, 40; 39, 100; 39, 114; 39, 120; 39, 132; 39, 145; 39, 186; 39, 194; 39, 208; 39, 227; 40, if_statement; 40, 41; 40, 43; 41, not_operator; 41, 42; 42, identifier:force; 43, block; 43, 44; 43, 58; 43, 86; 44, if_statement; 44, 45; 44, 49; 45, not_operator; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:user; 48, identifier:active; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:AuthenticationError; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:_; 56, argument_list; 56, 57; 57, string:'flask_unchained.bundles.security:error.disabled_account'; 58, if_statement; 58, 59; 58, 77; 59, parenthesized_expression; 59, 60; 60, boolean_operator:and; 60, 61; 60, 71; 61, boolean_operator:and; 61, 62; 61, 66; 62, not_operator; 62, 63; 63, attribute; 63, 64; 63, 65; 64, identifier:user; 65, identifier:confirmed_at; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:security; 70, identifier:confirmable; 71, not_operator; 71, 72; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:security; 76, identifier:login_without_confirmation; 77, block; 77, 78; 78, raise_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:AuthenticationError; 81, argument_list; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:_; 84, argument_list; 84, 85; 85, string:'flask_unchained.bundles.security:error.confirmation_required'; 86, if_statement; 86, 87; 86, 91; 87, not_operator; 87, 88; 88, attribute; 88, 89; 88, 90; 89, identifier:user; 90, identifier:password; 91, block; 91, 92; 92, raise_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:AuthenticationError; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:_; 98, argument_list; 98, 99; 99, string:'flask_unchained.bundles.security:error.password_not_set'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:session; 104, string:'user_id'; 105, call; 105, 106; 105, 107; 106, identifier:getattr; 107, argument_list; 107, 108; 107, 109; 108, identifier:user; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:user; 112, identifier:Meta; 113, identifier:pk; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:session; 118, string:'_fresh'; 119, identifier:fresh; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:session; 124, string:'_id'; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:app; 129, identifier:login_manager; 130, identifier:_session_identifier_generator; 131, argument_list; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:is; 133, 134; 133, 135; 134, identifier:remember; 135, None; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:remember; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:app; 143, identifier:config; 144, identifier:SECURITY_DEFAULT_REMEMBER_ME; 145, if_statement; 145, 146; 145, 147; 146, identifier:remember; 147, block; 147, 148; 147, 154; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:session; 152, string:'remember'; 153, string:'set'; 154, if_statement; 154, 155; 154, 158; 155, comparison_operator:is; 155, 156; 155, 157; 156, identifier:duration; 157, None; 158, block; 158, 159; 159, try_statement; 159, 160; 159, 171; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:session; 165, string:'remember_seconds'; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:duration; 169, identifier:total_seconds; 170, argument_list; 171, except_clause; 171, 172; 171, 173; 172, identifier:AttributeError; 173, block; 173, 174; 174, raise_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:Exception; 177, argument_list; 177, 178; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, concatenated_string; 180, 181; 180, 182; 181, string:'duration must be a datetime.timedelta, '; 182, string:'instead got: {0}'; 183, identifier:format; 184, argument_list; 184, 185; 185, identifier:duration; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 193; 188, attribute; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:_request_ctx_stack; 191, identifier:top; 192, identifier:user; 193, identifier:user; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:user_logged_in; 198, identifier:send; 199, argument_list; 199, 200; 199, 205; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:app; 203, identifier:_get_current_object; 204, argument_list; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:user; 207, identifier:user; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:identity_changed; 212, identifier:send; 213, argument_list; 213, 214; 213, 219; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:app; 217, identifier:_get_current_object; 218, argument_list; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:identity; 221, call; 221, 222; 221, 223; 222, identifier:Identity; 223, argument_list; 223, 224; 224, attribute; 224, 225; 224, 226; 225, identifier:user; 226, identifier:id; 227, return_statement; 227, 228; 228, True | def login_user(self,
user: User,
remember: Optional[bool] = None,
duration: Optional[timedelta] = None,
force: bool = False,
fresh: bool = True,
) -> bool:
if not force:
if not user.active:
raise AuthenticationError(
_('flask_unchained.bundles.security:error.disabled_account'))
if (not user.confirmed_at
and self.security.confirmable
and not self.security.login_without_confirmation):
raise AuthenticationError(
_('flask_unchained.bundles.security:error.confirmation_required'))
if not user.password:
raise AuthenticationError(
_('flask_unchained.bundles.security:error.password_not_set'))
session['user_id'] = getattr(user, user.Meta.pk)
session['_fresh'] = fresh
session['_id'] = app.login_manager._session_identifier_generator()
if remember is None:
remember = app.config.SECURITY_DEFAULT_REMEMBER_ME
if remember:
session['remember'] = 'set'
if duration is not None:
try:
session['remember_seconds'] = duration.total_seconds()
except AttributeError:
raise Exception('duration must be a datetime.timedelta, '
'instead got: {0}'.format(duration))
_request_ctx_stack.top.user = user
user_logged_in.send(app._get_current_object(), user=user)
identity_changed.send(app._get_current_object(),
identity=Identity(user.id))
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 70; 1, 78; 2, function_name:url_for; 3, parameters; 3, 4; 3, 8; 3, 17; 3, 32; 3, 41; 3, 50; 3, 59; 3, 68; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:endpoint_or_url_or_config_key; 6, type; 6, 7; 7, identifier:str; 8, typed_default_parameter; 8, 9; 8, 10; 8, 16; 9, identifier:_anchor; 10, type; 10, 11; 11, generic_type; 11, 12; 11, 13; 12, identifier:Optional; 13, type_parameter; 13, 14; 14, type; 14, 15; 15, identifier:str; 16, None; 17, typed_default_parameter; 17, 18; 17, 19; 17, 31; 18, identifier:_cls; 19, type; 19, 20; 20, generic_type; 20, 21; 20, 22; 21, identifier:Optional; 22, type_parameter; 22, 23; 23, type; 23, 24; 24, generic_type; 24, 25; 24, 26; 25, identifier:Union; 26, type_parameter; 26, 27; 26, 29; 27, type; 27, 28; 28, identifier:object; 29, type; 29, 30; 30, identifier:type; 31, None; 32, typed_default_parameter; 32, 33; 32, 34; 32, 40; 33, identifier:_external; 34, type; 34, 35; 35, generic_type; 35, 36; 35, 37; 36, identifier:Optional; 37, type_parameter; 37, 38; 38, type; 38, 39; 39, identifier:bool; 40, False; 41, typed_default_parameter; 41, 42; 41, 43; 41, 49; 42, identifier:_external_host; 43, type; 43, 44; 44, generic_type; 44, 45; 44, 46; 45, identifier:Optional; 46, type_parameter; 46, 47; 47, type; 47, 48; 48, identifier:str; 49, None; 50, typed_default_parameter; 50, 51; 50, 52; 50, 58; 51, identifier:_method; 52, type; 52, 53; 53, generic_type; 53, 54; 53, 55; 54, identifier:Optional; 55, type_parameter; 55, 56; 56, type; 56, 57; 57, identifier:str; 58, None; 59, typed_default_parameter; 59, 60; 59, 61; 59, 67; 60, identifier:_scheme; 61, type; 61, 62; 62, generic_type; 62, 63; 62, 64; 63, identifier:Optional; 64, type_parameter; 64, 65; 65, type; 65, 66; 66, identifier:str; 67, None; 68, dictionary_splat_pattern; 68, 69; 69, identifier:values; 70, type; 70, 71; 71, generic_type; 71, 72; 71, 73; 72, identifier:Union; 73, type_parameter; 73, 74; 73, 76; 74, type; 74, 75; 75, identifier:str; 76, type; 76, 77; 77, None; 78, block; 78, 79; 78, 83; 78, 103; 78, 118; 78, 128; 78, 151; 78, 195; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:what; 82, identifier:endpoint_or_url_or_config_key; 83, if_statement; 83, 84; 83, 91; 84, boolean_operator:and; 84, 85; 84, 86; 85, identifier:what; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:what; 89, identifier:isupper; 90, argument_list; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:what; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:current_app; 99, identifier:config; 100, identifier:get; 101, argument_list; 101, 102; 102, identifier:what; 103, if_statement; 103, 104; 103, 109; 104, call; 104, 105; 104, 106; 105, identifier:isinstance; 106, argument_list; 106, 107; 106, 108; 107, identifier:what; 108, identifier:LocalProxy; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:what; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:what; 116, identifier:_get_current_object; 117, argument_list; 118, if_statement; 118, 119; 118, 125; 119, boolean_operator:or; 119, 120; 119, 122; 120, not_operator; 120, 121; 121, identifier:what; 122, comparison_operator:in; 122, 123; 122, 124; 123, string:'/'; 124, identifier:what; 125, block; 125, 126; 126, return_statement; 126, 127; 127, identifier:what; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:flask_url_for_kwargs; 131, call; 131, 132; 131, 133; 132, identifier:dict; 133, argument_list; 133, 134; 133, 137; 133, 140; 133, 143; 133, 146; 133, 149; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:_anchor; 136, identifier:_anchor; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:_external; 139, identifier:_external; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:_external_host; 142, identifier:_external_host; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:_method; 145, identifier:_method; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:_scheme; 148, identifier:_scheme; 149, dictionary_splat; 149, 150; 150, identifier:values; 151, if_statement; 151, 152; 151, 157; 152, boolean_operator:and; 152, 153; 152, 154; 153, identifier:_cls; 154, comparison_operator:not; 154, 155; 154, 156; 155, string:'.'; 156, identifier:what; 157, block; 157, 158; 157, 166; 157, 175; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:controller_routes; 161, call; 161, 162; 161, 163; 162, identifier:getattr; 163, argument_list; 163, 164; 163, 165; 164, identifier:_cls; 165, identifier:CONTROLLER_ROUTES_ATTR; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:method_routes; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:controller_routes; 172, identifier:get; 173, argument_list; 173, 174; 174, identifier:what; 175, try_statement; 175, 176; 175, 188; 176, block; 176, 177; 177, return_statement; 177, 178; 178, call; 178, 179; 178, 180; 179, identifier:_url_for; 180, argument_list; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:method_routes; 184, integer:0; 185, identifier:endpoint; 186, dictionary_splat; 186, 187; 187, identifier:flask_url_for_kwargs; 188, except_clause; 188, 189; 188, 193; 189, tuple; 189, 190; 189, 191; 189, 192; 190, identifier:BuildError; 191, identifier:IndexError; 192, identifier:TypeError; 193, block; 193, 194; 194, pass_statement; 195, return_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:_url_for; 198, argument_list; 198, 199; 198, 200; 199, identifier:what; 200, dictionary_splat; 200, 201; 201, identifier:flask_url_for_kwargs | def url_for(endpoint_or_url_or_config_key: str,
_anchor: Optional[str] = None,
_cls: Optional[Union[object, type]] = None,
_external: Optional[bool] = False,
_external_host: Optional[str] = None,
_method: Optional[str] = None,
_scheme: Optional[str] = None,
**values,
) -> Union[str, None]:
what = endpoint_or_url_or_config_key
if what and what.isupper():
what = current_app.config.get(what)
if isinstance(what, LocalProxy):
what = what._get_current_object()
if not what or '/' in what:
return what
flask_url_for_kwargs = dict(_anchor=_anchor, _external=_external,
_external_host=_external_host, _method=_method,
_scheme=_scheme, **values)
if _cls and '.' not in what:
controller_routes = getattr(_cls, CONTROLLER_ROUTES_ATTR)
method_routes = controller_routes.get(what)
try:
return _url_for(method_routes[0].endpoint, **flask_url_for_kwargs)
except (
BuildError,
IndexError,
TypeError,
):
pass
return _url_for(what, **flask_url_for_kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 93; 1, 95; 2, function_name:redirect; 3, parameters; 3, 4; 3, 13; 3, 22; 3, 31; 3, 40; 3, 55; 3, 64; 3, 73; 3, 82; 3, 91; 4, typed_default_parameter; 4, 5; 4, 6; 4, 12; 5, identifier:where; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:Optional; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:str; 12, None; 13, typed_default_parameter; 13, 14; 13, 15; 13, 21; 14, identifier:default; 15, type; 15, 16; 16, generic_type; 16, 17; 16, 18; 17, identifier:Optional; 18, type_parameter; 18, 19; 19, type; 19, 20; 20, identifier:str; 21, None; 22, typed_default_parameter; 22, 23; 22, 24; 22, 30; 23, identifier:override; 24, type; 24, 25; 25, generic_type; 25, 26; 25, 27; 26, identifier:Optional; 27, type_parameter; 27, 28; 28, type; 28, 29; 29, identifier:str; 30, None; 31, typed_default_parameter; 31, 32; 31, 33; 31, 39; 32, identifier:_anchor; 33, type; 33, 34; 34, generic_type; 34, 35; 34, 36; 35, identifier:Optional; 36, type_parameter; 36, 37; 37, type; 37, 38; 38, identifier:str; 39, None; 40, typed_default_parameter; 40, 41; 40, 42; 40, 54; 41, identifier:_cls; 42, type; 42, 43; 43, generic_type; 43, 44; 43, 45; 44, identifier:Optional; 45, type_parameter; 45, 46; 46, type; 46, 47; 47, generic_type; 47, 48; 47, 49; 48, identifier:Union; 49, type_parameter; 49, 50; 49, 52; 50, type; 50, 51; 51, identifier:object; 52, type; 52, 53; 53, identifier:type; 54, None; 55, typed_default_parameter; 55, 56; 55, 57; 55, 63; 56, identifier:_external; 57, type; 57, 58; 58, generic_type; 58, 59; 58, 60; 59, identifier:Optional; 60, type_parameter; 60, 61; 61, type; 61, 62; 62, identifier:bool; 63, False; 64, typed_default_parameter; 64, 65; 64, 66; 64, 72; 65, identifier:_external_host; 66, type; 66, 67; 67, generic_type; 67, 68; 67, 69; 68, identifier:Optional; 69, type_parameter; 69, 70; 70, type; 70, 71; 71, identifier:str; 72, None; 73, typed_default_parameter; 73, 74; 73, 75; 73, 81; 74, identifier:_method; 75, type; 75, 76; 76, generic_type; 76, 77; 76, 78; 77, identifier:Optional; 78, type_parameter; 78, 79; 79, type; 79, 80; 80, identifier:str; 81, None; 82, typed_default_parameter; 82, 83; 82, 84; 82, 90; 83, identifier:_scheme; 84, type; 84, 85; 85, generic_type; 85, 86; 85, 87; 86, identifier:Optional; 87, type_parameter; 87, 88; 88, type; 88, 89; 89, identifier:str; 90, None; 91, dictionary_splat_pattern; 91, 92; 92, identifier:values; 93, type; 93, 94; 94, identifier:Response; 95, block; 95, 96; 95, 119; 95, 149; 95, 167; 95, 185; 95, 204; 95, 220; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:flask_url_for_kwargs; 99, call; 99, 100; 99, 101; 100, identifier:dict; 101, argument_list; 101, 102; 101, 105; 101, 108; 101, 111; 101, 114; 101, 117; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:_anchor; 104, identifier:_anchor; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:_external; 107, identifier:_external; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:_external_host; 110, identifier:_external_host; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:_method; 113, identifier:_method; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:_scheme; 116, identifier:_scheme; 117, dictionary_splat; 117, 118; 118, identifier:values; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:urls; 122, list:[url_for(request.args.get('next'), **flask_url_for_kwargs),
url_for(request.form.get('next'), **flask_url_for_kwargs)]; 122, 123; 122, 136; 123, call; 123, 124; 123, 125; 124, identifier:url_for; 125, argument_list; 125, 126; 125, 134; 126, call; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:request; 130, identifier:args; 131, identifier:get; 132, argument_list; 132, 133; 133, string:'next'; 134, dictionary_splat; 134, 135; 135, identifier:flask_url_for_kwargs; 136, call; 136, 137; 136, 138; 137, identifier:url_for; 138, argument_list; 138, 139; 138, 147; 139, call; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:request; 143, identifier:form; 144, identifier:get; 145, argument_list; 145, 146; 146, string:'next'; 147, dictionary_splat; 147, 148; 148, identifier:flask_url_for_kwargs; 149, if_statement; 149, 150; 149, 151; 150, identifier:where; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:urls; 156, identifier:append; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:url_for; 160, argument_list; 160, 161; 160, 162; 160, 165; 161, identifier:where; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:_cls; 164, identifier:_cls; 165, dictionary_splat; 165, 166; 166, identifier:flask_url_for_kwargs; 167, if_statement; 167, 168; 167, 169; 168, identifier:default; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:urls; 174, identifier:append; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:url_for; 178, argument_list; 178, 179; 178, 180; 178, 183; 179, identifier:default; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:_cls; 182, identifier:_cls; 183, dictionary_splat; 183, 184; 184, identifier:flask_url_for_kwargs; 185, if_statement; 185, 186; 185, 187; 186, identifier:override; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:urls; 192, identifier:insert; 193, argument_list; 193, 194; 193, 195; 194, integer:0; 195, call; 195, 196; 195, 197; 196, identifier:url_for; 197, argument_list; 197, 198; 197, 199; 197, 202; 198, identifier:override; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:_cls; 201, identifier:_cls; 202, dictionary_splat; 202, 203; 203, identifier:flask_url_for_kwargs; 204, for_statement; 204, 205; 204, 206; 204, 207; 205, identifier:url; 206, identifier:urls; 207, block; 207, 208; 208, if_statement; 208, 209; 208, 214; 209, call; 209, 210; 209, 211; 210, identifier:_validate_redirect_url; 211, argument_list; 211, 212; 211, 213; 212, identifier:url; 213, identifier:_external_host; 214, block; 214, 215; 215, return_statement; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:flask_redirect; 218, argument_list; 218, 219; 219, identifier:url; 220, return_statement; 220, 221; 221, call; 221, 222; 221, 223; 222, identifier:flask_redirect; 223, argument_list; 223, 224; 224, string:'/' | def redirect(where: Optional[str] = None,
default: Optional[str] = None,
override: Optional[str] = None,
_anchor: Optional[str] = None,
_cls: Optional[Union[object, type]] = None,
_external: Optional[bool] = False,
_external_host: Optional[str] = None,
_method: Optional[str] = None,
_scheme: Optional[str] = None,
**values,
) -> Response:
flask_url_for_kwargs = dict(_anchor=_anchor, _external=_external,
_external_host=_external_host, _method=_method,
_scheme=_scheme, **values)
urls = [url_for(request.args.get('next'), **flask_url_for_kwargs),
url_for(request.form.get('next'), **flask_url_for_kwargs)]
if where:
urls.append(url_for(where, _cls=_cls, **flask_url_for_kwargs))
if default:
urls.append(url_for(default, _cls=_cls, **flask_url_for_kwargs))
if override:
urls.insert(0, url_for(override, _cls=_cls, **flask_url_for_kwargs))
for url in urls:
if _validate_redirect_url(url, _external_host):
return flask_redirect(url)
return flask_redirect('/') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:auth_required; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:decorated_fn; 6, None; 7, dictionary_splat_pattern; 7, 8; 8, identifier:role_rules; 9, block; 9, 10; 9, 14; 9, 18; 9, 76; 9, 121; 9, 134; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:required_roles; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:one_of_roles; 17, list:[]; 18, if_statement; 18, 19; 18, 27; 19, not_operator; 19, 20; 20, parenthesized_expression; 20, 21; 21, boolean_operator:and; 21, 22; 21, 23; 22, identifier:decorated_fn; 23, call; 23, 24; 23, 25; 24, identifier:callable; 25, argument_list; 25, 26; 26, identifier:decorated_fn; 27, block; 27, 28; 27, 65; 28, if_statement; 28, 29; 28, 36; 28, 42; 28, 54; 29, boolean_operator:and; 29, 30; 29, 33; 30, comparison_operator:in; 30, 31; 30, 32; 31, string:'role'; 32, identifier:role_rules; 33, comparison_operator:in; 33, 34; 33, 35; 34, string:'roles'; 35, identifier:role_rules; 36, block; 36, 37; 37, raise_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:RuntimeError; 40, argument_list; 40, 41; 41, string:'specify only one of `role` or `roles` kwargs'; 42, elif_clause; 42, 43; 42, 46; 43, comparison_operator:in; 43, 44; 43, 45; 44, string:'role'; 45, identifier:role_rules; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:required_roles; 50, list:[role_rules['role']]; 50, 51; 51, subscript; 51, 52; 51, 53; 52, identifier:role_rules; 53, string:'role'; 54, elif_clause; 54, 55; 54, 58; 55, comparison_operator:in; 55, 56; 55, 57; 56, string:'roles'; 57, identifier:role_rules; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:required_roles; 62, subscript; 62, 63; 62, 64; 63, identifier:role_rules; 64, string:'roles'; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:in; 66, 67; 66, 68; 67, string:'one_of'; 68, identifier:role_rules; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:one_of_roles; 73, subscript; 73, 74; 73, 75; 74, identifier:role_rules; 75, string:'one_of'; 76, function_definition; 76, 77; 76, 78; 76, 80; 77, function_name:wrapper; 78, parameters; 78, 79; 79, identifier:fn; 80, block; 80, 81; 80, 119; 81, decorated_definition; 81, 82; 81, 87; 81, 91; 81, 97; 81, 103; 82, decorator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:wraps; 85, argument_list; 85, 86; 86, identifier:fn; 87, decorator; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:_auth_required; 90, argument_list; 91, decorator; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:roles_required; 94, argument_list; 94, 95; 95, list_splat; 95, 96; 96, identifier:required_roles; 97, decorator; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:roles_accepted; 100, argument_list; 100, 101; 101, list_splat; 101, 102; 102, identifier:one_of_roles; 103, function_definition; 103, 104; 103, 105; 103, 110; 104, function_name:decorated; 105, parameters; 105, 106; 105, 108; 106, list_splat_pattern; 106, 107; 107, identifier:args; 108, dictionary_splat_pattern; 108, 109; 109, identifier:kwargs; 110, block; 110, 111; 111, return_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:fn; 114, argument_list; 114, 115; 114, 117; 115, list_splat; 115, 116; 116, identifier:args; 117, dictionary_splat; 117, 118; 118, identifier:kwargs; 119, return_statement; 119, 120; 120, identifier:decorated; 121, if_statement; 121, 122; 121, 128; 122, boolean_operator:and; 122, 123; 122, 124; 123, identifier:decorated_fn; 124, call; 124, 125; 124, 126; 125, identifier:callable; 126, argument_list; 126, 127; 127, identifier:decorated_fn; 128, block; 128, 129; 129, return_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:wrapper; 132, argument_list; 132, 133; 133, identifier:decorated_fn; 134, return_statement; 134, 135; 135, identifier:wrapper | def auth_required(decorated_fn=None, **role_rules):
required_roles = []
one_of_roles = []
if not (decorated_fn and callable(decorated_fn)):
if 'role' in role_rules and 'roles' in role_rules:
raise RuntimeError('specify only one of `role` or `roles` kwargs')
elif 'role' in role_rules:
required_roles = [role_rules['role']]
elif 'roles' in role_rules:
required_roles = role_rules['roles']
if 'one_of' in role_rules:
one_of_roles = role_rules['one_of']
def wrapper(fn):
@wraps(fn)
@_auth_required()
@roles_required(*required_roles)
@roles_accepted(*one_of_roles)
def decorated(*args, **kwargs):
return fn(*args, **kwargs)
return decorated
if decorated_fn and callable(decorated_fn):
return wrapper(decorated_fn)
return wrapper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:build_tree; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 24; 5, 345; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:built; 10, block; 10, 11; 11, return_statement; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:doc_root; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:root; 22, identifier:element; 23, argument_list; 24, for_statement; 24, 25; 24, 26; 24, 31; 25, identifier:key; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:sorted_fields; 30, argument_list; 31, block; 31, 32; 31, 40; 31, 48; 32, if_statement; 32, 33; 32, 38; 33, comparison_operator:not; 33, 34; 33, 35; 34, identifier:key; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_fields; 38, block; 38, 39; 39, continue_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:field; 43, subscript; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_fields; 47, identifier:key; 48, if_statement; 48, 49; 48, 54; 49, comparison_operator:!=; 49, 50; 49, 51; 50, identifier:field; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:root; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 61; 55, 99; 55, 224; 55, 281; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:field; 60, identifier:XmlModel; 61, block; 61, 62; 61, 68; 61, 88; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:field; 66, identifier:build_tree; 67, argument_list; 68, if_statement; 68, 69; 68, 86; 69, parenthesized_expression; 69, 70; 70, boolean_operator:and; 70, 71; 70, 78; 71, boolean_operator:and; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:drop_empty; 75, attribute; 75, 76; 75, 77; 76, identifier:field; 77, identifier:drop_empty; 78, comparison_operator:==; 78, 79; 78, 85; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:field; 84, identifier:doc_root; 85, integer:0; 86, block; 86, 87; 87, continue_statement; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:doc_root; 94, identifier:append; 95, argument_list; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:field; 98, identifier:doc_root; 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:field; 104, identifier:list; 105, block; 105, 106; 106, for_statement; 106, 107; 106, 108; 106, 109; 107, identifier:item; 108, identifier:field; 109, block; 109, 110; 109, 220; 110, if_statement; 110, 111; 110, 116; 110, 147; 110, 186; 111, call; 111, 112; 111, 113; 112, identifier:isinstance; 113, argument_list; 113, 114; 113, 115; 114, identifier:item; 115, identifier:XmlField; 116, block; 116, 117; 116, 125; 116, 138; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:ele; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:item; 123, identifier:element; 124, argument_list; 125, if_statement; 125, 126; 125, 136; 126, boolean_operator:and; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:drop_empty; 130, comparison_operator:==; 130, 131; 130, 135; 131, call; 131, 132; 131, 133; 132, identifier:len; 133, argument_list; 133, 134; 134, identifier:ele; 135, integer:0; 136, block; 136, 137; 137, continue_statement; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:doc_root; 144, identifier:append; 145, argument_list; 145, 146; 146, identifier:ele; 147, elif_clause; 147, 148; 147, 153; 148, call; 148, 149; 148, 150; 149, identifier:isinstance; 150, argument_list; 150, 151; 150, 152; 151, identifier:item; 152, identifier:XmlModel; 153, block; 153, 154; 153, 160; 153, 175; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:item; 158, identifier:build_tree; 159, argument_list; 160, if_statement; 160, 161; 160, 173; 161, boolean_operator:and; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:drop_empty; 165, comparison_operator:==; 165, 166; 165, 172; 166, call; 166, 167; 166, 168; 167, identifier:len; 168, argument_list; 168, 169; 169, attribute; 169, 170; 169, 171; 170, identifier:item; 171, identifier:doc_root; 172, integer:0; 173, block; 173, 174; 174, continue_statement; 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:doc_root; 181, identifier:append; 182, argument_list; 182, 183; 183, attribute; 183, 184; 183, 185; 184, identifier:item; 185, identifier:doc_root; 186, elif_clause; 186, 187; 186, 198; 187, call; 187, 188; 187, 189; 188, identifier:isinstance; 189, argument_list; 189, 190; 189, 191; 190, identifier:item; 191, tuple; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:six; 194, identifier:text_type; 195, attribute; 195, 196; 195, 197; 196, identifier:six; 197, identifier:string_types; 198, block; 198, 199; 198, 211; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:ele; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:etree; 205, identifier:fromstring; 206, argument_list; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:clean_xml; 209, argument_list; 209, 210; 210, identifier:item; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:doc_root; 217, identifier:append; 218, argument_list; 218, 219; 219, identifier:ele; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:item; 223, None; 224, elif_clause; 224, 225; 224, 241; 225, comparison_operator:==; 225, 226; 225, 236; 226, parenthesized_expression; 226, 227; 227, boolean_operator:or; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:field; 230, identifier:parent; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:root; 235, identifier:name; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:root; 240, identifier:name; 241, block; 241, 242; 241, 250; 241, 268; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:ele; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:field; 248, identifier:element; 249, argument_list; 250, if_statement; 250, 251; 250, 266; 251, boolean_operator:and; 251, 252; 251, 262; 252, boolean_operator:and; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:self; 255, identifier:drop_empty; 256, comparison_operator:==; 256, 257; 256, 261; 257, call; 257, 258; 257, 259; 258, identifier:len; 259, argument_list; 259, 260; 260, identifier:ele; 261, integer:0; 262, not_operator; 262, 263; 263, attribute; 263, 264; 263, 265; 264, identifier:ele; 265, identifier:text; 266, block; 266, 267; 267, continue_statement; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:ele; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:field; 274, identifier:element; 275, argument_list; 275, 276; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:parent; 278, attribute; 278, 279; 278, 280; 279, identifier:self; 280, identifier:doc_root; 281, else_clause; 281, 282; 282, block; 282, 283; 282, 302; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:nodes; 286, list_comprehension; 286, 287; 286, 288; 287, identifier:n; 288, for_in_clause; 288, 289; 288, 290; 289, identifier:n; 290, call; 290, 291; 290, 296; 291, attribute; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:self; 294, identifier:doc_root; 295, identifier:iterdescendants; 296, argument_list; 296, 297; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:tag; 299, attribute; 299, 300; 299, 301; 300, identifier:field; 301, identifier:parent; 302, if_statement; 302, 303; 302, 304; 303, identifier:nodes; 304, block; 304, 305; 304, 313; 304, 332; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:ele; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:field; 311, identifier:element; 312, argument_list; 313, if_statement; 313, 314; 313, 330; 314, parenthesized_expression; 314, 315; 315, boolean_operator:and; 315, 316; 315, 326; 316, boolean_operator:and; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:self; 319, identifier:drop_empty; 320, comparison_operator:==; 320, 321; 320, 325; 321, call; 321, 322; 321, 323; 322, identifier:len; 323, argument_list; 323, 324; 324, identifier:ele; 325, integer:0; 326, not_operator; 326, 327; 327, attribute; 327, 328; 327, 329; 328, identifier:ele; 329, identifier:text; 330, block; 330, 331; 331, continue_statement; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:ele; 335, call; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:field; 338, identifier:element; 339, argument_list; 339, 340; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:parent; 342, subscript; 342, 343; 342, 344; 343, identifier:nodes; 344, integer:0; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:self; 349, identifier:built; 350, True | def build_tree(self):
if self.built:
return
self.doc_root = self.root.element()
for key in self.sorted_fields():
if key not in self._fields:
continue
field = self._fields[key]
if field != self.root:
if isinstance(field, XmlModel):
field.build_tree()
if (self.drop_empty and field.drop_empty
and len(field.doc_root) == 0):
continue
self.doc_root.append(field.doc_root)
elif isinstance(field, list):
for item in field:
if isinstance(item, XmlField):
ele = item.element()
if self.drop_empty and len(ele) == 0:
continue
self.doc_root.append(ele)
elif isinstance(item, XmlModel):
item.build_tree()
if self.drop_empty and len(item.doc_root) == 0:
continue
self.doc_root.append(item.doc_root)
elif isinstance(item, (six.text_type, six.string_types)):
ele = etree.fromstring(clean_xml(item))
self.doc_root.append(ele)
item = None
elif (field.parent or self.root.name) == self.root.name:
ele = field.element()
if self.drop_empty and len(ele) == 0 and not ele.text:
continue
ele = field.element(parent=self.doc_root)
else:
nodes = [n for n in self.doc_root.iterdescendants(
tag=field.parent)]
if nodes:
ele = field.element()
if (self.drop_empty and len(ele) == 0 and not ele.text):
continue
ele = field.element(parent=nodes[0])
self.built = True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.