sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:to_json; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sets; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:sets; 13, argument_list; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:sorted; 17, generator_expression; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 21, identifier:x; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:x; 24, identifier:sets | def to_json(self):
sets = self.sets()
return sorted(sorted(x) for x in sets) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:reload; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 14; 5, 20; 6, expression_statement; 6, 7; 7, string:'Generate histrow for each row and then reverse-sort by length.'; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:rows; 13, list:[]; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:discreteBinning; 19, argument_list; 20, for_statement; 20, 21; 20, 22; 20, 25; 21, identifier:c; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:nonKeyVisibleCols; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:c; 30, identifier:_cachedValues; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:collections; 34, identifier:OrderedDict; 35, argument_list | def reload(self):
'Generate histrow for each row and then reverse-sort by length.'
self.rows = []
self.discreteBinning()
for c in self.nonKeyVisibleCols:
c._cachedValues = collections.OrderedDict() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:resolve_colors; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:colorstack; 6, block; 6, 7; 6, 9; 6, 15; 6, 37; 7, expression_statement; 7, 8; 8, string:'Returns the curses attribute for the colorstack, a list of color option names sorted highest-precedence color first.'; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:attr; 12, call; 12, 13; 12, 14; 13, identifier:CursesAttr; 14, argument_list; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:coloropt; 17, identifier:colorstack; 18, block; 18, 19; 18, 28; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:c; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:get_color; 26, argument_list; 26, 27; 27, identifier:coloropt; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:attr; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:attr; 34, identifier:update_attr; 35, argument_list; 35, 36; 36, identifier:c; 37, return_statement; 37, 38; 38, identifier:attr | def resolve_colors(self, colorstack):
'Returns the curses attribute for the colorstack, a list of color option names sorted highest-precedence color first.'
attr = CursesAttr()
for coloropt in colorstack:
c = self.get_color(coloropt)
attr = attr.update_attr(c)
return attr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_mentions; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:docs; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, False; 11, block; 11, 12; 11, 16; 11, 169; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:result; 15, list:[]; 16, if_statement; 16, 17; 16, 18; 16, 109; 17, identifier:docs; 18, block; 18, 19; 18, 33; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:docs; 22, conditional_expression:if; 22, 23; 22, 24; 22, 31; 23, identifier:docs; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:docs; 28, tuple; 28, 29; 28, 30; 29, identifier:list; 30, identifier:tuple; 31, list:[docs]; 31, 32; 32, identifier:docs; 33, for_statement; 33, 34; 33, 35; 33, 38; 34, identifier:mention_class; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:mention_classes; 38, block; 38, 39; 38, 80; 38, 102; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:mentions; 42, parenthesized_expression; 42, 43; 43, call; 43, 44; 43, 79; 44, attribute; 44, 45; 44, 78; 45, call; 45, 46; 45, 74; 46, attribute; 46, 47; 46, 73; 47, call; 47, 48; 47, 58; 48, attribute; 48, 49; 48, 57; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:session; 54, identifier:query; 55, argument_list; 55, 56; 56, identifier:mention_class; 57, identifier:filter; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:mention_class; 63, identifier:document_id; 64, identifier:in_; 65, argument_list; 65, 66; 66, list_comprehension; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:doc; 69, identifier:id; 70, for_in_clause; 70, 71; 70, 72; 71, identifier:doc; 72, identifier:docs; 73, identifier:order_by; 74, argument_list; 74, 75; 75, attribute; 75, 76; 75, 77; 76, identifier:mention_class; 77, identifier:id; 78, identifier:all; 79, argument_list; 80, if_statement; 80, 81; 80, 82; 81, identifier:sort; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:mentions; 86, call; 86, 87; 86, 88; 87, identifier:sorted; 88, argument_list; 88, 89; 88, 90; 89, identifier:mentions; 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, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:x; 99, integer:0; 100, identifier:get_stable_id; 101, argument_list; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:result; 106, identifier:append; 107, argument_list; 107, 108; 108, identifier:mentions; 109, else_clause; 109, 110; 110, block; 110, 111; 111, for_statement; 111, 112; 111, 113; 111, 116; 112, identifier:mention_class; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:mention_classes; 116, block; 116, 117; 116, 140; 116, 162; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:mentions; 120, parenthesized_expression; 120, 121; 121, call; 121, 122; 121, 139; 122, attribute; 122, 123; 122, 138; 123, call; 123, 124; 123, 134; 124, attribute; 124, 125; 124, 133; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:session; 130, identifier:query; 131, argument_list; 131, 132; 132, identifier:mention_class; 133, identifier:order_by; 134, argument_list; 134, 135; 135, attribute; 135, 136; 135, 137; 136, identifier:mention_class; 137, identifier:id; 138, identifier:all; 139, argument_list; 140, if_statement; 140, 141; 140, 142; 141, identifier:sort; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:mentions; 146, call; 146, 147; 146, 148; 147, identifier:sorted; 148, argument_list; 148, 149; 148, 150; 149, identifier:mentions; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:key; 152, lambda; 152, 153; 152, 155; 153, lambda_parameters; 153, 154; 154, identifier:x; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:x; 159, integer:0; 160, identifier:get_stable_id; 161, argument_list; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:result; 166, identifier:append; 167, argument_list; 167, 168; 168, identifier:mentions; 169, return_statement; 169, 170; 170, identifier:result | def get_mentions(self, docs=None, sort=False):
result = []
if docs:
docs = docs if isinstance(docs, (list, tuple)) else [docs]
for mention_class in self.mention_classes:
mentions = (
self.session.query(mention_class)
.filter(mention_class.document_id.in_([doc.id for doc in docs]))
.order_by(mention_class.id)
.all()
)
if sort:
mentions = sorted(mentions, key=lambda x: x[0].get_stable_id())
result.append(mentions)
else:
for mention_class in self.mention_classes:
mentions = (
self.session.query(mention_class).order_by(mention_class.id).all()
)
if sort:
mentions = sorted(mentions, key=lambda x: x[0].get_stable_id())
result.append(mentions)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_candidates; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:docs; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:split; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, False; 14, block; 14, 15; 14, 19; 14, 245; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:result; 18, list:[]; 19, if_statement; 19, 20; 19, 21; 19, 129; 20, identifier:docs; 21, block; 21, 22; 21, 36; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:docs; 25, conditional_expression:if; 25, 26; 25, 27; 25, 34; 26, identifier:docs; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:docs; 31, tuple; 31, 32; 31, 33; 32, identifier:list; 33, identifier:tuple; 34, list:[docs]; 34, 35; 35, identifier:docs; 36, for_statement; 36, 37; 36, 38; 36, 41; 37, identifier:candidate_class; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:candidate_classes; 41, block; 41, 42; 41, 83; 41, 122; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:cands; 45, parenthesized_expression; 45, 46; 46, call; 46, 47; 46, 82; 47, attribute; 47, 48; 47, 81; 48, call; 48, 49; 48, 77; 49, attribute; 49, 50; 49, 76; 50, call; 50, 51; 50, 61; 51, attribute; 51, 52; 51, 60; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:session; 57, identifier:query; 58, argument_list; 58, 59; 59, identifier:candidate_class; 60, identifier:filter; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:candidate_class; 66, identifier:document_id; 67, identifier:in_; 68, argument_list; 68, 69; 69, list_comprehension; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:doc; 72, identifier:id; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:doc; 75, identifier:docs; 76, identifier:order_by; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:candidate_class; 80, identifier:id; 81, identifier:all; 82, argument_list; 83, if_statement; 83, 84; 83, 85; 84, identifier:sort; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:cands; 89, call; 89, 90; 89, 91; 90, identifier:sorted; 91, argument_list; 91, 92; 91, 93; 92, identifier:cands; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:key; 95, lambda; 95, 96; 95, 98; 96, lambda_parameters; 96, 97; 97, identifier:x; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, string:" "; 101, identifier:join; 102, argument_list; 102, 103; 103, list_comprehension; 103, 104; 103, 113; 104, call; 104, 105; 104, 112; 105, attribute; 105, 106; 105, 111; 106, subscript; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:x; 109, identifier:i; 110, integer:0; 111, identifier:get_stable_id; 112, argument_list; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:i; 115, call; 115, 116; 115, 117; 116, identifier:range; 117, argument_list; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:x; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:result; 126, identifier:append; 127, argument_list; 127, 128; 128, identifier:cands; 129, else_clause; 129, 130; 130, block; 130, 131; 131, for_statement; 131, 132; 131, 133; 131, 136; 132, identifier:candidate_class; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:candidate_classes; 136, block; 136, 137; 136, 164; 136, 199; 136, 238; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:sub_query; 140, parenthesized_expression; 140, 141; 141, call; 141, 142; 141, 163; 142, attribute; 142, 143; 142, 162; 143, call; 143, 144; 143, 156; 144, attribute; 144, 145; 144, 155; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:session; 150, identifier:query; 151, argument_list; 151, 152; 152, attribute; 152, 153; 152, 154; 153, identifier:Candidate; 154, identifier:id; 155, identifier:filter; 156, argument_list; 156, 157; 157, comparison_operator:==; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:Candidate; 160, identifier:split; 161, identifier:split; 162, identifier:subquery; 163, argument_list; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:cands; 167, parenthesized_expression; 167, 168; 168, call; 168, 169; 168, 198; 169, attribute; 169, 170; 169, 197; 170, call; 170, 171; 170, 193; 171, attribute; 171, 172; 171, 192; 172, call; 172, 173; 172, 183; 173, attribute; 173, 174; 173, 182; 174, call; 174, 175; 174, 180; 175, attribute; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:session; 179, identifier:query; 180, argument_list; 180, 181; 181, identifier:candidate_class; 182, identifier:filter; 183, argument_list; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:candidate_class; 188, identifier:id; 189, identifier:in_; 190, argument_list; 190, 191; 191, identifier:sub_query; 192, identifier:order_by; 193, argument_list; 193, 194; 194, attribute; 194, 195; 194, 196; 195, identifier:candidate_class; 196, identifier:id; 197, identifier:all; 198, argument_list; 199, if_statement; 199, 200; 199, 201; 200, identifier:sort; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:cands; 205, call; 205, 206; 205, 207; 206, identifier:sorted; 207, argument_list; 207, 208; 207, 209; 208, identifier:cands; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:key; 211, lambda; 211, 212; 211, 214; 212, lambda_parameters; 212, 213; 213, identifier:x; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, string:" "; 217, identifier:join; 218, argument_list; 218, 219; 219, list_comprehension; 219, 220; 219, 229; 220, call; 220, 221; 220, 228; 221, attribute; 221, 222; 221, 227; 222, subscript; 222, 223; 222, 226; 223, subscript; 223, 224; 223, 225; 224, identifier:x; 225, identifier:i; 226, integer:0; 227, identifier:get_stable_id; 228, argument_list; 229, for_in_clause; 229, 230; 229, 231; 230, identifier:i; 231, call; 231, 232; 231, 233; 232, identifier:range; 233, argument_list; 233, 234; 234, call; 234, 235; 234, 236; 235, identifier:len; 236, argument_list; 236, 237; 237, identifier:x; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:result; 242, identifier:append; 243, argument_list; 243, 244; 244, identifier:cands; 245, return_statement; 245, 246; 246, identifier:result | def get_candidates(self, docs=None, split=0, sort=False):
result = []
if docs:
docs = docs if isinstance(docs, (list, tuple)) else [docs]
for candidate_class in self.candidate_classes:
cands = (
self.session.query(candidate_class)
.filter(candidate_class.document_id.in_([doc.id for doc in docs]))
.order_by(candidate_class.id)
.all()
)
if sort:
cands = sorted(
cands,
key=lambda x: " ".join(
[x[i][0].get_stable_id() for i in range(len(x))]
),
)
result.append(cands)
else:
for candidate_class in self.candidate_classes:
sub_query = (
self.session.query(Candidate.id)
.filter(Candidate.split == split)
.subquery()
)
cands = (
self.session.query(candidate_class)
.filter(candidate_class.id.in_(sub_query))
.order_by(candidate_class.id)
.all()
)
if sort:
cands = sorted(
cands,
key=lambda x: " ".join(
[x[i][0].get_stable_id() for i in range(len(x))]
),
)
result.append(cands)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:text; 6, default_parameter; 6, 7; 6, 8; 7, identifier:checked; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 29; 12, 35; 12, 41; 12, 52; 12, 60; 12, 67; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:node; 16, call; 16, 17; 16, 18; 17, identifier:ListItem; 18, argument_list; 18, 19; 18, 24; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:parent_id; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:id; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:parent_server_id; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:server_id; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:node; 33, identifier:checked; 34, identifier:checked; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:node; 39, identifier:text; 40, identifier:text; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:sort; 44, None; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:node; 50, identifier:sort; 51, identifier:sort; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:append; 57, argument_list; 57, 58; 57, 59; 58, identifier:node; 59, True; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:touch; 65, argument_list; 65, 66; 66, True; 67, return_statement; 67, 68; 68, identifier:node | def add(self, text, checked=False, sort=None):
node = ListItem(parent_id=self.id, parent_server_id=self.server_id)
node.checked = checked
node.text = text
if sort is not None:
node.sort = sort
self.append(node, True)
self.touch(True)
return node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:items_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:items; 6, block; 6, 7; 6, 148; 6, 188; 7, class_definition; 7, 8; 7, 9; 7, 11; 8, identifier:t; 9, argument_list; 9, 10; 10, identifier:tuple; 11, block; 11, 12; 11, 58; 11, 73; 11, 88; 11, 103; 11, 118; 11, 133; 12, function_definition; 12, 13; 12, 14; 12, 17; 13, function_name:__cmp__; 14, parameters; 14, 15; 14, 16; 15, identifier:self; 16, identifier:other; 17, block; 17, 18; 17, 56; 18, for_statement; 18, 19; 18, 22; 18, 31; 19, pattern_list; 19, 20; 19, 21; 20, identifier:a; 21, identifier:b; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:six; 26, identifier:moves; 27, identifier:zip_longest; 28, argument_list; 28, 29; 28, 30; 29, identifier:self; 30, identifier:other; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 36; 33, comparison_operator:!=; 33, 34; 33, 35; 34, identifier:a; 35, identifier:b; 36, block; 36, 37; 36, 44; 36, 52; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:a; 40, None; 41, block; 41, 42; 42, return_statement; 42, 43; 43, integer:1; 44, if_statement; 44, 45; 44, 48; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:b; 47, None; 48, block; 48, 49; 49, return_statement; 49, 50; 50, unary_operator:-; 50, 51; 51, integer:1; 52, return_statement; 52, 53; 53, binary_operator:-; 53, 54; 53, 55; 54, identifier:a; 55, identifier:b; 56, return_statement; 56, 57; 57, integer:0; 58, function_definition; 58, 59; 58, 60; 58, 63; 59, function_name:__lt__; 60, parameters; 60, 61; 60, 62; 61, identifier:self; 62, identifier:other; 63, block; 63, 64; 64, return_statement; 64, 65; 65, comparison_operator:<; 65, 66; 65, 72; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:__cmp__; 70, argument_list; 70, 71; 71, identifier:other; 72, integer:0; 73, function_definition; 73, 74; 73, 75; 73, 78; 74, function_name:__gt_; 75, parameters; 75, 76; 75, 77; 76, identifier:self; 77, identifier:other; 78, block; 78, 79; 79, return_statement; 79, 80; 80, comparison_operator:>; 80, 81; 80, 87; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:__cmp__; 85, argument_list; 85, 86; 86, identifier:other; 87, integer:0; 88, function_definition; 88, 89; 88, 90; 88, 93; 89, function_name:__le__; 90, parameters; 90, 91; 90, 92; 91, identifier:self; 92, identifier:other; 93, block; 93, 94; 94, return_statement; 94, 95; 95, comparison_operator:<=; 95, 96; 95, 102; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:__cmp__; 100, argument_list; 100, 101; 101, identifier:other; 102, integer:0; 103, function_definition; 103, 104; 103, 105; 103, 108; 104, function_name:__ge_; 105, parameters; 105, 106; 105, 107; 106, identifier:self; 107, identifier:other; 108, block; 108, 109; 109, return_statement; 109, 110; 110, comparison_operator:>=; 110, 111; 110, 117; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:__cmp__; 115, argument_list; 115, 116; 116, identifier:other; 117, integer:0; 118, function_definition; 118, 119; 118, 120; 118, 123; 119, function_name:__eq__; 120, parameters; 120, 121; 120, 122; 121, identifier:self; 122, identifier:other; 123, block; 123, 124; 124, return_statement; 124, 125; 125, comparison_operator:==; 125, 126; 125, 132; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:__cmp__; 130, argument_list; 130, 131; 131, identifier:other; 132, integer:0; 133, function_definition; 133, 134; 133, 135; 133, 138; 134, function_name:__ne__; 135, parameters; 135, 136; 135, 137; 136, identifier:self; 137, identifier:other; 138, block; 138, 139; 139, return_statement; 139, 140; 140, comparison_operator:!=; 140, 141; 140, 147; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:__cmp__; 145, argument_list; 145, 146; 146, identifier:other; 147, integer:0; 148, function_definition; 148, 149; 148, 150; 148, 152; 149, function_name:key_func; 150, parameters; 150, 151; 151, identifier:x; 152, block; 152, 153; 152, 177; 153, if_statement; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:x; 156, identifier:indented; 157, block; 157, 158; 158, return_statement; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:t; 161, argument_list; 161, 162; 162, tuple; 162, 163; 162, 171; 163, call; 163, 164; 163, 165; 164, identifier:int; 165, argument_list; 165, 166; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:x; 169, identifier:parent_item; 170, identifier:sort; 171, call; 171, 172; 171, 173; 172, identifier:int; 173, argument_list; 173, 174; 174, attribute; 174, 175; 174, 176; 175, identifier:x; 176, identifier:sort; 177, return_statement; 177, 178; 178, call; 178, 179; 178, 180; 179, identifier:t; 180, argument_list; 180, 181; 181, tuple; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:int; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:x; 187, identifier:sort; 188, return_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:sorted; 191, argument_list; 191, 192; 191, 193; 191, 196; 192, identifier:items; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:key; 195, identifier:key_func; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:reverse; 198, True | def items_sort(cls, items):
class t(tuple):
def __cmp__(self, other):
for a, b in six.moves.zip_longest(self, other):
if a != b:
if a is None:
return 1
if b is None:
return -1
return a - b
return 0
def __lt__(self, other):
return self.__cmp__(other) < 0
def __gt_(self, other):
return self.__cmp__(other) > 0
def __le__(self, other):
return self.__cmp__(other) <= 0
def __ge_(self, other):
return self.__cmp__(other) >= 0
def __eq__(self, other):
return self.__cmp__(other) == 0
def __ne__(self, other):
return self.__cmp__(other) != 0
def key_func(x):
if x.indented:
return t((int(x.parent_item.sort), int(x.sort)))
return t((int(x.sort), ))
return sorted(items, key=key_func, reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:text; 6, default_parameter; 6, 7; 6, 8; 7, identifier:checked; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 27; 12, 40; 12, 47; 13, if_statement; 13, 14; 13, 19; 14, comparison_operator:is; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:parent; 18, None; 19, block; 19, 20; 20, raise_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:exception; 24, identifier:InvalidException; 25, argument_list; 25, 26; 26, string:'Item has no parent'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:node; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:parent; 35, identifier:add; 36, argument_list; 36, 37; 36, 38; 36, 39; 37, identifier:text; 38, identifier:checked; 39, identifier:sort; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:indent; 45, argument_list; 45, 46; 46, identifier:node; 47, return_statement; 47, 48; 48, identifier:node | def add(self, text, checked=False, sort=None):
if self.parent is None:
raise exception.InvalidException('Item has no parent')
node = self.parent.add(text, checked, sort)
self.indent(node)
return node |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_subsections; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:srcdir; 5, identifier:examples_dir; 6, identifier:sortkey; 7, block; 7, 8; 7, 39; 7, 51; 7, 67; 7, 77; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:subfolders; 11, list_comprehension; 11, 12; 11, 13; 11, 21; 12, identifier:subfolder; 13, for_in_clause; 13, 14; 13, 15; 14, identifier:subfolder; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:os; 18, identifier:listdir; 19, argument_list; 19, 20; 20, identifier:examples_dir; 21, if_clause; 21, 22; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:os; 26, identifier:path; 27, identifier:exists; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:os; 33, identifier:path; 34, identifier:join; 35, argument_list; 35, 36; 35, 37; 35, 38; 36, identifier:examples_dir; 37, identifier:subfolder; 38, string:'README.txt'; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:base_examples_dir_path; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:os; 46, identifier:path; 47, identifier:relpath; 48, argument_list; 48, 49; 48, 50; 49, identifier:examples_dir; 50, identifier:srcdir; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:subfolders_with_path; 54, list_comprehension; 54, 55; 54, 64; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:os; 59, identifier:path; 60, identifier:join; 61, argument_list; 61, 62; 61, 63; 62, identifier:base_examples_dir_path; 63, identifier:item; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:item; 66, identifier:subfolders; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:sorted_subfolders; 70, call; 70, 71; 70, 72; 71, identifier:sorted; 72, argument_list; 72, 73; 72, 74; 73, identifier:subfolders_with_path; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:key; 76, identifier:sortkey; 77, return_statement; 77, 78; 78, list_comprehension; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:subfolders; 81, identifier:i; 82, for_in_clause; 82, 83; 82, 84; 83, identifier:i; 84, list_comprehension; 84, 85; 84, 91; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:subfolders_with_path; 88, identifier:index; 89, argument_list; 89, 90; 90, identifier:item; 91, for_in_clause; 91, 92; 91, 93; 92, identifier:item; 93, identifier:sorted_subfolders | def get_subsections(srcdir, examples_dir, sortkey):
subfolders = [subfolder for subfolder in os.listdir(examples_dir)
if os.path.exists(os.path.join(
examples_dir, subfolder, 'README.txt'))]
base_examples_dir_path = os.path.relpath(examples_dir, srcdir)
subfolders_with_path = [os.path.join(base_examples_dir_path, item)
for item in subfolders]
sorted_subfolders = sorted(subfolders_with_path, key=sortkey)
return [subfolders[i] for i in [subfolders_with_path.index(item)
for item in sorted_subfolders]] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 18; 2, function_name:alphabetical_sort; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:list_to_sort; 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:str; 12, type; 12, 13; 13, generic_type; 13, 14; 13, 15; 14, identifier:List; 15, type_parameter; 15, 16; 16, type; 16, 17; 17, identifier:str; 18, block; 18, 19; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:sorted; 22, argument_list; 22, 23; 22, 24; 23, identifier:list_to_sort; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:key; 26, identifier:norm_fold | def alphabetical_sort(list_to_sort: Iterable[str]) -> List[str]:
return sorted(list_to_sort, key=norm_fold) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 18; 2, function_name:natural_sort; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:list_to_sort; 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:str; 12, type; 12, 13; 13, generic_type; 13, 14; 13, 15; 14, identifier:List; 15, type_parameter; 15, 16; 16, type; 16, 17; 17, identifier:str; 18, block; 18, 19; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:sorted; 22, argument_list; 22, 23; 22, 24; 23, identifier:list_to_sort; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:key; 26, identifier:natural_keys | def natural_sort(list_to_sort: Iterable[str]) -> List[str]:
return sorted(list_to_sort, key=natural_keys) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:find; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:_clauses; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 21; 9, 31; 9, 41; 9, 51; 9, 61; 9, 71; 9, 84; 9, 93; 9, 105; 9, 124; 9, 140; 9, 148; 9, 174; 10, if_statement; 10, 11; 10, 15; 11, not_operator; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:exists; 15, block; 15, 16; 16, return_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:iter; 19, argument_list; 19, 20; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:_limit; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:kwargs; 27, identifier:pop; 28, argument_list; 28, 29; 28, 30; 29, string:'_limit'; 30, None; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:_offset; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:kwargs; 37, identifier:pop; 38, argument_list; 38, 39; 38, 40; 39, string:'_offset'; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:order_by; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:kwargs; 47, identifier:pop; 48, argument_list; 48, 49; 48, 50; 49, string:'order_by'; 50, None; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:_streamed; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:kwargs; 57, identifier:pop; 58, argument_list; 58, 59; 58, 60; 59, string:'_streamed'; 60, False; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:_step; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:kwargs; 67, identifier:pop; 68, argument_list; 68, 69; 68, 70; 69, string:'_step'; 70, identifier:QUERY_STEP; 71, if_statement; 71, 72; 71, 79; 72, boolean_operator:or; 72, 73; 72, 76; 73, comparison_operator:is; 73, 74; 73, 75; 74, identifier:_step; 75, False; 76, comparison_operator:==; 76, 77; 76, 78; 77, identifier:_step; 78, integer:0; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:_step; 83, None; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:order_by; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_args_to_order_by; 91, argument_list; 91, 92; 92, identifier:order_by; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:args; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_args_to_clause; 100, argument_list; 100, 101; 100, 102; 101, identifier:kwargs; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:clauses; 104, identifier:_clauses; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:query; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:table; 113, identifier:select; 114, argument_list; 114, 115; 114, 118; 114, 121; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:whereclause; 117, identifier:args; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:limit; 120, identifier:_limit; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:offset; 123, identifier:_offset; 124, if_statement; 124, 125; 124, 129; 125, call; 125, 126; 125, 127; 126, identifier:len; 127, argument_list; 127, 128; 128, identifier:order_by; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:query; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:query; 136, identifier:order_by; 137, argument_list; 137, 138; 138, list_splat; 138, 139; 139, identifier:order_by; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:conn; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:db; 147, identifier:executable; 148, if_statement; 148, 149; 148, 150; 149, identifier:_streamed; 150, block; 150, 151; 150, 163; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:conn; 154, call; 154, 155; 154, 162; 155, attribute; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:db; 160, identifier:engine; 161, identifier:connect; 162, argument_list; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:conn; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:conn; 169, identifier:execution_options; 170, argument_list; 170, 171; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:stream_results; 173, True; 174, return_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:ResultIter; 177, argument_list; 177, 178; 177, 184; 177, 191; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:conn; 181, identifier:execute; 182, argument_list; 182, 183; 183, identifier:query; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:row_type; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:self; 189, identifier:db; 190, identifier:row_type; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:step; 193, identifier:_step | def find(self, *_clauses, **kwargs):
if not self.exists:
return iter([])
_limit = kwargs.pop('_limit', None)
_offset = kwargs.pop('_offset', 0)
order_by = kwargs.pop('order_by', None)
_streamed = kwargs.pop('_streamed', False)
_step = kwargs.pop('_step', QUERY_STEP)
if _step is False or _step == 0:
_step = None
order_by = self._args_to_order_by(order_by)
args = self._args_to_clause(kwargs, clauses=_clauses)
query = self.table.select(whereclause=args,
limit=_limit,
offset=_offset)
if len(order_by):
query = query.order_by(*order_by)
conn = self.db.executable
if _streamed:
conn = self.db.engine.connect()
conn = conn.execution_options(stream_results=True)
return ResultIter(conn.execute(query),
row_type=self.db.row_type,
step=_step) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 1, 6; 2, function_name:find_write_contribs; 3, parameters; 4, type; 4, 5; 5, None; 6, block; 6, 7; 6, 11; 6, 40; 6, 47; 6, 70; 6, 77; 6, 88; 6, 95; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:map_file_auth; 10, dictionary; 11, for_statement; 11, 12; 11, 13; 11, 17; 12, identifier:filename; 13, call; 13, 14; 13, 15; 14, identifier:scantree; 15, argument_list; 15, 16; 16, string:'cltk'; 17, block; 17, 18; 17, 24; 17, 31; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:filepath; 21, attribute; 21, 22; 21, 23; 22, identifier:filename; 23, identifier:path; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:authors_list; 27, call; 27, 28; 27, 29; 28, identifier:get_authors; 29, argument_list; 29, 30; 30, identifier:filepath; 31, if_statement; 31, 32; 31, 33; 32, identifier:authors_list; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:map_file_auth; 38, identifier:filepath; 39, identifier:authors_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:map_auth_file; 43, call; 43, 44; 43, 45; 44, identifier:defaultdict; 45, argument_list; 45, 46; 46, identifier:list; 47, for_statement; 47, 48; 47, 51; 47, 56; 48, pattern_list; 48, 49; 48, 50; 49, identifier:file; 50, identifier:authors_file; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:map_file_auth; 54, identifier:items; 55, argument_list; 56, block; 56, 57; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:author; 59, identifier:authors_file; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:map_auth_file; 66, identifier:author; 67, identifier:append; 68, argument_list; 68, 69; 69, identifier:file; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:map_auth_file; 73, call; 73, 74; 73, 75; 74, identifier:sort_def_dict; 75, argument_list; 75, 76; 76, identifier:map_auth_file; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:map_auth_file_sorted; 80, call; 80, 81; 80, 82; 81, identifier:sorted; 82, argument_list; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:map_auth_file; 86, identifier:items; 87, argument_list; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:map_auth_file; 91, call; 91, 92; 91, 93; 92, identifier:OrderedDict; 93, argument_list; 93, 94; 94, identifier:map_auth_file_sorted; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:write_contribs; 98, argument_list; 98, 99; 99, identifier:map_auth_file | def find_write_contribs() -> None:
map_file_auth = {}
for filename in scantree('cltk'):
filepath = filename.path
authors_list = get_authors(filepath)
if authors_list:
map_file_auth[filepath] = authors_list
map_auth_file = defaultdict(list)
for file, authors_file in map_file_auth.items():
for author in authors_file:
map_auth_file[author].append(file)
map_auth_file = sort_def_dict(map_auth_file)
map_auth_file_sorted = sorted(map_auth_file.items())
map_auth_file = OrderedDict(map_auth_file_sorted)
write_contribs(map_auth_file) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:find_files; 3, parameters; 3, 4; 4, identifier:folder; 5, block; 5, 6; 5, 26; 5, 32; 5, 71; 5, 87; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:files; 9, list_comprehension; 9, 10; 9, 11; 9, 19; 10, identifier:i; 11, for_in_clause; 11, 12; 11, 13; 12, identifier:i; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:os; 16, identifier:listdir; 17, argument_list; 17, 18; 18, identifier:folder; 19, if_clause; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:i; 23, identifier:startswith; 24, argument_list; 24, 25; 25, string:"left"; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:files; 30, identifier:sort; 31, argument_list; 32, for_statement; 32, 33; 32, 34; 32, 41; 33, identifier:i; 34, call; 34, 35; 34, 36; 35, identifier:range; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:files; 41, block; 41, 42; 41, 59; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:insert_string; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:"right{}"; 48, identifier:format; 49, argument_list; 49, 50; 50, subscript; 50, 51; 50, 56; 51, subscript; 51, 52; 51, 53; 52, identifier:files; 53, binary_operator:*; 53, 54; 53, 55; 54, identifier:i; 55, integer:2; 56, slice; 56, 57; 56, 58; 57, integer:4; 58, colon; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:files; 63, identifier:insert; 64, argument_list; 64, 65; 64, 70; 65, binary_operator:+; 65, 66; 65, 69; 66, binary_operator:*; 66, 67; 66, 68; 67, identifier:i; 68, integer:2; 69, integer:1; 70, identifier:insert_string; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:files; 74, list_comprehension; 74, 75; 74, 84; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:os; 79, identifier:path; 80, identifier:join; 81, argument_list; 81, 82; 81, 83; 82, identifier:folder; 83, identifier:filename; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:filename; 86, identifier:files; 87, return_statement; 87, 88; 88, identifier:files | def find_files(folder):
files = [i for i in os.listdir(folder) if i.startswith("left")]
files.sort()
for i in range(len(files)):
insert_string = "right{}".format(files[i * 2][4:])
files.insert(i * 2 + 1, insert_string)
files = [os.path.join(folder, filename) for filename in files]
return files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:cdx_load; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:sources; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:process; 8, True; 9, block; 9, 10; 9, 18; 9, 25; 9, 33; 9, 49; 9, 55; 9, 67; 9, 101; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:cdx_iter; 13, call; 13, 14; 13, 15; 14, identifier:create_merged_cdx_gen; 15, argument_list; 15, 16; 15, 17; 16, identifier:sources; 17, identifier:query; 18, if_statement; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:query; 21, identifier:page_count; 22, block; 22, 23; 23, return_statement; 23, 24; 24, identifier:cdx_iter; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:cdx_iter; 28, call; 28, 29; 28, 30; 29, identifier:make_obj_iter; 30, argument_list; 30, 31; 30, 32; 31, identifier:cdx_iter; 32, identifier:query; 33, if_statement; 33, 34; 33, 40; 34, boolean_operator:and; 34, 35; 34, 36; 35, identifier:process; 36, not_operator; 36, 37; 37, attribute; 37, 38; 37, 39; 38, identifier:query; 39, identifier:secondary_index_only; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:cdx_iter; 44, call; 44, 45; 44, 46; 45, identifier:process_cdx; 46, argument_list; 46, 47; 46, 48; 47, identifier:cdx_iter; 48, identifier:query; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:custom_ops; 52, attribute; 52, 53; 52, 54; 53, identifier:query; 54, identifier:custom_ops; 55, for_statement; 55, 56; 55, 57; 55, 58; 56, identifier:op; 57, identifier:custom_ops; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:cdx_iter; 62, call; 62, 63; 62, 64; 63, identifier:op; 64, argument_list; 64, 65; 64, 66; 65, identifier:cdx_iter; 66, identifier:query; 67, if_statement; 67, 68; 67, 73; 67, 84; 68, comparison_operator:==; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:query; 71, identifier:output; 72, string:'text'; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:cdx_iter; 77, call; 77, 78; 77, 79; 78, identifier:cdx_to_text; 79, argument_list; 79, 80; 79, 81; 80, identifier:cdx_iter; 81, attribute; 81, 82; 81, 83; 82, identifier:query; 83, identifier:fields; 84, elif_clause; 84, 85; 84, 90; 85, comparison_operator:==; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:query; 88, identifier:output; 89, string:'json'; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:cdx_iter; 94, call; 94, 95; 94, 96; 95, identifier:cdx_to_json; 96, argument_list; 96, 97; 96, 98; 97, identifier:cdx_iter; 98, attribute; 98, 99; 98, 100; 99, identifier:query; 100, identifier:fields; 101, return_statement; 101, 102; 102, identifier:cdx_iter | def cdx_load(sources, query, process=True):
cdx_iter = create_merged_cdx_gen(sources, query)
if query.page_count:
return cdx_iter
cdx_iter = make_obj_iter(cdx_iter, query)
if process and not query.secondary_index_only:
cdx_iter = process_cdx(cdx_iter, query)
custom_ops = query.custom_ops
for op in custom_ops:
cdx_iter = op(cdx_iter, query)
if query.output == 'text':
cdx_iter = cdx_to_text(cdx_iter, query.fields)
elif query.output == 'json':
cdx_iter = cdx_to_json(cdx_iter, query.fields)
return cdx_iter |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:cdx_sort_closest; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:closest; 5, identifier:cdx_iter; 6, default_parameter; 6, 7; 6, 8; 7, identifier:limit; 8, integer:10; 9, block; 9, 10; 9, 14; 9, 18; 9, 25; 9, 104; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:closest_cdx; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:closest_keys; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:closest_sec; 21, call; 21, 22; 21, 23; 22, identifier:timestamp_to_sec; 23, argument_list; 23, 24; 24, identifier:closest; 25, for_statement; 25, 26; 25, 27; 25, 28; 26, identifier:cdx; 27, identifier:cdx_iter; 28, block; 28, 29; 28, 38; 28, 47; 28, 57; 28, 65; 28, 73; 28, 90; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:sec; 32, call; 32, 33; 32, 34; 33, identifier:timestamp_to_sec; 34, argument_list; 34, 35; 35, subscript; 35, 36; 35, 37; 36, identifier:cdx; 37, identifier:TIMESTAMP; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:key; 41, call; 41, 42; 41, 43; 42, identifier:abs; 43, argument_list; 43, 44; 44, binary_operator:-; 44, 45; 44, 46; 45, identifier:closest_sec; 46, identifier:sec; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:i; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:bisect; 53, identifier:bisect_right; 54, argument_list; 54, 55; 54, 56; 55, identifier:closest_keys; 56, identifier:key; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:closest_keys; 61, identifier:insert; 62, argument_list; 62, 63; 62, 64; 63, identifier:i; 64, identifier:key; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:closest_cdx; 69, identifier:insert; 70, argument_list; 70, 71; 70, 72; 71, identifier:i; 72, identifier:cdx; 73, if_statement; 73, 74; 73, 80; 74, comparison_operator:==; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:closest_cdx; 79, identifier:limit; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 88; 82, comparison_operator:>; 82, 83; 82, 84; 83, identifier:key; 84, subscript; 84, 85; 84, 86; 85, identifier:closest_keys; 86, unary_operator:-; 86, 87; 87, integer:1; 88, block; 88, 89; 89, break_statement; 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:closest_cdx; 96, identifier:limit; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:closest_cdx; 102, identifier:pop; 103, argument_list; 104, for_statement; 104, 105; 104, 106; 104, 107; 105, identifier:cdx; 106, identifier:closest_cdx; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, yield; 109, 110; 110, identifier:cdx | def cdx_sort_closest(closest, cdx_iter, limit=10):
closest_cdx = []
closest_keys = []
closest_sec = timestamp_to_sec(closest)
for cdx in cdx_iter:
sec = timestamp_to_sec(cdx[TIMESTAMP])
key = abs(closest_sec - sec)
i = bisect.bisect_right(closest_keys, key)
closest_keys.insert(i, key)
closest_cdx.insert(i, cdx)
if len(closest_cdx) == limit:
if key > closest_keys[-1]:
break
if len(closest_cdx) > limit:
closest_cdx.pop()
for cdx in closest_cdx:
yield cdx |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:iter_prefix; 3, parameters; 3, 4; 3, 5; 4, identifier:reader; 5, identifier:key; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:itertools; 11, identifier:takewhile; 12, argument_list; 12, 13; 12, 22; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:line; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:line; 19, identifier:startswith; 20, argument_list; 20, 21; 21, identifier:key; 22, call; 22, 23; 22, 24; 23, identifier:search; 24, argument_list; 24, 25; 24, 26; 25, identifier:reader; 26, identifier:key | def iter_prefix(reader, key):
return itertools.takewhile(
lambda line: line.startswith(key),
search(reader, key)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_basis_dict; 3, parameters; 3, 4; 4, identifier:bs; 5, block; 5, 6; 5, 50; 5, 67; 5, 91; 5, 110; 5, 163; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:_keyorder; 9, list:[
'molssi_bse_schema', 'schema_type', 'schema_version',
'jkfit', 'jfit', 'rifit', 'admmfit', 'dftxfit', 'dftjfit',
'name', 'names', 'aliases', 'flags', 'family', 'description', 'role', 'auxiliaries',
'notes', 'function_types',
'reference_description', 'reference_keys',
'version', 'revision_description',
'data_source',
'elements', 'references', 'ecp_electrons',
'electron_shells', 'ecp_potentials', 'components',
'function_type', 'region', 'angular_momentum', 'exponents',
'coefficients',
'ecp_type', 'angular_momentum', 'r_exponents', 'gaussian_exponents',
'coefficients'
]; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 9, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 9, 21; 9, 22; 9, 23; 9, 24; 9, 25; 9, 26; 9, 27; 9, 28; 9, 29; 9, 30; 9, 31; 9, 32; 9, 33; 9, 34; 9, 35; 9, 36; 9, 37; 9, 38; 9, 39; 9, 40; 9, 41; 9, 42; 9, 43; 9, 44; 9, 45; 9, 46; 9, 47; 9, 48; 9, 49; 10, string:'molssi_bse_schema'; 11, string:'schema_type'; 12, string:'schema_version'; 13, string:'jkfit'; 14, string:'jfit'; 15, string:'rifit'; 16, string:'admmfit'; 17, string:'dftxfit'; 18, string:'dftjfit'; 19, string:'name'; 20, string:'names'; 21, string:'aliases'; 22, string:'flags'; 23, string:'family'; 24, string:'description'; 25, string:'role'; 26, string:'auxiliaries'; 27, string:'notes'; 28, string:'function_types'; 29, string:'reference_description'; 30, string:'reference_keys'; 31, string:'version'; 32, string:'revision_description'; 33, string:'data_source'; 34, string:'elements'; 35, string:'references'; 36, string:'ecp_electrons'; 37, string:'electron_shells'; 38, string:'ecp_potentials'; 39, string:'components'; 40, string:'function_type'; 41, string:'region'; 42, string:'angular_momentum'; 43, string:'exponents'; 44, string:'coefficients'; 45, string:'ecp_type'; 46, string:'angular_momentum'; 47, string:'r_exponents'; 48, string:'gaussian_exponents'; 49, string:'coefficients'; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:_keyorder; 54, identifier:extend; 55, argument_list; 55, 56; 56, list_comprehension; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:str; 59, argument_list; 59, 60; 60, identifier:x; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:x; 63, call; 63, 64; 63, 65; 64, identifier:range; 65, argument_list; 65, 66; 66, integer:150; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:bs_sorted; 70, call; 70, 71; 70, 72; 71, identifier:sorted; 72, argument_list; 72, 73; 72, 78; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:bs; 76, identifier:items; 77, argument_list; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:key; 80, lambda; 80, 81; 80, 83; 81, lambda_parameters; 81, 82; 82, identifier:x; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:_keyorder; 86, identifier:index; 87, argument_list; 87, 88; 88, subscript; 88, 89; 88, 90; 89, identifier:x; 90, integer:0; 91, if_statement; 91, 92; 91, 93; 91, 101; 92, identifier:_use_odict; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:bs_sorted; 97, call; 97, 98; 97, 99; 98, identifier:OrderedDict; 99, argument_list; 99, 100; 100, identifier:bs_sorted; 101, else_clause; 101, 102; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:bs_sorted; 106, call; 106, 107; 106, 108; 107, identifier:dict; 108, argument_list; 108, 109; 109, identifier:bs_sorted; 110, for_statement; 110, 111; 110, 114; 110, 119; 111, pattern_list; 111, 112; 111, 113; 112, identifier:k; 113, identifier:v; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:bs_sorted; 117, identifier:items; 118, argument_list; 119, block; 119, 120; 120, if_statement; 120, 121; 120, 126; 120, 136; 121, call; 121, 122; 121, 123; 122, identifier:isinstance; 123, argument_list; 123, 124; 123, 125; 124, identifier:v; 125, identifier:dict; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:bs_sorted; 131, identifier:k; 132, call; 132, 133; 132, 134; 133, identifier:sort_basis_dict; 134, argument_list; 134, 135; 135, identifier:v; 136, elif_clause; 136, 137; 136, 142; 137, call; 137, 138; 137, 139; 138, identifier:isinstance; 139, argument_list; 139, 140; 139, 141; 140, identifier:v; 141, identifier:list; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:bs_sorted; 147, identifier:k; 148, list_comprehension; 148, 149; 148, 160; 149, conditional_expression:if; 149, 150; 149, 154; 149, 159; 150, call; 150, 151; 150, 152; 151, identifier:sort_basis_dict; 152, argument_list; 152, 153; 153, identifier:x; 154, call; 154, 155; 154, 156; 155, identifier:isinstance; 156, argument_list; 156, 157; 156, 158; 157, identifier:x; 158, identifier:dict; 159, identifier:x; 160, for_in_clause; 160, 161; 160, 162; 161, identifier:x; 162, identifier:v; 163, return_statement; 163, 164; 164, identifier:bs_sorted | def sort_basis_dict(bs):
_keyorder = [
'molssi_bse_schema', 'schema_type', 'schema_version',
'jkfit', 'jfit', 'rifit', 'admmfit', 'dftxfit', 'dftjfit',
'name', 'names', 'aliases', 'flags', 'family', 'description', 'role', 'auxiliaries',
'notes', 'function_types',
'reference_description', 'reference_keys',
'version', 'revision_description',
'data_source',
'elements', 'references', 'ecp_electrons',
'electron_shells', 'ecp_potentials', 'components',
'function_type', 'region', 'angular_momentum', 'exponents',
'coefficients',
'ecp_type', 'angular_momentum', 'r_exponents', 'gaussian_exponents',
'coefficients'
]
_keyorder.extend([str(x) for x in range(150)])
bs_sorted = sorted(bs.items(), key=lambda x: _keyorder.index(x[0]))
if _use_odict:
bs_sorted = OrderedDict(bs_sorted)
else:
bs_sorted = dict(bs_sorted)
for k, v in bs_sorted.items():
if isinstance(v, dict):
bs_sorted[k] = sort_basis_dict(v)
elif isinstance(v, list):
bs_sorted[k] = [sort_basis_dict(x) if isinstance(x, dict) else x for x in v]
return bs_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_shell; 3, parameters; 3, 4; 3, 5; 4, identifier:shell; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 21; 8, 38; 8, 66; 8, 77; 8, 96; 8, 114; 8, 124; 8, 136; 8, 151; 8, 179; 8, 187; 8, 205; 8, 215; 8, 221; 9, if_statement; 9, 10; 9, 11; 10, identifier:use_copy; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:shell; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:copy; 18, identifier:deepcopy; 19, argument_list; 19, 20; 20, identifier:shell; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:tmp_c; 24, call; 24, 25; 24, 26; 25, identifier:list; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:map; 29, argument_list; 29, 30; 29, 31; 30, identifier:list; 31, call; 31, 32; 31, 33; 32, identifier:zip; 33, argument_list; 33, 34; 34, list_splat; 34, 35; 35, subscript; 35, 36; 35, 37; 36, identifier:shell; 37, string:'coefficients'; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:nonzero_idx; 41, list_comprehension; 41, 42; 41, 63; 42, call; 42, 43; 42, 44; 43, identifier:next; 44, argument_list; 44, 45; 44, 62; 45, generator_expression; 45, 46; 45, 47; 45, 55; 46, identifier:i; 47, for_in_clause; 47, 48; 47, 51; 48, pattern_list; 48, 49; 48, 50; 49, identifier:i; 50, identifier:x; 51, call; 51, 52; 51, 53; 52, identifier:enumerate; 53, argument_list; 53, 54; 54, identifier:c; 55, if_clause; 55, 56; 56, comparison_operator:!=; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:float; 59, argument_list; 59, 60; 60, identifier:x; 61, float:0.0; 62, None; 63, for_in_clause; 63, 64; 63, 65; 64, identifier:c; 65, identifier:tmp_c; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:tmp; 69, call; 69, 70; 69, 71; 70, identifier:zip; 71, argument_list; 71, 72; 71, 75; 71, 76; 72, subscript; 72, 73; 72, 74; 73, identifier:shell; 74, string:'exponents'; 75, identifier:tmp_c; 76, identifier:nonzero_idx; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:tmp; 80, call; 80, 81; 80, 82; 81, identifier:sorted; 82, argument_list; 82, 83; 82, 84; 83, identifier:tmp; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:key; 86, lambda; 86, 87; 86, 89; 87, lambda_parameters; 87, 88; 88, identifier:x; 89, unary_operator:-; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:float; 92, argument_list; 92, 93; 93, subscript; 93, 94; 93, 95; 94, identifier:x; 95, integer:0; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:tmp; 99, call; 99, 100; 99, 101; 100, identifier:sorted; 101, argument_list; 101, 102; 101, 103; 102, identifier:tmp; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:key; 105, lambda; 105, 106; 105, 108; 106, lambda_parameters; 106, 107; 107, identifier:x; 108, call; 108, 109; 108, 110; 109, identifier:int; 110, argument_list; 110, 111; 111, subscript; 111, 112; 111, 113; 112, identifier:x; 113, integer:2; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:tmp_c; 117, list_comprehension; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:x; 120, integer:1; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:x; 123, identifier:tmp; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:shell; 128, string:'exponents'; 129, list_comprehension; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:x; 132, integer:0; 133, for_in_clause; 133, 134; 133, 135; 134, identifier:x; 135, identifier:tmp; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:tmp_c; 139, call; 139, 140; 139, 141; 140, identifier:list; 141, argument_list; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:map; 144, argument_list; 144, 145; 144, 146; 145, identifier:list; 146, call; 146, 147; 146, 148; 147, identifier:zip; 148, argument_list; 148, 149; 149, list_splat; 149, 150; 150, identifier:tmp_c; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:nonzero_idx; 154, list_comprehension; 154, 155; 154, 176; 155, call; 155, 156; 155, 157; 156, identifier:next; 157, argument_list; 157, 158; 157, 175; 158, generator_expression; 158, 159; 158, 160; 158, 168; 159, identifier:i; 160, for_in_clause; 160, 161; 160, 164; 161, pattern_list; 161, 162; 161, 163; 162, identifier:i; 163, identifier:x; 164, call; 164, 165; 164, 166; 165, identifier:enumerate; 166, argument_list; 166, 167; 167, identifier:c; 168, if_clause; 168, 169; 169, comparison_operator:!=; 169, 170; 169, 174; 170, call; 170, 171; 170, 172; 171, identifier:float; 172, argument_list; 172, 173; 173, identifier:x; 174, float:0.0; 175, None; 176, for_in_clause; 176, 177; 176, 178; 177, identifier:c; 178, identifier:tmp_c; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:tmp; 182, call; 182, 183; 182, 184; 183, identifier:zip; 184, argument_list; 184, 185; 184, 186; 185, identifier:tmp_c; 186, identifier:nonzero_idx; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:tmp; 190, call; 190, 191; 190, 192; 191, identifier:sorted; 192, argument_list; 192, 193; 192, 194; 193, identifier:tmp; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:key; 196, lambda; 196, 197; 196, 199; 197, lambda_parameters; 197, 198; 198, identifier:x; 199, call; 199, 200; 199, 201; 200, identifier:int; 201, argument_list; 201, 202; 202, subscript; 202, 203; 202, 204; 203, identifier:x; 204, integer:1; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:tmp_c; 208, list_comprehension; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:x; 211, integer:0; 212, for_in_clause; 212, 213; 212, 214; 213, identifier:x; 214, identifier:tmp; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 220; 217, subscript; 217, 218; 217, 219; 218, identifier:shell; 219, string:'coefficients'; 220, identifier:tmp_c; 221, return_statement; 221, 222; 222, identifier:shell | def sort_shell(shell, use_copy=True):
if use_copy:
shell = copy.deepcopy(shell)
tmp_c = list(map(list, zip(*shell['coefficients'])))
nonzero_idx = [next((i for i, x in enumerate(c) if float(x) != 0.0), None) for c in tmp_c]
tmp = zip(shell['exponents'], tmp_c, nonzero_idx)
tmp = sorted(tmp, key=lambda x: -float(x[0]))
tmp = sorted(tmp, key=lambda x: int(x[2]))
tmp_c = [x[1] for x in tmp]
shell['exponents'] = [x[0] for x in tmp]
tmp_c = list(map(list, zip(*tmp_c)))
nonzero_idx = [next((i for i, x in enumerate(c) if float(x) != 0.0), None) for c in tmp_c]
tmp = zip(tmp_c, nonzero_idx)
tmp = sorted(tmp, key=lambda x: int(x[1]))
tmp_c = [x[0] for x in tmp]
shell['coefficients'] = tmp_c
return shell |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_shells; 3, parameters; 3, 4; 3, 5; 4, identifier:shells; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 21; 8, 33; 9, if_statement; 9, 10; 9, 11; 10, identifier:use_copy; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:shells; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:copy; 18, identifier:deepcopy; 19, argument_list; 19, 20; 20, identifier:shells; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:shells; 24, list_comprehension; 24, 25; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:sort_shell; 27, argument_list; 27, 28; 27, 29; 28, identifier:sh; 29, False; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:sh; 32, identifier:shells; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:list; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:sorted; 39, argument_list; 39, 40; 39, 41; 40, identifier:shells; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:key; 43, lambda; 43, 44; 43, 46; 44, lambda_parameters; 44, 45; 45, identifier:x; 46, tuple; 46, 47; 46, 53; 46, 60; 46, 67; 47, call; 47, 48; 47, 49; 48, identifier:max; 49, argument_list; 49, 50; 50, subscript; 50, 51; 50, 52; 51, identifier:x; 52, string:'angular_momentum'; 53, unary_operator:-; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:len; 56, argument_list; 56, 57; 57, subscript; 57, 58; 57, 59; 58, identifier:x; 59, string:'exponents'; 60, unary_operator:-; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:len; 63, argument_list; 63, 64; 64, subscript; 64, 65; 64, 66; 65, identifier:x; 66, string:'coefficients'; 67, unary_operator:-; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:float; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:max; 73, argument_list; 73, 74; 74, subscript; 74, 75; 74, 76; 75, identifier:x; 76, string:'exponents' | def sort_shells(shells, use_copy=True):
if use_copy:
shells = copy.deepcopy(shells)
shells = [sort_shell(sh, False) for sh in shells]
return list(
sorted(
shells,
key=lambda x: (max(x['angular_momentum']), -len(x['exponents']), -len(x['coefficients']), -float(
max(x['exponents']))))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_potentials; 3, parameters; 3, 4; 3, 5; 4, identifier:potentials; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 21; 8, 39; 8, 51; 9, if_statement; 9, 10; 9, 11; 10, identifier:use_copy; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:potentials; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:copy; 18, identifier:deepcopy; 19, argument_list; 19, 20; 20, identifier:potentials; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:potentials; 24, call; 24, 25; 24, 26; 25, identifier:list; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:sorted; 29, argument_list; 29, 30; 29, 31; 30, identifier:potentials; 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, subscript; 36, 37; 36, 38; 37, identifier:x; 38, string:'angular_momentum'; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:potentials; 43, identifier:insert; 44, argument_list; 44, 45; 44, 46; 45, integer:0; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:potentials; 49, identifier:pop; 50, argument_list; 51, return_statement; 51, 52; 52, identifier:potentials | def sort_potentials(potentials, use_copy=True):
if use_copy:
potentials = copy.deepcopy(potentials)
potentials = list(sorted(potentials, key=lambda x: x['angular_momentum']))
potentials.insert(0, potentials.pop())
return potentials |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_basis; 3, parameters; 3, 4; 3, 5; 4, identifier:basis; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 21; 8, 67; 9, if_statement; 9, 10; 9, 11; 10, identifier:use_copy; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:basis; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:copy; 18, identifier:deepcopy; 19, argument_list; 19, 20; 20, identifier:basis; 21, for_statement; 21, 22; 21, 25; 21, 32; 22, pattern_list; 22, 23; 22, 24; 23, identifier:k; 24, identifier:el; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:basis; 29, string:'elements'; 30, identifier:items; 31, argument_list; 32, block; 32, 33; 32, 50; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:in; 34, 35; 34, 36; 35, string:'electron_shells'; 36, identifier:el; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:el; 42, string:'electron_shells'; 43, call; 43, 44; 43, 45; 44, identifier:sort_shells; 45, argument_list; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:el; 48, string:'electron_shells'; 49, False; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:in; 51, 52; 51, 53; 52, string:'ecp_potentials'; 53, identifier:el; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:el; 59, string:'ecp_potentials'; 60, call; 60, 61; 60, 62; 61, identifier:sort_potentials; 62, argument_list; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:el; 65, string:'ecp_potentials'; 66, False; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:sort_basis_dict; 70, argument_list; 70, 71; 71, identifier:basis | def sort_basis(basis, use_copy=True):
if use_copy:
basis = copy.deepcopy(basis)
for k, el in basis['elements'].items():
if 'electron_shells' in el:
el['electron_shells'] = sort_shells(el['electron_shells'], False)
if 'ecp_potentials' in el:
el['ecp_potentials'] = sort_potentials(el['ecp_potentials'], False)
return sort_basis_dict(basis) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_single_reference; 3, parameters; 3, 4; 4, identifier:ref_entry; 5, block; 5, 6; 5, 29; 5, 53; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:_keyorder; 9, list:[
'schema_type', 'schema_version',
'type',
'authors', 'title', 'booktitle', 'series', 'editors', 'journal',
'institution', 'volume', 'number', 'page', 'year', 'note', 'publisher',
'address', 'isbn', 'doi'
]; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 9, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 9, 21; 9, 22; 9, 23; 9, 24; 9, 25; 9, 26; 9, 27; 9, 28; 10, string:'schema_type'; 11, string:'schema_version'; 12, string:'type'; 13, string:'authors'; 14, string:'title'; 15, string:'booktitle'; 16, string:'series'; 17, string:'editors'; 18, string:'journal'; 19, string:'institution'; 20, string:'volume'; 21, string:'number'; 22, string:'page'; 23, string:'year'; 24, string:'note'; 25, string:'publisher'; 26, string:'address'; 27, string:'isbn'; 28, string:'doi'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:sorted_entry; 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:ref_entry; 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:x; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:_keyorder; 48, identifier:index; 49, argument_list; 49, 50; 50, subscript; 50, 51; 50, 52; 51, identifier:x; 52, integer:0; 53, if_statement; 53, 54; 53, 55; 53, 61; 54, identifier:_use_odict; 55, block; 55, 56; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:OrderedDict; 59, argument_list; 59, 60; 60, identifier:sorted_entry; 61, else_clause; 61, 62; 62, block; 62, 63; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:dict; 66, argument_list; 66, 67; 67, identifier:sorted_entry | def sort_single_reference(ref_entry):
_keyorder = [
'schema_type', 'schema_version',
'type',
'authors', 'title', 'booktitle', 'series', 'editors', 'journal',
'institution', 'volume', 'number', 'page', 'year', 'note', 'publisher',
'address', 'isbn', 'doi'
]
sorted_entry = sorted(ref_entry.items(), key=lambda x: _keyorder.index(x[0]))
if _use_odict:
return OrderedDict(sorted_entry)
else:
return dict(sorted_entry) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_references_dict; 3, parameters; 3, 4; 4, identifier:refs; 5, block; 5, 6; 5, 23; 5, 31; 5, 53; 6, if_statement; 6, 7; 6, 8; 6, 15; 7, identifier:_use_odict; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:refs_sorted; 12, call; 12, 13; 12, 14; 13, identifier:OrderedDict; 14, argument_list; 15, else_clause; 15, 16; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:refs_sorted; 20, call; 20, 21; 20, 22; 21, identifier:dict; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:refs_sorted; 27, string:'molssi_bse_schema'; 28, subscript; 28, 29; 28, 30; 29, identifier:refs; 30, string:'molssi_bse_schema'; 31, for_statement; 31, 32; 31, 35; 31, 43; 32, pattern_list; 32, 33; 32, 34; 33, identifier:k; 34, identifier:v; 35, call; 35, 36; 35, 37; 36, identifier:sorted; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:refs; 41, identifier:items; 42, argument_list; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:refs_sorted; 48, identifier:k; 49, call; 49, 50; 49, 51; 50, identifier:sort_single_reference; 51, argument_list; 51, 52; 52, identifier:v; 53, return_statement; 53, 54; 54, identifier:refs_sorted | def sort_references_dict(refs):
if _use_odict:
refs_sorted = OrderedDict()
else:
refs_sorted = dict()
refs_sorted['molssi_bse_schema'] = refs['molssi_bse_schema']
for k, v in sorted(refs.items()):
refs_sorted[k] = sort_single_reference(v)
return refs_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:make_general; 3, parameters; 3, 4; 3, 5; 4, identifier:basis; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_copy; 7, True; 8, block; 8, 9; 8, 13; 8, 22; 8, 276; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:zero; 12, string:'0.00000000'; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:basis; 16, call; 16, 17; 16, 18; 17, identifier:uncontract_spdf; 18, argument_list; 18, 19; 18, 20; 18, 21; 19, identifier:basis; 20, integer:0; 21, identifier:use_copy; 22, for_statement; 22, 23; 22, 26; 22, 33; 23, pattern_list; 23, 24; 23, 25; 24, identifier:k; 25, identifier:el; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:basis; 30, string:'elements'; 31, identifier:items; 32, argument_list; 33, block; 33, 34; 33, 41; 33, 45; 33, 68; 33, 75; 33, 79; 33, 270; 34, if_statement; 34, 35; 34, 39; 35, not_operator; 35, 36; 36, comparison_operator:in; 36, 37; 36, 38; 37, string:'electron_shells'; 38, identifier:el; 39, block; 39, 40; 40, continue_statement; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:all_am; 44, list:[]; 45, for_statement; 45, 46; 45, 47; 45, 50; 46, identifier:sh; 47, subscript; 47, 48; 47, 49; 48, identifier:el; 49, string:'electron_shells'; 50, block; 50, 51; 51, if_statement; 51, 52; 51, 58; 52, not_operator; 52, 53; 53, comparison_operator:in; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:sh; 56, string:'angular_momentum'; 57, identifier:all_am; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:all_am; 63, identifier:append; 64, argument_list; 64, 65; 65, subscript; 65, 66; 65, 67; 66, identifier:sh; 67, string:'angular_momentum'; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:all_am; 71, call; 71, 72; 71, 73; 72, identifier:sorted; 73, argument_list; 73, 74; 74, identifier:all_am; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:newshells; 78, list:[]; 79, for_statement; 79, 80; 79, 81; 79, 82; 80, identifier:am; 81, identifier:all_am; 82, block; 82, 83; 82, 102; 82, 127; 82, 136; 82, 140; 82, 263; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:newsh; 86, dictionary; 86, 87; 86, 90; 86, 93; 86, 96; 86, 99; 87, pair; 87, 88; 87, 89; 88, string:'angular_momentum'; 89, identifier:am; 90, pair; 90, 91; 90, 92; 91, string:'exponents'; 92, list:[]; 93, pair; 93, 94; 93, 95; 94, string:'coefficients'; 95, list:[]; 96, pair; 96, 97; 96, 98; 97, string:'region'; 98, string:''; 99, pair; 99, 100; 99, 101; 100, string:'function_type'; 101, None; 102, for_statement; 102, 103; 102, 104; 102, 107; 103, identifier:sh; 104, subscript; 104, 105; 104, 106; 105, identifier:el; 106, string:'electron_shells'; 107, block; 107, 108; 107, 116; 108, if_statement; 108, 109; 108, 114; 109, comparison_operator:!=; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:sh; 112, string:'angular_momentum'; 113, identifier:am; 114, block; 114, 115; 115, continue_statement; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:newsh; 121, string:'exponents'; 122, identifier:extend; 123, argument_list; 123, 124; 124, subscript; 124, 125; 124, 126; 125, identifier:sh; 126, string:'exponents'; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:nprim; 130, call; 130, 131; 130, 132; 131, identifier:len; 132, argument_list; 132, 133; 133, subscript; 133, 134; 133, 135; 134, identifier:newsh; 135, string:'exponents'; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:cur_prim; 139, integer:0; 140, for_statement; 140, 141; 140, 142; 140, 145; 141, identifier:sh; 142, subscript; 142, 143; 142, 144; 143, identifier:el; 144, string:'electron_shells'; 145, block; 145, 146; 145, 154; 145, 169; 145, 175; 145, 181; 145, 195; 145, 204; 145, 254; 146, if_statement; 146, 147; 146, 152; 147, comparison_operator:!=; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:sh; 150, string:'angular_momentum'; 151, identifier:am; 152, block; 152, 153; 153, continue_statement; 154, if_statement; 154, 155; 154, 160; 155, comparison_operator:is; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:newsh; 158, string:'function_type'; 159, None; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:newsh; 165, string:'function_type'; 166, subscript; 166, 167; 166, 168; 167, identifier:sh; 168, string:'function_type'; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:ft1; 172, subscript; 172, 173; 172, 174; 173, identifier:newsh; 174, string:'function_type'; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:ft2; 178, subscript; 178, 179; 178, 180; 179, identifier:sh; 180, string:'function_type'; 181, if_statement; 181, 182; 181, 189; 182, boolean_operator:and; 182, 183; 182, 186; 183, comparison_operator:not; 183, 184; 183, 185; 184, identifier:ft1; 185, identifier:ft2; 186, comparison_operator:not; 186, 187; 186, 188; 187, identifier:ft2; 188, identifier:ft1; 189, block; 189, 190; 190, raise_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:RuntimeError; 193, argument_list; 193, 194; 194, string:"Cannot make general contraction of different function types"; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:ngen; 198, call; 198, 199; 198, 200; 199, identifier:len; 200, argument_list; 200, 201; 201, subscript; 201, 202; 201, 203; 202, identifier:sh; 203, string:'coefficients'; 204, for_statement; 204, 205; 204, 206; 204, 210; 205, identifier:g; 206, call; 206, 207; 206, 208; 207, identifier:range; 208, argument_list; 208, 209; 209, identifier:ngen; 210, block; 210, 211; 210, 218; 210, 229; 210, 245; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:coef; 214, binary_operator:*; 214, 215; 214, 217; 215, list:[zero]; 215, 216; 216, identifier:zero; 217, identifier:cur_prim; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:coef; 222, identifier:extend; 223, argument_list; 223, 224; 224, subscript; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:sh; 227, string:'coefficients'; 228, identifier:g; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:coef; 233, identifier:extend; 234, argument_list; 234, 235; 235, binary_operator:*; 235, 236; 235, 238; 236, list:[zero]; 236, 237; 237, identifier:zero; 238, parenthesized_expression; 238, 239; 239, binary_operator:-; 239, 240; 239, 241; 240, identifier:nprim; 241, call; 241, 242; 241, 243; 242, identifier:len; 243, argument_list; 243, 244; 244, identifier:coef; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, subscript; 248, 249; 248, 250; 249, identifier:newsh; 250, string:'coefficients'; 251, identifier:append; 252, argument_list; 252, 253; 253, identifier:coef; 254, expression_statement; 254, 255; 255, augmented_assignment:+=; 255, 256; 255, 257; 256, identifier:cur_prim; 257, call; 257, 258; 257, 259; 258, identifier:len; 259, argument_list; 259, 260; 260, subscript; 260, 261; 260, 262; 261, identifier:sh; 262, string:'exponents'; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:newshells; 267, identifier:append; 268, argument_list; 268, 269; 269, identifier:newsh; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:el; 274, string:'electron_shells'; 275, identifier:newshells; 276, return_statement; 276, 277; 277, identifier:basis | def make_general(basis, use_copy=True):
zero = '0.00000000'
basis = uncontract_spdf(basis, 0, use_copy)
for k, el in basis['elements'].items():
if not 'electron_shells' in el:
continue
all_am = []
for sh in el['electron_shells']:
if not sh['angular_momentum'] in all_am:
all_am.append(sh['angular_momentum'])
all_am = sorted(all_am)
newshells = []
for am in all_am:
newsh = {
'angular_momentum': am,
'exponents': [],
'coefficients': [],
'region': '',
'function_type': None,
}
for sh in el['electron_shells']:
if sh['angular_momentum'] != am:
continue
newsh['exponents'].extend(sh['exponents'])
nprim = len(newsh['exponents'])
cur_prim = 0
for sh in el['electron_shells']:
if sh['angular_momentum'] != am:
continue
if newsh['function_type'] is None:
newsh['function_type'] = sh['function_type']
ft1 = newsh['function_type']
ft2 = sh['function_type']
if ft1 not in ft2 and ft2 not in ft1:
raise RuntimeError("Cannot make general contraction of different function types")
ngen = len(sh['coefficients'])
for g in range(ngen):
coef = [zero] * cur_prim
coef.extend(sh['coefficients'][g])
coef.extend([zero] * (nprim - len(coef)))
newsh['coefficients'].append(coef)
cur_prim += len(sh['exponents'])
newshells.append(newsh)
el['electron_shells'] = newshells
return basis |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:ComputeApplicationUniquifier; 3, parameters; 3, 4; 4, identifier:hash_obj; 5, block; 5, 6; 5, 144; 5, 193; 5, 259; 6, function_definition; 6, 7; 6, 8; 6, 14; 7, function_name:ProcessDirectory; 8, parameters; 8, 9; 8, 10; 8, 11; 9, identifier:path; 10, identifier:relative_path; 11, default_parameter; 11, 12; 11, 13; 12, identifier:depth; 13, integer:1; 14, block; 14, 15; 14, 21; 14, 36; 14, 42; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:>; 16, 17; 16, 18; 17, identifier:depth; 18, identifier:_MAX_DEPTH; 19, block; 19, 20; 20, return_statement; 21, try_statement; 21, 22; 21, 32; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:names; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:os; 29, identifier:listdir; 30, argument_list; 30, 31; 31, identifier:path; 32, except_clause; 32, 33; 32, 34; 33, identifier:BaseException; 34, block; 34, 35; 35, return_statement; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:modules; 39, call; 39, 40; 39, 41; 40, identifier:set; 41, argument_list; 42, for_statement; 42, 43; 42, 44; 42, 48; 43, identifier:name; 44, call; 44, 45; 44, 46; 45, identifier:sorted; 46, argument_list; 46, 47; 47, identifier:names; 48, block; 48, 49; 48, 61; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:current_path; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:os; 56, identifier:path; 57, identifier:join; 58, argument_list; 58, 59; 58, 60; 59, identifier:path; 60, identifier:name; 61, if_statement; 61, 62; 61, 71; 61, 121; 62, not_operator; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:os; 67, identifier:path; 68, identifier:isdir; 69, argument_list; 69, 70; 70, identifier:current_path; 71, block; 71, 72; 71, 85; 71, 94; 71, 100; 71, 107; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, pattern_list; 74, 75; 74, 76; 75, identifier:file_name; 76, identifier:ext; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:os; 81, identifier:path; 82, identifier:splitext; 83, argument_list; 83, 84; 84, identifier:name; 85, if_statement; 85, 86; 85, 92; 86, comparison_operator:not; 86, 87; 86, 88; 87, identifier:ext; 88, tuple; 88, 89; 88, 90; 88, 91; 89, string:'.py'; 90, string:'.pyc'; 91, string:'.pyo'; 92, block; 92, 93; 93, continue_statement; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:in; 95, 96; 95, 97; 96, identifier:file_name; 97, identifier:modules; 98, block; 98, 99; 99, continue_statement; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:modules; 104, identifier:add; 105, argument_list; 105, 106; 106, identifier:file_name; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:ProcessApplicationFile; 110, argument_list; 110, 111; 110, 112; 111, identifier:current_path; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:os; 116, identifier:path; 117, identifier:join; 118, argument_list; 118, 119; 118, 120; 119, identifier:relative_path; 120, identifier:name; 121, elif_clause; 121, 122; 121, 126; 122, call; 122, 123; 122, 124; 123, identifier:IsPackage; 124, argument_list; 124, 125; 125, identifier:current_path; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:ProcessDirectory; 130, argument_list; 130, 131; 130, 132; 130, 141; 131, identifier:current_path; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:os; 136, identifier:path; 137, identifier:join; 138, argument_list; 138, 139; 138, 140; 139, identifier:relative_path; 140, identifier:name; 141, binary_operator:+; 141, 142; 141, 143; 142, identifier:depth; 143, integer:1; 144, function_definition; 144, 145; 144, 146; 144, 148; 145, function_name:IsPackage; 146, parameters; 146, 147; 147, identifier:path; 148, block; 148, 149; 148, 161; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:init_base_path; 152, call; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:os; 156, identifier:path; 157, identifier:join; 158, argument_list; 158, 159; 158, 160; 159, identifier:path; 160, string:'__init__.py'; 161, return_statement; 161, 162; 162, parenthesized_expression; 162, 163; 163, boolean_operator:or; 163, 164; 163, 183; 164, boolean_operator:or; 164, 165; 164, 173; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:os; 169, identifier:path; 170, identifier:isfile; 171, argument_list; 171, 172; 172, identifier:init_base_path; 173, call; 173, 174; 173, 179; 174, attribute; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:os; 177, identifier:path; 178, identifier:isfile; 179, argument_list; 179, 180; 180, binary_operator:+; 180, 181; 180, 182; 181, identifier:init_base_path; 182, string:'c'; 183, call; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:os; 187, identifier:path; 188, identifier:isfile; 189, argument_list; 189, 190; 190, binary_operator:+; 190, 191; 190, 192; 191, identifier:init_base_path; 192, string:'o'; 193, function_definition; 193, 194; 193, 195; 193, 198; 194, function_name:ProcessApplicationFile; 195, parameters; 195, 196; 195, 197; 196, identifier:path; 197, identifier:relative_path; 198, block; 198, 199; 198, 210; 198, 221; 198, 248; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:hash_obj; 203, identifier:update; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:relative_path; 208, identifier:encode; 209, argument_list; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:hash_obj; 214, identifier:update; 215, argument_list; 215, 216; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, string:':'; 219, identifier:encode; 220, argument_list; 221, try_statement; 221, 222; 221, 244; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:hash_obj; 227, identifier:update; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 243; 230, attribute; 230, 231; 230, 242; 231, call; 231, 232; 231, 233; 232, identifier:str; 233, argument_list; 233, 234; 234, attribute; 234, 235; 234, 241; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:os; 238, identifier:stat; 239, argument_list; 239, 240; 240, identifier:path; 241, identifier:st_size; 242, identifier:encode; 243, argument_list; 244, except_clause; 244, 245; 244, 246; 245, identifier:BaseException; 246, block; 246, 247; 247, pass_statement; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:hash_obj; 252, identifier:update; 253, argument_list; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, string:'\n'; 257, identifier:encode; 258, argument_list; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 262; 261, identifier:ProcessDirectory; 262, argument_list; 262, 263; 262, 268; 263, subscript; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:sys; 266, identifier:path; 267, integer:0; 268, string:'' | def ComputeApplicationUniquifier(hash_obj):
def ProcessDirectory(path, relative_path, depth=1):
if depth > _MAX_DEPTH:
return
try:
names = os.listdir(path)
except BaseException:
return
modules = set()
for name in sorted(names):
current_path = os.path.join(path, name)
if not os.path.isdir(current_path):
file_name, ext = os.path.splitext(name)
if ext not in ('.py', '.pyc', '.pyo'):
continue
if file_name in modules:
continue
modules.add(file_name)
ProcessApplicationFile(current_path, os.path.join(relative_path, name))
elif IsPackage(current_path):
ProcessDirectory(current_path,
os.path.join(relative_path, name),
depth + 1)
def IsPackage(path):
init_base_path = os.path.join(path, '__init__.py')
return (os.path.isfile(init_base_path) or
os.path.isfile(init_base_path + 'c') or
os.path.isfile(init_base_path + 'o'))
def ProcessApplicationFile(path, relative_path):
hash_obj.update(relative_path.encode())
hash_obj.update(':'.encode())
try:
hash_obj.update(str(os.stat(path).st_size).encode())
except BaseException:
pass
hash_obj.update('\n'.encode())
ProcessDirectory(sys.path[0], '') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_set_player; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 114; 5, 141; 5, 152; 5, 158; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:players; 9, list:[]; 10, for_statement; 10, 11; 10, 14; 10, 21; 11, pattern_list; 11, 12; 11, 13; 12, identifier:name; 13, identifier:p; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_mpris_players; 19, identifier:items; 20, argument_list; 21, block; 21, 22; 21, 87; 22, if_statement; 22, 23; 22, 26; 23, comparison_operator:not; 23, 24; 23, 25; 24, string:"_priority"; 25, identifier:p; 26, block; 26, 27; 26, 76; 27, if_statement; 27, 28; 27, 31; 27, 70; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:player_priority; 31, block; 31, 32; 32, try_statement; 32, 33; 32, 47; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:priority; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:player_priority; 42, identifier:index; 43, argument_list; 43, 44; 44, subscript; 44, 45; 44, 46; 45, identifier:p; 46, string:"name"; 47, except_clause; 47, 48; 47, 49; 48, identifier:ValueError; 49, block; 49, 50; 50, try_statement; 50, 51; 50, 63; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:priority; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:player_priority; 60, identifier:index; 61, argument_list; 61, 62; 62, string:"*"; 63, except_clause; 63, 64; 63, 65; 64, identifier:ValueError; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:priority; 69, None; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:priority; 75, integer:0; 76, if_statement; 76, 77; 76, 80; 77, comparison_operator:is; 77, 78; 77, 79; 78, identifier:priority; 79, None; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:p; 85, string:"_priority"; 86, identifier:priority; 87, if_statement; 87, 88; 87, 96; 88, comparison_operator:is; 88, 89; 88, 95; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:p; 92, identifier:get; 93, argument_list; 93, 94; 94, string:"_priority"; 95, None; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:players; 101, identifier:append; 102, argument_list; 102, 103; 103, tuple; 103, 104; 103, 107; 103, 110; 103, 113; 104, subscript; 104, 105; 104, 106; 105, identifier:p; 106, string:"_state_priority"; 107, subscript; 107, 108; 107, 109; 108, identifier:p; 109, string:"_priority"; 110, subscript; 110, 111; 110, 112; 111, identifier:p; 112, string:"index"; 113, identifier:name; 114, if_statement; 114, 115; 114, 116; 114, 135; 115, identifier:players; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:top_player; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_mpris_players; 125, identifier:get; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 134; 128, subscript; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:sorted; 131, argument_list; 131, 132; 132, identifier:players; 133, integer:0; 134, integer:3; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:top_player; 140, dictionary; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_player; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:top_player; 149, identifier:get; 150, argument_list; 150, 151; 151, string:"_dbus_player"; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_player_details; 157, identifier:top_player; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 165; 160, attribute; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:self; 163, identifier:py3; 164, identifier:update; 165, argument_list | def _set_player(self):
players = []
for name, p in self._mpris_players.items():
if "_priority" not in p:
if self.player_priority:
try:
priority = self.player_priority.index(p["name"])
except ValueError:
try:
priority = self.player_priority.index("*")
except ValueError:
priority = None
else:
priority = 0
if priority is not None:
p["_priority"] = priority
if p.get("_priority") is not None:
players.append((p["_state_priority"], p["_priority"], p["index"], name))
if players:
top_player = self._mpris_players.get(sorted(players)[0][3])
else:
top_player = {}
self._player = top_player.get("_dbus_player")
self._player_details = top_player
self.py3.update() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:file_sort; 3, parameters; 3, 4; 4, identifier:my_list; 5, block; 5, 6; 5, 33; 5, 42; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:alphanum_key; 8, parameters; 8, 9; 9, identifier:key; 10, block; 10, 11; 11, return_statement; 11, 12; 12, list_comprehension; 12, 13; 12, 24; 13, conditional_expression:if; 13, 14; 13, 18; 13, 23; 14, call; 14, 15; 14, 16; 15, identifier:int; 16, argument_list; 16, 17; 17, identifier:s; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:s; 21, identifier:isdigit; 22, argument_list; 23, identifier:s; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:s; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:re; 29, identifier:split; 30, argument_list; 30, 31; 30, 32; 31, string:"([0-9]+)"; 32, identifier:key; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:my_list; 37, identifier:sort; 38, argument_list; 38, 39; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:key; 41, identifier:alphanum_key; 42, return_statement; 42, 43; 43, identifier:my_list | def file_sort(my_list):
def alphanum_key(key):
return [int(s) if s.isdigit() else s for s in re.split("([0-9]+)", key)]
my_list.sort(key=alphanum_key)
return my_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:squad; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:R_in; 5, identifier:t_in; 6, identifier:t_out; 7, block; 7, 8; 7, 33; 7, 47; 7, 119; 7, 214; 7, 222; 7, 232; 7, 242; 7, 264; 7, 275; 7, 297; 7, 308; 7, 319; 7, 340; 7, 357; 7, 376; 8, if_statement; 8, 9; 8, 20; 9, boolean_operator:or; 9, 10; 9, 15; 10, comparison_operator:==; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:R_in; 13, identifier:size; 14, integer:0; 15, comparison_operator:==; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:t_out; 18, identifier:size; 19, integer:0; 20, block; 20, 21; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:array; 26, argument_list; 26, 27; 26, 28; 27, tuple; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:dtype; 30, attribute; 30, 31; 30, 32; 31, identifier:np; 32, identifier:quaternion; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:i_in_for_out; 36, binary_operator:-; 36, 37; 36, 46; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:t_in; 40, identifier:searchsorted; 41, argument_list; 41, 42; 41, 43; 42, identifier:t_out; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:side; 45, string:'right'; 46, integer:1; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:A; 50, binary_operator:*; 50, 51; 50, 52; 51, identifier:R_in; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:np; 55, identifier:exp; 56, argument_list; 56, 57; 57, binary_operator:*; 57, 58; 57, 118; 58, parenthesized_expression; 58, 59; 59, binary_operator:+; 59, 60; 59, 78; 60, unary_operator:-; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:np; 64, identifier:log; 65, argument_list; 65, 66; 66, binary_operator:*; 66, 67; 66, 70; 67, parenthesized_expression; 67, 68; 68, unary_operator:~; 68, 69; 69, identifier:R_in; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:np; 73, identifier:roll; 74, argument_list; 74, 75; 74, 76; 75, identifier:R_in; 76, unary_operator:-; 76, 77; 77, integer:1; 78, binary_operator:*; 78, 79; 78, 95; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:log; 83, argument_list; 83, 84; 84, binary_operator:*; 84, 85; 84, 94; 85, parenthesized_expression; 85, 86; 86, unary_operator:~; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:roll; 91, argument_list; 91, 92; 91, 93; 92, identifier:R_in; 93, integer:1; 94, identifier:R_in; 95, parenthesized_expression; 95, 96; 96, binary_operator:/; 96, 97; 96, 108; 97, parenthesized_expression; 97, 98; 98, binary_operator:-; 98, 99; 98, 107; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:np; 102, identifier:roll; 103, argument_list; 103, 104; 103, 105; 104, identifier:t_in; 105, unary_operator:-; 105, 106; 106, integer:1; 107, identifier:t_in; 108, parenthesized_expression; 108, 109; 109, binary_operator:-; 109, 110; 109, 111; 110, identifier:t_in; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:np; 114, identifier:roll; 115, argument_list; 115, 116; 115, 117; 116, identifier:t_in; 117, integer:1; 118, float:0.25; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:B; 122, binary_operator:*; 122, 123; 122, 131; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:np; 126, identifier:roll; 127, argument_list; 127, 128; 127, 129; 128, identifier:R_in; 129, unary_operator:-; 129, 130; 130, integer:1; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:np; 134, identifier:exp; 135, argument_list; 135, 136; 136, binary_operator:*; 136, 137; 136, 212; 137, parenthesized_expression; 137, 138; 138, binary_operator:-; 138, 139; 138, 195; 139, binary_operator:*; 139, 140; 139, 164; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:np; 143, identifier:log; 144, argument_list; 144, 145; 145, binary_operator:*; 145, 146; 145, 156; 146, parenthesized_expression; 146, 147; 147, unary_operator:~; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:np; 151, identifier:roll; 152, argument_list; 152, 153; 152, 154; 153, identifier:R_in; 154, unary_operator:-; 154, 155; 155, integer:1; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:np; 159, identifier:roll; 160, argument_list; 160, 161; 160, 162; 161, identifier:R_in; 162, unary_operator:-; 162, 163; 163, integer:2; 164, parenthesized_expression; 164, 165; 165, binary_operator:/; 165, 166; 165, 177; 166, parenthesized_expression; 166, 167; 167, binary_operator:-; 167, 168; 167, 176; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:np; 171, identifier:roll; 172, argument_list; 172, 173; 172, 174; 173, identifier:t_in; 174, unary_operator:-; 174, 175; 175, integer:1; 176, identifier:t_in; 177, parenthesized_expression; 177, 178; 178, binary_operator:-; 178, 179; 178, 187; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:np; 182, identifier:roll; 183, argument_list; 183, 184; 183, 185; 184, identifier:t_in; 185, unary_operator:-; 185, 186; 186, integer:2; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:np; 190, identifier:roll; 191, argument_list; 191, 192; 191, 193; 192, identifier:t_in; 193, unary_operator:-; 193, 194; 194, integer:1; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:np; 198, identifier:log; 199, argument_list; 199, 200; 200, binary_operator:*; 200, 201; 200, 204; 201, parenthesized_expression; 201, 202; 202, unary_operator:~; 202, 203; 203, identifier:R_in; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:np; 207, identifier:roll; 208, argument_list; 208, 209; 208, 210; 209, identifier:R_in; 210, unary_operator:-; 210, 211; 211, integer:1; 212, unary_operator:-; 212, 213; 213, float:0.25; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:A; 218, integer:0; 219, subscript; 219, 220; 219, 221; 220, identifier:R_in; 221, integer:0; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 228; 224, subscript; 224, 225; 224, 226; 225, identifier:A; 226, unary_operator:-; 226, 227; 227, integer:1; 228, subscript; 228, 229; 228, 230; 229, identifier:R_in; 230, unary_operator:-; 230, 231; 231, integer:1; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 238; 234, subscript; 234, 235; 234, 236; 235, identifier:B; 236, unary_operator:-; 236, 237; 237, integer:2; 238, subscript; 238, 239; 238, 240; 239, identifier:R_in; 240, unary_operator:-; 240, 241; 241, integer:1; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 248; 244, subscript; 244, 245; 244, 246; 245, identifier:B; 246, unary_operator:-; 246, 247; 247, integer:1; 248, binary_operator:*; 248, 249; 248, 260; 249, binary_operator:*; 249, 250; 249, 254; 250, subscript; 250, 251; 250, 252; 251, identifier:R_in; 252, unary_operator:-; 252, 253; 253, integer:1; 254, parenthesized_expression; 254, 255; 255, unary_operator:~; 255, 256; 256, subscript; 256, 257; 256, 258; 257, identifier:R_in; 258, unary_operator:-; 258, 259; 259, integer:2; 260, subscript; 260, 261; 260, 262; 261, identifier:R_in; 262, unary_operator:-; 262, 263; 263, integer:1; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:R_ip1; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:np; 270, identifier:roll; 271, argument_list; 271, 272; 271, 273; 272, identifier:R_in; 273, unary_operator:-; 273, 274; 274, integer:1; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 281; 277, subscript; 277, 278; 277, 279; 278, identifier:R_ip1; 279, unary_operator:-; 279, 280; 280, integer:1; 281, binary_operator:*; 281, 282; 281, 293; 282, binary_operator:*; 282, 283; 282, 287; 283, subscript; 283, 284; 283, 285; 284, identifier:R_in; 285, unary_operator:-; 285, 286; 286, integer:1; 287, parenthesized_expression; 287, 288; 288, unary_operator:~; 288, 289; 289, subscript; 289, 290; 289, 291; 290, identifier:R_in; 291, unary_operator:-; 291, 292; 292, integer:2; 293, subscript; 293, 294; 293, 295; 294, identifier:R_in; 295, unary_operator:-; 295, 296; 296, integer:1; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:R_ip1; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:np; 303, identifier:array; 304, argument_list; 304, 305; 305, subscript; 305, 306; 305, 307; 306, identifier:R_ip1; 307, identifier:i_in_for_out; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:t_inp1; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:np; 314, identifier:roll; 315, argument_list; 315, 316; 315, 317; 316, identifier:t_in; 317, unary_operator:-; 317, 318; 318, integer:1; 319, expression_statement; 319, 320; 320, assignment; 320, 321; 320, 325; 321, subscript; 321, 322; 321, 323; 322, identifier:t_inp1; 323, unary_operator:-; 323, 324; 324, integer:1; 325, binary_operator:+; 325, 326; 325, 330; 326, subscript; 326, 327; 326, 328; 327, identifier:t_in; 328, unary_operator:-; 328, 329; 329, integer:1; 330, parenthesized_expression; 330, 331; 331, binary_operator:-; 331, 332; 331, 336; 332, subscript; 332, 333; 332, 334; 333, identifier:t_in; 334, unary_operator:-; 334, 335; 335, integer:1; 336, subscript; 336, 337; 336, 338; 337, identifier:t_in; 338, unary_operator:-; 338, 339; 339, integer:2; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:tau; 343, binary_operator:/; 343, 344; 343, 350; 344, parenthesized_expression; 344, 345; 345, binary_operator:-; 345, 346; 345, 347; 346, identifier:t_out; 347, subscript; 347, 348; 347, 349; 348, identifier:t_in; 349, identifier:i_in_for_out; 350, parenthesized_expression; 350, 351; 351, subscript; 351, 352; 351, 356; 352, parenthesized_expression; 352, 353; 353, binary_operator:-; 353, 354; 353, 355; 354, identifier:t_inp1; 355, identifier:t_in; 356, identifier:i_in_for_out; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:R_out; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:np; 363, identifier:squad_vectorized; 364, argument_list; 364, 365; 364, 366; 364, 369; 364, 372; 364, 375; 365, identifier:tau; 366, subscript; 366, 367; 366, 368; 367, identifier:R_in; 368, identifier:i_in_for_out; 369, subscript; 369, 370; 369, 371; 370, identifier:A; 371, identifier:i_in_for_out; 372, subscript; 372, 373; 372, 374; 373, identifier:B; 374, identifier:i_in_for_out; 375, identifier:R_ip1; 376, return_statement; 376, 377; 377, identifier:R_out | def squad(R_in, t_in, t_out):
if R_in.size == 0 or t_out.size == 0:
return np.array((), dtype=np.quaternion)
i_in_for_out = t_in.searchsorted(t_out, side='right')-1
A = R_in * np.exp((- np.log((~R_in) * np.roll(R_in, -1))
+ np.log((~np.roll(R_in, 1)) * R_in) * ((np.roll(t_in, -1) - t_in) / (t_in - np.roll(t_in, 1)))
) * 0.25)
B = np.roll(R_in, -1) * np.exp((np.log((~np.roll(R_in, -1)) * np.roll(R_in, -2))
* ((np.roll(t_in, -1) - t_in) / (np.roll(t_in, -2) - np.roll(t_in, -1)))
- np.log((~R_in) * np.roll(R_in, -1))) * -0.25)
A[0] = R_in[0]
A[-1] = R_in[-1]
B[-2] = R_in[-1]
B[-1] = R_in[-1] * (~R_in[-2]) * R_in[-1]
R_ip1 = np.roll(R_in, -1)
R_ip1[-1] = R_in[-1]*(~R_in[-2])*R_in[-1]
R_ip1 = np.array(R_ip1[i_in_for_out])
t_inp1 = np.roll(t_in, -1)
t_inp1[-1] = t_in[-1] + (t_in[-1] - t_in[-2])
tau = (t_out - t_in[i_in_for_out]) / ((t_inp1 - t_in)[i_in_for_out])
R_out = np.squad_vectorized(tau, R_in[i_in_for_out], A[i_in_for_out], B[i_in_for_out], R_ip1)
return R_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_resource_id; 3, parameters; 3, 4; 3, 5; 4, identifier:prefix; 5, list_splat_pattern; 5, 6; 6, identifier:data; 7, block; 7, 8; 7, 15; 7, 43; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:parts; 11, call; 11, 12; 11, 13; 12, identifier:flatten; 13, argument_list; 13, 14; 14, identifier:data; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:part; 17, identifier:parts; 18, block; 18, 19; 19, if_statement; 19, 20; 19, 29; 20, comparison_operator:not; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:type; 23, argument_list; 23, 24; 24, identifier:part; 25, tuple; 25, 26; 25, 27; 25, 28; 26, identifier:str; 27, identifier:int; 28, identifier:float; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:ValueError; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, string:'Supported data types: int, float, list, tuple, str. Got: {}'; 37, identifier:format; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:type; 41, argument_list; 41, 42; 42, identifier:part; 43, return_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, string:'{}-{}'; 47, identifier:format; 48, argument_list; 48, 49; 48, 50; 49, identifier:prefix; 50, subscript; 50, 51; 50, 67; 51, call; 51, 52; 51, 53; 52, identifier:get_hash; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, string:'-'; 57, identifier:join; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:sorted; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:map; 64, argument_list; 64, 65; 64, 66; 65, identifier:str; 66, identifier:parts; 67, slice; 67, 68; 67, 70; 68, unary_operator:-; 68, 69; 69, integer:16; 70, colon | def get_resource_id(prefix, *data):
parts = flatten(data)
for part in parts:
if type(part) not in (str, int, float):
raise ValueError('Supported data types: int, float, list, tuple, str. Got: {}'.format(type(part)))
return '{}-{}'.format(
prefix,
get_hash('-'.join(sorted(map(str, parts))))[-16:]
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:sorted; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:iterator; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:reverse; 11, False; 12, block; 12, 13; 12, 16; 12, 28; 12, 36; 12, 43; 12, 224; 12, 236; 12, 242; 12, 255; 13, global_statement; 13, 14; 13, 15; 14, identifier:MemoryBytesSpilled; 15, identifier:DiskBytesSpilled; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:batch; 20, identifier:limit; 21, expression_list; 21, 22; 21, 23; 22, integer:100; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_next_limit; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 33; 30, pattern_list; 30, 31; 30, 32; 31, identifier:chunks; 32, identifier:current_chunk; 33, expression_list; 33, 34; 33, 35; 34, list:[]; 35, list:[]; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:iterator; 39, call; 39, 40; 39, 41; 40, identifier:iter; 41, argument_list; 41, 42; 42, identifier:iterator; 43, while_statement; 43, 44; 43, 45; 44, True; 45, block; 45, 46; 45, 59; 45, 66; 45, 75; 45, 81; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:chunk; 49, call; 49, 50; 49, 51; 50, identifier:list; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:itertools; 55, identifier:islice; 56, argument_list; 56, 57; 56, 58; 57, identifier:iterator; 58, identifier:batch; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:current_chunk; 63, identifier:extend; 64, argument_list; 64, 65; 65, identifier:chunk; 66, if_statement; 66, 67; 66, 73; 67, comparison_operator:<; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:len; 70, argument_list; 70, 71; 71, identifier:chunk; 72, identifier:batch; 73, block; 73, 74; 74, break_statement; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:used_memory; 78, call; 78, 79; 78, 80; 79, identifier:get_used_memory; 80, argument_list; 81, if_statement; 81, 82; 81, 85; 81, 207; 82, comparison_operator:>; 82, 83; 82, 84; 83, identifier:used_memory; 84, identifier:limit; 85, block; 85, 86; 85, 98; 85, 110; 85, 132; 85, 157; 85, 171; 85, 175; 85, 189; 85, 200; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:current_chunk; 90, identifier:sort; 91, argument_list; 91, 92; 91, 95; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:key; 94, identifier:key; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:reverse; 97, identifier:reverse; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:path; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_get_path; 105, argument_list; 105, 106; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, identifier:chunks; 110, with_statement; 110, 111; 110, 121; 111, with_clause; 111, 112; 112, with_item; 112, 113; 113, as_pattern; 113, 114; 113, 119; 114, call; 114, 115; 114, 116; 115, identifier:open; 116, argument_list; 116, 117; 116, 118; 117, identifier:path; 118, string:'wb'; 119, as_pattern_target; 119, 120; 120, identifier:f; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:serializer; 128, identifier:dump_stream; 129, argument_list; 129, 130; 129, 131; 130, identifier:current_chunk; 131, identifier:f; 132, function_definition; 132, 133; 132, 134; 132, 136; 133, function_name:load; 134, parameters; 134, 135; 135, identifier:f; 136, block; 136, 137; 136, 151; 137, for_statement; 137, 138; 137, 139; 137, 147; 138, identifier:v; 139, call; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:serializer; 144, identifier:load_stream; 145, argument_list; 145, 146; 146, identifier:f; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, yield; 149, 150; 150, identifier:v; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:f; 155, identifier:close; 156, argument_list; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:chunks; 161, identifier:append; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:load; 165, argument_list; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:open; 168, argument_list; 168, 169; 168, 170; 169, identifier:path; 170, string:'rb'; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:current_chunk; 174, list:[]; 175, expression_statement; 175, 176; 176, augmented_assignment:+=; 176, 177; 176, 178; 177, identifier:MemoryBytesSpilled; 178, binary_operator:<<; 178, 179; 178, 188; 179, call; 179, 180; 179, 181; 180, identifier:max; 181, argument_list; 181, 182; 181, 187; 182, binary_operator:-; 182, 183; 182, 184; 183, identifier:used_memory; 184, call; 184, 185; 184, 186; 185, identifier:get_used_memory; 186, argument_list; 187, integer:0; 188, integer:20; 189, expression_statement; 189, 190; 190, augmented_assignment:+=; 190, 191; 190, 192; 191, identifier:DiskBytesSpilled; 192, call; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:os; 196, identifier:path; 197, identifier:getsize; 198, argument_list; 198, 199; 199, identifier:path; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:os; 204, identifier:unlink; 205, argument_list; 205, 206; 206, identifier:path; 207, elif_clause; 207, 208; 207, 210; 208, not_operator; 208, 209; 209, identifier:chunks; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:batch; 214, call; 214, 215; 214, 216; 215, identifier:min; 216, argument_list; 216, 217; 216, 223; 217, call; 217, 218; 217, 219; 218, identifier:int; 219, argument_list; 219, 220; 220, binary_operator:*; 220, 221; 220, 222; 221, identifier:batch; 222, float:1.5; 223, integer:10000; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:current_chunk; 228, identifier:sort; 229, argument_list; 229, 230; 229, 233; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:key; 232, identifier:key; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:reverse; 235, identifier:reverse; 236, if_statement; 236, 237; 236, 239; 237, not_operator; 237, 238; 238, identifier:chunks; 239, block; 239, 240; 240, return_statement; 240, 241; 241, identifier:current_chunk; 242, if_statement; 242, 243; 242, 244; 243, identifier:current_chunk; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:chunks; 249, identifier:append; 250, argument_list; 250, 251; 251, call; 251, 252; 251, 253; 252, identifier:iter; 253, argument_list; 253, 254; 254, identifier:current_chunk; 255, return_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:heapq; 259, identifier:merge; 260, argument_list; 260, 261; 260, 262; 260, 265; 261, identifier:chunks; 262, keyword_argument; 262, 263; 262, 264; 263, identifier:key; 264, identifier:key; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:reverse; 267, identifier:reverse | def sorted(self, iterator, key=None, reverse=False):
global MemoryBytesSpilled, DiskBytesSpilled
batch, limit = 100, self._next_limit()
chunks, current_chunk = [], []
iterator = iter(iterator)
while True:
chunk = list(itertools.islice(iterator, batch))
current_chunk.extend(chunk)
if len(chunk) < batch:
break
used_memory = get_used_memory()
if used_memory > limit:
current_chunk.sort(key=key, reverse=reverse)
path = self._get_path(len(chunks))
with open(path, 'wb') as f:
self.serializer.dump_stream(current_chunk, f)
def load(f):
for v in self.serializer.load_stream(f):
yield v
f.close()
chunks.append(load(open(path, 'rb')))
current_chunk = []
MemoryBytesSpilled += max(used_memory - get_used_memory(), 0) << 20
DiskBytesSpilled += os.path.getsize(path)
os.unlink(path)
elif not chunks:
batch = min(int(batch * 1.5), 10000)
current_chunk.sort(key=key, reverse=reverse)
if not chunks:
return current_chunk
if current_chunk:
chunks.append(iter(current_chunk))
return heapq.merge(chunks, key=key, reverse=reverse) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_merge_sorted_items; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:index; 6, block; 6, 7; 6, 63; 6, 79; 6, 144; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:load_partition; 9, parameters; 9, 10; 10, identifier:j; 11, block; 11, 12; 11, 21; 11, 36; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:path; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_get_spill_dir; 19, argument_list; 19, 20; 20, identifier:j; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:p; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:os; 28, identifier:path; 29, identifier:join; 30, argument_list; 30, 31; 30, 32; 31, identifier:path; 32, call; 32, 33; 32, 34; 33, identifier:str; 34, argument_list; 34, 35; 35, identifier:index; 36, with_statement; 36, 37; 36, 48; 37, with_clause; 37, 38; 38, with_item; 38, 39; 39, as_pattern; 39, 40; 39, 46; 40, call; 40, 41; 40, 42; 41, identifier:open; 42, argument_list; 42, 43; 42, 44; 42, 45; 43, identifier:p; 44, string:'rb'; 45, integer:65536; 46, as_pattern_target; 46, 47; 47, identifier:f; 48, block; 48, 49; 49, for_statement; 49, 50; 49, 51; 49, 59; 50, identifier:v; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:serializer; 56, identifier:load_stream; 57, argument_list; 57, 58; 58, identifier:f; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, yield; 61, 62; 62, identifier:v; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:disk_items; 66, list_comprehension; 66, 67; 66, 71; 67, call; 67, 68; 67, 69; 68, identifier:load_partition; 69, argument_list; 69, 70; 70, identifier:j; 71, for_in_clause; 71, 72; 71, 73; 72, identifier:j; 73, call; 73, 74; 73, 75; 74, identifier:range; 75, argument_list; 75, 76; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:spills; 79, if_statement; 79, 80; 79, 83; 79, 101; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_sorted; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:sorted_items; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:heapq; 90, identifier:merge; 91, argument_list; 91, 92; 91, 93; 92, identifier:disk_items; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:key; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:operator; 98, identifier:itemgetter; 99, argument_list; 99, 100; 100, integer:0; 101, else_clause; 101, 102; 102, block; 102, 103; 102, 111; 102, 121; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:ser; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:flattened_serializer; 110, argument_list; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:sorter; 114, call; 114, 115; 114, 116; 115, identifier:ExternalSorter; 116, argument_list; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:memory_limit; 120, identifier:ser; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:sorted_items; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:sorter; 127, identifier:sorted; 128, argument_list; 128, 129; 128, 136; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:itertools; 132, identifier:chain; 133, argument_list; 133, 134; 134, list_splat; 134, 135; 135, identifier:disk_items; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:key; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:operator; 141, identifier:itemgetter; 142, argument_list; 142, 143; 143, integer:0; 144, return_statement; 144, 145; 145, generator_expression; 145, 146; 145, 149; 146, tuple; 146, 147; 146, 148; 147, identifier:k; 148, identifier:vs; 149, for_in_clause; 149, 150; 149, 153; 150, pattern_list; 150, 151; 150, 152; 151, identifier:k; 152, identifier:vs; 153, call; 153, 154; 153, 155; 154, identifier:GroupByKey; 155, argument_list; 155, 156; 156, identifier:sorted_items | def _merge_sorted_items(self, index):
def load_partition(j):
path = self._get_spill_dir(j)
p = os.path.join(path, str(index))
with open(p, 'rb', 65536) as f:
for v in self.serializer.load_stream(f):
yield v
disk_items = [load_partition(j) for j in range(self.spills)]
if self._sorted:
sorted_items = heapq.merge(disk_items, key=operator.itemgetter(0))
else:
ser = self.flattened_serializer()
sorter = ExternalSorter(self.memory_limit, ser)
sorted_items = sorter.sorted(itertools.chain(*disk_items),
key=operator.itemgetter(0))
return ((k, vs) for k, vs in GroupByKey(sorted_items)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:map; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:f; 6, default_parameter; 6, 7; 6, 8; 7, identifier:preservesPartitioning; 8, False; 9, block; 9, 10; 9, 25; 10, function_definition; 10, 11; 10, 12; 10, 15; 11, function_name:func; 12, parameters; 12, 13; 12, 14; 13, identifier:_; 14, identifier:iterator; 15, block; 15, 16; 16, return_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:map; 19, argument_list; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:fail_on_stopiteration; 22, argument_list; 22, 23; 23, identifier:f; 24, identifier:iterator; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:mapPartitionsWithIndex; 30, argument_list; 30, 31; 30, 32; 31, identifier:func; 32, identifier:preservesPartitioning | def map(self, f, preservesPartitioning=False):
def func(_, iterator):
return map(fail_on_stopiteration(f), iterator)
return self.mapPartitionsWithIndex(func, preservesPartitioning) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:flatMap; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:f; 6, default_parameter; 6, 7; 6, 8; 7, identifier:preservesPartitioning; 8, False; 9, block; 9, 10; 9, 30; 10, function_definition; 10, 11; 10, 12; 10, 15; 11, function_name:func; 12, parameters; 12, 13; 12, 14; 13, identifier:s; 14, identifier:iterator; 15, block; 15, 16; 16, return_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:chain; 20, identifier:from_iterable; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:map; 24, argument_list; 24, 25; 24, 29; 25, call; 25, 26; 25, 27; 26, identifier:fail_on_stopiteration; 27, argument_list; 27, 28; 28, identifier:f; 29, identifier:iterator; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:mapPartitionsWithIndex; 35, argument_list; 35, 36; 35, 37; 36, identifier:func; 37, identifier:preservesPartitioning | def flatMap(self, f, preservesPartitioning=False):
def func(s, iterator):
return chain.from_iterable(map(fail_on_stopiteration(f), iterator))
return self.mapPartitionsWithIndex(func, preservesPartitioning) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:distinct; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:numPartitions; 7, None; 8, block; 8, 9; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 36; 11, attribute; 11, 12; 11, 34; 11, 35; 12, call; 12, 13; 12, 27; 13, attribute; 13, 14; 13, 25; 13, 26; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:map; 18, argument_list; 18, 19; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:x; 22, tuple; 22, 23; 22, 24; 23, identifier:x; 24, None; 25, line_continuation:\; 26, identifier:reduceByKey; 27, argument_list; 27, 28; 27, 33; 28, lambda; 28, 29; 28, 32; 29, lambda_parameters; 29, 30; 29, 31; 30, identifier:x; 31, identifier:_; 32, identifier:x; 33, identifier:numPartitions; 34, line_continuation:\; 35, identifier:map; 36, argument_list; 36, 37; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:x; 40, subscript; 40, 41; 40, 42; 41, identifier:x; 42, integer:0 | def distinct(self, numPartitions=None):
return self.map(lambda x: (x, None)) \
.reduceByKey(lambda x, _: x, numPartitions) \
.map(lambda x: x[0]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:repartitionAndSortWithinPartitions; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:numPartitions; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:partitionFunc; 10, identifier:portable_hash; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:keyfunc; 16, lambda; 16, 17; 16, 19; 17, lambda_parameters; 17, 18; 18, identifier:x; 19, identifier:x; 20, block; 20, 21; 20, 34; 20, 51; 20, 57; 20, 98; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:numPartitions; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:numPartitions; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_defaultReducePartitions; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:memory; 37, call; 37, 38; 37, 39; 38, identifier:_parse_memory; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 48; 41, attribute; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:ctx; 46, identifier:_conf; 47, identifier:get; 48, argument_list; 48, 49; 48, 50; 49, string:"spark.python.worker.memory"; 50, string:"512m"; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:serializer; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_jrdd_deserializer; 57, function_definition; 57, 58; 57, 59; 57, 61; 58, function_name:sortPartition; 59, parameters; 59, 60; 60, identifier:iterator; 61, block; 61, 62; 61, 74; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:sort; 65, attribute; 65, 66; 65, 73; 66, call; 66, 67; 66, 68; 67, identifier:ExternalSorter; 68, argument_list; 68, 69; 68, 72; 69, binary_operator:*; 69, 70; 69, 71; 70, identifier:memory; 71, float:0.9; 72, identifier:serializer; 73, identifier:sorted; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:iter; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:sort; 80, argument_list; 80, 81; 80, 82; 80, 93; 81, identifier:iterator; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:key; 84, lambda; 84, 85; 84, 87; 85, lambda_parameters; 85, 86; 86, identifier:k_v; 87, call; 87, 88; 87, 89; 88, identifier:keyfunc; 89, argument_list; 89, 90; 90, subscript; 90, 91; 90, 92; 91, identifier:k_v; 92, integer:0; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:reverse; 95, parenthesized_expression; 95, 96; 96, not_operator; 96, 97; 97, identifier:ascending; 98, return_statement; 98, 99; 99, call; 99, 100; 99, 109; 100, attribute; 100, 101; 100, 108; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:partitionBy; 105, argument_list; 105, 106; 105, 107; 106, identifier:numPartitions; 107, identifier:partitionFunc; 108, identifier:mapPartitions; 109, argument_list; 109, 110; 109, 111; 110, identifier:sortPartition; 111, True | def repartitionAndSortWithinPartitions(self, numPartitions=None, partitionFunc=portable_hash,
ascending=True, keyfunc=lambda x: x):
if numPartitions is None:
numPartitions = self._defaultReducePartitions()
memory = _parse_memory(self.ctx._conf.get("spark.python.worker.memory", "512m"))
serializer = self._jrdd_deserializer
def sortPartition(iterator):
sort = ExternalSorter(memory * 0.9, serializer).sorted
return iter(sort(iterator, key=lambda k_v: keyfunc(k_v[0]), reverse=(not ascending)))
return self.partitionBy(numPartitions, partitionFunc).mapPartitions(sortPartition, True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:sortBy; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:keyfunc; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ascending; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:numPartitions; 11, None; 12, block; 12, 13; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 29; 15, attribute; 15, 16; 15, 28; 16, call; 16, 17; 16, 25; 17, attribute; 17, 18; 17, 24; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:keyBy; 22, argument_list; 22, 23; 23, identifier:keyfunc; 24, identifier:sortByKey; 25, argument_list; 25, 26; 25, 27; 26, identifier:ascending; 27, identifier:numPartitions; 28, identifier:values; 29, argument_list | def sortBy(self, keyfunc, ascending=True, numPartitions=None):
return self.keyBy(keyfunc).sortByKey(ascending, numPartitions).values() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:groupBy; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:f; 6, default_parameter; 6, 7; 6, 8; 7, identifier:numPartitions; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:partitionFunc; 11, identifier:portable_hash; 12, block; 12, 13; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 31; 15, attribute; 15, 16; 15, 30; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:map; 20, argument_list; 20, 21; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:x; 24, tuple; 24, 25; 24, 29; 25, call; 25, 26; 25, 27; 26, identifier:f; 27, argument_list; 27, 28; 28, identifier:x; 29, identifier:x; 30, identifier:groupByKey; 31, argument_list; 31, 32; 31, 33; 32, identifier:numPartitions; 33, identifier:partitionFunc | def groupBy(self, f, numPartitions=None, partitionFunc=portable_hash):
return self.map(lambda x: (f(x), x)).groupByKey(numPartitions, partitionFunc) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:top; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:num; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 27; 9, 46; 10, function_definition; 10, 11; 10, 12; 10, 14; 11, function_name:topIterator; 12, parameters; 12, 13; 13, identifier:iterator; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, yield; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:heapq; 20, identifier:nlargest; 21, argument_list; 21, 22; 21, 23; 21, 24; 22, identifier:num; 23, identifier:iterator; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:key; 26, identifier:key; 27, function_definition; 27, 28; 27, 29; 27, 32; 28, function_name:merge; 29, parameters; 29, 30; 29, 31; 30, identifier:a; 31, identifier:b; 32, block; 32, 33; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:heapq; 37, identifier:nlargest; 38, argument_list; 38, 39; 38, 40; 38, 43; 39, identifier:num; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:a; 42, identifier:b; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:key; 45, identifier:key; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 56; 48, attribute; 48, 49; 48, 55; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:mapPartitions; 53, argument_list; 53, 54; 54, identifier:topIterator; 55, identifier:reduce; 56, argument_list; 56, 57; 57, identifier:merge | def top(self, num, key=None):
def topIterator(iterator):
yield heapq.nlargest(num, iterator, key=key)
def merge(a, b):
return heapq.nlargest(num, a + b, key=key)
return self.mapPartitions(topIterator).reduce(merge) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:saveAsTextFile; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:compressionCodecClass; 8, None; 9, block; 9, 10; 9, 56; 9, 65; 9, 71; 10, function_definition; 10, 11; 10, 12; 10, 15; 11, function_name:func; 12, parameters; 12, 13; 12, 14; 13, identifier:split; 14, identifier:iterator; 15, block; 15, 16; 16, for_statement; 16, 17; 16, 18; 16, 19; 17, identifier:x; 18, identifier:iterator; 19, block; 19, 20; 19, 37; 19, 53; 20, if_statement; 20, 21; 20, 29; 21, not_operator; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:x; 26, tuple; 26, 27; 26, 28; 27, identifier:unicode; 28, identifier:bytes; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:x; 33, call; 33, 34; 33, 35; 34, identifier:unicode; 35, argument_list; 35, 36; 36, identifier:x; 37, if_statement; 37, 38; 37, 43; 38, call; 38, 39; 38, 40; 39, identifier:isinstance; 40, argument_list; 40, 41; 40, 42; 41, identifier:x; 42, identifier:unicode; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:x; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:x; 50, identifier:encode; 51, argument_list; 51, 52; 52, string:"utf-8"; 53, expression_statement; 53, 54; 54, yield; 54, 55; 55, identifier:x; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:keyed; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:mapPartitionsWithIndex; 63, argument_list; 63, 64; 64, identifier:func; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:keyed; 69, identifier:_bypass_serializer; 70, True; 71, if_statement; 71, 72; 71, 73; 71, 116; 72, identifier:compressionCodecClass; 73, block; 73, 74; 73, 93; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:compressionCodec; 77, call; 77, 78; 77, 91; 78, attribute; 78, 79; 78, 90; 79, attribute; 79, 80; 79, 89; 80, attribute; 80, 81; 80, 88; 81, attribute; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:ctx; 86, identifier:_jvm; 87, identifier:java; 88, identifier:lang; 89, identifier:Class; 90, identifier:forName; 91, argument_list; 91, 92; 92, identifier:compressionCodecClass; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 113; 95, attribute; 95, 96; 95, 112; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:keyed; 100, identifier:_jrdd; 101, identifier:map; 102, argument_list; 102, 103; 103, call; 103, 104; 103, 111; 104, attribute; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:ctx; 109, identifier:_jvm; 110, identifier:BytesToString; 111, argument_list; 112, identifier:saveAsTextFile; 113, argument_list; 113, 114; 113, 115; 114, identifier:path; 115, identifier:compressionCodec; 116, else_clause; 116, 117; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 138; 120, attribute; 120, 121; 120, 137; 121, call; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:keyed; 125, identifier:_jrdd; 126, identifier:map; 127, argument_list; 127, 128; 128, call; 128, 129; 128, 136; 129, attribute; 129, 130; 129, 135; 130, attribute; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:ctx; 134, identifier:_jvm; 135, identifier:BytesToString; 136, argument_list; 137, identifier:saveAsTextFile; 138, argument_list; 138, 139; 139, identifier:path | def saveAsTextFile(self, path, compressionCodecClass=None):
def func(split, iterator):
for x in iterator:
if not isinstance(x, (unicode, bytes)):
x = unicode(x)
if isinstance(x, unicode):
x = x.encode("utf-8")
yield x
keyed = self.mapPartitionsWithIndex(func)
keyed._bypass_serializer = True
if compressionCodecClass:
compressionCodec = self.ctx._jvm.java.lang.Class.forName(compressionCodecClass)
keyed._jrdd.map(self.ctx._jvm.BytesToString()).saveAsTextFile(path, compressionCodec)
else:
keyed._jrdd.map(self.ctx._jvm.BytesToString()).saveAsTextFile(path) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:reduceByKey; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:func; 6, default_parameter; 6, 7; 6, 8; 7, identifier:numPartitions; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:partitionFunc; 11, identifier:portable_hash; 12, block; 12, 13; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:combineByKey; 18, argument_list; 18, 19; 18, 23; 18, 24; 18, 25; 18, 26; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:x; 22, identifier:x; 23, identifier:func; 24, identifier:func; 25, identifier:numPartitions; 26, identifier:partitionFunc | def reduceByKey(self, func, numPartitions=None, partitionFunc=portable_hash):
return self.combineByKey(lambda x: x, func, func, numPartitions, partitionFunc) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:reduceByKeyLocally; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:func; 6, block; 6, 7; 6, 14; 6, 49; 6, 84; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:func; 10, call; 10, 11; 10, 12; 11, identifier:fail_on_stopiteration; 12, argument_list; 12, 13; 13, identifier:func; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:reducePartition; 16, parameters; 16, 17; 17, identifier:iterator; 18, block; 18, 19; 18, 23; 18, 46; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:m; 22, dictionary; 23, for_statement; 23, 24; 23, 27; 23, 28; 24, pattern_list; 24, 25; 24, 26; 25, identifier:k; 26, identifier:v; 27, identifier:iterator; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:m; 33, identifier:k; 34, conditional_expression:if; 34, 35; 34, 42; 34, 45; 35, call; 35, 36; 35, 37; 36, identifier:func; 37, argument_list; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:m; 40, identifier:k; 41, identifier:v; 42, comparison_operator:in; 42, 43; 42, 44; 43, identifier:k; 44, identifier:m; 45, identifier:v; 46, expression_statement; 46, 47; 47, yield; 47, 48; 48, identifier:m; 49, function_definition; 49, 50; 49, 51; 49, 54; 50, function_name:mergeMaps; 51, parameters; 51, 52; 51, 53; 52, identifier:m1; 53, identifier:m2; 54, block; 54, 55; 54, 82; 55, for_statement; 55, 56; 55, 59; 55, 64; 56, pattern_list; 56, 57; 56, 58; 57, identifier:k; 58, identifier:v; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:m2; 62, identifier:items; 63, argument_list; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:m1; 69, identifier:k; 70, conditional_expression:if; 70, 71; 70, 78; 70, 81; 71, call; 71, 72; 71, 73; 72, identifier:func; 73, argument_list; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:m1; 76, identifier:k; 77, identifier:v; 78, comparison_operator:in; 78, 79; 78, 80; 79, identifier:k; 80, identifier:m1; 81, identifier:v; 82, return_statement; 82, 83; 83, identifier:m1; 84, return_statement; 84, 85; 85, call; 85, 86; 85, 94; 86, attribute; 86, 87; 86, 93; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:mapPartitions; 91, argument_list; 91, 92; 92, identifier:reducePartition; 93, identifier:reduce; 94, argument_list; 94, 95; 95, identifier:mergeMaps | def reduceByKeyLocally(self, func):
func = fail_on_stopiteration(func)
def reducePartition(iterator):
m = {}
for k, v in iterator:
m[k] = func(m[k], v) if k in m else v
yield m
def mergeMaps(m1, m2):
for k, v in m2.items():
m1[k] = func(m1[k], v) if k in m1 else v
return m1
return self.mapPartitions(reducePartition).reduce(mergeMaps) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:combineByKey; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 4, identifier:self; 5, identifier:createCombiner; 6, identifier:mergeValue; 7, identifier:mergeCombiners; 8, default_parameter; 8, 9; 8, 10; 9, identifier:numPartitions; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:partitionFunc; 13, identifier:portable_hash; 14, block; 14, 15; 14, 28; 14, 36; 14, 44; 14, 53; 14, 82; 14, 94; 14, 104; 14, 131; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:numPartitions; 18, None; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:numPartitions; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_defaultReducePartitions; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:serializer; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:ctx; 35, identifier:serializer; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:memory; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_memory_limit; 43, argument_list; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:agg; 47, call; 47, 48; 47, 49; 48, identifier:Aggregator; 49, argument_list; 49, 50; 49, 51; 49, 52; 50, identifier:createCombiner; 51, identifier:mergeValue; 52, identifier:mergeCombiners; 53, function_definition; 53, 54; 53, 55; 53, 57; 54, function_name:combineLocally; 55, parameters; 55, 56; 56, identifier:iterator; 57, block; 57, 58; 57, 69; 57, 76; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:merger; 61, call; 61, 62; 61, 63; 62, identifier:ExternalMerger; 63, argument_list; 63, 64; 63, 65; 63, 68; 64, identifier:agg; 65, binary_operator:*; 65, 66; 65, 67; 66, identifier:memory; 67, float:0.9; 68, identifier:serializer; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:merger; 73, identifier:mergeValues; 74, argument_list; 74, 75; 75, identifier:iterator; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:merger; 80, identifier:items; 81, argument_list; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:locally_combined; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:mapPartitions; 89, argument_list; 89, 90; 89, 91; 90, identifier:combineLocally; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:preservesPartitioning; 93, True; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:shuffled; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:locally_combined; 100, identifier:partitionBy; 101, argument_list; 101, 102; 101, 103; 102, identifier:numPartitions; 103, identifier:partitionFunc; 104, function_definition; 104, 105; 104, 106; 104, 108; 105, function_name:_mergeCombiners; 106, parameters; 106, 107; 107, identifier:iterator; 108, block; 108, 109; 108, 118; 108, 125; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:merger; 112, call; 112, 113; 112, 114; 113, identifier:ExternalMerger; 114, argument_list; 114, 115; 114, 116; 114, 117; 115, identifier:agg; 116, identifier:memory; 117, identifier:serializer; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:merger; 122, identifier:mergeCombiners; 123, argument_list; 123, 124; 124, identifier:iterator; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:merger; 129, identifier:items; 130, argument_list; 131, return_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:shuffled; 135, identifier:mapPartitions; 136, argument_list; 136, 137; 136, 138; 137, identifier:_mergeCombiners; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:preservesPartitioning; 140, True | def combineByKey(self, createCombiner, mergeValue, mergeCombiners,
numPartitions=None, partitionFunc=portable_hash):
if numPartitions is None:
numPartitions = self._defaultReducePartitions()
serializer = self.ctx.serializer
memory = self._memory_limit()
agg = Aggregator(createCombiner, mergeValue, mergeCombiners)
def combineLocally(iterator):
merger = ExternalMerger(agg, memory * 0.9, serializer)
merger.mergeValues(iterator)
return merger.items()
locally_combined = self.mapPartitions(combineLocally, preservesPartitioning=True)
shuffled = locally_combined.partitionBy(numPartitions, partitionFunc)
def _mergeCombiners(iterator):
merger = ExternalMerger(agg, memory, serializer)
merger.mergeCombiners(iterator)
return merger.items()
return shuffled.mapPartitions(_mergeCombiners, preservesPartitioning=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:groupByKey; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:numPartitions; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:partitionFunc; 10, identifier:portable_hash; 11, block; 11, 12; 11, 20; 11, 35; 11, 50; 11, 58; 11, 64; 11, 73; 11, 102; 11, 114; 11, 124; 11, 151; 12, function_definition; 12, 13; 12, 14; 12, 16; 13, function_name:createCombiner; 14, parameters; 14, 15; 15, identifier:x; 16, block; 16, 17; 17, return_statement; 17, 18; 18, list:[x]; 18, 19; 19, identifier:x; 20, function_definition; 20, 21; 20, 22; 20, 25; 21, function_name:mergeValue; 22, parameters; 22, 23; 22, 24; 23, identifier:xs; 24, identifier:x; 25, block; 25, 26; 25, 33; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:xs; 30, identifier:append; 31, argument_list; 31, 32; 32, identifier:x; 33, return_statement; 33, 34; 34, identifier:xs; 35, function_definition; 35, 36; 35, 37; 35, 40; 36, function_name:mergeCombiners; 37, parameters; 37, 38; 37, 39; 38, identifier:a; 39, identifier:b; 40, block; 40, 41; 40, 48; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:a; 45, identifier:extend; 46, argument_list; 46, 47; 47, identifier:b; 48, return_statement; 48, 49; 49, identifier:a; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:memory; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_memory_limit; 57, argument_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:serializer; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_jrdd_deserializer; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:agg; 67, call; 67, 68; 67, 69; 68, identifier:Aggregator; 69, argument_list; 69, 70; 69, 71; 69, 72; 70, identifier:createCombiner; 71, identifier:mergeValue; 72, identifier:mergeCombiners; 73, function_definition; 73, 74; 73, 75; 73, 77; 74, function_name:combine; 75, parameters; 75, 76; 76, identifier:iterator; 77, block; 77, 78; 77, 89; 77, 96; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:merger; 81, call; 81, 82; 81, 83; 82, identifier:ExternalMerger; 83, argument_list; 83, 84; 83, 85; 83, 88; 84, identifier:agg; 85, binary_operator:*; 85, 86; 85, 87; 86, identifier:memory; 87, float:0.9; 88, identifier:serializer; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:merger; 93, identifier:mergeValues; 94, argument_list; 94, 95; 95, identifier:iterator; 96, return_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:merger; 100, identifier:items; 101, argument_list; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:locally_combined; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:mapPartitions; 109, argument_list; 109, 110; 109, 111; 110, identifier:combine; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:preservesPartitioning; 113, True; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:shuffled; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:locally_combined; 120, identifier:partitionBy; 121, argument_list; 121, 122; 121, 123; 122, identifier:numPartitions; 123, identifier:partitionFunc; 124, function_definition; 124, 125; 124, 126; 124, 128; 125, function_name:groupByKey; 126, parameters; 126, 127; 127, identifier:it; 128, block; 128, 129; 128, 138; 128, 145; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:merger; 132, call; 132, 133; 132, 134; 133, identifier:ExternalGroupBy; 134, argument_list; 134, 135; 134, 136; 134, 137; 135, identifier:agg; 136, identifier:memory; 137, identifier:serializer; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:merger; 142, identifier:mergeCombiners; 143, argument_list; 143, 144; 144, identifier:it; 145, return_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:merger; 149, identifier:items; 150, argument_list; 151, return_statement; 151, 152; 152, call; 152, 153; 152, 162; 153, attribute; 153, 154; 153, 161; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:shuffled; 157, identifier:mapPartitions; 158, argument_list; 158, 159; 158, 160; 159, identifier:groupByKey; 160, True; 161, identifier:mapValues; 162, argument_list; 162, 163; 163, identifier:ResultIterable | def groupByKey(self, numPartitions=None, partitionFunc=portable_hash):
def createCombiner(x):
return [x]
def mergeValue(xs, x):
xs.append(x)
return xs
def mergeCombiners(a, b):
a.extend(b)
return a
memory = self._memory_limit()
serializer = self._jrdd_deserializer
agg = Aggregator(createCombiner, mergeValue, mergeCombiners)
def combine(iterator):
merger = ExternalMerger(agg, memory * 0.9, serializer)
merger.mergeValues(iterator)
return merger.items()
locally_combined = self.mapPartitions(combine, preservesPartitioning=True)
shuffled = locally_combined.partitionBy(numPartitions, partitionFunc)
def groupByKey(it):
merger = ExternalGroupBy(agg, memory, serializer)
merger.mergeCombiners(it)
return merger.items()
return shuffled.mapPartitions(groupByKey, True).mapValues(ResultIterable) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:lookup; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:key; 6, block; 6, 7; 6, 27; 6, 54; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:values; 10, call; 10, 11; 10, 26; 11, attribute; 11, 12; 11, 25; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:filter; 16, argument_list; 16, 17; 17, lambda; 17, 18; 17, 20; 18, lambda_parameters; 18, 19; 19, identifier:kv; 20, comparison_operator:==; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:kv; 23, integer:0; 24, identifier:key; 25, identifier:values; 26, argument_list; 27, if_statement; 27, 28; 27, 33; 28, comparison_operator:is; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:partitioner; 32, None; 33, block; 33, 34; 34, return_statement; 34, 35; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:ctx; 40, identifier:runJob; 41, argument_list; 41, 42; 41, 43; 41, 47; 42, identifier:values; 43, lambda; 43, 44; 43, 46; 44, lambda_parameters; 44, 45; 45, identifier:x; 46, identifier:x; 47, list:[self.partitioner(key)]; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:partitioner; 52, argument_list; 52, 53; 53, identifier:key; 54, return_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:values; 58, identifier:collect; 59, argument_list | def lookup(self, key):
values = self.filter(lambda kv: kv[0] == key).values()
if self.partitioner is not None:
return self.ctx.runJob(values, lambda x: x, [self.partitioner(key)])
return values.collect() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:describeTopics; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:maxTermsPerTopic; 7, None; 8, block; 8, 9; 8, 35; 9, if_statement; 9, 10; 9, 13; 9, 23; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:maxTermsPerTopic; 12, None; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:topics; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:call; 21, argument_list; 21, 22; 22, string:"describeTopics"; 23, else_clause; 23, 24; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:topics; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:call; 32, argument_list; 32, 33; 32, 34; 33, string:"describeTopics"; 34, identifier:maxTermsPerTopic; 35, return_statement; 35, 36; 36, identifier:topics | def describeTopics(self, maxTermsPerTopic=None):
if maxTermsPerTopic is None:
topics = self.call("describeTopics")
else:
topics = self.call("describeTopics", maxTermsPerTopic)
return topics |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_sort_cols; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:cols; 6, identifier:kwargs; 7, block; 7, 8; 7, 17; 7, 39; 7, 50; 7, 60; 7, 125; 8, if_statement; 8, 9; 8, 11; 9, not_operator; 9, 10; 10, identifier:cols; 11, block; 11, 12; 12, raise_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:ValueError; 15, argument_list; 15, 16; 16, string:"should sort by at least one column"; 17, if_statement; 17, 18; 17, 32; 18, boolean_operator:and; 18, 19; 18, 25; 19, comparison_operator:==; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:cols; 24, integer:1; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:cols; 30, integer:0; 31, identifier:list; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:cols; 36, subscript; 36, 37; 36, 38; 37, identifier:cols; 38, integer:0; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:jcols; 42, list_comprehension; 42, 43; 42, 47; 43, call; 43, 44; 43, 45; 44, identifier:_to_java_column; 45, argument_list; 45, 46; 46, identifier:c; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:c; 49, identifier:cols; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ascending; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:kwargs; 56, identifier:get; 57, argument_list; 57, 58; 57, 59; 58, string:'ascending'; 59, True; 60, if_statement; 60, 61; 60, 68; 60, 85; 60, 113; 61, call; 61, 62; 61, 63; 62, identifier:isinstance; 63, argument_list; 63, 64; 63, 65; 64, identifier:ascending; 65, tuple; 65, 66; 65, 67; 66, identifier:bool; 67, identifier:int; 68, block; 68, 69; 69, if_statement; 69, 70; 69, 72; 70, not_operator; 70, 71; 71, identifier:ascending; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:jcols; 76, list_comprehension; 76, 77; 76, 82; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:jc; 80, identifier:desc; 81, argument_list; 82, for_in_clause; 82, 83; 82, 84; 83, identifier:jc; 84, identifier:jcols; 85, elif_clause; 85, 86; 85, 91; 86, call; 86, 87; 86, 88; 87, identifier:isinstance; 88, argument_list; 88, 89; 88, 90; 89, identifier:ascending; 90, identifier:list; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:jcols; 95, list_comprehension; 95, 96; 95, 104; 96, conditional_expression:if; 96, 97; 96, 98; 96, 99; 97, identifier:jc; 98, identifier:asc; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:jc; 102, identifier:desc; 103, argument_list; 104, for_in_clause; 104, 105; 104, 108; 105, pattern_list; 105, 106; 105, 107; 106, identifier:asc; 107, identifier:jc; 108, call; 108, 109; 108, 110; 109, identifier:zip; 110, argument_list; 110, 111; 110, 112; 111, identifier:ascending; 112, identifier:jcols; 113, else_clause; 113, 114; 114, block; 114, 115; 115, raise_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:TypeError; 118, argument_list; 118, 119; 119, binary_operator:%; 119, 120; 119, 121; 120, string:"ascending can only be boolean or list, but got %s"; 121, call; 121, 122; 121, 123; 122, identifier:type; 123, argument_list; 123, 124; 124, identifier:ascending; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_jseq; 130, argument_list; 130, 131; 131, identifier:jcols | def _sort_cols(self, cols, kwargs):
if not cols:
raise ValueError("should sort by at least one column")
if len(cols) == 1 and isinstance(cols[0], list):
cols = cols[0]
jcols = [_to_java_column(c) for c in cols]
ascending = kwargs.get('ascending', True)
if isinstance(ascending, (bool, int)):
if not ascending:
jcols = [jc.desc() for jc in jcols]
elif isinstance(ascending, list):
jcols = [jc if asc else jc.desc()
for asc, jc in zip(ascending, jcols)]
else:
raise TypeError("ascending can only be boolean or list, but got %s" % type(ascending))
return self._jseq(jcols) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_list_function_infos; 3, parameters; 3, 4; 4, identifier:jvm; 5, block; 5, 6; 5, 28; 5, 32; 5, 136; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:jinfos; 9, call; 9, 10; 9, 27; 10, attribute; 10, 11; 10, 26; 11, attribute; 11, 12; 11, 25; 12, attribute; 12, 13; 12, 24; 13, attribute; 13, 14; 13, 23; 14, attribute; 14, 15; 14, 22; 15, attribute; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:jvm; 19, identifier:org; 20, identifier:apache; 21, identifier:spark; 22, identifier:sql; 23, identifier:api; 24, identifier:python; 25, identifier:PythonSQLUtils; 26, identifier:listBuiltinFunctionInfos; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:infos; 31, list:[]; 32, for_statement; 32, 33; 32, 34; 32, 35; 33, identifier:jinfo; 34, identifier:jinfos; 35, block; 35, 36; 35, 44; 35, 52; 35, 67; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:name; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:jinfo; 42, identifier:getName; 43, argument_list; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:usage; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:jinfo; 50, identifier:getUsage; 51, argument_list; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:usage; 55, conditional_expression:if; 55, 56; 55, 63; 55, 66; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:usage; 59, identifier:replace; 60, argument_list; 60, 61; 60, 62; 61, string:"_FUNC_"; 62, identifier:name; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:usage; 65, None; 66, identifier:usage; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:infos; 71, identifier:append; 72, argument_list; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:ExpressionInfo; 75, argument_list; 75, 76; 75, 83; 75, 86; 75, 89; 75, 102; 75, 115; 75, 122; 75, 129; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:className; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:jinfo; 81, identifier:getClassName; 82, argument_list; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:name; 85, identifier:name; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:usage; 88, identifier:usage; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:arguments; 91, call; 91, 92; 91, 99; 92, attribute; 92, 93; 92, 98; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:jinfo; 96, identifier:getArguments; 97, argument_list; 98, identifier:replace; 99, argument_list; 99, 100; 99, 101; 100, string:"_FUNC_"; 101, identifier:name; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:examples; 104, call; 104, 105; 104, 112; 105, attribute; 105, 106; 105, 111; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:jinfo; 109, identifier:getExamples; 110, argument_list; 111, identifier:replace; 112, argument_list; 112, 113; 112, 114; 113, string:"_FUNC_"; 114, identifier:name; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:note; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:jinfo; 120, identifier:getNote; 121, argument_list; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:since; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:jinfo; 127, identifier:getSince; 128, argument_list; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:deprecated; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:jinfo; 134, identifier:getDeprecated; 135, argument_list; 136, return_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:sorted; 139, argument_list; 139, 140; 139, 141; 140, identifier:infos; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:key; 143, lambda; 143, 144; 143, 146; 144, lambda_parameters; 144, 145; 145, identifier:i; 146, attribute; 146, 147; 146, 148; 147, identifier:i; 148, identifier:name | def _list_function_infos(jvm):
jinfos = jvm.org.apache.spark.sql.api.python.PythonSQLUtils.listBuiltinFunctionInfos()
infos = []
for jinfo in jinfos:
name = jinfo.getName()
usage = jinfo.getUsage()
usage = usage.replace("_FUNC_", name) if usage is not None else usage
infos.append(ExpressionInfo(
className=jinfo.getClassName(),
name=name,
usage=usage,
arguments=jinfo.getArguments().replace("_FUNC_", name),
examples=jinfo.getExamples().replace("_FUNC_", name),
note=jinfo.getNote(),
since=jinfo.getSince(),
deprecated=jinfo.getDeprecated()))
return sorted(infos, key=lambda i: i.name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:iterables; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 14; 11, 18; 11, 24; 11, 62; 11, 177; 11, 217; 11, 222; 11, 286; 12, expression_statement; 12, 13; 13, string:'''Merge multiple sorted inputs into a single sorted output.
Similar to sorted(itertools.chain(*iterables)) but returns a generator,
does not pull the data into memory all at once, and assumes that each of
the input streams is already sorted (smallest to largest).
>>> list(merge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))
[0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
If *key* is not None, applies a key function to each element to determine
its sort order.
>>> list(merge(['dog', 'horse'], ['cat', 'fish', 'kangaroo'], key=len))
['dog', 'cat', 'fish', 'horse', 'kangaroo']
'''; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:h; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:h_append; 21, attribute; 21, 22; 21, 23; 22, identifier:h; 23, identifier:append; 24, if_statement; 24, 25; 24, 26; 24, 44; 25, identifier:reverse; 26, block; 26, 27; 26, 31; 26, 35; 26, 39; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:_heapify; 30, identifier:_heapify_max; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:_heappop; 34, identifier:_heappop_max; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:_heapreplace; 38, identifier:_heapreplace_max; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:direction; 42, unary_operator:-; 42, 43; 43, integer:1; 44, else_clause; 44, 45; 45, block; 45, 46; 45, 50; 45, 54; 45, 58; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:_heapify; 49, identifier:heapify; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:_heappop; 53, identifier:heappop; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:_heapreplace; 57, identifier:heapreplace; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:direction; 61, integer:1; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:key; 65, None; 66, block; 66, 67; 66, 99; 66, 104; 66, 154; 66, 176; 67, for_statement; 67, 68; 67, 71; 67, 79; 68, pattern_list; 68, 69; 68, 70; 69, identifier:order; 70, identifier:it; 71, call; 71, 72; 71, 73; 72, identifier:enumerate; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:map; 76, argument_list; 76, 77; 76, 78; 77, identifier:iter; 78, identifier:iterables; 79, block; 79, 80; 80, try_statement; 80, 81; 80, 95; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:h_append; 85, argument_list; 85, 86; 86, list:[next(it), order * direction, it]; 86, 87; 86, 91; 86, 94; 87, call; 87, 88; 87, 89; 88, identifier:next; 89, argument_list; 89, 90; 90, identifier:it; 91, binary_operator:*; 91, 92; 91, 93; 92, identifier:order; 93, identifier:direction; 94, identifier:it; 95, except_clause; 95, 96; 95, 97; 96, identifier:StopIteration; 97, block; 97, 98; 98, pass_statement; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:_heapify; 102, argument_list; 102, 103; 103, identifier:h; 104, while_statement; 104, 105; 104, 111; 105, comparison_operator:>; 105, 106; 105, 110; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, identifier:h; 110, integer:1; 111, block; 111, 112; 112, try_statement; 112, 113; 112, 146; 113, block; 113, 114; 114, while_statement; 114, 115; 114, 116; 115, True; 116, block; 116, 117; 116, 128; 116, 131; 116, 140; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 123; 119, pattern_list; 119, 120; 119, 121; 119, 122; 120, identifier:value; 121, identifier:order; 122, identifier:it; 123, assignment; 123, 124; 123, 125; 124, identifier:s; 125, subscript; 125, 126; 125, 127; 126, identifier:h; 127, integer:0; 128, expression_statement; 128, 129; 129, yield; 129, 130; 130, identifier:value; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:s; 135, integer:0; 136, call; 136, 137; 136, 138; 137, identifier:next; 138, argument_list; 138, 139; 139, identifier:it; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:_heapreplace; 143, argument_list; 143, 144; 143, 145; 144, identifier:h; 145, identifier:s; 146, except_clause; 146, 147; 146, 148; 147, identifier:StopIteration; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:_heappop; 152, argument_list; 152, 153; 153, identifier:h; 154, if_statement; 154, 155; 154, 156; 155, identifier:h; 156, block; 156, 157; 156, 166; 156, 169; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 163; 159, pattern_list; 159, 160; 159, 161; 159, 162; 160, identifier:value; 161, identifier:order; 162, identifier:it; 163, subscript; 163, 164; 163, 165; 164, identifier:h; 165, integer:0; 166, expression_statement; 166, 167; 167, yield; 167, 168; 168, identifier:value; 169, for_statement; 169, 170; 169, 171; 169, 172; 170, identifier:value; 171, identifier:it; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, yield; 174, 175; 175, identifier:value; 176, return_statement; 177, for_statement; 177, 178; 177, 181; 177, 189; 178, pattern_list; 178, 179; 178, 180; 179, identifier:order; 180, identifier:it; 181, call; 181, 182; 181, 183; 182, identifier:enumerate; 183, argument_list; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:map; 186, argument_list; 186, 187; 186, 188; 187, identifier:iter; 188, identifier:iterables; 189, block; 189, 190; 190, try_statement; 190, 191; 190, 213; 191, block; 191, 192; 191, 199; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:value; 195, call; 195, 196; 195, 197; 196, identifier:next; 197, argument_list; 197, 198; 198, identifier:it; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:h_append; 202, argument_list; 202, 203; 203, list:[key(value), order * direction, value, it]; 203, 204; 203, 208; 203, 211; 203, 212; 204, call; 204, 205; 204, 206; 205, identifier:key; 206, argument_list; 206, 207; 207, identifier:value; 208, binary_operator:*; 208, 209; 208, 210; 209, identifier:order; 210, identifier:direction; 211, identifier:value; 212, identifier:it; 213, except_clause; 213, 214; 213, 215; 214, identifier:StopIteration; 215, block; 215, 216; 216, pass_statement; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 220; 219, identifier:_heapify; 220, argument_list; 220, 221; 221, identifier:h; 222, while_statement; 222, 223; 222, 229; 223, comparison_operator:>; 223, 224; 223, 228; 224, call; 224, 225; 224, 226; 225, identifier:len; 226, argument_list; 226, 227; 227, identifier:h; 228, integer:1; 229, block; 229, 230; 230, try_statement; 230, 231; 230, 278; 231, block; 231, 232; 232, while_statement; 232, 233; 232, 234; 233, True; 234, block; 234, 235; 234, 247; 234, 250; 234, 257; 234, 266; 234, 272; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 242; 237, pattern_list; 237, 238; 237, 239; 237, 240; 237, 241; 238, identifier:key_value; 239, identifier:order; 240, identifier:value; 241, identifier:it; 242, assignment; 242, 243; 242, 244; 243, identifier:s; 244, subscript; 244, 245; 244, 246; 245, identifier:h; 246, integer:0; 247, expression_statement; 247, 248; 248, yield; 248, 249; 249, identifier:value; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:value; 253, call; 253, 254; 253, 255; 254, identifier:next; 255, argument_list; 255, 256; 256, identifier:it; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 262; 259, subscript; 259, 260; 259, 261; 260, identifier:s; 261, integer:0; 262, call; 262, 263; 262, 264; 263, identifier:key; 264, argument_list; 264, 265; 265, identifier:value; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 271; 268, subscript; 268, 269; 268, 270; 269, identifier:s; 270, integer:2; 271, identifier:value; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 275; 274, identifier:_heapreplace; 275, argument_list; 275, 276; 275, 277; 276, identifier:h; 277, identifier:s; 278, except_clause; 278, 279; 278, 280; 279, identifier:StopIteration; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:_heappop; 284, argument_list; 284, 285; 285, identifier:h; 286, if_statement; 286, 287; 286, 288; 287, identifier:h; 288, block; 288, 289; 288, 299; 288, 302; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 296; 291, pattern_list; 291, 292; 291, 293; 291, 294; 291, 295; 292, identifier:key_value; 293, identifier:order; 294, identifier:value; 295, identifier:it; 296, subscript; 296, 297; 296, 298; 297, identifier:h; 298, integer:0; 299, expression_statement; 299, 300; 300, yield; 300, 301; 301, identifier:value; 302, for_statement; 302, 303; 302, 304; 302, 305; 303, identifier:value; 304, identifier:it; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, yield; 307, 308; 308, identifier:value | def merge(iterables, key=None, reverse=False):
'''Merge multiple sorted inputs into a single sorted output.
Similar to sorted(itertools.chain(*iterables)) but returns a generator,
does not pull the data into memory all at once, and assumes that each of
the input streams is already sorted (smallest to largest).
>>> list(merge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))
[0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
If *key* is not None, applies a key function to each element to determine
its sort order.
>>> list(merge(['dog', 'horse'], ['cat', 'fish', 'kangaroo'], key=len))
['dog', 'cat', 'fish', 'horse', 'kangaroo']
'''
h = []
h_append = h.append
if reverse:
_heapify = _heapify_max
_heappop = _heappop_max
_heapreplace = _heapreplace_max
direction = -1
else:
_heapify = heapify
_heappop = heappop
_heapreplace = heapreplace
direction = 1
if key is None:
for order, it in enumerate(map(iter, iterables)):
try:
h_append([next(it), order * direction, it])
except StopIteration:
pass
_heapify(h)
while len(h) > 1:
try:
while True:
value, order, it = s = h[0]
yield value
s[0] = next(it)
_heapreplace(h, s)
except StopIteration:
_heappop(h)
if h:
value, order, it = h[0]
yield value
for value in it:
yield value
return
for order, it in enumerate(map(iter, iterables)):
try:
value = next(it)
h_append([key(value), order * direction, value, it])
except StopIteration:
pass
_heapify(h)
while len(h) > 1:
try:
while True:
key_value, order, value, it = s = h[0]
yield value
value = next(it)
s[0] = key(value)
s[2] = value
_heapreplace(h, s)
except StopIteration:
_heappop(h)
if h:
key_value, order, value, it = h[0]
yield value
for value in it:
yield value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:nsmallest; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:n; 5, identifier:iterable; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 66; 9, 100; 9, 201; 9, 208; 9, 231; 9, 237; 9, 242; 9, 250; 9, 254; 9, 258; 9, 295; 9, 301; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:==; 11, 12; 11, 13; 12, identifier:n; 13, integer:1; 14, block; 14, 15; 14, 22; 14, 28; 14, 58; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:it; 18, call; 18, 19; 18, 20; 19, identifier:iter; 20, argument_list; 20, 21; 21, identifier:iterable; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sentinel; 25, call; 25, 26; 25, 27; 26, identifier:object; 27, argument_list; 28, if_statement; 28, 29; 28, 32; 28, 43; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:key; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:result; 36, call; 36, 37; 36, 38; 37, identifier:min; 38, argument_list; 38, 39; 38, 40; 39, identifier:it; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:default; 42, identifier:sentinel; 43, else_clause; 43, 44; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:result; 48, call; 48, 49; 48, 50; 49, identifier:min; 50, argument_list; 50, 51; 50, 52; 50, 55; 51, identifier:it; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:default; 54, identifier:sentinel; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:key; 57, identifier:key; 58, return_statement; 58, 59; 59, conditional_expression:if; 59, 60; 59, 61; 59, 64; 60, list:[]; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:result; 63, identifier:sentinel; 64, list:[result]; 64, 65; 65, identifier:result; 66, try_statement; 66, 67; 66, 75; 66, 81; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:size; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:iterable; 75, except_clause; 75, 76; 75, 79; 76, tuple; 76, 77; 76, 78; 77, identifier:TypeError; 78, identifier:AttributeError; 79, block; 79, 80; 80, pass_statement; 81, else_clause; 81, 82; 82, block; 82, 83; 83, if_statement; 83, 84; 83, 87; 84, comparison_operator:>=; 84, 85; 84, 86; 85, identifier:n; 86, identifier:size; 87, block; 87, 88; 88, return_statement; 88, 89; 89, subscript; 89, 90; 89, 97; 90, call; 90, 91; 90, 92; 91, identifier:sorted; 92, argument_list; 92, 93; 92, 94; 93, identifier:iterable; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:key; 96, identifier:key; 97, slice; 97, 98; 97, 99; 98, colon; 99, identifier:n; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:key; 103, None; 104, block; 104, 105; 104, 112; 104, 131; 104, 137; 104, 142; 104, 150; 104, 154; 104, 158; 104, 187; 104, 193; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:it; 108, call; 108, 109; 108, 110; 109, identifier:iter; 110, argument_list; 110, 111; 111, identifier:iterable; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:result; 115, list_comprehension; 115, 116; 115, 119; 116, tuple; 116, 117; 116, 118; 117, identifier:elem; 118, identifier:i; 119, for_in_clause; 119, 120; 119, 123; 120, pattern_list; 120, 121; 120, 122; 121, identifier:i; 122, identifier:elem; 123, call; 123, 124; 123, 125; 124, identifier:zip; 125, argument_list; 125, 126; 125, 130; 126, call; 126, 127; 126, 128; 127, identifier:range; 128, argument_list; 128, 129; 129, identifier:n; 130, identifier:it; 131, if_statement; 131, 132; 131, 134; 132, not_operator; 132, 133; 133, identifier:result; 134, block; 134, 135; 135, return_statement; 135, 136; 136, identifier:result; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:_heapify_max; 140, argument_list; 140, 141; 141, identifier:result; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:top; 145, subscript; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:result; 148, integer:0; 149, integer:0; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:order; 153, identifier:n; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:_heapreplace; 157, identifier:_heapreplace_max; 158, for_statement; 158, 159; 158, 160; 158, 161; 159, identifier:elem; 160, identifier:it; 161, block; 161, 162; 162, if_statement; 162, 163; 162, 166; 163, comparison_operator:<; 163, 164; 163, 165; 164, identifier:elem; 165, identifier:top; 166, block; 166, 167; 166, 175; 166, 183; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:_heapreplace; 170, argument_list; 170, 171; 170, 172; 171, identifier:result; 172, tuple; 172, 173; 172, 174; 173, identifier:elem; 174, identifier:order; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:top; 178, subscript; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:result; 181, integer:0; 182, integer:0; 183, expression_statement; 183, 184; 184, augmented_assignment:+=; 184, 185; 184, 186; 185, identifier:order; 186, integer:1; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:result; 191, identifier:sort; 192, argument_list; 193, return_statement; 193, 194; 194, list_comprehension; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:r; 197, integer:0; 198, for_in_clause; 198, 199; 198, 200; 199, identifier:r; 200, identifier:result; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:it; 204, call; 204, 205; 204, 206; 205, identifier:iter; 206, argument_list; 206, 207; 207, identifier:iterable; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:result; 211, list_comprehension; 211, 212; 211, 219; 212, tuple; 212, 213; 212, 217; 212, 218; 213, call; 213, 214; 213, 215; 214, identifier:key; 215, argument_list; 215, 216; 216, identifier:elem; 217, identifier:i; 218, identifier:elem; 219, for_in_clause; 219, 220; 219, 223; 220, pattern_list; 220, 221; 220, 222; 221, identifier:i; 222, identifier:elem; 223, call; 223, 224; 223, 225; 224, identifier:zip; 225, argument_list; 225, 226; 225, 230; 226, call; 226, 227; 226, 228; 227, identifier:range; 228, argument_list; 228, 229; 229, identifier:n; 230, identifier:it; 231, if_statement; 231, 232; 231, 234; 232, not_operator; 232, 233; 233, identifier:result; 234, block; 234, 235; 235, return_statement; 235, 236; 236, identifier:result; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 240; 239, identifier:_heapify_max; 240, argument_list; 240, 241; 241, identifier:result; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:top; 245, subscript; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:result; 248, integer:0; 249, integer:0; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:order; 253, identifier:n; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:_heapreplace; 257, identifier:_heapreplace_max; 258, for_statement; 258, 259; 258, 260; 258, 261; 259, identifier:elem; 260, identifier:it; 261, block; 261, 262; 261, 269; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:k; 265, call; 265, 266; 265, 267; 266, identifier:key; 267, argument_list; 267, 268; 268, identifier:elem; 269, if_statement; 269, 270; 269, 273; 270, comparison_operator:<; 270, 271; 270, 272; 271, identifier:k; 272, identifier:top; 273, block; 273, 274; 273, 283; 273, 291; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 277; 276, identifier:_heapreplace; 277, argument_list; 277, 278; 277, 279; 278, identifier:result; 279, tuple; 279, 280; 279, 281; 279, 282; 280, identifier:k; 281, identifier:order; 282, identifier:elem; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:top; 286, subscript; 286, 287; 286, 290; 287, subscript; 287, 288; 287, 289; 288, identifier:result; 289, integer:0; 290, integer:0; 291, expression_statement; 291, 292; 292, augmented_assignment:+=; 292, 293; 292, 294; 293, identifier:order; 294, integer:1; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:result; 299, identifier:sort; 300, argument_list; 301, return_statement; 301, 302; 302, list_comprehension; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:r; 305, integer:2; 306, for_in_clause; 306, 307; 306, 308; 307, identifier:r; 308, identifier:result | def nsmallest(n, iterable, key=None):
if n == 1:
it = iter(iterable)
sentinel = object()
if key is None:
result = min(it, default=sentinel)
else:
result = min(it, default=sentinel, key=key)
return [] if result is sentinel else [result]
try:
size = len(iterable)
except (TypeError, AttributeError):
pass
else:
if n >= size:
return sorted(iterable, key=key)[:n]
if key is None:
it = iter(iterable)
result = [(elem, i) for i, elem in zip(range(n), it)]
if not result:
return result
_heapify_max(result)
top = result[0][0]
order = n
_heapreplace = _heapreplace_max
for elem in it:
if elem < top:
_heapreplace(result, (elem, order))
top = result[0][0]
order += 1
result.sort()
return [r[0] for r in result]
it = iter(iterable)
result = [(key(elem), i, elem) for i, elem in zip(range(n), it)]
if not result:
return result
_heapify_max(result)
top = result[0][0]
order = n
_heapreplace = _heapreplace_max
for elem in it:
k = key(elem)
if k < top:
_heapreplace(result, (k, order, elem))
top = result[0][0]
order += 1
result.sort()
return [r[2] for r in result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:nlargest; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:n; 5, identifier:iterable; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, None; 9, block; 9, 10; 9, 66; 9, 103; 9, 212; 9, 219; 9, 246; 9, 252; 9, 257; 9, 265; 9, 270; 9, 274; 9, 311; 9, 320; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:==; 11, 12; 11, 13; 12, identifier:n; 13, integer:1; 14, block; 14, 15; 14, 22; 14, 28; 14, 58; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:it; 18, call; 18, 19; 18, 20; 19, identifier:iter; 20, argument_list; 20, 21; 21, identifier:iterable; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sentinel; 25, call; 25, 26; 25, 27; 26, identifier:object; 27, argument_list; 28, if_statement; 28, 29; 28, 32; 28, 43; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:key; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:result; 36, call; 36, 37; 36, 38; 37, identifier:max; 38, argument_list; 38, 39; 38, 40; 39, identifier:it; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:default; 42, identifier:sentinel; 43, else_clause; 43, 44; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:result; 48, call; 48, 49; 48, 50; 49, identifier:max; 50, argument_list; 50, 51; 50, 52; 50, 55; 51, identifier:it; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:default; 54, identifier:sentinel; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:key; 57, identifier:key; 58, return_statement; 58, 59; 59, conditional_expression:if; 59, 60; 59, 61; 59, 64; 60, list:[]; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:result; 63, identifier:sentinel; 64, list:[result]; 64, 65; 65, identifier:result; 66, try_statement; 66, 67; 66, 75; 66, 81; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:size; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:iterable; 75, except_clause; 75, 76; 75, 79; 76, tuple; 76, 77; 76, 78; 77, identifier:TypeError; 78, identifier:AttributeError; 79, block; 79, 80; 80, pass_statement; 81, else_clause; 81, 82; 82, block; 82, 83; 83, if_statement; 83, 84; 83, 87; 84, comparison_operator:>=; 84, 85; 84, 86; 85, identifier:n; 86, identifier:size; 87, block; 87, 88; 88, return_statement; 88, 89; 89, subscript; 89, 90; 89, 100; 90, call; 90, 91; 90, 92; 91, identifier:sorted; 92, argument_list; 92, 93; 92, 94; 92, 97; 93, identifier:iterable; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:key; 96, identifier:key; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:reverse; 99, True; 100, slice; 100, 101; 100, 102; 101, colon; 102, identifier:n; 103, if_statement; 103, 104; 103, 107; 104, comparison_operator:is; 104, 105; 104, 106; 105, identifier:key; 106, None; 107, block; 107, 108; 107, 115; 107, 138; 107, 144; 107, 149; 107, 157; 107, 162; 107, 166; 107, 195; 107, 204; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:it; 111, call; 111, 112; 111, 113; 112, identifier:iter; 113, argument_list; 113, 114; 114, identifier:iterable; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:result; 118, list_comprehension; 118, 119; 118, 122; 119, tuple; 119, 120; 119, 121; 120, identifier:elem; 121, identifier:i; 122, for_in_clause; 122, 123; 122, 126; 123, pattern_list; 123, 124; 123, 125; 124, identifier:i; 125, identifier:elem; 126, call; 126, 127; 126, 128; 127, identifier:zip; 128, argument_list; 128, 129; 128, 137; 129, call; 129, 130; 129, 131; 130, identifier:range; 131, argument_list; 131, 132; 131, 133; 131, 135; 132, integer:0; 133, unary_operator:-; 133, 134; 134, identifier:n; 135, unary_operator:-; 135, 136; 136, integer:1; 137, identifier:it; 138, if_statement; 138, 139; 138, 141; 139, not_operator; 139, 140; 140, identifier:result; 141, block; 141, 142; 142, return_statement; 142, 143; 143, identifier:result; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:heapify; 147, argument_list; 147, 148; 148, identifier:result; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:top; 152, subscript; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:result; 155, integer:0; 156, integer:0; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:order; 160, unary_operator:-; 160, 161; 161, identifier:n; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:_heapreplace; 165, identifier:heapreplace; 166, for_statement; 166, 167; 166, 168; 166, 169; 167, identifier:elem; 168, identifier:it; 169, block; 169, 170; 170, if_statement; 170, 171; 170, 174; 171, comparison_operator:<; 171, 172; 171, 173; 172, identifier:top; 173, identifier:elem; 174, block; 174, 175; 174, 183; 174, 191; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:_heapreplace; 178, argument_list; 178, 179; 178, 180; 179, identifier:result; 180, tuple; 180, 181; 180, 182; 181, identifier:elem; 182, identifier:order; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:top; 186, subscript; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:result; 189, integer:0; 190, integer:0; 191, expression_statement; 191, 192; 192, augmented_assignment:-=; 192, 193; 192, 194; 193, identifier:order; 194, integer:1; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:result; 199, identifier:sort; 200, argument_list; 200, 201; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:reverse; 203, True; 204, return_statement; 204, 205; 205, list_comprehension; 205, 206; 205, 209; 206, subscript; 206, 207; 206, 208; 207, identifier:r; 208, integer:0; 209, for_in_clause; 209, 210; 209, 211; 210, identifier:r; 211, identifier:result; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:it; 215, call; 215, 216; 215, 217; 216, identifier:iter; 217, argument_list; 217, 218; 218, identifier:iterable; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:result; 222, list_comprehension; 222, 223; 222, 230; 223, tuple; 223, 224; 223, 228; 223, 229; 224, call; 224, 225; 224, 226; 225, identifier:key; 226, argument_list; 226, 227; 227, identifier:elem; 228, identifier:i; 229, identifier:elem; 230, for_in_clause; 230, 231; 230, 234; 231, pattern_list; 231, 232; 231, 233; 232, identifier:i; 233, identifier:elem; 234, call; 234, 235; 234, 236; 235, identifier:zip; 236, argument_list; 236, 237; 236, 245; 237, call; 237, 238; 237, 239; 238, identifier:range; 239, argument_list; 239, 240; 239, 241; 239, 243; 240, integer:0; 241, unary_operator:-; 241, 242; 242, identifier:n; 243, unary_operator:-; 243, 244; 244, integer:1; 245, identifier:it; 246, if_statement; 246, 247; 246, 249; 247, not_operator; 247, 248; 248, identifier:result; 249, block; 249, 250; 250, return_statement; 250, 251; 251, identifier:result; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:heapify; 255, argument_list; 255, 256; 256, identifier:result; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:top; 260, subscript; 260, 261; 260, 264; 261, subscript; 261, 262; 261, 263; 262, identifier:result; 263, integer:0; 264, integer:0; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:order; 268, unary_operator:-; 268, 269; 269, identifier:n; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:_heapreplace; 273, identifier:heapreplace; 274, for_statement; 274, 275; 274, 276; 274, 277; 275, identifier:elem; 276, identifier:it; 277, block; 277, 278; 277, 285; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:k; 281, call; 281, 282; 281, 283; 282, identifier:key; 283, argument_list; 283, 284; 284, identifier:elem; 285, if_statement; 285, 286; 285, 289; 286, comparison_operator:<; 286, 287; 286, 288; 287, identifier:top; 288, identifier:k; 289, block; 289, 290; 289, 299; 289, 307; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 293; 292, identifier:_heapreplace; 293, argument_list; 293, 294; 293, 295; 294, identifier:result; 295, tuple; 295, 296; 295, 297; 295, 298; 296, identifier:k; 297, identifier:order; 298, identifier:elem; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:top; 302, subscript; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:result; 305, integer:0; 306, integer:0; 307, expression_statement; 307, 308; 308, augmented_assignment:-=; 308, 309; 308, 310; 309, identifier:order; 310, integer:1; 311, expression_statement; 311, 312; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:result; 315, identifier:sort; 316, argument_list; 316, 317; 317, keyword_argument; 317, 318; 317, 319; 318, identifier:reverse; 319, True; 320, return_statement; 320, 321; 321, list_comprehension; 321, 322; 321, 325; 322, subscript; 322, 323; 322, 324; 323, identifier:r; 324, integer:2; 325, for_in_clause; 325, 326; 325, 327; 326, identifier:r; 327, identifier:result | def nlargest(n, iterable, key=None):
if n == 1:
it = iter(iterable)
sentinel = object()
if key is None:
result = max(it, default=sentinel)
else:
result = max(it, default=sentinel, key=key)
return [] if result is sentinel else [result]
try:
size = len(iterable)
except (TypeError, AttributeError):
pass
else:
if n >= size:
return sorted(iterable, key=key, reverse=True)[:n]
if key is None:
it = iter(iterable)
result = [(elem, i) for i, elem in zip(range(0, -n, -1), it)]
if not result:
return result
heapify(result)
top = result[0][0]
order = -n
_heapreplace = heapreplace
for elem in it:
if top < elem:
_heapreplace(result, (elem, order))
top = result[0][0]
order -= 1
result.sort(reverse=True)
return [r[0] for r in result]
it = iter(iterable)
result = [(key(elem), i, elem) for i, elem in zip(range(0, -n, -1), it)]
if not result:
return result
heapify(result)
top = result[0][0]
order = -n
_heapreplace = heapreplace
for elem in it:
k = key(elem)
if top < k:
_heapreplace(result, (k, order, elem))
top = result[0][0]
order -= 1
result.sort(reverse=True)
return [r[2] for r in result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sortBy; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:col; 6, list_splat_pattern; 6, 7; 7, identifier:cols; 8, block; 8, 9; 8, 48; 8, 75; 8, 97; 9, if_statement; 9, 10; 9, 17; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:col; 14, tuple; 14, 15; 14, 16; 15, identifier:list; 16, identifier:tuple; 17, block; 17, 18; 17, 34; 18, if_statement; 18, 19; 18, 20; 19, identifier:cols; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:ValueError; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, string:"col is a {0} but cols are not empty"; 28, identifier:format; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:type; 32, argument_list; 32, 33; 33, identifier:col; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, pattern_list; 36, 37; 36, 38; 37, identifier:col; 38, identifier:cols; 39, expression_list; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:col; 42, integer:0; 43, subscript; 43, 44; 43, 45; 44, identifier:col; 45, slice; 45, 46; 45, 47; 46, integer:1; 47, colon; 48, if_statement; 48, 49; 48, 69; 49, boolean_operator:or; 49, 50; 49, 62; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:all; 53, generator_expression; 53, 54; 53, 59; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:c; 58, identifier:basestring; 59, for_in_clause; 59, 60; 59, 61; 60, identifier:c; 61, identifier:cols; 62, not_operator; 62, 63; 63, parenthesized_expression; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:isinstance; 66, argument_list; 66, 67; 66, 68; 67, identifier:col; 68, identifier:basestring; 69, block; 69, 70; 70, raise_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:TypeError; 73, argument_list; 73, 74; 74, string:"all names should be `str`"; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:_jwrite; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_jwrite; 85, identifier:sortBy; 86, argument_list; 86, 87; 86, 88; 87, identifier:col; 88, call; 88, 89; 88, 90; 89, identifier:_to_seq; 90, argument_list; 90, 91; 90, 96; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_spark; 95, identifier:_sc; 96, identifier:cols; 97, return_statement; 97, 98; 98, identifier:self | def sortBy(self, col, *cols):
if isinstance(col, (list, tuple)):
if cols:
raise ValueError("col is a {0} but cols are not empty".format(type(col)))
col, cols = col[0], col[1:]
if not all(isinstance(c, basestring) for c in cols) or not(isinstance(col, basestring)):
raise TypeError("all names should be `str`")
self._jwrite = self._jwrite.sortBy(col, _to_seq(self._spark._sc, cols))
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:saveAsLibSVMFile; 3, parameters; 3, 4; 3, 5; 4, identifier:data; 5, identifier:dir; 6, block; 6, 7; 6, 24; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:lines; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:data; 13, identifier:map; 14, argument_list; 14, 15; 15, lambda; 15, 16; 15, 18; 16, lambda_parameters; 16, 17; 17, identifier:p; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:MLUtils; 21, identifier:_convert_labeled_point_to_libsvm; 22, argument_list; 22, 23; 23, identifier:p; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:lines; 28, identifier:saveAsTextFile; 29, argument_list; 29, 30; 30, identifier:dir | def saveAsLibSVMFile(data, dir):
lines = data.map(lambda p: MLUtils._convert_labeled_point_to_libsvm(p))
lines.saveAsTextFile(dir) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:rdds; 6, block; 6, 7; 6, 15; 6, 40; 6, 58; 6, 73; 6, 94; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:first_jrdd_deserializer; 10, attribute; 10, 11; 10, 14; 11, subscript; 11, 12; 11, 13; 12, identifier:rdds; 13, integer:0; 14, identifier:_jrdd_deserializer; 15, if_statement; 15, 16; 15, 27; 16, call; 16, 17; 16, 18; 17, identifier:any; 18, generator_expression; 18, 19; 18, 24; 19, comparison_operator:!=; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:x; 22, identifier:_jrdd_deserializer; 23, identifier:first_jrdd_deserializer; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:x; 26, identifier:rdds; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:rdds; 31, list_comprehension; 31, 32; 31, 37; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:x; 35, identifier:_reserialize; 36, argument_list; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:x; 39, identifier:rdds; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:cls; 43, attribute; 43, 44; 43, 57; 44, attribute; 44, 45; 44, 56; 45, attribute; 45, 46; 45, 55; 46, attribute; 46, 47; 46, 54; 47, attribute; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:SparkContext; 51, identifier:_jvm; 52, identifier:org; 53, identifier:apache; 54, identifier:spark; 55, identifier:api; 56, identifier:java; 57, identifier:JavaRDD; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:jrdds; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:SparkContext; 65, identifier:_gateway; 66, identifier:new_array; 67, argument_list; 67, 68; 67, 69; 68, identifier:cls; 69, call; 69, 70; 69, 71; 70, identifier:len; 71, argument_list; 71, 72; 72, identifier:rdds; 73, for_statement; 73, 74; 73, 75; 73, 83; 74, identifier:i; 75, call; 75, 76; 75, 77; 76, identifier:range; 77, argument_list; 77, 78; 77, 79; 78, integer:0; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:rdds; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:jrdds; 88, identifier:i; 89, attribute; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:rdds; 92, identifier:i; 93, identifier:_jrdd; 94, return_statement; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:RDD; 97, argument_list; 97, 98; 97, 106; 97, 107; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:_jsc; 103, identifier:union; 104, argument_list; 104, 105; 105, identifier:jrdds; 106, identifier:self; 107, attribute; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:rdds; 110, integer:0; 111, identifier:_jrdd_deserializer | def union(self, rdds):
first_jrdd_deserializer = rdds[0]._jrdd_deserializer
if any(x._jrdd_deserializer != first_jrdd_deserializer for x in rdds):
rdds = [x._reserialize() for x in rdds]
cls = SparkContext._jvm.org.apache.spark.api.java.JavaRDD
jrdds = SparkContext._gateway.new_array(cls, len(rdds))
for i in range(0, len(rdds)):
jrdds[i] = rdds[i]._jrdd
return RDD(self._jsc.union(jrdds), self, rdds[0]._jrdd_deserializer) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sortlevel; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:level; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_remaining; 13, None; 14, block; 14, 15; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:sort_values; 20, argument_list; 20, 21; 20, 24; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:return_indexer; 23, True; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:ascending; 26, identifier:ascending | def sortlevel(self, level=None, ascending=True, sort_remaining=None):
return self.sort_values(return_indexer=True, ascending=ascending) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_duplicates; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 20; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:warnings; 10, identifier:warn; 11, argument_list; 11, 12; 11, 16; 11, 17; 12, concatenated_string; 12, 13; 12, 14; 12, 15; 13, string:"'get_duplicates' is deprecated and will be removed in "; 14, string:"a future release. You can use "; 15, string:"idx[idx.duplicated()].unique() instead"; 16, identifier:FutureWarning; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:stacklevel; 19, integer:2; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 31; 22, attribute; 22, 23; 22, 30; 23, subscript; 23, 24; 23, 25; 24, identifier:self; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:duplicated; 29, argument_list; 30, identifier:unique; 31, argument_list | def get_duplicates(self):
warnings.warn("'get_duplicates' is deprecated and will be removed in "
"a future release. You can use "
"idx[idx.duplicated()].unique() instead",
FutureWarning, stacklevel=2)
return self[self.duplicated()].unique() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, block; 9, 10; 9, 17; 9, 24; 9, 31; 9, 53; 9, 68; 9, 108; 9, 133; 9, 158; 9, 319; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_validate_sort_keyword; 15, argument_list; 15, 16; 16, identifier:sort; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_assert_can_do_setop; 22, argument_list; 22, 23; 23, identifier:other; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:other; 27, call; 27, 28; 27, 29; 28, identifier:ensure_index; 29, argument_list; 29, 30; 30, identifier:other; 31, if_statement; 31, 32; 31, 45; 32, boolean_operator:or; 32, 33; 32, 39; 33, comparison_operator:==; 33, 34; 33, 38; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, identifier:other; 38, integer:0; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:equals; 43, argument_list; 43, 44; 44, identifier:other; 45, block; 45, 46; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_get_reconciled_name_object; 51, argument_list; 51, 52; 52, identifier:other; 53, if_statement; 53, 54; 53, 60; 54, comparison_operator:==; 54, 55; 54, 59; 55, call; 55, 56; 55, 57; 56, identifier:len; 57, argument_list; 57, 58; 58, identifier:self; 59, integer:0; 60, block; 60, 61; 61, return_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:other; 65, identifier:_get_reconciled_name_object; 66, argument_list; 66, 67; 67, identifier:self; 68, if_statement; 68, 69; 68, 79; 69, not_operator; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:is_dtype_union_equal; 72, argument_list; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:dtype; 76, attribute; 76, 77; 76, 78; 77, identifier:other; 78, identifier:dtype; 79, block; 79, 80; 79, 89; 79, 98; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:this; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:astype; 87, argument_list; 87, 88; 88, string:'O'; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:other; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:other; 95, identifier:astype; 96, argument_list; 96, 97; 97, string:'O'; 98, return_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:this; 102, identifier:union; 103, argument_list; 103, 104; 103, 105; 104, identifier:other; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:sort; 107, identifier:sort; 108, if_statement; 108, 109; 108, 118; 108, 125; 109, boolean_operator:or; 109, 110; 109, 114; 110, call; 110, 111; 110, 112; 111, identifier:is_period_dtype; 112, argument_list; 112, 113; 113, identifier:self; 114, call; 114, 115; 114, 116; 115, identifier:is_datetime64tz_dtype; 116, argument_list; 116, 117; 117, identifier:self; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:lvals; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_ndarray_values; 125, else_clause; 125, 126; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:lvals; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_values; 133, if_statement; 133, 134; 133, 143; 133, 150; 134, boolean_operator:or; 134, 135; 134, 139; 135, call; 135, 136; 135, 137; 136, identifier:is_period_dtype; 137, argument_list; 137, 138; 138, identifier:other; 139, call; 139, 140; 139, 141; 140, identifier:is_datetime64tz_dtype; 141, argument_list; 141, 142; 142, identifier:other; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:rvals; 147, attribute; 147, 148; 147, 149; 148, identifier:other; 149, identifier:_ndarray_values; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:rvals; 155, attribute; 155, 156; 155, 157; 156, identifier:other; 157, identifier:_values; 158, if_statement; 158, 159; 158, 170; 158, 217; 159, boolean_operator:and; 159, 160; 159, 167; 160, boolean_operator:and; 160, 161; 160, 164; 161, comparison_operator:is; 161, 162; 161, 163; 162, identifier:sort; 163, None; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:is_monotonic; 167, attribute; 167, 168; 167, 169; 168, identifier:other; 169, identifier:is_monotonic; 170, block; 170, 171; 171, try_statement; 171, 172; 171, 185; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:result; 176, subscript; 176, 177; 176, 184; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:_outer_indexer; 181, argument_list; 181, 182; 181, 183; 182, identifier:lvals; 183, identifier:rvals; 184, integer:0; 185, except_clause; 185, 186; 185, 187; 186, identifier:TypeError; 187, block; 187, 188; 187, 195; 187, 202; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:result; 191, call; 191, 192; 191, 193; 192, identifier:list; 193, argument_list; 193, 194; 194, identifier:lvals; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:value_set; 198, call; 198, 199; 198, 200; 199, identifier:set; 200, argument_list; 200, 201; 201, identifier:lvals; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:result; 206, identifier:extend; 207, argument_list; 207, 208; 208, list_comprehension; 208, 209; 208, 210; 208, 213; 209, identifier:x; 210, for_in_clause; 210, 211; 210, 212; 211, identifier:x; 212, identifier:rvals; 213, if_clause; 213, 214; 214, comparison_operator:not; 214, 215; 214, 216; 215, identifier:x; 216, identifier:value_set; 217, else_clause; 217, 218; 218, block; 218, 219; 218, 228; 218, 241; 218, 279; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:indexer; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:get_indexer; 226, argument_list; 226, 227; 227, identifier:other; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 232; 230, pattern_list; 230, 231; 231, identifier:indexer; 232, call; 232, 233; 232, 240; 233, attribute; 233, 234; 233, 239; 234, parenthesized_expression; 234, 235; 235, comparison_operator:==; 235, 236; 235, 237; 236, identifier:indexer; 237, unary_operator:-; 237, 238; 238, integer:1; 239, identifier:nonzero; 240, argument_list; 241, if_statement; 241, 242; 241, 248; 241, 273; 242, comparison_operator:>; 242, 243; 242, 247; 243, call; 243, 244; 243, 245; 244, identifier:len; 245, argument_list; 245, 246; 246, identifier:indexer; 247, integer:0; 248, block; 248, 249; 248, 262; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:other_diff; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:algos; 255, identifier:take_nd; 256, argument_list; 256, 257; 256, 258; 256, 259; 257, identifier:rvals; 258, identifier:indexer; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:allow_fill; 261, False; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:result; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:_concat; 268, identifier:_concat_compat; 269, argument_list; 269, 270; 270, tuple; 270, 271; 270, 272; 271, identifier:lvals; 272, identifier:other_diff; 273, else_clause; 273, 274; 274, block; 274, 275; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:result; 278, identifier:lvals; 279, if_statement; 279, 280; 279, 283; 280, comparison_operator:is; 280, 281; 280, 282; 281, identifier:sort; 282, None; 283, block; 283, 284; 284, try_statement; 284, 285; 284, 295; 285, block; 285, 286; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:result; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:sorting; 292, identifier:safe_sort; 293, argument_list; 293, 294; 294, identifier:result; 295, except_clause; 295, 296; 295, 300; 296, as_pattern; 296, 297; 296, 298; 297, identifier:TypeError; 298, as_pattern_target; 298, 299; 299, identifier:e; 300, block; 300, 301; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:warnings; 305, identifier:warn; 306, argument_list; 306, 307; 306, 315; 306, 316; 307, call; 307, 308; 307, 313; 308, attribute; 308, 309; 308, 312; 309, concatenated_string; 309, 310; 309, 311; 310, string:"{}, sort order is undefined for "; 311, string:"incomparable objects"; 312, identifier:format; 313, argument_list; 313, 314; 314, identifier:e; 315, identifier:RuntimeWarning; 316, keyword_argument; 316, 317; 316, 318; 317, identifier:stacklevel; 318, integer:3; 319, return_statement; 319, 320; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:self; 323, identifier:_wrap_setop_result; 324, argument_list; 324, 325; 324, 326; 325, identifier:other; 326, identifier:result | def union(self, other, sort=None):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other = ensure_index(other)
if len(other) == 0 or self.equals(other):
return self._get_reconciled_name_object(other)
if len(self) == 0:
return other._get_reconciled_name_object(self)
if not is_dtype_union_equal(self.dtype, other.dtype):
this = self.astype('O')
other = other.astype('O')
return this.union(other, sort=sort)
if is_period_dtype(self) or is_datetime64tz_dtype(self):
lvals = self._ndarray_values
else:
lvals = self._values
if is_period_dtype(other) or is_datetime64tz_dtype(other):
rvals = other._ndarray_values
else:
rvals = other._values
if sort is None and self.is_monotonic and other.is_monotonic:
try:
result = self._outer_indexer(lvals, rvals)[0]
except TypeError:
result = list(lvals)
value_set = set(lvals)
result.extend([x for x in rvals if x not in value_set])
else:
indexer = self.get_indexer(other)
indexer, = (indexer == -1).nonzero()
if len(indexer) > 0:
other_diff = algos.take_nd(rvals, indexer,
allow_fill=False)
result = _concat._concat_compat((lvals, other_diff))
else:
result = lvals
if sort is None:
try:
result = sorting.safe_sort(result)
except TypeError as e:
warnings.warn("{}, sort order is undefined for "
"incomparable objects".format(e),
RuntimeWarning, stacklevel=3)
return self._wrap_setop_result(other, result) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:difference; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, block; 9, 10; 9, 17; 9, 24; 9, 45; 9, 56; 9, 64; 9, 73; 9, 92; 9, 112; 9, 123; 9, 143; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_validate_sort_keyword; 15, argument_list; 15, 16; 16, identifier:sort; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_assert_can_do_setop; 22, argument_list; 22, 23; 23, identifier:other; 24, if_statement; 24, 25; 24, 31; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:equals; 29, argument_list; 29, 30; 30, identifier:other; 31, block; 31, 32; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_shallow_copy; 37, argument_list; 37, 38; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_data; 42, slice; 42, 43; 42, 44; 43, colon; 44, integer:0; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, pattern_list; 47, 48; 47, 49; 48, identifier:other; 49, identifier:result_name; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_convert_can_do_setop; 54, argument_list; 54, 55; 55, identifier:other; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:this; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_get_unique_index; 63, argument_list; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:indexer; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:this; 70, identifier:get_indexer; 71, argument_list; 71, 72; 72, identifier:other; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:indexer; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:indexer; 79, identifier:take; 80, argument_list; 80, 81; 81, subscript; 81, 82; 81, 91; 82, call; 82, 83; 82, 90; 83, attribute; 83, 84; 83, 89; 84, parenthesized_expression; 84, 85; 85, comparison_operator:!=; 85, 86; 85, 87; 86, identifier:indexer; 87, unary_operator:-; 87, 88; 88, integer:1; 89, identifier:nonzero; 90, argument_list; 91, integer:0; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:label_diff; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:np; 98, identifier:setdiff1d; 99, argument_list; 99, 100; 99, 108; 99, 109; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:np; 103, identifier:arange; 104, argument_list; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:this; 107, identifier:size; 108, identifier:indexer; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:assume_unique; 111, True; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:the_diff; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:this; 119, identifier:values; 120, identifier:take; 121, argument_list; 121, 122; 122, identifier:label_diff; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:sort; 126, None; 127, block; 127, 128; 128, try_statement; 128, 129; 128, 139; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:the_diff; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:sorting; 136, identifier:safe_sort; 137, argument_list; 137, 138; 138, identifier:the_diff; 139, except_clause; 139, 140; 139, 141; 140, identifier:TypeError; 141, block; 141, 142; 142, pass_statement; 143, return_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:this; 147, identifier:_shallow_copy; 148, argument_list; 148, 149; 148, 150; 148, 153; 149, identifier:the_diff; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:name; 152, identifier:result_name; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:freq; 155, None | def difference(self, other, sort=None):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
if self.equals(other):
return self._shallow_copy(self._data[:0])
other, result_name = self._convert_can_do_setop(other)
this = self._get_unique_index()
indexer = this.get_indexer(other)
indexer = indexer.take((indexer != -1).nonzero()[0])
label_diff = np.setdiff1d(np.arange(this.size), indexer,
assume_unique=True)
the_diff = this.values.take(label_diff)
if sort is None:
try:
the_diff = sorting.safe_sort(the_diff)
except TypeError:
pass
return this._shallow_copy(the_diff, name=result_name, freq=None) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:symmetric_difference; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:result_name; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 20; 12, 27; 12, 38; 12, 47; 12, 55; 12, 63; 12, 72; 12, 91; 12, 111; 12, 122; 12, 136; 12, 147; 12, 158; 12, 178; 12, 186; 12, 192; 12, 203; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_validate_sort_keyword; 18, argument_list; 18, 19; 19, identifier:sort; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_assert_can_do_setop; 25, argument_list; 25, 26; 26, identifier:other; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, pattern_list; 29, 30; 29, 31; 30, identifier:other; 31, identifier:result_name_update; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_convert_can_do_setop; 36, argument_list; 36, 37; 37, identifier:other; 38, if_statement; 38, 39; 38, 42; 39, comparison_operator:is; 39, 40; 39, 41; 40, identifier:result_name; 41, None; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:result_name; 46, identifier:result_name_update; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:this; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_get_unique_index; 54, argument_list; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:other; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:other; 61, identifier:_get_unique_index; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:indexer; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:this; 69, identifier:get_indexer; 70, argument_list; 70, 71; 71, identifier:other; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:common_indexer; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:indexer; 78, identifier:take; 79, argument_list; 79, 80; 80, subscript; 80, 81; 80, 90; 81, call; 81, 82; 81, 89; 82, attribute; 82, 83; 82, 88; 83, parenthesized_expression; 83, 84; 84, comparison_operator:!=; 84, 85; 84, 86; 85, identifier:indexer; 86, unary_operator:-; 86, 87; 87, integer:1; 88, identifier:nonzero; 89, argument_list; 90, integer:0; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:left_indexer; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:np; 97, identifier:setdiff1d; 98, argument_list; 98, 99; 98, 107; 98, 108; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:np; 102, identifier:arange; 103, argument_list; 103, 104; 104, attribute; 104, 105; 104, 106; 105, identifier:this; 106, identifier:size; 107, identifier:common_indexer; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:assume_unique; 110, True; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:left_diff; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:this; 118, identifier:values; 119, identifier:take; 120, argument_list; 120, 121; 121, identifier:left_indexer; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:right_indexer; 125, subscript; 125, 126; 125, 135; 126, call; 126, 127; 126, 134; 127, attribute; 127, 128; 127, 133; 128, parenthesized_expression; 128, 129; 129, comparison_operator:==; 129, 130; 129, 131; 130, identifier:indexer; 131, unary_operator:-; 131, 132; 132, integer:1; 133, identifier:nonzero; 134, argument_list; 135, integer:0; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:right_diff; 139, call; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:other; 143, identifier:values; 144, identifier:take; 145, argument_list; 145, 146; 146, identifier:right_indexer; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:the_diff; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:_concat; 153, identifier:_concat_compat; 154, argument_list; 154, 155; 155, list:[left_diff, right_diff]; 155, 156; 155, 157; 156, identifier:left_diff; 157, identifier:right_diff; 158, if_statement; 158, 159; 158, 162; 159, comparison_operator:is; 159, 160; 159, 161; 160, identifier:sort; 161, None; 162, block; 162, 163; 163, try_statement; 163, 164; 163, 174; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:the_diff; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:sorting; 171, identifier:safe_sort; 172, argument_list; 172, 173; 173, identifier:the_diff; 174, except_clause; 174, 175; 174, 176; 175, identifier:TypeError; 176, block; 176, 177; 177, pass_statement; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:attribs; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:_get_attributes_dict; 185, argument_list; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:attribs; 190, string:'name'; 191, identifier:result_name; 192, if_statement; 192, 193; 192, 196; 193, comparison_operator:in; 193, 194; 193, 195; 194, string:'freq'; 195, identifier:attribs; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:attribs; 201, string:'freq'; 202, None; 203, return_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:_shallow_copy_with_infer; 208, argument_list; 208, 209; 208, 210; 209, identifier:the_diff; 210, dictionary_splat; 210, 211; 211, identifier:attribs | def symmetric_difference(self, other, result_name=None, sort=None):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other, result_name_update = self._convert_can_do_setop(other)
if result_name is None:
result_name = result_name_update
this = self._get_unique_index()
other = other._get_unique_index()
indexer = this.get_indexer(other)
common_indexer = indexer.take((indexer != -1).nonzero()[0])
left_indexer = np.setdiff1d(np.arange(this.size), common_indexer,
assume_unique=True)
left_diff = this.values.take(left_indexer)
right_indexer = (indexer == -1).nonzero()[0]
right_diff = other.values.take(right_indexer)
the_diff = _concat._concat_compat([left_diff, right_diff])
if sort is None:
try:
the_diff = sorting.safe_sort(the_diff)
except TypeError:
pass
attribs = self._get_attributes_dict()
attribs['name'] = result_name
if 'freq' in attribs:
attribs['freq'] = None
return self._shallow_copy_with_infer(the_diff, **attribs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:asof; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:label; 6, block; 6, 7; 7, try_statement; 7, 8; 7, 21; 7, 28; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:loc; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:get_loc; 16, argument_list; 16, 17; 16, 18; 17, identifier:label; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:method; 20, string:'pad'; 21, except_clause; 21, 22; 21, 23; 22, identifier:KeyError; 23, block; 23, 24; 24, return_statement; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_na_value; 28, else_clause; 28, 29; 29, block; 29, 30; 29, 52; 30, if_statement; 30, 31; 30, 36; 31, call; 31, 32; 31, 33; 32, identifier:isinstance; 33, argument_list; 33, 34; 33, 35; 34, identifier:loc; 35, identifier:slice; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:loc; 40, subscript; 40, 41; 40, 50; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:loc; 44, identifier:indices; 45, argument_list; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, identifier:self; 50, unary_operator:-; 50, 51; 51, integer:1; 52, return_statement; 52, 53; 53, subscript; 53, 54; 53, 55; 54, identifier:self; 55, identifier:loc | def asof(self, label):
try:
loc = self.get_loc(label, method='pad')
except KeyError:
return self._na_value
else:
if isinstance(loc, slice):
loc = loc.indices(len(self))[-1]
return self[loc] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:return_indexer; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, block; 11, 12; 11, 20; 11, 34; 11, 43; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:_as; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:argsort; 19, argument_list; 20, if_statement; 20, 21; 20, 23; 21, not_operator; 21, 22; 22, identifier:ascending; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:_as; 27, subscript; 27, 28; 27, 29; 28, identifier:_as; 29, slice; 29, 30; 29, 31; 29, 32; 30, colon; 31, colon; 32, unary_operator:-; 32, 33; 33, integer:1; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:sorted_index; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:take; 41, argument_list; 41, 42; 42, identifier:_as; 43, if_statement; 43, 44; 43, 45; 43, 50; 44, identifier:return_indexer; 45, block; 45, 46; 46, return_statement; 46, 47; 47, expression_list; 47, 48; 47, 49; 48, identifier:sorted_index; 49, identifier:_as; 50, else_clause; 50, 51; 51, block; 51, 52; 52, return_statement; 52, 53; 53, identifier:sorted_index | def sort_values(self, return_indexer=False, ascending=True):
_as = self.argsort()
if not ascending:
_as = _as[::-1]
sorted_index = self.take(_as)
if return_indexer:
return sorted_index, _as
else:
return sorted_index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 16; 9, 30; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:result; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:asi8; 16, if_statement; 16, 17; 16, 20; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:result; 19, None; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:result; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:array; 28, argument_list; 28, 29; 29, identifier:self; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:result; 34, identifier:argsort; 35, argument_list; 35, 36; 35, 38; 36, list_splat; 36, 37; 37, identifier:args; 38, dictionary_splat; 38, 39; 39, identifier:kwargs | def argsort(self, *args, **kwargs):
result = self.asi8
if result is None:
result = np.array(self)
return result.argsort(*args, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:slice_indexer; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:end; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:step; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:kind; 16, None; 17, block; 17, 18; 17, 36; 17, 48; 17, 60; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:start_slice; 22, identifier:end_slice; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:slice_locs; 27, argument_list; 27, 28; 27, 29; 27, 30; 27, 33; 28, identifier:start; 29, identifier:end; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:step; 32, identifier:step; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:kind; 35, identifier:kind; 36, if_statement; 36, 37; 36, 42; 37, not_operator; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:is_scalar; 40, argument_list; 40, 41; 41, identifier:start_slice; 42, block; 42, 43; 43, raise_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:AssertionError; 46, argument_list; 46, 47; 47, string:"Start slice bound is non-scalar"; 48, if_statement; 48, 49; 48, 54; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:is_scalar; 52, argument_list; 52, 53; 53, identifier:end_slice; 54, block; 54, 55; 55, raise_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:AssertionError; 58, argument_list; 58, 59; 59, string:"End slice bound is non-scalar"; 60, return_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:slice; 63, argument_list; 63, 64; 63, 65; 63, 66; 64, identifier:start_slice; 65, identifier:end_slice; 66, identifier:step | def slice_indexer(self, start=None, end=None, step=None, kind=None):
start_slice, end_slice = self.slice_locs(start, end, step=step,
kind=kind)
if not is_scalar(start_slice):
raise AssertionError("Start slice bound is non-scalar")
if not is_scalar(end_slice):
raise AssertionError("End slice bound is non-scalar")
return slice(start_slice, end_slice, step) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_set_grouper; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:obj; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, False; 9, block; 9, 10; 9, 28; 9, 43; 9, 201; 9, 255; 9, 261; 9, 267; 10, if_statement; 10, 11; 10, 22; 11, boolean_operator:and; 11, 12; 11, 17; 12, comparison_operator:is; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:key; 16, None; 17, comparison_operator:is; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:level; 21, None; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:ValueError; 26, argument_list; 26, 27; 27, string:"The Grouper cannot specify both a key and a level!"; 28, if_statement; 28, 29; 28, 34; 29, comparison_operator:is; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_grouper; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_grouper; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:grouper; 43, if_statement; 43, 44; 43, 49; 43, 119; 44, comparison_operator:is; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:key; 48, None; 49, block; 49, 50; 49, 56; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:key; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:key; 56, if_statement; 56, 57; 56, 74; 56, 88; 57, parenthesized_expression; 57, 58; 58, boolean_operator:and; 58, 59; 58, 69; 59, comparison_operator:==; 59, 60; 59, 68; 60, call; 60, 61; 60, 62; 61, identifier:getattr; 62, argument_list; 62, 63; 62, 66; 62, 67; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:grouper; 66, string:'name'; 67, None; 68, identifier:key; 69, call; 69, 70; 69, 71; 70, identifier:isinstance; 71, argument_list; 71, 72; 71, 73; 72, identifier:obj; 73, identifier:ABCSeries; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:ax; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_grouper; 83, identifier:take; 84, argument_list; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:obj; 87, identifier:index; 88, else_clause; 88, 89; 89, block; 89, 90; 89, 107; 90, if_statement; 90, 91; 90, 96; 91, comparison_operator:not; 91, 92; 91, 93; 92, identifier:key; 93, attribute; 93, 94; 93, 95; 94, identifier:obj; 95, identifier:_info_axis; 96, block; 96, 97; 97, raise_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:KeyError; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, string:"The grouper name {0} is not found"; 104, identifier:format; 105, argument_list; 105, 106; 106, identifier:key; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:ax; 110, call; 110, 111; 110, 112; 111, identifier:Index; 112, argument_list; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:obj; 115, identifier:key; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:name; 118, identifier:key; 119, else_clause; 119, 120; 120, block; 120, 121; 120, 132; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:ax; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:obj; 127, identifier:_get_axis; 128, argument_list; 128, 129; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:axis; 132, if_statement; 132, 133; 132, 138; 133, comparison_operator:is; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:level; 137, None; 138, block; 138, 139; 138, 145; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:level; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:level; 145, if_statement; 145, 146; 145, 151; 145, 180; 146, call; 146, 147; 146, 148; 147, identifier:isinstance; 148, argument_list; 148, 149; 148, 150; 149, identifier:ax; 150, identifier:MultiIndex; 151, block; 151, 152; 151, 161; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:level; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:ax; 158, identifier:_get_level_number; 159, argument_list; 159, 160; 160, identifier:level; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:ax; 164, call; 164, 165; 164, 166; 165, identifier:Index; 166, argument_list; 166, 167; 166, 173; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:ax; 170, identifier:_get_level_values; 171, argument_list; 171, 172; 172, identifier:level; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:name; 175, subscript; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:ax; 178, identifier:names; 179, identifier:level; 180, else_clause; 180, 181; 181, block; 181, 182; 182, if_statement; 182, 183; 182, 190; 183, comparison_operator:not; 183, 184; 183, 185; 184, identifier:level; 185, tuple; 185, 186; 185, 187; 186, integer:0; 187, attribute; 187, 188; 187, 189; 188, identifier:ax; 189, identifier:name; 190, block; 190, 191; 191, raise_statement; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:ValueError; 194, argument_list; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, string:"The level {0} is not valid"; 198, identifier:format; 199, argument_list; 199, 200; 200, identifier:level; 201, if_statement; 201, 202; 201, 213; 202, boolean_operator:and; 202, 203; 202, 209; 203, parenthesized_expression; 203, 204; 204, boolean_operator:or; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:sort; 208, identifier:sort; 209, not_operator; 209, 210; 210, attribute; 210, 211; 210, 212; 211, identifier:ax; 212, identifier:is_monotonic; 213, block; 213, 214; 213, 229; 213, 238; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:indexer; 217, assignment; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:indexer; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:ax; 224, identifier:argsort; 225, argument_list; 225, 226; 226, keyword_argument; 226, 227; 226, 228; 227, identifier:kind; 228, string:'mergesort'; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:ax; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:ax; 235, identifier:take; 236, argument_list; 236, 237; 237, identifier:indexer; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:obj; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:obj; 244, identifier:_take; 245, argument_list; 245, 246; 245, 247; 245, 252; 246, identifier:indexer; 247, keyword_argument; 247, 248; 247, 249; 248, identifier:axis; 249, attribute; 249, 250; 249, 251; 250, identifier:self; 251, identifier:axis; 252, keyword_argument; 252, 253; 252, 254; 253, identifier:is_copy; 254, False; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:obj; 260, identifier:obj; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:self; 265, identifier:grouper; 266, identifier:ax; 267, return_statement; 267, 268; 268, attribute; 268, 269; 268, 270; 269, identifier:self; 270, identifier:grouper | def _set_grouper(self, obj, sort=False):
if self.key is not None and self.level is not None:
raise ValueError(
"The Grouper cannot specify both a key and a level!")
if self._grouper is None:
self._grouper = self.grouper
if self.key is not None:
key = self.key
if (getattr(self.grouper, 'name', None) == key and
isinstance(obj, ABCSeries)):
ax = self._grouper.take(obj.index)
else:
if key not in obj._info_axis:
raise KeyError(
"The grouper name {0} is not found".format(key))
ax = Index(obj[key], name=key)
else:
ax = obj._get_axis(self.axis)
if self.level is not None:
level = self.level
if isinstance(ax, MultiIndex):
level = ax._get_level_number(level)
ax = Index(ax._get_level_values(level),
name=ax.names[level])
else:
if level not in (0, ax.name):
raise ValueError(
"The level {0} is not valid".format(level))
if (self.sort or sort) and not ax.is_monotonic:
indexer = self.indexer = ax.argsort(kind='mergesort')
ax = ax.take(indexer)
obj = obj._take(indexer, axis=self.axis, is_copy=False)
self.obj = obj
self.grouper = ax
return self.grouper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:_from_derivatives; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:xi; 5, identifier:yi; 6, identifier:x; 7, default_parameter; 7, 8; 7, 9; 8, identifier:order; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:der; 12, integer:0; 13, default_parameter; 13, 14; 13, 15; 14, identifier:extrapolate; 15, False; 16, block; 16, 17; 16, 22; 16, 30; 16, 51; 17, import_from_statement; 17, 18; 17, 20; 18, dotted_name; 18, 19; 19, identifier:scipy; 20, dotted_name; 20, 21; 21, identifier:interpolate; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:method; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:interpolate; 28, identifier:BPoly; 29, identifier:from_derivatives; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:m; 33, call; 33, 34; 33, 35; 34, identifier:method; 35, argument_list; 35, 36; 35, 37; 35, 45; 35, 48; 36, identifier:xi; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:yi; 40, identifier:reshape; 41, argument_list; 41, 42; 41, 44; 42, unary_operator:-; 42, 43; 43, integer:1; 44, integer:1; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:orders; 47, identifier:order; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:extrapolate; 50, identifier:extrapolate; 51, return_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:m; 54, argument_list; 54, 55; 55, identifier:x | def _from_derivatives(xi, yi, x, order=None, der=0, extrapolate=False):
from scipy import interpolate
method = interpolate.BPoly.from_derivatives
m = method(xi, yi.reshape(-1, 1),
orders=order, extrapolate=extrapolate)
return m(x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:recode_for_groupby; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:c; 5, identifier:sort; 6, identifier:observed; 7, block; 7, 8; 7, 92; 7, 99; 7, 107; 7, 130; 8, if_statement; 8, 9; 8, 10; 9, identifier:observed; 10, block; 10, 11; 10, 20; 10, 29; 10, 43; 10, 54; 10, 67; 10, 79; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:unique_codes; 14, call; 14, 15; 14, 16; 15, identifier:unique1d; 16, argument_list; 16, 17; 17, attribute; 17, 18; 17, 19; 18, identifier:c; 19, identifier:codes; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:take_codes; 23, subscript; 23, 24; 23, 25; 24, identifier:unique_codes; 25, comparison_operator:!=; 25, 26; 25, 27; 26, identifier:unique_codes; 27, unary_operator:-; 27, 28; 28, integer:1; 29, if_statement; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:c; 32, identifier:ordered; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:take_codes; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:sort; 41, argument_list; 41, 42; 42, identifier:take_codes; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:categories; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:c; 50, identifier:categories; 51, identifier:take; 52, argument_list; 52, 53; 53, identifier:take_codes; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:codes; 57, call; 57, 58; 57, 59; 58, identifier:_recode_for_categories; 59, argument_list; 59, 60; 59, 63; 59, 66; 60, attribute; 60, 61; 60, 62; 61, identifier:c; 62, identifier:codes; 63, attribute; 63, 64; 63, 65; 64, identifier:c; 65, identifier:categories; 66, identifier:categories; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:dtype; 70, call; 70, 71; 70, 72; 71, identifier:CategoricalDtype; 72, argument_list; 72, 73; 72, 74; 73, identifier:categories; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:ordered; 76, attribute; 76, 77; 76, 78; 77, identifier:c; 78, identifier:ordered; 79, return_statement; 79, 80; 80, expression_list; 80, 81; 80, 91; 81, call; 81, 82; 81, 83; 82, identifier:Categorical; 83, argument_list; 83, 84; 83, 85; 83, 88; 84, identifier:codes; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:dtype; 87, identifier:dtype; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:fastpath; 90, True; 91, identifier:c; 92, if_statement; 92, 93; 92, 94; 93, identifier:sort; 94, block; 94, 95; 95, return_statement; 95, 96; 96, expression_list; 96, 97; 96, 98; 97, identifier:c; 98, None; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:cat; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:c; 105, identifier:unique; 106, argument_list; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:cat; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:cat; 113, identifier:add_categories; 114, argument_list; 114, 115; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:c; 118, identifier:categories; 119, unary_operator:~; 119, 120; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:c; 124, identifier:categories; 125, identifier:isin; 126, argument_list; 126, 127; 127, attribute; 127, 128; 127, 129; 128, identifier:cat; 129, identifier:categories; 130, return_statement; 130, 131; 131, expression_list; 131, 132; 131, 140; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:c; 135, identifier:reorder_categories; 136, argument_list; 136, 137; 137, attribute; 137, 138; 137, 139; 138, identifier:cat; 139, identifier:categories; 140, None | def recode_for_groupby(c, sort, observed):
if observed:
unique_codes = unique1d(c.codes)
take_codes = unique_codes[unique_codes != -1]
if c.ordered:
take_codes = np.sort(take_codes)
categories = c.categories.take(take_codes)
codes = _recode_for_categories(c.codes,
c.categories,
categories)
dtype = CategoricalDtype(categories, ordered=c.ordered)
return Categorical(codes, dtype=dtype, fastpath=True), c
if sort:
return c, None
cat = c.unique()
cat = cat.add_categories(
c.categories[~c.categories.isin(cat.categories)])
return c.reorder_categories(cat.categories), None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:generate_bins_generic; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:values; 5, identifier:binner; 6, identifier:closed; 7, block; 7, 8; 7, 15; 7, 22; 7, 36; 7, 50; 7, 68; 7, 84; 7, 88; 7, 92; 7, 147; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:lenidx; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:values; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:lenbin; 18, call; 18, 19; 18, 20; 19, identifier:len; 20, argument_list; 20, 21; 21, identifier:binner; 22, if_statement; 22, 23; 22, 30; 23, boolean_operator:or; 23, 24; 23, 27; 24, comparison_operator:<=; 24, 25; 24, 26; 25, identifier:lenidx; 26, integer:0; 27, comparison_operator:<=; 27, 28; 27, 29; 28, identifier:lenbin; 29, integer:0; 30, block; 30, 31; 31, raise_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:ValueError; 34, argument_list; 34, 35; 35, string:"Invalid length for values or for binner"; 36, if_statement; 36, 37; 36, 44; 37, comparison_operator:<; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:values; 40, integer:0; 41, subscript; 41, 42; 41, 43; 42, identifier:binner; 43, integer:0; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:ValueError; 48, argument_list; 48, 49; 49, string:"Values falls before first bin"; 50, if_statement; 50, 51; 50, 62; 51, comparison_operator:>; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 54; 53, identifier:values; 54, binary_operator:-; 54, 55; 54, 56; 55, identifier:lenidx; 56, integer:1; 57, subscript; 57, 58; 57, 59; 58, identifier:binner; 59, binary_operator:-; 59, 60; 59, 61; 60, identifier:lenbin; 61, integer:1; 62, block; 62, 63; 63, raise_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:ValueError; 66, argument_list; 66, 67; 67, string:"Values falls after last bin"; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:bins; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:np; 74, identifier:empty; 75, argument_list; 75, 76; 75, 79; 76, binary_operator:-; 76, 77; 76, 78; 77, identifier:lenbin; 78, integer:1; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:dtype; 81, attribute; 81, 82; 81, 83; 82, identifier:np; 83, identifier:int64; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:j; 87, integer:0; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:bc; 91, integer:0; 92, for_statement; 92, 93; 92, 94; 92, 101; 93, identifier:i; 94, call; 94, 95; 94, 96; 95, identifier:range; 96, argument_list; 96, 97; 96, 98; 97, integer:0; 98, binary_operator:-; 98, 99; 98, 100; 99, identifier:lenbin; 100, integer:1; 101, block; 101, 102; 101, 110; 101, 137; 101, 143; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:r_bin; 105, subscript; 105, 106; 105, 107; 106, identifier:binner; 107, binary_operator:+; 107, 108; 107, 109; 108, identifier:i; 109, integer:1; 110, while_statement; 110, 111; 110, 132; 111, boolean_operator:and; 111, 112; 111, 115; 112, comparison_operator:<; 112, 113; 112, 114; 113, identifier:j; 114, identifier:lenidx; 115, parenthesized_expression; 115, 116; 116, boolean_operator:or; 116, 117; 116, 122; 117, comparison_operator:<; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:values; 120, identifier:j; 121, identifier:r_bin; 122, parenthesized_expression; 122, 123; 123, boolean_operator:and; 123, 124; 123, 127; 124, comparison_operator:==; 124, 125; 124, 126; 125, identifier:closed; 126, string:'right'; 127, comparison_operator:==; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:values; 130, identifier:j; 131, identifier:r_bin; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, augmented_assignment:+=; 134, 135; 134, 136; 135, identifier:j; 136, integer:1; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:bins; 141, identifier:bc; 142, identifier:j; 143, expression_statement; 143, 144; 144, augmented_assignment:+=; 144, 145; 144, 146; 145, identifier:bc; 146, integer:1; 147, return_statement; 147, 148; 148, identifier:bins | def generate_bins_generic(values, binner, closed):
lenidx = len(values)
lenbin = len(binner)
if lenidx <= 0 or lenbin <= 0:
raise ValueError("Invalid length for values or for binner")
if values[0] < binner[0]:
raise ValueError("Values falls before first bin")
if values[lenidx - 1] > binner[lenbin - 1]:
raise ValueError("Values falls after last bin")
bins = np.empty(lenbin - 1, dtype=np.int64)
j = 0
bc = 0
for i in range(0, lenbin - 1):
r_bin = binner[i + 1]
while j < lenidx and (values[j] < r_bin or
(closed == 'right' and values[j] == r_bin)):
j += 1
bins[bc] = j
bc += 1
return bins |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:wide_to_long; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 4, identifier:df; 5, identifier:stubnames; 6, identifier:i; 7, identifier:j; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sep; 10, string:""; 11, default_parameter; 11, 12; 11, 13; 12, identifier:suffix; 13, string:r'\d+'; 14, block; 14, 15; 14, 17; 14, 76; 14, 168; 14, 189; 14, 207; 14, 228; 14, 246; 14, 260; 14, 271; 14, 292; 14, 314; 14, 332; 14, 358; 14, 384; 15, expression_statement; 15, 16; 16, identifier:r; 17, function_definition; 17, 18; 17, 19; 17, 24; 18, function_name:get_var_names; 19, parameters; 19, 20; 19, 21; 19, 22; 19, 23; 20, identifier:df; 21, identifier:stub; 22, identifier:sep; 23, identifier:suffix; 24, block; 24, 25; 24, 52; 24, 61; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:regex; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, string:r'^{stub}{sep}{suffix}$'; 31, identifier:format; 32, argument_list; 32, 33; 32, 41; 32, 49; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:stub; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:re; 38, identifier:escape; 39, argument_list; 39, 40; 40, identifier:stub; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:sep; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:re; 46, identifier:escape; 47, argument_list; 47, 48; 48, identifier:sep; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:suffix; 51, identifier:suffix; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:pattern; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:re; 58, identifier:compile; 59, argument_list; 59, 60; 60, identifier:regex; 61, return_statement; 61, 62; 62, list_comprehension; 62, 63; 62, 64; 62, 69; 63, identifier:col; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:col; 66, attribute; 66, 67; 66, 68; 67, identifier:df; 68, identifier:columns; 69, if_clause; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:pattern; 73, identifier:match; 74, argument_list; 74, 75; 75, identifier:col; 76, function_definition; 76, 77; 76, 78; 76, 85; 77, function_name:melt_stub; 78, parameters; 78, 79; 78, 80; 78, 81; 78, 82; 78, 83; 78, 84; 79, identifier:df; 80, identifier:stub; 81, identifier:i; 82, identifier:j; 83, identifier:value_vars; 84, identifier:sep; 85, block; 85, 86; 85, 110; 85, 121; 85, 144; 85, 158; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:newdf; 89, call; 89, 90; 89, 91; 90, identifier:melt; 91, argument_list; 91, 92; 91, 93; 91, 96; 91, 99; 91, 107; 92, identifier:df; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:id_vars; 95, identifier:i; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:value_vars; 98, identifier:value_vars; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:value_name; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:stub; 104, identifier:rstrip; 105, argument_list; 105, 106; 106, identifier:sep; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:var_name; 109, identifier:j; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:newdf; 114, identifier:j; 115, call; 115, 116; 115, 117; 116, identifier:Categorical; 117, argument_list; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:newdf; 120, identifier:j; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:newdf; 125, identifier:j; 126, call; 126, 127; 126, 134; 127, attribute; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:newdf; 131, identifier:j; 132, identifier:str; 133, identifier:replace; 134, argument_list; 134, 135; 134, 143; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:re; 138, identifier:escape; 139, argument_list; 139, 140; 140, binary_operator:+; 140, 141; 140, 142; 141, identifier:stub; 142, identifier:sep; 143, string:""; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:newdf; 148, identifier:j; 149, call; 149, 150; 149, 151; 150, identifier:to_numeric; 151, argument_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:newdf; 154, identifier:j; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:errors; 157, string:'ignore'; 158, return_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:newdf; 162, identifier:set_index; 163, argument_list; 163, 164; 164, binary_operator:+; 164, 165; 164, 166; 165, identifier:i; 166, list:[j]; 166, 167; 167, identifier:j; 168, if_statement; 168, 169; 168, 174; 168, 180; 169, not_operator; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:is_list_like; 172, argument_list; 172, 173; 173, identifier:stubnames; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:stubnames; 178, list:[stubnames]; 178, 179; 179, identifier:stubnames; 180, else_clause; 180, 181; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:stubnames; 185, call; 185, 186; 185, 187; 186, identifier:list; 187, argument_list; 187, 188; 188, identifier:stubnames; 189, if_statement; 189, 190; 189, 201; 190, call; 190, 191; 190, 192; 191, identifier:any; 192, generator_expression; 192, 193; 192, 196; 193, comparison_operator:in; 193, 194; 193, 195; 194, identifier:col; 195, identifier:stubnames; 196, for_in_clause; 196, 197; 196, 198; 197, identifier:col; 198, attribute; 198, 199; 198, 200; 199, identifier:df; 200, identifier:columns; 201, block; 201, 202; 202, raise_statement; 202, 203; 203, call; 203, 204; 203, 205; 204, identifier:ValueError; 205, argument_list; 205, 206; 206, string:"stubname can't be identical to a column name"; 207, if_statement; 207, 208; 207, 213; 207, 219; 208, not_operator; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:is_list_like; 211, argument_list; 211, 212; 212, identifier:i; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:i; 217, list:[i]; 217, 218; 218, identifier:i; 219, else_clause; 219, 220; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:i; 224, call; 224, 225; 224, 226; 225, identifier:list; 226, argument_list; 226, 227; 227, identifier:i; 228, if_statement; 228, 229; 228, 240; 229, call; 229, 230; 229, 239; 230, attribute; 230, 231; 230, 238; 231, call; 231, 232; 231, 237; 232, attribute; 232, 233; 232, 236; 233, subscript; 233, 234; 233, 235; 234, identifier:df; 235, identifier:i; 236, identifier:duplicated; 237, argument_list; 238, identifier:any; 239, argument_list; 240, block; 240, 241; 241, raise_statement; 241, 242; 242, call; 242, 243; 242, 244; 243, identifier:ValueError; 244, argument_list; 244, 245; 245, string:"the id variables need to uniquely identify each row"; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:value_vars; 249, list_comprehension; 249, 250; 249, 257; 250, call; 250, 251; 250, 252; 251, identifier:get_var_names; 252, argument_list; 252, 253; 252, 254; 252, 255; 252, 256; 253, identifier:df; 254, identifier:stub; 255, identifier:sep; 256, identifier:suffix; 257, for_in_clause; 257, 258; 257, 259; 258, identifier:stub; 259, identifier:stubnames; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:value_vars_flattened; 263, list_comprehension; 263, 264; 263, 265; 263, 268; 264, identifier:e; 265, for_in_clause; 265, 266; 265, 267; 266, identifier:sublist; 267, identifier:value_vars; 268, for_in_clause; 268, 269; 268, 270; 269, identifier:e; 270, identifier:sublist; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:id_vars; 274, call; 274, 275; 274, 276; 275, identifier:list; 276, argument_list; 276, 277; 277, call; 277, 278; 277, 290; 278, attribute; 278, 279; 278, 289; 279, call; 279, 280; 279, 281; 280, identifier:set; 281, argument_list; 281, 282; 282, call; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:df; 286, identifier:columns; 287, identifier:tolist; 288, argument_list; 289, identifier:difference; 290, argument_list; 290, 291; 291, identifier:value_vars_flattened; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:melted; 295, list_comprehension; 295, 296; 295, 305; 296, call; 296, 297; 296, 298; 297, identifier:melt_stub; 298, argument_list; 298, 299; 298, 300; 298, 301; 298, 302; 298, 303; 298, 304; 299, identifier:df; 300, identifier:s; 301, identifier:i; 302, identifier:j; 303, identifier:v; 304, identifier:sep; 305, for_in_clause; 305, 306; 305, 309; 306, pattern_list; 306, 307; 306, 308; 307, identifier:s; 308, identifier:v; 309, call; 309, 310; 309, 311; 310, identifier:zip; 311, argument_list; 311, 312; 311, 313; 312, identifier:stubnames; 313, identifier:value_vars; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:melted; 317, call; 317, 318; 317, 323; 318, attribute; 318, 319; 318, 322; 319, subscript; 319, 320; 319, 321; 320, identifier:melted; 321, integer:0; 322, identifier:join; 323, argument_list; 323, 324; 323, 329; 324, subscript; 324, 325; 324, 326; 325, identifier:melted; 326, slice; 326, 327; 326, 328; 327, integer:1; 328, colon; 329, keyword_argument; 329, 330; 329, 331; 330, identifier:how; 331, string:'outer'; 332, if_statement; 332, 333; 332, 339; 333, comparison_operator:==; 333, 334; 333, 338; 334, call; 334, 335; 334, 336; 335, identifier:len; 336, argument_list; 336, 337; 337, identifier:i; 338, integer:1; 339, block; 339, 340; 339, 356; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:new; 343, call; 343, 344; 343, 354; 344, attribute; 344, 345; 344, 353; 345, call; 345, 346; 345, 351; 346, attribute; 346, 347; 346, 350; 347, subscript; 347, 348; 347, 349; 348, identifier:df; 349, identifier:id_vars; 350, identifier:set_index; 351, argument_list; 351, 352; 352, identifier:i; 353, identifier:join; 354, argument_list; 354, 355; 355, identifier:melted; 356, return_statement; 356, 357; 357, identifier:new; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:new; 361, call; 361, 362; 361, 379; 362, attribute; 362, 363; 362, 378; 363, call; 363, 364; 363, 369; 364, attribute; 364, 365; 364, 368; 365, subscript; 365, 366; 365, 367; 366, identifier:df; 367, identifier:id_vars; 368, identifier:merge; 369, argument_list; 369, 370; 369, 375; 370, call; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:melted; 373, identifier:reset_index; 374, argument_list; 375, keyword_argument; 375, 376; 375, 377; 376, identifier:on; 377, identifier:i; 378, identifier:set_index; 379, argument_list; 379, 380; 380, binary_operator:+; 380, 381; 380, 382; 381, identifier:i; 382, list:[j]; 382, 383; 383, identifier:j; 384, return_statement; 384, 385; 385, identifier:new | def wide_to_long(df, stubnames, i, j, sep="", suffix=r'\d+'):
r
def get_var_names(df, stub, sep, suffix):
regex = r'^{stub}{sep}{suffix}$'.format(
stub=re.escape(stub), sep=re.escape(sep), suffix=suffix)
pattern = re.compile(regex)
return [col for col in df.columns if pattern.match(col)]
def melt_stub(df, stub, i, j, value_vars, sep):
newdf = melt(df, id_vars=i, value_vars=value_vars,
value_name=stub.rstrip(sep), var_name=j)
newdf[j] = Categorical(newdf[j])
newdf[j] = newdf[j].str.replace(re.escape(stub + sep), "")
newdf[j] = to_numeric(newdf[j], errors='ignore')
return newdf.set_index(i + [j])
if not is_list_like(stubnames):
stubnames = [stubnames]
else:
stubnames = list(stubnames)
if any(col in stubnames for col in df.columns):
raise ValueError("stubname can't be identical to a column name")
if not is_list_like(i):
i = [i]
else:
i = list(i)
if df[i].duplicated().any():
raise ValueError("the id variables need to uniquely identify each row")
value_vars = [get_var_names(df, stub, sep, suffix) for stub in stubnames]
value_vars_flattened = [e for sublist in value_vars for e in sublist]
id_vars = list(set(df.columns.tolist()).difference(value_vars_flattened))
melted = [melt_stub(df, s, i, j, v, sep)
for s, v in zip(stubnames, value_vars)]
melted = melted[0].join(melted[1:], how='outer')
if len(i) == 1:
new = df[id_vars].set_index(i).join(melted)
return new
new = df[id_vars].merge(melted.reset_index(), on=i).set_index(i + [j])
return new |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 18; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:nv; 14, identifier:validate_argsort; 15, argument_list; 15, 16; 15, 17; 16, identifier:args; 17, identifier:kwargs; 18, if_statement; 18, 19; 18, 24; 18, 35; 19, comparison_operator:>; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_step; 23, integer:0; 24, block; 24, 25; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:arange; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:self; 35, else_clause; 35, 36; 36, block; 36, 37; 37, return_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:np; 41, identifier:arange; 42, argument_list; 42, 43; 42, 49; 42, 51; 43, binary_operator:-; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:self; 48, integer:1; 49, unary_operator:-; 49, 50; 50, integer:1; 51, unary_operator:-; 51, 52; 52, integer:1 | def argsort(self, *args, **kwargs):
nv.validate_argsort(args, kwargs)
if self._step > 0:
return np.arange(len(self))
else:
return np.arange(len(self) - 1, -1, -1) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, block; 9, 10; 9, 17; 9, 51; 9, 395; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_assert_can_do_setop; 15, argument_list; 15, 16; 16, identifier:other; 17, if_statement; 17, 18; 17, 38; 18, boolean_operator:or; 18, 19; 18, 32; 19, boolean_operator:or; 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:other; 25, integer:0; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:equals; 30, argument_list; 30, 31; 31, identifier:other; 32, comparison_operator:==; 32, 33; 32, 37; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:self; 37, integer:0; 38, block; 38, 39; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, call; 42, 43; 42, 44; 43, identifier:super; 44, argument_list; 45, identifier:union; 46, argument_list; 46, 47; 46, 48; 47, identifier:other; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:sort; 50, identifier:sort; 51, if_statement; 51, 52; 51, 61; 52, boolean_operator:and; 52, 53; 52, 58; 53, call; 53, 54; 53, 55; 54, identifier:isinstance; 55, argument_list; 55, 56; 55, 57; 56, identifier:other; 57, identifier:RangeIndex; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:sort; 60, None; 61, block; 61, 62; 61, 74; 61, 92; 61, 104; 61, 122; 61, 140; 61, 158; 61, 212; 61, 220; 61, 228; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, pattern_list; 64, 65; 64, 66; 65, identifier:start_s; 66, identifier:step_s; 67, expression_list; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_start; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_step; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:end_s; 77, binary_operator:+; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_start; 81, binary_operator:*; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_step; 85, parenthesized_expression; 85, 86; 86, binary_operator:-; 86, 87; 86, 91; 87, call; 87, 88; 87, 89; 88, identifier:len; 89, argument_list; 89, 90; 90, identifier:self; 91, integer:1; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, pattern_list; 94, 95; 94, 96; 95, identifier:start_o; 96, identifier:step_o; 97, expression_list; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:other; 100, identifier:_start; 101, attribute; 101, 102; 101, 103; 102, identifier:other; 103, identifier:_step; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:end_o; 107, binary_operator:+; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:other; 110, identifier:_start; 111, binary_operator:*; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:other; 114, identifier:_step; 115, parenthesized_expression; 115, 116; 116, binary_operator:-; 116, 117; 116, 121; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, identifier:other; 121, integer:1; 122, if_statement; 122, 123; 122, 128; 123, comparison_operator:<; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_step; 127, integer:0; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 135; 131, pattern_list; 131, 132; 131, 133; 131, 134; 132, identifier:start_s; 133, identifier:step_s; 134, identifier:end_s; 135, expression_list; 135, 136; 135, 137; 135, 139; 136, identifier:end_s; 137, unary_operator:-; 137, 138; 138, identifier:step_s; 139, identifier:start_s; 140, if_statement; 140, 141; 140, 146; 141, comparison_operator:<; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:other; 144, identifier:_step; 145, integer:0; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 153; 149, pattern_list; 149, 150; 149, 151; 149, 152; 150, identifier:start_o; 151, identifier:step_o; 152, identifier:end_o; 153, expression_list; 153, 154; 153, 155; 153, 157; 154, identifier:end_o; 155, unary_operator:-; 155, 156; 156, identifier:step_o; 157, identifier:start_o; 158, if_statement; 158, 159; 158, 172; 158, 188; 158, 200; 159, boolean_operator:and; 159, 160; 159, 166; 160, comparison_operator:==; 160, 161; 160, 165; 161, call; 161, 162; 161, 163; 162, identifier:len; 163, argument_list; 163, 164; 164, identifier:self; 165, integer:1; 166, comparison_operator:==; 166, 167; 166, 171; 167, call; 167, 168; 167, 169; 168, identifier:len; 169, argument_list; 169, 170; 170, identifier:other; 171, integer:1; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:step_s; 176, assignment; 176, 177; 176, 178; 177, identifier:step_o; 178, call; 178, 179; 178, 180; 179, identifier:abs; 180, argument_list; 180, 181; 181, binary_operator:-; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:_start; 185, attribute; 185, 186; 185, 187; 186, identifier:other; 187, identifier:_start; 188, elif_clause; 188, 189; 188, 195; 189, comparison_operator:==; 189, 190; 189, 194; 190, call; 190, 191; 190, 192; 191, identifier:len; 192, argument_list; 192, 193; 193, identifier:self; 194, integer:1; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:step_s; 199, identifier:step_o; 200, elif_clause; 200, 201; 200, 207; 201, comparison_operator:==; 201, 202; 201, 206; 202, call; 202, 203; 202, 204; 203, identifier:len; 204, argument_list; 204, 205; 205, identifier:other; 206, integer:1; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:step_o; 211, identifier:step_s; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:start_r; 215, call; 215, 216; 215, 217; 216, identifier:min; 217, argument_list; 217, 218; 217, 219; 218, identifier:start_s; 219, identifier:start_o; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:end_r; 223, call; 223, 224; 223, 225; 224, identifier:max; 225, argument_list; 225, 226; 225, 227; 226, identifier:end_s; 227, identifier:end_o; 228, if_statement; 228, 229; 228, 232; 228, 313; 228, 354; 229, comparison_operator:==; 229, 230; 229, 231; 230, identifier:step_o; 231, identifier:step_s; 232, block; 232, 233; 232, 267; 233, if_statement; 233, 234; 233, 257; 234, parenthesized_expression; 234, 235; 235, boolean_operator:and; 235, 236; 235, 251; 236, boolean_operator:and; 236, 237; 236, 245; 237, comparison_operator:==; 237, 238; 237, 244; 238, binary_operator:%; 238, 239; 238, 243; 239, parenthesized_expression; 239, 240; 240, binary_operator:-; 240, 241; 240, 242; 241, identifier:start_s; 242, identifier:start_o; 243, identifier:step_s; 244, integer:0; 245, comparison_operator:<=; 245, 246; 245, 250; 246, parenthesized_expression; 246, 247; 247, binary_operator:-; 247, 248; 247, 249; 248, identifier:start_s; 249, identifier:end_o; 250, identifier:step_s; 251, comparison_operator:<=; 251, 252; 251, 256; 252, parenthesized_expression; 252, 253; 253, binary_operator:-; 253, 254; 253, 255; 254, identifier:start_o; 255, identifier:end_s; 256, identifier:step_s; 257, block; 257, 258; 258, return_statement; 258, 259; 259, call; 259, 260; 259, 261; 260, identifier:RangeIndex; 261, argument_list; 261, 262; 261, 263; 261, 266; 262, identifier:start_r; 263, binary_operator:+; 263, 264; 263, 265; 264, identifier:end_r; 265, identifier:step_s; 266, identifier:step_s; 267, if_statement; 267, 268; 267, 299; 268, parenthesized_expression; 268, 269; 269, boolean_operator:and; 269, 270; 269, 288; 270, boolean_operator:and; 270, 271; 270, 277; 271, parenthesized_expression; 271, 272; 272, comparison_operator:==; 272, 273; 272, 276; 273, binary_operator:%; 273, 274; 273, 275; 274, identifier:step_s; 275, integer:2; 276, integer:0; 277, parenthesized_expression; 277, 278; 278, comparison_operator:<=; 278, 279; 278, 285; 279, call; 279, 280; 279, 281; 280, identifier:abs; 281, argument_list; 281, 282; 282, binary_operator:-; 282, 283; 282, 284; 283, identifier:start_s; 284, identifier:start_o; 285, binary_operator:/; 285, 286; 285, 287; 286, identifier:step_s; 287, integer:2; 288, parenthesized_expression; 288, 289; 289, comparison_operator:<=; 289, 290; 289, 296; 290, call; 290, 291; 290, 292; 291, identifier:abs; 292, argument_list; 292, 293; 293, binary_operator:-; 293, 294; 293, 295; 294, identifier:end_s; 295, identifier:end_o; 296, binary_operator:/; 296, 297; 296, 298; 297, identifier:step_s; 298, integer:2; 299, block; 299, 300; 300, return_statement; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:RangeIndex; 303, argument_list; 303, 304; 303, 305; 303, 310; 304, identifier:start_r; 305, binary_operator:+; 305, 306; 305, 307; 306, identifier:end_r; 307, binary_operator:/; 307, 308; 307, 309; 308, identifier:step_s; 309, integer:2; 310, binary_operator:/; 310, 311; 310, 312; 311, identifier:step_s; 312, integer:2; 313, elif_clause; 313, 314; 313, 319; 314, comparison_operator:==; 314, 315; 314, 318; 315, binary_operator:%; 315, 316; 315, 317; 316, identifier:step_o; 317, identifier:step_s; 318, integer:0; 319, block; 319, 320; 320, if_statement; 320, 321; 320, 344; 321, parenthesized_expression; 321, 322; 322, boolean_operator:and; 322, 323; 322, 338; 323, boolean_operator:and; 323, 324; 323, 332; 324, comparison_operator:==; 324, 325; 324, 331; 325, binary_operator:%; 325, 326; 325, 330; 326, parenthesized_expression; 326, 327; 327, binary_operator:-; 327, 328; 327, 329; 328, identifier:start_o; 329, identifier:start_s; 330, identifier:step_s; 331, integer:0; 332, parenthesized_expression; 332, 333; 333, comparison_operator:>=; 333, 334; 333, 337; 334, binary_operator:+; 334, 335; 334, 336; 335, identifier:start_o; 336, identifier:step_s; 337, identifier:start_s; 338, parenthesized_expression; 338, 339; 339, comparison_operator:<=; 339, 340; 339, 343; 340, binary_operator:-; 340, 341; 340, 342; 341, identifier:end_o; 342, identifier:step_s; 343, identifier:end_s; 344, block; 344, 345; 345, return_statement; 345, 346; 346, call; 346, 347; 346, 348; 347, identifier:RangeIndex; 348, argument_list; 348, 349; 348, 350; 348, 353; 349, identifier:start_r; 350, binary_operator:+; 350, 351; 350, 352; 351, identifier:end_r; 352, identifier:step_s; 353, identifier:step_s; 354, elif_clause; 354, 355; 354, 360; 355, comparison_operator:==; 355, 356; 355, 359; 356, binary_operator:%; 356, 357; 356, 358; 357, identifier:step_s; 358, identifier:step_o; 359, integer:0; 360, block; 360, 361; 361, if_statement; 361, 362; 361, 385; 362, parenthesized_expression; 362, 363; 363, boolean_operator:and; 363, 364; 363, 379; 364, boolean_operator:and; 364, 365; 364, 373; 365, comparison_operator:==; 365, 366; 365, 372; 366, binary_operator:%; 366, 367; 366, 371; 367, parenthesized_expression; 367, 368; 368, binary_operator:-; 368, 369; 368, 370; 369, identifier:start_s; 370, identifier:start_o; 371, identifier:step_o; 372, integer:0; 373, parenthesized_expression; 373, 374; 374, comparison_operator:>=; 374, 375; 374, 378; 375, binary_operator:+; 375, 376; 375, 377; 376, identifier:start_s; 377, identifier:step_o; 378, identifier:start_o; 379, parenthesized_expression; 379, 380; 380, comparison_operator:<=; 380, 381; 380, 384; 381, binary_operator:-; 381, 382; 381, 383; 382, identifier:end_s; 383, identifier:step_o; 384, identifier:end_o; 385, block; 385, 386; 386, return_statement; 386, 387; 387, call; 387, 388; 387, 389; 388, identifier:RangeIndex; 389, argument_list; 389, 390; 389, 391; 389, 394; 390, identifier:start_r; 391, binary_operator:+; 391, 392; 391, 393; 392, identifier:end_r; 393, identifier:step_o; 394, identifier:step_o; 395, return_statement; 395, 396; 396, call; 396, 397; 396, 402; 397, attribute; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:self; 400, identifier:_int64index; 401, identifier:union; 402, argument_list; 402, 403; 402, 404; 403, identifier:other; 404, keyword_argument; 404, 405; 404, 406; 405, identifier:sort; 406, identifier:sort | def union(self, other, sort=None):
self._assert_can_do_setop(other)
if len(other) == 0 or self.equals(other) or len(self) == 0:
return super().union(other, sort=sort)
if isinstance(other, RangeIndex) and sort is None:
start_s, step_s = self._start, self._step
end_s = self._start + self._step * (len(self) - 1)
start_o, step_o = other._start, other._step
end_o = other._start + other._step * (len(other) - 1)
if self._step < 0:
start_s, step_s, end_s = end_s, -step_s, start_s
if other._step < 0:
start_o, step_o, end_o = end_o, -step_o, start_o
if len(self) == 1 and len(other) == 1:
step_s = step_o = abs(self._start - other._start)
elif len(self) == 1:
step_s = step_o
elif len(other) == 1:
step_o = step_s
start_r = min(start_s, start_o)
end_r = max(end_s, end_o)
if step_o == step_s:
if ((start_s - start_o) % step_s == 0 and
(start_s - end_o) <= step_s and
(start_o - end_s) <= step_s):
return RangeIndex(start_r, end_r + step_s, step_s)
if ((step_s % 2 == 0) and
(abs(start_s - start_o) <= step_s / 2) and
(abs(end_s - end_o) <= step_s / 2)):
return RangeIndex(start_r, end_r + step_s / 2, step_s / 2)
elif step_o % step_s == 0:
if ((start_o - start_s) % step_s == 0 and
(start_o + step_s >= start_s) and
(end_o - step_s <= end_s)):
return RangeIndex(start_r, end_r + step_s, step_s)
elif step_s % step_o == 0:
if ((start_s - start_o) % step_o == 0 and
(start_s + step_o >= start_o) and
(end_s - step_o <= end_o)):
return RangeIndex(start_r, end_r + step_o, step_o)
return self._int64index.union(other, sort=sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:nlargest; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:n; 6, identifier:columns; 7, default_parameter; 7, 8; 7, 9; 8, identifier:keep; 9, string:'first'; 10, block; 10, 11; 11, return_statement; 11, 12; 12, call; 12, 13; 12, 30; 13, attribute; 13, 14; 13, 29; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:algorithms; 17, identifier:SelectNFrame; 18, argument_list; 18, 19; 18, 20; 18, 23; 18, 26; 19, identifier:self; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:n; 22, identifier:n; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:keep; 25, identifier:keep; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:columns; 28, identifier:columns; 29, identifier:nlargest; 30, argument_list | def nlargest(self, n, columns, keep='first'):
return algorithms.SelectNFrame(self,
n=n,
keep=keep,
columns=columns).nlargest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:nsmallest; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:n; 6, identifier:columns; 7, default_parameter; 7, 8; 7, 9; 8, identifier:keep; 9, string:'first'; 10, block; 10, 11; 11, return_statement; 11, 12; 12, call; 12, 13; 12, 30; 13, attribute; 13, 14; 13, 29; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:algorithms; 17, identifier:SelectNFrame; 18, argument_list; 18, 19; 18, 20; 18, 23; 18, 26; 19, identifier:self; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:n; 22, identifier:n; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:keep; 25, identifier:keep; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:columns; 28, identifier:columns; 29, identifier:nsmallest; 30, argument_list | def nsmallest(self, n, columns, keep='first'):
return algorithms.SelectNFrame(self,
n=n,
keep=keep,
columns=columns).nsmallest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:append; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ignore_index; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:verify_integrity; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sort; 14, None; 15, block; 15, 16; 15, 259; 15, 267; 15, 291; 16, if_statement; 16, 17; 16, 24; 16, 204; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:other; 21, tuple; 21, 22; 21, 23; 22, identifier:Series; 23, identifier:dict; 24, block; 24, 25; 24, 39; 24, 56; 24, 86; 24, 99; 24, 131; 24, 143; 24, 168; 24, 182; 25, if_statement; 25, 26; 25, 31; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:other; 30, identifier:dict; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:other; 35, call; 35, 36; 35, 37; 36, identifier:Series; 37, argument_list; 37, 38; 38, identifier:other; 39, if_statement; 39, 40; 39, 48; 40, boolean_operator:and; 40, 41; 40, 46; 41, comparison_operator:is; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:other; 44, identifier:name; 45, None; 46, not_operator; 46, 47; 47, identifier:ignore_index; 48, block; 48, 49; 49, raise_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:TypeError; 52, argument_list; 52, 53; 53, concatenated_string; 53, 54; 53, 55; 54, string:'Can only append a Series if ignore_index=True'; 55, string:' or if the Series has a name'; 56, if_statement; 56, 57; 56, 62; 56, 67; 57, comparison_operator:is; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:other; 60, identifier:name; 61, None; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:index; 66, None; 67, else_clause; 67, 68; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:index; 72, call; 72, 73; 72, 74; 73, identifier:Index; 74, argument_list; 74, 75; 74, 79; 75, list:[other.name]; 75, 76; 76, attribute; 76, 77; 76, 78; 77, identifier:other; 78, identifier:name; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:name; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:index; 85, identifier:name; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:idx_diff; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:other; 93, identifier:index; 94, identifier:difference; 95, argument_list; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:columns; 99, try_statement; 99, 100; 99, 112; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:combined_columns; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:columns; 109, identifier:append; 110, argument_list; 110, 111; 111, identifier:idx_diff; 112, except_clause; 112, 113; 112, 114; 113, identifier:TypeError; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:combined_columns; 118, call; 118, 119; 118, 129; 119, attribute; 119, 120; 119, 128; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:columns; 125, identifier:astype; 126, argument_list; 126, 127; 127, identifier:object; 128, identifier:append; 129, argument_list; 129, 130; 130, identifier:idx_diff; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:other; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:other; 137, identifier:reindex; 138, argument_list; 138, 139; 138, 140; 139, identifier:combined_columns; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:copy; 142, False; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:other; 146, call; 146, 147; 146, 148; 147, identifier:DataFrame; 148, argument_list; 148, 149; 148, 162; 148, 165; 149, call; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:other; 153, identifier:values; 154, identifier:reshape; 155, argument_list; 155, 156; 156, tuple; 156, 157; 156, 158; 157, integer:1; 158, call; 158, 159; 158, 160; 159, identifier:len; 160, argument_list; 160, 161; 161, identifier:other; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:index; 164, identifier:index; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:columns; 167, identifier:combined_columns; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:other; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:other; 174, identifier:_convert; 175, argument_list; 175, 176; 175, 179; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:datetime; 178, True; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:timedelta; 181, True; 182, if_statement; 182, 183; 182, 192; 183, not_operator; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:columns; 189, identifier:equals; 190, argument_list; 190, 191; 191, identifier:combined_columns; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:self; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:reindex; 200, argument_list; 200, 201; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:columns; 203, identifier:combined_columns; 204, elif_clause; 204, 205; 204, 219; 205, boolean_operator:and; 205, 206; 205, 211; 206, call; 206, 207; 206, 208; 207, identifier:isinstance; 208, argument_list; 208, 209; 208, 210; 209, identifier:other; 210, identifier:list; 211, not_operator; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:isinstance; 214, argument_list; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:other; 217, integer:0; 218, identifier:DataFrame; 219, block; 219, 220; 219, 227; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:other; 223, call; 223, 224; 223, 225; 224, identifier:DataFrame; 225, argument_list; 225, 226; 226, identifier:other; 227, if_statement; 227, 228; 227, 245; 228, call; 228, 229; 228, 244; 229, attribute; 229, 230; 229, 243; 230, parenthesized_expression; 230, 231; 231, comparison_operator:>=; 231, 232; 231, 242; 232, call; 232, 233; 232, 238; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:self; 236, identifier:columns; 237, identifier:get_indexer; 238, argument_list; 238, 239; 239, attribute; 239, 240; 239, 241; 240, identifier:other; 241, identifier:columns; 242, integer:0; 243, identifier:all; 244, argument_list; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:other; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:other; 252, identifier:reindex; 253, argument_list; 253, 254; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:columns; 256, attribute; 256, 257; 256, 258; 257, identifier:self; 258, identifier:columns; 259, import_from_statement; 259, 260; 259, 265; 260, dotted_name; 260, 261; 260, 262; 260, 263; 260, 264; 261, identifier:pandas; 262, identifier:core; 263, identifier:reshape; 264, identifier:concat; 265, dotted_name; 265, 266; 266, identifier:concat; 267, if_statement; 267, 268; 267, 275; 267, 283; 268, call; 268, 269; 268, 270; 269, identifier:isinstance; 270, argument_list; 270, 271; 270, 272; 271, identifier:other; 272, tuple; 272, 273; 272, 274; 273, identifier:list; 274, identifier:tuple; 275, block; 275, 276; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:to_concat; 279, binary_operator:+; 279, 280; 279, 282; 280, list:[self]; 280, 281; 281, identifier:self; 282, identifier:other; 283, else_clause; 283, 284; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:to_concat; 288, list:[self, other]; 288, 289; 288, 290; 289, identifier:self; 290, identifier:other; 291, return_statement; 291, 292; 292, call; 292, 293; 292, 294; 293, identifier:concat; 294, argument_list; 294, 295; 294, 296; 294, 299; 294, 302; 295, identifier:to_concat; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:ignore_index; 298, identifier:ignore_index; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:verify_integrity; 301, identifier:verify_integrity; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:sort; 304, identifier:sort | def append(self, other, ignore_index=False,
verify_integrity=False, sort=None):
if isinstance(other, (Series, dict)):
if isinstance(other, dict):
other = Series(other)
if other.name is None and not ignore_index:
raise TypeError('Can only append a Series if ignore_index=True'
' or if the Series has a name')
if other.name is None:
index = None
else:
index = Index([other.name], name=self.index.name)
idx_diff = other.index.difference(self.columns)
try:
combined_columns = self.columns.append(idx_diff)
except TypeError:
combined_columns = self.columns.astype(object).append(idx_diff)
other = other.reindex(combined_columns, copy=False)
other = DataFrame(other.values.reshape((1, len(other))),
index=index,
columns=combined_columns)
other = other._convert(datetime=True, timedelta=True)
if not self.columns.equals(combined_columns):
self = self.reindex(columns=combined_columns)
elif isinstance(other, list) and not isinstance(other[0], DataFrame):
other = DataFrame(other)
if (self.columns.get_indexer(other.columns) >= 0).all():
other = other.reindex(columns=self.columns)
from pandas.core.reshape.concat import concat
if isinstance(other, (list, tuple)):
to_concat = [self] + other
else:
to_concat = [self, other]
return concat(to_concat, ignore_index=ignore_index,
verify_integrity=verify_integrity,
sort=sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:join; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:on; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:how; 11, string:'left'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:lsuffix; 14, string:''; 15, default_parameter; 15, 16; 15, 17; 16, identifier:rsuffix; 17, string:''; 18, default_parameter; 18, 19; 18, 20; 19, identifier:sort; 20, False; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_join_compat; 27, argument_list; 27, 28; 27, 29; 27, 32; 27, 35; 27, 38; 27, 41; 28, identifier:other; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:on; 31, identifier:on; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:how; 34, identifier:how; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:lsuffix; 37, identifier:lsuffix; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:rsuffix; 40, identifier:rsuffix; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:sort; 43, identifier:sort | def join(self, other, on=None, how='left', lsuffix='', rsuffix='',
sort=False):
return self._join_compat(other, on=on, how=how, lsuffix=lsuffix,
rsuffix=rsuffix, sort=sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 1, 9; 2, function_name:_values_for_argsort; 3, parameters; 3, 4; 4, identifier:self; 5, type; 5, 6; 6, attribute; 6, 7; 6, 8; 7, identifier:np; 8, identifier:ndarray; 9, block; 9, 10; 9, 20; 9, 34; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:data; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_data; 18, identifier:copy; 19, argument_list; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 27; 22, subscript; 22, 23; 22, 24; 23, identifier:data; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_mask; 27, binary_operator:-; 27, 28; 27, 33; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:data; 31, identifier:min; 32, argument_list; 33, integer:1; 34, return_statement; 34, 35; 35, identifier:data | def _values_for_argsort(self) -> np.ndarray:
data = self._data.copy()
data[self._mask] = data.min() - 1
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_get_combined_index; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:indexes; 5, default_parameter; 5, 6; 5, 7; 6, identifier:intersect; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, False; 11, block; 11, 12; 11, 19; 11, 93; 11, 110; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:indexes; 15, call; 15, 16; 15, 17; 16, identifier:_get_distinct_objs; 17, argument_list; 17, 18; 18, identifier:indexes; 19, if_statement; 19, 20; 19, 26; 19, 34; 19, 48; 19, 74; 20, comparison_operator:==; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:indexes; 25, integer:0; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:index; 30, call; 30, 31; 30, 32; 31, identifier:Index; 32, argument_list; 32, 33; 33, list:[]; 34, elif_clause; 34, 35; 34, 41; 35, comparison_operator:==; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:indexes; 40, integer:1; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:index; 45, subscript; 45, 46; 45, 47; 46, identifier:indexes; 47, integer:0; 48, elif_clause; 48, 49; 48, 50; 49, identifier:intersect; 50, block; 50, 51; 50, 57; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:index; 54, subscript; 54, 55; 54, 56; 55, identifier:indexes; 56, integer:0; 57, for_statement; 57, 58; 57, 59; 57, 64; 58, identifier:other; 59, subscript; 59, 60; 59, 61; 60, identifier:indexes; 61, slice; 61, 62; 61, 63; 62, integer:1; 63, colon; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:index; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:index; 71, identifier:intersection; 72, argument_list; 72, 73; 73, identifier:other; 74, else_clause; 74, 75; 75, block; 75, 76; 75, 86; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:index; 79, call; 79, 80; 79, 81; 80, identifier:_union_indexes; 81, argument_list; 81, 82; 81, 83; 82, identifier:indexes; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:sort; 85, identifier:sort; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:index; 89, call; 89, 90; 89, 91; 90, identifier:ensure_index; 91, argument_list; 91, 92; 92, identifier:index; 93, if_statement; 93, 94; 93, 95; 94, identifier:sort; 95, block; 95, 96; 96, try_statement; 96, 97; 96, 106; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:index; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:index; 104, identifier:sort_values; 105, argument_list; 106, except_clause; 106, 107; 106, 108; 107, identifier:TypeError; 108, block; 108, 109; 109, pass_statement; 110, return_statement; 110, 111; 111, identifier:index | def _get_combined_index(indexes, intersect=False, sort=False):
indexes = _get_distinct_objs(indexes)
if len(indexes) == 0:
index = Index([])
elif len(indexes) == 1:
index = indexes[0]
elif intersect:
index = indexes[0]
for other in indexes[1:]:
index = index.intersection(other)
else:
index = _union_indexes(indexes, sort=sort)
index = ensure_index(index)
if sort:
try:
index = index.sort_values()
except TypeError:
pass
return index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_union_indexes; 3, parameters; 3, 4; 3, 5; 4, identifier:indexes; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, True; 8, block; 8, 9; 8, 22; 8, 55; 8, 64; 8, 111; 9, if_statement; 9, 10; 9, 16; 10, comparison_operator:==; 10, 11; 10, 15; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:indexes; 15, integer:0; 16, block; 16, 17; 17, raise_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:AssertionError; 20, argument_list; 20, 21; 21, string:'Must have at least 1 Index to union'; 22, if_statement; 22, 23; 22, 29; 23, comparison_operator:==; 23, 24; 23, 28; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, identifier:indexes; 28, integer:1; 29, block; 29, 30; 29, 36; 29, 53; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:result; 33, subscript; 33, 34; 33, 35; 34, identifier:indexes; 35, integer:0; 36, if_statement; 36, 37; 36, 42; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:result; 41, identifier:list; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:result; 46, call; 46, 47; 46, 48; 47, identifier:Index; 48, argument_list; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:sorted; 51, argument_list; 51, 52; 52, identifier:result; 53, return_statement; 53, 54; 54, identifier:result; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, pattern_list; 57, 58; 57, 59; 58, identifier:indexes; 59, identifier:kind; 60, call; 60, 61; 60, 62; 61, identifier:_sanitize_and_check; 62, argument_list; 62, 63; 63, identifier:indexes; 64, function_definition; 64, 65; 64, 66; 64, 68; 65, function_name:_unique_indices; 66, parameters; 66, 67; 67, identifier:inds; 68, block; 68, 69; 68, 91; 69, function_definition; 69, 70; 69, 71; 69, 73; 70, function_name:conv; 71, parameters; 71, 72; 72, identifier:i; 73, block; 73, 74; 73, 89; 74, if_statement; 74, 75; 74, 80; 75, call; 75, 76; 75, 77; 76, identifier:isinstance; 77, argument_list; 77, 78; 77, 79; 78, identifier:i; 79, identifier:Index; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:i; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:i; 87, identifier:tolist; 88, argument_list; 89, return_statement; 89, 90; 90, identifier:i; 91, return_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:Index; 94, argument_list; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:lib; 98, identifier:fast_unique_multiple_list; 99, argument_list; 99, 100; 99, 108; 100, list_comprehension; 100, 101; 100, 105; 101, call; 101, 102; 101, 103; 102, identifier:conv; 103, argument_list; 103, 104; 104, identifier:i; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:i; 107, identifier:inds; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:sort; 110, identifier:sort; 111, if_statement; 111, 112; 111, 115; 111, 161; 111, 243; 112, comparison_operator:==; 112, 113; 112, 114; 113, identifier:kind; 114, string:'special'; 115, block; 115, 116; 115, 122; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:result; 119, subscript; 119, 120; 119, 121; 120, identifier:indexes; 121, integer:0; 122, if_statement; 122, 123; 122, 128; 122, 140; 123, call; 123, 124; 123, 125; 124, identifier:hasattr; 125, argument_list; 125, 126; 125, 127; 126, identifier:result; 127, string:'union_many'; 128, block; 128, 129; 129, return_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:result; 133, identifier:union_many; 134, argument_list; 134, 135; 135, subscript; 135, 136; 135, 137; 136, identifier:indexes; 137, slice; 137, 138; 137, 139; 138, integer:1; 139, colon; 140, else_clause; 140, 141; 141, block; 141, 142; 141, 159; 142, for_statement; 142, 143; 142, 144; 142, 149; 143, identifier:other; 144, subscript; 144, 145; 144, 146; 145, identifier:indexes; 146, slice; 146, 147; 146, 148; 147, integer:1; 148, colon; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:result; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:result; 156, identifier:union; 157, argument_list; 157, 158; 158, identifier:other; 159, return_statement; 159, 160; 160, identifier:result; 161, elif_clause; 161, 162; 161, 165; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:kind; 164, string:'array'; 165, block; 165, 166; 165, 172; 165, 214; 165, 223; 165, 241; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:index; 169, subscript; 169, 170; 169, 171; 170, identifier:indexes; 171, integer:0; 172, for_statement; 172, 173; 172, 174; 172, 179; 173, identifier:other; 174, subscript; 174, 175; 174, 176; 175, identifier:indexes; 176, slice; 176, 177; 176, 178; 177, integer:1; 178, colon; 179, block; 179, 180; 180, if_statement; 180, 181; 180, 188; 181, not_operator; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:index; 185, identifier:equals; 186, argument_list; 186, 187; 187, identifier:other; 188, block; 188, 189; 188, 209; 189, if_statement; 189, 190; 189, 193; 190, comparison_operator:is; 190, 191; 190, 192; 191, identifier:sort; 192, None; 193, block; 193, 194; 193, 205; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:warnings; 198, identifier:warn; 199, argument_list; 199, 200; 199, 201; 199, 202; 200, identifier:_sort_msg; 201, identifier:FutureWarning; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:stacklevel; 204, integer:8; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:sort; 208, True; 209, return_statement; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:_unique_indices; 212, argument_list; 212, 213; 213, identifier:indexes; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:name; 217, subscript; 217, 218; 217, 222; 218, call; 218, 219; 218, 220; 219, identifier:_get_consensus_names; 220, argument_list; 220, 221; 221, identifier:indexes; 222, integer:0; 223, if_statement; 223, 224; 223, 229; 224, comparison_operator:!=; 224, 225; 224, 226; 225, identifier:name; 226, attribute; 226, 227; 226, 228; 227, identifier:index; 228, identifier:name; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:index; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:index; 236, identifier:_shallow_copy; 237, argument_list; 237, 238; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:name; 240, identifier:name; 241, return_statement; 241, 242; 242, identifier:index; 243, else_clause; 243, 244; 244, block; 244, 245; 245, return_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:_unique_indices; 248, argument_list; 248, 249; 249, identifier:indexes | def _union_indexes(indexes, sort=True):
if len(indexes) == 0:
raise AssertionError('Must have at least 1 Index to union')
if len(indexes) == 1:
result = indexes[0]
if isinstance(result, list):
result = Index(sorted(result))
return result
indexes, kind = _sanitize_and_check(indexes)
def _unique_indices(inds):
def conv(i):
if isinstance(i, Index):
i = i.tolist()
return i
return Index(
lib.fast_unique_multiple_list([conv(i) for i in inds], sort=sort))
if kind == 'special':
result = indexes[0]
if hasattr(result, 'union_many'):
return result.union_many(indexes[1:])
else:
for other in indexes[1:]:
result = result.union(other)
return result
elif kind == 'array':
index = indexes[0]
for other in indexes[1:]:
if not index.equals(other):
if sort is None:
warnings.warn(_sort_msg, FutureWarning, stacklevel=8)
sort = True
return _unique_indices(indexes)
name = _get_consensus_names(indexes)[0]
if name != index.name:
index = index._shallow_copy(name=name)
return index
else:
return _unique_indices(indexes) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sanitize_and_check; 3, parameters; 3, 4; 4, identifier:indexes; 5, block; 5, 6; 5, 20; 5, 70; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:kinds; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 11, 12; 12, set_comprehension; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:type; 15, argument_list; 15, 16; 16, identifier:index; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:index; 19, identifier:indexes; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:in; 21, 22; 21, 23; 22, identifier:list; 23, identifier:kinds; 24, block; 24, 25; 25, if_statement; 25, 26; 25, 32; 25, 64; 26, comparison_operator:>; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:kinds; 31, integer:1; 32, block; 32, 33; 32, 57; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:indexes; 36, list_comprehension; 36, 37; 36, 54; 37, conditional_expression:if; 37, 38; 37, 47; 37, 53; 38, call; 38, 39; 38, 40; 39, identifier:Index; 40, argument_list; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:com; 44, identifier:try_sort; 45, argument_list; 45, 46; 46, identifier:x; 47, not_operator; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:x; 52, identifier:Index; 53, identifier:x; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:x; 56, identifier:indexes; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:kinds; 61, identifier:remove; 62, argument_list; 62, 63; 63, identifier:list; 64, else_clause; 64, 65; 65, block; 65, 66; 66, return_statement; 66, 67; 67, expression_list; 67, 68; 67, 69; 68, identifier:indexes; 69, string:'list'; 70, if_statement; 70, 71; 70, 81; 70, 86; 71, boolean_operator:or; 71, 72; 71, 78; 72, comparison_operator:>; 72, 73; 72, 77; 73, call; 73, 74; 73, 75; 74, identifier:len; 75, argument_list; 75, 76; 76, identifier:kinds; 77, integer:1; 78, comparison_operator:not; 78, 79; 78, 80; 79, identifier:Index; 80, identifier:kinds; 81, block; 81, 82; 82, return_statement; 82, 83; 83, expression_list; 83, 84; 83, 85; 84, identifier:indexes; 85, string:'special'; 86, else_clause; 86, 87; 87, block; 87, 88; 88, return_statement; 88, 89; 89, expression_list; 89, 90; 89, 91; 90, identifier:indexes; 91, string:'array' | def _sanitize_and_check(indexes):
kinds = list({type(index) for index in indexes})
if list in kinds:
if len(kinds) > 1:
indexes = [Index(com.try_sort(x))
if not isinstance(x, Index) else
x for x in indexes]
kinds.remove(list)
else:
return indexes, 'list'
if len(kinds) > 1 or Index not in kinds:
return indexes, 'special'
else:
return indexes, 'array' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_from_inferred_categories; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:cls; 5, identifier:inferred_categories; 6, identifier:inferred_codes; 7, identifier:dtype; 8, default_parameter; 8, 9; 8, 10; 9, identifier:true_values; 10, None; 11, block; 11, 12; 11, 23; 11, 30; 11, 45; 11, 133; 11, 208; 12, import_from_statement; 12, 13; 12, 15; 12, 17; 12, 19; 12, 21; 13, dotted_name; 13, 14; 14, identifier:pandas; 15, dotted_name; 15, 16; 16, identifier:Index; 17, dotted_name; 17, 18; 18, identifier:to_numeric; 19, dotted_name; 19, 20; 20, identifier:to_datetime; 21, dotted_name; 21, 22; 22, identifier:to_timedelta; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:cats; 26, call; 26, 27; 26, 28; 27, identifier:Index; 28, argument_list; 28, 29; 29, identifier:inferred_categories; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:known_categories; 33, parenthesized_expression; 33, 34; 34, boolean_operator:and; 34, 35; 34, 40; 35, call; 35, 36; 35, 37; 36, identifier:isinstance; 37, argument_list; 37, 38; 37, 39; 38, identifier:dtype; 39, identifier:CategoricalDtype; 40, comparison_operator:is; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:dtype; 43, identifier:categories; 44, None; 45, if_statement; 45, 46; 45, 47; 46, identifier:known_categories; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 56; 48, 67; 48, 85; 48, 103; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:dtype; 53, identifier:categories; 54, identifier:is_numeric; 55, argument_list; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:cats; 60, call; 60, 61; 60, 62; 61, identifier:to_numeric; 62, argument_list; 62, 63; 62, 64; 63, identifier:inferred_categories; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:errors; 66, string:"coerce"; 67, elif_clause; 67, 68; 67, 74; 68, call; 68, 69; 68, 70; 69, identifier:is_datetime64_dtype; 70, argument_list; 70, 71; 71, attribute; 71, 72; 71, 73; 72, identifier:dtype; 73, identifier:categories; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:cats; 78, call; 78, 79; 78, 80; 79, identifier:to_datetime; 80, argument_list; 80, 81; 80, 82; 81, identifier:inferred_categories; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:errors; 84, string:"coerce"; 85, elif_clause; 85, 86; 85, 92; 86, call; 86, 87; 86, 88; 87, identifier:is_timedelta64_dtype; 88, argument_list; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:dtype; 91, identifier:categories; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:cats; 96, call; 96, 97; 96, 98; 97, identifier:to_timedelta; 98, argument_list; 98, 99; 98, 100; 99, identifier:inferred_categories; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:errors; 102, string:"coerce"; 103, elif_clause; 103, 104; 103, 111; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:dtype; 108, identifier:categories; 109, identifier:is_boolean; 110, argument_list; 111, block; 111, 112; 111, 124; 112, if_statement; 112, 113; 112, 116; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:true_values; 115, None; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:true_values; 120, list:["True", "TRUE", "true"]; 120, 121; 120, 122; 120, 123; 121, string:"True"; 122, string:"TRUE"; 123, string:"true"; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:cats; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:cats; 130, identifier:isin; 131, argument_list; 131, 132; 132, identifier:true_values; 133, if_statement; 133, 134; 133, 135; 133, 151; 133, 192; 134, identifier:known_categories; 135, block; 135, 136; 135, 142; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:categories; 139, attribute; 139, 140; 139, 141; 140, identifier:dtype; 141, identifier:categories; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:codes; 145, call; 145, 146; 145, 147; 146, identifier:_recode_for_categories; 147, argument_list; 147, 148; 147, 149; 147, 150; 148, identifier:inferred_codes; 149, identifier:cats; 150, identifier:categories; 151, elif_clause; 151, 152; 151, 156; 152, not_operator; 152, 153; 153, attribute; 153, 154; 153, 155; 154, identifier:cats; 155, identifier:is_monotonic_increasing; 156, block; 156, 157; 156, 165; 156, 173; 156, 182; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:unsorted; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:cats; 163, identifier:copy; 164, argument_list; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:categories; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:cats; 171, identifier:sort_values; 172, argument_list; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:codes; 176, call; 176, 177; 176, 178; 177, identifier:_recode_for_categories; 178, argument_list; 178, 179; 178, 180; 178, 181; 179, identifier:inferred_codes; 180, identifier:unsorted; 181, identifier:categories; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:dtype; 185, call; 185, 186; 185, 187; 186, identifier:CategoricalDtype; 187, argument_list; 187, 188; 187, 189; 188, identifier:categories; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:ordered; 191, False; 192, else_clause; 192, 193; 193, block; 193, 194; 193, 204; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:dtype; 197, call; 197, 198; 197, 199; 198, identifier:CategoricalDtype; 199, argument_list; 199, 200; 199, 201; 200, identifier:cats; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:ordered; 203, False; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:codes; 207, identifier:inferred_codes; 208, return_statement; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:cls; 211, argument_list; 211, 212; 211, 213; 211, 216; 212, identifier:codes; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:dtype; 215, identifier:dtype; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:fastpath; 218, True | def _from_inferred_categories(cls, inferred_categories, inferred_codes,
dtype, true_values=None):
from pandas import Index, to_numeric, to_datetime, to_timedelta
cats = Index(inferred_categories)
known_categories = (isinstance(dtype, CategoricalDtype) and
dtype.categories is not None)
if known_categories:
if dtype.categories.is_numeric():
cats = to_numeric(inferred_categories, errors="coerce")
elif is_datetime64_dtype(dtype.categories):
cats = to_datetime(inferred_categories, errors="coerce")
elif is_timedelta64_dtype(dtype.categories):
cats = to_timedelta(inferred_categories, errors="coerce")
elif dtype.categories.is_boolean():
if true_values is None:
true_values = ["True", "TRUE", "true"]
cats = cats.isin(true_values)
if known_categories:
categories = dtype.categories
codes = _recode_for_categories(inferred_codes, cats, categories)
elif not cats.is_monotonic_increasing:
unsorted = cats.copy()
categories = cats.sort_values()
codes = _recode_for_categories(inferred_codes, unsorted,
categories)
dtype = CategoricalDtype(categories, ordered=False)
else:
dtype = CategoricalDtype(cats, ordered=False)
codes = inferred_codes
return cls(codes, dtype=dtype, fastpath=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:inplace; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:na_position; 13, string:'last'; 14, block; 14, 15; 14, 23; 14, 46; 14, 59; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:inplace; 18, call; 18, 19; 18, 20; 19, identifier:validate_bool_kwarg; 20, argument_list; 20, 21; 20, 22; 21, identifier:inplace; 22, string:'inplace'; 23, if_statement; 23, 24; 23, 29; 24, comparison_operator:not; 24, 25; 24, 26; 25, identifier:na_position; 26, list:['last', 'first']; 26, 27; 26, 28; 27, string:'last'; 28, string:'first'; 29, block; 29, 30; 29, 34; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:msg; 33, string:'invalid na_position: {na_position!r}'; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ValueError; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:msg; 41, identifier:format; 42, argument_list; 42, 43; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:na_position; 45, identifier:na_position; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:sorted_idx; 49, call; 49, 50; 49, 51; 50, identifier:nargsort; 51, argument_list; 51, 52; 51, 53; 51, 56; 52, identifier:self; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:ascending; 55, identifier:ascending; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:na_position; 58, identifier:na_position; 59, if_statement; 59, 60; 59, 61; 59, 72; 60, identifier:inplace; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_codes; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_codes; 71, identifier:sorted_idx; 72, else_clause; 72, 73; 73, block; 73, 74; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_constructor; 79, argument_list; 79, 80; 79, 87; 79, 92; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:values; 82, subscript; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_codes; 86, identifier:sorted_idx; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:dtype; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:dtype; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:fastpath; 94, True | def sort_values(self, inplace=False, ascending=True, na_position='last'):
inplace = validate_bool_kwarg(inplace, 'inplace')
if na_position not in ['last', 'first']:
msg = 'invalid na_position: {na_position!r}'
raise ValueError(msg.format(na_position=na_position))
sorted_idx = nargsort(self,
ascending=ascending,
na_position=na_position)
if inplace:
self._codes = self._codes[sorted_idx]
else:
return self._constructor(values=self._codes[sorted_idx],
dtype=self.dtype,
fastpath=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:unique; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 15; 5, 23; 5, 29; 5, 38; 5, 52; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:unique_codes; 9, call; 9, 10; 9, 11; 10, identifier:unique1d; 11, argument_list; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:codes; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:cat; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:copy; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:cat; 27, identifier:_codes; 28, identifier:unique_codes; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:take_codes; 32, subscript; 32, 33; 32, 34; 33, identifier:unique_codes; 34, comparison_operator:!=; 34, 35; 34, 36; 35, identifier:unique_codes; 36, unary_operator:-; 36, 37; 37, integer:1; 38, if_statement; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:ordered; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:take_codes; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:np; 49, identifier:sort; 50, argument_list; 50, 51; 51, identifier:take_codes; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:cat; 56, identifier:set_categories; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:cat; 62, identifier:categories; 63, identifier:take; 64, argument_list; 64, 65; 65, identifier:take_codes | def unique(self):
unique_codes = unique1d(self.codes)
cat = self.copy()
cat._codes = unique_codes
take_codes = unique_codes[unique_codes != -1]
if self.ordered:
take_codes = np.sort(take_codes)
return cat.set_categories(cat.categories.take(take_codes)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 35; 2, function_name:concat; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 4, identifier:objs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:join; 10, string:'outer'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:join_axes; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:ignore_index; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:keys; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:levels; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:names; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:verify_integrity; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:sort; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:copy; 34, True; 35, block; 35, 36; 35, 73; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:op; 39, call; 39, 40; 39, 41; 40, identifier:_Concatenator; 41, argument_list; 41, 42; 41, 43; 41, 46; 41, 49; 41, 52; 41, 55; 41, 58; 41, 61; 41, 64; 41, 67; 41, 70; 42, identifier:objs; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:axis; 45, identifier:axis; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:join_axes; 48, identifier:join_axes; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:ignore_index; 51, identifier:ignore_index; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:join; 54, identifier:join; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:keys; 57, identifier:keys; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:levels; 60, identifier:levels; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:names; 63, identifier:names; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:verify_integrity; 66, identifier:verify_integrity; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:copy; 69, identifier:copy; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:sort; 72, identifier:sort; 73, return_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:op; 77, identifier:get_result; 78, argument_list | def concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
sort=None, copy=True):
op = _Concatenator(objs, axis=axis, join_axes=join_axes,
ignore_index=ignore_index, join=join,
keys=keys, levels=levels, names=names,
verify_integrity=verify_integrity,
copy=copy, sort=sort)
return op.get_result() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 24; 2, function_name:cut; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 4, identifier:x; 5, identifier:bins; 6, default_parameter; 6, 7; 6, 8; 7, identifier:right; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:labels; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:retbins; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:precision; 17, integer:3; 18, default_parameter; 18, 19; 18, 20; 19, identifier:include_lowest; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:duplicates; 23, string:'raise'; 24, block; 24, 25; 24, 36; 24, 45; 24, 330; 24, 358; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 32; 27, pattern_list; 27, 28; 27, 29; 27, 30; 27, 31; 28, identifier:x_is_series; 29, identifier:series_index; 30, identifier:name; 31, identifier:x; 32, call; 32, 33; 32, 34; 33, identifier:_preprocess_for_cut; 34, argument_list; 34, 35; 35, identifier:x; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, pattern_list; 38, 39; 38, 40; 39, identifier:x; 40, identifier:dtype; 41, call; 41, 42; 41, 43; 42, identifier:_coerce_to_type; 43, argument_list; 43, 44; 44, identifier:x; 45, if_statement; 45, 46; 45, 53; 45, 249; 45, 266; 46, not_operator; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:np; 50, identifier:iterable; 51, argument_list; 51, 52; 52, identifier:bins; 53, block; 53, 54; 53, 69; 53, 95; 53, 105; 53, 121; 53, 133; 54, if_statement; 54, 55; 54, 63; 55, boolean_operator:and; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:is_scalar; 58, argument_list; 58, 59; 59, identifier:bins; 60, comparison_operator:<; 60, 61; 60, 62; 61, identifier:bins; 62, integer:1; 63, block; 63, 64; 64, raise_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:ValueError; 67, argument_list; 67, 68; 68, string:"`bins` should be a positive integer."; 69, try_statement; 69, 70; 69, 77; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:sz; 74, attribute; 74, 75; 74, 76; 75, identifier:x; 76, identifier:size; 77, except_clause; 77, 78; 77, 79; 78, identifier:AttributeError; 79, block; 79, 80; 79, 89; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:x; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:np; 86, identifier:asarray; 87, argument_list; 87, 88; 88, identifier:x; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:sz; 92, attribute; 92, 93; 92, 94; 93, identifier:x; 94, identifier:size; 95, if_statement; 95, 96; 95, 99; 96, comparison_operator:==; 96, 97; 96, 98; 97, identifier:sz; 98, integer:0; 99, block; 99, 100; 100, raise_statement; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:ValueError; 103, argument_list; 103, 104; 104, string:'Cannot cut empty array'; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:rng; 108, tuple; 108, 109; 108, 115; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:nanops; 112, identifier:nanmin; 113, argument_list; 113, 114; 114, identifier:x; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:nanops; 118, identifier:nanmax; 119, argument_list; 119, 120; 120, identifier:x; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, pattern_list; 123, 124; 123, 125; 124, identifier:mn; 125, identifier:mx; 126, list_comprehension; 126, 127; 126, 130; 127, binary_operator:+; 127, 128; 127, 129; 128, identifier:mi; 129, float:0.0; 130, for_in_clause; 130, 131; 130, 132; 131, identifier:mi; 132, identifier:rng; 133, if_statement; 133, 134; 133, 147; 133, 155; 133, 204; 134, boolean_operator:or; 134, 135; 134, 141; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:np; 138, identifier:isinf; 139, argument_list; 139, 140; 140, identifier:mn; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:np; 144, identifier:isinf; 145, argument_list; 145, 146; 146, identifier:mx; 147, block; 147, 148; 148, raise_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:ValueError; 151, argument_list; 151, 152; 152, concatenated_string; 152, 153; 152, 154; 153, string:'cannot specify integer `bins` when input data '; 154, string:'contains infinity'; 155, elif_clause; 155, 156; 155, 159; 156, comparison_operator:==; 156, 157; 156, 158; 157, identifier:mn; 158, identifier:mx; 159, block; 159, 160; 159, 174; 159, 188; 160, expression_statement; 160, 161; 161, augmented_assignment:-=; 161, 162; 161, 163; 162, identifier:mn; 163, conditional_expression:if; 163, 164; 163, 170; 163, 173; 164, binary_operator:*; 164, 165; 164, 166; 165, float:.001; 166, call; 166, 167; 166, 168; 167, identifier:abs; 168, argument_list; 168, 169; 169, identifier:mn; 170, comparison_operator:!=; 170, 171; 170, 172; 171, identifier:mn; 172, integer:0; 173, float:.001; 174, expression_statement; 174, 175; 175, augmented_assignment:+=; 175, 176; 175, 177; 176, identifier:mx; 177, conditional_expression:if; 177, 178; 177, 184; 177, 187; 178, binary_operator:*; 178, 179; 178, 180; 179, float:.001; 180, call; 180, 181; 180, 182; 181, identifier:abs; 182, argument_list; 182, 183; 183, identifier:mx; 184, comparison_operator:!=; 184, 185; 184, 186; 185, identifier:mx; 186, integer:0; 187, float:.001; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:bins; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:np; 194, identifier:linspace; 195, argument_list; 195, 196; 195, 197; 195, 198; 195, 201; 196, identifier:mn; 197, identifier:mx; 198, binary_operator:+; 198, 199; 198, 200; 199, identifier:bins; 200, integer:1; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:endpoint; 203, True; 204, else_clause; 204, 205; 205, block; 205, 206; 205, 222; 205, 231; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:bins; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:np; 212, identifier:linspace; 213, argument_list; 213, 214; 213, 215; 213, 216; 213, 219; 214, identifier:mn; 215, identifier:mx; 216, binary_operator:+; 216, 217; 216, 218; 217, identifier:bins; 218, integer:1; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:endpoint; 221, True; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:adj; 225, binary_operator:*; 225, 226; 225, 230; 226, parenthesized_expression; 226, 227; 227, binary_operator:-; 227, 228; 227, 229; 228, identifier:mx; 229, identifier:mn; 230, float:0.001; 231, if_statement; 231, 232; 231, 233; 231, 240; 232, identifier:right; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, augmented_assignment:-=; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:bins; 238, integer:0; 239, identifier:adj; 240, else_clause; 240, 241; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, augmented_assignment:+=; 243, 244; 243, 248; 244, subscript; 244, 245; 244, 246; 245, identifier:bins; 246, unary_operator:-; 246, 247; 247, integer:1; 248, identifier:adj; 249, elif_clause; 249, 250; 249, 255; 250, call; 250, 251; 250, 252; 251, identifier:isinstance; 252, argument_list; 252, 253; 252, 254; 253, identifier:bins; 254, identifier:IntervalIndex; 255, block; 255, 256; 256, if_statement; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:bins; 259, identifier:is_overlapping; 260, block; 260, 261; 261, raise_statement; 261, 262; 262, call; 262, 263; 262, 264; 263, identifier:ValueError; 264, argument_list; 264, 265; 265, string:'Overlapping IntervalIndex is not accepted.'; 266, else_clause; 266, 267; 267, block; 267, 268; 267, 297; 267, 305; 268, if_statement; 268, 269; 268, 273; 268, 286; 269, call; 269, 270; 269, 271; 270, identifier:is_datetime64tz_dtype; 271, argument_list; 271, 272; 272, identifier:bins; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:bins; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:np; 280, identifier:asarray; 281, argument_list; 281, 282; 281, 283; 282, identifier:bins; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:dtype; 285, identifier:_NS_DTYPE; 286, else_clause; 286, 287; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:bins; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:np; 294, identifier:asarray; 295, argument_list; 295, 296; 296, identifier:bins; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:bins; 300, call; 300, 301; 300, 302; 301, identifier:_convert_bin_to_numeric_type; 302, argument_list; 302, 303; 302, 304; 303, identifier:bins; 304, identifier:dtype; 305, if_statement; 305, 306; 305, 324; 306, call; 306, 307; 306, 323; 307, attribute; 307, 308; 307, 322; 308, parenthesized_expression; 308, 309; 309, comparison_operator:<; 309, 310; 309, 321; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:np; 313, identifier:diff; 314, argument_list; 314, 315; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:bins; 318, identifier:astype; 319, argument_list; 319, 320; 320, string:'float64'; 321, integer:0; 322, identifier:any; 323, argument_list; 324, block; 324, 325; 325, raise_statement; 325, 326; 326, call; 326, 327; 326, 328; 327, identifier:ValueError; 328, argument_list; 328, 329; 329, string:'bins must increase monotonically.'; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 335; 332, pattern_list; 332, 333; 332, 334; 333, identifier:fac; 334, identifier:bins; 335, call; 335, 336; 335, 337; 336, identifier:_bins_to_cuts; 337, argument_list; 337, 338; 337, 339; 337, 340; 337, 343; 337, 346; 337, 349; 337, 352; 337, 355; 338, identifier:x; 339, identifier:bins; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:right; 342, identifier:right; 343, keyword_argument; 343, 344; 343, 345; 344, identifier:labels; 345, identifier:labels; 346, keyword_argument; 346, 347; 346, 348; 347, identifier:precision; 348, identifier:precision; 349, keyword_argument; 349, 350; 349, 351; 350, identifier:include_lowest; 351, identifier:include_lowest; 352, keyword_argument; 352, 353; 352, 354; 353, identifier:dtype; 354, identifier:dtype; 355, keyword_argument; 355, 356; 355, 357; 356, identifier:duplicates; 357, identifier:duplicates; 358, return_statement; 358, 359; 359, call; 359, 360; 359, 361; 360, identifier:_postprocess_for_cut; 361, argument_list; 361, 362; 361, 363; 361, 364; 361, 365; 361, 366; 361, 367; 361, 368; 362, identifier:fac; 363, identifier:bins; 364, identifier:retbins; 365, identifier:x_is_series; 366, identifier:series_index; 367, identifier:name; 368, identifier:dtype | def cut(x, bins, right=True, labels=None, retbins=False, precision=3,
include_lowest=False, duplicates='raise'):
x_is_series, series_index, name, x = _preprocess_for_cut(x)
x, dtype = _coerce_to_type(x)
if not np.iterable(bins):
if is_scalar(bins) and bins < 1:
raise ValueError("`bins` should be a positive integer.")
try:
sz = x.size
except AttributeError:
x = np.asarray(x)
sz = x.size
if sz == 0:
raise ValueError('Cannot cut empty array')
rng = (nanops.nanmin(x), nanops.nanmax(x))
mn, mx = [mi + 0.0 for mi in rng]
if np.isinf(mn) or np.isinf(mx):
raise ValueError('cannot specify integer `bins` when input data '
'contains infinity')
elif mn == mx:
mn -= .001 * abs(mn) if mn != 0 else .001
mx += .001 * abs(mx) if mx != 0 else .001
bins = np.linspace(mn, mx, bins + 1, endpoint=True)
else:
bins = np.linspace(mn, mx, bins + 1, endpoint=True)
adj = (mx - mn) * 0.001
if right:
bins[0] -= adj
else:
bins[-1] += adj
elif isinstance(bins, IntervalIndex):
if bins.is_overlapping:
raise ValueError('Overlapping IntervalIndex is not accepted.')
else:
if is_datetime64tz_dtype(bins):
bins = np.asarray(bins, dtype=_NS_DTYPE)
else:
bins = np.asarray(bins)
bins = _convert_bin_to_numeric_type(bins, dtype)
if (np.diff(bins.astype('float64')) < 0).any():
raise ValueError('bins must increase monotonically.')
fac, bins = _bins_to_cuts(x, bins, right=right, labels=labels,
precision=precision,
include_lowest=include_lowest,
dtype=dtype,
duplicates=duplicates)
return _postprocess_for_cut(fac, bins, retbins, x_is_series,
series_index, name, dtype) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:union_categoricals; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:to_union; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_categories; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ignore_order; 10, False; 11, block; 11, 12; 11, 23; 11, 31; 11, 44; 11, 78; 11, 89; 11, 95; 11, 126; 11, 130; 11, 412; 11, 419; 12, import_from_statement; 12, 13; 12, 15; 12, 17; 12, 19; 12, 21; 13, dotted_name; 13, 14; 14, identifier:pandas; 15, dotted_name; 15, 16; 16, identifier:Index; 17, dotted_name; 17, 18; 18, identifier:Categorical; 19, dotted_name; 19, 20; 20, identifier:CategoricalIndex; 21, dotted_name; 21, 22; 22, identifier:Series; 23, import_from_statement; 23, 24; 23, 29; 24, dotted_name; 24, 25; 24, 26; 24, 27; 24, 28; 25, identifier:pandas; 26, identifier:core; 27, identifier:arrays; 28, identifier:categorical; 29, dotted_name; 29, 30; 30, identifier:_recode_for_categories; 31, if_statement; 31, 32; 31, 38; 32, comparison_operator:==; 32, 33; 32, 37; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:to_union; 37, integer:0; 38, block; 38, 39; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:ValueError; 42, argument_list; 42, 43; 43, string:'No Categoricals to union'; 44, function_definition; 44, 45; 44, 46; 44, 48; 45, function_name:_maybe_unwrap; 46, parameters; 46, 47; 47, identifier:x; 48, block; 48, 49; 49, if_statement; 49, 50; 49, 57; 49, 62; 49, 71; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:x; 54, tuple; 54, 55; 54, 56; 55, identifier:CategoricalIndex; 56, identifier:Series; 57, block; 57, 58; 58, return_statement; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:x; 61, identifier:values; 62, elif_clause; 62, 63; 62, 68; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:x; 67, identifier:Categorical; 68, block; 68, 69; 69, return_statement; 69, 70; 70, identifier:x; 71, else_clause; 71, 72; 72, block; 72, 73; 73, raise_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:TypeError; 76, argument_list; 76, 77; 77, string:"all components to combine must be Categorical"; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:to_union; 81, list_comprehension; 81, 82; 81, 86; 82, call; 82, 83; 82, 84; 83, identifier:_maybe_unwrap; 84, argument_list; 84, 85; 85, identifier:x; 86, for_in_clause; 86, 87; 86, 88; 87, identifier:x; 88, identifier:to_union; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:first; 92, subscript; 92, 93; 92, 94; 93, identifier:to_union; 94, integer:0; 95, if_statement; 95, 96; 95, 120; 96, not_operator; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:all; 99, generator_expression; 99, 100; 99, 113; 100, call; 100, 101; 100, 102; 101, identifier:is_dtype_equal; 102, argument_list; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:other; 106, identifier:categories; 107, identifier:dtype; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:first; 111, identifier:categories; 112, identifier:dtype; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:other; 115, subscript; 115, 116; 115, 117; 116, identifier:to_union; 117, slice; 117, 118; 117, 119; 118, integer:1; 119, colon; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:TypeError; 124, argument_list; 124, 125; 125, string:"dtype of categories must be the same"; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:ordered; 129, False; 130, if_statement; 130, 131; 130, 147; 130, 297; 130, 380; 131, call; 131, 132; 131, 133; 132, identifier:all; 133, generator_expression; 133, 134; 133, 140; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:first; 137, identifier:is_dtype_equal; 138, argument_list; 138, 139; 139, identifier:other; 140, for_in_clause; 140, 141; 140, 142; 141, identifier:other; 142, subscript; 142, 143; 142, 144; 143, identifier:to_union; 144, slice; 144, 145; 144, 146; 145, integer:1; 146, colon; 147, block; 147, 148; 147, 154; 147, 160; 147, 236; 147, 251; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:categories; 151, attribute; 151, 152; 151, 153; 152, identifier:first; 153, identifier:categories; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:ordered; 157, attribute; 157, 158; 157, 159; 158, identifier:first; 159, identifier:ordered; 160, if_statement; 160, 161; 160, 181; 160, 197; 161, call; 161, 162; 161, 163; 162, identifier:all; 163, generator_expression; 163, 164; 163, 174; 164, call; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:first; 168, identifier:categories; 169, identifier:equals; 170, argument_list; 170, 171; 171, attribute; 171, 172; 171, 173; 172, identifier:other; 173, identifier:categories; 174, for_in_clause; 174, 175; 174, 176; 175, identifier:other; 176, subscript; 176, 177; 176, 178; 177, identifier:to_union; 178, slice; 178, 179; 178, 180; 179, integer:1; 180, colon; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:new_codes; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:np; 188, identifier:concatenate; 189, argument_list; 189, 190; 190, list_comprehension; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:c; 193, identifier:codes; 194, for_in_clause; 194, 195; 194, 196; 195, identifier:c; 196, identifier:to_union; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 227; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:codes; 202, binary_operator:+; 202, 203; 202, 207; 203, list:[first.codes]; 203, 204; 204, attribute; 204, 205; 204, 206; 205, identifier:first; 206, identifier:codes; 207, list_comprehension; 207, 208; 207, 220; 208, call; 208, 209; 208, 210; 209, identifier:_recode_for_categories; 210, argument_list; 210, 211; 210, 214; 210, 217; 211, attribute; 211, 212; 211, 213; 212, identifier:other; 213, identifier:codes; 214, attribute; 214, 215; 214, 216; 215, identifier:other; 216, identifier:categories; 217, attribute; 217, 218; 217, 219; 218, identifier:first; 219, identifier:categories; 220, for_in_clause; 220, 221; 220, 222; 221, identifier:other; 222, subscript; 222, 223; 222, 224; 223, identifier:to_union; 224, slice; 224, 225; 224, 226; 225, integer:1; 226, colon; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:new_codes; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:np; 233, identifier:concatenate; 234, argument_list; 234, 235; 235, identifier:codes; 236, if_statement; 236, 237; 236, 243; 237, boolean_operator:and; 237, 238; 237, 242; 238, boolean_operator:and; 238, 239; 238, 240; 239, identifier:sort_categories; 240, not_operator; 240, 241; 241, identifier:ignore_order; 242, identifier:ordered; 243, block; 243, 244; 244, raise_statement; 244, 245; 245, call; 245, 246; 245, 247; 246, identifier:TypeError; 247, argument_list; 247, 248; 248, concatenated_string; 248, 249; 248, 250; 249, string:"Cannot use sort_categories=True with "; 250, string:"ordered Categoricals"; 251, if_statement; 251, 252; 251, 258; 252, boolean_operator:and; 252, 253; 252, 254; 253, identifier:sort_categories; 254, not_operator; 254, 255; 255, attribute; 255, 256; 255, 257; 256, identifier:categories; 257, identifier:is_monotonic_increasing; 258, block; 258, 259; 258, 267; 258, 278; 258, 285; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:categories; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:categories; 265, identifier:sort_values; 266, argument_list; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:indexer; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:categories; 273, identifier:get_indexer; 274, argument_list; 274, 275; 275, attribute; 275, 276; 275, 277; 276, identifier:first; 277, identifier:categories; 278, import_from_statement; 278, 279; 278, 283; 279, dotted_name; 279, 280; 279, 281; 279, 282; 280, identifier:pandas; 281, identifier:core; 282, identifier:algorithms; 283, dotted_name; 283, 284; 284, identifier:take_1d; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:new_codes; 288, call; 288, 289; 288, 290; 289, identifier:take_1d; 290, argument_list; 290, 291; 290, 292; 290, 293; 291, identifier:indexer; 292, identifier:new_codes; 293, keyword_argument; 293, 294; 293, 295; 294, identifier:fill_value; 295, unary_operator:-; 295, 296; 296, integer:1; 297, elif_clause; 297, 298; 297, 310; 298, boolean_operator:or; 298, 299; 298, 300; 299, identifier:ignore_order; 300, call; 300, 301; 300, 302; 301, identifier:all; 302, generator_expression; 302, 303; 302, 307; 303, not_operator; 303, 304; 304, attribute; 304, 305; 304, 306; 305, identifier:c; 306, identifier:ordered; 307, for_in_clause; 307, 308; 307, 309; 308, identifier:c; 309, identifier:to_union; 310, block; 310, 311; 310, 332; 310, 343; 310, 354; 310, 371; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:cats; 314, call; 314, 315; 314, 320; 315, attribute; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:first; 318, identifier:categories; 319, identifier:append; 320, argument_list; 320, 321; 321, list_comprehension; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:c; 324, identifier:categories; 325, for_in_clause; 325, 326; 325, 327; 326, identifier:c; 327, subscript; 327, 328; 327, 329; 328, identifier:to_union; 329, slice; 329, 330; 329, 331; 330, integer:1; 331, colon; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:categories; 335, call; 335, 336; 335, 337; 336, identifier:Index; 337, argument_list; 337, 338; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:cats; 341, identifier:unique; 342, argument_list; 343, if_statement; 343, 344; 343, 345; 344, identifier:sort_categories; 345, block; 345, 346; 346, expression_statement; 346, 347; 347, assignment; 347, 348; 347, 349; 348, identifier:categories; 349, call; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:categories; 352, identifier:sort_values; 353, argument_list; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 357; 356, identifier:new_codes; 357, list_comprehension; 357, 358; 357, 368; 358, call; 358, 359; 358, 360; 359, identifier:_recode_for_categories; 360, argument_list; 360, 361; 360, 364; 360, 367; 361, attribute; 361, 362; 361, 363; 362, identifier:c; 363, identifier:codes; 364, attribute; 364, 365; 364, 366; 365, identifier:c; 366, identifier:categories; 367, identifier:categories; 368, for_in_clause; 368, 369; 368, 370; 369, identifier:c; 370, identifier:to_union; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 374; 373, identifier:new_codes; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:np; 377, identifier:concatenate; 378, argument_list; 378, 379; 379, identifier:new_codes; 380, else_clause; 380, 381; 381, block; 381, 382; 382, if_statement; 382, 383; 382, 392; 382, 405; 383, call; 383, 384; 383, 385; 384, identifier:all; 385, generator_expression; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:c; 388, identifier:ordered; 389, for_in_clause; 389, 390; 389, 391; 390, identifier:c; 391, identifier:to_union; 392, block; 392, 393; 392, 400; 393, expression_statement; 393, 394; 394, assignment; 394, 395; 394, 396; 395, identifier:msg; 396, parenthesized_expression; 396, 397; 397, concatenated_string; 397, 398; 397, 399; 398, string:"to union ordered Categoricals, "; 399, string:"all categories must be the same"; 400, raise_statement; 400, 401; 401, call; 401, 402; 401, 403; 402, identifier:TypeError; 403, argument_list; 403, 404; 404, identifier:msg; 405, else_clause; 405, 406; 406, block; 406, 407; 407, raise_statement; 407, 408; 408, call; 408, 409; 408, 410; 409, identifier:TypeError; 410, argument_list; 410, 411; 411, string:'Categorical.ordered must be the same'; 412, if_statement; 412, 413; 412, 414; 413, identifier:ignore_order; 414, block; 414, 415; 415, expression_statement; 415, 416; 416, assignment; 416, 417; 416, 418; 417, identifier:ordered; 418, False; 419, return_statement; 419, 420; 420, call; 420, 421; 420, 422; 421, identifier:Categorical; 422, argument_list; 422, 423; 422, 424; 422, 427; 422, 430; 423, identifier:new_codes; 424, keyword_argument; 424, 425; 424, 426; 425, identifier:categories; 426, identifier:categories; 427, keyword_argument; 427, 428; 427, 429; 428, identifier:ordered; 429, identifier:ordered; 430, keyword_argument; 430, 431; 430, 432; 431, identifier:fastpath; 432, True | def union_categoricals(to_union, sort_categories=False, ignore_order=False):
from pandas import Index, Categorical, CategoricalIndex, Series
from pandas.core.arrays.categorical import _recode_for_categories
if len(to_union) == 0:
raise ValueError('No Categoricals to union')
def _maybe_unwrap(x):
if isinstance(x, (CategoricalIndex, Series)):
return x.values
elif isinstance(x, Categorical):
return x
else:
raise TypeError("all components to combine must be Categorical")
to_union = [_maybe_unwrap(x) for x in to_union]
first = to_union[0]
if not all(is_dtype_equal(other.categories.dtype, first.categories.dtype)
for other in to_union[1:]):
raise TypeError("dtype of categories must be the same")
ordered = False
if all(first.is_dtype_equal(other) for other in to_union[1:]):
categories = first.categories
ordered = first.ordered
if all(first.categories.equals(other.categories)
for other in to_union[1:]):
new_codes = np.concatenate([c.codes for c in to_union])
else:
codes = [first.codes] + [_recode_for_categories(other.codes,
other.categories,
first.categories)
for other in to_union[1:]]
new_codes = np.concatenate(codes)
if sort_categories and not ignore_order and ordered:
raise TypeError("Cannot use sort_categories=True with "
"ordered Categoricals")
if sort_categories and not categories.is_monotonic_increasing:
categories = categories.sort_values()
indexer = categories.get_indexer(first.categories)
from pandas.core.algorithms import take_1d
new_codes = take_1d(indexer, new_codes, fill_value=-1)
elif ignore_order or all(not c.ordered for c in to_union):
cats = first.categories.append([c.categories for c in to_union[1:]])
categories = Index(cats.unique())
if sort_categories:
categories = categories.sort_values()
new_codes = [_recode_for_categories(c.codes, c.categories, categories)
for c in to_union]
new_codes = np.concatenate(new_codes)
else:
if all(c.ordered for c in to_union):
msg = ("to union ordered Categoricals, "
"all categories must be the same")
raise TypeError(msg)
else:
raise TypeError('Categorical.ordered must be the same')
if ignore_order:
ordered = False
return Categorical(new_codes, categories=categories, ordered=ordered,
fastpath=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 13; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ascending; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:kind; 10, string:'quicksort'; 11, list_splat_pattern; 11, 12; 12, identifier:args; 13, dictionary_splat_pattern; 13, 14; 14, identifier:kwargs; 15, block; 15, 16; 15, 27; 15, 35; 15, 49; 15, 63; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:ascending; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:nv; 22, identifier:validate_argsort_with_ascending; 23, argument_list; 23, 24; 23, 25; 23, 26; 24, identifier:ascending; 25, identifier:args; 26, identifier:kwargs; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:values; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_values_for_argsort; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:result; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:np; 41, identifier:argsort; 42, argument_list; 42, 43; 42, 44; 42, 47; 43, identifier:values; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:kind; 46, identifier:kind; 47, dictionary_splat; 47, 48; 48, identifier:kwargs; 49, if_statement; 49, 50; 49, 52; 50, not_operator; 50, 51; 51, identifier:ascending; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:result; 56, subscript; 56, 57; 56, 58; 57, identifier:result; 58, slice; 58, 59; 58, 60; 58, 61; 59, colon; 60, colon; 61, unary_operator:-; 61, 62; 62, integer:1; 63, return_statement; 63, 64; 64, identifier:result | def argsort(self, ascending=True, kind='quicksort', *args, **kwargs):
ascending = nv.validate_argsort_with_ascending(ascending, args, kwargs)
values = self._values_for_argsort()
result = np.argsort(values, kind=kind, **kwargs)
if not ascending:
result = result[::-1]
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 1, 21; 2, function_name:factorize; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:na_sentinel; 7, type; 7, 8; 8, identifier:int; 9, unary_operator:-; 9, 10; 10, integer:1; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:Tuple; 14, type_parameter; 14, 15; 14, 19; 15, type; 15, 16; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:ndarray; 19, type; 19, 20; 20, identifier:ABCExtensionArray; 21, block; 21, 22; 21, 29; 21, 39; 21, 54; 21, 64; 22, import_from_statement; 22, 23; 22, 27; 23, dotted_name; 23, 24; 23, 25; 23, 26; 24, identifier:pandas; 25, identifier:core; 26, identifier:algorithms; 27, dotted_name; 27, 28; 28, identifier:_factorize_array; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, pattern_list; 31, 32; 31, 33; 32, identifier:arr; 33, identifier:na_value; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_values_for_factorize; 38, argument_list; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, pattern_list; 41, 42; 41, 43; 42, identifier:labels; 43, identifier:uniques; 44, call; 44, 45; 44, 46; 45, identifier:_factorize_array; 46, argument_list; 46, 47; 46, 48; 46, 51; 47, identifier:arr; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:na_sentinel; 50, identifier:na_sentinel; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:na_value; 53, identifier:na_value; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:uniques; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:_from_factorized; 61, argument_list; 61, 62; 61, 63; 62, identifier:uniques; 63, identifier:self; 64, return_statement; 64, 65; 65, expression_list; 65, 66; 65, 67; 66, identifier:labels; 67, identifier:uniques | def factorize(
self,
na_sentinel: int = -1,
) -> Tuple[np.ndarray, ABCExtensionArray]:
from pandas.core.algorithms import _factorize_array
arr, na_value = self._values_for_factorize()
labels, uniques = _factorize_array(arr, na_sentinel=na_sentinel,
na_value=na_value)
uniques = self._from_factorized(uniques, self)
return labels, uniques |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:return_indexer; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, block; 11, 12; 12, if_statement; 12, 13; 12, 14; 12, 50; 13, identifier:return_indexer; 14, block; 14, 15; 14, 23; 14, 37; 14, 46; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:_as; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:argsort; 22, argument_list; 23, if_statement; 23, 24; 23, 26; 24, not_operator; 24, 25; 25, identifier:ascending; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:_as; 30, subscript; 30, 31; 30, 32; 31, identifier:_as; 32, slice; 32, 33; 32, 34; 32, 35; 33, colon; 34, colon; 35, unary_operator:-; 35, 36; 36, integer:1; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:sorted_index; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:take; 44, argument_list; 44, 45; 45, identifier:_as; 46, return_statement; 46, 47; 47, expression_list; 47, 48; 47, 49; 48, identifier:sorted_index; 49, identifier:_as; 50, else_clause; 50, 51; 51, block; 51, 52; 51, 63; 51, 71; 51, 77; 51, 121; 51, 127; 51, 141; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:sorted_values; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:np; 58, identifier:sort; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_ndarray_values; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:attribs; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:_get_attributes_dict; 70, argument_list; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:freq; 74, subscript; 74, 75; 74, 76; 75, identifier:attribs; 76, string:'freq'; 77, if_statement; 77, 78; 77, 87; 78, boolean_operator:and; 78, 79; 78, 82; 79, comparison_operator:is; 79, 80; 79, 81; 80, identifier:freq; 81, None; 82, not_operator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:is_period_dtype; 85, argument_list; 85, 86; 86, identifier:self; 87, block; 87, 88; 88, if_statement; 88, 89; 88, 97; 88, 105; 89, boolean_operator:and; 89, 90; 89, 95; 90, comparison_operator:>; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:freq; 93, identifier:n; 94, integer:0; 95, not_operator; 95, 96; 96, identifier:ascending; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:freq; 101, binary_operator:*; 101, 102; 101, 103; 102, identifier:freq; 103, unary_operator:-; 103, 104; 104, integer:1; 105, elif_clause; 105, 106; 105, 113; 106, boolean_operator:and; 106, 107; 106, 112; 107, comparison_operator:<; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:freq; 110, identifier:n; 111, integer:0; 112, identifier:ascending; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:freq; 117, binary_operator:*; 117, 118; 117, 119; 118, identifier:freq; 119, unary_operator:-; 119, 120; 120, integer:1; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:attribs; 125, string:'freq'; 126, identifier:freq; 127, if_statement; 127, 128; 127, 130; 128, not_operator; 128, 129; 129, identifier:ascending; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:sorted_values; 134, subscript; 134, 135; 134, 136; 135, identifier:sorted_values; 136, slice; 136, 137; 136, 138; 136, 139; 137, colon; 138, colon; 139, unary_operator:-; 139, 140; 140, integer:1; 141, return_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_simple_new; 146, argument_list; 146, 147; 146, 148; 147, identifier:sorted_values; 148, dictionary_splat; 148, 149; 149, identifier:attribs | def sort_values(self, return_indexer=False, ascending=True):
if return_indexer:
_as = self.argsort()
if not ascending:
_as = _as[::-1]
sorted_index = self.take(_as)
return sorted_index, _as
else:
sorted_values = np.sort(self._ndarray_values)
attribs = self._get_attributes_dict()
freq = attribs['freq']
if freq is not None and not is_period_dtype(self):
if freq.n > 0 and not ascending:
freq = freq * -1
elif freq.n < 0 and ascending:
freq = freq * -1
attribs['freq'] = freq
if not ascending:
sorted_values = sorted_values[::-1]
return self._simple_new(sorted_values, **attribs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:axis; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:inplace; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:kind; 19, string:'quicksort'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:na_position; 22, string:'last'; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:NotImplementedError; 27, argument_list; 27, 28; 28, concatenated_string; 28, 29; 28, 30; 29, string:"sort_values has not been implemented "; 30, string:"on Panel or Panel4D objects." | def sort_values(self, by=None, axis=0, ascending=True, inplace=False,
kind='quicksort', na_position='last'):
raise NotImplementedError("sort_values has not been implemented "
"on Panel or Panel4D objects.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 31; 2, function_name:groupby; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:axis; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:level; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:as_index; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:sort; 19, True; 20, default_parameter; 20, 21; 20, 22; 21, identifier:group_keys; 22, True; 23, default_parameter; 23, 24; 23, 25; 24, identifier:squeeze; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:observed; 28, False; 29, dictionary_splat_pattern; 29, 30; 30, identifier:kwargs; 31, block; 31, 32; 31, 40; 31, 54; 31, 63; 32, import_from_statement; 32, 33; 32, 38; 33, dotted_name; 33, 34; 33, 35; 33, 36; 33, 37; 34, identifier:pandas; 35, identifier:core; 36, identifier:groupby; 37, identifier:groupby; 38, dotted_name; 38, 39; 39, identifier:groupby; 40, if_statement; 40, 41; 40, 48; 41, boolean_operator:and; 41, 42; 41, 45; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:level; 44, None; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:by; 47, None; 48, block; 48, 49; 49, raise_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:TypeError; 52, argument_list; 52, 53; 53, string:"You have to supply one of 'by' and 'level'"; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:axis; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:_get_axis_number; 61, argument_list; 61, 62; 62, identifier:axis; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:groupby; 66, argument_list; 66, 67; 66, 68; 66, 71; 66, 74; 66, 77; 66, 80; 66, 83; 66, 86; 66, 89; 66, 92; 67, identifier:self; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:by; 70, identifier:by; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:axis; 73, identifier:axis; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:level; 76, identifier:level; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:as_index; 79, identifier:as_index; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:sort; 82, identifier:sort; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:group_keys; 85, identifier:group_keys; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:squeeze; 88, identifier:squeeze; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:observed; 91, identifier:observed; 92, dictionary_splat; 92, 93; 93, identifier:kwargs | def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True,
group_keys=True, squeeze=False, observed=False, **kwargs):
from pandas.core.groupby.groupby import groupby
if level is None and by is None:
raise TypeError("You have to supply one of 'by' and 'level'")
axis = self._get_axis_number(axis)
return groupby(self, by=by, axis=axis, level=level, as_index=as_index,
sort=sort, group_keys=group_keys, squeeze=squeeze,
observed=observed, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:inplace; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:kind; 16, string:'quicksort'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:na_position; 19, string:'last'; 20, block; 20, 21; 20, 29; 20, 36; 20, 50; 20, 78; 20, 84; 20, 101; 20, 108; 20, 113; 20, 125; 20, 134; 20, 167; 20, 179; 20, 193; 20, 275; 20, 293; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:inplace; 24, call; 24, 25; 24, 26; 25, identifier:validate_bool_kwarg; 26, argument_list; 26, 27; 26, 28; 27, identifier:inplace; 28, string:'inplace'; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_get_axis_number; 34, argument_list; 34, 35; 35, identifier:axis; 36, if_statement; 36, 37; 36, 42; 37, boolean_operator:and; 37, 38; 37, 39; 38, identifier:inplace; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_is_cached; 42, block; 42, 43; 43, raise_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:ValueError; 46, argument_list; 46, 47; 47, concatenated_string; 47, 48; 47, 49; 48, string:"This Series is a view of some other array, to "; 49, string:"sort in-place you must create a copy"; 50, function_definition; 50, 51; 50, 52; 50, 54; 51, function_name:_try_kind_sort; 52, parameters; 52, 53; 53, identifier:arr; 54, block; 54, 55; 55, try_statement; 55, 56; 55, 66; 56, block; 56, 57; 57, return_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:arr; 61, identifier:argsort; 62, argument_list; 62, 63; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:kind; 65, identifier:kind; 66, except_clause; 66, 67; 66, 68; 67, identifier:TypeError; 68, block; 68, 69; 69, return_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:arr; 73, identifier:argsort; 74, argument_list; 74, 75; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:kind; 77, string:'quicksort'; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:arr; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_values; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:sortedIdx; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:empty; 91, argument_list; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, identifier:self; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:dtype; 98, attribute; 98, 99; 98, 100; 99, identifier:np; 100, identifier:int32; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:bad; 104, call; 104, 105; 104, 106; 105, identifier:isna; 106, argument_list; 106, 107; 107, identifier:arr; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:good; 111, unary_operator:~; 111, 112; 112, identifier:bad; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:idx; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:ibase; 119, identifier:default_index; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:len; 123, argument_list; 123, 124; 124, identifier:self; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:argsorted; 128, call; 128, 129; 128, 130; 129, identifier:_try_kind_sort; 130, argument_list; 130, 131; 131, subscript; 131, 132; 131, 133; 132, identifier:arr; 133, identifier:good; 134, if_statement; 134, 135; 134, 139; 135, call; 135, 136; 135, 137; 136, identifier:is_list_like; 137, argument_list; 137, 138; 138, identifier:ascending; 139, block; 139, 140; 139, 161; 140, if_statement; 140, 141; 140, 147; 141, comparison_operator:!=; 141, 142; 141, 146; 142, call; 142, 143; 142, 144; 143, identifier:len; 144, argument_list; 144, 145; 145, identifier:ascending; 146, integer:1; 147, block; 147, 148; 148, raise_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:ValueError; 151, argument_list; 151, 152; 152, binary_operator:%; 152, 153; 152, 156; 153, concatenated_string; 153, 154; 153, 155; 154, string:'Length of ascending (%d) must be 1 '; 155, string:'for Series'; 156, parenthesized_expression; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:len; 159, argument_list; 159, 160; 160, identifier:ascending; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:ascending; 164, subscript; 164, 165; 164, 166; 165, identifier:ascending; 166, integer:0; 167, if_statement; 167, 168; 167, 173; 168, not_operator; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:is_bool; 171, argument_list; 171, 172; 172, identifier:ascending; 173, block; 173, 174; 174, raise_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:ValueError; 177, argument_list; 177, 178; 178, string:'ascending must be boolean'; 179, if_statement; 179, 180; 179, 182; 180, not_operator; 180, 181; 181, identifier:ascending; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:argsorted; 186, subscript; 186, 187; 186, 188; 187, identifier:argsorted; 188, slice; 188, 189; 188, 190; 188, 191; 189, colon; 190, colon; 191, unary_operator:-; 191, 192; 192, integer:1; 193, if_statement; 193, 194; 193, 197; 193, 228; 193, 263; 194, comparison_operator:==; 194, 195; 194, 196; 195, identifier:na_position; 196, string:'last'; 197, block; 197, 198; 197, 206; 197, 218; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:n; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:good; 204, identifier:sum; 205, argument_list; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 213; 208, subscript; 208, 209; 208, 210; 209, identifier:sortedIdx; 210, slice; 210, 211; 210, 212; 211, colon; 212, identifier:n; 213, subscript; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:idx; 216, identifier:good; 217, identifier:argsorted; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 225; 220, subscript; 220, 221; 220, 222; 221, identifier:sortedIdx; 222, slice; 222, 223; 222, 224; 223, identifier:n; 224, colon; 225, subscript; 225, 226; 225, 227; 226, identifier:idx; 227, identifier:bad; 228, elif_clause; 228, 229; 228, 232; 229, comparison_operator:==; 229, 230; 229, 231; 230, identifier:na_position; 231, string:'first'; 232, block; 232, 233; 232, 241; 232, 253; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:n; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:bad; 239, identifier:sum; 240, argument_list; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 248; 243, subscript; 243, 244; 243, 245; 244, identifier:sortedIdx; 245, slice; 245, 246; 245, 247; 246, identifier:n; 247, colon; 248, subscript; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:idx; 251, identifier:good; 252, identifier:argsorted; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 260; 255, subscript; 255, 256; 255, 257; 256, identifier:sortedIdx; 257, slice; 257, 258; 257, 259; 258, colon; 259, identifier:n; 260, subscript; 260, 261; 260, 262; 261, identifier:idx; 262, identifier:bad; 263, else_clause; 263, 264; 264, block; 264, 265; 265, raise_statement; 265, 266; 266, call; 266, 267; 266, 268; 267, identifier:ValueError; 268, argument_list; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, string:'invalid na_position: {!r}'; 272, identifier:format; 273, argument_list; 273, 274; 274, identifier:na_position; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:result; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:self; 281, identifier:_constructor; 282, argument_list; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:arr; 285, identifier:sortedIdx; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:index; 288, subscript; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:self; 291, identifier:index; 292, identifier:sortedIdx; 293, if_statement; 293, 294; 293, 295; 293, 303; 294, identifier:inplace; 295, block; 295, 296; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:self; 300, identifier:_update_inplace; 301, argument_list; 301, 302; 302, identifier:result; 303, else_clause; 303, 304; 304, block; 304, 305; 305, return_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:result; 309, identifier:__finalize__; 310, argument_list; 310, 311; 311, identifier:self | def sort_values(self, axis=0, ascending=True, inplace=False,
kind='quicksort', na_position='last'):
inplace = validate_bool_kwarg(inplace, 'inplace')
self._get_axis_number(axis)
if inplace and self._is_cached:
raise ValueError("This Series is a view of some other array, to "
"sort in-place you must create a copy")
def _try_kind_sort(arr):
try:
return arr.argsort(kind=kind)
except TypeError:
return arr.argsort(kind='quicksort')
arr = self._values
sortedIdx = np.empty(len(self), dtype=np.int32)
bad = isna(arr)
good = ~bad
idx = ibase.default_index(len(self))
argsorted = _try_kind_sort(arr[good])
if is_list_like(ascending):
if len(ascending) != 1:
raise ValueError('Length of ascending (%d) must be 1 '
'for Series' % (len(ascending)))
ascending = ascending[0]
if not is_bool(ascending):
raise ValueError('ascending must be boolean')
if not ascending:
argsorted = argsorted[::-1]
if na_position == 'last':
n = good.sum()
sortedIdx[:n] = idx[good][argsorted]
sortedIdx[n:] = idx[bad]
elif na_position == 'first':
n = bad.sum()
sortedIdx[n:] = idx[good][argsorted]
sortedIdx[:n] = idx[bad]
else:
raise ValueError('invalid na_position: {!r}'.format(na_position))
result = self._constructor(arr[sortedIdx], index=self.index[sortedIdx])
if inplace:
self._update_inplace(result)
else:
return result.__finalize__(self) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:sort_index; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:level; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:inplace; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:kind; 19, string:'quicksort'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:na_position; 22, string:'last'; 23, default_parameter; 23, 24; 23, 25; 24, identifier:sort_remaining; 25, True; 26, block; 26, 27; 26, 35; 26, 42; 26, 48; 26, 163; 26, 170; 26, 179; 26, 187; 26, 198; 26, 210; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:inplace; 30, call; 30, 31; 30, 32; 31, identifier:validate_bool_kwarg; 32, argument_list; 32, 33; 32, 34; 33, identifier:inplace; 34, string:'inplace'; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_get_axis_number; 40, argument_list; 40, 41; 41, identifier:axis; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:index; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:index; 48, if_statement; 48, 49; 48, 52; 48, 70; 48, 109; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:level; 51, None; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, pattern_list; 55, 56; 55, 57; 56, identifier:new_index; 57, identifier:indexer; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:index; 61, identifier:sortlevel; 62, argument_list; 62, 63; 62, 64; 62, 67; 63, identifier:level; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:ascending; 66, identifier:ascending; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:sort_remaining; 69, identifier:sort_remaining; 70, elif_clause; 70, 71; 70, 76; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:index; 75, identifier:MultiIndex; 76, block; 76, 77; 76, 84; 76, 92; 77, import_from_statement; 77, 78; 77, 82; 78, dotted_name; 78, 79; 78, 80; 78, 81; 79, identifier:pandas; 80, identifier:core; 81, identifier:sorting; 82, dotted_name; 82, 83; 83, identifier:lexsort_indexer; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:labels; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:index; 90, identifier:_sort_levels_monotonic; 91, argument_list; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:indexer; 95, call; 95, 96; 95, 97; 96, identifier:lexsort_indexer; 97, argument_list; 97, 98; 97, 103; 97, 106; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:labels; 101, identifier:_get_codes_for_sorting; 102, argument_list; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:orders; 105, identifier:ascending; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:na_position; 108, identifier:na_position; 109, else_clause; 109, 110; 110, block; 110, 111; 110, 118; 110, 147; 111, import_from_statement; 111, 112; 111, 116; 112, dotted_name; 112, 113; 112, 114; 112, 115; 113, identifier:pandas; 114, identifier:core; 115, identifier:sorting; 116, dotted_name; 116, 117; 117, identifier:nargsort; 118, if_statement; 118, 119; 118, 134; 119, parenthesized_expression; 119, 120; 120, boolean_operator:or; 120, 121; 120, 127; 121, parenthesized_expression; 121, 122; 122, boolean_operator:and; 122, 123; 122, 124; 123, identifier:ascending; 124, attribute; 124, 125; 124, 126; 125, identifier:index; 126, identifier:is_monotonic_increasing; 127, parenthesized_expression; 127, 128; 128, boolean_operator:and; 128, 129; 128, 131; 129, not_operator; 129, 130; 130, identifier:ascending; 131, attribute; 131, 132; 131, 133; 132, identifier:index; 133, identifier:is_monotonic_decreasing; 134, block; 134, 135; 135, if_statement; 135, 136; 135, 137; 135, 139; 136, identifier:inplace; 137, block; 137, 138; 138, return_statement; 139, else_clause; 139, 140; 140, block; 140, 141; 141, return_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:copy; 146, argument_list; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:indexer; 150, call; 150, 151; 150, 152; 151, identifier:nargsort; 152, argument_list; 152, 153; 152, 154; 152, 157; 152, 160; 153, identifier:index; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:kind; 156, identifier:kind; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:ascending; 159, identifier:ascending; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:na_position; 162, identifier:na_position; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:indexer; 166, call; 166, 167; 166, 168; 167, identifier:ensure_platform_int; 168, argument_list; 168, 169; 169, identifier:indexer; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:new_index; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:index; 176, identifier:take; 177, argument_list; 177, 178; 178, identifier:indexer; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:new_index; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:new_index; 185, identifier:_sort_levels_monotonic; 186, argument_list; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:new_values; 190, call; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:self; 194, identifier:_values; 195, identifier:take; 196, argument_list; 196, 197; 197, identifier:indexer; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:result; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:self; 204, identifier:_constructor; 205, argument_list; 205, 206; 205, 207; 206, identifier:new_values; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:index; 209, identifier:new_index; 210, if_statement; 210, 211; 210, 212; 210, 220; 211, identifier:inplace; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:self; 217, identifier:_update_inplace; 218, argument_list; 218, 219; 219, identifier:result; 220, else_clause; 220, 221; 221, block; 221, 222; 222, return_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:result; 226, identifier:__finalize__; 227, argument_list; 227, 228; 228, identifier:self | def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
kind='quicksort', na_position='last', sort_remaining=True):
inplace = validate_bool_kwarg(inplace, 'inplace')
self._get_axis_number(axis)
index = self.index
if level is not None:
new_index, indexer = index.sortlevel(level, ascending=ascending,
sort_remaining=sort_remaining)
elif isinstance(index, MultiIndex):
from pandas.core.sorting import lexsort_indexer
labels = index._sort_levels_monotonic()
indexer = lexsort_indexer(labels._get_codes_for_sorting(),
orders=ascending,
na_position=na_position)
else:
from pandas.core.sorting import nargsort
if ((ascending and index.is_monotonic_increasing) or
(not ascending and index.is_monotonic_decreasing)):
if inplace:
return
else:
return self.copy()
indexer = nargsort(index, kind=kind, ascending=ascending,
na_position=na_position)
indexer = ensure_platform_int(indexer)
new_index = index.take(indexer)
new_index = new_index._sort_levels_monotonic()
new_values = self._values.take(indexer)
result = self._constructor(new_values, index=new_index)
if inplace:
self._update_inplace(result)
else:
return result.__finalize__(self) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:nlargest; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:n; 7, integer:5; 8, default_parameter; 8, 9; 8, 10; 9, identifier:keep; 10, string:'first'; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 28; 14, attribute; 14, 15; 14, 27; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:algorithms; 18, identifier:SelectNSeries; 19, argument_list; 19, 20; 19, 21; 19, 24; 20, identifier:self; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:n; 23, identifier:n; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:keep; 26, identifier:keep; 27, identifier:nlargest; 28, argument_list | def nlargest(self, n=5, keep='first'):
return algorithms.SelectNSeries(self, n=n, keep=keep).nlargest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:nsmallest; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:n; 7, integer:5; 8, default_parameter; 8, 9; 8, 10; 9, identifier:keep; 10, string:'first'; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 28; 14, attribute; 14, 15; 14, 27; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:algorithms; 18, identifier:SelectNSeries; 19, argument_list; 19, 20; 19, 21; 19, 24; 20, identifier:self; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:n; 23, identifier:n; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:keep; 26, identifier:keep; 27, identifier:nsmallest; 28, argument_list | def nsmallest(self, n=5, keep='first'):
return algorithms.SelectNSeries(self, n=n, keep=keep).nsmallest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:searchsorted; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:value; 6, default_parameter; 6, 7; 6, 8; 7, identifier:side; 8, string:"left"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sorter; 11, None; 12, block; 12, 13; 12, 30; 13, try_statement; 13, 14; 13, 26; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:value; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:dtype; 23, identifier:type; 24, argument_list; 24, 25; 25, identifier:value; 26, except_clause; 26, 27; 26, 28; 27, identifier:ValueError; 28, block; 28, 29; 29, pass_statement; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, call; 33, 34; 33, 35; 34, identifier:super; 35, argument_list; 36, identifier:searchsorted; 37, argument_list; 37, 38; 37, 39; 37, 42; 38, identifier:value; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:side; 41, identifier:side; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:sorter; 44, identifier:sorter | def searchsorted(self, value, side="left", sorter=None):
try:
value = self.dtype.type(value)
except ValueError:
pass
return super().searchsorted(value, side=side, sorter=sorter) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_arrays; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:arrays; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 17; 12, 42; 12, 58; 12, 91; 12, 99; 12, 108; 12, 126; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:error_msg; 16, string:"Input must be a list / sequence of array-likes."; 17, if_statement; 17, 18; 17, 23; 17, 29; 18, not_operator; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:is_list_like; 21, argument_list; 21, 22; 22, identifier:arrays; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:TypeError; 27, argument_list; 27, 28; 28, identifier:error_msg; 29, elif_clause; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:is_iterator; 32, argument_list; 32, 33; 33, identifier:arrays; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:arrays; 38, call; 38, 39; 38, 40; 39, identifier:list; 40, argument_list; 40, 41; 41, identifier:arrays; 42, for_statement; 42, 43; 42, 44; 42, 45; 43, identifier:array; 44, identifier:arrays; 45, block; 45, 46; 46, if_statement; 46, 47; 46, 52; 47, not_operator; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:is_list_like; 50, argument_list; 50, 51; 51, identifier:array; 52, block; 52, 53; 53, raise_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:TypeError; 56, argument_list; 56, 57; 57, identifier:error_msg; 58, for_statement; 58, 59; 58, 60; 58, 68; 59, identifier:i; 60, call; 60, 61; 60, 62; 61, identifier:range; 62, argument_list; 62, 63; 62, 64; 63, integer:1; 64, call; 64, 65; 64, 66; 65, identifier:len; 66, argument_list; 66, 67; 67, identifier:arrays; 68, block; 68, 69; 69, if_statement; 69, 70; 69, 85; 70, comparison_operator:!=; 70, 71; 70, 77; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, subscript; 74, 75; 74, 76; 75, identifier:arrays; 76, identifier:i; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, subscript; 80, 81; 80, 82; 81, identifier:arrays; 82, binary_operator:-; 82, 83; 82, 84; 83, identifier:i; 84, integer:1; 85, block; 85, 86; 86, raise_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:ValueError; 89, argument_list; 89, 90; 90, string:'all arrays must be same length'; 91, import_from_statement; 91, 92; 91, 97; 92, dotted_name; 92, 93; 92, 94; 92, 95; 92, 96; 93, identifier:pandas; 94, identifier:core; 95, identifier:arrays; 96, identifier:categorical; 97, dotted_name; 97, 98; 98, identifier:_factorize_from_iterables; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 104; 101, pattern_list; 101, 102; 101, 103; 102, identifier:codes; 103, identifier:levels; 104, call; 104, 105; 104, 106; 105, identifier:_factorize_from_iterables; 106, argument_list; 106, 107; 107, identifier:arrays; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:names; 111, None; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:names; 116, list_comprehension; 116, 117; 116, 123; 117, call; 117, 118; 117, 119; 118, identifier:getattr; 119, argument_list; 119, 120; 119, 121; 119, 122; 120, identifier:arr; 121, string:"name"; 122, None; 123, for_in_clause; 123, 124; 123, 125; 124, identifier:arr; 125, identifier:arrays; 126, return_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:MultiIndex; 129, argument_list; 129, 130; 129, 133; 129, 136; 129, 139; 129, 142; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:levels; 132, identifier:levels; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:codes; 135, identifier:codes; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:sortorder; 138, identifier:sortorder; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:names; 141, identifier:names; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:verify_integrity; 144, False | def from_arrays(cls, arrays, sortorder=None, names=None):
error_msg = "Input must be a list / sequence of array-likes."
if not is_list_like(arrays):
raise TypeError(error_msg)
elif is_iterator(arrays):
arrays = list(arrays)
for array in arrays:
if not is_list_like(array):
raise TypeError(error_msg)
for i in range(1, len(arrays)):
if len(arrays[i]) != len(arrays[i - 1]):
raise ValueError('all arrays must be same length')
from pandas.core.arrays.categorical import _factorize_from_iterables
codes, levels = _factorize_from_iterables(arrays)
if names is None:
names = [getattr(arr, "name", None) for arr in arrays]
return MultiIndex(levels=levels, codes=codes, sortorder=sortorder,
names=names, verify_integrity=False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_tuples; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:tuples; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 38; 12, 139; 13, if_statement; 13, 14; 13, 19; 13, 25; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:is_list_like; 17, argument_list; 17, 18; 18, identifier:tuples; 19, block; 19, 20; 20, raise_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:TypeError; 23, argument_list; 23, 24; 24, string:'Input must be a list / sequence of tuple-likes.'; 25, elif_clause; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:is_iterator; 28, argument_list; 28, 29; 29, identifier:tuples; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:tuples; 34, call; 34, 35; 34, 36; 35, identifier:list; 36, argument_list; 36, 37; 37, identifier:tuples; 38, if_statement; 38, 39; 38, 45; 38, 70; 38, 108; 38, 129; 39, comparison_operator:==; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:tuples; 44, integer:0; 45, block; 45, 46; 45, 60; 46, if_statement; 46, 47; 46, 50; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:names; 49, None; 50, block; 50, 51; 50, 55; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:msg; 54, string:'Cannot infer number of levels from empty list'; 55, raise_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:TypeError; 58, argument_list; 58, 59; 59, identifier:msg; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:arrays; 63, binary_operator:*; 63, 64; 63, 66; 64, list:[[]]; 64, 65; 65, list:[]; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:names; 70, elif_clause; 70, 71; 70, 80; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:tuples; 75, tuple; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:np; 78, identifier:ndarray; 79, identifier:Index; 80, block; 80, 81; 80, 94; 81, if_statement; 81, 82; 81, 87; 82, call; 82, 83; 82, 84; 83, identifier:isinstance; 84, argument_list; 84, 85; 84, 86; 85, identifier:tuples; 86, identifier:Index; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:tuples; 91, attribute; 91, 92; 91, 93; 92, identifier:tuples; 93, identifier:_values; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:arrays; 97, call; 97, 98; 97, 99; 98, identifier:list; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 107; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:lib; 104, identifier:tuples_to_object_array; 105, argument_list; 105, 106; 106, identifier:tuples; 107, identifier:T; 108, elif_clause; 108, 109; 108, 114; 109, call; 109, 110; 109, 111; 110, identifier:isinstance; 111, argument_list; 111, 112; 111, 113; 112, identifier:tuples; 113, identifier:list; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:arrays; 118, call; 118, 119; 118, 120; 119, identifier:list; 120, argument_list; 120, 121; 121, attribute; 121, 122; 121, 128; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:lib; 125, identifier:to_object_array_tuples; 126, argument_list; 126, 127; 127, identifier:tuples; 128, identifier:T; 129, else_clause; 129, 130; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:arrays; 134, call; 134, 135; 134, 136; 135, identifier:lzip; 136, argument_list; 136, 137; 137, list_splat; 137, 138; 138, identifier:tuples; 139, return_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:MultiIndex; 143, identifier:from_arrays; 144, argument_list; 144, 145; 144, 146; 144, 149; 145, identifier:arrays; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:sortorder; 148, identifier:sortorder; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:names; 151, identifier:names | def from_tuples(cls, tuples, sortorder=None, names=None):
if not is_list_like(tuples):
raise TypeError('Input must be a list / sequence of tuple-likes.')
elif is_iterator(tuples):
tuples = list(tuples)
if len(tuples) == 0:
if names is None:
msg = 'Cannot infer number of levels from empty list'
raise TypeError(msg)
arrays = [[]] * len(names)
elif isinstance(tuples, (np.ndarray, Index)):
if isinstance(tuples, Index):
tuples = tuples._values
arrays = list(lib.tuples_to_object_array(tuples).T)
elif isinstance(tuples, list):
arrays = list(lib.to_object_array_tuples(tuples).T)
else:
arrays = lzip(*tuples)
return MultiIndex.from_arrays(arrays, sortorder=sortorder, names=names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_product; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:iterables; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 21; 12, 29; 12, 54; 12, 63; 12, 70; 13, import_from_statement; 13, 14; 13, 19; 14, dotted_name; 14, 15; 14, 16; 14, 17; 14, 18; 15, identifier:pandas; 16, identifier:core; 17, identifier:arrays; 18, identifier:categorical; 19, dotted_name; 19, 20; 20, identifier:_factorize_from_iterables; 21, import_from_statement; 21, 22; 21, 27; 22, dotted_name; 22, 23; 22, 24; 22, 25; 22, 26; 23, identifier:pandas; 24, identifier:core; 25, identifier:reshape; 26, identifier:util; 27, dotted_name; 27, 28; 28, identifier:cartesian_product; 29, if_statement; 29, 30; 29, 35; 29, 41; 30, not_operator; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:is_list_like; 33, argument_list; 33, 34; 34, identifier:iterables; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:TypeError; 39, argument_list; 39, 40; 40, string:"Input must be a list / sequence of iterables."; 41, elif_clause; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:is_iterator; 44, argument_list; 44, 45; 45, identifier:iterables; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:iterables; 50, call; 50, 51; 50, 52; 51, identifier:list; 52, argument_list; 52, 53; 53, identifier:iterables; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, pattern_list; 56, 57; 56, 58; 57, identifier:codes; 58, identifier:levels; 59, call; 59, 60; 59, 61; 60, identifier:_factorize_from_iterables; 61, argument_list; 61, 62; 62, identifier:iterables; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:codes; 66, call; 66, 67; 66, 68; 67, identifier:cartesian_product; 68, argument_list; 68, 69; 69, identifier:codes; 70, return_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:MultiIndex; 73, argument_list; 73, 74; 73, 75; 73, 76; 73, 79; 74, identifier:levels; 75, identifier:codes; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:sortorder; 78, identifier:sortorder; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:names; 81, identifier:names | def from_product(cls, iterables, sortorder=None, names=None):
from pandas.core.arrays.categorical import _factorize_from_iterables
from pandas.core.reshape.util import cartesian_product
if not is_list_like(iterables):
raise TypeError("Input must be a list / sequence of iterables.")
elif is_iterator(iterables):
iterables = list(iterables)
codes, levels = _factorize_from_iterables(iterables)
codes = cartesian_product(codes)
return MultiIndex(levels, codes, sortorder=sortorder, names=names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:from_frame; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:df; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sortorder; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:names; 11, None; 12, block; 12, 13; 12, 26; 12, 40; 12, 49; 13, if_statement; 13, 14; 13, 20; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:df; 19, identifier:ABCDataFrame; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:TypeError; 24, argument_list; 24, 25; 25, string:"Input must be a DataFrame"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:column_names; 30, identifier:columns; 31, call; 31, 32; 31, 33; 32, identifier:lzip; 33, argument_list; 33, 34; 34, list_splat; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:df; 38, identifier:iteritems; 39, argument_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:names; 43, conditional_expression:if; 43, 44; 43, 45; 43, 48; 44, identifier:column_names; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:names; 47, None; 48, identifier:names; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:cls; 53, identifier:from_arrays; 54, argument_list; 54, 55; 54, 56; 54, 59; 55, identifier:columns; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:sortorder; 58, identifier:sortorder; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:names; 61, identifier:names | def from_frame(cls, df, sortorder=None, names=None):
if not isinstance(df, ABCDataFrame):
raise TypeError("Input must be a DataFrame")
column_names, columns = lzip(*df.iteritems())
names = column_names if names is None else names
return cls.from_arrays(columns, sortorder=sortorder, names=names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sortlevel; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:level; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_remaining; 13, True; 14, block; 14, 15; 14, 22; 14, 36; 14, 49; 14, 53; 14, 224; 14, 231; 14, 246; 14, 271; 15, import_from_statement; 15, 16; 15, 20; 16, dotted_name; 16, 17; 16, 18; 16, 19; 17, identifier:pandas; 18, identifier:core; 19, identifier:sorting; 20, dotted_name; 20, 21; 21, identifier:indexer_from_factorized; 22, if_statement; 22, 23; 22, 30; 23, call; 23, 24; 23, 25; 24, identifier:isinstance; 25, argument_list; 25, 26; 25, 27; 26, identifier:level; 27, tuple; 27, 28; 27, 29; 28, identifier:str; 29, identifier:int; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:level; 34, list:[level]; 34, 35; 35, identifier:level; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:level; 39, list_comprehension; 39, 40; 39, 46; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_get_level_number; 44, argument_list; 44, 45; 45, identifier:lev; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:lev; 48, identifier:level; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:sortorder; 52, None; 53, if_statement; 53, 54; 53, 59; 53, 102; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:ascending; 58, identifier:list; 59, block; 59, 60; 59, 77; 59, 84; 60, if_statement; 60, 61; 60, 71; 61, not_operator; 61, 62; 62, comparison_operator:==; 62, 63; 62, 67; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, identifier:level; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, identifier:ascending; 71, block; 71, 72; 72, raise_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:ValueError; 75, argument_list; 75, 76; 76, string:"level must have same length as ascending"; 77, import_from_statement; 77, 78; 77, 82; 78, dotted_name; 78, 79; 78, 80; 78, 81; 79, identifier:pandas; 80, identifier:core; 81, identifier:sorting; 82, dotted_name; 82, 83; 83, identifier:lexsort_indexer; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:indexer; 87, call; 87, 88; 87, 89; 88, identifier:lexsort_indexer; 89, argument_list; 89, 90; 89, 99; 90, list_comprehension; 90, 91; 90, 96; 91, subscript; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:codes; 95, identifier:lev; 96, for_in_clause; 96, 97; 96, 98; 97, identifier:lev; 98, identifier:level; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:orders; 101, identifier:ascending; 102, else_clause; 102, 103; 103, block; 103, 104; 103, 113; 103, 122; 103, 134; 103, 146; 103, 170; 103, 199; 103, 210; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:codes; 107, call; 107, 108; 107, 109; 108, identifier:list; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:codes; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:shape; 116, call; 116, 117; 116, 118; 117, identifier:list; 118, argument_list; 118, 119; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:levshape; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:primary; 125, call; 125, 126; 125, 127; 126, identifier:tuple; 127, generator_expression; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:codes; 130, identifier:lev; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:lev; 133, identifier:level; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:primshp; 137, call; 137, 138; 137, 139; 138, identifier:tuple; 139, generator_expression; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:shape; 142, identifier:lev; 143, for_in_clause; 143, 144; 143, 145; 144, identifier:lev; 145, identifier:level; 146, for_statement; 146, 147; 146, 148; 146, 155; 147, identifier:lev; 148, call; 148, 149; 148, 150; 149, identifier:sorted; 150, argument_list; 150, 151; 150, 152; 151, identifier:level; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:reverse; 154, True; 155, block; 155, 156; 155, 163; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:codes; 160, identifier:pop; 161, argument_list; 161, 162; 162, identifier:lev; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:shape; 167, identifier:pop; 168, argument_list; 168, 169; 169, identifier:lev; 170, if_statement; 170, 171; 170, 172; 170, 191; 171, identifier:sort_remaining; 172, block; 172, 173; 172, 182; 173, expression_statement; 173, 174; 174, augmented_assignment:+=; 174, 175; 174, 176; 175, identifier:primary; 176, binary_operator:+; 176, 177; 176, 178; 177, identifier:primary; 178, call; 178, 179; 178, 180; 179, identifier:tuple; 180, argument_list; 180, 181; 181, identifier:codes; 182, expression_statement; 182, 183; 183, augmented_assignment:+=; 183, 184; 183, 185; 184, identifier:primshp; 185, binary_operator:+; 185, 186; 185, 187; 186, identifier:primshp; 187, call; 187, 188; 187, 189; 188, identifier:tuple; 189, argument_list; 189, 190; 190, identifier:shape; 191, else_clause; 191, 192; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:sortorder; 196, subscript; 196, 197; 196, 198; 197, identifier:level; 198, integer:0; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:indexer; 202, call; 202, 203; 202, 204; 203, identifier:indexer_from_factorized; 204, argument_list; 204, 205; 204, 206; 204, 207; 205, identifier:primary; 206, identifier:primshp; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:compress; 209, False; 210, if_statement; 210, 211; 210, 213; 211, not_operator; 211, 212; 212, identifier:ascending; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:indexer; 217, subscript; 217, 218; 217, 219; 218, identifier:indexer; 219, slice; 219, 220; 219, 221; 219, 222; 220, colon; 221, colon; 222, unary_operator:-; 222, 223; 223, integer:1; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:indexer; 227, call; 227, 228; 227, 229; 228, identifier:ensure_platform_int; 229, argument_list; 229, 230; 230, identifier:indexer; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:new_codes; 234, list_comprehension; 234, 235; 234, 241; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:level_codes; 238, identifier:take; 239, argument_list; 239, 240; 240, identifier:indexer; 241, for_in_clause; 241, 242; 241, 243; 242, identifier:level_codes; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:codes; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:new_index; 249, call; 249, 250; 249, 251; 250, identifier:MultiIndex; 251, argument_list; 251, 252; 251, 255; 251, 260; 251, 265; 251, 268; 252, keyword_argument; 252, 253; 252, 254; 253, identifier:codes; 254, identifier:new_codes; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:levels; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:levels; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:names; 262, attribute; 262, 263; 262, 264; 263, identifier:self; 264, identifier:names; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:sortorder; 267, identifier:sortorder; 268, keyword_argument; 268, 269; 268, 270; 269, identifier:verify_integrity; 270, False; 271, return_statement; 271, 272; 272, expression_list; 272, 273; 272, 274; 273, identifier:new_index; 274, identifier:indexer | def sortlevel(self, level=0, ascending=True, sort_remaining=True):
from pandas.core.sorting import indexer_from_factorized
if isinstance(level, (str, int)):
level = [level]
level = [self._get_level_number(lev) for lev in level]
sortorder = None
if isinstance(ascending, list):
if not len(level) == len(ascending):
raise ValueError("level must have same length as ascending")
from pandas.core.sorting import lexsort_indexer
indexer = lexsort_indexer([self.codes[lev] for lev in level],
orders=ascending)
else:
codes = list(self.codes)
shape = list(self.levshape)
primary = tuple(codes[lev] for lev in level)
primshp = tuple(shape[lev] for lev in level)
for lev in sorted(level, reverse=True):
codes.pop(lev)
shape.pop(lev)
if sort_remaining:
primary += primary + tuple(codes)
primshp += primshp + tuple(shape)
else:
sortorder = level[0]
indexer = indexer_from_factorized(primary, primshp,
compress=False)
if not ascending:
indexer = indexer[::-1]
indexer = ensure_platform_int(indexer)
new_codes = [level_codes.take(indexer) for level_codes in self.codes]
new_index = MultiIndex(codes=new_codes, levels=self.levels,
names=self.names, sortorder=sortorder,
verify_integrity=False)
return new_index, indexer |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:slice_locs; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:end; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:step; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:kind; 16, None; 17, block; 17, 18; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, call; 21, 22; 21, 23; 22, identifier:super; 23, argument_list; 24, identifier:slice_locs; 25, argument_list; 25, 26; 25, 27; 25, 28; 25, 29; 26, identifier:start; 27, identifier:end; 28, identifier:step; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:kind; 31, identifier:kind | def slice_locs(self, start=None, end=None, step=None, kind=None):
return super().slice_locs(start, end, step, kind=kind) |
Subsets and Splits