sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sortby; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:ntd; 6, block; 6, 7; 7, if_statement; 7, 8; 7, 19; 7, 34; 8, comparison_operator:in; 8, 9; 8, 10; 9, string:'reldepth'; 10, subscript; 10, 11; 10, 18; 11, attribute; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:grprobj; 16, identifier:gosubdag; 17, identifier:prt_attr; 18, string:'flds'; 19, block; 19, 20; 20, return_statement; 20, 21; 21, list:[ntd.NS, -1*ntd.dcnt, ntd.reldepth]; 21, 22; 21, 25; 21, 31; 22, attribute; 22, 23; 22, 24; 23, identifier:ntd; 24, identifier:NS; 25, binary_operator:*; 25, 26; 25, 28; 26, unary_operator:-; 26, 27; 27, integer:1; 28, attribute; 28, 29; 28, 30; 29, identifier:ntd; 30, identifier:dcnt; 31, attribute; 31, 32; 31, 33; 32, identifier:ntd; 33, identifier:reldepth; 34, else_clause; 34, 35; 35, block; 35, 36; 36, return_statement; 36, 37; 37, list:[ntd.NS, -1*ntd.dcnt, ntd.depth]; 37, 38; 37, 41; 37, 47; 38, attribute; 38, 39; 38, 40; 39, identifier:ntd; 40, identifier:NS; 41, binary_operator:*; 41, 42; 41, 44; 42, unary_operator:-; 42, 43; 43, integer:1; 44, attribute; 44, 45; 44, 46; 45, identifier:ntd; 46, identifier:dcnt; 47, attribute; 47, 48; 47, 49; 48, identifier:ntd; 49, identifier:depth | def sortby(self, ntd):
if 'reldepth' in self.grprobj.gosubdag.prt_attr['flds']:
return [ntd.NS, -1*ntd.dcnt, ntd.reldepth]
else:
return [ntd.NS, -1*ntd.dcnt, ntd.depth] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_nts_sorted; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:hdrgo_prt; 6, identifier:hdrgos; 7, identifier:hdrgo_sort; 8, block; 8, 9; 8, 13; 8, 23; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:nts_flat; 12, list:[]; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:get_sorted_hdrgo2usrgos; 18, argument_list; 18, 19; 18, 20; 18, 21; 18, 22; 19, identifier:hdrgos; 20, identifier:nts_flat; 21, identifier:hdrgo_prt; 22, identifier:hdrgo_sort; 23, return_statement; 23, 24; 24, identifier:nts_flat | def get_nts_sorted(self, hdrgo_prt, hdrgos, hdrgo_sort):
nts_flat = []
self.get_sorted_hdrgo2usrgos(hdrgos, nts_flat, hdrgo_prt, hdrgo_sort)
return nts_flat |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:get_sorted_hdrgo2usrgos; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:hdrgos; 6, default_parameter; 6, 7; 6, 8; 7, identifier:flat_list; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:hdrgo_prt; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:hdrgo_sort; 14, True; 15, block; 15, 16; 15, 20; 15, 30; 15, 39; 15, 68; 15, 182; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:sorted_hdrgos_usrgos; 19, list:[]; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:h2u_get; 23, attribute; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:grprobj; 28, identifier:hdrgo2usrgos; 29, identifier:get; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:hdr_go2nt; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_get_go2nt; 37, argument_list; 37, 38; 38, identifier:hdrgos; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:hdrgo_sort; 42, True; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:hdr_go2nt; 47, call; 47, 48; 47, 49; 48, identifier:sorted; 49, argument_list; 49, 50; 49, 55; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:hdr_go2nt; 53, identifier:items; 54, argument_list; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:key; 57, lambda; 57, 58; 57, 60; 58, lambda_parameters; 58, 59; 59, identifier:t; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:hdrgo_sortby; 64, argument_list; 64, 65; 65, subscript; 65, 66; 65, 67; 66, identifier:t; 67, integer:1; 68, for_statement; 68, 69; 68, 72; 68, 73; 69, pattern_list; 69, 70; 69, 71; 70, identifier:hdrgo_id; 71, identifier:hdrgo_nt; 72, identifier:hdr_go2nt; 73, block; 73, 74; 73, 97; 73, 104; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:flat_list; 77, None; 78, block; 78, 79; 79, if_statement; 79, 80; 79, 89; 80, boolean_operator:or; 80, 81; 80, 82; 81, identifier:hdrgo_prt; 82, comparison_operator:in; 82, 83; 82, 84; 83, identifier:hdrgo_id; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:grprobj; 88, identifier:usrgos; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:flat_list; 94, identifier:append; 95, argument_list; 95, 96; 96, identifier:hdrgo_nt; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:usrgos_unsorted; 100, call; 100, 101; 100, 102; 101, identifier:h2u_get; 102, argument_list; 102, 103; 103, identifier:hdrgo_id; 104, if_statement; 104, 105; 104, 106; 104, 171; 105, identifier:usrgos_unsorted; 106, block; 106, 107; 106, 116; 106, 140; 106, 150; 106, 162; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:usrgo2nt; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:_get_go2nt; 114, argument_list; 114, 115; 115, identifier:usrgos_unsorted; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:usrgont_sorted; 119, call; 119, 120; 119, 121; 120, identifier:sorted; 121, argument_list; 121, 122; 121, 127; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:usrgo2nt; 125, identifier:items; 126, argument_list; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:key; 129, lambda; 129, 130; 129, 132; 130, lambda_parameters; 130, 131; 131, identifier:t; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:usrgo_sortby; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:t; 139, integer:1; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, pattern_list; 142, 143; 142, 144; 143, identifier:usrgos_sorted; 144, identifier:usrnts_sorted; 145, call; 145, 146; 145, 147; 146, identifier:zip; 147, argument_list; 147, 148; 148, list_splat; 148, 149; 149, identifier:usrgont_sorted; 150, if_statement; 150, 151; 150, 154; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:flat_list; 153, None; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:flat_list; 159, identifier:extend; 160, argument_list; 160, 161; 161, identifier:usrnts_sorted; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:sorted_hdrgos_usrgos; 166, identifier:append; 167, argument_list; 167, 168; 168, tuple; 168, 169; 168, 170; 169, identifier:hdrgo_id; 170, identifier:usrgos_sorted; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:sorted_hdrgos_usrgos; 177, identifier:append; 178, argument_list; 178, 179; 179, tuple; 179, 180; 179, 181; 180, identifier:hdrgo_id; 181, list:[]; 182, return_statement; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:cx; 186, identifier:OrderedDict; 187, argument_list; 187, 188; 188, identifier:sorted_hdrgos_usrgos | def get_sorted_hdrgo2usrgos(self, hdrgos, flat_list=None, hdrgo_prt=True, hdrgo_sort=True):
sorted_hdrgos_usrgos = []
h2u_get = self.grprobj.hdrgo2usrgos.get
hdr_go2nt = self._get_go2nt(hdrgos)
if hdrgo_sort is True:
hdr_go2nt = sorted(hdr_go2nt.items(), key=lambda t: self.hdrgo_sortby(t[1]))
for hdrgo_id, hdrgo_nt in hdr_go2nt:
if flat_list is not None:
if hdrgo_prt or hdrgo_id in self.grprobj.usrgos:
flat_list.append(hdrgo_nt)
usrgos_unsorted = h2u_get(hdrgo_id)
if usrgos_unsorted:
usrgo2nt = self._get_go2nt(usrgos_unsorted)
usrgont_sorted = sorted(usrgo2nt.items(), key=lambda t: self.usrgo_sortby(t[1]))
usrgos_sorted, usrnts_sorted = zip(*usrgont_sorted)
if flat_list is not None:
flat_list.extend(usrnts_sorted)
sorted_hdrgos_usrgos.append((hdrgo_id, usrgos_sorted))
else:
sorted_hdrgos_usrgos.append((hdrgo_id, []))
return cx.OrderedDict(sorted_hdrgos_usrgos) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_init_hdrgo_sortby; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:hdrgo_sortby; 6, identifier:sortby; 7, block; 7, 8; 7, 15; 7, 22; 8, if_statement; 8, 9; 8, 12; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:hdrgo_sortby; 11, None; 12, block; 12, 13; 13, return_statement; 13, 14; 14, identifier:hdrgo_sortby; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:sortby; 18, None; 19, block; 19, 20; 20, return_statement; 20, 21; 21, identifier:sortby; 22, return_statement; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:sortby | def _init_hdrgo_sortby(self, hdrgo_sortby, sortby):
if hdrgo_sortby is not None:
return hdrgo_sortby
if sortby is not None:
return sortby
return self.sortby |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_sortgo; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 23; 6, if_statement; 6, 7; 6, 14; 7, comparison_operator:in; 7, 8; 7, 9; 8, string:'sortgo'; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:datobj; 13, identifier:kws; 14, block; 14, 15; 15, return_statement; 15, 16; 16, subscript; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:datobj; 21, identifier:kws; 22, string:'sortgo'; 23, return_statement; 23, 24; 24, binary_operator:+; 24, 25; 24, 36; 25, subscript; 25, 26; 25, 35; 26, attribute; 26, 27; 26, 34; 27, attribute; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:datobj; 32, identifier:grprdflt; 33, identifier:gosubdag; 34, identifier:prt_attr; 35, string:'sort'; 36, string:"\n" | def _get_sortgo(self):
if 'sortgo' in self.datobj.kws:
return self.datobj.kws['sortgo']
return self.datobj.grprdflt.gosubdag.prt_attr['sort'] + "\n" |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_sorted_section; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:nts_section; 6, block; 6, 7; 6, 32; 6, 47; 7, if_statement; 7, 8; 7, 13; 8, comparison_operator:is; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:section_sortby; 12, True; 13, block; 13, 14; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:sorted; 17, argument_list; 17, 18; 17, 19; 18, identifier:nts_section; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:nt; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:sortgos; 29, identifier:usrgo_sortby; 30, argument_list; 30, 31; 31, identifier:nt; 32, if_statement; 32, 33; 32, 44; 33, boolean_operator:or; 33, 34; 33, 39; 34, comparison_operator:is; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:section_sortby; 38, False; 39, comparison_operator:is; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:section_sortby; 43, None; 44, block; 44, 45; 45, return_statement; 45, 46; 46, identifier:nts_section; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:sorted; 50, argument_list; 50, 51; 50, 52; 51, identifier:nts_section; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:key; 54, lambda; 54, 55; 54, 57; 55, lambda_parameters; 55, 56; 56, identifier:nt; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:section_sortby; 61, argument_list; 61, 62; 62, identifier:nt | def _get_sorted_section(self, nts_section):
if self.section_sortby is True:
return sorted(nts_section, key=lambda nt: self.sortgos.usrgo_sortby(nt))
if self.section_sortby is False or self.section_sortby is None:
return nts_section
return sorted(nts_section, key=lambda nt: self.section_sortby(nt)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_sections_2dnt; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sec2d_go; 6, block; 6, 7; 7, return_statement; 7, 8; 8, list_comprehension; 8, 9; 8, 17; 9, tuple; 9, 10; 9, 11; 10, identifier:nm; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:get_ntgos_sorted; 15, argument_list; 15, 16; 16, identifier:gos; 17, for_in_clause; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:nm; 20, identifier:gos; 21, identifier:sec2d_go | def get_sections_2dnt(self, sec2d_go):
return [(nm, self.get_ntgos_sorted(gos)) for nm, gos in sec2d_go] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_ntgos_sorted; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:hdrgos; 6, block; 6, 7; 6, 15; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:go2nt; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:grprobj; 14, identifier:go2nt; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 18, 30; 19, list_comprehension; 19, 20; 19, 23; 19, 26; 20, subscript; 20, 21; 20, 22; 21, identifier:go2nt; 22, identifier:go; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:go; 25, identifier:hdrgos; 26, if_clause; 26, 27; 27, comparison_operator:in; 27, 28; 27, 29; 28, identifier:go; 29, identifier:go2nt; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:fncsortnt | def get_ntgos_sorted(self, hdrgos):
go2nt = self.grprobj.go2nt
return sorted([go2nt[go] for go in hdrgos if go in go2nt], key=self.fncsortnt) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_sortobj; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:goea_results; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kws; 8, block; 8, 9; 8, 22; 8, 34; 8, 46; 8, 65; 8, 74; 8, 93; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:nts_goea; 12, call; 12, 13; 12, 19; 13, attribute; 13, 14; 13, 18; 14, call; 14, 15; 14, 16; 15, identifier:MgrNtGOEAs; 16, argument_list; 16, 17; 17, identifier:goea_results; 18, identifier:get_goea_nts_prt; 19, argument_list; 19, 20; 20, dictionary_splat; 20, 21; 21, identifier:kws; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:goids; 25, call; 25, 26; 25, 27; 26, identifier:set; 27, generator_expression; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:nt; 30, identifier:GO; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:nt; 33, identifier:nts_goea; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:go2nt; 37, dictionary_comprehension; 37, 38; 37, 43; 38, pair; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:nt; 41, identifier:GO; 42, identifier:nt; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:nt; 45, identifier:nts_goea; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:grprobj; 49, call; 49, 50; 49, 51; 50, identifier:Grouper; 51, argument_list; 51, 52; 51, 53; 51, 54; 51, 57; 51, 62; 52, string:"GOEA"; 53, identifier:goids; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:hdrobj; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:grprdflt; 61, identifier:gosubdag; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:go2nt; 64, identifier:go2nt; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:grprobj; 69, identifier:prt_summary; 70, argument_list; 70, 71; 71, attribute; 71, 72; 71, 73; 72, identifier:sys; 73, identifier:stdout; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:sortobj; 77, call; 77, 78; 77, 79; 78, identifier:Sorter; 79, argument_list; 79, 80; 79, 81; 80, identifier:grprobj; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:section_sortby; 83, lambda; 83, 84; 83, 86; 84, lambda_parameters; 84, 85; 85, identifier:nt; 86, call; 86, 87; 86, 88; 87, identifier:getattr; 88, argument_list; 88, 89; 88, 90; 89, identifier:nt; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:pval_fld; 93, return_statement; 93, 94; 94, identifier:sortobj | def get_sortobj(self, goea_results, **kws):
nts_goea = MgrNtGOEAs(goea_results).get_goea_nts_prt(**kws)
goids = set(nt.GO for nt in nts_goea)
go2nt = {nt.GO:nt for nt in nts_goea}
grprobj = Grouper("GOEA", goids, self.hdrobj, self.grprdflt.gosubdag, go2nt=go2nt)
grprobj.prt_summary(sys.stdout)
sortobj = Sorter(grprobj, section_sortby=lambda nt: getattr(nt, self.pval_fld))
return sortobj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_sorted_relationships; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:goterm; 6, block; 6, 7; 6, 17; 6, 28; 6, 43; 7, if_statement; 7, 8; 7, 15; 8, comparison_operator:in; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:goterm; 11, identifier:id; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:goids_seen; 15, block; 15, 16; 16, return_statement; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:goids_seen; 23, identifier:add; 24, argument_list; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:goterm; 27, identifier:id; 28, for_statement; 28, 29; 28, 30; 28, 35; 29, identifier:goterm_upper; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:goterm; 33, identifier:get_goterms_upper; 34, argument_list; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_get_sorted_relationships; 41, argument_list; 41, 42; 42, identifier:goterm_upper; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:goterms_sorted; 49, identifier:append; 50, argument_list; 50, 51; 51, identifier:goterm | def _get_sorted_relationships(self, goterm):
if goterm.id in self.goids_seen:
return
self.goids_seen.add(goterm.id)
for goterm_upper in goterm.get_goterms_upper():
self._get_sorted_relationships(goterm_upper)
self.goterms_sorted.append(goterm) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:write_dag; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:out; 7, attribute; 7, 8; 7, 9; 8, identifier:sys; 9, identifier:stdout; 10, block; 10, 11; 11, for_statement; 11, 12; 11, 13; 11, 21; 12, identifier:rec; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:values; 20, argument_list; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:print; 25, argument_list; 25, 26; 25, 27; 26, identifier:rec; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:file; 29, identifier:out | def write_dag(self, out=sys.stdout):
for rec in sorted(self.values()):
print(rec, file=out) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_nts; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:nt_list; 6, identifier:codekey; 7, block; 7, 8; 7, 28; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:sortby; 11, lambda; 11, 12; 11, 14; 12, lambda_parameters; 12, 13; 13, identifier:nt; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:ev2idx; 19, identifier:get; 20, argument_list; 20, 21; 20, 26; 21, call; 21, 22; 21, 23; 22, identifier:getattr; 23, argument_list; 23, 24; 23, 25; 24, identifier:nt; 25, identifier:codekey; 26, unary_operator:-; 26, 27; 27, integer:1; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:sorted; 31, argument_list; 31, 32; 31, 33; 32, identifier:nt_list; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:key; 35, identifier:sortby | def sort_nts(self, nt_list, codekey):
sortby = lambda nt: self.ev2idx.get(getattr(nt, codekey), -1)
return sorted(nt_list, key=sortby) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:prt_gos; 3, parameters; 3, 4; 3, 5; 3, 10; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:prt; 7, attribute; 7, 8; 7, 9; 8, identifier:sys; 9, identifier:stdout; 10, dictionary_splat_pattern; 10, 11; 11, identifier:kws_usr; 12, block; 12, 13; 12, 23; 12, 37; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:desc2nts; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:get_desc2nts; 20, argument_list; 20, 21; 21, dictionary_splat; 21, 22; 22, identifier:kws_usr; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:prt_nts; 28, argument_list; 28, 29; 28, 30; 28, 31; 29, identifier:desc2nts; 30, identifier:prt; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kws_usr; 34, identifier:get; 35, argument_list; 35, 36; 36, string:'prtfmt'; 37, return_statement; 37, 38; 38, identifier:desc2nts | def prt_gos(self, prt=sys.stdout, **kws_usr):
desc2nts = self.get_desc2nts(**kws_usr)
self.prt_nts(desc2nts, prt, kws_usr.get('prtfmt'))
return desc2nts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_nts_flat; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:hdrgo_prt; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:use_sections; 10, True; 11, block; 11, 12; 11, 43; 11, 59; 12, if_statement; 12, 13; 12, 21; 13, boolean_operator:or; 13, 14; 13, 19; 14, comparison_operator:is; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:sectobj; 18, None; 19, not_operator; 19, 20; 20, identifier:use_sections; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:sortgos; 28, identifier:get_nts_sorted; 29, argument_list; 29, 30; 29, 31; 29, 40; 30, identifier:hdrgo_prt; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:hdrgos; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:grprobj; 38, identifier:get_hdrgos; 39, argument_list; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:hdrgo_sort; 42, True; 43, if_statement; 43, 44; 43, 46; 44, not_operator; 44, 45; 45, identifier:use_sections; 46, block; 46, 47; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:sectobj; 53, identifier:get_sorted_nts_omit_section; 54, argument_list; 54, 55; 54, 56; 55, identifier:hdrgo_prt; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:hdrgo_sort; 58, True; 59, return_statement; 59, 60; 60, None | def get_nts_flat(self, hdrgo_prt=True, use_sections=True):
if self.sectobj is None or not use_sections:
return self.sortgos.get_nts_sorted(
hdrgo_prt,
hdrgos=self.grprobj.get_hdrgos(),
hdrgo_sort=True)
if not use_sections:
return self.sectobj.get_sorted_nts_omit_section(hdrgo_prt, hdrgo_sort=True)
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_adjust_prt_flds; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:kws_xlsx; 6, identifier:desc2nts; 7, identifier:shade_hdrgos; 8, block; 8, 9; 8, 18; 8, 28; 8, 32; 8, 43; 8, 78; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:in; 10, 11; 10, 12; 11, string:"prt_flds"; 12, identifier:kws_xlsx; 13, block; 13, 14; 14, return_statement; 14, 15; 15, subscript; 15, 16; 15, 17; 16, identifier:kws_xlsx; 17, string:"prt_flds"; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:dont_print; 21, call; 21, 22; 21, 23; 22, identifier:set; 23, argument_list; 23, 24; 24, list:['hdr_idx', 'is_hdrgo', 'is_usrgo']; 24, 25; 24, 26; 24, 27; 25, string:'hdr_idx'; 26, string:'is_hdrgo'; 27, string:'is_usrgo'; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:prt_flds_adjusted; 31, list:[]; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:nt_flds; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:sortobj; 40, identifier:get_fields; 41, argument_list; 41, 42; 42, identifier:desc2nts; 43, for_statement; 43, 44; 43, 45; 43, 46; 44, identifier:nt_fld; 45, identifier:nt_flds; 46, block; 46, 47; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:not; 48, 49; 48, 50; 49, identifier:nt_fld; 50, identifier:dont_print; 51, block; 51, 52; 52, if_statement; 52, 53; 52, 56; 52, 69; 53, comparison_operator:==; 53, 54; 53, 55; 54, identifier:nt_fld; 55, string:"format_txt"; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:shade_hdrgos; 60, True; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:prt_flds_adjusted; 66, identifier:append; 67, argument_list; 67, 68; 68, identifier:nt_fld; 69, else_clause; 69, 70; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:prt_flds_adjusted; 75, identifier:append; 76, argument_list; 76, 77; 77, identifier:nt_fld; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:kws_xlsx; 82, string:'prt_flds'; 83, identifier:prt_flds_adjusted | def _adjust_prt_flds(self, kws_xlsx, desc2nts, shade_hdrgos):
if "prt_flds" in kws_xlsx:
return kws_xlsx["prt_flds"]
dont_print = set(['hdr_idx', 'is_hdrgo', 'is_usrgo'])
prt_flds_adjusted = []
nt_flds = self.sortobj.get_fields(desc2nts)
for nt_fld in nt_flds:
if nt_fld not in dont_print:
if nt_fld == "format_txt":
if shade_hdrgos is True:
prt_flds_adjusted.append(nt_fld)
else:
prt_flds_adjusted.append(nt_fld)
kws_xlsx['prt_flds'] = prt_flds_adjusted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_shade_hdrgos; 3, parameters; 3, 4; 4, dictionary_splat_pattern; 4, 5; 5, identifier:kws; 6, block; 6, 7; 6, 16; 6, 25; 6, 36; 6, 51; 7, if_statement; 7, 8; 7, 11; 8, comparison_operator:in; 8, 9; 8, 10; 9, string:'shade_hdrgos'; 10, identifier:kws; 11, block; 11, 12; 12, return_statement; 12, 13; 13, subscript; 13, 14; 13, 15; 14, identifier:kws; 15, string:'shade_hdrgos'; 16, if_statement; 16, 17; 16, 20; 17, comparison_operator:in; 17, 18; 17, 19; 18, string:'hdrgo_prt'; 19, identifier:kws; 20, block; 20, 21; 21, return_statement; 21, 22; 22, subscript; 22, 23; 22, 24; 23, identifier:kws; 24, string:'hdrgo_prt'; 25, if_statement; 25, 26; 25, 33; 26, boolean_operator:and; 26, 27; 26, 30; 27, comparison_operator:in; 27, 28; 27, 29; 28, string:'section_sortby'; 29, identifier:kws; 30, subscript; 30, 31; 30, 32; 31, identifier:kws; 32, string:'section_sortby'; 33, block; 33, 34; 34, return_statement; 34, 35; 35, False; 36, if_statement; 36, 37; 36, 48; 37, boolean_operator:and; 37, 38; 37, 41; 38, comparison_operator:in; 38, 39; 38, 40; 39, string:'top_n'; 40, identifier:kws; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:kws; 46, string:'top_n'; 47, identifier:int; 48, block; 48, 49; 49, return_statement; 49, 50; 50, False; 51, return_statement; 51, 52; 52, True | def _get_shade_hdrgos(**kws):
if 'shade_hdrgos' in kws:
return kws['shade_hdrgos']
if 'hdrgo_prt' in kws:
return kws['hdrgo_prt']
if 'section_sortby' in kws and kws['section_sortby']:
return False
if 'top_n' in kws and isinstance(kws['top_n'], int):
return False
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:dflt_sortby_objgoea; 3, parameters; 3, 4; 4, identifier:goea_res; 5, block; 5, 6; 6, return_statement; 6, 7; 7, list:[getattr(goea_res, 'enrichment'),
getattr(goea_res, 'namespace'),
getattr(goea_res, 'p_uncorrected'),
getattr(goea_res, 'depth'),
getattr(goea_res, 'GO')]; 7, 8; 7, 13; 7, 18; 7, 23; 7, 28; 8, call; 8, 9; 8, 10; 9, identifier:getattr; 10, argument_list; 10, 11; 10, 12; 11, identifier:goea_res; 12, string:'enrichment'; 13, call; 13, 14; 13, 15; 14, identifier:getattr; 15, argument_list; 15, 16; 15, 17; 16, identifier:goea_res; 17, string:'namespace'; 18, call; 18, 19; 18, 20; 19, identifier:getattr; 20, argument_list; 20, 21; 20, 22; 21, identifier:goea_res; 22, string:'p_uncorrected'; 23, call; 23, 24; 23, 25; 24, identifier:getattr; 25, argument_list; 25, 26; 25, 27; 26, identifier:goea_res; 27, string:'depth'; 28, call; 28, 29; 28, 30; 29, identifier:getattr; 30, argument_list; 30, 31; 30, 32; 31, identifier:goea_res; 32, string:'GO' | def dflt_sortby_objgoea(goea_res):
return [getattr(goea_res, 'enrichment'),
getattr(goea_res, 'namespace'),
getattr(goea_res, 'p_uncorrected'),
getattr(goea_res, 'depth'),
getattr(goea_res, 'GO')] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:dflt_sortby_ntgoea; 3, parameters; 3, 4; 4, identifier:ntgoea; 5, block; 5, 6; 6, return_statement; 6, 7; 7, list:[ntgoea.enrichment,
ntgoea.namespace,
ntgoea.p_uncorrected,
ntgoea.depth,
ntgoea.GO]; 7, 8; 7, 11; 7, 14; 7, 17; 7, 20; 8, attribute; 8, 9; 8, 10; 9, identifier:ntgoea; 10, identifier:enrichment; 11, attribute; 11, 12; 11, 13; 12, identifier:ntgoea; 13, identifier:namespace; 14, attribute; 14, 15; 14, 16; 15, identifier:ntgoea; 16, identifier:p_uncorrected; 17, attribute; 17, 18; 17, 19; 18, identifier:ntgoea; 19, identifier:depth; 20, attribute; 20, 21; 20, 22; 21, identifier:ntgoea; 22, identifier:GO | def dflt_sortby_ntgoea(ntgoea):
return [ntgoea.enrichment,
ntgoea.namespace,
ntgoea.p_uncorrected,
ntgoea.depth,
ntgoea.GO] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 12; 3, 15; 4, identifier:x; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, unary_operator:-; 7, 8; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:reverse; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:with_index; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:only_index; 17, False; 18, block; 18, 19; 18, 28; 18, 38; 19, import_from_statement; 19, 20; 19, 24; 20, relative_import; 20, 21; 20, 22; 21, import_prefix; 22, dotted_name; 22, 23; 23, identifier:function_bases; 24, aliased_import; 24, 25; 24, 27; 25, dotted_name; 25, 26; 26, identifier:sort; 27, identifier:sort_base; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:n_outputs; 31, conditional_expression:if; 31, 32; 31, 33; 31, 37; 32, integer:2; 33, boolean_operator:and; 33, 34; 33, 35; 34, identifier:with_index; 35, not_operator; 35, 36; 36, identifier:only_index; 37, integer:1; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:sort_base; 41, argument_list; 41, 42; 41, 43; 41, 44; 41, 45; 41, 46; 41, 47; 42, identifier:x; 43, identifier:axis; 44, identifier:reverse; 45, identifier:with_index; 46, identifier:only_index; 47, identifier:n_outputs | def sort(x, axis=-1, reverse=False, with_index=False, only_index=False):
from .function_bases import sort as sort_base
n_outputs = 2 if with_index and not only_index else 1
return sort_base(x, axis, reverse, with_index, only_index, n_outputs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:optimize; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 27; 6, with_statement; 6, 7; 6, 17; 7, with_clause; 7, 8; 8, with_item; 8, 9; 9, as_pattern; 9, 10; 9, 15; 10, call; 10, 11; 10, 12; 11, identifier:open; 12, argument_list; 12, 13; 12, 14; 13, identifier:LIBRARIES_FILE; 14, string:'r'; 15, as_pattern_target; 15, 16; 16, identifier:f; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:libs_data; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:json; 24, identifier:load; 25, argument_list; 25, 26; 26, identifier:f; 27, for_statement; 27, 28; 27, 31; 27, 36; 28, pattern_list; 28, 29; 28, 30; 29, identifier:alg; 30, identifier:libs_names; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:libs_data; 34, identifier:items; 35, argument_list; 36, block; 36, 37; 36, 46; 36, 51; 36, 73; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:libs; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:get_libs; 44, argument_list; 44, 45; 45, identifier:alg; 46, if_statement; 46, 47; 46, 49; 47, not_operator; 47, 48; 48, identifier:libs; 49, block; 49, 50; 50, continue_statement; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 58; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:libs; 57, identifier:alg; 58, list_comprehension; 58, 59; 58, 60; 58, 63; 59, identifier:lib; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:lib; 62, identifier:libs; 63, if_clause; 63, 64; 64, comparison_operator:in; 64, 65; 64, 72; 65, list:[lib.module_name, lib.func_name]; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:lib; 68, identifier:module_name; 69, attribute; 69, 70; 69, 71; 70, identifier:lib; 71, identifier:func_name; 72, identifier:libs_names; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 82; 75, attribute; 75, 76; 75, 81; 76, subscript; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:libs; 80, identifier:alg; 81, identifier:sort; 82, argument_list; 82, 83; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:key; 85, lambda; 85, 86; 85, 88; 86, lambda_parameters; 86, 87; 87, identifier:lib; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:libs_names; 91, identifier:index; 92, argument_list; 92, 93; 93, list:[lib.module_name, lib.func_name]; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:lib; 96, identifier:module_name; 97, attribute; 97, 98; 97, 99; 98, identifier:lib; 99, identifier:func_name | def optimize(self):
with open(LIBRARIES_FILE, 'r') as f:
libs_data = json.load(f)
for alg, libs_names in libs_data.items():
libs = self.get_libs(alg)
if not libs:
continue
self.libs[alg] = [lib for lib in libs if [lib.module_name, lib.func_name] in libs_names]
self.libs[alg].sort(key=lambda lib: libs_names.index([lib.module_name, lib.func_name])) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:sort_common_members; 3, parameters; 4, block; 4, 5; 4, 11; 4, 15; 4, 22; 4, 26; 4, 43; 4, 50; 4, 75; 4, 89; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:filename; 8, binary_operator:+; 8, 9; 8, 10; 9, identifier:PREFIX; 10, string:'/common_members.json'; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:sorted_json_data; 14, dictionary; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:json_data; 18, call; 18, 19; 18, 20; 19, identifier:read_json; 20, argument_list; 20, 21; 21, identifier:filename; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:all_keys; 25, list:[]; 26, for_statement; 26, 27; 26, 30; 26, 35; 27, pattern_list; 27, 28; 27, 29; 28, identifier:key; 29, identifier:value; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:json_data; 33, identifier:items; 34, argument_list; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:all_keys; 40, identifier:append; 41, argument_list; 41, 42; 42, identifier:key; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:sorted_keys; 46, call; 46, 47; 46, 48; 47, identifier:sorted; 48, argument_list; 48, 49; 49, identifier:all_keys; 50, for_statement; 50, 51; 50, 52; 50, 53; 51, identifier:key; 52, identifier:sorted_keys; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 63; 55, comparison_operator:>; 55, 56; 55, 62; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, subscript; 59, 60; 59, 61; 60, identifier:json_data; 61, identifier:key; 62, integer:0; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:sorted_json_data; 68, identifier:key; 69, call; 69, 70; 69, 71; 70, identifier:sorted; 71, argument_list; 71, 72; 72, subscript; 72, 73; 72, 74; 73, identifier:json_data; 74, identifier:key; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:print; 78, argument_list; 78, 79; 79, binary_operator:+; 79, 80; 79, 81; 80, string:'--> Sorted/cleaned '; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:os; 85, identifier:path; 86, identifier:basename; 87, argument_list; 87, 88; 88, identifier:filename; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:write_json; 92, argument_list; 92, 93; 92, 94; 93, identifier:sorted_json_data; 94, identifier:filename | def sort_common_members():
filename = PREFIX + '/common_members.json'
sorted_json_data = {}
json_data = read_json(filename)
all_keys = []
for key, value in json_data.items():
all_keys.append(key)
sorted_keys = sorted(all_keys)
for key in sorted_keys:
if len(json_data[key]) > 0:
sorted_json_data[key] = sorted(json_data[key])
print('--> Sorted/cleaned ' + os.path.basename(filename))
write_json(sorted_json_data, filename) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_ConstructPartitions; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:collection_links; 6, identifier:partitions_per_node; 7, block; 7, 8; 7, 15; 7, 33; 7, 37; 7, 92; 7, 98; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:collections_node_count; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:collection_links; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:partitions; 18, list_comprehension; 18, 19; 18, 24; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:partition; 22, identifier:_Partition; 23, argument_list; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:_; 26, call; 26, 27; 26, 28; 27, identifier:xrange; 28, argument_list; 28, 29; 28, 30; 29, integer:0; 30, binary_operator:*; 30, 31; 30, 32; 31, identifier:partitions_per_node; 32, identifier:collections_node_count; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:index; 36, integer:0; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:collection_node; 39, identifier:collection_links; 40, block; 40, 41; 40, 57; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:hash_value; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:hash_generator; 49, identifier:ComputeHash; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:_GetBytes; 55, argument_list; 55, 56; 56, identifier:collection_node; 57, for_statement; 57, 58; 57, 59; 57, 64; 58, identifier:_; 59, call; 59, 60; 59, 61; 60, identifier:xrange; 61, argument_list; 61, 62; 61, 63; 62, integer:0; 63, identifier:partitions_per_node; 64, block; 64, 65; 64, 77; 64, 81; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:partitions; 69, identifier:index; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:partition; 73, identifier:_Partition; 74, argument_list; 74, 75; 74, 76; 75, identifier:hash_value; 76, identifier:collection_node; 77, expression_statement; 77, 78; 78, augmented_assignment:+=; 78, 79; 78, 80; 79, identifier:index; 80, integer:1; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:hash_value; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:hash_generator; 89, identifier:ComputeHash; 90, argument_list; 90, 91; 91, identifier:hash_value; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:partitions; 96, identifier:sort; 97, argument_list; 98, return_statement; 98, 99; 99, identifier:partitions | def _ConstructPartitions(self, collection_links, partitions_per_node):
collections_node_count = len(collection_links)
partitions = [partition._Partition() for _ in xrange(0, partitions_per_node * collections_node_count)]
index = 0
for collection_node in collection_links:
hash_value = self.hash_generator.ComputeHash(self._GetBytes(collection_node))
for _ in xrange(0, partitions_per_node):
partitions[index] = partition._Partition(hash_value, collection_node)
index += 1
hash_value = self.hash_generator.ComputeHash(hash_value)
partitions.sort()
return partitions |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:parse_leap_seconds; 3, parameters; 3, 4; 4, identifier:fileobj; 5, block; 5, 6; 5, 13; 5, 29; 5, 38; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:lines; 9, call; 9, 10; 9, 11; 10, identifier:iter; 11, argument_list; 11, 12; 12, identifier:fileobj; 13, for_statement; 13, 14; 13, 15; 13, 16; 13, 21; 13, 22; 14, identifier:line; 15, identifier:lines; 16, ERROR; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:line; 19, identifier:startswith; 20, identifier:break; 21, block:; 22, else_clause; 22, 23; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:ValueError; 27, argument_list; 27, 28; 28, string:'Leap_Second.dat is missing its expiration date'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:line; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:line; 35, identifier:decode; 36, argument_list; 36, 37; 37, string:'ascii'; 38, with_statement; 38, 39; 38, 42; 39, with_clause; 39, 40; 40, with_item; 40, 41; 41, identifier:_lock; 42, block; 42, 43; 42, 54; 42, 64; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:original_locale; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:locale; 49, identifier:setlocale; 50, argument_list; 50, 51; 51, attribute; 51, 52; 51, 53; 52, identifier:locale; 53, identifier:LC_ALL; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:locale; 58, identifier:setlocale; 59, argument_list; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:locale; 62, identifier:LC_ALL; 63, string:'C'; 64, ERROR; 64, 65; 64, 184; 65, ERROR; 65, 66; 65, 67; 65, 70; 65, 71; 65, 82; 65, 99; 65, 101; 65, 102; 65, 103; 65, 104; 65, 181; 66, identifier:dt; 67, attribute; 67, 68; 67, 69; 68, identifier:datetime; 69, identifier:strptime; 70, identifier:line; 71, ERROR; 71, 72; 71, 73; 72, identifier:finally; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:locale; 76, identifier:setlocale; 77, argument_list; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:locale; 80, identifier:LC_ALL; 81, identifier:original_locale; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:grace_period; 84, binary_operator:+; 84, 85; 84, 98; 85, call; 85, 86; 85, 97; 86, attribute; 86, 87; 86, 93; 86, 96; 87, call; 87, 88; 87, 89; 88, identifier:timedelta; 89, argument_list; 89, 90; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:days; 92, integer:30; 93, ERROR; 93, 94; 93, 95; 94, identifier:expiration_date; 95, identifier:dt; 96, identifier:date; 97, argument_list; 98, identifier:grace_period; 99, ERROR; 99, 100; 100, identifier:mjd; 101, identifier:day; 102, identifier:month; 103, identifier:year; 104, keyword_argument; 104, 105; 104, 106; 104, 180; 105, identifier:offsets; 106, ERROR; 106, 107; 106, 132; 106, 141; 106, 149; 106, 150; 106, 151; 106, 166; 106, 169; 106, 178; 106, 179; 107, subscript; 107, 108; 107, 129; 107, 131; 108, call; 108, 109; 108, 122; 109, attribute; 109, 110; 109, 118; 109, 121; 110, attribute; 110, 111; 110, 117; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:np; 114, identifier:loadtxt; 115, argument_list; 115, 116; 116, identifier:lines; 117, identifier:T; 118, ERROR; 118, 119; 118, 120; 119, identifier:leap_dates; 120, identifier:np; 121, identifier:ndarray; 122, argument_list; 122, 123; 123, binary_operator:+; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:len; 126, argument_list; 126, 127; 127, identifier:mjd; 128, integer:2; 129, ERROR; 129, 130; 130, identifier:leap_dates; 131, integer:0; 132, subscript; 132, 133; 132, 134; 132, 136; 133, string:'-inf'; 134, ERROR; 134, 135; 135, identifier:leap_dates; 136, slice; 136, 137; 136, 138; 136, 139; 137, integer:1; 138, colon; 139, unary_operator:-; 139, 140; 140, integer:1; 141, binary_operator:+; 141, 142; 141, 143; 142, identifier:mjd; 143, subscript; 143, 144; 143, 145; 143, 147; 144, float:2400000.5; 145, ERROR; 145, 146; 146, identifier:leap_dates; 147, unary_operator:-; 147, 148; 148, integer:1; 149, string:'inf'; 150, identifier:leap_offsets; 151, subscript; 151, 152; 151, 163; 151, 165; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:np; 155, identifier:ndarray; 156, argument_list; 156, 157; 157, binary_operator:+; 157, 158; 157, 162; 158, call; 158, 159; 158, 160; 159, identifier:len; 160, argument_list; 160, 161; 161, identifier:mjd; 162, integer:2; 163, ERROR; 163, 164; 164, identifier:leap_offsets; 165, integer:0; 166, subscript; 166, 167; 166, 168; 167, identifier:leap_offsets; 168, integer:1; 169, subscript; 169, 170; 169, 173; 169, 175; 170, subscript; 170, 171; 170, 172; 171, identifier:offsets; 172, integer:0; 173, ERROR; 173, 174; 174, identifier:leap_offsets; 175, slice; 175, 176; 175, 177; 176, integer:2; 177, colon; 178, identifier:offsets; 179, identifier:return; 180, identifier:expiration_date; 181, tuple; 181, 182; 181, 183; 182, identifier:leap_dates; 183, identifier:leap_offsets; 184, block: | def parse_leap_seconds(fileobj):
lines = iter(fileobj)
for line in lines:
if line.startswith(b'
break
else:
raise ValueError('Leap_Second.dat is missing its expiration date')
line = line.decode('ascii')
with _lock:
original_locale = locale.setlocale(locale.LC_ALL)
locale.setlocale(locale.LC_ALL, 'C')
try:
dt = datetime.strptime(line, '
finally:
locale.setlocale(locale.LC_ALL, original_locale)
grace_period = timedelta(days=30)
expiration_date = dt.date() + grace_period
mjd, day, month, year, offsets = np.loadtxt(lines).T
leap_dates = np.ndarray(len(mjd) + 2)
leap_dates[0] = '-inf'
leap_dates[1:-1] = mjd + 2400000.5
leap_dates[-1] = 'inf'
leap_offsets = np.ndarray(len(mjd) + 2)
leap_offsets[0] = leap_offsets[1] = offsets[0]
leap_offsets[2:] = offsets
return expiration_date, (leap_dates, leap_offsets) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:build_delta_t_table; 3, parameters; 3, 4; 4, identifier:delta_t_recent; 5, block; 5, 6; 5, 13; 5, 20; 5, 27; 5, 37; 5, 55; 5, 62; 5, 72; 5, 80; 5, 100; 5, 104; 5, 113; 5, 126; 5, 136; 5, 150; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ancient; 9, call; 9, 10; 9, 11; 10, identifier:load_bundled_npy; 11, argument_list; 11, 12; 12, string:'morrison_stephenson_deltat.npy'; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:historic; 16, call; 16, 17; 16, 18; 17, identifier:load_bundled_npy; 18, argument_list; 18, 19; 19, string:'historic_deltat.npy'; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:historic_start_time; 23, subscript; 23, 24; 23, 25; 23, 26; 24, identifier:historic; 25, integer:0; 26, integer:0; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:i; 30, call; 30, 31; 30, 32; 31, identifier:searchsorted; 32, argument_list; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:ancient; 35, integer:0; 36, identifier:historic_start_time; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:bundled; 40, call; 40, 41; 40, 42; 41, identifier:concatenate; 42, argument_list; 42, 43; 42, 52; 43, list:[ancient[:,:i], historic]; 43, 44; 43, 51; 44, subscript; 44, 45; 44, 46; 44, 48; 45, identifier:ancient; 46, slice; 46, 47; 47, colon; 48, slice; 48, 49; 48, 50; 49, colon; 50, identifier:i; 51, identifier:historic; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:axis; 54, integer:1; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:recent_start_time; 58, subscript; 58, 59; 58, 60; 58, 61; 59, identifier:delta_t_recent; 60, integer:0; 61, integer:0; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:i; 65, call; 65, 66; 65, 67; 66, identifier:searchsorted; 67, argument_list; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:bundled; 70, integer:0; 71, identifier:recent_start_time; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:row; 75, tuple; 75, 76; 75, 78; 76, tuple; 76, 77; 77, integer:0; 78, tuple; 78, 79; 79, integer:0; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:table; 83, call; 83, 84; 83, 85; 84, identifier:concatenate; 85, argument_list; 85, 86; 85, 97; 86, list:[row, bundled[:,:i], delta_t_recent, row]; 86, 87; 86, 88; 86, 95; 86, 96; 87, identifier:row; 88, subscript; 88, 89; 88, 90; 88, 92; 89, identifier:bundled; 90, slice; 90, 91; 91, colon; 92, slice; 92, 93; 92, 94; 93, colon; 94, identifier:i; 95, identifier:delta_t_recent; 96, identifier:row; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:axis; 99, integer:1; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:century; 103, float:36524.0; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:start; 107, binary_operator:-; 107, 108; 107, 112; 108, subscript; 108, 109; 108, 110; 108, 111; 109, identifier:table; 110, integer:0; 111, integer:1; 112, identifier:century; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 120; 115, subscript; 115, 116; 115, 117; 115, 119; 116, identifier:table; 117, slice; 117, 118; 118, colon; 119, integer:0; 120, expression_list; 120, 121; 120, 122; 121, identifier:start; 122, call; 122, 123; 122, 124; 123, identifier:delta_t_formula_morrison_and_stephenson_2004; 124, argument_list; 124, 125; 125, identifier:start; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:end; 129, binary_operator:+; 129, 130; 129, 135; 130, subscript; 130, 131; 130, 132; 130, 133; 131, identifier:table; 132, integer:0; 133, unary_operator:-; 133, 134; 134, integer:2; 135, identifier:century; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 144; 138, subscript; 138, 139; 138, 140; 138, 142; 139, identifier:table; 140, slice; 140, 141; 141, colon; 142, unary_operator:-; 142, 143; 143, integer:1; 144, expression_list; 144, 145; 144, 146; 145, identifier:end; 146, call; 146, 147; 146, 148; 147, identifier:delta_t_formula_morrison_and_stephenson_2004; 148, argument_list; 148, 149; 149, identifier:end; 150, return_statement; 150, 151; 151, identifier:table | def build_delta_t_table(delta_t_recent):
ancient = load_bundled_npy('morrison_stephenson_deltat.npy')
historic = load_bundled_npy('historic_deltat.npy')
historic_start_time = historic[0,0]
i = searchsorted(ancient[0], historic_start_time)
bundled = concatenate([ancient[:,:i], historic], axis=1)
recent_start_time = delta_t_recent[0,0]
i = searchsorted(bundled[0], recent_start_time)
row = ((0,),(0,))
table = concatenate([row, bundled[:,:i], delta_t_recent, row], axis=1)
century = 36524.0
start = table[0,1] - century
table[:,0] = start, delta_t_formula_morrison_and_stephenson_2004(start)
end = table[0,-2] + century
table[:,-1] = end, delta_t_formula_morrison_and_stephenson_2004(end)
return table |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 55; 2, function_name:plot_confusion_matrix_with_cv; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 3, 34; 3, 37; 3, 40; 3, 43; 3, 46; 3, 49; 3, 52; 4, identifier:clf; 5, identifier:X; 6, identifier:y; 7, default_parameter; 7, 8; 7, 9; 8, identifier:labels; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:true_labels; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:pred_labels; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:title; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:normalize; 21, False; 22, default_parameter; 22, 23; 22, 24; 23, identifier:hide_zeros; 24, False; 25, default_parameter; 25, 26; 25, 27; 26, identifier:x_tick_rotation; 27, integer:0; 28, default_parameter; 28, 29; 28, 30; 29, identifier:do_cv; 30, True; 31, default_parameter; 31, 32; 31, 33; 32, identifier:cv; 33, None; 34, default_parameter; 34, 35; 34, 36; 35, identifier:shuffle; 36, True; 37, default_parameter; 37, 38; 37, 39; 38, identifier:random_state; 39, None; 40, default_parameter; 40, 41; 40, 42; 41, identifier:ax; 42, None; 43, default_parameter; 43, 44; 43, 45; 44, identifier:figsize; 45, None; 46, default_parameter; 46, 47; 46, 48; 47, identifier:cmap; 48, string:'Blues'; 49, default_parameter; 49, 50; 49, 51; 50, identifier:title_fontsize; 51, string:"large"; 52, default_parameter; 52, 53; 52, 54; 53, identifier:text_fontsize; 54, string:"medium"; 55, block; 55, 56; 55, 65; 55, 226; 55, 276; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:y; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:np; 62, identifier:array; 63, argument_list; 63, 64; 64, identifier:y; 65, if_statement; 65, 66; 65, 68; 65, 82; 66, not_operator; 66, 67; 67, identifier:do_cv; 68, block; 68, 69; 68, 78; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:y_pred; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:clf; 75, identifier:predict; 76, argument_list; 76, 77; 77, identifier:X; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:y_true; 81, identifier:y; 82, else_clause; 82, 83; 83, block; 83, 84; 83, 126; 83, 133; 83, 137; 83, 141; 83, 208; 83, 217; 84, if_statement; 84, 85; 84, 88; 84, 101; 84, 123; 85, comparison_operator:is; 85, 86; 85, 87; 86, identifier:cv; 87, None; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:cv; 92, call; 92, 93; 92, 94; 93, identifier:StratifiedKFold; 94, argument_list; 94, 95; 94, 98; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:shuffle; 97, identifier:shuffle; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:random_state; 100, identifier:random_state; 101, elif_clause; 101, 102; 101, 107; 102, call; 102, 103; 102, 104; 103, identifier:isinstance; 104, argument_list; 104, 105; 104, 106; 105, identifier:cv; 106, identifier:int; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:cv; 111, call; 111, 112; 111, 113; 112, identifier:StratifiedKFold; 113, argument_list; 113, 114; 113, 117; 113, 120; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:n_splits; 116, identifier:cv; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:shuffle; 119, identifier:shuffle; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:random_state; 122, identifier:random_state; 123, else_clause; 123, 124; 124, block; 124, 125; 125, pass_statement; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:clf_clone; 129, call; 129, 130; 129, 131; 130, identifier:clone; 131, argument_list; 131, 132; 132, identifier:clf; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:preds_list; 136, list:[]; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:trues_list; 140, list:[]; 141, for_statement; 141, 142; 141, 145; 141, 152; 142, pattern_list; 142, 143; 142, 144; 143, identifier:train_index; 144, identifier:test_index; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:cv; 148, identifier:split; 149, argument_list; 149, 150; 149, 151; 150, identifier:X; 151, identifier:y; 152, block; 152, 153; 152, 165; 152, 177; 152, 185; 152, 194; 152, 201; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 158; 155, pattern_list; 155, 156; 155, 157; 156, identifier:X_train; 157, identifier:X_test; 158, expression_list; 158, 159; 158, 162; 159, subscript; 159, 160; 159, 161; 160, identifier:X; 161, identifier:train_index; 162, subscript; 162, 163; 162, 164; 163, identifier:X; 164, identifier:test_index; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 170; 167, pattern_list; 167, 168; 167, 169; 168, identifier:y_train; 169, identifier:y_test; 170, expression_list; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:y; 173, identifier:train_index; 174, subscript; 174, 175; 174, 176; 175, identifier:y; 176, identifier:test_index; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:clf_clone; 181, identifier:fit; 182, argument_list; 182, 183; 182, 184; 183, identifier:X_train; 184, identifier:y_train; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:preds; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:clf_clone; 191, identifier:predict; 192, argument_list; 192, 193; 193, identifier:X_test; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:preds_list; 198, identifier:append; 199, argument_list; 199, 200; 200, identifier:preds; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:trues_list; 205, identifier:append; 206, argument_list; 206, 207; 207, identifier:y_test; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:y_pred; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:np; 214, identifier:concatenate; 215, argument_list; 215, 216; 216, identifier:preds_list; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:y_true; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:np; 223, identifier:concatenate; 224, argument_list; 224, 225; 225, identifier:trues_list; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:ax; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:plotters; 232, identifier:plot_confusion_matrix; 233, argument_list; 233, 234; 233, 237; 233, 240; 233, 243; 233, 246; 233, 249; 233, 252; 233, 255; 233, 258; 233, 261; 233, 264; 233, 267; 233, 270; 233, 273; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:y_true; 236, identifier:y_true; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:y_pred; 239, identifier:y_pred; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:labels; 242, identifier:labels; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:true_labels; 245, identifier:true_labels; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:pred_labels; 248, identifier:pred_labels; 249, keyword_argument; 249, 250; 249, 251; 250, identifier:title; 251, identifier:title; 252, keyword_argument; 252, 253; 252, 254; 253, identifier:normalize; 254, identifier:normalize; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:hide_zeros; 257, identifier:hide_zeros; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:x_tick_rotation; 260, identifier:x_tick_rotation; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:ax; 263, identifier:ax; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:figsize; 266, identifier:figsize; 267, keyword_argument; 267, 268; 267, 269; 268, identifier:cmap; 269, identifier:cmap; 270, keyword_argument; 270, 271; 270, 272; 271, identifier:title_fontsize; 272, identifier:title_fontsize; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:text_fontsize; 275, identifier:text_fontsize; 276, return_statement; 276, 277; 277, identifier:ax | def plot_confusion_matrix_with_cv(clf, X, y, labels=None, true_labels=None,
pred_labels=None, title=None,
normalize=False, hide_zeros=False,
x_tick_rotation=0, do_cv=True, cv=None,
shuffle=True, random_state=None, ax=None,
figsize=None, cmap='Blues',
title_fontsize="large",
text_fontsize="medium"):
y = np.array(y)
if not do_cv:
y_pred = clf.predict(X)
y_true = y
else:
if cv is None:
cv = StratifiedKFold(shuffle=shuffle, random_state=random_state)
elif isinstance(cv, int):
cv = StratifiedKFold(n_splits=cv, shuffle=shuffle,
random_state=random_state)
else:
pass
clf_clone = clone(clf)
preds_list = []
trues_list = []
for train_index, test_index in cv.split(X, y):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
clf_clone.fit(X_train, y_train)
preds = clf_clone.predict(X_test)
preds_list.append(preds)
trues_list.append(y_test)
y_pred = np.concatenate(preds_list)
y_true = np.concatenate(trues_list)
ax = plotters.plot_confusion_matrix(y_true=y_true, y_pred=y_pred,
labels=labels, true_labels=true_labels,
pred_labels=pred_labels,
title=title, normalize=normalize,
hide_zeros=hide_zeros,
x_tick_rotation=x_tick_rotation, ax=ax,
figsize=figsize, cmap=cmap,
title_fontsize=title_fontsize,
text_fontsize=text_fontsize)
return ax |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 42; 2, function_name:plot_confusion_matrix; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 3, 33; 3, 36; 3, 39; 4, identifier:y_true; 5, identifier:y_pred; 6, default_parameter; 6, 7; 6, 8; 7, identifier:labels; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:true_labels; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:pred_labels; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:title; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:normalize; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:hide_zeros; 23, False; 24, default_parameter; 24, 25; 24, 26; 25, identifier:x_tick_rotation; 26, integer:0; 27, default_parameter; 27, 28; 27, 29; 28, identifier:ax; 29, None; 30, default_parameter; 30, 31; 30, 32; 31, identifier:figsize; 32, None; 33, default_parameter; 33, 34; 33, 35; 34, identifier:cmap; 35, string:'Blues'; 36, default_parameter; 36, 37; 36, 38; 37, identifier:title_fontsize; 38, string:"large"; 39, default_parameter; 39, 40; 39, 41; 40, identifier:text_fontsize; 41, string:"medium"; 42, block; 42, 43; 42, 63; 42, 74; 42, 98; 42, 148; 42, 188; 42, 230; 42, 268; 42, 290; 42, 299; 42, 311; 42, 323; 42, 330; 42, 343; 42, 350; 42, 360; 42, 370; 42, 440; 42, 450; 42, 460; 42, 467; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:ax; 46, None; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:fig; 52, identifier:ax; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:plt; 56, identifier:subplots; 57, argument_list; 57, 58; 57, 59; 57, 60; 58, integer:1; 59, integer:1; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:figsize; 62, identifier:figsize; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:cm; 66, call; 66, 67; 66, 68; 67, identifier:confusion_matrix; 68, argument_list; 68, 69; 68, 70; 68, 71; 69, identifier:y_true; 70, identifier:y_pred; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:labels; 73, identifier:labels; 74, if_statement; 74, 75; 74, 78; 74, 87; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:labels; 77, None; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:classes; 82, call; 82, 83; 82, 84; 83, identifier:unique_labels; 84, argument_list; 84, 85; 84, 86; 85, identifier:y_true; 86, identifier:y_pred; 87, else_clause; 87, 88; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:classes; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:np; 95, identifier:asarray; 96, argument_list; 96, 97; 97, identifier:labels; 98, if_statement; 98, 99; 98, 100; 99, identifier:normalize; 100, block; 100, 101; 100, 125; 100, 137; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:cm; 104, binary_operator:/; 104, 105; 104, 111; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:cm; 108, identifier:astype; 109, argument_list; 109, 110; 110, string:'float'; 111, subscript; 111, 112; 111, 120; 111, 122; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:cm; 115, identifier:sum; 116, argument_list; 116, 117; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:axis; 119, integer:1; 120, slice; 120, 121; 121, colon; 122, attribute; 122, 123; 122, 124; 123, identifier:np; 124, identifier:newaxis; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:cm; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:np; 131, identifier:around; 132, argument_list; 132, 133; 132, 134; 133, identifier:cm; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:decimals; 136, integer:2; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 147; 139, subscript; 139, 140; 139, 141; 140, identifier:cm; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:np; 144, identifier:isnan; 145, argument_list; 145, 146; 146, identifier:cm; 147, float:0.0; 148, if_statement; 148, 149; 148, 152; 148, 157; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:true_labels; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:true_classes; 156, identifier:classes; 157, else_clause; 157, 158; 158, block; 158, 159; 158, 166; 158, 176; 158, 182; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:validate_labels; 162, argument_list; 162, 163; 162, 164; 162, 165; 163, identifier:classes; 164, identifier:true_labels; 165, string:"true_labels"; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:true_label_indexes; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:np; 172, identifier:in1d; 173, argument_list; 173, 174; 173, 175; 174, identifier:classes; 175, identifier:true_labels; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:true_classes; 179, subscript; 179, 180; 179, 181; 180, identifier:classes; 181, identifier:true_label_indexes; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:cm; 185, subscript; 185, 186; 185, 187; 186, identifier:cm; 187, identifier:true_label_indexes; 188, if_statement; 188, 189; 188, 192; 188, 197; 189, comparison_operator:is; 189, 190; 189, 191; 190, identifier:pred_labels; 191, None; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:pred_classes; 196, identifier:classes; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 206; 198, 216; 198, 222; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:validate_labels; 202, argument_list; 202, 203; 202, 204; 202, 205; 203, identifier:classes; 204, identifier:pred_labels; 205, string:"pred_labels"; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:pred_label_indexes; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:np; 212, identifier:in1d; 213, argument_list; 213, 214; 213, 215; 214, identifier:classes; 215, identifier:pred_labels; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:pred_classes; 219, subscript; 219, 220; 219, 221; 220, identifier:classes; 221, identifier:pred_label_indexes; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:cm; 225, subscript; 225, 226; 225, 227; 225, 229; 226, identifier:cm; 227, slice; 227, 228; 228, colon; 229, identifier:pred_label_indexes; 230, if_statement; 230, 231; 230, 232; 230, 243; 230, 256; 231, identifier:title; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:ax; 237, identifier:set_title; 238, argument_list; 238, 239; 238, 240; 239, identifier:title; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:fontsize; 242, identifier:title_fontsize; 243, elif_clause; 243, 244; 243, 245; 244, identifier:normalize; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:ax; 250, identifier:set_title; 251, argument_list; 251, 252; 251, 253; 252, string:'Normalized Confusion Matrix'; 253, keyword_argument; 253, 254; 253, 255; 254, identifier:fontsize; 255, identifier:title_fontsize; 256, else_clause; 256, 257; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:ax; 262, identifier:set_title; 263, argument_list; 263, 264; 263, 265; 264, string:'Confusion Matrix'; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:fontsize; 267, identifier:title_fontsize; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:image; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:ax; 274, identifier:imshow; 275, argument_list; 275, 276; 275, 277; 275, 280; 276, identifier:cm; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:interpolation; 279, string:'nearest'; 280, keyword_argument; 280, 281; 280, 282; 281, identifier:cmap; 282, call; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:plt; 286, identifier:cm; 287, identifier:get_cmap; 288, argument_list; 288, 289; 289, identifier:cmap; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:plt; 294, identifier:colorbar; 295, argument_list; 295, 296; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:mappable; 298, identifier:image; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:x_tick_marks; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:np; 305, identifier:arange; 306, argument_list; 306, 307; 307, call; 307, 308; 307, 309; 308, identifier:len; 309, argument_list; 309, 310; 310, identifier:pred_classes; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:y_tick_marks; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:np; 317, identifier:arange; 318, argument_list; 318, 319; 319, call; 319, 320; 319, 321; 320, identifier:len; 321, argument_list; 321, 322; 322, identifier:true_classes; 323, expression_statement; 323, 324; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:ax; 327, identifier:set_xticks; 328, argument_list; 328, 329; 329, identifier:x_tick_marks; 330, expression_statement; 330, 331; 331, call; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:ax; 334, identifier:set_xticklabels; 335, argument_list; 335, 336; 335, 337; 335, 340; 336, identifier:pred_classes; 337, keyword_argument; 337, 338; 337, 339; 338, identifier:fontsize; 339, identifier:text_fontsize; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:rotation; 342, identifier:x_tick_rotation; 343, expression_statement; 343, 344; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:ax; 347, identifier:set_yticks; 348, argument_list; 348, 349; 349, identifier:y_tick_marks; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:ax; 354, identifier:set_yticklabels; 355, argument_list; 355, 356; 355, 357; 356, identifier:true_classes; 357, keyword_argument; 357, 358; 357, 359; 358, identifier:fontsize; 359, identifier:text_fontsize; 360, expression_statement; 360, 361; 361, assignment; 361, 362; 361, 363; 362, identifier:thresh; 363, binary_operator:/; 363, 364; 363, 369; 364, call; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, identifier:cm; 367, identifier:max; 368, argument_list; 369, float:2.; 370, for_statement; 370, 371; 370, 374; 370, 395; 371, pattern_list; 371, 372; 371, 373; 372, identifier:i; 373, identifier:j; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:itertools; 377, identifier:product; 378, argument_list; 378, 379; 378, 387; 379, call; 379, 380; 379, 381; 380, identifier:range; 381, argument_list; 381, 382; 382, subscript; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:cm; 385, identifier:shape; 386, integer:0; 387, call; 387, 388; 387, 389; 388, identifier:range; 389, argument_list; 389, 390; 390, subscript; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:cm; 393, identifier:shape; 394, integer:1; 395, block; 395, 396; 396, if_statement; 396, 397; 396, 407; 397, not_operator; 397, 398; 398, parenthesized_expression; 398, 399; 399, boolean_operator:and; 399, 400; 399, 401; 400, identifier:hide_zeros; 401, comparison_operator:==; 401, 402; 401, 406; 402, subscript; 402, 403; 402, 404; 402, 405; 403, identifier:cm; 404, identifier:i; 405, identifier:j; 406, integer:0; 407, block; 407, 408; 408, expression_statement; 408, 409; 409, call; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, identifier:ax; 412, identifier:text; 413, argument_list; 413, 414; 413, 415; 413, 416; 413, 420; 413, 423; 413, 426; 413, 429; 414, identifier:j; 415, identifier:i; 416, subscript; 416, 417; 416, 418; 416, 419; 417, identifier:cm; 418, identifier:i; 419, identifier:j; 420, keyword_argument; 420, 421; 420, 422; 421, identifier:horizontalalignment; 422, string:"center"; 423, keyword_argument; 423, 424; 423, 425; 424, identifier:verticalalignment; 425, string:"center"; 426, keyword_argument; 426, 427; 426, 428; 427, identifier:fontsize; 428, identifier:text_fontsize; 429, keyword_argument; 429, 430; 429, 431; 430, identifier:color; 431, conditional_expression:if; 431, 432; 431, 433; 431, 439; 432, string:"white"; 433, comparison_operator:>; 433, 434; 433, 438; 434, subscript; 434, 435; 434, 436; 434, 437; 435, identifier:cm; 436, identifier:i; 437, identifier:j; 438, identifier:thresh; 439, string:"black"; 440, expression_statement; 440, 441; 441, call; 441, 442; 441, 445; 442, attribute; 442, 443; 442, 444; 443, identifier:ax; 444, identifier:set_ylabel; 445, argument_list; 445, 446; 445, 447; 446, string:'True label'; 447, keyword_argument; 447, 448; 447, 449; 448, identifier:fontsize; 449, identifier:text_fontsize; 450, expression_statement; 450, 451; 451, call; 451, 452; 451, 455; 452, attribute; 452, 453; 452, 454; 453, identifier:ax; 454, identifier:set_xlabel; 455, argument_list; 455, 456; 455, 457; 456, string:'Predicted label'; 457, keyword_argument; 457, 458; 457, 459; 458, identifier:fontsize; 459, identifier:text_fontsize; 460, expression_statement; 460, 461; 461, call; 461, 462; 461, 465; 462, attribute; 462, 463; 462, 464; 463, identifier:ax; 464, identifier:grid; 465, argument_list; 465, 466; 466, string:'off'; 467, return_statement; 467, 468; 468, identifier:ax | def plot_confusion_matrix(y_true, y_pred, labels=None, true_labels=None,
pred_labels=None, title=None, normalize=False,
hide_zeros=False, x_tick_rotation=0, ax=None,
figsize=None, cmap='Blues', title_fontsize="large",
text_fontsize="medium"):
if ax is None:
fig, ax = plt.subplots(1, 1, figsize=figsize)
cm = confusion_matrix(y_true, y_pred, labels=labels)
if labels is None:
classes = unique_labels(y_true, y_pred)
else:
classes = np.asarray(labels)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
cm = np.around(cm, decimals=2)
cm[np.isnan(cm)] = 0.0
if true_labels is None:
true_classes = classes
else:
validate_labels(classes, true_labels, "true_labels")
true_label_indexes = np.in1d(classes, true_labels)
true_classes = classes[true_label_indexes]
cm = cm[true_label_indexes]
if pred_labels is None:
pred_classes = classes
else:
validate_labels(classes, pred_labels, "pred_labels")
pred_label_indexes = np.in1d(classes, pred_labels)
pred_classes = classes[pred_label_indexes]
cm = cm[:, pred_label_indexes]
if title:
ax.set_title(title, fontsize=title_fontsize)
elif normalize:
ax.set_title('Normalized Confusion Matrix', fontsize=title_fontsize)
else:
ax.set_title('Confusion Matrix', fontsize=title_fontsize)
image = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.get_cmap(cmap))
plt.colorbar(mappable=image)
x_tick_marks = np.arange(len(pred_classes))
y_tick_marks = np.arange(len(true_classes))
ax.set_xticks(x_tick_marks)
ax.set_xticklabels(pred_classes, fontsize=text_fontsize,
rotation=x_tick_rotation)
ax.set_yticks(y_tick_marks)
ax.set_yticklabels(true_classes, fontsize=text_fontsize)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
if not (hide_zeros and cm[i, j] == 0):
ax.text(j, i, cm[i, j],
horizontalalignment="center",
verticalalignment="center",
fontsize=text_fontsize,
color="white" if cm[i, j] > thresh else "black")
ax.set_ylabel('True label', fontsize=text_fontsize)
ax.set_xlabel('Predicted label', fontsize=text_fontsize)
ax.grid('off')
return ax |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorting; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 124; 6, if_statement; 6, 7; 6, 15; 7, call; 7, 8; 7, 13; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:qs; 12, identifier:get; 13, argument_list; 13, 14; 14, string:'sort'; 15, block; 15, 16; 15, 20; 15, 122; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:sorting_results; 19, list:[]; 20, for_statement; 20, 21; 20, 22; 20, 32; 21, identifier:sort_field; 22, call; 22, 23; 22, 30; 23, attribute; 23, 24; 23, 29; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:qs; 28, string:'sort'; 29, identifier:split; 30, argument_list; 30, 31; 31, string:','; 32, block; 32, 33; 32, 43; 32, 67; 32, 87; 32, 97; 32, 109; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:field; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:sort_field; 39, identifier:replace; 40, argument_list; 40, 41; 40, 42; 41, string:'-'; 42, string:''; 43, if_statement; 43, 44; 43, 51; 44, comparison_operator:not; 44, 45; 44, 46; 45, identifier:field; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:schema; 50, identifier:_declared_fields; 51, block; 51, 52; 52, raise_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:InvalidSort; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, string:"{} has no attribute {}"; 59, identifier:format; 60, argument_list; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:schema; 65, identifier:__name__; 66, identifier:field; 67, if_statement; 67, 68; 67, 76; 68, comparison_operator:in; 68, 69; 68, 70; 69, identifier:field; 70, call; 70, 71; 70, 72; 71, identifier:get_relationships; 72, argument_list; 72, 73; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:schema; 76, block; 76, 77; 77, raise_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:InvalidSort; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, string:"You can't sort on {} because it is a relationship field"; 84, identifier:format; 85, argument_list; 85, 86; 86, identifier:field; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:field; 90, call; 90, 91; 90, 92; 91, identifier:get_model_field; 92, argument_list; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:schema; 96, identifier:field; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:order; 100, conditional_expression:if; 100, 101; 100, 102; 100, 108; 101, string:'desc'; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:sort_field; 105, identifier:startswith; 106, argument_list; 106, 107; 107, string:'-'; 108, string:'asc'; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:sorting_results; 113, identifier:append; 114, argument_list; 114, 115; 115, dictionary; 115, 116; 115, 119; 116, pair; 116, 117; 116, 118; 117, string:'field'; 118, identifier:field; 119, pair; 119, 120; 119, 121; 120, string:'order'; 121, identifier:order; 122, return_statement; 122, 123; 123, identifier:sorting_results; 124, return_statement; 124, 125; 125, list:[] | def sorting(self):
if self.qs.get('sort'):
sorting_results = []
for sort_field in self.qs['sort'].split(','):
field = sort_field.replace('-', '')
if field not in self.schema._declared_fields:
raise InvalidSort("{} has no attribute {}".format(self.schema.__name__, field))
if field in get_relationships(self.schema):
raise InvalidSort("You can't sort on {} because it is a relationship field".format(field))
field = get_model_field(self.schema, field)
order = 'desc' if sort_field.startswith('-') else 'asc'
sorting_results.append({'field': field, 'order': order})
return sorting_results
return [] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:filter_query; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:query; 6, identifier:filter_info; 7, identifier:model; 8, block; 8, 9; 8, 33; 9, if_statement; 9, 10; 9, 11; 10, identifier:filter_info; 11, block; 11, 12; 11, 23; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:filters; 15, call; 15, 16; 15, 17; 16, identifier:create_filters; 17, argument_list; 17, 18; 17, 19; 17, 20; 18, identifier:model; 19, identifier:filter_info; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:resource; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:query; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:query; 29, identifier:filter; 30, argument_list; 30, 31; 31, list_splat; 31, 32; 32, identifier:filters; 33, return_statement; 33, 34; 34, identifier:query | def filter_query(self, query, filter_info, model):
if filter_info:
filters = create_filters(model, filter_info, self.resource)
query = query.filter(*filters)
return query |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_query; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:query; 6, identifier:sort_info; 7, block; 7, 8; 7, 66; 8, for_statement; 8, 9; 8, 10; 8, 11; 9, identifier:sort_opt; 10, identifier:sort_info; 11, block; 11, 12; 11, 18; 11, 43; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:field; 15, subscript; 15, 16; 15, 17; 16, identifier:sort_opt; 17, string:'field'; 18, if_statement; 18, 19; 18, 27; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:hasattr; 22, argument_list; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:model; 26, identifier:field; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:InvalidSort; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, string:"{} has no attribute {}"; 35, identifier:format; 36, argument_list; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:model; 41, identifier:__name__; 42, identifier:field; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:query; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:query; 49, identifier:order_by; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 65; 52, call; 52, 53; 52, 54; 53, identifier:getattr; 54, argument_list; 54, 55; 54, 62; 55, call; 55, 56; 55, 57; 56, identifier:getattr; 57, argument_list; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:model; 61, identifier:field; 62, subscript; 62, 63; 62, 64; 63, identifier:sort_opt; 64, string:'order'; 65, argument_list; 66, return_statement; 66, 67; 67, identifier:query | def sort_query(self, query, sort_info):
for sort_opt in sort_info:
field = sort_opt['field']
if not hasattr(self.model, field):
raise InvalidSort("{} has no attribute {}".format(self.model.__name__, field))
query = query.order_by(getattr(getattr(self.model, field), sort_opt['order'])())
return query |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 1, 25; 2, function_name:_get_log_entries; 3, parameters; 3, 4; 4, identifier:self; 5, type; 5, 6; 6, generic_type; 6, 7; 6, 8; 7, identifier:List; 8, type_parameter; 8, 9; 9, type; 9, 10; 10, generic_type; 10, 11; 10, 12; 11, identifier:Tuple; 12, type_parameter; 12, 13; 12, 15; 12, 17; 12, 23; 13, type; 13, 14; 14, identifier:int; 15, type; 15, 16; 16, identifier:bytes; 17, type; 17, 18; 18, generic_type; 18, 19; 18, 20; 19, identifier:List; 20, type_parameter; 20, 21; 21, type; 21, 22; 22, identifier:int; 23, type; 23, 24; 24, identifier:bytes; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 30; 26, 33; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:is_error; 30, block; 30, 31; 31, return_statement; 31, 32; 32, list:[]; 33, else_clause; 33, 34; 34, block; 34, 35; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:sorted; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:itertools; 42, identifier:chain; 43, argument_list; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_log_entries; 47, list_splat; 47, 48; 48, generator_expression; 48, 49; 48, 54; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:child; 52, identifier:_get_log_entries; 53, argument_list; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:child; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:children | def _get_log_entries(self) -> List[Tuple[int, bytes, List[int], bytes]]:
if self.is_error:
return []
else:
return sorted(itertools.chain(
self._log_entries,
*(child._get_log_entries() for child in self.children)
)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sort_by_size; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:group_limit; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:discard_others; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:others_label; 13, string:'others'; 14, block; 14, 15; 14, 48; 14, 155; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:groups; 20, call; 20, 21; 20, 22; 21, identifier:OrderedDict; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:sorted; 25, argument_list; 25, 26; 25, 34; 25, 45; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:six; 29, identifier:iteritems; 30, argument_list; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:groups; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:key; 36, lambda; 36, 37; 36, 39; 37, lambda_parameters; 37, 38; 38, identifier:x; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:x; 44, integer:1; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:reverse; 47, True; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:group_limit; 51, None; 52, block; 52, 53; 52, 101; 52, 130; 53, if_statement; 53, 54; 53, 56; 53, 85; 54, not_operator; 54, 55; 55, identifier:discard_others; 56, block; 56, 57; 56, 73; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:group_keys; 60, subscript; 60, 61; 60, 68; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:groups; 66, identifier:keys; 67, argument_list; 68, slice; 68, 69; 68, 72; 69, binary_operator:-; 69, 70; 69, 71; 70, identifier:group_limit; 71, integer:1; 72, colon; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:groups; 79, identifier:setdefault; 80, argument_list; 80, 81; 80, 82; 81, identifier:others_label; 82, call; 82, 83; 82, 84; 83, identifier:list; 84, argument_list; 85, else_clause; 85, 86; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:group_keys; 90, subscript; 90, 91; 90, 98; 91, call; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:groups; 96, identifier:keys; 97, argument_list; 98, slice; 98, 99; 98, 100; 99, identifier:group_limit; 100, colon; 101, for_statement; 101, 102; 101, 103; 101, 104; 102, identifier:g; 103, identifier:group_keys; 104, block; 104, 105; 104, 124; 105, if_statement; 105, 106; 105, 108; 106, not_operator; 106, 107; 107, identifier:discard_others; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 118; 111, attribute; 111, 112; 111, 117; 112, subscript; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:groups; 116, identifier:others_label; 117, identifier:extend; 118, argument_list; 118, 119; 119, subscript; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:groups; 123, identifier:g; 124, delete_statement; 124, 125; 125, subscript; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:groups; 129, identifier:g; 130, if_statement; 130, 131; 130, 148; 131, parenthesized_expression; 131, 132; 132, boolean_operator:and; 132, 133; 132, 138; 133, comparison_operator:in; 133, 134; 133, 135; 134, identifier:others_label; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:groups; 138, comparison_operator:==; 138, 139; 138, 147; 139, call; 139, 140; 139, 141; 140, identifier:len; 141, argument_list; 141, 142; 142, subscript; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:groups; 146, identifier:others_label; 147, integer:0; 148, block; 148, 149; 149, delete_statement; 149, 150; 150, subscript; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:groups; 154, identifier:others_label; 155, if_statement; 155, 156; 155, 163; 156, boolean_operator:and; 156, 157; 156, 158; 157, identifier:discard_others; 158, comparison_operator:in; 158, 159; 158, 160; 159, identifier:others_label; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:groups; 163, block; 163, 164; 164, delete_statement; 164, 165; 165, subscript; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:groups; 169, identifier:others_label | def sort_by_size(self, group_limit=None, discard_others=False,
others_label='others'):
self.groups = OrderedDict(sorted(six.iteritems(self.groups),
key=lambda x: len(x[1]),
reverse=True))
if group_limit is not None:
if not discard_others:
group_keys = self.groups.keys()[group_limit - 1:]
self.groups.setdefault(others_label, list())
else:
group_keys = self.groups.keys()[group_limit:]
for g in group_keys:
if not discard_others:
self.groups[others_label].extend(self.groups[g])
del self.groups[g]
if (others_label in self.groups and
len(self.groups[others_label]) == 0):
del self.groups[others_label]
if discard_others and others_label in self.groups:
del self.groups[others_label] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_comments; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:resource; 6, default_parameter; 6, 7; 6, 8; 7, identifier:before; 8, None; 9, block; 9, 10; 9, 27; 9, 67; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:params; 13, call; 13, 14; 13, 15; 14, identifier:dict; 15, argument_list; 15, 16; 15, 21; 15, 24; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:apikey; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:api_key; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:resource; 23, identifier:resource; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:before; 26, identifier:before; 27, try_statement; 27, 28; 27, 50; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:response; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:requests; 35, identifier:get; 36, argument_list; 36, 37; 36, 42; 36, 45; 37, binary_operator:+; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:base; 41, string:'comments/get'; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:params; 44, identifier:params; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:proxies; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:proxies; 50, except_clause; 50, 51; 50, 57; 51, as_pattern; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:requests; 54, identifier:RequestException; 55, as_pattern_target; 55, 56; 56, identifier:e; 57, block; 57, 58; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:dict; 61, argument_list; 61, 62; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:error; 64, attribute; 64, 65; 64, 66; 65, identifier:e; 66, identifier:message; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:_return_response_and_status_code; 70, argument_list; 70, 71; 71, identifier:response | def get_comments(self, resource, before=None):
params = dict(apikey=self.api_key, resource=resource, before=before)
try:
response = requests.get(self.base + 'comments/get', params=params, proxies=self.proxies)
except requests.RequestException as e:
return dict(error=e.message)
return _return_response_and_status_code(response) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:clean_fail; 3, parameters; 3, 4; 4, identifier:func; 5, block; 5, 6; 5, 8; 5, 56; 6, expression_statement; 6, 7; 7, string:'''
A decorator to cleanly exit on a failed call to AWS.
catch a `botocore.exceptions.ClientError` raised from an action.
This sort of error is raised if you are targeting a region that
isn't set up (see, `credstash setup`.
'''; 8, function_definition; 8, 9; 8, 10; 8, 15; 9, function_name:func_wrapper; 10, parameters; 10, 11; 10, 13; 11, list_splat_pattern; 11, 12; 12, identifier:args; 13, dictionary_splat_pattern; 13, 14; 14, identifier:kwargs; 15, block; 15, 16; 16, try_statement; 16, 17; 16, 26; 17, block; 17, 18; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:func; 21, argument_list; 21, 22; 21, 24; 22, list_splat; 22, 23; 23, identifier:args; 24, dictionary_splat; 24, 25; 25, identifier:kwargs; 26, except_clause; 26, 27; 26, 35; 27, as_pattern; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:botocore; 31, identifier:exceptions; 32, identifier:ClientError; 33, as_pattern_target; 33, 34; 34, identifier:e; 35, block; 35, 36; 35, 49; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:print; 39, argument_list; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:str; 42, argument_list; 42, 43; 43, identifier:e; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:file; 46, attribute; 46, 47; 46, 48; 47, identifier:sys; 48, identifier:stderr; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:sys; 53, identifier:exit; 54, argument_list; 54, 55; 55, integer:1; 56, return_statement; 56, 57; 57, identifier:func_wrapper | def clean_fail(func):
'''
A decorator to cleanly exit on a failed call to AWS.
catch a `botocore.exceptions.ClientError` raised from an action.
This sort of error is raised if you are targeting a region that
isn't set up (see, `credstash setup`.
'''
def func_wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except botocore.exceptions.ClientError as e:
print(str(e), file=sys.stderr)
sys.exit(1)
return func_wrapper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:parse_header; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, default_parameter; 5, 6; 5, 7; 6, identifier:value; 7, string:'*/*'; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, yield; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:sorted; 13, argument_list; 13, 14; 13, 39; 14, generator_expression; 14, 15; 14, 25; 14, 33; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:cls; 18, identifier:from_string; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:token; 23, identifier:strip; 24, argument_list; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:token; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:value; 30, identifier:split; 31, argument_list; 31, 32; 32, string:','; 33, if_clause; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:token; 37, identifier:strip; 38, argument_list; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:reverse; 41, True | def parse_header(cls, value='*/*'):
yield from sorted((
cls.from_string(token.strip())
for token in value.split(',')
if token.strip()
), reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_canonical; 3, parameters; 3, 4; 3, 5; 4, identifier:keyword; 5, identifier:stmts; 6, block; 6, 7; 6, 22; 6, 26; 6, 39; 6, 105; 6, 120; 7, try_statement; 7, 8; 7, 17; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 14; 11, tuple_pattern; 11, 12; 11, 13; 12, identifier:_arg_type; 13, identifier:subspec; 14, subscript; 14, 15; 14, 16; 15, identifier:stmt_map; 16, identifier:keyword; 17, except_clause; 17, 18; 17, 19; 18, identifier:KeyError; 19, block; 19, 20; 20, return_statement; 20, 21; 21, identifier:stmts; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:res; 25, list:[]; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:keep; 29, binary_operator:+; 29, 30; 29, 37; 30, list_comprehension; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:s; 33, integer:0; 34, for_in_clause; 34, 35; 34, 36; 35, identifier:s; 36, identifier:data_def_stmts; 37, list:['case']; 37, 38; 38, string:'case'; 39, for_statement; 39, 40; 39, 43; 39, 47; 40, tuple_pattern; 40, 41; 40, 42; 41, identifier:kw; 42, identifier:_spec; 43, call; 43, 44; 43, 45; 44, identifier:flatten_spec; 45, argument_list; 45, 46; 46, identifier:subspec; 47, block; 47, 48; 47, 52; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:comments; 51, list:[]; 52, for_statement; 52, 53; 52, 54; 52, 55; 53, identifier:s; 54, identifier:stmts; 55, block; 55, 56; 56, if_statement; 56, 57; 56, 62; 56, 70; 56, 99; 57, comparison_operator:==; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:s; 60, identifier:keyword; 61, string:'_comment'; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:comments; 67, identifier:append; 68, argument_list; 68, 69; 69, identifier:s; 70, elif_clause; 70, 71; 70, 80; 71, boolean_operator:and; 71, 72; 71, 77; 72, comparison_operator:==; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:s; 75, identifier:keyword; 76, identifier:kw; 77, comparison_operator:not; 77, 78; 77, 79; 78, identifier:kw; 79, identifier:keep; 80, block; 80, 81; 80, 88; 80, 92; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:res; 85, identifier:extend; 86, argument_list; 86, 87; 87, identifier:comments; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:comments; 91, list:[]; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:res; 96, identifier:append; 97, argument_list; 97, 98; 98, identifier:s; 99, else_clause; 99, 100; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:comments; 104, list:[]; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:res; 109, identifier:extend; 110, argument_list; 110, 111; 111, list_comprehension; 111, 112; 111, 113; 111, 116; 112, identifier:stmt; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:stmt; 115, identifier:stmts; 116, if_clause; 116, 117; 117, comparison_operator:not; 117, 118; 117, 119; 118, identifier:stmt; 119, identifier:res; 120, return_statement; 120, 121; 121, identifier:res | def sort_canonical(keyword, stmts):
try:
(_arg_type, subspec) = stmt_map[keyword]
except KeyError:
return stmts
res = []
keep = [s[0] for s in data_def_stmts] + ['case']
for (kw, _spec) in flatten_spec(subspec):
comments = []
for s in stmts:
if s.keyword == '_comment':
comments.append(s)
elif s.keyword == kw and kw not in keep:
res.extend(comments)
comments = []
res.append(s)
else:
comments = []
res.extend([stmt for stmt in stmts if stmt not in res])
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:start; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:num; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:by; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:get; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:desc; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:alpha; 23, False; 24, default_parameter; 24, 25; 24, 26; 25, identifier:store; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:groups; 29, False; 30, block; 30, 31; 30, 33; 30, 58; 30, 63; 30, 82; 30, 112; 30, 158; 30, 168; 30, 178; 30, 197; 30, 225; 30, 238; 31, expression_statement; 31, 32; 32, string:'''Sort and return the list, set or sorted set at ``key``.
``start`` and ``num`` allow for paging through the sorted data
``by`` allows using an external key to weight and sort the items.
Use an "*" to indicate where in the key the item value is located
``get`` allows for returning items from external keys rather than the
sorted data itself. Use an "*" to indicate where int he key
the item value is located
``desc`` allows for reversing the sort
``alpha`` allows for sorting lexicographically rather than numerically
``store`` allows for storing the result of the sort into
the key ``store``
``groups`` if set to True and if ``get`` contains at least two
elements, sort will return a list of tuples, each containing the
values fetched from the arguments to ``get``.
'''; 33, if_statement; 33, 34; 33, 52; 34, parenthesized_expression; 34, 35; 35, boolean_operator:or; 35, 36; 35, 44; 36, parenthesized_expression; 36, 37; 37, boolean_operator:and; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:start; 40, None; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:num; 43, None; 44, parenthesized_expression; 44, 45; 45, boolean_operator:and; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:num; 48, None; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:start; 51, None; 52, block; 52, 53; 53, raise_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:CommandError; 56, argument_list; 56, 57; 57, string:"``start`` and ``num`` must both be specified"; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:pieces; 61, list:[key]; 61, 62; 62, identifier:key; 63, if_statement; 63, 64; 63, 67; 64, comparison_operator:is; 64, 65; 64, 66; 65, identifier:by; 66, None; 67, block; 67, 68; 67, 75; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:pieces; 72, identifier:append; 73, argument_list; 73, 74; 74, string:'BY'; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:pieces; 79, identifier:append; 80, argument_list; 80, 81; 81, identifier:by; 82, if_statement; 82, 83; 82, 90; 83, boolean_operator:and; 83, 84; 83, 87; 84, comparison_operator:is; 84, 85; 84, 86; 85, identifier:start; 86, None; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:num; 89, None; 90, block; 90, 91; 90, 98; 90, 105; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:pieces; 95, identifier:append; 96, argument_list; 96, 97; 97, string:'LIMIT'; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:pieces; 102, identifier:append; 103, argument_list; 103, 104; 104, identifier:start; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:pieces; 109, identifier:append; 110, argument_list; 110, 111; 111, identifier:num; 112, if_statement; 112, 113; 112, 116; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:get; 115, None; 116, block; 116, 117; 117, if_statement; 117, 118; 117, 123; 117, 138; 118, call; 118, 119; 118, 120; 119, identifier:isinstance; 120, argument_list; 120, 121; 120, 122; 121, identifier:get; 122, identifier:str; 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:pieces; 128, identifier:append; 129, argument_list; 129, 130; 130, string:'GET'; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:pieces; 135, identifier:append; 136, argument_list; 136, 137; 137, identifier:get; 138, else_clause; 138, 139; 139, block; 139, 140; 140, for_statement; 140, 141; 140, 142; 140, 143; 141, identifier:g; 142, identifier:get; 143, block; 143, 144; 143, 151; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:pieces; 148, identifier:append; 149, argument_list; 149, 150; 150, string:'GET'; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:pieces; 155, identifier:append; 156, argument_list; 156, 157; 157, identifier:g; 158, if_statement; 158, 159; 158, 160; 159, identifier:desc; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:pieces; 165, identifier:append; 166, argument_list; 166, 167; 167, string:'DESC'; 168, if_statement; 168, 169; 168, 170; 169, identifier:alpha; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:pieces; 175, identifier:append; 176, argument_list; 176, 177; 177, string:'ALPHA'; 178, if_statement; 178, 179; 178, 182; 179, comparison_operator:is; 179, 180; 179, 181; 180, identifier:store; 181, None; 182, block; 182, 183; 182, 190; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:pieces; 187, identifier:append; 188, argument_list; 188, 189; 189, string:'STORE'; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:pieces; 194, identifier:append; 195, argument_list; 195, 196; 196, identifier:store; 197, if_statement; 197, 198; 197, 199; 198, identifier:groups; 199, block; 199, 200; 200, if_statement; 200, 201; 200, 216; 201, boolean_operator:or; 201, 202; 201, 210; 202, boolean_operator:or; 202, 203; 202, 205; 203, not_operator; 203, 204; 204, identifier:get; 205, call; 205, 206; 205, 207; 206, identifier:isinstance; 207, argument_list; 207, 208; 207, 209; 208, identifier:get; 209, identifier:str; 210, comparison_operator:<; 210, 211; 210, 215; 211, call; 211, 212; 211, 213; 212, identifier:len; 213, argument_list; 213, 214; 214, identifier:get; 215, integer:2; 216, block; 216, 217; 217, raise_statement; 217, 218; 218, call; 218, 219; 218, 220; 219, identifier:CommandError; 220, argument_list; 220, 221; 221, concatenated_string; 221, 222; 221, 223; 221, 224; 222, string:'when using "groups" the "get" argument '; 223, string:'must be specified and contain at least '; 224, string:'two keys'; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:options; 228, dictionary; 228, 229; 229, pair; 229, 230; 229, 231; 230, string:'groups'; 231, conditional_expression:if; 231, 232; 231, 236; 231, 237; 232, call; 232, 233; 232, 234; 233, identifier:len; 234, argument_list; 234, 235; 235, identifier:get; 236, identifier:groups; 237, None; 238, return_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:self; 242, identifier:execute_command; 243, argument_list; 243, 244; 243, 245; 243, 247; 244, string:'SORT'; 245, list_splat; 245, 246; 246, identifier:pieces; 247, dictionary_splat; 247, 248; 248, identifier:options | def sort(self, key, start=None, num=None, by=None, get=None,
desc=False, alpha=False, store=None, groups=False):
'''Sort and return the list, set or sorted set at ``key``.
``start`` and ``num`` allow for paging through the sorted data
``by`` allows using an external key to weight and sort the items.
Use an "*" to indicate where in the key the item value is located
``get`` allows for returning items from external keys rather than the
sorted data itself. Use an "*" to indicate where int he key
the item value is located
``desc`` allows for reversing the sort
``alpha`` allows for sorting lexicographically rather than numerically
``store`` allows for storing the result of the sort into
the key ``store``
``groups`` if set to True and if ``get`` contains at least two
elements, sort will return a list of tuples, each containing the
values fetched from the arguments to ``get``.
'''
if ((start is not None and num is None) or
(num is not None and start is None)):
raise CommandError("``start`` and ``num`` must both be specified")
pieces = [key]
if by is not None:
pieces.append('BY')
pieces.append(by)
if start is not None and num is not None:
pieces.append('LIMIT')
pieces.append(start)
pieces.append(num)
if get is not None:
if isinstance(get, str):
pieces.append('GET')
pieces.append(get)
else:
for g in get:
pieces.append('GET')
pieces.append(g)
if desc:
pieces.append('DESC')
if alpha:
pieces.append('ALPHA')
if store is not None:
pieces.append('STORE')
pieces.append(store)
if groups:
if not get or isinstance(get, str) or len(get) < 2:
raise CommandError('when using "groups" the "get" argument '
'must be specified and contain at least '
'two keys')
options = {'groups': len(get) if groups else None}
return self.execute_command('SORT', *pieces, **options) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_url_filemeta; 3, parameters; 3, 4; 4, identifier:url; 5, block; 5, 6; 5, 13; 5, 20; 5, 35; 5, 43; 5, 127; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:parsed_url; 9, call; 9, 10; 9, 11; 10, identifier:try_parse_url; 11, argument_list; 11, 12; 12, identifier:url; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:parsed_url; 16, None; 17, block; 17, 18; 18, return_statement; 18, 19; 19, None; 20, if_statement; 20, 21; 20, 29; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:parsed_url; 25, identifier:scheme; 26, identifier:startswith; 27, argument_list; 27, 28; 28, string:'ftp'; 29, block; 29, 30; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:get_ftp_filemeta; 33, argument_list; 33, 34; 34, identifier:parsed_url; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:url; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:parsed_url; 41, identifier:geturl; 42, argument_list; 43, try_statement; 43, 44; 43, 113; 43, 118; 44, block; 44, 45; 44, 63; 44, 76; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:r; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:requests; 51, identifier:get; 52, argument_list; 52, 53; 52, 54; 52, 57; 52, 60; 53, identifier:url; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:stream; 56, True; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:allow_redirects; 59, True; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:timeout; 62, integer:5; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:remote_size; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:r; 70, identifier:headers; 71, identifier:get; 72, argument_list; 72, 73; 72, 74; 73, string:'Content-Length'; 74, unary_operator:-; 74, 75; 75, integer:1; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:dict; 79, argument_list; 79, 80; 79, 83; 79, 88; 79, 93; 79, 98; 79, 101; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:url; 82, identifier:url; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:hostname; 85, attribute; 85, 86; 85, 87; 86, identifier:parsed_url; 87, identifier:hostname; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:path; 90, attribute; 90, 91; 90, 92; 91, identifier:parsed_url; 92, identifier:path; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:username; 95, attribute; 95, 96; 95, 97; 96, identifier:parsed_url; 97, identifier:username; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:remote_size; 100, identifier:remote_size; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:filename; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:os; 107, identifier:path; 108, identifier:basename; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 112; 111, identifier:parsed_url; 112, identifier:path; 113, except_clause; 113, 114; 113, 115; 114, identifier:ConnectionError; 115, block; 115, 116; 116, return_statement; 116, 117; 117, None; 118, except_clause; 118, 119; 118, 124; 119, tuple; 119, 120; 119, 121; 119, 122; 119, 123; 120, identifier:InvalidURL; 121, identifier:InvalidSchema; 122, identifier:InvalidHeader; 123, identifier:MissingSchema; 124, block; 124, 125; 125, return_statement; 125, 126; 126, None; 127, return_statement; 127, 128; 128, None | def get_url_filemeta(url):
parsed_url = try_parse_url(url)
if parsed_url is None:
return None
if parsed_url.scheme.startswith('ftp'):
return get_ftp_filemeta(parsed_url)
url = parsed_url.geturl()
try:
r = requests.get(url, stream=True, allow_redirects=True, timeout=5)
remote_size = r.headers.get('Content-Length', -1)
return dict(url=url, hostname=parsed_url.hostname, path=parsed_url.path,
username=parsed_url.username, remote_size=remote_size,
filename=os.path.basename(parsed_url.path))
except ConnectionError:
return None
except (InvalidURL, InvalidSchema, InvalidHeader, MissingSchema):
return None
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 59; 2, function_name:offline_plotly_scatter_bubble; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 32; 3, 35; 3, 38; 3, 50; 3, 56; 4, identifier:df; 5, default_parameter; 5, 6; 5, 7; 6, identifier:x; 7, string:'x'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:y; 10, string:'y'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:size_col; 13, string:'size'; 14, default_parameter; 14, 15; 14, 16; 15, identifier:text_col; 16, string:'text'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:category_col; 19, string:'category'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:possible_categories; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:filename; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:config; 28, dictionary; 28, 29; 29, pair; 29, 30; 29, 31; 30, string:'displaylogo'; 31, False; 32, default_parameter; 32, 33; 32, 34; 33, identifier:xscale; 34, None; 35, default_parameter; 35, 36; 35, 37; 36, identifier:yscale; 37, string:'log'; 38, default_parameter; 38, 39; 38, 40; 39, identifier:layout; 40, dictionary; 40, 41; 40, 44; 40, 47; 41, pair; 41, 42; 41, 43; 42, string:'hovermode'; 43, string:'closest'; 44, pair; 44, 45; 44, 46; 45, string:'showlegend'; 46, False; 47, pair; 47, 48; 47, 49; 48, string:'autosize'; 49, True; 50, default_parameter; 50, 51; 50, 52; 51, identifier:marker; 52, dictionary; 52, 53; 53, pair; 53, 54; 53, 55; 54, string:'sizemode'; 55, string:'area'; 56, default_parameter; 56, 57; 56, 58; 57, identifier:min_size; 58, integer:10; 59, block; 59, 60; 59, 62; 59, 69; 59, 98; 59, 105; 59, 114; 59, 140; 59, 148; 59, 160; 59, 171; 59, 214; 59, 224; 59, 271; 59, 354; 60, expression_statement; 60, 61; 61, identifier:r; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:config_default; 65, call; 65, 66; 65, 67; 66, identifier:dict; 67, argument_list; 67, 68; 68, identifier:DEFAULT_PLOTLY_CONFIG; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:marker_default; 72, dictionary; 72, 73; 72, 78; 72, 81; 73, pair; 73, 74; 73, 75; 74, string:'size'; 75, boolean_operator:or; 75, 76; 75, 77; 76, identifier:size_col; 77, identifier:min_size; 78, pair; 78, 79; 78, 80; 79, string:'sizemode'; 80, string:'area'; 81, pair; 81, 82; 81, 83; 82, string:'sizeref'; 83, conditional_expression:if; 83, 84; 83, 96; 83, 97; 84, call; 84, 85; 84, 86; 85, identifier:int; 86, argument_list; 86, 87; 87, binary_operator:*; 87, 88; 87, 95; 88, call; 88, 89; 88, 94; 89, attribute; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:df; 92, identifier:size_col; 93, identifier:min; 94, argument_list; 95, float:.8; 96, identifier:size_col; 97, identifier:min_size; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:marker_default; 102, identifier:update; 103, argument_list; 103, 104; 104, identifier:marker; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:size_col; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:marker_default; 111, identifier:pop; 112, argument_list; 112, 113; 113, string:'size'; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:layout_default; 117, dictionary; 117, 118; 117, 129; 118, pair; 118, 119; 118, 120; 119, string:'xaxis'; 120, call; 120, 121; 120, 122; 121, identifier:XAxis; 122, argument_list; 122, 123; 122, 126; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:title; 125, identifier:x; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:type; 128, identifier:xscale; 129, pair; 129, 130; 129, 131; 130, string:'yaxis'; 131, call; 131, 132; 131, 133; 132, identifier:YAxis; 133, argument_list; 133, 134; 133, 137; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:title; 136, identifier:y; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:type; 139, identifier:yscale; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:layout_default; 144, identifier:update; 145, argument_list; 145, 146; 146, dictionary_splat; 146, 147; 147, identifier:layout; 148, if_statement; 148, 149; 148, 152; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:config; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:config_default; 157, identifier:update; 158, argument_list; 158, 159; 159, identifier:config; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:df; 164, identifier:columns; 165, call; 165, 166; 165, 167; 166, identifier:clean_columns; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:df; 170, identifier:columns; 171, if_statement; 171, 172; 171, 179; 172, boolean_operator:and; 172, 173; 172, 176; 173, comparison_operator:is; 173, 174; 173, 175; 174, identifier:possible_categories; 175, None; 176, comparison_operator:is; 176, 177; 176, 178; 177, identifier:category_col; 178, None; 179, block; 179, 180; 179, 204; 180, if_statement; 180, 181; 180, 186; 180, 193; 181, comparison_operator:in; 181, 182; 181, 183; 182, identifier:category_col; 183, attribute; 183, 184; 183, 185; 184, identifier:df; 185, identifier:columns; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:category_labels; 190, subscript; 190, 191; 190, 192; 191, identifier:df; 192, identifier:category_col; 193, else_clause; 193, 194; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:category_labels; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:np; 201, identifier:array; 202, argument_list; 202, 203; 203, identifier:category_col; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:possible_categories; 207, call; 207, 208; 207, 209; 208, identifier:list; 209, argument_list; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:set; 212, argument_list; 212, 213; 213, identifier:category_labels; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:possible_categories; 217, conditional_expression:if; 217, 218; 217, 220; 217, 223; 218, list:[None]; 218, 219; 219, None; 220, comparison_operator:is; 220, 221; 220, 222; 221, identifier:possible_categories; 222, None; 223, identifier:possible_categories; 224, if_statement; 224, 225; 224, 230; 224, 248; 225, boolean_operator:and; 225, 226; 225, 227; 226, identifier:category_col; 227, comparison_operator:in; 227, 228; 227, 229; 228, identifier:category_col; 229, identifier:df; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:masks; 234, list_comprehension; 234, 235; 234, 245; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:np; 238, identifier:array; 239, argument_list; 239, 240; 240, comparison_operator:==; 240, 241; 240, 244; 241, subscript; 241, 242; 241, 243; 242, identifier:df; 243, identifier:category_col; 244, identifier:label; 245, for_in_clause; 245, 246; 245, 247; 246, identifier:label; 247, identifier:possible_categories; 248, else_clause; 248, 249; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:masks; 253, binary_operator:*; 253, 254; 253, 267; 254, list:[np.array([True] * len(df))]; 254, 255; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:np; 258, identifier:array; 259, argument_list; 259, 260; 260, binary_operator:*; 260, 261; 260, 263; 261, list:[True]; 261, 262; 262, True; 263, call; 263, 264; 263, 265; 264, identifier:len; 265, argument_list; 265, 266; 266, identifier:df; 267, call; 267, 268; 267, 269; 268, identifier:len; 269, argument_list; 269, 270; 270, identifier:possible_categories; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:data; 274, dictionary; 274, 275; 274, 347; 275, pair; 275, 276; 275, 277; 276, string:'data'; 277, list_comprehension; 277, 278; 277, 338; 278, call; 278, 279; 278, 280; 279, identifier:Scatter; 280, argument_list; 280, 281; 280, 290; 280, 299; 280, 308; 280, 329; 280, 332; 281, keyword_argument; 281, 282; 281, 283; 282, identifier:x; 283, attribute; 283, 284; 283, 289; 284, subscript; 284, 285; 284, 288; 285, subscript; 285, 286; 285, 287; 286, identifier:df; 287, identifier:x; 288, identifier:mask; 289, identifier:values; 290, keyword_argument; 290, 291; 290, 292; 291, identifier:y; 292, attribute; 292, 293; 292, 298; 293, subscript; 293, 294; 293, 297; 294, subscript; 294, 295; 294, 296; 295, identifier:df; 296, identifier:y; 297, identifier:mask; 298, identifier:values; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:text; 301, attribute; 301, 302; 301, 307; 302, subscript; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:df; 305, identifier:text_col; 306, identifier:mask; 307, identifier:values; 308, keyword_argument; 308, 309; 308, 310; 309, identifier:marker; 310, call; 310, 311; 310, 312; 311, identifier:Marker; 312, argument_list; 312, 313; 312, 327; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:size; 315, conditional_expression:if; 315, 316; 315, 321; 315, 326; 316, subscript; 316, 317; 316, 320; 317, subscript; 317, 318; 317, 319; 318, identifier:df; 319, identifier:size_col; 320, identifier:mask; 321, comparison_operator:in; 321, 322; 321, 323; 322, identifier:size_col; 323, attribute; 323, 324; 323, 325; 324, identifier:df; 325, identifier:columns; 326, identifier:size_col; 327, dictionary_splat; 327, 328; 328, identifier:marker_default; 329, keyword_argument; 329, 330; 329, 331; 330, identifier:mode; 331, string:'markers'; 332, keyword_argument; 332, 333; 332, 334; 333, identifier:name; 334, call; 334, 335; 334, 336; 335, identifier:str; 336, argument_list; 336, 337; 337, identifier:category_name; 338, for_in_clause; 338, 339; 338, 342; 339, tuple_pattern; 339, 340; 339, 341; 340, identifier:category_name; 341, identifier:mask; 342, call; 342, 343; 342, 344; 343, identifier:zip; 344, argument_list; 344, 345; 344, 346; 345, identifier:possible_categories; 346, identifier:masks; 347, pair; 347, 348; 347, 349; 348, string:'layout'; 349, call; 349, 350; 349, 351; 350, identifier:Layout; 351, argument_list; 351, 352; 352, dictionary_splat; 352, 353; 353, identifier:layout_default; 354, return_statement; 354, 355; 355, call; 355, 356; 355, 357; 356, identifier:offline_plotly_data; 357, argument_list; 357, 358; 357, 359; 357, 362; 358, identifier:data; 359, keyword_argument; 359, 360; 359, 361; 360, identifier:filename; 361, identifier:filename; 362, keyword_argument; 362, 363; 362, 364; 363, identifier:config; 364, identifier:config_default | def offline_plotly_scatter_bubble(df, x='x', y='y', size_col='size', text_col='text',
category_col='category', possible_categories=None,
filename=None,
config={'displaylogo': False},
xscale=None, yscale='log',
layout={'hovermode': 'closest', 'showlegend': False, 'autosize': True},
marker={'sizemode': 'area'},
min_size=10,
):
r
config_default = dict(DEFAULT_PLOTLY_CONFIG)
marker_default = {
'size': size_col or min_size,
'sizemode': 'area',
'sizeref': int(df[size_col].min() * .8) if size_col else min_size}
marker_default.update(marker)
size_col = marker_default.pop('size')
layout_default = {
'xaxis': XAxis(title=x, type=xscale),
'yaxis': YAxis(title=y, type=yscale),
}
layout_default.update(**layout)
if config is not None:
config_default.update(config)
df.columns = clean_columns(df.columns)
if possible_categories is None and category_col is not None:
if category_col in df.columns:
category_labels = df[category_col]
else:
category_labels = np.array(category_col)
possible_categories = list(set(category_labels))
possible_categories = [None] if possible_categories is None else possible_categories
if category_col and category_col in df:
masks = [np.array(df[category_col] == label) for label in possible_categories]
else:
masks = [np.array([True] * len(df))] * len(possible_categories)
data = {'data': [
Scatter(x=df[x][mask].values,
y=df[y][mask].values,
text=df[text_col][mask].values,
marker=Marker(size=df[size_col][mask] if size_col in df.columns else size_col,
**marker_default),
mode='markers',
name=str(category_name)) for (category_name, mask) in zip(possible_categories, masks)
],
'layout': Layout(**layout_default)
}
return offline_plotly_data(data, filename=filename, config=config_default) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_acronyms; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:manuscript; 6, call; 6, 7; 6, 12; 7, attribute; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:os; 10, identifier:path; 11, identifier:expanduser; 12, argument_list; 12, 13; 13, string:'~/code/nlpia/lane/manuscript'; 14, block; 14, 15; 14, 19; 14, 156; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:acronyms; 18, list:[]; 19, for_statement; 19, 20; 19, 23; 19, 27; 20, pattern_list; 20, 21; 20, 22; 21, identifier:f; 22, identifier:lines; 23, call; 23, 24; 23, 25; 24, identifier:get_lines; 25, argument_list; 25, 26; 26, identifier:manuscript; 27, block; 27, 28; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:line; 30, identifier:lines; 31, block; 31, 32; 31, 41; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:matches; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:CRE_ACRONYM; 38, identifier:finditer; 39, argument_list; 39, 40; 40, identifier:line; 41, if_statement; 41, 42; 41, 43; 42, identifier:matches; 43, block; 43, 44; 44, for_statement; 44, 45; 44, 46; 44, 47; 45, identifier:m; 46, identifier:matches; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 55; 48, 75; 48, 102; 48, 129; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:m; 52, identifier:group; 53, argument_list; 53, 54; 54, string:'a2'; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:acronyms; 60, identifier:append; 61, argument_list; 61, 62; 62, tuple; 62, 63; 62, 69; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:m; 66, identifier:group; 67, argument_list; 67, 68; 68, string:'a2'; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:m; 72, identifier:group; 73, argument_list; 73, 74; 74, string:'s2'; 75, elif_clause; 75, 76; 75, 82; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:m; 79, identifier:group; 80, argument_list; 80, 81; 81, string:'a3'; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:acronyms; 87, identifier:append; 88, argument_list; 88, 89; 89, tuple; 89, 90; 89, 96; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:m; 93, identifier:group; 94, argument_list; 94, 95; 95, string:'a3'; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:m; 99, identifier:group; 100, argument_list; 100, 101; 101, string:'s3'; 102, elif_clause; 102, 103; 102, 109; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:m; 106, identifier:group; 107, argument_list; 107, 108; 108, string:'a4'; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:acronyms; 114, identifier:append; 115, argument_list; 115, 116; 116, tuple; 116, 117; 116, 123; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:m; 120, identifier:group; 121, argument_list; 121, 122; 122, string:'a4'; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:m; 126, identifier:group; 127, argument_list; 127, 128; 128, string:'s4'; 129, elif_clause; 129, 130; 129, 136; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:m; 133, identifier:group; 134, argument_list; 134, 135; 135, string:'a5'; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:acronyms; 141, identifier:append; 142, argument_list; 142, 143; 143, tuple; 143, 144; 143, 150; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:m; 147, identifier:group; 148, argument_list; 148, 149; 149, string:'a5'; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:m; 153, identifier:group; 154, argument_list; 154, 155; 155, string:'s5'; 156, return_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:sorted; 159, argument_list; 159, 160; 160, call; 160, 161; 160, 167; 161, attribute; 161, 162; 161, 166; 162, call; 162, 163; 162, 164; 163, identifier:dict; 164, argument_list; 164, 165; 165, identifier:acronyms; 166, identifier:items; 167, argument_list | def get_acronyms(manuscript=os.path.expanduser('~/code/nlpia/lane/manuscript')):
acronyms = []
for f, lines in get_lines(manuscript):
for line in lines:
matches = CRE_ACRONYM.finditer(line)
if matches:
for m in matches:
if m.group('a2'):
acronyms.append((m.group('a2'), m.group('s2')))
elif m.group('a3'):
acronyms.append((m.group('a3'), m.group('s3')))
elif m.group('a4'):
acronyms.append((m.group('a4'), m.group('s4')))
elif m.group('a5'):
acronyms.append((m.group('a5'), m.group('s5')))
return sorted(dict(acronyms).items()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_find; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:rpcmethod; 6, block; 6, 7; 6, 23; 6, 29; 6, 51; 6, 63; 6, 67; 6, 104; 6, 112; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:log; 11, identifier:info; 12, argument_list; 12, 13; 12, 14; 13, string:"crawling network with nearest: %s"; 14, call; 14, 15; 14, 16; 15, identifier:str; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:tuple; 19, argument_list; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:nearest; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:count; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:alpha; 29, if_statement; 29, 30; 29, 41; 30, comparison_operator:==; 30, 31; 30, 38; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:nearest; 36, identifier:get_ids; 37, argument_list; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:last_ids_crawled; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:count; 45, call; 45, 46; 45, 47; 46, identifier:len; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:nearest; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:last_ids_crawled; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:nearest; 61, identifier:get_ids; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:dicts; 66, dictionary; 67, for_statement; 67, 68; 67, 69; 67, 80; 68, identifier:peer; 69, subscript; 69, 70; 69, 77; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:nearest; 75, identifier:get_uncontacted; 76, argument_list; 77, slice; 77, 78; 77, 79; 78, colon; 79, identifier:count; 80, block; 80, 81; 80, 95; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 85; 84, identifier:dicts; 85, attribute; 85, 86; 85, 87; 86, identifier:peer; 87, identifier:id; 88, call; 88, 89; 88, 90; 89, identifier:rpcmethod; 90, argument_list; 90, 91; 90, 92; 91, identifier:peer; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:node; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:nearest; 101, identifier:mark_contacted; 102, argument_list; 102, 103; 103, identifier:peer; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:found; 107, await; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:gather_dict; 110, argument_list; 110, 111; 111, identifier:dicts; 112, return_statement; 112, 113; 113, await; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:_nodes_found; 118, argument_list; 118, 119; 119, identifier:found | async def _find(self, rpcmethod):
log.info("crawling network with nearest: %s", str(tuple(self.nearest)))
count = self.alpha
if self.nearest.get_ids() == self.last_ids_crawled:
count = len(self.nearest)
self.last_ids_crawled = self.nearest.get_ids()
dicts = {}
for peer in self.nearest.get_uncontacted()[:count]:
dicts[peer.id] = rpcmethod(peer, self.node)
self.nearest.mark_contacted(peer)
found = await gather_dict(dicts)
return await self._nodes_found(found) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 1, 21; 2, function_name:match_key; 3, parameters; 3, 4; 4, identifier:self; 5, type; 5, 6; 6, generic_type; 6, 7; 6, 8; 7, identifier:Tuple; 8, type_parameter; 8, 9; 8, 11; 8, 13; 8, 15; 9, type; 9, 10; 10, identifier:bool; 11, type; 11, 12; 12, identifier:bool; 13, type; 13, 14; 14, identifier:int; 15, type; 15, 16; 16, generic_type; 16, 17; 16, 18; 17, identifier:List; 18, type_parameter; 18, 19; 19, type; 19, 20; 20, identifier:WeightedPart; 21, block; 21, 22; 21, 34; 21, 48; 22, if_statement; 22, 23; 22, 28; 23, comparison_operator:is; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:map; 27, None; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:RuntimeError; 32, argument_list; 32, 33; 33, string:f"{self!r} is not bound to a Map"; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:complex_rule; 37, call; 37, 38; 37, 39; 38, identifier:any; 39, generator_expression; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:weight; 42, identifier:converter; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:weight; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_weights; 48, return_statement; 48, 49; 49, tuple; 49, 50; 49, 57; 49, 58; 49, 65; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:bool; 53, argument_list; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:defaults; 57, identifier:complex_rule; 58, unary_operator:-; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:len; 61, argument_list; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_weights; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_weights | def match_key(self) -> Tuple[bool, bool, int, List[WeightedPart]]:
if self.map is None:
raise RuntimeError(f"{self!r} is not bound to a Map")
complex_rule = any(weight.converter for weight in self._weights)
return (not bool(self.defaults), complex_rule, -len(self._weights), self._weights) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 1, 13; 2, function_name:build_key; 3, parameters; 3, 4; 4, identifier:self; 5, type; 5, 6; 6, generic_type; 6, 7; 6, 8; 7, identifier:Tuple; 8, type_parameter; 8, 9; 8, 11; 9, type; 9, 10; 10, identifier:bool; 11, type; 11, 12; 12, identifier:int; 13, block; 13, 14; 13, 26; 14, if_statement; 14, 15; 14, 20; 15, comparison_operator:is; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:map; 19, None; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:RuntimeError; 24, argument_list; 24, 25; 25, string:f"{self!r} is not bound to a Map"; 26, return_statement; 26, 27; 27, tuple; 27, 28; 27, 35; 28, not_operator; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:bool; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:defaults; 35, unary_operator:-; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:sum; 38, generator_expression; 38, 39; 38, 40; 38, 45; 39, integer:1; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:weight; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_weights; 45, if_clause; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:weight; 48, identifier:converter | def build_key(self) -> Tuple[bool, int]:
if self.map is None:
raise RuntimeError(f"{self!r} is not bound to a Map")
return (not bool(self.defaults), -sum(1 for weight in self._weights if weight.converter)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:load_ui_file; 3, parameters; 3, 4; 4, identifier:name; 5, block; 5, 6; 5, 14; 5, 31; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ui; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:gtk; 12, identifier:Builder; 13, argument_list; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:ui; 18, identifier:add_from_file; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:os; 24, identifier:path; 25, identifier:join; 26, argument_list; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:runtime; 29, identifier:data_dir; 30, identifier:name; 31, return_statement; 31, 32; 32, identifier:ui | def load_ui_file(name):
ui = gtk.Builder()
ui.add_from_file(os.path.join(runtime.data_dir, name))
return ui |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:__remove_category; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:id; 6, block; 6, 7; 6, 26; 6, 30; 6, 39; 6, 48; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:affected_query; 10, assignment; 10, 11; 10, 12; 11, identifier:affected_ids; 12, list_comprehension; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:res; 15, integer:0; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:res; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:fetchall; 22, argument_list; 22, 23; 22, 24; 23, identifier:affected_query; 24, tuple; 24, 25; 25, identifier:id; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:update; 29, string:"update activities set category_id = -1 where category_id = ?"; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:execute; 35, argument_list; 35, 36; 35, 37; 36, identifier:update; 37, tuple; 37, 38; 38, identifier:id; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:execute; 44, argument_list; 44, 45; 44, 46; 45, string:"delete from categories where id = ?"; 46, tuple; 46, 47; 47, identifier:id; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:__remove_index; 53, argument_list; 53, 54; 54, identifier:affected_ids | def __remove_category(self, id):
affected_query =
affected_ids = [res[0] for res in self.fetchall(affected_query, (id,))]
update = "update activities set category_id = -1 where category_id = ?"
self.execute(update, (id, ))
self.execute("delete from categories where id = ?", (id, ))
self.__remove_index(affected_ids) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 13; 8, subscript; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:__dict__; 12, string:'_z_ordered_sprites'; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:sprites; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:sprite; 24, attribute; 24, 25; 24, 26; 25, identifier:sprite; 26, identifier:z_order | def _sort(self):
self.__dict__['_z_ordered_sprites'] = sorted(self.sprites, key=lambda sprite:sprite.z_order) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_mouse_cursor; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, if_statement; 6, 7; 6, 12; 6, 17; 6, 32; 7, comparison_operator:is; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:mouse_cursor; 11, None; 12, block; 12, 13; 13, return_statement; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:mouse_cursor; 17, elif_clause; 17, 18; 17, 25; 18, boolean_operator:and; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:interactive; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:draggable; 25, block; 25, 26; 26, return_statement; 26, 27; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:gdk; 30, identifier:CursorType; 31, identifier:FLEUR; 32, elif_clause; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:interactive; 36, block; 36, 37; 37, return_statement; 37, 38; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:gdk; 41, identifier:CursorType; 42, identifier:HAND2 | def _get_mouse_cursor(self):
if self.mouse_cursor is not None:
return self.mouse_cursor
elif self.interactive and self.draggable:
return gdk.CursorType.FLEUR
elif self.interactive:
return gdk.CursorType.HAND2 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:entries; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 13; 5, 31; 5, 48; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:log; 11, argument_list; 11, 12; 12, string:u"Getting entries"; 13, if_statement; 13, 14; 13, 20; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:exists; 19, argument_list; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:log_exc; 26, argument_list; 26, 27; 26, 28; 26, 29; 26, 30; 27, string:u"This container does not exist. Wrong path?"; 28, None; 29, True; 30, identifier:TypeError; 31, if_statement; 31, 32; 31, 37; 32, comparison_operator:is; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:actual_container; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:log_exc; 43, argument_list; 43, 44; 43, 45; 43, 46; 43, 47; 44, string:u"The actual container object has not been set"; 45, None; 46, True; 47, identifier:TypeError; 48, return_statement; 48, 49; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:actual_container; 53, identifier:entries | def entries(self):
self.log(u"Getting entries")
if not self.exists():
self.log_exc(u"This container does not exist. Wrong path?", None, True, TypeError)
if self.actual_container is None:
self.log_exc(u"The actual container object has not been set", None, True, TypeError)
return self.actual_container.entries |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 19; 5, 26; 5, 37; 5, 44; 5, 51; 5, 132; 5, 139; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:is_guaranteed_sorted; 10, block; 10, 11; 10, 18; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:log; 16, argument_list; 16, 17; 17, string:u"Already sorted, returning"; 18, return_statement; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:log; 24, argument_list; 24, 25; 25, string:u"Sorting..."; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:__fragments; 31, call; 31, 32; 31, 33; 32, identifier:sorted; 33, argument_list; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:__fragments; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:log; 42, argument_list; 42, 43; 43, string:u"Sorting... done"; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:log; 49, argument_list; 49, 50; 50, string:u"Checking relative positions..."; 51, for_statement; 51, 52; 51, 53; 51, 62; 52, identifier:i; 53, call; 53, 54; 53, 55; 54, identifier:range; 55, argument_list; 55, 56; 56, binary_operator:-; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:self; 61, integer:1; 62, block; 62, 63; 62, 71; 62, 81; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:current_interval; 66, attribute; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:self; 69, identifier:i; 70, identifier:interval; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:next_interval; 74, attribute; 74, 75; 74, 80; 75, subscript; 75, 76; 75, 77; 76, identifier:self; 77, binary_operator:+; 77, 78; 77, 79; 78, identifier:i; 79, integer:1; 80, identifier:interval; 81, if_statement; 81, 82; 81, 92; 82, comparison_operator:not; 82, 83; 82, 89; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:current_interval; 86, identifier:relative_position_of; 87, argument_list; 87, 88; 88, identifier:next_interval; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:ALLOWED_POSITIONS; 92, block; 92, 93; 92, 100; 92, 110; 92, 122; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:log; 98, argument_list; 98, 99; 99, string:u"Found overlapping fragments:"; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:log; 105, argument_list; 105, 106; 106, list:[u" Index %d => %s", i, current_interval]; 106, 107; 106, 108; 106, 109; 107, string:u" Index %d => %s"; 108, identifier:i; 109, identifier:current_interval; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:log; 115, argument_list; 115, 116; 116, list:[u" Index %d => %s", i + 1, next_interval]; 116, 117; 116, 118; 116, 121; 117, string:u" Index %d => %s"; 118, binary_operator:+; 118, 119; 118, 120; 119, identifier:i; 120, integer:1; 121, identifier:next_interval; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:log_exc; 127, argument_list; 127, 128; 127, 129; 127, 130; 127, 131; 128, string:u"The list contains two fragments overlapping in a forbidden way"; 129, None; 130, True; 131, identifier:ValueError; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:log; 137, argument_list; 137, 138; 138, string:u"Checking relative positions... done"; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:__sorted; 144, True | def sort(self):
if self.is_guaranteed_sorted:
self.log(u"Already sorted, returning")
return
self.log(u"Sorting...")
self.__fragments = sorted(self.__fragments)
self.log(u"Sorting... done")
self.log(u"Checking relative positions...")
for i in range(len(self) - 1):
current_interval = self[i].interval
next_interval = self[i + 1].interval
if current_interval.relative_position_of(next_interval) not in self.ALLOWED_POSITIONS:
self.log(u"Found overlapping fragments:")
self.log([u" Index %d => %s", i, current_interval])
self.log([u" Index %d => %s", i + 1, next_interval])
self.log_exc(u"The list contains two fragments overlapping in a forbidden way", None, True, ValueError)
self.log(u"Checking relative positions... done")
self.__sorted = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 168; 5, 182; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:sorted; 10, block; 10, 11; 11, return_statement; 12, function_definition; 12, 13; 12, 14; 12, 16; 13, function_name:key; 14, parameters; 14, 15; 15, identifier:variant; 16, block; 16, 17; 16, 21; 16, 27; 16, 85; 16, 89; 16, 120; 16, 166; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:requested_key; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:names; 24, call; 24, 25; 24, 26; 25, identifier:set; 26, argument_list; 27, for_statement; 27, 28; 27, 31; 27, 39; 28, pattern_list; 28, 29; 28, 30; 29, identifier:i; 30, identifier:request; 31, call; 31, 32; 31, 33; 32, identifier:enumerate; 33, argument_list; 33, 34; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:solver; 38, identifier:request_list; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 45; 41, not_operator; 41, 42; 42, attribute; 42, 43; 42, 44; 43, identifier:request; 44, identifier:conflict; 45, block; 45, 46; 45, 59; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:req; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:variant; 53, identifier:requires_list; 54, identifier:get; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:request; 58, identifier:name; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:req; 62, None; 63, block; 63, 64; 63, 76; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:requested_key; 68, identifier:append; 69, argument_list; 69, 70; 70, tuple; 70, 71; 70, 73; 71, unary_operator:-; 71, 72; 72, identifier:i; 73, attribute; 73, 74; 73, 75; 74, identifier:req; 75, identifier:range; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:names; 80, identifier:add; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:req; 84, identifier:name; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:additional_key; 88, list:[]; 89, for_statement; 89, 90; 89, 91; 89, 94; 90, identifier:request; 91, attribute; 91, 92; 91, 93; 92, identifier:variant; 93, identifier:requires_list; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 106; 96, boolean_operator:and; 96, 97; 96, 101; 97, not_operator; 97, 98; 98, attribute; 98, 99; 98, 100; 99, identifier:request; 100, identifier:conflict; 101, comparison_operator:not; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:request; 104, identifier:name; 105, identifier:names; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:additional_key; 111, identifier:append; 112, argument_list; 112, 113; 113, tuple; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:request; 116, identifier:range; 117, attribute; 117, 118; 117, 119; 118, identifier:request; 119, identifier:name; 120, if_statement; 120, 121; 120, 131; 120, 146; 121, parenthesized_expression; 121, 122; 122, comparison_operator:==; 122, 123; 122, 128; 123, subscript; 123, 124; 123, 125; 124, identifier:VariantSelectMode; 125, attribute; 125, 126; 125, 127; 126, identifier:config; 127, identifier:variant_select_mode; 128, attribute; 128, 129; 128, 130; 129, identifier:VariantSelectMode; 130, identifier:version_priority; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:k; 135, tuple; 135, 136; 135, 137; 135, 142; 135, 143; 136, identifier:requested_key; 137, unary_operator:-; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:len; 140, argument_list; 140, 141; 141, identifier:additional_key; 142, identifier:additional_key; 143, attribute; 143, 144; 143, 145; 144, identifier:variant; 145, identifier:index; 146, else_clause; 146, 147; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:k; 151, tuple; 151, 152; 151, 156; 151, 157; 151, 162; 151, 163; 152, call; 152, 153; 152, 154; 153, identifier:len; 154, argument_list; 154, 155; 155, identifier:requested_key; 156, identifier:requested_key; 157, unary_operator:-; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:len; 160, argument_list; 160, 161; 161, identifier:additional_key; 162, identifier:additional_key; 163, attribute; 163, 164; 163, 165; 164, identifier:variant; 165, identifier:index; 166, return_statement; 166, 167; 167, identifier:k; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:variants; 174, identifier:sort; 175, argument_list; 175, 176; 175, 179; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:key; 178, identifier:key; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:reverse; 181, True; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:sorted; 187, True | def sort(self):
if self.sorted:
return
def key(variant):
requested_key = []
names = set()
for i, request in enumerate(self.solver.request_list):
if not request.conflict:
req = variant.requires_list.get(request.name)
if req is not None:
requested_key.append((-i, req.range))
names.add(req.name)
additional_key = []
for request in variant.requires_list:
if not request.conflict and request.name not in names:
additional_key.append((request.range, request.name))
if (VariantSelectMode[config.variant_select_mode] ==
VariantSelectMode.version_priority):
k = (requested_key,
-len(additional_key),
additional_key,
variant.index)
else:
k = (len(requested_key),
requested_key,
-len(additional_key),
additional_key,
variant.index)
return k
self.variants.sort(key=key, reverse=True)
self.sorted = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_versions; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 79; 5, 101; 5, 107; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:sorted; 10, block; 10, 11; 11, return_statement; 12, for_statement; 12, 13; 12, 14; 12, 22; 13, identifier:orderer; 14, parenthesized_expression; 14, 15; 15, boolean_operator:or; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:solver; 20, identifier:package_orderers; 21, list:[]; 22, block; 22, 23; 22, 42; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:entries; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:orderer; 29, identifier:reorder; 30, argument_list; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:entries; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:key; 36, lambda; 36, 37; 36, 39; 37, lambda_parameters; 37, 38; 38, identifier:x; 39, attribute; 39, 40; 39, 41; 40, identifier:x; 41, identifier:package; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:entries; 45, None; 46, block; 46, 47; 46, 53; 46, 59; 46, 78; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:entries; 52, identifier:entries; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:sorted; 58, True; 59, if_statement; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:pr; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:pr; 69, argument_list; 69, 70; 69, 71; 69, 74; 70, string:"sorted: %s packages: %s"; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:package_name; 74, call; 74, 75; 74, 76; 75, identifier:repr; 76, argument_list; 76, 77; 77, identifier:orderer; 78, return_statement; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:entries; 84, call; 84, 85; 84, 86; 85, identifier:sorted; 86, argument_list; 86, 87; 86, 90; 86, 98; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:entries; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:key; 92, lambda; 92, 93; 92, 95; 93, lambda_parameters; 93, 94; 94, identifier:x; 95, attribute; 95, 96; 95, 97; 96, identifier:x; 97, identifier:version; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:reverse; 100, True; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:sorted; 106, True; 107, if_statement; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:pr; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:pr; 117, argument_list; 117, 118; 117, 119; 118, string:"sorted: %s packages: version descending"; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:package_name | def sort_versions(self):
if self.sorted:
return
for orderer in (self.solver.package_orderers or []):
entries = orderer.reorder(self.entries, key=lambda x: x.package)
if entries is not None:
self.entries = entries
self.sorted = True
if self.pr:
self.pr("sorted: %s packages: %s", self.package_name, repr(orderer))
return
self.entries = sorted(self.entries, key=lambda x: x.version, reverse=True)
self.sorted = True
if self.pr:
self.pr("sorted: %s packages: version descending", self.package_name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_reset; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:load; 6, block; 6, 7; 6, 18; 6, 24; 6, 30; 6, 38; 6, 46; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:values; 10, call; 10, 11; 10, 12; 11, identifier:reduce; 12, argument_list; 12, 13; 12, 14; 12, 17; 13, identifier:iadd; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_lists; 17, list:[]; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_clear; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_load; 29, identifier:load; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_half; 35, binary_operator:>>; 35, 36; 35, 37; 36, identifier:load; 37, integer:1; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_dual; 43, binary_operator:<<; 43, 44; 43, 45; 44, identifier:load; 45, integer:1; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_update; 51, argument_list; 51, 52; 52, identifier:values | def _reset(self, load):
values = reduce(iadd, self._lists, [])
self._clear()
self._load = load
self._half = load >> 1
self._dual = load << 1
self._update(values) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_build_index; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 19; 5, 43; 5, 50; 5, 57; 5, 72; 5, 90; 5, 116; 5, 137; 5, 153; 5, 159; 5, 209; 5, 221; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:row0; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:map; 14, argument_list; 14, 15; 14, 16; 15, identifier:len; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_lists; 19, if_statement; 19, 20; 19, 26; 20, comparison_operator:==; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:row0; 25, integer:1; 26, block; 26, 27; 26, 36; 26, 42; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 35; 29, subscript; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_index; 33, slice; 33, 34; 34, colon; 35, identifier:row0; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_offset; 41, integer:0; 42, return_statement; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:head; 46, call; 46, 47; 46, 48; 47, identifier:iter; 48, argument_list; 48, 49; 49, identifier:row0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:tail; 53, call; 53, 54; 53, 55; 54, identifier:iter; 55, argument_list; 55, 56; 56, identifier:head; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:row1; 60, call; 60, 61; 60, 62; 61, identifier:list; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:starmap; 65, argument_list; 65, 66; 65, 67; 66, identifier:add; 67, call; 67, 68; 67, 69; 68, identifier:zip; 69, argument_list; 69, 70; 69, 71; 70, identifier:head; 71, identifier:tail; 72, if_statement; 72, 73; 72, 79; 73, binary_operator:&; 73, 74; 73, 78; 74, call; 74, 75; 74, 76; 75, identifier:len; 76, argument_list; 76, 77; 77, identifier:row0; 78, integer:1; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:row1; 84, identifier:append; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 88; 87, identifier:row0; 88, unary_operator:-; 88, 89; 89, integer:1; 90, if_statement; 90, 91; 90, 97; 91, comparison_operator:==; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, identifier:row1; 96, integer:1; 97, block; 97, 98; 97, 109; 97, 115; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 106; 100, subscript; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_index; 104, slice; 104, 105; 105, colon; 106, binary_operator:+; 106, 107; 106, 108; 107, identifier:row1; 108, identifier:row0; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:_offset; 114, integer:1; 115, return_statement; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:size; 119, binary_operator:**; 119, 120; 119, 121; 120, integer:2; 121, parenthesized_expression; 121, 122; 122, binary_operator:+; 122, 123; 122, 136; 123, call; 123, 124; 123, 125; 124, identifier:int; 125, argument_list; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:log_e; 128, argument_list; 128, 129; 128, 135; 129, binary_operator:-; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:len; 132, argument_list; 132, 133; 133, identifier:row1; 134, integer:1; 135, integer:2; 136, integer:1; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:row1; 141, identifier:extend; 142, argument_list; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:repeat; 145, argument_list; 145, 146; 145, 147; 146, integer:0; 147, binary_operator:-; 147, 148; 147, 149; 148, identifier:size; 149, call; 149, 150; 149, 151; 150, identifier:len; 151, argument_list; 151, 152; 152, identifier:row1; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:tree; 156, list:[row0, row1]; 156, 157; 156, 158; 157, identifier:row0; 158, identifier:row1; 159, while_statement; 159, 160; 159, 169; 160, comparison_operator:>; 160, 161; 160, 168; 161, call; 161, 162; 161, 163; 162, identifier:len; 163, argument_list; 163, 164; 164, subscript; 164, 165; 164, 166; 165, identifier:tree; 166, unary_operator:-; 166, 167; 167, integer:1; 168, integer:1; 169, block; 169, 170; 169, 180; 169, 187; 169, 202; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:head; 173, call; 173, 174; 173, 175; 174, identifier:iter; 175, argument_list; 175, 176; 176, subscript; 176, 177; 176, 178; 177, identifier:tree; 178, unary_operator:-; 178, 179; 179, integer:1; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:tail; 183, call; 183, 184; 183, 185; 184, identifier:iter; 185, argument_list; 185, 186; 186, identifier:head; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:row; 190, call; 190, 191; 190, 192; 191, identifier:list; 192, argument_list; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:starmap; 195, argument_list; 195, 196; 195, 197; 196, identifier:add; 197, call; 197, 198; 197, 199; 198, identifier:zip; 199, argument_list; 199, 200; 199, 201; 200, identifier:head; 201, identifier:tail; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:tree; 206, identifier:append; 207, argument_list; 207, 208; 208, identifier:row; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:reduce; 212, argument_list; 212, 213; 212, 214; 212, 218; 213, identifier:iadd; 214, call; 214, 215; 214, 216; 215, identifier:reversed; 216, argument_list; 216, 217; 217, identifier:tree; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:_index; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:_offset; 226, binary_operator:-; 226, 227; 226, 230; 227, binary_operator:*; 227, 228; 227, 229; 228, identifier:size; 229, integer:2; 230, integer:1 | def _build_index(self):
row0 = list(map(len, self._lists))
if len(row0) == 1:
self._index[:] = row0
self._offset = 0
return
head = iter(row0)
tail = iter(head)
row1 = list(starmap(add, zip(head, tail)))
if len(row0) & 1:
row1.append(row0[-1])
if len(row1) == 1:
self._index[:] = row1 + row0
self._offset = 1
return
size = 2 ** (int(log_e(len(row1) - 1, 2)) + 1)
row1.extend(repeat(0, size - len(row1)))
tree = [row0, row1]
while len(tree[-1]) > 1:
head = iter(tree[-1])
tail = iter(head)
row = list(starmap(add, zip(head, tail)))
tree.append(row)
reduce(iadd, reversed(tree), self._index)
self._offset = size * 2 - 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_fromset; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:values; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 19; 9, 25; 9, 34; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sorted_set; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:object; 16, identifier:__new__; 17, argument_list; 17, 18; 18, identifier:cls; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:sorted_set; 23, identifier:_set; 24, identifier:values; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:sorted_set; 29, identifier:__init__; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:key; 33, identifier:key; 34, return_statement; 34, 35; 35, identifier:sorted_set | def _fromset(cls, values, key=None):
sorted_set = object.__new__(cls)
sorted_set._set = values
sorted_set.__init__(key=key)
return sorted_set |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_argsort_and_resolve_ties; 3, parameters; 3, 4; 3, 5; 4, identifier:time; 5, identifier:random_state; 6, block; 6, 7; 6, 14; 6, 26; 6, 30; 6, 87; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:n_samples; 10, call; 10, 11; 10, 12; 11, identifier:len; 12, argument_list; 12, 13; 13, identifier:time; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:order; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:numpy; 20, identifier:argsort; 21, argument_list; 21, 22; 21, 23; 22, identifier:time; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:kind; 25, string:"mergesort"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:i; 29, integer:0; 30, while_statement; 30, 31; 30, 36; 31, comparison_operator:<; 31, 32; 31, 33; 32, identifier:i; 33, binary_operator:-; 33, 34; 33, 35; 34, identifier:n_samples; 35, integer:1; 36, block; 36, 37; 36, 43; 36, 64; 36, 83; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:inext; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:i; 42, integer:1; 43, while_statement; 43, 44; 43, 59; 44, boolean_operator:and; 44, 45; 44, 48; 45, comparison_operator:<; 45, 46; 45, 47; 46, identifier:inext; 47, identifier:n_samples; 48, comparison_operator:==; 48, 49; 48, 54; 49, subscript; 49, 50; 49, 51; 50, identifier:time; 51, subscript; 51, 52; 51, 53; 52, identifier:order; 53, identifier:i; 54, subscript; 54, 55; 54, 56; 55, identifier:time; 56, subscript; 56, 57; 56, 58; 57, identifier:order; 58, identifier:inext; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, augmented_assignment:+=; 61, 62; 61, 63; 62, identifier:inext; 63, integer:1; 64, if_statement; 64, 65; 64, 70; 65, comparison_operator:!=; 65, 66; 65, 69; 66, binary_operator:+; 66, 67; 66, 68; 67, identifier:i; 68, integer:1; 69, identifier:inext; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:random_state; 75, identifier:shuffle; 76, argument_list; 76, 77; 77, subscript; 77, 78; 77, 79; 78, identifier:order; 79, slice; 79, 80; 79, 81; 79, 82; 80, identifier:i; 81, colon; 82, identifier:inext; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:i; 86, identifier:inext; 87, return_statement; 87, 88; 88, identifier:order | def _argsort_and_resolve_ties(time, random_state):
n_samples = len(time)
order = numpy.argsort(time, kind="mergesort")
i = 0
while i < n_samples - 1:
inext = i + 1
while inext < n_samples and time[order[i]] == time[order[inext]]:
inext += 1
if i + 1 != inext:
random_state.shuffle(order[i:inext])
i = inext
return order |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:toposort_classes; 3, parameters; 3, 4; 4, identifier:classes; 5, block; 5, 6; 5, 131; 5, 143; 5, 149; 5, 153; 5, 176; 6, function_definition; 6, 7; 6, 8; 6, 13; 7, function_name:get_class_topolist; 8, parameters; 8, 9; 8, 10; 8, 11; 8, 12; 9, identifier:class_name; 10, identifier:name_to_class; 11, identifier:processed_classes; 12, identifier:current_trace; 13, block; 13, 14; 13, 21; 13, 36; 13, 42; 13, 49; 13, 60; 13, 78; 13, 82; 13, 89; 13, 106; 13, 113; 13, 122; 13, 129; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:in; 15, 16; 15, 17; 16, identifier:class_name; 17, identifier:processed_classes; 18, block; 18, 19; 19, return_statement; 19, 20; 20, list:[]; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:in; 22, 23; 22, 24; 23, identifier:class_name; 24, identifier:current_trace; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:AssertionError; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, string:'Encountered self-reference in dependency chain of {}'; 33, identifier:format; 34, argument_list; 34, 35; 35, identifier:class_name; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:cls; 39, subscript; 39, 40; 39, 41; 40, identifier:name_to_class; 41, identifier:class_name; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:dependencies; 45, call; 45, 46; 45, 47; 46, identifier:_list_superclasses; 47, argument_list; 47, 48; 48, identifier:cls; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:properties; 52, conditional_expression:if; 52, 53; 52, 56; 52, 59; 53, subscript; 53, 54; 53, 55; 54, identifier:cls; 55, string:'properties'; 56, comparison_operator:in; 56, 57; 56, 58; 57, string:'properties'; 58, identifier:cls; 59, list:[]; 60, for_statement; 60, 61; 60, 62; 60, 63; 61, identifier:prop; 62, identifier:properties; 63, block; 63, 64; 64, if_statement; 64, 65; 64, 68; 65, comparison_operator:in; 65, 66; 65, 67; 66, string:'linkedClass'; 67, identifier:prop; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:dependencies; 73, identifier:append; 74, argument_list; 74, 75; 75, subscript; 75, 76; 75, 77; 76, identifier:prop; 77, string:'linkedClass'; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:class_list; 81, list:[]; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:current_trace; 86, identifier:add; 87, argument_list; 87, 88; 88, identifier:class_name; 89, for_statement; 89, 90; 89, 91; 89, 92; 90, identifier:dependency; 91, identifier:dependencies; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:class_list; 97, identifier:extend; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:get_class_topolist; 101, argument_list; 101, 102; 101, 103; 101, 104; 101, 105; 102, identifier:dependency; 103, identifier:name_to_class; 104, identifier:processed_classes; 105, identifier:current_trace; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:current_trace; 110, identifier:remove; 111, argument_list; 111, 112; 112, identifier:class_name; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:class_list; 117, identifier:append; 118, argument_list; 118, 119; 119, subscript; 119, 120; 119, 121; 120, identifier:name_to_class; 121, identifier:class_name; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:processed_classes; 126, identifier:add; 127, argument_list; 127, 128; 128, identifier:class_name; 129, return_statement; 129, 130; 130, identifier:class_list; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:class_map; 134, dictionary_comprehension; 134, 135; 134, 140; 135, pair; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:c; 138, string:'name'; 139, identifier:c; 140, for_in_clause; 140, 141; 140, 142; 141, identifier:c; 142, identifier:classes; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:seen_classes; 146, call; 146, 147; 146, 148; 147, identifier:set; 148, argument_list; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:toposorted; 152, list:[]; 153, for_statement; 153, 154; 153, 155; 153, 160; 154, identifier:name; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:class_map; 158, identifier:keys; 159, argument_list; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:toposorted; 165, identifier:extend; 166, argument_list; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:get_class_topolist; 169, argument_list; 169, 170; 169, 171; 169, 172; 169, 173; 170, identifier:name; 171, identifier:class_map; 172, identifier:seen_classes; 173, call; 173, 174; 173, 175; 174, identifier:set; 175, argument_list; 176, return_statement; 176, 177; 177, identifier:toposorted | def toposort_classes(classes):
def get_class_topolist(class_name, name_to_class, processed_classes, current_trace):
if class_name in processed_classes:
return []
if class_name in current_trace:
raise AssertionError(
'Encountered self-reference in dependency chain of {}'.format(class_name))
cls = name_to_class[class_name]
dependencies = _list_superclasses(cls)
properties = cls['properties'] if 'properties' in cls else []
for prop in properties:
if 'linkedClass' in prop:
dependencies.append(prop['linkedClass'])
class_list = []
current_trace.add(class_name)
for dependency in dependencies:
class_list.extend(get_class_topolist(
dependency, name_to_class, processed_classes, current_trace))
current_trace.remove(class_name)
class_list.append(name_to_class[class_name])
processed_classes.add(class_name)
return class_list
class_map = {c['name']: c for c in classes}
seen_classes = set()
toposorted = []
for name in class_map.keys():
toposorted.extend(get_class_topolist(name, class_map, seen_classes, set()))
return toposorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_init_steps; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 20; 5, 27; 5, 31; 5, 58; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:_check_old_yaml_format; 11, argument_list; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:config_steps; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:flow_config; 19, identifier:steps; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_check_infinite_flows; 25, argument_list; 25, 26; 26, identifier:config_steps; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:steps; 30, list:[]; 31, for_statement; 31, 32; 31, 35; 31, 40; 32, pattern_list; 32, 33; 32, 34; 33, identifier:number; 34, identifier:step_config; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:config_steps; 38, identifier:items; 39, argument_list; 40, block; 40, 41; 40, 51; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:specs; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_visit_step; 48, argument_list; 48, 49; 48, 50; 49, identifier:number; 50, identifier:step_config; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:steps; 55, identifier:extend; 56, argument_list; 56, 57; 57, identifier:specs; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:sorted; 61, argument_list; 61, 62; 61, 63; 62, identifier:steps; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:key; 65, call; 65, 66; 65, 67; 66, identifier:attrgetter; 67, argument_list; 67, 68; 68, string:"step_num" | def _init_steps(self,):
self._check_old_yaml_format()
config_steps = self.flow_config.steps
self._check_infinite_flows(config_steps)
steps = []
for number, step_config in config_steps.items():
specs = self._visit_step(number, step_config)
steps.extend(specs)
return sorted(steps, key=attrgetter("step_num")) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:ranker; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:X; 6, identifier:meta; 7, block; 7, 8; 7, 23; 7, 37; 7, 45; 7, 55; 7, 65; 7, 71; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:total_score; 11, call; 11, 12; 11, 22; 12, attribute; 12, 13; 12, 21; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:X; 16, identifier:sum; 17, argument_list; 17, 18; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:axis; 20, integer:1; 21, identifier:transpose; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:total_score; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:squeeze; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:asarray; 35, argument_list; 35, 36; 36, identifier:total_score; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:ranks; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:total_score; 43, identifier:argsort; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:ranks; 48, subscript; 48, 49; 48, 50; 49, identifier:ranks; 50, slice; 50, 51; 50, 52; 50, 53; 51, colon; 52, colon; 53, unary_operator:-; 53, 54; 54, integer:1; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:sorted_meta; 58, list_comprehension; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:meta; 61, identifier:r; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:r; 64, identifier:ranks; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:sorted_X; 68, subscript; 68, 69; 68, 70; 69, identifier:X; 70, identifier:ranks; 71, return_statement; 71, 72; 72, tuple; 72, 73; 72, 74; 73, identifier:sorted_X; 74, identifier:sorted_meta | def ranker(self, X, meta):
total_score = X.sum(axis=1).transpose()
total_score = np.squeeze(np.asarray(total_score))
ranks = total_score.argsort()
ranks = ranks[::-1]
sorted_meta = [meta[r] for r in ranks]
sorted_X = X[ranks]
return (sorted_X, sorted_meta) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:create_pickled_data; 3, parameters; 3, 4; 3, 5; 4, identifier:idevice; 5, identifier:filename; 6, block; 6, 7; 6, 11; 6, 27; 6, 31; 6, 39; 6, 52; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:data; 10, dictionary; 11, for_statement; 11, 12; 11, 13; 11, 16; 12, identifier:x; 13, attribute; 13, 14; 13, 15; 14, identifier:idevice; 15, identifier:content; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:data; 21, identifier:x; 22, subscript; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:idevice; 25, identifier:content; 26, identifier:x; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:location; 30, identifier:filename; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:pickle_file; 34, call; 34, 35; 34, 36; 35, identifier:open; 36, argument_list; 36, 37; 36, 38; 37, identifier:location; 38, string:'wb'; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:pickle; 43, identifier:dump; 44, argument_list; 44, 45; 44, 46; 44, 47; 45, identifier:data; 46, identifier:pickle_file; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:protocol; 49, attribute; 49, 50; 49, 51; 50, identifier:pickle; 51, identifier:HIGHEST_PROTOCOL; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:pickle_file; 56, identifier:close; 57, argument_list | def create_pickled_data(idevice, filename):
data = {}
for x in idevice.content:
data[x] = idevice.content[x]
location = filename
pickle_file = open(location, 'wb')
pickle.dump(data, pickle_file, protocol=pickle.HIGHEST_PROTOCOL)
pickle_file.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_html_string; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 17; 7, 42; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:options; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_get_options; 15, argument_list; 15, 16; 16, identifier:kwargs; 17, if_statement; 17, 18; 17, 21; 17, 31; 18, subscript; 18, 19; 18, 20; 19, identifier:options; 20, string:"format"; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:string; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_get_formatted_html_string; 29, argument_list; 29, 30; 30, identifier:options; 31, else_clause; 31, 32; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:string; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_get_simple_html_string; 40, argument_list; 40, 41; 41, identifier:options; 42, return_statement; 42, 43; 43, identifier:string | def get_html_string(self, **kwargs):
options = self._get_options(kwargs)
if options["format"]:
string = self._get_formatted_html_string(options)
else:
string = self._get_simple_html_string(options)
return string |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_last_update_time; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 28; 6, expression_statement; 6, 7; 7, string:'''
Gets the time at which each ledger was updated.
Can be called at any time to get this information.
:return: an ordered dict of outdated ledgers sorted by last update time (from old to new)
and then by ledger ID (in case of equal update time)
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:last_updated; 11, dictionary_comprehension; 11, 12; 11, 17; 12, pair; 12, 13; 12, 14; 13, identifier:ledger_id; 14, attribute; 14, 15; 14, 16; 15, identifier:freshness_state; 16, identifier:last_updated; 17, for_in_clause; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:ledger_id; 20, identifier:freshness_state; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_ledger_freshness; 26, identifier:items; 27, argument_list; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:OrderedDict; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:sorted; 34, argument_list; 34, 35; 34, 40; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:last_updated; 38, identifier:items; 39, argument_list; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:key; 42, lambda; 42, 43; 42, 45; 43, lambda_parameters; 43, 44; 44, identifier:item; 45, tuple; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:item; 48, integer:1; 49, subscript; 49, 50; 49, 51; 50, identifier:item; 51, integer:0 | def get_last_update_time(self):
'''
Gets the time at which each ledger was updated.
Can be called at any time to get this information.
:return: an ordered dict of outdated ledgers sorted by last update time (from old to new)
and then by ledger ID (in case of equal update time)
'''
last_updated = {ledger_id: freshness_state.last_updated
for ledger_id, freshness_state in self._ledger_freshness.items()}
return OrderedDict(
sorted(
last_updated.items(),
key=lambda item: (item[1], item[0])
)
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_listChunks; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 42; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:chunks; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 20; 11, identifier:fileName; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:os; 15, identifier:listdir; 16, argument_list; 16, 17; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:dataDir; 20, block; 20, 21; 20, 30; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:index; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:ChunkedFileStore; 27, identifier:_fileNameToChunkIndex; 28, argument_list; 28, 29; 29, identifier:fileName; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:index; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:chunks; 39, identifier:append; 40, argument_list; 40, 41; 41, identifier:index; 42, return_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:sorted; 45, argument_list; 45, 46; 46, identifier:chunks | def _listChunks(self):
chunks = []
for fileName in os.listdir(self.dataDir):
index = ChunkedFileStore._fileNameToChunkIndex(fileName)
if index is not None:
chunks.append(index)
return sorted(chunks) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:mostCommonElement; 3, parameters; 3, 4; 3, 12; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:elements; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:Iterable; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:T; 12, typed_default_parameter; 12, 13; 12, 14; 12, 16; 13, identifier:to_hashable_f; 14, type; 14, 15; 15, identifier:Callable; 16, None; 17, block; 17, 18; 17, 110; 17, 121; 17, 139; 18, class_definition; 18, 19; 18, 20; 18, 26; 19, identifier:_Hashable; 20, argument_list; 20, 21; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:collections; 24, identifier:abc; 25, identifier:Hashable; 26, block; 26, 27; 26, 84; 26, 98; 27, function_definition; 27, 28; 27, 29; 27, 32; 28, function_name:__init__; 29, parameters; 29, 30; 29, 31; 30, identifier:self; 31, identifier:orig; 32, block; 32, 33; 32, 39; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:orig; 38, identifier:orig; 39, if_statement; 39, 40; 39, 47; 39, 54; 39, 68; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:orig; 44, attribute; 44, 45; 44, 46; 45, identifier:collections; 46, identifier:Hashable; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:hashable; 53, identifier:orig; 54, elif_clause; 54, 55; 54, 58; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:to_hashable_f; 57, None; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:hashable; 64, call; 64, 65; 64, 66; 65, identifier:to_hashable_f; 66, argument_list; 66, 67; 67, identifier:orig; 68, else_clause; 68, 69; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:hashable; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:json; 78, identifier:dumps; 79, argument_list; 79, 80; 79, 81; 80, identifier:orig; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:sort_keys; 83, True; 84, function_definition; 84, 85; 84, 86; 84, 89; 85, function_name:__eq__; 86, parameters; 86, 87; 86, 88; 87, identifier:self; 88, identifier:other; 89, block; 89, 90; 90, return_statement; 90, 91; 91, comparison_operator:==; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:hashable; 95, attribute; 95, 96; 95, 97; 96, identifier:other; 97, identifier:hashable; 98, function_definition; 98, 99; 98, 100; 98, 102; 99, function_name:__hash__; 100, parameters; 100, 101; 101, identifier:self; 102, block; 102, 103; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:hash; 106, argument_list; 106, 107; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:hashable; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:_elements; 113, generator_expression; 113, 114; 113, 118; 114, call; 114, 115; 114, 116; 115, identifier:_Hashable; 116, argument_list; 116, 117; 117, identifier:el; 118, for_in_clause; 118, 119; 118, 120; 119, identifier:el; 120, identifier:elements; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, pattern_list; 123, 124; 123, 125; 124, identifier:most_common; 125, identifier:counter; 126, subscript; 126, 127; 126, 138; 127, call; 127, 128; 127, 134; 128, attribute; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:Counter; 131, argument_list; 131, 132; 132, identifier:_elements; 133, identifier:most_common; 134, argument_list; 134, 135; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:n; 137, integer:1; 138, integer:0; 139, return_statement; 139, 140; 140, expression_list; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:most_common; 143, identifier:orig; 144, identifier:counter | def mostCommonElement(elements: Iterable[T], to_hashable_f: Callable=None):
class _Hashable(collections.abc.Hashable):
def __init__(self, orig):
self.orig = orig
if isinstance(orig, collections.Hashable):
self.hashable = orig
elif to_hashable_f is not None:
self.hashable = to_hashable_f(orig)
else:
self.hashable = json.dumps(orig, sort_keys=True)
def __eq__(self, other):
return self.hashable == other.hashable
def __hash__(self):
return hash(self.hashable)
_elements = (_Hashable(el) for el in elements)
most_common, counter = Counter(_elements).most_common(n=1)[0]
return most_common.orig, counter |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:minute_index_to_session_labels; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:index; 6, block; 6, 7; 6, 18; 6, 39; 6, 58; 6, 65; 6, 156; 7, if_statement; 7, 8; 7, 12; 8, not_operator; 8, 9; 9, attribute; 9, 10; 9, 11; 10, identifier:index; 11, identifier:is_monotonic_increasing; 12, block; 12, 13; 13, raise_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:ValueError; 16, argument_list; 16, 17; 17, string:"Non-ordered index passed to minute_index_to_session_labels."; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:prev_opens; 21, parenthesized_expression; 21, 22; 22, binary_operator:-; 22, 23; 22, 38; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_opens; 29, identifier:values; 30, identifier:searchsorted; 31, argument_list; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:index; 34, identifier:values; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:side; 37, string:'right'; 38, integer:1; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:next_closes; 42, parenthesized_expression; 42, 43; 43, call; 43, 44; 43, 51; 44, attribute; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_closes; 49, identifier:values; 50, identifier:searchsorted; 51, argument_list; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:index; 54, identifier:values; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:side; 57, string:'left'; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:mismatches; 61, parenthesized_expression; 61, 62; 62, comparison_operator:!=; 62, 63; 62, 64; 63, identifier:prev_opens; 64, identifier:next_closes; 65, if_statement; 65, 66; 65, 71; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:mismatches; 69, identifier:any; 70, argument_list; 71, block; 71, 72; 71, 83; 71, 89; 71, 95; 71, 107; 71, 121; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:bad_ix; 75, subscript; 75, 76; 75, 82; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:np; 79, identifier:flatnonzero; 80, argument_list; 80, 81; 81, identifier:mismatches; 82, integer:0; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:example; 86, subscript; 86, 87; 86, 88; 87, identifier:index; 88, identifier:bad_ix; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:prev_day; 92, subscript; 92, 93; 92, 94; 93, identifier:prev_opens; 94, identifier:bad_ix; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, pattern_list; 97, 98; 97, 99; 98, identifier:prev_open; 99, identifier:prev_close; 100, subscript; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:schedule; 105, identifier:iloc; 106, identifier:prev_day; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 112; 109, pattern_list; 109, 110; 109, 111; 110, identifier:next_open; 111, identifier:next_close; 112, subscript; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:schedule; 117, identifier:iloc; 118, binary_operator:+; 118, 119; 118, 120; 119, identifier:prev_day; 120, integer:1; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:ValueError; 124, argument_list; 124, 125; 125, call; 125, 126; 125, 133; 126, attribute; 126, 127; 126, 132; 127, concatenated_string; 127, 128; 127, 129; 127, 130; 127, 131; 128, string:"{num} non-market minutes in minute_index_to_session_labels:\n"; 129, string:"First Bad Minute: {first_bad}\n"; 130, string:"Previous Session: {prev_open} -> {prev_close}\n"; 131, string:"Next Session: {next_open} -> {next_close}"; 132, identifier:format; 133, argument_list; 133, 134; 133, 141; 133, 144; 133, 147; 133, 150; 133, 153; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:num; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:mismatches; 139, identifier:sum; 140, argument_list; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:first_bad; 143, identifier:example; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:prev_open; 146, identifier:prev_open; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:prev_close; 149, identifier:prev_close; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:next_open; 152, identifier:next_open; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:next_close; 155, identifier:next_close; 156, return_statement; 156, 157; 157, subscript; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:schedule; 162, identifier:index; 163, identifier:prev_opens | def minute_index_to_session_labels(self, index):
if not index.is_monotonic_increasing:
raise ValueError(
"Non-ordered index passed to minute_index_to_session_labels."
)
prev_opens = (
self._opens.values.searchsorted(index.values, side='right') - 1
)
next_closes = (
self._closes.values.searchsorted(index.values, side='left')
)
mismatches = (prev_opens != next_closes)
if mismatches.any():
bad_ix = np.flatnonzero(mismatches)[0]
example = index[bad_ix]
prev_day = prev_opens[bad_ix]
prev_open, prev_close = self.schedule.iloc[prev_day]
next_open, next_close = self.schedule.iloc[prev_day + 1]
raise ValueError(
"{num} non-market minutes in minute_index_to_session_labels:\n"
"First Bad Minute: {first_bad}\n"
"Previous Session: {prev_open} -> {prev_close}\n"
"Next Session: {next_open} -> {next_close}"
.format(
num=mismatches.sum(),
first_bad=example,
prev_open=prev_open, prev_close=prev_close,
next_open=next_open, next_close=next_close)
)
return self.schedule.index[prev_opens] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:aggregate_repeated_calls; 3, parameters; 3, 4; 3, 5; 4, identifier:frame; 5, identifier:options; 6, block; 6, 7; 6, 9; 6, 16; 6, 20; 6, 79; 6, 93; 6, 110; 7, expression_statement; 7, 8; 8, string:'''
Converts a timeline into a time-aggregate summary.
Adds together calls along the same call stack, so that repeated calls appear as the same
frame. Removes time-linearity - frames are sorted according to total time spent.
Useful for outputs that display a summary of execution (e.g. text and html outputs)
'''; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:frame; 12, None; 13, block; 13, 14; 14, return_statement; 14, 15; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:children_by_identifier; 19, dictionary; 20, for_statement; 20, 21; 20, 22; 20, 25; 21, identifier:child; 22, attribute; 22, 23; 22, 24; 23, identifier:frame; 24, identifier:children; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 32; 26, 69; 27, comparison_operator:in; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:child; 30, identifier:identifier; 31, identifier:children_by_identifier; 32, block; 32, 33; 32, 41; 32, 49; 32, 63; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:aggregate_frame; 36, subscript; 36, 37; 36, 38; 37, identifier:children_by_identifier; 38, attribute; 38, 39; 38, 40; 39, identifier:child; 40, identifier:identifier; 41, expression_statement; 41, 42; 42, augmented_assignment:+=; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:aggregate_frame; 45, identifier:self_time; 46, attribute; 46, 47; 46, 48; 47, identifier:child; 48, identifier:self_time; 49, if_statement; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:child; 52, identifier:children; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:aggregate_frame; 58, identifier:add_children; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:child; 62, identifier:children; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:child; 67, identifier:remove_from_parent; 68, argument_list; 69, else_clause; 69, 70; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 78; 73, subscript; 73, 74; 73, 75; 74, identifier:children_by_identifier; 75, attribute; 75, 76; 75, 77; 76, identifier:child; 77, identifier:identifier; 78, identifier:child; 79, for_statement; 79, 80; 79, 81; 79, 84; 80, identifier:child; 81, attribute; 81, 82; 81, 83; 82, identifier:frame; 83, identifier:children; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:aggregate_repeated_calls; 88, argument_list; 88, 89; 88, 90; 89, identifier:child; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:options; 92, identifier:options; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:frame; 98, identifier:_children; 99, identifier:sort; 100, argument_list; 100, 101; 100, 107; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:key; 103, call; 103, 104; 103, 105; 104, identifier:methodcaller; 105, argument_list; 105, 106; 106, string:'time'; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:reverse; 109, True; 110, return_statement; 110, 111; 111, identifier:frame | def aggregate_repeated_calls(frame, options):
'''
Converts a timeline into a time-aggregate summary.
Adds together calls along the same call stack, so that repeated calls appear as the same
frame. Removes time-linearity - frames are sorted according to total time spent.
Useful for outputs that display a summary of execution (e.g. text and html outputs)
'''
if frame is None:
return None
children_by_identifier = {}
for child in frame.children:
if child.identifier in children_by_identifier:
aggregate_frame = children_by_identifier[child.identifier]
aggregate_frame.self_time += child.self_time
if child.children:
aggregate_frame.add_children(child.children)
child.remove_from_parent()
else:
children_by_identifier[child.identifier] = child
for child in frame.children:
aggregate_repeated_calls(child, options=options)
frame._children.sort(key=methodcaller('time'), reverse=True)
return frame |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_all_tags_names_as_list; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:admin; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:language; 10, string:"en"; 11, block; 11, 12; 11, 55; 11, 61; 11, 67; 11, 78; 11, 126; 11, 147; 11, 168; 11, 177; 12, if_statement; 12, 13; 12, 14; 12, 34; 13, identifier:admin; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 27; 16, boolean_operator:and; 16, 17; 16, 22; 17, comparison_operator:!=; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_all_tags_cache_list_admin; 21, dictionary; 22, comparison_operator:in; 22, 23; 22, 24; 23, identifier:language; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_all_tags_cache_list_admin; 27, block; 27, 28; 28, return_statement; 28, 29; 29, subscript; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_all_tags_cache_list_admin; 33, identifier:language; 34, else_clause; 34, 35; 35, block; 35, 36; 36, if_statement; 36, 37; 36, 48; 37, boolean_operator:and; 37, 38; 37, 43; 38, comparison_operator:!=; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_all_tags_cache_list; 42, dictionary; 43, comparison_operator:in; 43, 44; 43, 45; 44, identifier:language; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_all_tags_cache_list; 48, block; 48, 49; 49, return_statement; 49, 50; 50, subscript; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_all_tags_cache_list; 54, identifier:language; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:s_stud; 58, call; 58, 59; 58, 60; 59, identifier:set; 60, argument_list; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:s_admin; 64, call; 64, 65; 64, 66; 65, identifier:set; 66, argument_list; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 73; 69, tuple_pattern; 69, 70; 69, 71; 69, 72; 70, identifier:common; 71, identifier:_; 72, identifier:org; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:get_all_tags; 77, argument_list; 78, for_statement; 78, 79; 78, 80; 78, 83; 79, identifier:tag; 80, binary_operator:+; 80, 81; 80, 82; 81, identifier:common; 82, identifier:org; 83, block; 83, 84; 83, 105; 83, 112; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:tag_name_with_translation; 87, conditional_expression:if; 87, 88; 87, 99; 87, 104; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:gettext; 92, argument_list; 92, 93; 92, 94; 93, identifier:language; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:tag; 97, identifier:get_name; 98, argument_list; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:tag; 102, identifier:get_name; 103, argument_list; 104, string:""; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:s_admin; 109, identifier:add; 110, argument_list; 110, 111; 111, identifier:tag_name_with_translation; 112, if_statement; 112, 113; 112, 118; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:tag; 116, identifier:is_visible_for_student; 117, argument_list; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:s_stud; 123, identifier:add; 124, argument_list; 124, 125; 125, identifier:tag_name_with_translation; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 133; 128, subscript; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_all_tags_cache_list_admin; 132, identifier:language; 133, call; 133, 134; 133, 135; 134, identifier:natsorted; 135, argument_list; 135, 136; 135, 137; 136, identifier:s_admin; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:key; 139, lambda; 139, 140; 139, 142; 140, lambda_parameters; 140, 141; 141, identifier:y; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:y; 145, identifier:lower; 146, argument_list; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 154; 149, subscript; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_all_tags_cache_list; 153, identifier:language; 154, call; 154, 155; 154, 156; 155, identifier:natsorted; 156, argument_list; 156, 157; 156, 158; 157, identifier:s_stud; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:key; 160, lambda; 160, 161; 160, 163; 161, lambda_parameters; 161, 162; 162, identifier:y; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:y; 166, identifier:lower; 167, argument_list; 168, if_statement; 168, 169; 168, 170; 169, identifier:admin; 170, block; 170, 171; 171, return_statement; 171, 172; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:_all_tags_cache_list_admin; 176, identifier:language; 177, return_statement; 177, 178; 178, subscript; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:_all_tags_cache_list; 182, identifier:language | def get_all_tags_names_as_list(self, admin=False, language="en"):
if admin:
if self._all_tags_cache_list_admin != {} and language in self._all_tags_cache_list_admin:
return self._all_tags_cache_list_admin[language]
else:
if self._all_tags_cache_list != {} and language in self._all_tags_cache_list:
return self._all_tags_cache_list[language]
s_stud = set()
s_admin = set()
(common, _, org) = self.get_all_tags()
for tag in common + org:
tag_name_with_translation = self.gettext(language, tag.get_name()) if tag.get_name() else ""
s_admin.add(tag_name_with_translation)
if tag.is_visible_for_student():
s_stud.add(tag_name_with_translation)
self._all_tags_cache_list_admin[language] = natsorted(s_admin, key=lambda y: y.lower())
self._all_tags_cache_list[language] = natsorted(s_stud, key=lambda y: y.lower())
if admin:
return self._all_tags_cache_list_admin[language]
return self._all_tags_cache_list[language] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_users; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:course; 6, block; 6, 7; 6, 55; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:users; 10, call; 10, 11; 10, 12; 11, identifier:OrderedDict; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 38; 16, call; 16, 17; 16, 18; 17, identifier:list; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 37; 20, attribute; 20, 21; 20, 36; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:user_manager; 26, identifier:get_users_info; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:user_manager; 33, identifier:get_course_registered_users; 34, argument_list; 34, 35; 35, identifier:course; 36, identifier:items; 37, argument_list; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, lambda; 40, 41; 40, 43; 41, lambda_parameters; 41, 42; 42, identifier:k; 43, conditional_expression:if; 43, 44; 43, 49; 43, 54; 44, subscript; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:k; 47, integer:1; 48, integer:0; 49, comparison_operator:is; 49, 50; 49, 53; 50, subscript; 50, 51; 50, 52; 51, identifier:k; 52, integer:1; 53, None; 54, string:""; 55, return_statement; 55, 56; 56, identifier:users | def get_users(self, course):
users = OrderedDict(sorted(list(self.user_manager.get_users_info(self.user_manager.get_course_registered_users(course)).items()),
key=lambda k: k[1][0] if k[1] is not None else ""))
return users |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:radius_cmp; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:a; 5, identifier:b; 6, identifier:offsets; 7, block; 7, 8; 7, 10; 7, 24; 7, 31; 7, 39; 8, expression_statement; 8, 9; 9, string:'''return +1 or -1 for for sorting'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:diff; 13, binary_operator:-; 13, 14; 13, 19; 14, call; 14, 15; 14, 16; 15, identifier:radius; 16, argument_list; 16, 17; 16, 18; 17, identifier:a; 18, identifier:offsets; 19, call; 19, 20; 19, 21; 20, identifier:radius; 21, argument_list; 21, 22; 21, 23; 22, identifier:b; 23, identifier:offsets; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:>; 25, 26; 25, 27; 26, identifier:diff; 27, integer:0; 28, block; 28, 29; 29, return_statement; 29, 30; 30, integer:1; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:<; 32, 33; 32, 34; 33, identifier:diff; 34, integer:0; 35, block; 35, 36; 36, return_statement; 36, 37; 37, unary_operator:-; 37, 38; 38, integer:1; 39, return_statement; 39, 40; 40, integer:0 | def radius_cmp(a, b, offsets):
'''return +1 or -1 for for sorting'''
diff = radius(a, offsets) - radius(b, offsets)
if diff > 0:
return 1
if diff < 0:
return -1
return 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:generate_enums_info; 3, parameters; 3, 4; 3, 5; 4, identifier:enums; 5, identifier:msgs; 6, block; 6, 7; 6, 230; 7, for_statement; 7, 8; 7, 9; 7, 10; 8, identifier:enum; 9, identifier:enums; 10, block; 10, 11; 10, 22; 10, 32; 10, 38; 10, 70; 10, 74; 10, 78; 10, 194; 10, 205; 10, 216; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:enum; 15, identifier:swift_name; 16, call; 16, 17; 16, 18; 17, identifier:camel_case_from_underscores; 18, argument_list; 18, 19; 19, attribute; 19, 20; 19, 21; 20, identifier:enum; 21, identifier:name; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:enum; 26, identifier:raw_value_type; 27, call; 27, 28; 27, 29; 28, identifier:get_enum_raw_type; 29, argument_list; 29, 30; 29, 31; 30, identifier:enum; 31, identifier:msgs; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:enum; 36, identifier:formatted_description; 37, string:""; 38, if_statement; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:enum; 41, identifier:description; 42, block; 42, 43; 42, 60; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:enum; 47, identifier:description; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, string:" "; 51, identifier:join; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:enum; 57, identifier:description; 58, identifier:split; 59, argument_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:enum; 64, identifier:formatted_description; 65, binary_operator:%; 65, 66; 65, 67; 66, string:"\n/**\n %s\n*/\n"; 67, attribute; 67, 68; 67, 69; 68, identifier:enum; 69, identifier:description; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:all_entities; 73, list:[]; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:entities_info; 77, list:[]; 78, for_statement; 78, 79; 78, 80; 78, 83; 79, identifier:entry; 80, attribute; 80, 81; 80, 82; 81, identifier:enum; 82, identifier:entry; 83, block; 83, 84; 83, 100; 83, 115; 83, 124; 83, 130; 83, 164; 83, 173; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:name; 87, call; 87, 88; 87, 93; 88, attribute; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:entry; 91, identifier:name; 92, identifier:replace; 93, argument_list; 93, 94; 93, 99; 94, binary_operator:+; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:enum; 97, identifier:name; 98, string:'_'; 99, string:''; 100, if_statement; 100, 101; 100, 108; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:name; 105, integer:0; 106, identifier:isdigit; 107, argument_list; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:name; 112, binary_operator:+; 112, 113; 112, 114; 113, string:"MAV_"; 114, identifier:name; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:entry; 119, identifier:swift_name; 120, call; 120, 121; 120, 122; 121, identifier:camel_case_from_underscores; 122, argument_list; 122, 123; 123, identifier:name; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:entry; 128, identifier:formatted_description; 129, string:""; 130, if_statement; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:entry; 133, identifier:description; 134, block; 134, 135; 134, 152; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:entry; 139, identifier:description; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, string:" "; 143, identifier:join; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:entry; 149, identifier:description; 150, identifier:split; 151, argument_list; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:entry; 156, identifier:formatted_description; 157, binary_operator:+; 157, 158; 157, 163; 158, binary_operator:+; 158, 159; 158, 160; 159, string:"\n\t/// "; 160, attribute; 160, 161; 160, 162; 161, identifier:entry; 162, identifier:description; 163, string:"\n"; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:all_entities; 168, identifier:append; 169, argument_list; 169, 170; 170, attribute; 170, 171; 170, 172; 171, identifier:entry; 172, identifier:swift_name; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:entities_info; 177, identifier:append; 178, argument_list; 178, 179; 179, binary_operator:%; 179, 180; 179, 181; 180, string:'("%s", "%s")'; 181, tuple; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:entry; 184, identifier:name; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:entry; 189, identifier:description; 190, identifier:replace; 191, argument_list; 191, 192; 191, 193; 192, string:'"'; 193, string:'\\"'; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:enum; 198, identifier:all_entities; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, string:", "; 202, identifier:join; 203, argument_list; 203, 204; 204, identifier:all_entities; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:enum; 209, identifier:entities_info; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, string:", "; 213, identifier:join; 214, argument_list; 214, 215; 215, identifier:entities_info; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:enum; 220, identifier:entity_description; 221, call; 221, 222; 221, 227; 222, attribute; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:enum; 225, identifier:description; 226, identifier:replace; 227, argument_list; 227, 228; 227, 229; 228, string:'"'; 229, string:'\\"'; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:enums; 234, identifier:sort; 235, argument_list; 235, 236; 236, keyword_argument; 236, 237; 236, 238; 237, identifier:key; 238, lambda; 238, 239; 238, 241; 239, lambda_parameters; 239, 240; 240, identifier:enum; 241, attribute; 241, 242; 241, 243; 242, identifier:enum; 243, identifier:swift_name | def generate_enums_info(enums, msgs):
for enum in enums:
enum.swift_name = camel_case_from_underscores(enum.name)
enum.raw_value_type = get_enum_raw_type(enum, msgs)
enum.formatted_description = ""
if enum.description:
enum.description = " ".join(enum.description.split())
enum.formatted_description = "\n/**\n %s\n*/\n" % enum.description
all_entities = []
entities_info = []
for entry in enum.entry:
name = entry.name.replace(enum.name + '_', '')
if name[0].isdigit():
name = "MAV_" + name
entry.swift_name = camel_case_from_underscores(name)
entry.formatted_description = ""
if entry.description:
entry.description = " ".join(entry.description.split())
entry.formatted_description = "\n\t/// " + entry.description + "\n"
all_entities.append(entry.swift_name)
entities_info.append('("%s", "%s")' % (entry.name, entry.description.replace('"','\\"')))
enum.all_entities = ", ".join(all_entities)
enum.entities_info = ", ".join(entities_info)
enum.entity_description = enum.description.replace('"','\\"')
enums.sort(key = lambda enum : enum.swift_name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:compare_report_print; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:sorted_list; 5, identifier:scores; 6, identifier:best_name; 7, block; 7, 8; 7, 16; 7, 42; 7, 98; 7, 102; 7, 113; 7, 140; 7, 144; 7, 219; 7, 230; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:title_items; 11, list:["Rank", "Name", "Class-Score", "Overall-Score"]; 11, 12; 11, 13; 11, 14; 11, 15; 12, string:"Rank"; 13, string:"Name"; 14, string:"Class-Score"; 15, string:"Overall-Score"; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:class_scores_len; 19, call; 19, 20; 19, 21; 20, identifier:map; 21, argument_list; 21, 22; 21, 34; 22, lambda; 22, 23; 22, 25; 23, lambda_parameters; 23, 24; 24, identifier:x; 25, call; 25, 26; 25, 27; 26, identifier:len; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:str; 30, argument_list; 30, 31; 31, subscript; 31, 32; 31, 33; 32, identifier:x; 33, string:"class"; 34, call; 34, 35; 34, 36; 35, identifier:list; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:scores; 40, identifier:values; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:shifts; 45, list:["%-" +
str(len(sorted_list) +
4) +
"s", "%-" +
str(max(map(lambda x: len(str(x)), sorted_list)) +
4) +
"s", "%-" +
str(max(class_scores_len) + 11) + "s"]; 45, 46; 45, 59; 45, 85; 46, binary_operator:+; 46, 47; 46, 58; 47, binary_operator:+; 47, 48; 47, 49; 48, string:"%-"; 49, call; 49, 50; 49, 51; 50, identifier:str; 51, argument_list; 51, 52; 52, binary_operator:+; 52, 53; 52, 57; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:sorted_list; 57, integer:4; 58, string:"s"; 59, binary_operator:+; 59, 60; 59, 84; 60, binary_operator:+; 60, 61; 60, 62; 61, string:"%-"; 62, call; 62, 63; 62, 64; 63, identifier:str; 64, argument_list; 64, 65; 65, binary_operator:+; 65, 66; 65, 83; 66, call; 66, 67; 66, 68; 67, identifier:max; 68, argument_list; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:map; 71, argument_list; 71, 72; 71, 82; 72, lambda; 72, 73; 72, 75; 73, lambda_parameters; 73, 74; 74, identifier:x; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:str; 80, argument_list; 80, 81; 81, identifier:x; 82, identifier:sorted_list; 83, integer:4; 84, string:"s"; 85, binary_operator:+; 85, 86; 85, 97; 86, binary_operator:+; 86, 87; 86, 88; 87, string:"%-"; 88, call; 88, 89; 88, 90; 89, identifier:str; 90, argument_list; 90, 91; 91, binary_operator:+; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:max; 94, argument_list; 94, 95; 95, identifier:class_scores_len; 96, integer:11; 97, string:"s"; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:result; 101, string:""; 102, expression_statement; 102, 103; 103, augmented_assignment:+=; 103, 104; 103, 105; 104, identifier:result; 105, binary_operator:+; 105, 106; 105, 112; 106, binary_operator:+; 106, 107; 106, 108; 107, string:"Best : "; 108, call; 108, 109; 108, 110; 109, identifier:str; 110, argument_list; 110, 111; 111, identifier:best_name; 112, string:"\n\n"; 113, expression_statement; 113, 114; 114, augmented_assignment:+=; 114, 115; 114, 116; 115, identifier:result; 116, binary_operator:+; 116, 117; 116, 139; 117, binary_operator:+; 117, 118; 117, 135; 118, binary_operator:%; 118, 119; 118, 126; 119, parenthesized_expression; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, string:""; 123, identifier:join; 124, argument_list; 124, 125; 125, identifier:shifts; 126, call; 126, 127; 126, 128; 127, identifier:tuple; 128, argument_list; 128, 129; 129, subscript; 129, 130; 129, 131; 130, identifier:title_items; 131, slice; 131, 132; 131, 133; 132, colon; 133, unary_operator:-; 133, 134; 134, integer:1; 135, subscript; 135, 136; 135, 137; 136, identifier:title_items; 137, unary_operator:-; 137, 138; 138, integer:1; 139, string:"\n"; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:prev_rank; 143, integer:0; 144, for_statement; 144, 145; 144, 148; 144, 152; 145, pattern_list; 145, 146; 145, 147; 146, identifier:index; 147, identifier:cm; 148, call; 148, 149; 148, 150; 149, identifier:enumerate; 150, argument_list; 150, 151; 151, identifier:sorted_list; 152, block; 152, 153; 152, 157; 152, 174; 152, 215; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:rank; 156, identifier:index; 157, if_statement; 157, 158; 157, 169; 158, comparison_operator:==; 158, 159; 158, 164; 159, subscript; 159, 160; 159, 161; 160, identifier:scores; 161, subscript; 161, 162; 161, 163; 162, identifier:sorted_list; 163, identifier:rank; 164, subscript; 164, 165; 164, 166; 165, identifier:scores; 166, subscript; 166, 167; 166, 168; 167, identifier:sorted_list; 168, identifier:prev_rank; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:rank; 173, identifier:prev_rank; 174, expression_statement; 174, 175; 175, augmented_assignment:+=; 175, 176; 175, 177; 176, identifier:result; 177, binary_operator:+; 177, 178; 177, 214; 178, binary_operator:+; 178, 179; 178, 206; 179, binary_operator:%; 179, 180; 179, 187; 180, parenthesized_expression; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, string:""; 184, identifier:join; 185, argument_list; 185, 186; 186, identifier:shifts; 187, tuple; 187, 188; 187, 194; 187, 198; 188, call; 188, 189; 188, 190; 189, identifier:str; 190, argument_list; 190, 191; 191, binary_operator:+; 191, 192; 191, 193; 192, identifier:rank; 193, integer:1; 194, call; 194, 195; 194, 196; 195, identifier:str; 196, argument_list; 196, 197; 197, identifier:cm; 198, call; 198, 199; 198, 200; 199, identifier:str; 200, argument_list; 200, 201; 201, subscript; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:scores; 204, identifier:cm; 205, string:"class"; 206, call; 206, 207; 206, 208; 207, identifier:str; 208, argument_list; 208, 209; 209, subscript; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:scores; 212, identifier:cm; 213, string:"overall"; 214, string:"\n"; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:prev_rank; 218, identifier:rank; 219, if_statement; 219, 220; 219, 223; 220, comparison_operator:is; 220, 221; 220, 222; 221, identifier:best_name; 222, None; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, augmented_assignment:+=; 225, 226; 225, 227; 226, identifier:result; 227, binary_operator:+; 227, 228; 227, 229; 228, string:"\nWarning: "; 229, identifier:COMPARE_RESULT_WARNING; 230, return_statement; 230, 231; 231, identifier:result | def compare_report_print(sorted_list, scores, best_name):
title_items = ["Rank", "Name", "Class-Score", "Overall-Score"]
class_scores_len = map(lambda x: len(
str(x["class"])), list(scores.values()))
shifts = ["%-" +
str(len(sorted_list) +
4) +
"s", "%-" +
str(max(map(lambda x: len(str(x)), sorted_list)) +
4) +
"s", "%-" +
str(max(class_scores_len) + 11) + "s"]
result = ""
result += "Best : " + str(best_name) + "\n\n"
result += ("".join(shifts)
) % tuple(title_items[:-1]) + title_items[-1] + "\n"
prev_rank = 0
for index, cm in enumerate(sorted_list):
rank = index
if scores[sorted_list[rank]] == scores[sorted_list[prev_rank]]:
rank = prev_rank
result += ("".join(shifts)) % (str(rank + 1), str(cm),
str(scores[cm]["class"])) + str(scores[cm]["overall"]) + "\n"
prev_rank = rank
if best_name is None:
result += "\nWarning: " + COMPARE_RESULT_WARNING
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:replace_cells; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, identifier:sorted_row_idxs; 7, block; 7, 8; 7, 15; 7, 19; 7, 23; 7, 35; 7, 106; 7, 121; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 14; 10, pattern_list; 10, 11; 10, 12; 10, 13; 11, identifier:row; 12, identifier:col; 13, identifier:tab; 14, identifier:key; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:new_keys; 18, dictionary; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:del_keys; 22, list:[]; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:selection; 26, call; 26, 27; 26, 34; 27, attribute; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:grid; 32, identifier:actions; 33, identifier:get_selection; 34, argument_list; 35, for_statement; 35, 36; 35, 40; 35, 45; 36, pattern_list; 36, 37; 36, 38; 36, 39; 37, identifier:__row; 38, identifier:__col; 39, identifier:__tab; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:grid; 44, identifier:code_array; 45, block; 45, 46; 46, if_statement; 46, 47; 46, 61; 47, boolean_operator:and; 47, 48; 47, 51; 47, 52; 48, comparison_operator:==; 48, 49; 48, 50; 49, identifier:__tab; 50, identifier:tab; 51, line_continuation:\; 52, parenthesized_expression; 52, 53; 53, boolean_operator:or; 53, 54; 53, 56; 54, not_operator; 54, 55; 55, identifier:selection; 56, comparison_operator:in; 56, 57; 56, 60; 57, tuple; 57, 58; 57, 59; 58, identifier:__row; 59, identifier:__col; 60, identifier:selection; 61, block; 61, 62; 61, 71; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:new_row; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:sorted_row_idxs; 68, identifier:index; 69, argument_list; 69, 70; 70, identifier:__row; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:!=; 72, 73; 72, 74; 73, identifier:__row; 74, identifier:new_row; 75, block; 75, 76; 75, 96; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 84; 77, 85; 78, subscript; 78, 79; 78, 80; 79, identifier:new_keys; 80, tuple; 80, 81; 80, 82; 80, 83; 81, identifier:new_row; 82, identifier:__col; 83, identifier:__tab; 84, line_continuation:\; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:grid; 90, identifier:code_array; 91, argument_list; 91, 92; 92, tuple; 92, 93; 92, 94; 92, 95; 93, identifier:__row; 94, identifier:__col; 95, identifier:__tab; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:del_keys; 100, identifier:append; 101, argument_list; 101, 102; 102, tuple; 102, 103; 102, 104; 102, 105; 103, identifier:__row; 104, identifier:__col; 105, identifier:__tab; 106, for_statement; 106, 107; 106, 108; 106, 109; 107, identifier:key; 108, identifier:del_keys; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 119; 112, attribute; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:grid; 117, identifier:code_array; 118, identifier:pop; 119, argument_list; 119, 120; 120, identifier:key; 121, for_statement; 121, 122; 121, 123; 121, 124; 122, identifier:key; 123, identifier:new_keys; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:CellActions; 129, identifier:set_code; 130, argument_list; 130, 131; 130, 132; 130, 133; 131, identifier:self; 132, identifier:key; 133, subscript; 133, 134; 133, 135; 134, identifier:new_keys; 135, identifier:key | def replace_cells(self, key, sorted_row_idxs):
row, col, tab = key
new_keys = {}
del_keys = []
selection = self.grid.actions.get_selection()
for __row, __col, __tab in self.grid.code_array:
if __tab == tab and \
(not selection or (__row, __col) in selection):
new_row = sorted_row_idxs.index(__row)
if __row != new_row:
new_keys[(new_row, __col, __tab)] = \
self.grid.code_array((__row, __col, __tab))
del_keys.append((__row, __col, __tab))
for key in del_keys:
self.grid.code_array.pop(key)
for key in new_keys:
CellActions.set_code(self, key, new_keys[key]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:OnSortAscending; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:event; 6, block; 6, 7; 6, 62; 7, try_statement; 7, 8; 7, 46; 8, block; 8, 9; 8, 39; 9, with_statement; 9, 10; 9, 21; 10, with_clause; 10, 11; 11, with_item; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:undo; 15, identifier:group; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:_; 19, argument_list; 19, 20; 20, string:"Sort ascending"; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:grid; 29, identifier:actions; 30, identifier:sort_ascending; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:grid; 37, identifier:actions; 38, identifier:cursor; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:statustext; 42, call; 42, 43; 42, 44; 43, identifier:_; 44, argument_list; 44, 45; 45, string:u"Sorting complete."; 46, except_clause; 46, 47; 46, 48; 46, 49; 47, identifier:Exception; 48, identifier:err; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:statustext; 53, call; 53, 54; 53, 60; 54, attribute; 54, 55; 54, 59; 55, call; 55, 56; 55, 57; 56, identifier:_; 57, argument_list; 57, 58; 58, string:u"Sorting failed: {}"; 59, identifier:format; 60, argument_list; 60, 61; 61, identifier:err; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:post_command_event; 65, argument_list; 65, 66; 65, 71; 65, 76; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:grid; 70, identifier:main_window; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:grid; 75, identifier:StatusBarMsg; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:text; 78, identifier:statustext | def OnSortAscending(self, event):
try:
with undo.group(_("Sort ascending")):
self.grid.actions.sort_ascending(self.grid.actions.cursor)
statustext = _(u"Sorting complete.")
except Exception, err:
statustext = _(u"Sorting failed: {}").format(err)
post_command_event(self.grid.main_window, self.grid.StatusBarMsg,
text=statustext) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:get_font_list; 3, parameters; 4, block; 4, 5; 4, 13; 4, 29; 4, 35; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:font_map; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:pangocairo; 11, identifier:cairo_font_map_get_default; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:font_list; 16, list_comprehension; 16, 17; 16, 22; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:f; 20, identifier:get_name; 21, argument_list; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:f; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:font_map; 27, identifier:list_families; 28, argument_list; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:font_list; 33, identifier:sort; 34, argument_list; 35, return_statement; 35, 36; 36, identifier:font_list | def get_font_list():
font_map = pangocairo.cairo_font_map_get_default()
font_list = [f.get_name() for f in font_map.list_families()]
font_list.sort()
return font_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_sorted_keys; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:keys; 6, identifier:startkey; 7, default_parameter; 7, 8; 7, 9; 8, identifier:reverse; 9, False; 10, block; 10, 11; 10, 24; 10, 71; 10, 84; 10, 98; 10, 112; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:tuple_key; 14, lambda; 14, 15; 14, 17; 15, lambda_parameters; 15, 16; 16, identifier:t; 17, subscript; 17, 18; 17, 19; 18, identifier:t; 19, slice; 19, 20; 19, 21; 19, 22; 20, colon; 21, colon; 22, unary_operator:-; 22, 23; 23, integer:1; 24, if_statement; 24, 25; 24, 26; 24, 48; 25, identifier:reverse; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:tuple_cmp; 30, lambda; 30, 31; 30, 33; 31, lambda_parameters; 31, 32; 32, identifier:t; 33, comparison_operator:>; 33, 34; 33, 41; 34, subscript; 34, 35; 34, 36; 35, identifier:t; 36, slice; 36, 37; 36, 38; 36, 39; 37, colon; 38, colon; 39, unary_operator:-; 39, 40; 40, integer:1; 41, subscript; 41, 42; 41, 43; 42, identifier:startkey; 43, slice; 43, 44; 43, 45; 43, 46; 44, colon; 45, colon; 46, unary_operator:-; 46, 47; 47, integer:1; 48, else_clause; 48, 49; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:tuple_cmp; 53, lambda; 53, 54; 53, 56; 54, lambda_parameters; 54, 55; 55, identifier:t; 56, comparison_operator:<; 56, 57; 56, 64; 57, subscript; 57, 58; 57, 59; 58, identifier:t; 59, slice; 59, 60; 59, 61; 59, 62; 60, colon; 61, colon; 62, unary_operator:-; 62, 63; 63, integer:1; 64, subscript; 64, 65; 64, 66; 65, identifier:startkey; 66, slice; 66, 67; 66, 68; 66, 69; 67, colon; 68, colon; 69, unary_operator:-; 69, 70; 70, integer:1; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:searchkeys; 74, call; 74, 75; 74, 76; 75, identifier:sorted; 76, argument_list; 76, 77; 76, 78; 76, 81; 77, identifier:keys; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:key; 80, identifier:tuple_key; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:reverse; 83, identifier:reverse; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:searchpos; 87, call; 87, 88; 87, 89; 88, identifier:sum; 89, generator_expression; 89, 90; 89, 91; 90, integer:1; 91, for_in_clause; 91, 92; 91, 93; 92, identifier:_; 93, call; 93, 94; 93, 95; 94, identifier:ifilter; 95, argument_list; 95, 96; 95, 97; 96, identifier:tuple_cmp; 97, identifier:searchkeys; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:searchkeys; 101, binary_operator:+; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 104; 103, identifier:searchkeys; 104, slice; 104, 105; 104, 106; 105, identifier:searchpos; 106, colon; 107, subscript; 107, 108; 107, 109; 108, identifier:searchkeys; 109, slice; 109, 110; 109, 111; 110, colon; 111, identifier:searchpos; 112, for_statement; 112, 113; 112, 114; 112, 115; 113, identifier:key; 114, identifier:searchkeys; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, yield; 117, 118; 118, identifier:key | def _sorted_keys(self, keys, startkey, reverse=False):
tuple_key = lambda t: t[::-1]
if reverse:
tuple_cmp = lambda t: t[::-1] > startkey[::-1]
else:
tuple_cmp = lambda t: t[::-1] < startkey[::-1]
searchkeys = sorted(keys, key=tuple_key, reverse=reverse)
searchpos = sum(1 for _ in ifilter(tuple_cmp, searchkeys))
searchkeys = searchkeys[searchpos:] + searchkeys[:searchpos]
for key in searchkeys:
yield key |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:stratify; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 28; 5, 36; 5, 72; 5, 88; 5, 108; 5, 127; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 12; 8, pattern_list; 8, 9; 8, 10; 8, 11; 9, identifier:Y; 10, identifier:D; 11, identifier:X; 12, expression_list; 12, 13; 12, 18; 12, 23; 13, subscript; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:raw_data; 17, string:'Y'; 18, subscript; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:raw_data; 22, string:'D'; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:raw_data; 27, string:'X'; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:pscore; 31, subscript; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:raw_data; 35, string:'pscore'; 36, if_statement; 36, 37; 36, 44; 36, 55; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:blocks; 43, identifier:int; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:blocks; 48, call; 48, 49; 48, 50; 49, identifier:split_equal_bins; 50, argument_list; 50, 51; 50, 52; 51, identifier:pscore; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:blocks; 55, else_clause; 55, 56; 56, block; 56, 57; 56, 66; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:blocks; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:blocks; 64, slice; 64, 65; 65, colon; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:blocks; 70, integer:0; 71, integer:0; 72, function_definition; 72, 73; 72, 74; 72, 77; 73, function_name:subset; 74, parameters; 74, 75; 74, 76; 75, identifier:p_low; 76, identifier:p_high; 77, block; 77, 78; 78, return_statement; 78, 79; 79, binary_operator:&; 79, 80; 79, 84; 80, parenthesized_expression; 80, 81; 81, comparison_operator:<; 81, 82; 81, 83; 82, identifier:p_low; 83, identifier:pscore; 84, parenthesized_expression; 84, 85; 85, comparison_operator:<=; 85, 86; 85, 87; 86, identifier:pscore; 87, identifier:p_high; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:subsets; 91, list_comprehension; 91, 92; 91, 97; 92, call; 92, 93; 92, 94; 93, identifier:subset; 94, argument_list; 94, 95; 95, list_splat; 95, 96; 96, identifier:ps; 97, for_in_clause; 97, 98; 97, 99; 98, identifier:ps; 99, call; 99, 100; 99, 101; 100, identifier:zip; 101, argument_list; 101, 102; 101, 103; 102, identifier:blocks; 103, subscript; 103, 104; 103, 105; 104, identifier:blocks; 105, slice; 105, 106; 105, 107; 106, integer:1; 107, colon; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:strata; 111, list_comprehension; 111, 112; 111, 124; 112, call; 112, 113; 112, 114; 113, identifier:CausalModel; 114, argument_list; 114, 115; 114, 118; 114, 121; 115, subscript; 115, 116; 115, 117; 116, identifier:Y; 117, identifier:s; 118, subscript; 118, 119; 118, 120; 119, identifier:D; 120, identifier:s; 121, subscript; 121, 122; 121, 123; 122, identifier:X; 123, identifier:s; 124, for_in_clause; 124, 125; 124, 126; 125, identifier:s; 126, identifier:subsets; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:strata; 132, call; 132, 133; 132, 134; 133, identifier:Strata; 134, argument_list; 134, 135; 134, 136; 134, 137; 135, identifier:strata; 136, identifier:subsets; 137, identifier:pscore | def stratify(self):
Y, D, X = self.raw_data['Y'], self.raw_data['D'], self.raw_data['X']
pscore = self.raw_data['pscore']
if isinstance(self.blocks, int):
blocks = split_equal_bins(pscore, self.blocks)
else:
blocks = self.blocks[:]
blocks[0] = 0
def subset(p_low, p_high):
return (p_low < pscore) & (pscore <= p_high)
subsets = [subset(*ps) for ps in zip(blocks, blocks[1:])]
strata = [CausalModel(Y[s], D[s], X[s]) for s in subsets]
self.strata = Strata(strata, subsets, pscore) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 43; 2, function_name:list_current_orders; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 25; 3, 28; 3, 31; 3, 34; 3, 37; 3, 40; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:bet_ids; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:market_ids; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:order_projection; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:customer_order_refs; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:customer_strategy_refs; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:date_range; 22, call; 22, 23; 22, 24; 23, identifier:time_range; 24, argument_list; 25, default_parameter; 25, 26; 25, 27; 26, identifier:order_by; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:sort_dir; 30, None; 31, default_parameter; 31, 32; 31, 33; 32, identifier:from_record; 33, None; 34, default_parameter; 34, 35; 34, 36; 35, identifier:record_count; 36, None; 37, default_parameter; 37, 38; 37, 39; 38, identifier:session; 39, None; 40, default_parameter; 40, 41; 40, 42; 41, identifier:lightweight; 42, None; 43, block; 43, 44; 43, 53; 43, 63; 43, 76; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:params; 47, call; 47, 48; 47, 49; 48, identifier:clean_locals; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:locals; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:method; 56, binary_operator:%; 56, 57; 56, 58; 57, string:'%s%s'; 58, tuple; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:URI; 62, string:'listCurrentOrders'; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, tuple_pattern; 65, 66; 65, 67; 66, identifier:response; 67, identifier:elapsed_time; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:request; 72, argument_list; 72, 73; 72, 74; 72, 75; 73, identifier:method; 74, identifier:params; 75, identifier:session; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:process_response; 81, argument_list; 81, 82; 81, 83; 81, 86; 81, 87; 82, identifier:response; 83, attribute; 83, 84; 83, 85; 84, identifier:resources; 85, identifier:CurrentOrders; 86, identifier:elapsed_time; 87, identifier:lightweight | def list_current_orders(self, bet_ids=None, market_ids=None, order_projection=None, customer_order_refs=None,
customer_strategy_refs=None, date_range=time_range(), order_by=None, sort_dir=None,
from_record=None, record_count=None, session=None, lightweight=None):
params = clean_locals(locals())
method = '%s%s' % (self.URI, 'listCurrentOrders')
(response, elapsed_time) = self.request(method, params, session)
return self.process_response(response, resources.CurrentOrders, elapsed_time, lightweight) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:visit_Module; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:node; 6, block; 6, 7; 6, 13; 6, 19; 6, 50; 6, 92; 6, 103; 6, 111; 6, 117; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:newbody; 10, call; 10, 11; 10, 12; 11, identifier:list; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:olddef; 16, call; 16, 17; 16, 18; 17, identifier:list; 18, argument_list; 19, for_statement; 19, 20; 19, 21; 19, 24; 20, identifier:stmt; 21, attribute; 21, 22; 21, 23; 22, identifier:node; 23, identifier:body; 24, block; 24, 25; 25, if_statement; 25, 26; 25, 33; 25, 41; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:stmt; 30, attribute; 30, 31; 30, 32; 31, identifier:ast; 32, identifier:FunctionDef; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:olddef; 38, identifier:append; 39, argument_list; 39, 40; 40, identifier:stmt; 41, else_clause; 41, 42; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:newbody; 47, identifier:append; 48, argument_list; 48, 49; 49, identifier:stmt; 50, try_statement; 50, 51; 50, 80; 51, block; 51, 52; 51, 64; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:newdef; 55, call; 55, 56; 55, 57; 56, identifier:topological_sort; 57, argument_list; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:type_dependencies; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:ordered_global_declarations; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:newdef; 67, list_comprehension; 67, 68; 67, 69; 67, 72; 68, identifier:f; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:f; 71, identifier:newdef; 72, if_clause; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:isinstance; 75, argument_list; 75, 76; 75, 77; 76, identifier:f; 77, attribute; 77, 78; 77, 79; 78, identifier:ast; 79, identifier:FunctionDef; 80, except_clause; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:nx; 84, identifier:exception; 85, identifier:NetworkXUnfeasible; 86, block; 86, 87; 87, raise_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:PythranSyntaxError; 90, argument_list; 90, 91; 91, string:"Infinite function recursion"; 92, assert_statement; 92, 93; 92, 102; 93, comparison_operator:==; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:set; 96, argument_list; 96, 97; 97, identifier:newdef; 98, call; 98, 99; 98, 100; 99, identifier:set; 100, argument_list; 100, 101; 101, identifier:olddef; 102, string:"A function have been lost..."; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:node; 107, identifier:body; 108, binary_operator:+; 108, 109; 108, 110; 109, identifier:newbody; 110, identifier:newdef; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:update; 116, True; 117, return_statement; 117, 118; 118, identifier:node | def visit_Module(self, node):
newbody = list()
olddef = list()
for stmt in node.body:
if isinstance(stmt, ast.FunctionDef):
olddef.append(stmt)
else:
newbody.append(stmt)
try:
newdef = topological_sort(
self.type_dependencies,
self.ordered_global_declarations)
newdef = [f for f in newdef if isinstance(f, ast.FunctionDef)]
except nx.exception.NetworkXUnfeasible:
raise PythranSyntaxError("Infinite function recursion")
assert set(newdef) == set(olddef), "A function have been lost..."
node.body = newbody + newdef
self.update = True
return node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:qzordered; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:A; 5, identifier:B; 6, default_parameter; 6, 7; 6, 8; 7, identifier:crit; 8, float:1.0; 9, block; 9, 10; 9, 12; 9, 16; 9, 32; 9, 52; 9, 71; 10, expression_statement; 10, 11; 11, string:"Eigenvalues bigger than crit are sorted in the top-left."; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:TOL; 15, float:1e-10; 16, function_definition; 16, 17; 16, 18; 16, 21; 17, function_name:select; 18, parameters; 18, 19; 18, 20; 19, identifier:alpha; 20, identifier:beta; 21, block; 21, 22; 22, return_statement; 22, 23; 23, comparison_operator:>; 23, 24; 23, 27; 24, binary_operator:**; 24, 25; 24, 26; 25, identifier:alpha; 26, integer:2; 27, binary_operator:*; 27, 28; 27, 29; 28, identifier:crit; 29, binary_operator:**; 29, 30; 29, 31; 30, identifier:beta; 31, integer:2; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 41; 34, list_pattern; 34, 35; 34, 36; 34, 37; 34, 38; 34, 39; 34, 40; 35, identifier:S; 36, identifier:T; 37, identifier:alpha; 38, identifier:beta; 39, identifier:U; 40, identifier:V; 41, call; 41, 42; 41, 43; 42, identifier:ordqz; 43, argument_list; 43, 44; 43, 45; 43, 46; 43, 49; 44, identifier:A; 45, identifier:B; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:output; 48, string:'real'; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:sort; 51, identifier:select; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:eigval; 55, call; 55, 56; 55, 57; 56, identifier:abs; 57, argument_list; 57, 58; 58, binary_operator:/; 58, 59; 58, 65; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:numpy; 62, identifier:diag; 63, argument_list; 63, 64; 64, identifier:S; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:numpy; 68, identifier:diag; 69, argument_list; 69, 70; 70, identifier:T; 71, return_statement; 71, 72; 72, list:[S,T,U,V,eigval]; 72, 73; 72, 74; 72, 75; 72, 76; 72, 77; 73, identifier:S; 74, identifier:T; 75, identifier:U; 76, identifier:V; 77, identifier:eigval | def qzordered(A,B,crit=1.0):
"Eigenvalues bigger than crit are sorted in the top-left."
TOL = 1e-10
def select(alpha, beta):
return alpha**2>crit*beta**2
[S,T,alpha,beta,U,V] = ordqz(A,B,output='real',sort=select)
eigval = abs(numpy.diag(S)/numpy.diag(T))
return [S,T,U,V,eigval] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:ordqz; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:A; 5, identifier:B; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, string:'lhp'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:output; 11, string:'real'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:overwrite_a; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:overwrite_b; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:check_finite; 20, True; 21, block; 21, 22; 21, 25; 21, 30; 21, 35; 21, 44; 21, 51; 21, 58; 21, 67; 21, 71; 21, 99; 21, 121; 21, 158; 21, 165; 21, 173; 21, 185; 21, 232; 21, 236; 21, 270; 21, 287; 21, 294; 21, 323; 22, import_statement; 22, 23; 23, dotted_name; 23, 24; 24, identifier:warnings; 25, import_statement; 25, 26; 26, aliased_import; 26, 27; 26, 29; 27, dotted_name; 27, 28; 28, identifier:numpy; 29, identifier:np; 30, import_from_statement; 30, 31; 30, 33; 31, dotted_name; 31, 32; 32, identifier:numpy; 33, dotted_name; 33, 34; 34, identifier:asarray_chkfinite; 35, import_from_statement; 35, 36; 35, 40; 35, 42; 36, dotted_name; 36, 37; 36, 38; 36, 39; 37, identifier:scipy; 38, identifier:linalg; 39, identifier:misc; 40, dotted_name; 40, 41; 41, identifier:LinAlgError; 42, dotted_name; 42, 43; 43, identifier:_datacopied; 44, import_from_statement; 44, 45; 44, 49; 45, dotted_name; 45, 46; 45, 47; 45, 48; 46, identifier:scipy; 47, identifier:linalg; 48, identifier:lapack; 49, dotted_name; 49, 50; 50, identifier:get_lapack_funcs; 51, import_from_statement; 51, 52; 51, 56; 52, dotted_name; 52, 53; 52, 54; 52, 55; 53, identifier:scipy; 54, identifier:_lib; 55, identifier:six; 56, dotted_name; 56, 57; 57, identifier:callable; 58, import_from_statement; 58, 59; 58, 63; 58, 65; 59, dotted_name; 59, 60; 59, 61; 59, 62; 60, identifier:scipy; 61, identifier:linalg; 62, identifier:_decomp_qz; 63, dotted_name; 63, 64; 64, identifier:_qz; 65, dotted_name; 65, 66; 66, identifier:_select_function; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:lwork; 70, None; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, pattern_list; 73, 74; 73, 75; 74, identifier:result; 75, identifier:typ; 76, call; 76, 77; 76, 78; 77, identifier:_qz; 78, argument_list; 78, 79; 78, 80; 78, 81; 78, 84; 78, 87; 78, 90; 78, 93; 78, 96; 79, identifier:A; 80, identifier:B; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:output; 83, identifier:output; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:lwork; 86, identifier:lwork; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:sort; 89, None; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:overwrite_a; 92, identifier:overwrite_a; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:overwrite_b; 95, identifier:overwrite_b; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:check_finite; 98, identifier:check_finite; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 106; 101, pattern_list; 101, 102; 101, 103; 101, 104; 101, 105; 102, identifier:AA; 103, identifier:BB; 104, identifier:Q; 105, identifier:Z; 106, expression_list; 106, 107; 106, 110; 106, 113; 106, 117; 107, subscript; 107, 108; 107, 109; 108, identifier:result; 109, integer:0; 110, subscript; 110, 111; 110, 112; 111, identifier:result; 112, integer:1; 113, subscript; 113, 114; 113, 115; 114, identifier:result; 115, unary_operator:-; 115, 116; 116, integer:4; 117, subscript; 117, 118; 117, 119; 118, identifier:result; 119, unary_operator:-; 119, 120; 120, integer:3; 121, if_statement; 121, 122; 121, 125; 121, 144; 122, comparison_operator:not; 122, 123; 122, 124; 123, identifier:typ; 124, string:'cz'; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, pattern_list; 128, 129; 128, 130; 129, identifier:alpha; 130, identifier:beta; 131, expression_list; 131, 132; 131, 141; 132, binary_operator:+; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:result; 135, integer:3; 136, binary_operator:*; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:result; 139, integer:4; 140, float:1.j; 141, subscript; 141, 142; 141, 143; 142, identifier:result; 143, integer:5; 144, else_clause; 144, 145; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, pattern_list; 148, 149; 148, 150; 149, identifier:alpha; 150, identifier:beta; 151, expression_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:result; 154, integer:3; 155, subscript; 155, 156; 155, 157; 156, identifier:result; 157, integer:4; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:sfunction; 161, call; 161, 162; 161, 163; 162, identifier:_select_function; 163, argument_list; 163, 164; 164, identifier:sort; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:select; 168, call; 168, 169; 168, 170; 169, identifier:sfunction; 170, argument_list; 170, 171; 170, 172; 171, identifier:alpha; 172, identifier:beta; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 177; 175, pattern_list; 175, 176; 176, identifier:tgsen; 177, call; 177, 178; 177, 179; 178, identifier:get_lapack_funcs; 179, argument_list; 179, 180; 179, 182; 180, tuple; 180, 181; 181, string:'tgsen'; 182, tuple; 182, 183; 182, 184; 183, identifier:AA; 184, identifier:BB; 185, if_statement; 185, 186; 185, 194; 186, boolean_operator:or; 186, 187; 186, 190; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:lwork; 189, None; 190, comparison_operator:==; 190, 191; 190, 192; 191, identifier:lwork; 192, unary_operator:-; 192, 193; 193, integer:1; 194, block; 194, 195; 194, 210; 194, 228; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:result; 198, call; 198, 199; 198, 200; 199, identifier:tgsen; 200, argument_list; 200, 201; 200, 202; 200, 203; 200, 204; 200, 205; 200, 206; 201, identifier:select; 202, identifier:AA; 203, identifier:BB; 204, identifier:Q; 205, identifier:Z; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:lwork; 208, unary_operator:-; 208, 209; 209, integer:1; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:lwork; 213, call; 213, 214; 213, 224; 214, attribute; 214, 215; 214, 223; 215, attribute; 215, 216; 215, 222; 216, subscript; 216, 217; 216, 221; 217, subscript; 217, 218; 217, 219; 218, identifier:result; 219, unary_operator:-; 219, 220; 220, integer:3; 221, integer:0; 222, identifier:real; 223, identifier:astype; 224, argument_list; 224, 225; 225, attribute; 225, 226; 225, 227; 226, identifier:np; 227, identifier:int; 228, expression_statement; 228, 229; 229, augmented_assignment:+=; 229, 230; 229, 231; 230, identifier:lwork; 231, integer:1; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:liwork; 235, None; 236, if_statement; 236, 237; 236, 245; 237, boolean_operator:or; 237, 238; 237, 241; 238, comparison_operator:is; 238, 239; 238, 240; 239, identifier:liwork; 240, None; 241, comparison_operator:==; 241, 242; 241, 243; 242, identifier:liwork; 243, unary_operator:-; 243, 244; 244, integer:1; 245, block; 245, 246; 245, 261; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:result; 249, call; 249, 250; 249, 251; 250, identifier:tgsen; 251, argument_list; 251, 252; 251, 253; 251, 254; 251, 255; 251, 256; 251, 257; 252, identifier:select; 253, identifier:AA; 254, identifier:BB; 255, identifier:Q; 256, identifier:Z; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:liwork; 259, unary_operator:-; 259, 260; 260, integer:1; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:liwork; 264, subscript; 264, 265; 264, 269; 265, subscript; 265, 266; 265, 267; 266, identifier:result; 267, unary_operator:-; 267, 268; 268, integer:2; 269, integer:0; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:result; 273, call; 273, 274; 273, 275; 274, identifier:tgsen; 275, argument_list; 275, 276; 275, 277; 275, 278; 275, 279; 275, 280; 275, 281; 275, 284; 276, identifier:select; 277, identifier:AA; 278, identifier:BB; 279, identifier:Q; 280, identifier:Z; 281, keyword_argument; 281, 282; 281, 283; 282, identifier:lwork; 283, identifier:lwork; 284, keyword_argument; 284, 285; 284, 286; 285, identifier:liwork; 286, identifier:liwork; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:info; 290, subscript; 290, 291; 290, 292; 291, identifier:result; 292, unary_operator:-; 292, 293; 293, integer:1; 294, if_statement; 294, 295; 294, 298; 294, 307; 295, comparison_operator:<; 295, 296; 295, 297; 296, identifier:info; 297, integer:0; 298, block; 298, 299; 299, raise_statement; 299, 300; 300, call; 300, 301; 300, 302; 301, identifier:ValueError; 302, argument_list; 302, 303; 303, binary_operator:%; 303, 304; 303, 305; 304, string:"Illegal value in argument %d of tgsen"; 305, unary_operator:-; 305, 306; 306, identifier:info; 307, elif_clause; 307, 308; 307, 311; 308, comparison_operator:==; 308, 309; 308, 310; 309, identifier:info; 310, integer:1; 311, block; 311, 312; 312, raise_statement; 312, 313; 313, call; 313, 314; 313, 315; 314, identifier:ValueError; 315, argument_list; 315, 316; 316, concatenated_string; 316, 317; 316, 318; 316, 319; 316, 320; 316, 321; 316, 322; 317, string:"Reordering of (A, B) failed because the transformed"; 318, string:" matrix pair (A, B) would be too far from "; 319, string:"generalized Schur form; the problem is very "; 320, string:"ill-conditioned. (A, B) may have been partially "; 321, string:"reorded. If requested, 0 is returned in DIF(*), "; 322, string:"PL, and PR."; 323, if_statement; 323, 324; 323, 329; 323, 360; 324, comparison_operator:in; 324, 325; 324, 326; 325, identifier:typ; 326, list:['f', 'd']; 326, 327; 326, 328; 327, string:'f'; 328, string:'d'; 329, block; 329, 330; 329, 342; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:alpha; 333, binary_operator:+; 333, 334; 333, 337; 334, subscript; 334, 335; 334, 336; 335, identifier:result; 336, integer:2; 337, binary_operator:*; 337, 338; 337, 341; 338, subscript; 338, 339; 338, 340; 339, identifier:result; 340, integer:3; 341, float:1.j; 342, return_statement; 342, 343; 343, tuple; 343, 344; 343, 347; 343, 350; 343, 351; 343, 354; 343, 357; 344, subscript; 344, 345; 344, 346; 345, identifier:result; 346, integer:0; 347, subscript; 347, 348; 347, 349; 348, identifier:result; 349, integer:1; 350, identifier:alpha; 351, subscript; 351, 352; 351, 353; 352, identifier:result; 353, integer:4; 354, subscript; 354, 355; 354, 356; 355, identifier:result; 356, integer:5; 357, subscript; 357, 358; 357, 359; 358, identifier:result; 359, integer:6; 360, else_clause; 360, 361; 361, block; 361, 362; 362, return_statement; 362, 363; 363, expression_list; 363, 364; 363, 367; 363, 370; 363, 373; 363, 376; 363, 379; 364, subscript; 364, 365; 364, 366; 365, identifier:result; 366, integer:0; 367, subscript; 367, 368; 367, 369; 368, identifier:result; 369, integer:1; 370, subscript; 370, 371; 370, 372; 371, identifier:result; 372, integer:2; 373, subscript; 373, 374; 373, 375; 374, identifier:result; 375, integer:3; 376, subscript; 376, 377; 376, 378; 377, identifier:result; 378, integer:4; 379, subscript; 379, 380; 379, 381; 380, identifier:result; 381, integer:5 | def ordqz(A, B, sort='lhp', output='real', overwrite_a=False,
overwrite_b=False, check_finite=True):
import warnings
import numpy as np
from numpy import asarray_chkfinite
from scipy.linalg.misc import LinAlgError, _datacopied
from scipy.linalg.lapack import get_lapack_funcs
from scipy._lib.six import callable
from scipy.linalg._decomp_qz import _qz, _select_function
lwork = None
result, typ = _qz(A, B, output=output, lwork=lwork, sort=None,
overwrite_a=overwrite_a, overwrite_b=overwrite_b,
check_finite=check_finite)
AA, BB, Q, Z = result[0], result[1], result[-4], result[-3]
if typ not in 'cz':
alpha, beta = result[3] + result[4]*1.j, result[5]
else:
alpha, beta = result[3], result[4]
sfunction = _select_function(sort)
select = sfunction(alpha, beta)
tgsen, = get_lapack_funcs(('tgsen',), (AA, BB))
if lwork is None or lwork == -1:
result = tgsen(select, AA, BB, Q, Z, lwork=-1)
lwork = result[-3][0].real.astype(np.int)
lwork += 1
liwork = None
if liwork is None or liwork == -1:
result = tgsen(select, AA, BB, Q, Z, liwork=-1)
liwork = result[-2][0]
result = tgsen(select, AA, BB, Q, Z, lwork=lwork, liwork=liwork)
info = result[-1]
if info < 0:
raise ValueError("Illegal value in argument %d of tgsen" % -info)
elif info == 1:
raise ValueError("Reordering of (A, B) failed because the transformed"
" matrix pair (A, B) would be too far from "
"generalized Schur form; the problem is very "
"ill-conditioned. (A, B) may have been partially "
"reorded. If requested, 0 is returned in DIF(*), "
"PL, and PR.")
if typ in ['f', 'd']:
alpha = result[2] + result[3] * 1.j
return (result[0], result[1], alpha, result[4], result[5], result[6])
else:
return result[0], result[1], result[2], result[3], result[4], result[5] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:inverse_cdf; 3, parameters; 3, 4; 3, 5; 4, identifier:su; 5, identifier:W; 6, block; 6, 7; 6, 11; 6, 17; 6, 25; 6, 35; 6, 65; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:j; 10, integer:0; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:s; 14, subscript; 14, 15; 14, 16; 15, identifier:W; 16, integer:0; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:M; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:su; 23, identifier:shape; 24, integer:0; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:A; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:empty; 32, argument_list; 32, 33; 32, 34; 33, identifier:M; 34, string:'int'; 35, for_statement; 35, 36; 35, 37; 35, 41; 36, identifier:n; 37, call; 37, 38; 37, 39; 38, identifier:range; 39, argument_list; 39, 40; 40, identifier:M; 41, block; 41, 42; 41, 59; 42, while_statement; 42, 43; 42, 48; 43, comparison_operator:>; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:su; 46, identifier:n; 47, identifier:s; 48, block; 48, 49; 48, 53; 49, expression_statement; 49, 50; 50, augmented_assignment:+=; 50, 51; 50, 52; 51, identifier:j; 52, integer:1; 53, expression_statement; 53, 54; 54, augmented_assignment:+=; 54, 55; 54, 56; 55, identifier:s; 56, subscript; 56, 57; 56, 58; 57, identifier:W; 58, identifier:j; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:A; 63, identifier:n; 64, identifier:j; 65, return_statement; 65, 66; 66, identifier:A | def inverse_cdf(su, W):
j = 0
s = W[0]
M = su.shape[0]
A = np.empty(M, 'int')
for n in range(M):
while su[n] > s:
j += 1
s += W[j]
A[n] = j
return A |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort_items; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:items; 6, default_parameter; 6, 7; 6, 8; 7, identifier:args; 8, False; 9, block; 9, 10; 9, 24; 9, 33; 9, 109; 9, 125; 9, 254; 9, 270; 10, if_statement; 10, 11; 10, 22; 11, comparison_operator:==; 11, 12; 11, 21; 12, call; 12, 13; 12, 20; 13, attribute; 13, 14; 13, 19; 14, subscript; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:settings; 18, string:'sort'; 19, identifier:lower; 20, argument_list; 21, string:'src'; 22, block; 22, 23; 23, return_statement; 24, function_definition; 24, 25; 24, 26; 24, 28; 25, function_name:alpha; 26, parameters; 26, 27; 27, identifier:i; 28, block; 28, 29; 29, return_statement; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:i; 32, identifier:name; 33, function_definition; 33, 34; 33, 35; 33, 37; 34, function_name:permission; 35, parameters; 35, 36; 36, identifier:i; 37, block; 37, 38; 37, 77; 37, 86; 37, 93; 37, 100; 37, 107; 38, if_statement; 38, 39; 38, 40; 39, identifier:args; 40, block; 40, 41; 40, 50; 40, 59; 40, 68; 41, if_statement; 41, 42; 41, 47; 42, comparison_operator:==; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:i; 45, identifier:intent; 46, string:'in'; 47, block; 47, 48; 48, return_statement; 48, 49; 49, string:'b'; 50, if_statement; 50, 51; 50, 56; 51, comparison_operator:==; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:i; 54, identifier:intent; 55, string:'inout'; 56, block; 56, 57; 57, return_statement; 57, 58; 58, string:'c'; 59, if_statement; 59, 60; 59, 65; 60, comparison_operator:==; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:i; 63, identifier:intent; 64, string:'out'; 65, block; 65, 66; 66, return_statement; 66, 67; 67, string:'d'; 68, if_statement; 68, 69; 68, 74; 69, comparison_operator:==; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:i; 72, identifier:intent; 73, string:''; 74, block; 74, 75; 75, return_statement; 75, 76; 76, string:'e'; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:perm; 80, call; 80, 81; 80, 82; 81, identifier:getattr; 82, argument_list; 82, 83; 82, 84; 82, 85; 83, identifier:i; 84, string:'permission'; 85, string:''; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:==; 87, 88; 87, 89; 88, identifier:perm; 89, string:'public'; 90, block; 90, 91; 91, return_statement; 91, 92; 92, string:'b'; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:==; 94, 95; 94, 96; 95, identifier:perm; 96, string:'protected'; 97, block; 97, 98; 98, return_statement; 98, 99; 99, string:'c'; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:==; 101, 102; 101, 103; 102, identifier:perm; 103, string:'private'; 104, block; 104, 105; 105, return_statement; 105, 106; 106, string:'d'; 107, return_statement; 107, 108; 108, string:'a'; 109, function_definition; 109, 110; 109, 111; 109, 113; 110, function_name:permission_alpha; 111, parameters; 111, 112; 112, identifier:i; 113, block; 113, 114; 114, return_statement; 114, 115; 115, binary_operator:+; 115, 116; 115, 122; 116, binary_operator:+; 116, 117; 116, 121; 117, call; 117, 118; 117, 119; 118, identifier:permission; 119, argument_list; 119, 120; 120, identifier:i; 121, string:'-'; 122, attribute; 122, 123; 122, 124; 123, identifier:i; 124, identifier:name; 125, function_definition; 125, 126; 125, 127; 125, 129; 126, function_name:itype; 127, parameters; 127, 128; 128, identifier:i; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 136; 130, 207; 130, 248; 131, comparison_operator:==; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:i; 134, identifier:obj; 135, string:'variable'; 136, block; 136, 137; 136, 143; 136, 152; 136, 170; 136, 188; 136, 205; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:retstr; 140, attribute; 140, 141; 140, 142; 141, identifier:i; 142, identifier:vartype; 143, if_statement; 143, 144; 143, 147; 144, comparison_operator:==; 144, 145; 144, 146; 145, identifier:retstr; 146, string:'class'; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:retstr; 151, string:'type'; 152, if_statement; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:i; 155, identifier:kind; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:retstr; 160, binary_operator:+; 160, 161; 160, 164; 161, binary_operator:+; 161, 162; 161, 163; 162, identifier:retstr; 163, string:'-'; 164, call; 164, 165; 164, 166; 165, identifier:str; 166, argument_list; 166, 167; 167, attribute; 167, 168; 167, 169; 168, identifier:i; 169, identifier:kind; 170, if_statement; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:i; 173, identifier:strlen; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:retstr; 178, binary_operator:+; 178, 179; 178, 182; 179, binary_operator:+; 179, 180; 179, 181; 180, identifier:retstr; 181, string:'-'; 182, call; 182, 183; 182, 184; 183, identifier:str; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:i; 187, identifier:strlen; 188, if_statement; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:i; 191, identifier:proto; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:retstr; 196, binary_operator:+; 196, 197; 196, 200; 197, binary_operator:+; 197, 198; 197, 199; 198, identifier:retstr; 199, string:'-'; 200, subscript; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:i; 203, identifier:proto; 204, integer:0; 205, return_statement; 205, 206; 206, identifier:retstr; 207, elif_clause; 207, 208; 207, 213; 208, comparison_operator:==; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:i; 211, identifier:obj; 212, string:'proc'; 213, block; 213, 214; 214, if_statement; 214, 215; 214, 220; 214, 229; 215, comparison_operator:!=; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:i; 218, identifier:proctype; 219, string:'Function'; 220, block; 220, 221; 221, return_statement; 221, 222; 222, call; 222, 223; 222, 228; 223, attribute; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:i; 226, identifier:proctype; 227, identifier:lower; 228, argument_list; 229, else_clause; 229, 230; 230, block; 230, 231; 231, return_statement; 231, 232; 232, binary_operator:+; 232, 233; 232, 242; 233, binary_operator:+; 233, 234; 233, 241; 234, call; 234, 235; 234, 240; 235, attribute; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:i; 238, identifier:proctype; 239, identifier:lower; 240, argument_list; 241, string:'-'; 242, call; 242, 243; 242, 244; 243, identifier:itype; 244, argument_list; 244, 245; 245, attribute; 245, 246; 245, 247; 246, identifier:i; 247, identifier:retvar; 248, else_clause; 248, 249; 249, block; 249, 250; 250, return_statement; 250, 251; 251, attribute; 251, 252; 251, 253; 252, identifier:i; 253, identifier:obj; 254, function_definition; 254, 255; 254, 256; 254, 258; 255, function_name:itype_alpha; 256, parameters; 256, 257; 257, identifier:i; 258, block; 258, 259; 259, return_statement; 259, 260; 260, binary_operator:+; 260, 261; 260, 267; 261, binary_operator:+; 261, 262; 261, 266; 262, call; 262, 263; 262, 264; 263, identifier:itype; 264, argument_list; 264, 265; 265, identifier:i; 266, string:'-'; 267, attribute; 267, 268; 267, 269; 268, identifier:i; 269, identifier:name; 270, if_statement; 270, 271; 270, 282; 270, 292; 270, 314; 270, 336; 270, 358; 271, comparison_operator:==; 271, 272; 271, 281; 272, call; 272, 273; 272, 280; 273, attribute; 273, 274; 273, 279; 274, subscript; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:self; 277, identifier:settings; 278, string:'sort'; 279, identifier:lower; 280, argument_list; 281, string:'alpha'; 282, block; 282, 283; 283, expression_statement; 283, 284; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:items; 287, identifier:sort; 288, argument_list; 288, 289; 289, keyword_argument; 289, 290; 289, 291; 290, identifier:key; 291, identifier:alpha; 292, elif_clause; 292, 293; 292, 304; 293, comparison_operator:==; 293, 294; 293, 303; 294, call; 294, 295; 294, 302; 295, attribute; 295, 296; 295, 301; 296, subscript; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:self; 299, identifier:settings; 300, string:'sort'; 301, identifier:lower; 302, argument_list; 303, string:'permission'; 304, block; 304, 305; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:items; 309, identifier:sort; 310, argument_list; 310, 311; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:key; 313, identifier:permission; 314, elif_clause; 314, 315; 314, 326; 315, comparison_operator:==; 315, 316; 315, 325; 316, call; 316, 317; 316, 324; 317, attribute; 317, 318; 317, 323; 318, subscript; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:settings; 322, string:'sort'; 323, identifier:lower; 324, argument_list; 325, string:'permission-alpha'; 326, block; 326, 327; 327, expression_statement; 327, 328; 328, call; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:items; 331, identifier:sort; 332, argument_list; 332, 333; 333, keyword_argument; 333, 334; 333, 335; 334, identifier:key; 335, identifier:permission_alpha; 336, elif_clause; 336, 337; 336, 348; 337, comparison_operator:==; 337, 338; 337, 347; 338, call; 338, 339; 338, 346; 339, attribute; 339, 340; 339, 345; 340, subscript; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:self; 343, identifier:settings; 344, string:'sort'; 345, identifier:lower; 346, argument_list; 347, string:'type'; 348, block; 348, 349; 349, expression_statement; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:items; 353, identifier:sort; 354, argument_list; 354, 355; 355, keyword_argument; 355, 356; 355, 357; 356, identifier:key; 357, identifier:itype; 358, elif_clause; 358, 359; 358, 370; 359, comparison_operator:==; 359, 360; 359, 369; 360, call; 360, 361; 360, 368; 361, attribute; 361, 362; 361, 367; 362, subscript; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:self; 365, identifier:settings; 366, string:'sort'; 367, identifier:lower; 368, argument_list; 369, string:'type-alpha'; 370, block; 370, 371; 371, expression_statement; 371, 372; 372, call; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:items; 375, identifier:sort; 376, argument_list; 376, 377; 377, keyword_argument; 377, 378; 377, 379; 378, identifier:key; 379, identifier:itype_alpha | def sort_items(self,items,args=False):
if self.settings['sort'].lower() == 'src': return
def alpha(i):
return i.name
def permission(i):
if args:
if i.intent == 'in': return 'b'
if i.intent == 'inout': return 'c'
if i.intent == 'out': return 'd'
if i.intent == '': return 'e'
perm = getattr(i, 'permission', '')
if perm == 'public': return 'b'
if perm == 'protected': return 'c'
if perm == 'private': return 'd'
return 'a'
def permission_alpha(i):
return permission(i) + '-' + i.name
def itype(i):
if i.obj == 'variable':
retstr = i.vartype
if retstr == 'class': retstr = 'type'
if i.kind: retstr = retstr + '-' + str(i.kind)
if i.strlen: retstr = retstr + '-' + str(i.strlen)
if i.proto:
retstr = retstr + '-' + i.proto[0]
return retstr
elif i.obj == 'proc':
if i.proctype != 'Function':
return i.proctype.lower()
else:
return i.proctype.lower() + '-' + itype(i.retvar)
else:
return i.obj
def itype_alpha(i):
return itype(i) + '-' + i.name
if self.settings['sort'].lower() == 'alpha':
items.sort(key=alpha)
elif self.settings['sort'].lower() == 'permission':
items.sort(key=permission)
elif self.settings['sort'].lower() == 'permission-alpha':
items.sort(key=permission_alpha)
elif self.settings['sort'].lower() == 'type':
items.sort(key=itype)
elif self.settings['sort'].lower() == 'type-alpha':
items.sort(key=itype_alpha) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 23; 5, 38; 5, 53; 5, 68; 5, 83; 5, 98; 5, 113; 5, 128; 5, 143; 5, 158; 5, 173; 5, 188; 5, 203; 5, 218; 6, expression_statement; 6, 7; 7, string:'''
Sorts components of the object.
'''; 8, if_statement; 8, 9; 8, 14; 9, call; 9, 10; 9, 11; 10, identifier:hasattr; 11, argument_list; 11, 12; 11, 13; 12, identifier:self; 13, string:'variables'; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:sort_items; 18, argument_list; 18, 19; 18, 20; 19, identifier:self; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:variables; 23, if_statement; 23, 24; 23, 29; 24, call; 24, 25; 24, 26; 25, identifier:hasattr; 26, argument_list; 26, 27; 26, 28; 27, identifier:self; 28, string:'modules'; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:sort_items; 33, argument_list; 33, 34; 33, 35; 34, identifier:self; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:modules; 38, if_statement; 38, 39; 38, 44; 39, call; 39, 40; 39, 41; 40, identifier:hasattr; 41, argument_list; 41, 42; 41, 43; 42, identifier:self; 43, string:'submodules'; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:sort_items; 48, argument_list; 48, 49; 48, 50; 49, identifier:self; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:submodules; 53, if_statement; 53, 54; 53, 59; 54, call; 54, 55; 54, 56; 55, identifier:hasattr; 56, argument_list; 56, 57; 56, 58; 57, identifier:self; 58, string:'common'; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:sort_items; 63, argument_list; 63, 64; 63, 65; 64, identifier:self; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:common; 68, if_statement; 68, 69; 68, 74; 69, call; 69, 70; 69, 71; 70, identifier:hasattr; 71, argument_list; 71, 72; 71, 73; 72, identifier:self; 73, string:'subroutines'; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:sort_items; 78, argument_list; 78, 79; 78, 80; 79, identifier:self; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:subroutines; 83, if_statement; 83, 84; 83, 89; 84, call; 84, 85; 84, 86; 85, identifier:hasattr; 86, argument_list; 86, 87; 86, 88; 87, identifier:self; 88, string:'modprocedures'; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:sort_items; 93, argument_list; 93, 94; 93, 95; 94, identifier:self; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:modprocedures; 98, if_statement; 98, 99; 98, 104; 99, call; 99, 100; 99, 101; 100, identifier:hasattr; 101, argument_list; 101, 102; 101, 103; 102, identifier:self; 103, string:'functions'; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 108; 107, identifier:sort_items; 108, argument_list; 108, 109; 108, 110; 109, identifier:self; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:functions; 113, if_statement; 113, 114; 113, 119; 114, call; 114, 115; 114, 116; 115, identifier:hasattr; 116, argument_list; 116, 117; 116, 118; 117, identifier:self; 118, string:'interfaces'; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:sort_items; 123, argument_list; 123, 124; 123, 125; 124, identifier:self; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:interfaces; 128, if_statement; 128, 129; 128, 134; 129, call; 129, 130; 129, 131; 130, identifier:hasattr; 131, argument_list; 131, 132; 131, 133; 132, identifier:self; 133, string:'absinterfaces'; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:sort_items; 138, argument_list; 138, 139; 138, 140; 139, identifier:self; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:absinterfaces; 143, if_statement; 143, 144; 143, 149; 144, call; 144, 145; 144, 146; 145, identifier:hasattr; 146, argument_list; 146, 147; 146, 148; 147, identifier:self; 148, string:'types'; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:sort_items; 153, argument_list; 153, 154; 153, 155; 154, identifier:self; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:types; 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:self; 163, string:'programs'; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:sort_items; 168, argument_list; 168, 169; 168, 170; 169, identifier:self; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:programs; 173, if_statement; 173, 174; 173, 179; 174, call; 174, 175; 174, 176; 175, identifier:hasattr; 176, argument_list; 176, 177; 176, 178; 177, identifier:self; 178, string:'blockdata'; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:sort_items; 183, argument_list; 183, 184; 183, 185; 184, identifier:self; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:blockdata; 188, if_statement; 188, 189; 188, 194; 189, call; 189, 190; 189, 191; 190, identifier:hasattr; 191, argument_list; 191, 192; 191, 193; 192, identifier:self; 193, string:'boundprocs'; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:sort_items; 198, argument_list; 198, 199; 198, 200; 199, identifier:self; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:boundprocs; 203, if_statement; 203, 204; 203, 209; 204, call; 204, 205; 204, 206; 205, identifier:hasattr; 206, argument_list; 206, 207; 206, 208; 207, identifier:self; 208, string:'finalprocs'; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:sort_items; 213, argument_list; 213, 214; 213, 215; 214, identifier:self; 215, attribute; 215, 216; 215, 217; 216, identifier:self; 217, identifier:finalprocs; 218, if_statement; 218, 219; 218, 224; 219, call; 219, 220; 219, 221; 220, identifier:hasattr; 221, argument_list; 221, 222; 221, 223; 222, identifier:self; 223, string:'args'; 224, block; 224, 225; 225, pass_statement | def sort(self):
'''
Sorts components of the object.
'''
if hasattr(self,'variables'):
sort_items(self,self.variables)
if hasattr(self,'modules'):
sort_items(self,self.modules)
if hasattr(self,'submodules'):
sort_items(self,self.submodules)
if hasattr(self,'common'):
sort_items(self,self.common)
if hasattr(self,'subroutines'):
sort_items(self,self.subroutines)
if hasattr(self,'modprocedures'):
sort_items(self,self.modprocedures)
if hasattr(self,'functions'):
sort_items(self,self.functions)
if hasattr(self,'interfaces'):
sort_items(self,self.interfaces)
if hasattr(self,'absinterfaces'):
sort_items(self,self.absinterfaces)
if hasattr(self,'types'):
sort_items(self,self.types)
if hasattr(self,'programs'):
sort_items(self,self.programs)
if hasattr(self,'blockdata'):
sort_items(self,self.blockdata)
if hasattr(self,'boundprocs'):
sort_items(self,self.boundprocs)
if hasattr(self,'finalprocs'):
sort_items(self,self.finalprocs)
if hasattr(self,'args'):
pass |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_catalogue_chronologically; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 16; 5, 25; 5, 48; 6, expression_statement; 6, 7; 7, string:'''
Sorts the catalogue into chronological order
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:dec_time; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:get_decimal_time; 15, argument_list; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:idx; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:argsort; 23, argument_list; 23, 24; 24, identifier:dec_time; 25, if_statement; 25, 26; 25, 46; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:all; 30, argument_list; 30, 31; 31, comparison_operator:>; 31, 32; 31, 45; 32, parenthesized_expression; 32, 33; 33, binary_operator:-; 33, 34; 33, 39; 34, subscript; 34, 35; 34, 36; 35, identifier:idx; 36, slice; 36, 37; 36, 38; 37, integer:1; 38, colon; 39, subscript; 39, 40; 39, 41; 40, identifier:idx; 41, slice; 41, 42; 41, 43; 42, colon; 43, unary_operator:-; 43, 44; 44, integer:1; 45, float:0.; 46, block; 46, 47; 47, return_statement; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:select_catalogue_events; 53, argument_list; 53, 54; 54, identifier:idx | def sort_catalogue_chronologically(self):
'''
Sorts the catalogue into chronological order
'''
dec_time = self.get_decimal_time()
idx = np.argsort(dec_time)
if np.all((idx[1:] - idx[:-1]) > 0.):
return
self.select_catalogue_events(idx) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:cmp_mat; 3, parameters; 3, 4; 3, 5; 4, identifier:a; 5, identifier:b; 6, block; 6, 7; 6, 11; 6, 46; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:c; 10, integer:0; 11, for_statement; 11, 12; 11, 15; 11, 24; 12, pattern_list; 12, 13; 12, 14; 13, identifier:x; 14, identifier:y; 15, call; 15, 16; 15, 17; 16, identifier:zip; 17, argument_list; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:a; 20, identifier:flat; 21, attribute; 21, 22; 21, 23; 22, identifier:b; 23, identifier:flat; 24, block; 24, 25; 24, 39; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:c; 28, call; 28, 29; 28, 30; 29, identifier:cmp; 30, argument_list; 30, 31; 30, 35; 31, call; 31, 32; 31, 33; 32, identifier:abs; 33, argument_list; 33, 34; 34, identifier:x; 35, call; 35, 36; 35, 37; 36, identifier:abs; 37, argument_list; 37, 38; 38, identifier:y; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:!=; 40, 41; 40, 42; 41, identifier:c; 42, integer:0; 43, block; 43, 44; 44, return_statement; 44, 45; 45, identifier:c; 46, return_statement; 46, 47; 47, identifier:c | def cmp_mat(a, b):
c = 0
for x, y in zip(a.flat, b.flat):
c = cmp(abs(x), abs(y))
if c != 0:
return c
return c |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_dicoms; 3, parameters; 3, 4; 4, identifier:dicoms; 5, block; 5, 6; 5, 24; 5, 42; 5, 60; 5, 82; 5, 104; 5, 126; 5, 137; 5, 148; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:dicom_input_sorted_x; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 13; 12, identifier:dicoms; 13, keyword_argument; 13, 14; 13, 15; 14, identifier:key; 15, lambda; 15, 16; 15, 18; 16, lambda_parameters; 16, 17; 17, identifier:x; 18, parenthesized_expression; 18, 19; 19, subscript; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:x; 22, identifier:ImagePositionPatient; 23, integer:0; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:dicom_input_sorted_y; 27, call; 27, 28; 27, 29; 28, identifier:sorted; 29, argument_list; 29, 30; 29, 31; 30, identifier:dicoms; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:key; 33, lambda; 33, 34; 33, 36; 34, lambda_parameters; 34, 35; 35, identifier:x; 36, parenthesized_expression; 36, 37; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:x; 40, identifier:ImagePositionPatient; 41, integer:1; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:dicom_input_sorted_z; 45, call; 45, 46; 45, 47; 46, identifier:sorted; 47, argument_list; 47, 48; 47, 49; 48, identifier:dicoms; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:key; 51, lambda; 51, 52; 51, 54; 52, lambda_parameters; 52, 53; 53, identifier:x; 54, parenthesized_expression; 54, 55; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:x; 58, identifier:ImagePositionPatient; 59, integer:2; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:diff_x; 63, call; 63, 64; 63, 65; 64, identifier:abs; 65, argument_list; 65, 66; 66, binary_operator:-; 66, 67; 66, 75; 67, subscript; 67, 68; 67, 74; 68, attribute; 68, 69; 68, 73; 69, subscript; 69, 70; 69, 71; 70, identifier:dicom_input_sorted_x; 71, unary_operator:-; 71, 72; 72, integer:1; 73, identifier:ImagePositionPatient; 74, integer:0; 75, subscript; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:dicom_input_sorted_x; 79, integer:0; 80, identifier:ImagePositionPatient; 81, integer:0; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:diff_y; 85, call; 85, 86; 85, 87; 86, identifier:abs; 87, argument_list; 87, 88; 88, binary_operator:-; 88, 89; 88, 97; 89, subscript; 89, 90; 89, 96; 90, attribute; 90, 91; 90, 95; 91, subscript; 91, 92; 91, 93; 92, identifier:dicom_input_sorted_y; 93, unary_operator:-; 93, 94; 94, integer:1; 95, identifier:ImagePositionPatient; 96, integer:1; 97, subscript; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:dicom_input_sorted_y; 101, integer:0; 102, identifier:ImagePositionPatient; 103, integer:1; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:diff_z; 107, call; 107, 108; 107, 109; 108, identifier:abs; 109, argument_list; 109, 110; 110, binary_operator:-; 110, 111; 110, 119; 111, subscript; 111, 112; 111, 118; 112, attribute; 112, 113; 112, 117; 113, subscript; 113, 114; 113, 115; 114, identifier:dicom_input_sorted_z; 115, unary_operator:-; 115, 116; 116, integer:1; 117, identifier:ImagePositionPatient; 118, integer:2; 119, subscript; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:dicom_input_sorted_z; 123, integer:0; 124, identifier:ImagePositionPatient; 125, integer:2; 126, if_statement; 126, 127; 126, 134; 127, boolean_operator:and; 127, 128; 127, 131; 128, comparison_operator:>=; 128, 129; 128, 130; 129, identifier:diff_x; 130, identifier:diff_y; 131, comparison_operator:>=; 131, 132; 131, 133; 132, identifier:diff_x; 133, identifier:diff_z; 134, block; 134, 135; 135, return_statement; 135, 136; 136, identifier:dicom_input_sorted_x; 137, if_statement; 137, 138; 137, 145; 138, boolean_operator:and; 138, 139; 138, 142; 139, comparison_operator:>=; 139, 140; 139, 141; 140, identifier:diff_y; 141, identifier:diff_x; 142, comparison_operator:>=; 142, 143; 142, 144; 143, identifier:diff_y; 144, identifier:diff_z; 145, block; 145, 146; 146, return_statement; 146, 147; 147, identifier:dicom_input_sorted_y; 148, if_statement; 148, 149; 148, 156; 149, boolean_operator:and; 149, 150; 149, 153; 150, comparison_operator:>=; 150, 151; 150, 152; 151, identifier:diff_z; 152, identifier:diff_x; 153, comparison_operator:>=; 153, 154; 153, 155; 154, identifier:diff_z; 155, identifier:diff_y; 156, block; 156, 157; 157, return_statement; 157, 158; 158, identifier:dicom_input_sorted_z | def sort_dicoms(dicoms):
dicom_input_sorted_x = sorted(dicoms, key=lambda x: (x.ImagePositionPatient[0]))
dicom_input_sorted_y = sorted(dicoms, key=lambda x: (x.ImagePositionPatient[1]))
dicom_input_sorted_z = sorted(dicoms, key=lambda x: (x.ImagePositionPatient[2]))
diff_x = abs(dicom_input_sorted_x[-1].ImagePositionPatient[0] - dicom_input_sorted_x[0].ImagePositionPatient[0])
diff_y = abs(dicom_input_sorted_y[-1].ImagePositionPatient[1] - dicom_input_sorted_y[0].ImagePositionPatient[1])
diff_z = abs(dicom_input_sorted_z[-1].ImagePositionPatient[2] - dicom_input_sorted_z[0].ImagePositionPatient[2])
if diff_x >= diff_y and diff_x >= diff_z:
return dicom_input_sorted_x
if diff_y >= diff_x and diff_y >= diff_z:
return dicom_input_sorted_y
if diff_z >= diff_x and diff_z >= diff_y:
return dicom_input_sorted_z |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_sorted_mosaics; 3, parameters; 3, 4; 4, identifier:dicom_input; 5, block; 5, 6; 5, 21; 5, 54; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sorted_mosaics; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 13; 12, identifier:dicom_input; 13, keyword_argument; 13, 14; 13, 15; 14, identifier:key; 15, lambda; 15, 16; 15, 18; 16, lambda_parameters; 16, 17; 17, identifier:x; 18, attribute; 18, 19; 18, 20; 19, identifier:x; 20, identifier:AcquisitionNumber; 21, for_statement; 21, 22; 21, 23; 21, 33; 22, identifier:index; 23, call; 23, 24; 23, 25; 24, identifier:range; 25, argument_list; 25, 26; 25, 27; 26, integer:0; 27, binary_operator:-; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:sorted_mosaics; 32, integer:1; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 48; 35, comparison_operator:>=; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:sorted_mosaics; 39, identifier:index; 40, identifier:AcquisitionNumber; 41, attribute; 41, 42; 41, 47; 42, subscript; 42, 43; 42, 44; 43, identifier:sorted_mosaics; 44, binary_operator:+; 44, 45; 44, 46; 45, identifier:index; 46, integer:1; 47, identifier:AcquisitionNumber; 48, block; 48, 49; 49, raise_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:ConversionValidationError; 52, argument_list; 52, 53; 53, string:"INCONSISTENT_ACQUISITION_NUMBERS"; 54, return_statement; 54, 55; 55, identifier:sorted_mosaics | def _get_sorted_mosaics(dicom_input):
sorted_mosaics = sorted(dicom_input, key=lambda x: x.AcquisitionNumber)
for index in range(0, len(sorted_mosaics) - 1):
if sorted_mosaics[index].AcquisitionNumber >= sorted_mosaics[index + 1].AcquisitionNumber:
raise ConversionValidationError("INCONSISTENT_ACQUISITION_NUMBERS")
return sorted_mosaics |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:relate_obs_ids_to_chosen_alts; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:obs_id_array; 5, identifier:alt_id_array; 6, identifier:choice_array; 7, block; 7, 8; 7, 12; 7, 63; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:chosen_alts_to_obs_ids; 11, dictionary; 12, for_statement; 12, 13; 12, 14; 12, 25; 13, identifier:alt_id; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:np; 17, identifier:sort; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:unique; 23, argument_list; 23, 24; 24, identifier:alt_id_array; 25, block; 25, 26; 25, 44; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 27, 30; 28, identifier:selection_condition; 29, line_continuation:\; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:np; 33, identifier:where; 34, argument_list; 34, 35; 35, binary_operator:&; 35, 36; 35, 40; 36, parenthesized_expression; 36, 37; 37, comparison_operator:==; 37, 38; 37, 39; 38, identifier:alt_id_array; 39, identifier:alt_id; 40, parenthesized_expression; 40, 41; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:choice_array; 43, integer:1; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 45, 50; 46, subscript; 46, 47; 46, 48; 47, identifier:chosen_alts_to_obs_ids; 48, identifier:alt_id; 49, line_continuation:\; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:np; 53, identifier:sort; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:np; 58, identifier:unique; 59, argument_list; 59, 60; 60, subscript; 60, 61; 60, 62; 61, identifier:obs_id_array; 62, identifier:selection_condition; 63, return_statement; 63, 64; 64, identifier:chosen_alts_to_obs_ids | def relate_obs_ids_to_chosen_alts(obs_id_array,
alt_id_array,
choice_array):
chosen_alts_to_obs_ids = {}
for alt_id in np.sort(np.unique(alt_id_array)):
selection_condition =\
np.where((alt_id_array == alt_id) & (choice_array == 1))
chosen_alts_to_obs_ids[alt_id] =\
np.sort(np.unique(obs_id_array[selection_condition]))
return chosen_alts_to_obs_ids |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:create_estimation_obj; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:model_obj; 5, identifier:init_vals; 6, default_parameter; 6, 7; 6, 8; 7, identifier:mappings; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:ridge; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:constrained_pos; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:weights; 17, None; 18, block; 18, 19; 18, 33; 18, 46; 18, 54; 18, 71; 18, 86; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 20, 23; 21, identifier:mapping_matrices; 22, line_continuation:\; 23, conditional_expression:if; 23, 24; 23, 29; 23, 32; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:model_obj; 27, identifier:get_mappings_for_fit; 28, argument_list; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:mappings; 31, None; 32, identifier:mappings; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:zero_vector; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:np; 39, identifier:zeros; 40, argument_list; 40, 41; 41, subscript; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:init_vals; 44, identifier:shape; 45, integer:0; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:internal_model_name; 49, subscript; 49, 50; 49, 51; 50, identifier:display_name_to_model_type; 51, attribute; 51, 52; 51, 53; 52, identifier:model_obj; 53, identifier:model_type; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 55, 60; 56, pattern_list; 56, 57; 56, 58; 57, identifier:estimator_class; 58, identifier:current_split_func; 59, line_continuation:\; 60, tuple; 60, 61; 60, 66; 61, subscript; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:model_type_to_resources; 64, identifier:internal_model_name; 65, string:'estimator'; 66, subscript; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:model_type_to_resources; 69, identifier:internal_model_name; 70, string:'split_func'; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:estimation_obj; 74, call; 74, 75; 74, 76; 75, identifier:estimator_class; 76, argument_list; 76, 77; 76, 78; 76, 79; 76, 80; 76, 81; 76, 82; 76, 83; 77, identifier:model_obj; 78, identifier:mapping_matrices; 79, identifier:ridge; 80, identifier:zero_vector; 81, identifier:current_split_func; 82, identifier:constrained_pos; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:weights; 85, identifier:weights; 86, return_statement; 86, 87; 87, identifier:estimation_obj | def create_estimation_obj(model_obj,
init_vals,
mappings=None,
ridge=None,
constrained_pos=None,
weights=None):
mapping_matrices =\
model_obj.get_mappings_for_fit() if mappings is None else mappings
zero_vector = np.zeros(init_vals.shape[0])
internal_model_name = display_name_to_model_type[model_obj.model_type]
estimator_class, current_split_func =\
(model_type_to_resources[internal_model_name]['estimator'],
model_type_to_resources[internal_model_name]['split_func'])
estimation_obj = estimator_class(model_obj,
mapping_matrices,
ridge,
zero_vector,
current_split_func,
constrained_pos,
weights=weights)
return estimation_obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sequence; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 110; 6, expression_statement; 6, 7; 7, string:'''
sort the points in the line with given option
'''; 8, if_statement; 8, 9; 8, 20; 9, parenthesized_expression; 9, 10; 10, comparison_operator:==; 10, 11; 10, 19; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, subscript; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:Points; 18, integer:0; 19, integer:2; 20, block; 20, 21; 21, if_statement; 21, 22; 21, 34; 21, 60; 21, 99; 22, parenthesized_expression; 22, 23; 23, boolean_operator:or; 23, 24; 23, 29; 24, comparison_operator:==; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:Sort; 28, string:'X'; 29, comparison_operator:==; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:Sort; 33, string:'x'; 34, block; 34, 35; 34, 51; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:Points; 41, identifier:sort; 42, argument_list; 42, 43; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:key; 45, lambda; 45, 46; 45, 48; 46, lambda_parameters; 46, 47; 47, identifier:x; 48, subscript; 48, 49; 48, 50; 49, identifier:x; 50, integer:0; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:order; 56, argument_list; 56, 57; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:Points; 60, elif_clause; 60, 61; 60, 73; 61, parenthesized_expression; 61, 62; 62, boolean_operator:or; 62, 63; 62, 68; 63, comparison_operator:==; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:Sort; 67, string:'Y'; 68, comparison_operator:==; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:Sort; 72, string:'y'; 73, block; 73, 74; 73, 90; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:Points; 80, identifier:sort; 81, argument_list; 81, 82; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:key; 84, lambda; 84, 85; 84, 87; 85, lambda_parameters; 85, 86; 86, identifier:x; 87, subscript; 87, 88; 87, 89; 88, identifier:x; 89, integer:1; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:order; 95, argument_list; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:Points; 99, else_clause; 99, 100; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:order; 106, argument_list; 106, 107; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:Points; 110, if_statement; 110, 111; 110, 122; 111, parenthesized_expression; 111, 112; 112, comparison_operator:==; 112, 113; 112, 121; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, subscript; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:Points; 120, integer:0; 121, integer:3; 122, block; 122, 123; 123, if_statement; 123, 124; 123, 136; 123, 162; 123, 201; 123, 240; 124, parenthesized_expression; 124, 125; 125, boolean_operator:or; 125, 126; 125, 131; 126, comparison_operator:==; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:Sort; 130, string:'X'; 131, comparison_operator:==; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:Sort; 135, string:'x'; 136, block; 136, 137; 136, 153; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 144; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:Points; 143, identifier:sort; 144, argument_list; 144, 145; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:key; 147, lambda; 147, 148; 147, 150; 148, lambda_parameters; 148, 149; 149, identifier:x; 150, subscript; 150, 151; 150, 152; 151, identifier:x; 152, integer:0; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:order; 158, argument_list; 158, 159; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:Points; 162, elif_clause; 162, 163; 162, 175; 163, parenthesized_expression; 163, 164; 164, boolean_operator:or; 164, 165; 164, 170; 165, comparison_operator:==; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:Sort; 169, string:'Y'; 170, comparison_operator:==; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:Sort; 174, string:'y'; 175, block; 175, 176; 175, 192; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:Points; 182, identifier:sort; 183, argument_list; 183, 184; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:key; 186, lambda; 186, 187; 186, 189; 187, lambda_parameters; 187, 188; 188, identifier:x; 189, subscript; 189, 190; 189, 191; 190, identifier:x; 191, integer:1; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:order; 197, argument_list; 197, 198; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:Points; 201, elif_clause; 201, 202; 201, 214; 202, parenthesized_expression; 202, 203; 203, boolean_operator:or; 203, 204; 203, 209; 204, comparison_operator:==; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:Sort; 208, string:'Z'; 209, comparison_operator:==; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:self; 212, identifier:Sort; 213, string:'Z'; 214, block; 214, 215; 214, 231; 215, expression_statement; 215, 216; 216, call; 216, 217; 216, 222; 217, attribute; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:Points; 221, identifier:sort; 222, argument_list; 222, 223; 223, keyword_argument; 223, 224; 223, 225; 224, identifier:key; 225, lambda; 225, 226; 225, 228; 226, lambda_parameters; 226, 227; 227, identifier:x; 228, subscript; 228, 229; 228, 230; 229, identifier:x; 230, integer:2; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:self; 235, identifier:order; 236, argument_list; 236, 237; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:Points; 240, else_clause; 240, 241; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:self; 246, identifier:order; 247, argument_list; 247, 248; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:Points | def sequence(self):
'''
sort the points in the line with given option
'''
if (len(self.Points[0]) == 2):
if (self.Sort == 'X' or self.Sort == 'x'):
self.Points.sort(key=lambda x: x[0])
self.order(self.Points)
elif (self.Sort == 'Y' or self.Sort == 'y'):
self.Points.sort(key=lambda x: x[1])
self.order(self.Points)
else:
self.order(self.Points)
if (len(self.Points[0]) == 3):
if (self.Sort == 'X' or self.Sort == 'x'):
self.Points.sort(key=lambda x: x[0])
self.order(self.Points)
elif (self.Sort == 'Y' or self.Sort == 'y'):
self.Points.sort(key=lambda x: x[1])
self.order(self.Points)
elif (self.Sort == 'Z' or self.Sort == 'Z'):
self.Points.sort(key=lambda x: x[2])
self.order(self.Points)
else:
self.order(self.Points) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_pos; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:key; 6, block; 6, 7; 6, 24; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:p; 10, call; 10, 11; 10, 12; 11, identifier:bisect; 12, argument_list; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:runtime; 17, identifier:_keys; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:hashi; 22, argument_list; 22, 23; 23, identifier:key; 24, if_statement; 24, 25; 24, 35; 24, 38; 25, comparison_operator:==; 25, 26; 25, 27; 26, identifier:p; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:runtime; 34, identifier:_keys; 35, block; 35, 36; 36, return_statement; 36, 37; 37, integer:0; 38, else_clause; 38, 39; 39, block; 39, 40; 40, return_statement; 40, 41; 41, identifier:p | def _get_pos(self, key):
p = bisect(self.runtime._keys, self.hashi(key))
if p == len(self.runtime._keys):
return 0
else:
return p |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:lapmod; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 3, 14; 4, identifier:n; 5, identifier:cc; 6, identifier:ii; 7, identifier:kk; 8, default_parameter; 8, 9; 8, 10; 9, identifier:fast; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:return_cost; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:fp_version; 16, identifier:FP_DYNAMIC; 17, block; 17, 18; 17, 26; 17, 255; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:check_cost; 21, argument_list; 21, 22; 21, 23; 21, 24; 21, 25; 22, identifier:n; 23, identifier:cc; 24, identifier:ii; 25, identifier:kk; 26, if_statement; 26, 27; 26, 30; 26, 46; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:fast; 29, True; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, pattern_list; 33, 34; 33, 35; 34, identifier:x; 35, identifier:y; 36, call; 36, 37; 36, 38; 37, identifier:_lapmod; 38, argument_list; 38, 39; 38, 40; 38, 41; 38, 42; 38, 43; 39, identifier:n; 40, identifier:cc; 41, identifier:ii; 42, identifier:kk; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:fp_version; 45, identifier:fp_version; 46, else_clause; 46, 47; 47, block; 47, 48; 47, 62; 47, 76; 47, 90; 47, 105; 47, 120; 47, 135; 47, 150; 47, 164; 47, 192; 47, 242; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:cc; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:ascontiguousarray; 55, argument_list; 55, 56; 55, 57; 56, identifier:cc; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:dtype; 59, attribute; 59, 60; 59, 61; 60, identifier:np; 61, identifier:float64; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:ii; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:np; 68, identifier:ascontiguousarray; 69, argument_list; 69, 70; 69, 71; 70, identifier:ii; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:dtype; 73, attribute; 73, 74; 73, 75; 74, identifier:np; 75, identifier:int32; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:kk; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:ascontiguousarray; 83, argument_list; 83, 84; 83, 85; 84, identifier:kk; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:dtype; 87, attribute; 87, 88; 87, 89; 88, identifier:np; 89, identifier:int32; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:x; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:empty; 97, argument_list; 97, 98; 97, 100; 98, tuple; 98, 99; 99, identifier:n; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:dtype; 102, attribute; 102, 103; 102, 104; 103, identifier:np; 104, identifier:int32; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:y; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:np; 111, identifier:empty; 112, argument_list; 112, 113; 112, 115; 113, tuple; 113, 114; 114, identifier:n; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:dtype; 117, attribute; 117, 118; 117, 119; 118, identifier:np; 119, identifier:int32; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:v; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:np; 126, identifier:empty; 127, argument_list; 127, 128; 127, 130; 128, tuple; 128, 129; 129, identifier:n; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:dtype; 132, attribute; 132, 133; 132, 134; 133, identifier:np; 134, identifier:float64; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:free_rows; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:np; 141, identifier:empty; 142, argument_list; 142, 143; 142, 145; 143, tuple; 143, 144; 144, identifier:n; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:dtype; 147, attribute; 147, 148; 147, 149; 148, identifier:np; 149, identifier:int32; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:n_free_rows; 153, call; 153, 154; 153, 155; 154, identifier:_pycrrt; 155, argument_list; 155, 156; 155, 157; 155, 158; 155, 159; 155, 160; 155, 161; 155, 162; 155, 163; 156, identifier:n; 157, identifier:cc; 158, identifier:ii; 159, identifier:kk; 160, identifier:free_rows; 161, identifier:x; 162, identifier:y; 163, identifier:v; 164, if_statement; 164, 165; 164, 168; 165, comparison_operator:==; 165, 166; 165, 167; 166, identifier:n_free_rows; 167, integer:0; 168, block; 168, 169; 169, if_statement; 169, 170; 169, 173; 169, 186; 170, comparison_operator:is; 170, 171; 170, 172; 171, identifier:return_cost; 172, True; 173, block; 173, 174; 174, return_statement; 174, 175; 175, expression_list; 175, 176; 175, 184; 175, 185; 176, call; 176, 177; 176, 178; 177, identifier:get_cost; 178, argument_list; 178, 179; 178, 180; 178, 181; 178, 182; 178, 183; 179, identifier:n; 180, identifier:cc; 181, identifier:ii; 182, identifier:kk; 183, identifier:x; 184, identifier:x; 185, identifier:y; 186, else_clause; 186, 187; 187, block; 187, 188; 188, return_statement; 188, 189; 189, expression_list; 189, 190; 189, 191; 190, identifier:x; 191, identifier:y; 192, for_statement; 192, 193; 192, 194; 192, 198; 193, identifier:it; 194, call; 194, 195; 194, 196; 195, identifier:range; 196, argument_list; 196, 197; 197, integer:2; 198, block; 198, 199; 198, 214; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:n_free_rows; 202, call; 202, 203; 202, 204; 203, identifier:_pyarr; 204, argument_list; 204, 205; 204, 206; 204, 207; 204, 208; 204, 209; 204, 210; 204, 211; 204, 212; 204, 213; 205, identifier:n; 206, identifier:cc; 207, identifier:ii; 208, identifier:kk; 209, identifier:n_free_rows; 210, identifier:free_rows; 211, identifier:x; 212, identifier:y; 213, identifier:v; 214, if_statement; 214, 215; 214, 218; 215, comparison_operator:==; 215, 216; 215, 217; 216, identifier:n_free_rows; 217, integer:0; 218, block; 218, 219; 219, if_statement; 219, 220; 219, 223; 219, 236; 220, comparison_operator:is; 220, 221; 220, 222; 221, identifier:return_cost; 222, True; 223, block; 223, 224; 224, return_statement; 224, 225; 225, expression_list; 225, 226; 225, 234; 225, 235; 226, call; 226, 227; 226, 228; 227, identifier:get_cost; 228, argument_list; 228, 229; 228, 230; 228, 231; 228, 232; 228, 233; 229, identifier:n; 230, identifier:cc; 231, identifier:ii; 232, identifier:kk; 233, identifier:x; 234, identifier:x; 235, identifier:y; 236, else_clause; 236, 237; 237, block; 237, 238; 238, return_statement; 238, 239; 239, expression_list; 239, 240; 239, 241; 240, identifier:x; 241, identifier:y; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 245; 244, identifier:_pya; 245, argument_list; 245, 246; 245, 247; 245, 248; 245, 249; 245, 250; 245, 251; 245, 252; 245, 253; 245, 254; 246, identifier:n; 247, identifier:cc; 248, identifier:ii; 249, identifier:kk; 250, identifier:n_free_rows; 251, identifier:free_rows; 252, identifier:x; 253, identifier:y; 254, identifier:v; 255, if_statement; 255, 256; 255, 259; 255, 272; 256, comparison_operator:is; 256, 257; 256, 258; 257, identifier:return_cost; 258, True; 259, block; 259, 260; 260, return_statement; 260, 261; 261, expression_list; 261, 262; 261, 270; 261, 271; 262, call; 262, 263; 262, 264; 263, identifier:get_cost; 264, argument_list; 264, 265; 264, 266; 264, 267; 264, 268; 264, 269; 265, identifier:n; 266, identifier:cc; 267, identifier:ii; 268, identifier:kk; 269, identifier:x; 270, identifier:x; 271, identifier:y; 272, else_clause; 272, 273; 273, block; 273, 274; 274, return_statement; 274, 275; 275, expression_list; 275, 276; 275, 277; 276, identifier:x; 277, identifier:y | def lapmod(n, cc, ii, kk, fast=True, return_cost=True,
fp_version=FP_DYNAMIC):
check_cost(n, cc, ii, kk)
if fast is True:
x, y = _lapmod(n, cc, ii, kk, fp_version=fp_version)
else:
cc = np.ascontiguousarray(cc, dtype=np.float64)
ii = np.ascontiguousarray(ii, dtype=np.int32)
kk = np.ascontiguousarray(kk, dtype=np.int32)
x = np.empty((n,), dtype=np.int32)
y = np.empty((n,), dtype=np.int32)
v = np.empty((n,), dtype=np.float64)
free_rows = np.empty((n,), dtype=np.int32)
n_free_rows = _pycrrt(n, cc, ii, kk, free_rows, x, y, v)
if n_free_rows == 0:
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y
for it in range(2):
n_free_rows = _pyarr(
n, cc, ii, kk, n_free_rows, free_rows, x, y, v)
if n_free_rows == 0:
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y
_pya(n, cc, ii, kk, n_free_rows, free_rows, x, y, v)
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_items; 3, parameters; 3, 4; 4, identifier:items; 5, block; 5, 6; 5, 10; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sorted_items; 9, dictionary; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:item; 12, identifier:items; 13, block; 13, 14; 13, 23; 13, 39; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:category; 17, call; 17, 18; 17, 19; 18, identifier:lookup; 19, argument_list; 19, 20; 19, 21; 19, 22; 20, identifier:item; 21, string:'itemCategory'; 22, string:'categoryCode'; 23, if_statement; 23, 24; 23, 32; 24, comparison_operator:is; 24, 25; 24, 31; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:sorted_items; 28, identifier:get; 29, argument_list; 29, 30; 30, identifier:category; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:sorted_items; 37, identifier:category; 38, list:[]; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:sorted_items; 44, identifier:category; 45, identifier:append; 46, argument_list; 46, 47; 47, identifier:item; 48, return_statement; 48, 49; 49, identifier:sorted_items | def sort_items(items):
sorted_items = {}
for item in items:
category = lookup(item, 'itemCategory', 'categoryCode')
if sorted_items.get(category) is None:
sorted_items[category] = []
sorted_items[category].append(item)
return sorted_items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_user_permissions; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:user_id; 6, block; 6, 7; 6, 20; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:permissions; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:user_service; 15, identifier:getPermissions; 16, argument_list; 16, 17; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:id; 19, identifier:user_id; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:sorted; 23, argument_list; 23, 24; 23, 25; 24, identifier:permissions; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:key; 27, call; 27, 28; 27, 29; 28, identifier:itemgetter; 29, argument_list; 29, 30; 30, string:'keyName' | def get_user_permissions(self, user_id):
permissions = self.user_service.getPermissions(id=user_id)
return sorted(permissions, key=itemgetter('keyName')) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:transformChildrenToNative; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 21; 7, identifier:childArray; 8, generator_expression; 8, 9; 8, 14; 9, subscript; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:contents; 13, identifier:k; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:k; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:sortChildKeys; 20, argument_list; 21, block; 21, 22; 22, for_statement; 22, 23; 22, 24; 22, 25; 23, identifier:child; 24, identifier:childArray; 25, block; 25, 26; 25, 34; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:child; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:child; 32, identifier:transformToNative; 33, argument_list; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:child; 38, identifier:transformChildrenToNative; 39, argument_list | def transformChildrenToNative(self):
for childArray in (self.contents[k] for k in self.sortChildKeys()):
for child in childArray:
child = child.transformToNative()
child.transformChildrenToNative() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_candidate_pairs; 3, parameters; 3, 4; 3, 5; 4, identifier:pairs; 5, identifier:ice_controlling; 6, block; 6, 7; 6, 24; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:pair_priority; 9, parameters; 9, 10; 10, identifier:pair; 11, block; 11, 12; 12, return_statement; 12, 13; 13, unary_operator:-; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:candidate_pair_priority; 16, argument_list; 16, 17; 16, 20; 16, 23; 17, attribute; 17, 18; 17, 19; 18, identifier:pair; 19, identifier:local_candidate; 20, attribute; 20, 21; 20, 22; 21, identifier:pair; 22, identifier:remote_candidate; 23, identifier:ice_controlling; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:pairs; 28, identifier:sort; 29, argument_list; 29, 30; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, identifier:pair_priority | def sort_candidate_pairs(pairs, ice_controlling):
def pair_priority(pair):
return -candidate_pair_priority(pair.local_candidate,
pair.remote_candidate,
ice_controlling)
pairs.sort(key=pair_priority) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:order_by_refs; 3, parameters; 3, 4; 4, identifier:envs; 5, block; 5, 6; 5, 23; 5, 35; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:topology; 9, dictionary_comprehension; 9, 10; 9, 20; 10, pair; 10, 11; 10, 14; 11, subscript; 11, 12; 11, 13; 12, identifier:env; 13, string:'name'; 14, call; 14, 15; 14, 16; 15, identifier:set; 16, argument_list; 16, 17; 17, subscript; 17, 18; 17, 19; 18, identifier:env; 19, string:'refs'; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:env; 22, identifier:envs; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:by_name; 26, dictionary_comprehension; 26, 27; 26, 32; 27, pair; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:env; 30, string:'name'; 31, identifier:env; 32, for_in_clause; 32, 33; 32, 34; 33, identifier:env; 34, identifier:envs; 35, return_statement; 35, 36; 36, list_comprehension; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:by_name; 39, identifier:name; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:name; 42, call; 42, 43; 42, 44; 43, identifier:toposort_flatten; 44, argument_list; 44, 45; 45, identifier:topology | def order_by_refs(envs):
topology = {
env['name']: set(env['refs'])
for env in envs
}
by_name = {
env['name']: env
for env in envs
}
return [
by_name[name]
for name in toposort_flatten(topology)
] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:merged_packages; 3, parameters; 3, 4; 3, 5; 4, identifier:env_packages; 5, identifier:names; 6, block; 6, 7; 6, 30; 6, 34; 6, 40; 6, 78; 6, 111; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:combined_packages; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:itertools; 17, identifier:chain; 18, identifier:from_iterable; 19, generator_expression; 19, 20; 19, 27; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:env_packages; 24, identifier:name; 25, identifier:items; 26, argument_list; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:name; 29, identifier:names; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:result; 33, dictionary; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:errors; 37, call; 37, 38; 37, 39; 38, identifier:set; 39, argument_list; 40, for_statement; 40, 41; 40, 44; 40, 45; 41, pattern_list; 41, 42; 41, 43; 42, identifier:name; 43, identifier:version; 44, identifier:combined_packages; 45, block; 45, 46; 46, if_statement; 46, 47; 46, 50; 46, 70; 47, comparison_operator:in; 47, 48; 47, 49; 48, identifier:name; 49, identifier:result; 50, block; 50, 51; 51, if_statement; 51, 52; 51, 57; 52, comparison_operator:!=; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:result; 55, identifier:name; 56, identifier:version; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:errors; 62, identifier:add; 63, argument_list; 63, 64; 64, tuple; 64, 65; 64, 66; 64, 67; 65, identifier:name; 66, identifier:version; 67, subscript; 67, 68; 67, 69; 68, identifier:result; 69, identifier:name; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:result; 76, identifier:name; 77, identifier:version; 78, if_statement; 78, 79; 78, 80; 79, identifier:errors; 80, block; 80, 81; 80, 106; 81, for_statement; 81, 82; 81, 83; 81, 87; 82, identifier:error; 83, call; 83, 84; 83, 85; 84, identifier:sorted; 85, argument_list; 85, 86; 86, identifier:errors; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:logger; 92, identifier:error; 93, argument_list; 93, 94; 93, 97; 93, 100; 93, 103; 94, concatenated_string; 94, 95; 94, 96; 95, string:"Package %s was resolved to different "; 96, string:"versions in different environments: %s and %s"; 97, subscript; 97, 98; 97, 99; 98, identifier:error; 99, integer:0; 100, subscript; 100, 101; 100, 102; 101, identifier:error; 102, integer:1; 103, subscript; 103, 104; 103, 105; 104, identifier:error; 105, integer:2; 106, raise_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:RuntimeError; 109, argument_list; 109, 110; 110, string:"Please add constraints for the package version listed above"; 111, return_statement; 111, 112; 112, identifier:result | def merged_packages(env_packages, names):
combined_packages = sorted(itertools.chain.from_iterable(
env_packages[name].items()
for name in names
))
result = {}
errors = set()
for name, version in combined_packages:
if name in result:
if result[name] != version:
errors.add((name, version, result[name]))
else:
result[name] = version
if errors:
for error in sorted(errors):
logger.error(
"Package %s was resolved to different "
"versions in different environments: %s and %s",
error[0], error[1], error[2],
)
raise RuntimeError(
"Please add constraints for the package version listed above"
)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:recursive_refs; 3, parameters; 3, 4; 3, 5; 4, identifier:envs; 5, identifier:name; 6, block; 6, 7; 6, 24; 6, 30; 6, 63; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:refs_by_name; 10, dictionary_comprehension; 10, 11; 10, 21; 11, pair; 11, 12; 11, 15; 12, subscript; 12, 13; 12, 14; 13, identifier:env; 14, string:'name'; 15, call; 15, 16; 15, 17; 16, identifier:set; 17, argument_list; 17, 18; 18, subscript; 18, 19; 18, 20; 19, identifier:env; 20, string:'refs'; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:env; 23, identifier:envs; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:refs; 27, subscript; 27, 28; 27, 29; 28, identifier:refs_by_name; 29, identifier:name; 30, if_statement; 30, 31; 30, 32; 30, 55; 31, identifier:refs; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:indirect_refs; 36, call; 36, 37; 36, 38; 37, identifier:set; 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:itertools; 43, identifier:chain; 44, identifier:from_iterable; 45, argument_list; 45, 46; 46, list_comprehension; 46, 47; 46, 52; 47, call; 47, 48; 47, 49; 48, identifier:recursive_refs; 49, argument_list; 49, 50; 49, 51; 50, identifier:envs; 51, identifier:ref; 52, for_in_clause; 52, 53; 52, 54; 53, identifier:ref; 54, identifier:refs; 55, else_clause; 55, 56; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:indirect_refs; 60, call; 60, 61; 60, 62; 61, identifier:set; 62, argument_list; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:set; 67, identifier:union; 68, argument_list; 68, 69; 68, 70; 69, identifier:refs; 70, identifier:indirect_refs | def recursive_refs(envs, name):
refs_by_name = {
env['name']: set(env['refs'])
for env in envs
}
refs = refs_by_name[name]
if refs:
indirect_refs = set(itertools.chain.from_iterable([
recursive_refs(envs, ref)
for ref in refs
]))
else:
indirect_refs = set()
return set.union(refs, indirect_refs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:reference_cluster; 3, parameters; 3, 4; 3, 5; 4, identifier:envs; 5, identifier:name; 6, block; 6, 7; 6, 27; 6, 41; 6, 83; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:edges; 10, list_comprehension; 10, 11; 10, 19; 10, 22; 11, call; 11, 12; 11, 13; 12, identifier:set; 13, argument_list; 13, 14; 14, list:[env['name'], ref]; 14, 15; 14, 18; 15, subscript; 15, 16; 15, 17; 16, identifier:env; 17, string:'name'; 18, identifier:ref; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:env; 21, identifier:envs; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:ref; 24, subscript; 24, 25; 24, 26; 25, identifier:env; 26, string:'refs'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, pattern_list; 29, 30; 29, 31; 30, identifier:prev; 31, identifier:cluster; 32, expression_list; 32, 33; 32, 36; 33, call; 33, 34; 33, 35; 34, identifier:set; 35, argument_list; 36, call; 36, 37; 36, 38; 37, identifier:set; 38, argument_list; 38, 39; 39, list:[name]; 39, 40; 40, identifier:name; 41, while_statement; 41, 42; 41, 45; 42, comparison_operator:!=; 42, 43; 42, 44; 43, identifier:prev; 44, identifier:cluster; 45, block; 45, 46; 45, 53; 45, 57; 45, 79; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:prev; 49, call; 49, 50; 49, 51; 50, identifier:set; 51, argument_list; 51, 52; 52, identifier:cluster; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:to_visit; 56, list:[]; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:edge; 59, identifier:edges; 60, block; 60, 61; 61, if_statement; 61, 62; 61, 65; 61, 70; 62, binary_operator:&; 62, 63; 62, 64; 63, identifier:cluster; 64, identifier:edge; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, augmented_assignment:|=; 67, 68; 67, 69; 68, identifier:cluster; 69, identifier:edge; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:to_visit; 76, identifier:append; 77, argument_list; 77, 78; 78, identifier:edge; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:edges; 82, identifier:to_visit; 83, return_statement; 83, 84; 84, identifier:cluster | def reference_cluster(envs, name):
edges = [
set([env['name'], ref])
for env in envs
for ref in env['refs']
]
prev, cluster = set(), set([name])
while prev != cluster:
prev = set(cluster)
to_visit = []
for edge in edges:
if cluster & edge:
cluster |= edge
else:
to_visit.append(edge)
edges = to_visit
return cluster |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:search; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:text; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:offset; 11, integer:100; 12, default_parameter; 12, 13; 12, 14; 13, identifier:page; 14, integer:1; 15, default_parameter; 15, 16; 15, 17; 16, identifier:aquarius_url; 17, None; 18, block; 18, 19; 18, 24; 18, 31; 19, assert_statement; 19, 20; 19, 23; 20, comparison_operator:>=; 20, 21; 20, 22; 21, identifier:page; 22, integer:1; 23, string:f'Invalid page value {page}. Required page >= 1.'; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:logger; 28, identifier:info; 29, argument_list; 29, 30; 30, string:f'Searching asset containing: {text}'; 31, return_statement; 31, 32; 32, list_comprehension; 32, 33; 32, 39; 33, call; 33, 34; 33, 35; 34, identifier:DDO; 35, argument_list; 35, 36; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:dictionary; 38, identifier:ddo_dict; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:ddo_dict; 41, subscript; 41, 42; 41, 56; 42, call; 42, 43; 42, 51; 43, attribute; 43, 44; 43, 50; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_get_aquarius; 48, argument_list; 48, 49; 49, identifier:aquarius_url; 50, identifier:text_search; 51, argument_list; 51, 52; 51, 53; 51, 54; 51, 55; 52, identifier:text; 53, identifier:sort; 54, identifier:offset; 55, identifier:page; 56, string:'results' | def search(self, text, sort=None, offset=100, page=1, aquarius_url=None):
assert page >= 1, f'Invalid page value {page}. Required page >= 1.'
logger.info(f'Searching asset containing: {text}')
return [DDO(dictionary=ddo_dict) for ddo_dict in
self._get_aquarius(aquarius_url).text_search(text, sort, offset, page)['results']] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:query; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:offset; 11, integer:100; 12, default_parameter; 12, 13; 12, 14; 13, identifier:page; 14, integer:1; 15, default_parameter; 15, 16; 15, 17; 16, identifier:aquarius_url; 17, None; 18, block; 18, 19; 18, 26; 18, 35; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:logger; 23, identifier:info; 24, argument_list; 24, 25; 25, string:f'Searching asset query: {query}'; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:aquarius; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_get_aquarius; 33, argument_list; 33, 34; 34, identifier:aquarius_url; 35, return_statement; 35, 36; 36, list_comprehension; 36, 37; 36, 43; 37, call; 37, 38; 37, 39; 38, identifier:DDO; 39, argument_list; 39, 40; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:dictionary; 42, identifier:ddo_dict; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:ddo_dict; 45, subscript; 45, 46; 45, 55; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:aquarius; 49, identifier:query_search; 50, argument_list; 50, 51; 50, 52; 50, 53; 50, 54; 51, identifier:query; 52, identifier:sort; 53, identifier:offset; 54, identifier:page; 55, string:'results' | def query(self, query, sort=None, offset=100, page=1, aquarius_url=None):
logger.info(f'Searching asset query: {query}')
aquarius = self._get_aquarius(aquarius_url)
return [DDO(dictionary=ddo_dict) for ddo_dict in
aquarius.query_search(query, sort, offset, page)['results']] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.