sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_loc; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:method; 8, None; 9, block; 9, 10; 9, 22; 9, 97; 9, 122; 9, 129; 9, 151; 9, 171; 9, 177; 9, 193; 9, 214; 9, 224; 9, 234; 9, 245; 9, 258; 9, 318; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:method; 13, None; 14, block; 14, 15; 15, raise_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:NotImplementedError; 18, argument_list; 18, 19; 19, concatenated_string; 19, 20; 19, 21; 20, string:'only the default get_loc method is '; 21, string:'currently supported for MultiIndex'; 22, function_definition; 22, 23; 22, 24; 22, 26; 23, function_name:_maybe_to_slice; 24, parameters; 24, 25; 25, identifier:loc; 26, block; 26, 27; 26, 45; 26, 58; 26, 67; 26, 82; 26, 89; 26, 95; 27, if_statement; 27, 28; 27, 42; 28, boolean_operator:or; 28, 29; 28, 37; 29, not_operator; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:isinstance; 32, argument_list; 32, 33; 32, 34; 33, identifier:loc; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:ndarray; 37, comparison_operator:!=; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:loc; 40, identifier:dtype; 41, string:'int64'; 42, block; 42, 43; 43, return_statement; 43, 44; 44, identifier:loc; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:loc; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:lib; 51, identifier:maybe_indices_to_slice; 52, argument_list; 52, 53; 52, 54; 53, identifier:loc; 54, call; 54, 55; 54, 56; 55, identifier:len; 56, argument_list; 56, 57; 57, identifier:self; 58, if_statement; 58, 59; 58, 64; 59, call; 59, 60; 59, 61; 60, identifier:isinstance; 61, argument_list; 61, 62; 61, 63; 62, identifier:loc; 63, identifier:slice; 64, block; 64, 65; 65, return_statement; 65, 66; 66, identifier:loc; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:mask; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:np; 73, identifier:empty; 74, argument_list; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:self; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:dtype; 81, string:'bool'; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:mask; 86, identifier:fill; 87, argument_list; 87, 88; 88, False; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:mask; 93, identifier:loc; 94, True; 95, return_statement; 95, 96; 96, identifier:mask; 97, if_statement; 97, 98; 97, 104; 98, not_operator; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:isinstance; 101, argument_list; 101, 102; 101, 103; 102, identifier:key; 103, identifier:tuple; 104, block; 104, 105; 104, 117; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:loc; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:_get_level_indexer; 112, argument_list; 112, 113; 112, 114; 113, identifier:key; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:level; 116, integer:0; 117, return_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:_maybe_to_slice; 120, argument_list; 120, 121; 121, identifier:loc; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:keylen; 125, call; 125, 126; 125, 127; 126, identifier:len; 127, argument_list; 127, 128; 128, identifier:key; 129, if_statement; 129, 130; 129, 135; 130, comparison_operator:<; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:nlevels; 134, identifier:keylen; 135, block; 135, 136; 136, raise_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:KeyError; 139, argument_list; 139, 140; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, concatenated_string; 142, 143; 142, 144; 143, string:'Key length ({0}) exceeds index depth ({1})'; 144, string:''; 145, identifier:format; 146, argument_list; 146, 147; 146, 148; 147, identifier:keylen; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:nlevels; 151, if_statement; 151, 152; 151, 161; 152, boolean_operator:and; 152, 153; 152, 158; 153, comparison_operator:==; 153, 154; 153, 155; 154, identifier:keylen; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:nlevels; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:is_unique; 161, block; 161, 162; 162, return_statement; 162, 163; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:_engine; 168, identifier:get_loc; 169, argument_list; 169, 170; 170, identifier:key; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:i; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:lexsort_depth; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, pattern_list; 179, 180; 179, 181; 180, identifier:lead_key; 181, identifier:follow_key; 182, expression_list; 182, 183; 182, 188; 183, subscript; 183, 184; 183, 185; 184, identifier:key; 185, slice; 185, 186; 185, 187; 186, colon; 187, identifier:i; 188, subscript; 188, 189; 188, 190; 189, identifier:key; 190, slice; 190, 191; 190, 192; 191, identifier:i; 192, colon; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, pattern_list; 195, 196; 195, 197; 196, identifier:start; 197, identifier:stop; 198, parenthesized_expression; 198, 199; 199, conditional_expression:if; 199, 200; 199, 207; 199, 208; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:slice_locs; 204, argument_list; 204, 205; 204, 206; 205, identifier:lead_key; 206, identifier:lead_key; 207, identifier:lead_key; 208, tuple; 208, 209; 208, 210; 209, integer:0; 210, call; 210, 211; 210, 212; 211, identifier:len; 212, argument_list; 212, 213; 213, identifier:self; 214, if_statement; 214, 215; 214, 218; 215, comparison_operator:==; 215, 216; 215, 217; 216, identifier:start; 217, identifier:stop; 218, block; 218, 219; 219, raise_statement; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:KeyError; 222, argument_list; 222, 223; 223, identifier:key; 224, if_statement; 224, 225; 224, 227; 225, not_operator; 225, 226; 226, identifier:follow_key; 227, block; 227, 228; 228, return_statement; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:slice; 231, argument_list; 231, 232; 231, 233; 232, identifier:start; 233, identifier:stop; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:warnings; 238, identifier:warn; 239, argument_list; 239, 240; 239, 241; 239, 242; 240, string:'indexing past lexsort depth may impact performance.'; 241, identifier:PerformanceWarning; 242, keyword_argument; 242, 243; 242, 244; 243, identifier:stacklevel; 244, integer:10; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:loc; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:np; 251, identifier:arange; 252, argument_list; 252, 253; 252, 254; 252, 255; 253, identifier:start; 254, identifier:stop; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:dtype; 257, string:'int64'; 258, for_statement; 258, 259; 258, 262; 258, 270; 259, pattern_list; 259, 260; 259, 261; 260, identifier:i; 261, identifier:k; 262, call; 262, 263; 262, 264; 263, identifier:enumerate; 264, argument_list; 264, 265; 264, 266; 265, identifier:follow_key; 266, call; 266, 267; 266, 268; 267, identifier:len; 268, argument_list; 268, 269; 269, identifier:lead_key; 270, block; 270, 271; 270, 292; 270, 306; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:mask; 274, comparison_operator:==; 274, 275; 274, 282; 275, subscript; 275, 276; 275, 281; 276, subscript; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:self; 279, identifier:codes; 280, identifier:i; 281, identifier:loc; 282, call; 282, 283; 282, 290; 283, attribute; 283, 284; 283, 289; 284, subscript; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:self; 287, identifier:levels; 288, identifier:i; 289, identifier:get_loc; 290, argument_list; 290, 291; 291, identifier:k; 292, if_statement; 292, 293; 292, 299; 293, not_operator; 293, 294; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:mask; 297, identifier:all; 298, argument_list; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:loc; 303, subscript; 303, 304; 303, 305; 304, identifier:loc; 305, identifier:mask; 306, if_statement; 306, 307; 306, 312; 307, not_operator; 307, 308; 308, call; 308, 309; 308, 310; 309, identifier:len; 310, argument_list; 310, 311; 311, identifier:loc; 312, block; 312, 313; 313, raise_statement; 313, 314; 314, call; 314, 315; 314, 316; 315, identifier:KeyError; 316, argument_list; 316, 317; 317, identifier:key; 318, return_statement; 318, 319; 319, parenthesized_expression; 319, 320; 320, conditional_expression:if; 320, 321; 320, 325; 320, 333; 321, call; 321, 322; 321, 323; 322, identifier:_maybe_to_slice; 323, argument_list; 323, 324; 324, identifier:loc; 325, comparison_operator:!=; 325, 326; 325, 330; 326, call; 326, 327; 326, 328; 327, identifier:len; 328, argument_list; 328, 329; 329, identifier:loc; 330, binary_operator:-; 330, 331; 330, 332; 331, identifier:stop; 332, identifier:start; 333, call; 333, 334; 333, 335; 334, identifier:slice; 335, argument_list; 335, 336; 335, 337; 336, identifier:start; 337, identifier:stop | def get_loc(self, key, method=None):
if method is not None:
raise NotImplementedError('only the default get_loc method is '
'currently supported for MultiIndex')
def _maybe_to_slice(loc):
if not isinstance(loc, np.ndarray) or loc.dtype != 'int64':
return loc
loc = lib.maybe_indices_to_slice(loc, len(self))
if isinstance(loc, slice):
return loc
mask = np.empty(len(self), dtype='bool')
mask.fill(False)
mask[loc] = True
return mask
if not isinstance(key, tuple):
loc = self._get_level_indexer(key, level=0)
return _maybe_to_slice(loc)
keylen = len(key)
if self.nlevels < keylen:
raise KeyError('Key length ({0}) exceeds index depth ({1})'
''.format(keylen, self.nlevels))
if keylen == self.nlevels and self.is_unique:
return self._engine.get_loc(key)
i = self.lexsort_depth
lead_key, follow_key = key[:i], key[i:]
start, stop = (self.slice_locs(lead_key, lead_key)
if lead_key else (0, len(self)))
if start == stop:
raise KeyError(key)
if not follow_key:
return slice(start, stop)
warnings.warn('indexing past lexsort depth may impact performance.',
PerformanceWarning, stacklevel=10)
loc = np.arange(start, stop, dtype='int64')
for i, k in enumerate(follow_key, len(lead_key)):
mask = self.codes[i][loc] == self.levels[i].get_loc(k)
if not mask.all():
loc = loc[mask]
if not len(loc):
raise KeyError(key)
return (_maybe_to_slice(loc) if len(loc) != stop - start else
slice(start, stop)) |
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, 35; 9, 52; 9, 70; 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, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:other; 28, identifier:result_names; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_convert_can_do_setop; 33, argument_list; 33, 34; 34, identifier:other; 35, if_statement; 35, 36; 35, 49; 36, boolean_operator:or; 36, 37; 36, 43; 37, comparison_operator:==; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:other; 42, integer:0; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:equals; 47, argument_list; 47, 48; 48, identifier:other; 49, block; 49, 50; 50, return_statement; 50, 51; 51, identifier:self; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:uniq_tuples; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:lib; 58, identifier:fast_unique_multiple; 59, argument_list; 59, 60; 59, 67; 60, list:[self._ndarray_values,
other._ndarray_values]; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_ndarray_values; 64, attribute; 64, 65; 64, 66; 65, identifier:other; 66, identifier:_ndarray_values; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:sort; 69, identifier:sort; 70, return_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:MultiIndex; 74, identifier:from_arrays; 75, argument_list; 75, 76; 75, 81; 75, 84; 76, call; 76, 77; 76, 78; 77, identifier:lzip; 78, argument_list; 78, 79; 79, list_splat; 79, 80; 80, identifier:uniq_tuples; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:sortorder; 83, integer:0; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:names; 86, identifier:result_names | def union(self, other, sort=None):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other, result_names = self._convert_can_do_setop(other)
if len(other) == 0 or self.equals(other):
return self
uniq_tuples = lib.fast_unique_multiple([self._ndarray_values,
other._ndarray_values],
sort=sort)
return MultiIndex.from_arrays(lzip(*uniq_tuples), sortorder=0,
names=result_names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:intersection; 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, False; 9, block; 9, 10; 9, 17; 9, 24; 9, 35; 9, 45; 9, 51; 9, 57; 9, 69; 9, 81; 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, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:other; 28, identifier:result_names; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_convert_can_do_setop; 33, argument_list; 33, 34; 34, identifier:other; 35, if_statement; 35, 36; 35, 42; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:equals; 40, argument_list; 40, 41; 41, identifier:other; 42, block; 42, 43; 43, return_statement; 43, 44; 44, identifier:self; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:self_tuples; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_ndarray_values; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:other_tuples; 54, attribute; 54, 55; 54, 56; 55, identifier:other; 56, identifier:_ndarray_values; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:uniq_tuples; 60, binary_operator:&; 60, 61; 60, 65; 61, call; 61, 62; 61, 63; 62, identifier:set; 63, argument_list; 63, 64; 64, identifier:self_tuples; 65, call; 65, 66; 65, 67; 66, identifier:set; 67, argument_list; 67, 68; 68, identifier:other_tuples; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:sort; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:uniq_tuples; 77, call; 77, 78; 77, 79; 78, identifier:sorted; 79, argument_list; 79, 80; 80, identifier:uniq_tuples; 81, if_statement; 81, 82; 81, 88; 81, 112; 82, comparison_operator:==; 82, 83; 82, 87; 83, call; 83, 84; 83, 85; 84, identifier:len; 85, argument_list; 85, 86; 86, identifier:uniq_tuples; 87, integer:0; 88, block; 88, 89; 89, return_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:MultiIndex; 92, argument_list; 92, 93; 92, 98; 92, 106; 92, 109; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:levels; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:levels; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:codes; 100, binary_operator:*; 100, 101; 100, 103; 101, list:[[]]; 101, 102; 102, list:[]; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:nlevels; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:names; 108, identifier:result_names; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:verify_integrity; 111, False; 112, else_clause; 112, 113; 113, block; 113, 114; 114, return_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:MultiIndex; 118, identifier:from_arrays; 119, argument_list; 119, 120; 119, 125; 119, 128; 120, call; 120, 121; 120, 122; 121, identifier:lzip; 122, argument_list; 122, 123; 123, list_splat; 123, 124; 124, identifier:uniq_tuples; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:sortorder; 127, integer:0; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:names; 130, identifier:result_names | def intersection(self, other, sort=False):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other, result_names = self._convert_can_do_setop(other)
if self.equals(other):
return self
self_tuples = self._ndarray_values
other_tuples = other._ndarray_values
uniq_tuples = set(self_tuples) & set(other_tuples)
if sort is None:
uniq_tuples = sorted(uniq_tuples)
if len(uniq_tuples) == 0:
return MultiIndex(levels=self.levels,
codes=[[]] * self.nlevels,
names=result_names, verify_integrity=False)
else:
return MultiIndex.from_arrays(lzip(*uniq_tuples), sortorder=0,
names=result_names) |
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, 35; 9, 45; 9, 76; 9, 84; 9, 93; 9, 112; 9, 132; 9, 143; 9, 155; 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, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:other; 28, identifier:result_names; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_convert_can_do_setop; 33, argument_list; 33, 34; 34, identifier:other; 35, if_statement; 35, 36; 35, 42; 36, comparison_operator:==; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:other; 41, integer:0; 42, block; 42, 43; 43, return_statement; 43, 44; 44, identifier:self; 45, if_statement; 45, 46; 45, 52; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:equals; 50, argument_list; 50, 51; 51, identifier:other; 52, block; 52, 53; 53, return_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:MultiIndex; 56, argument_list; 56, 57; 56, 62; 56, 70; 56, 73; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:levels; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:levels; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:codes; 64, binary_operator:*; 64, 65; 64, 67; 65, list:[[]]; 65, 66; 66, list:[]; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:nlevels; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:names; 72, identifier:result_names; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:verify_integrity; 75, False; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:this; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_get_unique_index; 83, argument_list; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:indexer; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:this; 90, identifier:get_indexer; 91, argument_list; 91, 92; 92, identifier:other; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:indexer; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:indexer; 99, identifier:take; 100, argument_list; 100, 101; 101, subscript; 101, 102; 101, 111; 102, call; 102, 103; 102, 110; 103, attribute; 103, 104; 103, 109; 104, parenthesized_expression; 104, 105; 105, comparison_operator:!=; 105, 106; 105, 107; 106, identifier:indexer; 107, unary_operator:-; 107, 108; 108, integer:1; 109, identifier:nonzero; 110, argument_list; 111, integer:0; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:label_diff; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:np; 118, identifier:setdiff1d; 119, argument_list; 119, 120; 119, 128; 119, 129; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:np; 123, identifier:arange; 124, argument_list; 124, 125; 125, attribute; 125, 126; 125, 127; 126, identifier:this; 127, identifier:size; 128, identifier:indexer; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:assume_unique; 131, True; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:difference; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:this; 139, identifier:values; 140, identifier:take; 141, argument_list; 141, 142; 142, identifier:label_diff; 143, if_statement; 143, 144; 143, 147; 144, comparison_operator:is; 144, 145; 144, 146; 145, identifier:sort; 146, None; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:difference; 151, call; 151, 152; 151, 153; 152, identifier:sorted; 153, argument_list; 153, 154; 154, identifier:difference; 155, if_statement; 155, 156; 155, 162; 155, 189; 156, comparison_operator:==; 156, 157; 156, 161; 157, call; 157, 158; 157, 159; 158, identifier:len; 159, argument_list; 159, 160; 160, identifier:difference; 161, integer:0; 162, block; 162, 163; 163, return_statement; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:MultiIndex; 166, argument_list; 166, 167; 166, 175; 166, 183; 166, 186; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:levels; 169, binary_operator:*; 169, 170; 169, 172; 170, list:[[]]; 170, 171; 171, list:[]; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:nlevels; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:codes; 177, binary_operator:*; 177, 178; 177, 180; 178, list:[[]]; 178, 179; 179, list:[]; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:nlevels; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:names; 185, identifier:result_names; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:verify_integrity; 188, False; 189, else_clause; 189, 190; 190, block; 190, 191; 191, return_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:MultiIndex; 195, identifier:from_tuples; 196, argument_list; 196, 197; 196, 198; 196, 201; 197, identifier:difference; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:sortorder; 200, integer:0; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:names; 203, identifier:result_names | def difference(self, other, sort=None):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
other, result_names = self._convert_can_do_setop(other)
if len(other) == 0:
return self
if self.equals(other):
return MultiIndex(levels=self.levels,
codes=[[]] * self.nlevels,
names=result_names, verify_integrity=False)
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)
difference = this.values.take(label_diff)
if sort is None:
difference = sorted(difference)
if len(difference) == 0:
return MultiIndex(levels=[[]] * self.nlevels,
codes=[[]] * self.nlevels,
names=result_names, verify_integrity=False)
else:
return MultiIndex.from_tuples(difference, sortorder=0,
names=result_names) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:unique; 3, parameters; 3, 4; 4, identifier:values; 5, block; 5, 6; 5, 13; 5, 25; 5, 29; 5, 41; 5, 51; 5, 60; 5, 69; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:values; 9, call; 9, 10; 9, 11; 10, identifier:_ensure_arraylike; 11, argument_list; 11, 12; 12, identifier:values; 13, if_statement; 13, 14; 13, 18; 14, call; 14, 15; 14, 16; 15, identifier:is_extension_array_dtype; 16, argument_list; 16, 17; 17, identifier:values; 18, block; 18, 19; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:values; 23, identifier:unique; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:original; 28, identifier:values; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 37; 31, pattern_list; 31, 32; 31, 33; 31, 34; 31, 35; 31, 36; 32, identifier:htable; 33, identifier:_; 34, identifier:values; 35, identifier:dtype; 36, identifier:ndtype; 37, call; 37, 38; 37, 39; 38, identifier:_get_hashtable_algo; 39, argument_list; 39, 40; 40, identifier:values; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:table; 44, call; 44, 45; 44, 46; 45, identifier:htable; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:len; 49, argument_list; 49, 50; 50, identifier:values; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:uniques; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:table; 57, identifier:unique; 58, argument_list; 58, 59; 59, identifier:values; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:uniques; 63, call; 63, 64; 63, 65; 64, identifier:_reconstruct_data; 65, argument_list; 65, 66; 65, 67; 65, 68; 66, identifier:uniques; 67, identifier:dtype; 68, identifier:original; 69, return_statement; 69, 70; 70, identifier:uniques | def unique(values):
values = _ensure_arraylike(values)
if is_extension_array_dtype(values):
return values.unique()
original = values
htable, _, values, dtype, ndtype = _get_hashtable_algo(values)
table = htable(len(values))
uniques = table.unique(values)
uniques = _reconstruct_data(uniques, dtype, original)
return uniques |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:value_counts; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:values; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:normalize; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:bins; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:dropna; 19, True; 20, block; 20, 21; 20, 30; 20, 39; 20, 243; 20, 257; 20, 273; 21, import_from_statement; 21, 22; 21, 26; 21, 28; 22, dotted_name; 22, 23; 22, 24; 22, 25; 23, identifier:pandas; 24, identifier:core; 25, identifier:series; 26, dotted_name; 26, 27; 27, identifier:Series; 28, dotted_name; 28, 29; 29, identifier:Index; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:name; 33, call; 33, 34; 33, 35; 34, identifier:getattr; 35, argument_list; 35, 36; 35, 37; 35, 38; 36, identifier:values; 37, string:'name'; 38, None; 39, if_statement; 39, 40; 39, 43; 39, 162; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:bins; 42, None; 43, block; 43, 44; 43, 80; 43, 91; 43, 103; 43, 116; 43, 124; 43, 149; 44, try_statement; 44, 45; 44, 72; 45, block; 45, 46; 45, 54; 45, 61; 46, import_from_statement; 46, 47; 46, 52; 47, dotted_name; 47, 48; 47, 49; 47, 50; 47, 51; 48, identifier:pandas; 49, identifier:core; 50, identifier:reshape; 51, identifier:tile; 52, dotted_name; 52, 53; 53, identifier:cut; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:values; 57, call; 57, 58; 57, 59; 58, identifier:Series; 59, argument_list; 59, 60; 60, identifier:values; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:ii; 64, call; 64, 65; 64, 66; 65, identifier:cut; 66, argument_list; 66, 67; 66, 68; 66, 69; 67, identifier:values; 68, identifier:bins; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:include_lowest; 71, True; 72, except_clause; 72, 73; 72, 74; 73, identifier:TypeError; 74, block; 74, 75; 75, raise_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:TypeError; 78, argument_list; 78, 79; 79, string:"bins argument only works with numeric data."; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:result; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:ii; 86, identifier:value_counts; 87, argument_list; 87, 88; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:dropna; 90, identifier:dropna; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:result; 94, subscript; 94, 95; 94, 96; 95, identifier:result; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:result; 100, identifier:index; 101, identifier:notna; 102, argument_list; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:result; 107, identifier:index; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:result; 112, identifier:index; 113, identifier:astype; 114, argument_list; 114, 115; 115, string:'interval'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:result; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:result; 122, identifier:sort_index; 123, argument_list; 124, if_statement; 124, 125; 124, 137; 125, boolean_operator:and; 125, 126; 125, 127; 126, identifier:dropna; 127, call; 127, 128; 127, 136; 128, attribute; 128, 129; 128, 135; 129, parenthesized_expression; 129, 130; 130, comparison_operator:==; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:result; 133, identifier:values; 134, integer:0; 135, identifier:all; 136, argument_list; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:result; 141, subscript; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:result; 144, identifier:iloc; 145, slice; 145, 146; 145, 147; 145, 148; 146, integer:0; 147, colon; 148, integer:0; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:counts; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:np; 155, identifier:array; 156, argument_list; 156, 157; 157, list:[len(ii)]; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:len; 160, argument_list; 160, 161; 161, identifier:ii; 162, else_clause; 162, 163; 163, block; 163, 164; 164, if_statement; 164, 165; 164, 174; 164, 203; 165, boolean_operator:or; 165, 166; 165, 170; 166, call; 166, 167; 166, 168; 167, identifier:is_extension_array_dtype; 168, argument_list; 168, 169; 169, identifier:values; 170, call; 170, 171; 170, 172; 171, identifier:is_sparse; 172, argument_list; 172, 173; 173, identifier:values; 174, block; 174, 175; 174, 191; 174, 197; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:result; 178, call; 178, 179; 178, 187; 179, attribute; 179, 180; 179, 186; 180, attribute; 180, 181; 180, 185; 181, call; 181, 182; 181, 183; 182, identifier:Series; 183, argument_list; 183, 184; 184, identifier:values; 185, identifier:_values; 186, identifier:value_counts; 187, argument_list; 187, 188; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:dropna; 190, identifier:dropna; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:result; 195, identifier:name; 196, identifier:name; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:counts; 200, attribute; 200, 201; 200, 202; 201, identifier:result; 202, identifier:values; 203, else_clause; 203, 204; 204, block; 204, 205; 204, 215; 204, 230; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 210; 207, pattern_list; 207, 208; 207, 209; 208, identifier:keys; 209, identifier:counts; 210, call; 210, 211; 210, 212; 211, identifier:_value_counts_arraylike; 212, argument_list; 212, 213; 212, 214; 213, identifier:values; 214, identifier:dropna; 215, if_statement; 215, 216; 215, 222; 216, not_operator; 216, 217; 217, call; 217, 218; 217, 219; 218, identifier:isinstance; 219, argument_list; 219, 220; 219, 221; 220, identifier:keys; 221, identifier:Index; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:keys; 226, call; 226, 227; 226, 228; 227, identifier:Index; 228, argument_list; 228, 229; 229, identifier:keys; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:result; 233, call; 233, 234; 233, 235; 234, identifier:Series; 235, argument_list; 235, 236; 235, 237; 235, 240; 236, identifier:counts; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:index; 239, identifier:keys; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:name; 242, identifier:name; 243, if_statement; 243, 244; 243, 245; 244, identifier:sort; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:result; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:result; 252, identifier:sort_values; 253, argument_list; 253, 254; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:ascending; 256, identifier:ascending; 257, if_statement; 257, 258; 257, 259; 258, identifier:normalize; 259, block; 259, 260; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:result; 263, binary_operator:/; 263, 264; 263, 265; 264, identifier:result; 265, call; 265, 266; 265, 267; 266, identifier:float; 267, argument_list; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:counts; 271, identifier:sum; 272, argument_list; 273, return_statement; 273, 274; 274, identifier:result | def value_counts(values, sort=True, ascending=False, normalize=False,
bins=None, dropna=True):
from pandas.core.series import Series, Index
name = getattr(values, 'name', None)
if bins is not None:
try:
from pandas.core.reshape.tile import cut
values = Series(values)
ii = cut(values, bins, include_lowest=True)
except TypeError:
raise TypeError("bins argument only works with numeric data.")
result = ii.value_counts(dropna=dropna)
result = result[result.index.notna()]
result.index = result.index.astype('interval')
result = result.sort_index()
if dropna and (result.values == 0).all():
result = result.iloc[0:0]
counts = np.array([len(ii)])
else:
if is_extension_array_dtype(values) or is_sparse(values):
result = Series(values)._values.value_counts(dropna=dropna)
result.name = name
counts = result.values
else:
keys, counts = _value_counts_arraylike(values, dropna)
if not isinstance(keys, Index):
keys = Index(keys)
result = Series(counts, index=keys, name=name)
if sort:
result = result.sort_values(ascending=ascending)
if normalize:
result = result / float(counts.sum())
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:validate_argsort_with_ascending; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:ascending; 5, identifier:args; 6, identifier:kwargs; 7, block; 7, 8; 7, 29; 7, 38; 8, if_statement; 8, 9; 8, 17; 9, boolean_operator:or; 9, 10; 9, 14; 10, call; 10, 11; 10, 12; 11, identifier:is_integer; 12, argument_list; 12, 13; 13, identifier:ascending; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:ascending; 16, None; 17, block; 17, 18; 17, 25; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:args; 21, binary_operator:+; 21, 22; 21, 24; 22, tuple; 22, 23; 23, identifier:ascending; 24, identifier:args; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:ascending; 28, True; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:validate_argsort_kind; 32, argument_list; 32, 33; 32, 34; 32, 35; 33, identifier:args; 34, identifier:kwargs; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:max_fname_arg_count; 37, integer:3; 38, return_statement; 38, 39; 39, identifier:ascending | def validate_argsort_with_ascending(ascending, args, kwargs):
if is_integer(ascending) or ascending is None:
args = (ascending,) + args
ascending = True
validate_argsort_kind(args, kwargs, max_fname_arg_count=3)
return ascending |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 44; 2, function_name:merge_asof; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 3, 35; 3, 38; 3, 41; 4, identifier:left; 5, identifier:right; 6, default_parameter; 6, 7; 6, 8; 7, identifier:on; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:left_on; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:right_on; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:left_index; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:right_index; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:by; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:left_by; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:right_by; 29, None; 30, default_parameter; 30, 31; 30, 32; 31, identifier:suffixes; 32, tuple; 32, 33; 32, 34; 33, string:'_x'; 34, string:'_y'; 35, default_parameter; 35, 36; 35, 37; 36, identifier:tolerance; 37, None; 38, default_parameter; 38, 39; 38, 40; 39, identifier:allow_exact_matches; 40, True; 41, default_parameter; 41, 42; 41, 43; 42, identifier:direction; 43, string:'backward'; 44, block; 44, 45; 44, 92; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:op; 48, call; 48, 49; 48, 50; 49, identifier:_AsOfMerge; 50, argument_list; 50, 51; 50, 52; 50, 53; 50, 56; 50, 59; 50, 62; 50, 65; 50, 68; 50, 71; 50, 74; 50, 77; 50, 80; 50, 83; 50, 86; 50, 89; 51, identifier:left; 52, identifier:right; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:on; 55, identifier:on; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:left_on; 58, identifier:left_on; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:right_on; 61, identifier:right_on; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:left_index; 64, identifier:left_index; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:right_index; 67, identifier:right_index; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:by; 70, identifier:by; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:left_by; 73, identifier:left_by; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:right_by; 76, identifier:right_by; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:suffixes; 79, identifier:suffixes; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:how; 82, string:'asof'; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:tolerance; 85, identifier:tolerance; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:allow_exact_matches; 88, identifier:allow_exact_matches; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:direction; 91, identifier:direction; 92, return_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:op; 96, identifier:get_result; 97, argument_list | def merge_asof(left, right, on=None,
left_on=None, right_on=None,
left_index=False, right_index=False,
by=None, left_by=None, right_by=None,
suffixes=('_x', '_y'),
tolerance=None,
allow_exact_matches=True,
direction='backward'):
op = _AsOfMerge(left, right,
on=on, left_on=left_on, right_on=right_on,
left_index=left_index, right_index=right_index,
by=by, left_by=left_by, right_by=right_by,
suffixes=suffixes,
how='asof', tolerance=tolerance,
allow_exact_matches=allow_exact_matches,
direction=direction)
return op.get_result() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:generate_classes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:items; 6, block; 6, 7; 6, 9; 6, 15; 6, 31; 6, 38; 6, 44; 7, expression_statement; 7, 8; 8, string:"Generate classes from `items` by taking the sorted unique values."; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:classes; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:c; 17, identifier:items; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:classes; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:classes; 25, identifier:union; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:set; 29, argument_list; 29, 30; 30, identifier:c; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:classes; 34, call; 34, 35; 34, 36; 35, identifier:list; 36, argument_list; 36, 37; 37, identifier:classes; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:classes; 42, identifier:sort; 43, argument_list; 44, return_statement; 44, 45; 45, identifier:classes | def generate_classes(self, items):
"Generate classes from `items` by taking the sorted unique values."
classes = set()
for c in items: classes = classes.union(set(c))
classes = list(classes)
classes.sort()
return classes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 1, 29; 2, function_name:most_confused; 3, parameters; 3, 4; 3, 5; 3, 10; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:min_val; 7, type; 7, 8; 8, identifier:int; 9, integer:1; 10, typed_default_parameter; 10, 11; 10, 12; 10, 14; 11, identifier:slice_size; 12, type; 12, 13; 13, identifier:int; 14, integer:1; 15, type; 15, 16; 16, generic_type; 16, 17; 16, 18; 17, identifier:Collection; 18, type_parameter; 18, 19; 19, type; 19, 20; 20, generic_type; 20, 21; 20, 22; 21, identifier:Tuple; 22, type_parameter; 22, 23; 22, 25; 22, 27; 23, type; 23, 24; 24, identifier:str; 25, type; 25, 26; 26, identifier:str; 27, type; 27, 28; 28, identifier:int; 29, block; 29, 30; 29, 32; 29, 43; 29, 51; 29, 90; 30, expression_statement; 30, 31; 31, string:"Sorted descending list of largest non-diagonal entries of confusion matrix, presented as actual, predicted, number of occurrences."; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:cm; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:confusion_matrix; 39, argument_list; 39, 40; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:slice_size; 42, identifier:slice_size; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:np; 47, identifier:fill_diagonal; 48, argument_list; 48, 49; 48, 50; 49, identifier:cm; 50, integer:0; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:res; 54, list_comprehension; 54, 55; 54, 74; 55, tuple; 55, 56; 55, 63; 55, 70; 56, subscript; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:data; 61, identifier:classes; 62, identifier:i; 63, subscript; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:data; 68, identifier:classes; 69, identifier:j; 70, subscript; 70, 71; 70, 72; 70, 73; 71, identifier:cm; 72, identifier:i; 73, identifier:j; 74, for_in_clause; 74, 75; 74, 78; 75, pattern_list; 75, 76; 75, 77; 76, identifier:i; 77, identifier:j; 78, call; 78, 79; 78, 80; 79, identifier:zip; 80, argument_list; 80, 81; 81, list_splat; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:np; 85, identifier:where; 86, argument_list; 86, 87; 87, comparison_operator:>=; 87, 88; 87, 89; 88, identifier:cm; 89, identifier:min_val; 90, return_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:sorted; 93, argument_list; 93, 94; 93, 95; 93, 101; 94, identifier:res; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:key; 97, call; 97, 98; 97, 99; 98, identifier:itemgetter; 99, argument_list; 99, 100; 100, integer:2; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:reverse; 103, True | def most_confused(self, min_val:int=1, slice_size:int=1)->Collection[Tuple[str,str,int]]:
"Sorted descending list of largest non-diagonal entries of confusion matrix, presented as actual, predicted, number of occurrences."
cm = self.confusion_matrix(slice_size=slice_size)
np.fill_diagonal(cm, 0)
res = [(self.data.classes[i],self.data.classes[j],cm[i,j])
for i,j in zip(*np.where(cm>=min_val))]
return sorted(res, key=itemgetter(2), reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_toplosses_idxs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:learn; 6, identifier:n_imgs; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 12; 9, 20; 9, 33; 9, 52; 9, 64; 10, expression_statement; 10, 11; 11, string:"Sorts `ds_type` dataset by top losses and returns dataset and sorted indices."; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:dl; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:learn; 18, identifier:data; 19, identifier:fix_dl; 20, if_statement; 20, 21; 20, 23; 21, not_operator; 21, 22; 22, identifier:n_imgs; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:n_imgs; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:dl; 32, identifier:dataset; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 39; 35, pattern_list; 35, 36; 35, 37; 35, 38; 36, identifier:_; 37, identifier:_; 38, identifier:top_losses; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:learn; 42, identifier:get_preds; 43, argument_list; 43, 44; 43, 49; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:ds_type; 46, attribute; 46, 47; 46, 48; 47, identifier:DatasetType; 48, identifier:Fix; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:with_loss; 51, True; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:idxs; 55, subscript; 55, 56; 55, 63; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:torch; 59, identifier:topk; 60, argument_list; 60, 61; 60, 62; 61, identifier:top_losses; 62, identifier:n_imgs; 63, integer:1; 64, return_statement; 64, 65; 65, expression_list; 65, 66; 65, 76; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:cls; 69, identifier:padded_ds; 70, argument_list; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:dl; 73, identifier:dataset; 74, dictionary_splat; 74, 75; 75, identifier:kwargs; 76, identifier:idxs | def get_toplosses_idxs(cls, learn, n_imgs, **kwargs):
"Sorts `ds_type` dataset by top losses and returns dataset and sorted indices."
dl = learn.data.fix_dl
if not n_imgs: n_imgs = len(dl.dataset)
_,_,top_losses = learn.get_preds(ds_type=DatasetType.Fix, with_loss=True)
idxs = torch.topk(top_losses, n_imgs)[1]
return cls.padded_ds(dl.dataset, **kwargs), idxs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_idxs; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:similarities; 6, block; 6, 7; 6, 9; 6, 22; 6, 48; 7, expression_statement; 7, 8; 8, string:"Sorts `similarities` and return the indexes in pairs ordered by highest similarity."; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:idxs; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:cls; 15, identifier:largest_indices; 16, argument_list; 16, 17; 16, 18; 17, identifier:similarities; 18, call; 18, 19; 18, 20; 19, identifier:len; 20, argument_list; 20, 21; 21, identifier:similarities; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:idxs; 25, list_comprehension; 25, 26; 25, 37; 26, tuple; 26, 27; 26, 32; 27, subscript; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:idxs; 30, integer:0; 31, identifier:i; 32, subscript; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:idxs; 35, integer:1; 36, identifier:i; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:i; 39, call; 39, 40; 39, 41; 40, identifier:range; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:len; 44, argument_list; 44, 45; 45, subscript; 45, 46; 45, 47; 46, identifier:idxs; 47, integer:0; 48, return_statement; 48, 49; 49, list_comprehension; 49, 50; 49, 51; 49, 54; 50, identifier:e; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:l; 53, identifier:idxs; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:e; 56, identifier:l | def sort_idxs(cls, similarities):
"Sorts `similarities` and return the indexes in pairs ordered by highest similarity."
idxs = cls.largest_indices(similarities, len(similarities))
idxs = [(idxs[0][i], idxs[1][i]) for i in range(len(idxs[0]))]
return [e for l in idxs for e in l] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 1, 15; 2, function_name:uniqueify; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:x; 6, type; 6, 7; 7, identifier:Series; 8, typed_default_parameter; 8, 9; 8, 10; 8, 12; 9, identifier:sort; 10, type; 10, 11; 11, identifier:bool; 12, False; 13, type; 13, 14; 14, identifier:List; 15, block; 15, 16; 15, 18; 15, 34; 15, 43; 16, expression_statement; 16, 17; 17, string:"Return sorted unique values of `x`."; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:res; 21, call; 21, 22; 21, 23; 22, identifier:list; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 33; 25, attribute; 25, 26; 25, 32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:OrderedDict; 29, identifier:fromkeys; 30, argument_list; 30, 31; 31, identifier:x; 32, identifier:keys; 33, argument_list; 34, if_statement; 34, 35; 34, 36; 35, identifier:sort; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:res; 41, identifier:sort; 42, argument_list; 43, return_statement; 43, 44; 44, identifier:res | def uniqueify(x:Series, sort:bool=False)->List:
"Return sorted unique values of `x`."
res = list(OrderedDict.fromkeys(x).keys())
if sort: res.sort()
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_imported_modules; 3, parameters; 3, 4; 3, 5; 4, identifier:cells; 5, default_parameter; 5, 6; 5, 7; 6, identifier:nb_module_name; 7, string:''; 8, block; 8, 9; 8, 11; 8, 17; 8, 46; 8, 55; 8, 78; 8, 86; 8, 100; 9, expression_statement; 9, 10; 10, string:"Finds all submodules of notebook - sorted by submodules > top level modules > manual imports. This gives notebook imports priority"; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:module_names; 14, call; 14, 15; 14, 16; 15, identifier:get_top_level_modules; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:nb_imports; 20, list_comprehension; 20, 21; 20, 27; 20, 30; 20, 40; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:match; 24, identifier:group; 25, argument_list; 25, 26; 26, integer:1; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:cell; 29, identifier:cells; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:match; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:IMPORT_RE; 35, identifier:finditer; 36, argument_list; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:cell; 39, string:'source'; 40, if_clause; 40, 41; 41, comparison_operator:==; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:cell; 44, string:'cell_type'; 45, string:'code'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:parts; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:nb_module_name; 52, identifier:split; 53, argument_list; 53, 54; 54, string:'.'; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:parent_modules; 58, list_comprehension; 58, 59; 58, 72; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, string:'.'; 62, identifier:join; 63, argument_list; 63, 64; 64, subscript; 64, 65; 64, 66; 65, identifier:parts; 66, slice; 66, 67; 66, 68; 67, colon; 68, parenthesized_expression; 68, 69; 69, binary_operator:+; 69, 70; 69, 71; 70, identifier:x; 71, integer:1; 72, for_in_clause; 72, 73; 72, 74; 73, identifier:x; 74, call; 74, 75; 74, 76; 75, identifier:range_of; 76, argument_list; 76, 77; 77, identifier:parts; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:all_modules; 81, binary_operator:+; 81, 82; 81, 85; 82, binary_operator:+; 82, 83; 82, 84; 83, identifier:module_names; 84, identifier:nb_imports; 85, identifier:parent_modules; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:mods; 89, list_comprehension; 89, 90; 89, 97; 90, call; 90, 91; 90, 92; 91, identifier:import_mod; 92, argument_list; 92, 93; 92, 94; 93, identifier:m; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:ignore_errors; 96, True; 97, for_in_clause; 97, 98; 97, 99; 98, identifier:m; 99, identifier:all_modules; 100, return_statement; 100, 101; 101, list_comprehension; 101, 102; 101, 103; 101, 106; 102, identifier:m; 103, for_in_clause; 103, 104; 103, 105; 104, identifier:m; 105, identifier:mods; 106, if_clause; 106, 107; 107, comparison_operator:is; 107, 108; 107, 109; 108, identifier:m; 109, None | def get_imported_modules(cells, nb_module_name=''):
"Finds all submodules of notebook - sorted by submodules > top level modules > manual imports. This gives notebook imports priority"
module_names = get_top_level_modules()
nb_imports = [match.group(1) for cell in cells for match in IMPORT_RE.finditer(cell['source']) if cell['cell_type'] == 'code']
parts = nb_module_name.split('.')
parent_modules = ['.'.join(parts[:(x+1)]) for x in range_of(parts)]
all_modules = module_names + nb_imports + parent_modules
mods = [import_mod(m, ignore_errors=True) for m in all_modules]
return [m for m in mods if m is not None] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:numericalize_tok; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:tokens; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_vocab; 7, integer:50000; 8, default_parameter; 8, 9; 8, 10; 9, identifier:min_freq; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:unk_tok; 13, string:"_unk_"; 14, default_parameter; 14, 15; 14, 16; 15, identifier:pad_tok; 16, string:"_pad_"; 17, default_parameter; 17, 18; 17, 19; 18, identifier:bos_tok; 19, string:"_bos_"; 20, default_parameter; 20, 21; 20, 22; 21, identifier:eos_tok; 22, string:"_eos_"; 23, block; 23, 24; 23, 36; 23, 56; 23, 63; 23, 82; 23, 86; 23, 94; 23, 102; 23, 110; 23, 118; 23, 140; 24, if_statement; 24, 25; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:tokens; 29, identifier:str; 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:"Expected to receive a list of tokens. Received a string instead"; 36, if_statement; 36, 37; 36, 44; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:tokens; 42, integer:0; 43, identifier:list; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:tokens; 48, list_comprehension; 48, 49; 48, 50; 48, 53; 49, identifier:p; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:o; 52, identifier:tokens; 53, for_in_clause; 53, 54; 53, 55; 54, identifier:p; 55, identifier:o; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:freq; 59, call; 59, 60; 59, 61; 60, identifier:Counter; 61, argument_list; 61, 62; 62, identifier:tokens; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:int2tok; 66, list_comprehension; 66, 67; 66, 68; 66, 78; 67, identifier:o; 68, for_in_clause; 68, 69; 68, 72; 69, pattern_list; 69, 70; 69, 71; 70, identifier:o; 71, identifier:c; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:freq; 75, identifier:most_common; 76, argument_list; 76, 77; 77, identifier:max_vocab; 78, if_clause; 78, 79; 79, comparison_operator:>; 79, 80; 79, 81; 80, identifier:c; 81, identifier:min_freq; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:unk_id; 85, integer:3; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:int2tok; 90, identifier:insert; 91, argument_list; 91, 92; 91, 93; 92, integer:0; 93, identifier:bos_tok; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:int2tok; 98, identifier:insert; 99, argument_list; 99, 100; 99, 101; 100, integer:1; 101, identifier:pad_tok; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:int2tok; 106, identifier:insert; 107, argument_list; 107, 108; 107, 109; 108, integer:2; 109, identifier:eos_tok; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:int2tok; 114, identifier:insert; 115, argument_list; 115, 116; 115, 117; 116, identifier:unk_id; 117, identifier:unk_tok; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:tok2int; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:collections; 124, identifier:defaultdict; 125, argument_list; 125, 126; 125, 128; 126, lambda; 126, 127; 127, identifier:unk_id; 128, dictionary_comprehension; 128, 129; 128, 132; 129, pair; 129, 130; 129, 131; 130, identifier:v; 131, identifier:k; 132, for_in_clause; 132, 133; 132, 136; 133, pattern_list; 133, 134; 133, 135; 134, identifier:k; 135, identifier:v; 136, call; 136, 137; 136, 138; 137, identifier:enumerate; 138, argument_list; 138, 139; 139, identifier:int2tok; 140, return_statement; 140, 141; 141, expression_list; 141, 142; 141, 143; 142, identifier:int2tok; 143, identifier:tok2int | def numericalize_tok(tokens, max_vocab=50000, min_freq=0, unk_tok="_unk_", pad_tok="_pad_", bos_tok="_bos_", eos_tok="_eos_"):
if isinstance(tokens, str):
raise ValueError("Expected to receive a list of tokens. Received a string instead")
if isinstance(tokens[0], list):
tokens = [p for o in tokens for p in o]
freq = Counter(tokens)
int2tok = [o for o,c in freq.most_common(max_vocab) if c>min_freq]
unk_id = 3
int2tok.insert(0, bos_tok)
int2tok.insert(1, pad_tok)
int2tok.insert(2, eos_tok)
int2tok.insert(unk_id, unk_tok)
tok2int = collections.defaultdict(lambda:unk_id, {v:k for k,v in enumerate(int2tok)})
return int2tok, tok2int |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_freq_tuples; 3, parameters; 3, 4; 3, 5; 4, identifier:my_list; 5, identifier:print_total_threshold; 6, block; 6, 7; 6, 11; 6, 29; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:d; 10, dictionary; 11, for_statement; 11, 12; 11, 13; 11, 14; 12, identifier:token; 13, identifier:my_list; 14, block; 14, 15; 14, 23; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:d; 19, identifier:setdefault; 20, argument_list; 20, 21; 20, 22; 21, identifier:token; 22, integer:0; 23, expression_statement; 23, 24; 24, augmented_assignment:+=; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:d; 27, identifier:token; 28, integer:1; 29, return_statement; 29, 30; 30, subscript; 30, 31; 30, 50; 31, call; 31, 32; 31, 33; 32, identifier:sorted; 33, argument_list; 33, 34; 33, 39; 33, 47; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:d; 37, identifier:items; 38, argument_list; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:key; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:operator; 44, identifier:itemgetter; 45, argument_list; 45, 46; 46, integer:1; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:reverse; 49, True; 50, slice; 50, 51; 50, 52; 51, colon; 52, identifier:print_total_threshold | def get_freq_tuples(my_list, print_total_threshold):
d = {}
for token in my_list:
d.setdefault(token, 0)
d[token] += 1
return sorted(d.items(), key=operator.itemgetter(1), reverse=True)[:print_total_threshold] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_levels; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:arcs; 6, block; 6, 7; 6, 27; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:levels; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:map; 15, argument_list; 15, 16; 15, 26; 16, lambda; 16, 17; 16, 19; 17, lambda_parameters; 17, 18; 18, identifier:arc; 19, binary_operator:-; 19, 20; 19, 23; 20, subscript; 20, 21; 20, 22; 21, identifier:arc; 22, string:"end"; 23, subscript; 23, 24; 23, 25; 24, identifier:arc; 25, string:"start"; 26, identifier:arcs; 27, return_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:sorted; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:list; 33, argument_list; 33, 34; 34, identifier:levels | def get_levels(self, arcs):
levels = set(map(lambda arc: arc["end"] - arc["start"], arcs))
return sorted(list(levels)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:organize_commands; 3, parameters; 3, 4; 4, identifier:corrected_commands; 5, block; 5, 6; 5, 22; 5, 45; 5, 60; 5, 88; 6, try_statement; 6, 7; 6, 18; 7, block; 7, 8; 7, 15; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:first_command; 11, call; 11, 12; 11, 13; 12, identifier:next; 13, argument_list; 13, 14; 14, identifier:corrected_commands; 15, expression_statement; 15, 16; 16, yield; 16, 17; 17, identifier:first_command; 18, except_clause; 18, 19; 18, 20; 19, identifier:StopIteration; 20, block; 20, 21; 21, return_statement; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:without_duplicates; 25, set_comprehension; 25, 26; 25, 27; 25, 41; 26, identifier:command; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:command; 29, call; 29, 30; 29, 31; 30, identifier:sorted; 31, argument_list; 31, 32; 31, 33; 32, identifier:corrected_commands; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:key; 35, lambda; 35, 36; 35, 38; 36, lambda_parameters; 36, 37; 37, identifier:command; 38, attribute; 38, 39; 38, 40; 39, identifier:command; 40, identifier:priority; 41, if_clause; 41, 42; 42, comparison_operator:!=; 42, 43; 42, 44; 43, identifier:command; 44, identifier:first_command; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:sorted_commands; 48, call; 48, 49; 48, 50; 49, identifier:sorted; 50, argument_list; 50, 51; 50, 52; 51, identifier:without_duplicates; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:key; 54, lambda; 54, 55; 54, 57; 55, lambda_parameters; 55, 56; 56, identifier:corrected_command; 57, attribute; 57, 58; 57, 59; 58, identifier:corrected_command; 59, identifier:priority; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:logs; 64, identifier:debug; 65, argument_list; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, string:'Corrected commands: '; 69, identifier:format; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, string:', '; 74, identifier:join; 75, generator_expression; 75, 76; 75, 82; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:u'{}'; 79, identifier:format; 80, argument_list; 80, 81; 81, identifier:cmd; 82, for_in_clause; 82, 83; 82, 84; 83, identifier:cmd; 84, binary_operator:+; 84, 85; 84, 87; 85, list:[first_command]; 85, 86; 86, identifier:first_command; 87, identifier:sorted_commands; 88, for_statement; 88, 89; 88, 90; 88, 91; 89, identifier:command; 90, identifier:sorted_commands; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, yield; 93, 94; 94, identifier:command | def organize_commands(corrected_commands):
try:
first_command = next(corrected_commands)
yield first_command
except StopIteration:
return
without_duplicates = {
command for command in sorted(
corrected_commands, key=lambda command: command.priority)
if command != first_command}
sorted_commands = sorted(
without_duplicates,
key=lambda corrected_command: corrected_command.priority)
logs.debug('Corrected commands: '.format(
', '.join(u'{}'.format(cmd) for cmd in [first_command] + sorted_commands)))
for command in sorted_commands:
yield command |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_corrected_commands; 3, parameters; 3, 4; 4, identifier:command; 5, block; 5, 6; 5, 31; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:corrected_commands; 9, generator_expression; 9, 10; 9, 11; 9, 16; 9, 23; 10, identifier:corrected; 11, for_in_clause; 11, 12; 11, 13; 12, identifier:rule; 13, call; 13, 14; 13, 15; 14, identifier:get_rules; 15, argument_list; 16, if_clause; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:rule; 20, identifier:is_match; 21, argument_list; 21, 22; 22, identifier:command; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:corrected; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:rule; 28, identifier:get_corrected_commands; 29, argument_list; 29, 30; 30, identifier:command; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:organize_commands; 34, argument_list; 34, 35; 35, identifier:corrected_commands | def get_corrected_commands(command):
corrected_commands = (
corrected for rule in get_rules()
if rule.is_match(command)
for corrected in rule.get_corrected_commands(command))
return organize_commands(corrected_commands) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:_partition_query; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:cls; 5, identifier:table_name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:limit; 8, integer:0; 9, default_parameter; 9, 10; 9, 11; 10, identifier:order_by; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:filters; 14, None; 15, block; 15, 16; 15, 28; 15, 32; 15, 68; 15, 72; 15, 107; 15, 116; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:limit_clause; 19, conditional_expression:if; 19, 20; 19, 26; 19, 27; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, string:'LIMIT {}'; 23, identifier:format; 24, argument_list; 24, 25; 25, identifier:limit; 26, identifier:limit; 27, string:''; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:order_by_clause; 31, string:''; 32, if_statement; 32, 33; 32, 34; 33, identifier:order_by; 34, block; 34, 35; 34, 39; 34, 57; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:l; 38, list:[]; 39, for_statement; 39, 40; 39, 43; 39, 44; 40, pattern_list; 40, 41; 40, 42; 41, identifier:field; 42, identifier:desc; 43, identifier:order_by; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:l; 49, identifier:append; 50, argument_list; 50, 51; 51, conditional_expression:if; 51, 52; 51, 55; 51, 56; 52, binary_operator:+; 52, 53; 52, 54; 53, identifier:field; 54, string:' DESC'; 55, identifier:desc; 56, string:''; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:order_by_clause; 60, binary_operator:+; 60, 61; 60, 62; 61, string:'ORDER BY '; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, string:', '; 65, identifier:join; 66, argument_list; 66, 67; 67, identifier:l; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:where_clause; 71, string:''; 72, if_statement; 72, 73; 72, 74; 73, identifier:filters; 74, block; 74, 75; 74, 79; 74, 96; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:l; 78, list:[]; 79, for_statement; 79, 80; 79, 83; 79, 88; 80, pattern_list; 80, 81; 80, 82; 81, identifier:field; 82, identifier:value; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:filters; 86, identifier:items; 87, argument_list; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:l; 93, identifier:append; 94, argument_list; 94, 95; 95, string:f"{field} = '{value}'"; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:where_clause; 99, binary_operator:+; 99, 100; 99, 101; 100, string:'WHERE '; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, string:' AND '; 104, identifier:join; 105, argument_list; 105, 106; 106, identifier:l; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:sql; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:textwrap; 113, identifier:dedent; 114, argument_list; 114, 115; 115, identifier:f; 116, return_statement; 116, 117; 117, identifier:sql | def _partition_query(
cls, table_name, limit=0, order_by=None, filters=None):
limit_clause = 'LIMIT {}'.format(limit) if limit else ''
order_by_clause = ''
if order_by:
l = []
for field, desc in order_by:
l.append(field + ' DESC' if desc else '')
order_by_clause = 'ORDER BY ' + ', '.join(l)
where_clause = ''
if filters:
l = []
for field, value in filters.items():
l.append(f"{field} = '{value}'")
where_clause = 'WHERE ' + ' AND '.join(l)
sql = textwrap.dedent(f
)
return sql |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:cocktail_shaker_sort; 3, parameters; 3, 4; 4, identifier:arr; 5, block; 5, 6; 5, 28; 5, 35; 5, 39; 5, 123; 6, function_definition; 6, 7; 6, 8; 6, 11; 7, function_name:swap; 8, parameters; 8, 9; 8, 10; 9, identifier:i; 10, identifier:j; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 21; 14, pattern_list; 14, 15; 14, 18; 15, subscript; 15, 16; 15, 17; 16, identifier:arr; 17, identifier:i; 18, subscript; 18, 19; 18, 20; 19, identifier:arr; 20, identifier:j; 21, expression_list; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:arr; 24, identifier:j; 25, subscript; 25, 26; 25, 27; 26, identifier:arr; 27, identifier:i; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:n; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:arr; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:swapped; 38, True; 39, while_statement; 39, 40; 39, 41; 40, identifier:swapped; 41, block; 41, 42; 41, 46; 41, 77; 41, 84; 41, 88; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:swapped; 45, False; 46, for_statement; 46, 47; 46, 48; 46, 53; 47, identifier:i; 48, call; 48, 49; 48, 50; 49, identifier:range; 50, argument_list; 50, 51; 50, 52; 51, integer:1; 52, identifier:n; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 64; 55, comparison_operator:>; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 58; 57, identifier:arr; 58, binary_operator:-; 58, 59; 58, 60; 59, identifier:i; 60, integer:1; 61, subscript; 61, 62; 61, 63; 62, identifier:arr; 63, identifier:i; 64, block; 64, 65; 64, 73; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:swap; 68, argument_list; 68, 69; 68, 72; 69, binary_operator:-; 69, 70; 69, 71; 70, identifier:i; 71, integer:1; 72, identifier:i; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:swapped; 76, True; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:==; 78, 79; 78, 80; 79, identifier:swapped; 80, False; 81, block; 81, 82; 82, return_statement; 82, 83; 83, identifier:arr; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:swapped; 87, False; 88, for_statement; 88, 89; 88, 90; 88, 99; 89, identifier:i; 90, call; 90, 91; 90, 92; 91, identifier:range; 92, argument_list; 92, 93; 92, 96; 92, 97; 93, binary_operator:-; 93, 94; 93, 95; 94, identifier:n; 95, integer:1; 96, integer:0; 97, unary_operator:-; 97, 98; 98, integer:1; 99, block; 99, 100; 100, if_statement; 100, 101; 100, 110; 101, comparison_operator:>; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 104; 103, identifier:arr; 104, binary_operator:-; 104, 105; 104, 106; 105, identifier:i; 106, integer:1; 107, subscript; 107, 108; 107, 109; 108, identifier:arr; 109, identifier:i; 110, block; 110, 111; 110, 119; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:swap; 114, argument_list; 114, 115; 114, 118; 115, binary_operator:-; 115, 116; 115, 117; 116, identifier:i; 117, integer:1; 118, identifier:i; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:swapped; 122, True; 123, return_statement; 123, 124; 124, identifier:arr | def cocktail_shaker_sort(arr):
def swap(i, j):
arr[i], arr[j] = arr[j], arr[i]
n = len(arr)
swapped = True
while swapped:
swapped = False
for i in range(1, n):
if arr[i - 1] > arr[i]:
swap(i - 1, i)
swapped = True
if swapped == False:
return arr
swapped = False
for i in range(n-1,0,-1):
if arr[i - 1] > arr[i]:
swap(i - 1, i)
swapped = True
return arr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:max_heapify; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:arr; 5, identifier:end; 6, identifier:simulation; 7, identifier:iteration; 8, block; 8, 9; 8, 18; 8, 119; 8, 135; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:last_parent; 12, binary_operator://; 12, 13; 12, 17; 13, parenthesized_expression; 13, 14; 14, binary_operator:-; 14, 15; 14, 16; 15, identifier:end; 16, integer:1; 17, integer:2; 18, for_statement; 18, 19; 18, 20; 18, 28; 19, identifier:parent; 20, call; 20, 21; 20, 22; 21, identifier:range; 22, argument_list; 22, 23; 22, 24; 22, 26; 23, identifier:last_parent; 24, unary_operator:-; 24, 25; 25, integer:1; 26, unary_operator:-; 26, 27; 27, integer:1; 28, block; 28, 29; 28, 33; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:current_parent; 32, identifier:parent; 33, while_statement; 33, 34; 33, 37; 34, comparison_operator:<=; 34, 35; 34, 36; 35, identifier:current_parent; 36, identifier:last_parent; 37, block; 37, 38; 37, 46; 37, 69; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:child; 41, binary_operator:+; 41, 42; 41, 45; 42, binary_operator:*; 42, 43; 42, 44; 43, integer:2; 44, identifier:current_parent; 45, integer:1; 46, if_statement; 46, 47; 46, 62; 47, boolean_operator:and; 47, 48; 47, 53; 48, comparison_operator:<=; 48, 49; 48, 52; 49, binary_operator:+; 49, 50; 49, 51; 50, identifier:child; 51, integer:1; 52, identifier:end; 53, comparison_operator:<; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:arr; 56, identifier:child; 57, subscript; 57, 58; 57, 59; 58, identifier:arr; 59, binary_operator:+; 59, 60; 59, 61; 60, identifier:child; 61, integer:1; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:child; 66, binary_operator:+; 66, 67; 66, 68; 67, identifier:child; 68, integer:1; 69, if_statement; 69, 70; 69, 77; 69, 116; 70, comparison_operator:>; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:arr; 73, identifier:child; 74, subscript; 74, 75; 74, 76; 75, identifier:arr; 76, identifier:current_parent; 77, block; 77, 78; 77, 94; 77, 98; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 87; 80, pattern_list; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:arr; 83, identifier:current_parent; 84, subscript; 84, 85; 84, 86; 85, identifier:arr; 86, identifier:child; 87, expression_list; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:arr; 90, identifier:child; 91, subscript; 91, 92; 91, 93; 92, identifier:arr; 93, identifier:current_parent; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:current_parent; 97, identifier:child; 98, if_statement; 98, 99; 98, 100; 99, identifier:simulation; 100, block; 100, 101; 100, 107; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:iteration; 104, binary_operator:+; 104, 105; 104, 106; 105, identifier:iteration; 106, integer:1; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:print; 110, argument_list; 110, 111; 110, 112; 110, 113; 110, 114; 111, string:"iteration"; 112, identifier:iteration; 113, string:":"; 114, list_splat; 114, 115; 115, identifier:arr; 116, else_clause; 116, 117; 117, block; 117, 118; 118, break_statement; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 128; 121, pattern_list; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:arr; 124, integer:0; 125, subscript; 125, 126; 125, 127; 126, identifier:arr; 127, identifier:end; 128, expression_list; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:arr; 131, identifier:end; 132, subscript; 132, 133; 132, 134; 133, identifier:arr; 134, integer:0; 135, return_statement; 135, 136; 136, identifier:iteration | def max_heapify(arr, end, simulation, iteration):
last_parent = (end - 1) // 2
for parent in range(last_parent, -1, -1):
current_parent = parent
while current_parent <= last_parent:
child = 2 * current_parent + 1
if child + 1 <= end and arr[child] < arr[child + 1]:
child = child + 1
if arr[child] > arr[current_parent]:
arr[current_parent], arr[child] = arr[child], arr[current_parent]
current_parent = child
if simulation:
iteration = iteration + 1
print("iteration",iteration,":",*arr)
else:
break
arr[0], arr[end] = arr[end], arr[0]
return iteration |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:min_heapify; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:arr; 5, identifier:start; 6, identifier:simulation; 7, identifier:iteration; 8, block; 8, 9; 8, 18; 8, 29; 8, 149; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:end; 12, binary_operator:-; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:len; 15, argument_list; 15, 16; 16, identifier:arr; 17, integer:1; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:last_parent; 21, binary_operator://; 21, 22; 21, 28; 22, parenthesized_expression; 22, 23; 23, binary_operator:-; 23, 24; 23, 27; 24, binary_operator:-; 24, 25; 24, 26; 25, identifier:end; 26, identifier:start; 27, integer:1; 28, integer:2; 29, for_statement; 29, 30; 29, 31; 29, 39; 30, identifier:parent; 31, call; 31, 32; 31, 33; 32, identifier:range; 33, argument_list; 33, 34; 33, 35; 33, 37; 34, identifier:last_parent; 35, unary_operator:-; 35, 36; 36, integer:1; 37, unary_operator:-; 37, 38; 38, integer:1; 39, block; 39, 40; 39, 44; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:current_parent; 43, identifier:parent; 44, while_statement; 44, 45; 44, 48; 45, comparison_operator:<=; 45, 46; 45, 47; 46, identifier:current_parent; 47, identifier:last_parent; 48, block; 48, 49; 48, 57; 48, 86; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:child; 52, binary_operator:+; 52, 53; 52, 56; 53, binary_operator:*; 53, 54; 53, 55; 54, integer:2; 55, identifier:current_parent; 56, integer:1; 57, if_statement; 57, 58; 57, 79; 58, boolean_operator:and; 58, 59; 58, 66; 59, comparison_operator:<=; 59, 60; 59, 63; 60, binary_operator:+; 60, 61; 60, 62; 61, identifier:child; 62, integer:1; 63, binary_operator:-; 63, 64; 63, 65; 64, identifier:end; 65, identifier:start; 66, comparison_operator:>; 66, 67; 66, 72; 67, subscript; 67, 68; 67, 69; 68, identifier:arr; 69, binary_operator:+; 69, 70; 69, 71; 70, identifier:child; 71, identifier:start; 72, subscript; 72, 73; 72, 74; 73, identifier:arr; 74, binary_operator:+; 74, 75; 74, 78; 75, binary_operator:+; 75, 76; 75, 77; 76, identifier:child; 77, integer:1; 78, identifier:start; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:child; 83, binary_operator:+; 83, 84; 83, 85; 84, identifier:child; 85, integer:1; 86, if_statement; 86, 87; 86, 98; 86, 146; 87, comparison_operator:<; 87, 88; 87, 93; 88, subscript; 88, 89; 88, 90; 89, identifier:arr; 90, binary_operator:+; 90, 91; 90, 92; 91, identifier:child; 92, identifier:start; 93, subscript; 93, 94; 93, 95; 94, identifier:arr; 95, binary_operator:+; 95, 96; 95, 97; 96, identifier:current_parent; 97, identifier:start; 98, block; 98, 99; 98, 124; 98, 128; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 112; 100, 113; 101, pattern_list; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 104; 103, identifier:arr; 104, binary_operator:+; 104, 105; 104, 106; 105, identifier:current_parent; 106, identifier:start; 107, subscript; 107, 108; 107, 109; 108, identifier:arr; 109, binary_operator:+; 109, 110; 109, 111; 110, identifier:child; 111, identifier:start; 112, line_continuation:\; 113, expression_list; 113, 114; 113, 119; 114, subscript; 114, 115; 114, 116; 115, identifier:arr; 116, binary_operator:+; 116, 117; 116, 118; 117, identifier:child; 118, identifier:start; 119, subscript; 119, 120; 119, 121; 120, identifier:arr; 121, binary_operator:+; 121, 122; 121, 123; 122, identifier:current_parent; 123, identifier:start; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:current_parent; 127, identifier:child; 128, if_statement; 128, 129; 128, 130; 129, identifier:simulation; 130, block; 130, 131; 130, 137; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:iteration; 134, binary_operator:+; 134, 135; 134, 136; 135, identifier:iteration; 136, integer:1; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:print; 140, argument_list; 140, 141; 140, 142; 140, 143; 140, 144; 141, string:"iteration"; 142, identifier:iteration; 143, string:":"; 144, list_splat; 144, 145; 145, identifier:arr; 146, else_clause; 146, 147; 147, block; 147, 148; 148, break_statement; 149, return_statement; 149, 150; 150, identifier:iteration | def min_heapify(arr, start, simulation, iteration):
end = len(arr) - 1
last_parent = (end - start - 1) // 2
for parent in range(last_parent, -1, -1):
current_parent = parent
while current_parent <= last_parent:
child = 2 * current_parent + 1
if child + 1 <= end - start and arr[child + start] > arr[
child + 1 + start]:
child = child + 1
if arr[child + start] < arr[current_parent + start]:
arr[current_parent + start], arr[child + start] = \
arr[child + start], arr[current_parent + start]
current_parent = child
if simulation:
iteration = iteration + 1
print("iteration",iteration,":",*arr)
else:
break
return iteration |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:pancake_sort; 3, parameters; 3, 4; 4, identifier:arr; 5, block; 5, 6; 5, 13; 5, 20; 5, 96; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:len_arr; 9, call; 9, 10; 9, 11; 10, identifier:len; 11, argument_list; 11, 12; 12, identifier:arr; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:<=; 14, 15; 14, 16; 15, identifier:len_arr; 16, integer:1; 17, block; 17, 18; 18, return_statement; 18, 19; 19, identifier:arr; 20, for_statement; 20, 21; 20, 22; 20, 32; 21, identifier:cur; 22, call; 22, 23; 22, 24; 23, identifier:range; 24, argument_list; 24, 25; 24, 29; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:len; 27, argument_list; 27, 28; 28, identifier:arr; 29, integer:1; 30, unary_operator:-; 30, 31; 31, integer:1; 32, block; 32, 33; 32, 50; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:index_max; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:arr; 39, identifier:index; 40, argument_list; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:max; 43, argument_list; 43, 44; 44, subscript; 44, 45; 44, 46; 45, identifier:arr; 46, slice; 46, 47; 46, 48; 46, 49; 47, integer:0; 48, colon; 49, identifier:cur; 50, if_statement; 50, 51; 50, 56; 51, comparison_operator:!=; 51, 52; 51, 55; 52, binary_operator:+; 52, 53; 52, 54; 53, identifier:index_max; 54, integer:1; 55, identifier:cur; 56, block; 56, 57; 56, 81; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:!=; 58, 59; 58, 60; 59, identifier:index_max; 60, integer:0; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 71; 64, subscript; 64, 65; 64, 66; 65, identifier:arr; 66, slice; 66, 67; 66, 68; 67, colon; 68, binary_operator:+; 68, 69; 68, 70; 69, identifier:index_max; 70, integer:1; 71, call; 71, 72; 71, 73; 72, identifier:reversed; 73, argument_list; 73, 74; 74, subscript; 74, 75; 74, 76; 75, identifier:arr; 76, slice; 76, 77; 76, 78; 77, colon; 78, binary_operator:+; 78, 79; 78, 80; 79, identifier:index_max; 80, integer:1; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 85; 84, identifier:arr; 85, slice; 85, 86; 85, 87; 86, colon; 87, identifier:cur; 88, call; 88, 89; 88, 90; 89, identifier:reversed; 90, argument_list; 90, 91; 91, subscript; 91, 92; 91, 93; 92, identifier:arr; 93, slice; 93, 94; 93, 95; 94, colon; 95, identifier:cur; 96, return_statement; 96, 97; 97, identifier:arr | def pancake_sort(arr):
len_arr = len(arr)
if len_arr <= 1:
return arr
for cur in range(len(arr), 1, -1):
index_max = arr.index(max(arr[0:cur]))
if index_max+1 != cur:
if index_max != 0:
arr[:index_max+1] = reversed(arr[:index_max+1])
arr[:cur] = reversed(arr[:cur])
return arr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:natural_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, lambda; 7, 8; 7, 10; 8, lambda_parameters; 8, 9; 9, identifier:s; 10, identifier:s; 11, block; 11, 12; 11, 55; 11, 62; 12, function_definition; 12, 13; 12, 14; 12, 16; 13, function_name:get_alphanum_key_func; 14, parameters; 14, 15; 15, identifier:key; 16, block; 16, 17; 16, 34; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:convert; 20, lambda; 20, 21; 20, 23; 21, lambda_parameters; 21, 22; 22, identifier:text; 23, conditional_expression:if; 23, 24; 23, 28; 23, 33; 24, call; 24, 25; 24, 26; 25, identifier:int; 26, argument_list; 26, 27; 27, identifier:text; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:text; 31, identifier:isdigit; 32, argument_list; 33, identifier:text; 34, return_statement; 34, 35; 35, lambda; 35, 36; 35, 38; 36, lambda_parameters; 36, 37; 37, identifier:s; 38, list_comprehension; 38, 39; 38, 43; 39, call; 39, 40; 39, 41; 40, identifier:convert; 41, argument_list; 41, 42; 42, identifier:c; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:c; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:re; 48, identifier:split; 49, argument_list; 49, 50; 49, 51; 50, string:'([0-9]+)'; 51, call; 51, 52; 51, 53; 52, identifier:key; 53, argument_list; 53, 54; 54, identifier:s; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:sort_key; 58, call; 58, 59; 58, 60; 59, identifier:get_alphanum_key_func; 60, argument_list; 60, 61; 61, identifier:key; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:list; 66, identifier:sort; 67, argument_list; 67, 68; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:key; 70, identifier:sort_key | def natural_sort(list, key=lambda s:s):
def get_alphanum_key_func(key):
convert = lambda text: int(text) if text.isdigit() else text
return lambda s: [convert(c) for c in re.split('([0-9]+)', key(s))]
sort_key = get_alphanum_key_func(key)
list.sort(key=sort_key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_build_vocab; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:filename; 5, identifier:vocab_path; 6, identifier:vocab_size; 7, block; 7, 8; 7, 15; 7, 24; 7, 48; 7, 61; 7, 69; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:data; 11, call; 11, 12; 11, 13; 12, identifier:_read_words; 13, argument_list; 13, 14; 14, identifier:filename; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:counter; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:collections; 21, identifier:Counter; 22, argument_list; 22, 23; 23, identifier:data; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:count_pairs; 27, call; 27, 28; 27, 29; 28, identifier:sorted; 29, argument_list; 29, 30; 29, 35; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:counter; 33, identifier:items; 34, argument_list; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:key; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:x; 40, tuple; 40, 41; 40, 45; 41, unary_operator:-; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:x; 44, integer:1; 45, subscript; 45, 46; 45, 47; 46, identifier:x; 47, integer:0; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:words; 52, identifier:_; 53, call; 53, 54; 53, 55; 54, identifier:list; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:zip; 58, argument_list; 58, 59; 59, list_splat; 59, 60; 60, identifier:count_pairs; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:words; 64, subscript; 64, 65; 64, 66; 65, identifier:words; 66, slice; 66, 67; 66, 68; 67, colon; 68, identifier:vocab_size; 69, with_statement; 69, 70; 69, 80; 70, with_clause; 70, 71; 71, with_item; 71, 72; 72, as_pattern; 72, 73; 72, 78; 73, call; 73, 74; 73, 75; 74, identifier:open; 75, argument_list; 75, 76; 75, 77; 76, identifier:vocab_path; 77, string:"w"; 78, as_pattern_target; 78, 79; 79, identifier:f; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:f; 85, identifier:write; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, string:"\n"; 90, identifier:join; 91, argument_list; 91, 92; 92, identifier:words | def _build_vocab(filename, vocab_path, vocab_size):
data = _read_words(filename)
counter = collections.Counter(data)
count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))
words, _ = list(zip(*count_pairs))
words = words[:vocab_size]
with open(vocab_path, "w") as f:
f.write("\n".join(words)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_read_stepfiles_list; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:path_prefix; 5, default_parameter; 5, 6; 5, 7; 6, identifier:path_suffix; 7, string:".index"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:min_steps; 10, integer:0; 11, block; 11, 12; 11, 16; 11, 119; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:stepfiles; 15, list:[]; 16, for_statement; 16, 17; 16, 18; 16, 26; 17, identifier:filename; 18, call; 18, 19; 18, 20; 19, identifier:_try_twice_tf_glob; 20, argument_list; 20, 21; 21, binary_operator:+; 21, 22; 21, 25; 22, binary_operator:+; 22, 23; 22, 24; 23, identifier:path_prefix; 24, string:"*-[0-9]*"; 25, identifier:path_suffix; 26, block; 26, 27; 26, 42; 26, 63; 26, 69; 26, 92; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:basename; 30, conditional_expression:if; 30, 31; 30, 40; 30, 41; 31, subscript; 31, 32; 31, 33; 32, identifier:filename; 33, slice; 33, 34; 33, 35; 34, colon; 35, unary_operator:-; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:path_suffix; 40, identifier:path_suffix; 41, identifier:filename; 42, try_statement; 42, 43; 42, 59; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:steps; 47, call; 47, 48; 47, 49; 48, identifier:int; 49, argument_list; 49, 50; 50, subscript; 50, 51; 50, 57; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:basename; 54, identifier:rsplit; 55, argument_list; 55, 56; 56, string:"-"; 57, unary_operator:-; 57, 58; 58, integer:1; 59, except_clause; 59, 60; 59, 61; 60, identifier:ValueError; 61, block; 61, 62; 62, continue_statement; 63, if_statement; 63, 64; 63, 67; 64, comparison_operator:<; 64, 65; 64, 66; 65, identifier:steps; 66, identifier:min_steps; 67, block; 67, 68; 68, continue_statement; 69, if_statement; 69, 70; 69, 79; 70, not_operator; 70, 71; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:os; 75, identifier:path; 76, identifier:exists; 77, argument_list; 77, 78; 78, identifier:filename; 79, block; 79, 80; 79, 91; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:tf; 85, identifier:logging; 86, identifier:info; 87, argument_list; 87, 88; 88, binary_operator:+; 88, 89; 88, 90; 89, identifier:filename; 90, string:" was deleted, so skipping it"; 91, continue_statement; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:stepfiles; 96, identifier:append; 97, argument_list; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:StepFile; 100, argument_list; 100, 101; 100, 102; 100, 110; 100, 118; 101, identifier:basename; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:os; 106, identifier:path; 107, identifier:getmtime; 108, argument_list; 108, 109; 109, identifier:filename; 110, call; 110, 111; 110, 116; 111, attribute; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:os; 114, identifier:path; 115, identifier:getctime; 116, argument_list; 116, 117; 117, identifier:filename; 118, identifier:steps; 119, return_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:sorted; 122, argument_list; 122, 123; 122, 124; 123, identifier:stepfiles; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:key; 126, lambda; 126, 127; 126, 129; 127, lambda_parameters; 127, 128; 128, identifier:x; 129, unary_operator:-; 129, 130; 130, attribute; 130, 131; 130, 132; 131, identifier:x; 132, identifier:steps | def _read_stepfiles_list(path_prefix, path_suffix=".index", min_steps=0):
stepfiles = []
for filename in _try_twice_tf_glob(path_prefix + "*-[0-9]*" + path_suffix):
basename = filename[:-len(path_suffix)] if path_suffix else filename
try:
steps = int(basename.rsplit("-")[-1])
except ValueError:
continue
if steps < min_steps:
continue
if not os.path.exists(filename):
tf.logging.info(filename + " was deleted, so skipping it")
continue
stepfiles.append(StepFile(basename, os.path.getmtime(filename),
os.path.getctime(filename), steps))
return sorted(stepfiles, key=lambda x: -x.steps) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:to_json; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:indent; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:separators; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_keys; 13, False; 14, block; 14, 15; 14, 75; 15, function_definition; 15, 16; 15, 17; 15, 19; 16, function_name:remove_callables; 17, parameters; 17, 18; 18, identifier:x; 19, block; 19, 20; 19, 73; 20, if_statement; 20, 21; 20, 26; 20, 51; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:x; 25, identifier:dict; 26, block; 26, 27; 27, return_statement; 27, 28; 28, dictionary_comprehension; 28, 29; 28, 35; 28, 45; 29, pair; 29, 30; 29, 31; 30, identifier:k; 31, call; 31, 32; 31, 33; 32, identifier:remove_callables; 33, argument_list; 33, 34; 34, identifier:v; 35, for_in_clause; 35, 36; 35, 39; 36, pattern_list; 36, 37; 36, 38; 37, identifier:k; 38, identifier:v; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:six; 42, identifier:iteritems; 43, argument_list; 43, 44; 44, identifier:x; 45, if_clause; 45, 46; 46, not_operator; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:callable; 49, argument_list; 49, 50; 50, identifier:v; 51, elif_clause; 51, 52; 51, 57; 52, call; 52, 53; 52, 54; 53, identifier:isinstance; 54, argument_list; 54, 55; 54, 56; 55, identifier:x; 56, identifier:list; 57, block; 57, 58; 58, return_statement; 58, 59; 59, list_comprehension; 59, 60; 59, 64; 59, 67; 60, call; 60, 61; 60, 62; 61, identifier:remove_callables; 62, argument_list; 62, 63; 63, identifier:i; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:i; 66, identifier:x; 67, if_clause; 67, 68; 68, not_operator; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:callable; 71, argument_list; 71, 72; 72, identifier:i; 73, return_statement; 73, 74; 74, identifier:x; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:json; 79, identifier:dumps; 80, argument_list; 80, 81; 80, 89; 80, 92; 80, 95; 81, call; 81, 82; 81, 83; 82, identifier:remove_callables; 83, argument_list; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:values; 88, argument_list; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:indent; 91, identifier:indent; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:separators; 94, identifier:separators; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:sort_keys; 97, identifier:sort_keys | def to_json(self, indent=None, separators=None, sort_keys=False):
def remove_callables(x):
if isinstance(x, dict):
return {k: remove_callables(v) for k, v in six.iteritems(x)
if not callable(v)}
elif isinstance(x, list):
return [remove_callables(i) for i in x if not callable(i)]
return x
return json.dumps(
remove_callables(self.values()),
indent=indent,
separators=separators,
sort_keys=sort_keys) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_create_topk_unique; 3, parameters; 3, 4; 3, 5; 4, identifier:inputs; 5, identifier:k; 6, block; 6, 7; 6, 15; 6, 23; 6, 40; 6, 56; 6, 62; 6, 78; 6, 82; 6, 98; 6, 204; 6, 228; 6, 234; 6, 240; 6, 249; 6, 261; 6, 273; 6, 285; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:height; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:inputs; 13, identifier:shape; 14, integer:0; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:width; 18, subscript; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:inputs; 21, identifier:shape; 22, integer:1; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:neg_inf_r0; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:tf; 29, identifier:constant; 30, argument_list; 30, 31; 30, 35; 31, unary_operator:-; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:inf; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:dtype; 37, attribute; 37, 38; 37, 39; 38, identifier:tf; 39, identifier:float32; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:ones; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:tf; 46, identifier:ones; 47, argument_list; 47, 48; 47, 51; 48, list:[height, width]; 48, 49; 48, 50; 49, identifier:height; 50, identifier:width; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:dtype; 53, attribute; 53, 54; 53, 55; 54, identifier:tf; 55, identifier:float32; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:neg_inf_r2; 59, binary_operator:*; 59, 60; 59, 61; 60, identifier:ones; 61, identifier:neg_inf_r0; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:inputs; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:tf; 68, identifier:where; 69, argument_list; 69, 70; 69, 76; 69, 77; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:tf; 73, identifier:is_nan; 74, argument_list; 74, 75; 75, identifier:inputs; 76, identifier:neg_inf_r2; 77, identifier:inputs; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:tmp; 81, identifier:inputs; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:topk_r2; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:tf; 88, identifier:zeros; 89, argument_list; 89, 90; 89, 93; 90, list:[height, k]; 90, 91; 90, 92; 91, identifier:height; 92, identifier:k; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:dtype; 95, attribute; 95, 96; 95, 97; 96, identifier:tf; 97, identifier:float32; 98, for_statement; 98, 99; 98, 100; 98, 104; 99, identifier:i; 100, call; 100, 101; 100, 102; 101, identifier:range; 102, argument_list; 102, 103; 103, identifier:k; 104, block; 104, 105; 104, 120; 104, 156; 104, 175; 104, 193; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:kth_order_statistic; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:tf; 111, identifier:reduce_max; 112, argument_list; 112, 113; 112, 114; 112, 117; 113, identifier:tmp; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:axis; 116, integer:1; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:keepdims; 119, True; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:k_mask; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:tf; 126, identifier:tile; 127, argument_list; 127, 128; 127, 153; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:tf; 131, identifier:expand_dims; 132, argument_list; 132, 133; 132, 152; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:tf; 136, identifier:equal; 137, argument_list; 137, 138; 137, 144; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:tf; 141, identifier:range; 142, argument_list; 142, 143; 143, identifier:k; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:tf; 147, identifier:fill; 148, argument_list; 148, 149; 148, 151; 149, list:[k]; 149, 150; 150, identifier:k; 151, identifier:i; 152, integer:0; 153, list:[height, 1]; 153, 154; 153, 155; 154, identifier:height; 155, integer:1; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:topk_r2; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:tf; 162, identifier:where; 163, argument_list; 163, 164; 163, 165; 163, 174; 164, identifier:k_mask; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:tf; 168, identifier:tile; 169, argument_list; 169, 170; 169, 171; 170, identifier:kth_order_statistic; 171, list:[1, k]; 171, 172; 171, 173; 172, integer:1; 173, identifier:k; 174, identifier:topk_r2; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:ge_r2; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:tf; 181, identifier:greater_equal; 182, argument_list; 182, 183; 182, 184; 183, identifier:inputs; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:tf; 187, identifier:tile; 188, argument_list; 188, 189; 188, 190; 189, identifier:kth_order_statistic; 190, list:[1, width]; 190, 191; 190, 192; 191, integer:1; 192, identifier:width; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:tmp; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:tf; 199, identifier:where; 200, argument_list; 200, 201; 200, 202; 200, 203; 201, identifier:ge_r2; 202, identifier:neg_inf_r2; 203, identifier:inputs; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:log2_ceiling; 207, call; 207, 208; 207, 209; 208, identifier:int; 209, argument_list; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:math; 213, identifier:ceil; 214, argument_list; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:math; 218, identifier:log; 219, argument_list; 219, 220; 219, 227; 220, call; 220, 221; 220, 222; 221, identifier:float; 222, argument_list; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:int; 225, argument_list; 225, 226; 226, identifier:width; 227, integer:2; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:next_power_of_two; 231, binary_operator:<<; 231, 232; 231, 233; 232, integer:1; 233, identifier:log2_ceiling; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:count_mask; 237, binary_operator:-; 237, 238; 237, 239; 238, identifier:next_power_of_two; 239, integer:1; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:mask_r0; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:tf; 246, identifier:constant; 247, argument_list; 247, 248; 248, identifier:count_mask; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:mask_r2; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:tf; 255, identifier:fill; 256, argument_list; 256, 257; 256, 260; 257, list:[height, k]; 257, 258; 257, 259; 258, identifier:height; 259, identifier:k; 260, identifier:mask_r0; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:topk_r2_s32; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:tf; 267, identifier:bitcast; 268, argument_list; 268, 269; 268, 270; 269, identifier:topk_r2; 270, attribute; 270, 271; 270, 272; 271, identifier:tf; 272, identifier:int32; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:topk_indices_r2; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:tf; 280, identifier:bitwise; 281, identifier:bitwise_and; 282, argument_list; 282, 283; 282, 284; 283, identifier:topk_r2_s32; 284, identifier:mask_r2; 285, return_statement; 285, 286; 286, expression_list; 286, 287; 286, 288; 287, identifier:topk_r2; 288, identifier:topk_indices_r2 | def _create_topk_unique(inputs, k):
height = inputs.shape[0]
width = inputs.shape[1]
neg_inf_r0 = tf.constant(-np.inf, dtype=tf.float32)
ones = tf.ones([height, width], dtype=tf.float32)
neg_inf_r2 = ones * neg_inf_r0
inputs = tf.where(tf.is_nan(inputs), neg_inf_r2, inputs)
tmp = inputs
topk_r2 = tf.zeros([height, k], dtype=tf.float32)
for i in range(k):
kth_order_statistic = tf.reduce_max(tmp, axis=1, keepdims=True)
k_mask = tf.tile(tf.expand_dims(tf.equal(tf.range(k), tf.fill([k], i)), 0),
[height, 1])
topk_r2 = tf.where(k_mask, tf.tile(kth_order_statistic, [1, k]), topk_r2)
ge_r2 = tf.greater_equal(inputs, tf.tile(kth_order_statistic, [1, width]))
tmp = tf.where(ge_r2, neg_inf_r2, inputs)
log2_ceiling = int(math.ceil(math.log(float(int(width)), 2)))
next_power_of_two = 1 << log2_ceiling
count_mask = next_power_of_two - 1
mask_r0 = tf.constant(count_mask)
mask_r2 = tf.fill([height, k], mask_r0)
topk_r2_s32 = tf.bitcast(topk_r2, tf.int32)
topk_indices_r2 = tf.bitwise.bitwise_and(topk_r2_s32, mask_r2)
return topk_r2, topk_indices_r2 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:top_k_with_unique; 3, parameters; 3, 4; 3, 5; 4, identifier:inputs; 5, identifier:k; 6, block; 6, 7; 6, 22; 6, 32; 6, 44; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:unique_inputs; 10, call; 10, 11; 10, 12; 11, identifier:_create_make_unique; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:tf; 16, identifier:cast; 17, argument_list; 17, 18; 17, 19; 18, identifier:inputs; 19, attribute; 19, 20; 19, 21; 20, identifier:tf; 21, identifier:float32; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, pattern_list; 24, 25; 24, 26; 25, identifier:top_values; 26, identifier:indices; 27, call; 27, 28; 27, 29; 28, identifier:_create_topk_unique; 29, argument_list; 29, 30; 29, 31; 30, identifier:unique_inputs; 31, identifier:k; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:top_values; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:tf; 38, identifier:cast; 39, argument_list; 39, 40; 39, 41; 40, identifier:top_values; 41, attribute; 41, 42; 41, 43; 42, identifier:inputs; 43, identifier:dtype; 44, return_statement; 44, 45; 45, expression_list; 45, 46; 45, 47; 46, identifier:top_values; 47, identifier:indices | def top_k_with_unique(inputs, k):
unique_inputs = _create_make_unique(tf.cast(inputs, tf.float32))
top_values, indices = _create_topk_unique(unique_inputs, k)
top_values = tf.cast(top_values, inputs.dtype)
return top_values, indices |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_rowwise_unsorted_segment_sum; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:values; 5, identifier:indices; 6, identifier:n; 7, block; 7, 8; 7, 27; 7, 56; 7, 77; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 13; 10, pattern_list; 10, 11; 10, 12; 11, identifier:batch; 12, identifier:k; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:tf; 16, identifier:unstack; 17, argument_list; 17, 18; 17, 24; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:tf; 21, identifier:shape; 22, argument_list; 22, 23; 23, identifier:indices; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:num; 26, integer:2; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:indices_flat; 30, binary_operator:+; 30, 31; 30, 40; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:tf; 34, identifier:reshape; 35, argument_list; 35, 36; 35, 37; 36, identifier:indices; 37, list:[-1]; 37, 38; 38, unary_operator:-; 38, 39; 39, integer:1; 40, binary_operator:*; 40, 41; 40, 55; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:tf; 44, identifier:div; 45, argument_list; 45, 46; 45, 54; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:tf; 49, identifier:range; 50, argument_list; 50, 51; 51, binary_operator:*; 51, 52; 51, 53; 52, identifier:batch; 53, identifier:k; 54, identifier:k; 55, identifier:n; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:ret_flat; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:tf; 62, identifier:unsorted_segment_sum; 63, argument_list; 63, 64; 63, 73; 63, 74; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:tf; 67, identifier:reshape; 68, argument_list; 68, 69; 68, 70; 69, identifier:values; 70, list:[-1]; 70, 71; 71, unary_operator:-; 71, 72; 72, integer:1; 73, identifier:indices_flat; 74, binary_operator:*; 74, 75; 74, 76; 75, identifier:batch; 76, identifier:n; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:tf; 81, identifier:reshape; 82, argument_list; 82, 83; 82, 84; 83, identifier:ret_flat; 84, list:[batch, n]; 84, 85; 84, 86; 85, identifier:batch; 86, identifier:n | def _rowwise_unsorted_segment_sum(values, indices, n):
batch, k = tf.unstack(tf.shape(indices), num=2)
indices_flat = tf.reshape(indices, [-1]) + tf.div(tf.range(batch * k), k) * n
ret_flat = tf.unsorted_segment_sum(
tf.reshape(values, [-1]), indices_flat, batch * n)
return tf.reshape(ret_flat, [batch, n]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_get_sorted_inputs; 3, parameters; 3, 4; 3, 5; 4, identifier:filename; 5, default_parameter; 5, 6; 5, 7; 6, identifier:delimiter; 7, string:"\n"; 8, block; 8, 9; 8, 18; 8, 75; 8, 98; 8, 113; 8, 117; 8, 121; 8, 147; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:tf; 14, identifier:logging; 15, identifier:info; 16, argument_list; 16, 17; 17, string:"Getting sorted inputs"; 18, with_statement; 18, 19; 18, 32; 19, with_clause; 19, 20; 20, with_item; 20, 21; 21, as_pattern; 21, 22; 21, 30; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:tf; 26, identifier:gfile; 27, identifier:Open; 28, argument_list; 28, 29; 29, identifier:filename; 30, as_pattern_target; 30, 31; 31, identifier:f; 32, block; 32, 33; 32, 41; 32, 50; 32, 62; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:text; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:f; 39, identifier:read; 40, argument_list; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:records; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:text; 47, identifier:split; 48, argument_list; 48, 49; 49, identifier:delimiter; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:inputs; 53, list_comprehension; 53, 54; 53, 59; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:record; 57, identifier:strip; 58, argument_list; 59, for_in_clause; 59, 60; 59, 61; 60, identifier:record; 61, identifier:records; 62, if_statement; 62, 63; 62, 68; 63, not_operator; 63, 64; 64, subscript; 64, 65; 64, 66; 65, identifier:inputs; 66, unary_operator:-; 66, 67; 67, integer:1; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:inputs; 73, identifier:pop; 74, argument_list; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:input_lens; 78, list_comprehension; 78, 79; 78, 90; 79, tuple; 79, 80; 79, 81; 80, identifier:i; 81, unary_operator:-; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:line; 88, identifier:split; 89, argument_list; 90, for_in_clause; 90, 91; 90, 94; 91, pattern_list; 91, 92; 91, 93; 92, identifier:i; 93, identifier:line; 94, call; 94, 95; 94, 96; 95, identifier:enumerate; 96, argument_list; 96, 97; 97, identifier:inputs; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:sorted_input_lens; 101, call; 101, 102; 101, 103; 102, identifier:sorted; 103, argument_list; 103, 104; 103, 105; 104, identifier:input_lens; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:key; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:operator; 110, identifier:itemgetter; 111, argument_list; 111, 112; 112, integer:1; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:sorted_keys; 116, dictionary; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:sorted_inputs; 120, list:[]; 121, for_statement; 121, 122; 121, 127; 121, 131; 122, pattern_list; 122, 123; 122, 124; 123, identifier:i; 124, tuple_pattern; 124, 125; 124, 126; 125, identifier:index; 126, identifier:_; 127, call; 127, 128; 127, 129; 128, identifier:enumerate; 129, argument_list; 129, 130; 130, identifier:sorted_input_lens; 131, block; 131, 132; 131, 141; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:sorted_inputs; 136, identifier:append; 137, argument_list; 137, 138; 138, subscript; 138, 139; 138, 140; 139, identifier:inputs; 140, identifier:index; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:sorted_keys; 145, identifier:index; 146, identifier:i; 147, return_statement; 147, 148; 148, expression_list; 148, 149; 148, 150; 149, identifier:sorted_inputs; 150, identifier:sorted_keys | def _get_sorted_inputs(filename, delimiter="\n"):
tf.logging.info("Getting sorted inputs")
with tf.gfile.Open(filename) as f:
text = f.read()
records = text.split(delimiter)
inputs = [record.strip() for record in records]
if not inputs[-1]:
inputs.pop()
input_lens = [(i, -len(line.split())) for i, line in enumerate(inputs)]
sorted_input_lens = sorted(input_lens, key=operator.itemgetter(1))
sorted_keys = {}
sorted_inputs = []
for i, (index, _) in enumerate(sorted_input_lens):
sorted_inputs.append(inputs[index])
sorted_keys[index] = i
return sorted_inputs, sorted_keys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:sort_batch_by_length; 3, parameters; 3, 4; 3, 10; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:tensor; 6, type; 6, 7; 7, attribute; 7, 8; 7, 9; 8, identifier:torch; 9, identifier:Tensor; 10, typed_parameter; 10, 11; 10, 12; 11, identifier:sequence_lengths; 12, type; 12, 13; 13, attribute; 13, 14; 13, 15; 14, identifier:torch; 15, identifier:Tensor; 16, block; 16, 17; 16, 41; 16, 55; 16, 65; 16, 83; 16, 97; 16, 107; 17, if_statement; 17, 18; 17, 35; 18, boolean_operator:or; 18, 19; 18, 27; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:tensor; 24, attribute; 24, 25; 24, 26; 25, identifier:torch; 26, identifier:Tensor; 27, not_operator; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:sequence_lengths; 32, attribute; 32, 33; 32, 34; 33, identifier:torch; 34, identifier:Tensor; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:ConfigurationError; 39, argument_list; 39, 40; 40, string:"Both the tensor and sequence lengths must be torch.Tensors."; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 46; 43, pattern_list; 43, 44; 43, 45; 44, identifier:sorted_sequence_lengths; 45, identifier:permutation_index; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:sequence_lengths; 49, identifier:sort; 50, argument_list; 50, 51; 50, 52; 51, integer:0; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:descending; 54, True; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:sorted_tensor; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:tensor; 61, identifier:index_select; 62, argument_list; 62, 63; 62, 64; 63, integer:0; 64, identifier:permutation_index; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:index_range; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:torch; 71, identifier:arange; 72, argument_list; 72, 73; 72, 74; 72, 78; 73, integer:0; 74, call; 74, 75; 74, 76; 75, identifier:len; 76, argument_list; 76, 77; 77, identifier:sequence_lengths; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:device; 80, attribute; 80, 81; 80, 82; 81, identifier:sequence_lengths; 82, identifier:device; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, pattern_list; 85, 86; 85, 87; 86, identifier:_; 87, identifier:reverse_mapping; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:permutation_index; 91, identifier:sort; 92, argument_list; 92, 93; 92, 94; 93, integer:0; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:descending; 96, False; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:restoration_indices; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:index_range; 103, identifier:index_select; 104, argument_list; 104, 105; 104, 106; 105, integer:0; 106, identifier:reverse_mapping; 107, return_statement; 107, 108; 108, expression_list; 108, 109; 108, 110; 108, 111; 108, 112; 109, identifier:sorted_tensor; 110, identifier:sorted_sequence_lengths; 111, identifier:restoration_indices; 112, identifier:permutation_index | def sort_batch_by_length(tensor: torch.Tensor, sequence_lengths: torch.Tensor):
if not isinstance(tensor, torch.Tensor) or not isinstance(sequence_lengths, torch.Tensor):
raise ConfigurationError("Both the tensor and sequence lengths must be torch.Tensors.")
sorted_sequence_lengths, permutation_index = sequence_lengths.sort(0, descending=True)
sorted_tensor = tensor.index_select(0, permutation_index)
index_range = torch.arange(0, len(sequence_lengths), device=sequence_lengths.device)
_, reverse_mapping = permutation_index.sort(0, descending=False)
restoration_indices = index_range.index_select(0, reverse_mapping)
return sorted_tensor, sorted_sequence_lengths, restoration_indices, permutation_index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 1, 15; 2, function_name:render_config; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:config; 6, type; 6, 7; 7, identifier:Config; 8, typed_default_parameter; 8, 9; 8, 10; 8, 12; 9, identifier:indent; 10, type; 10, 11; 11, identifier:str; 12, string:""; 13, type; 13, 14; 14, identifier:str; 15, block; 15, 16; 15, 22; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:new_indent; 19, binary_operator:+; 19, 20; 19, 21; 20, identifier:indent; 21, string:" "; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, string:""; 26, identifier:join; 27, argument_list; 27, 28; 28, list:[
"{\n",
f'{new_indent}"type": "{config.typ3}",\n' if config.typ3 else '',
"".join(_render(item, new_indent) for item in config.items),
indent,
"}\n"
]; 28, 29; 28, 30; 28, 36; 28, 51; 28, 52; 29, string:"{\n"; 30, conditional_expression:if; 30, 31; 30, 32; 30, 35; 31, string:f'{new_indent}"type": "{config.typ3}",\n'; 32, attribute; 32, 33; 32, 34; 33, identifier:config; 34, identifier:typ3; 35, string:''; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, string:""; 39, identifier:join; 40, generator_expression; 40, 41; 40, 46; 41, call; 41, 42; 41, 43; 42, identifier:_render; 43, argument_list; 43, 44; 43, 45; 44, identifier:item; 45, identifier:new_indent; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:item; 48, attribute; 48, 49; 48, 50; 49, identifier:config; 50, identifier:items; 51, identifier:indent; 52, string:"}\n" | def render_config(config: Config, indent: str = "") -> str:
new_indent = indent + " "
return "".join([
"{\n",
f'{new_indent}"type": "{config.typ3}",\n' if config.typ3 else '',
"".join(_render(item, new_indent) for item in config.items),
indent,
"}\n"
]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 54; 2, function_name:sort_and_run_forward; 3, parameters; 3, 4; 3, 5; 3, 33; 3, 39; 3, 45; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:module; 7, type; 7, 8; 8, generic_type; 8, 9; 8, 10; 9, identifier:Callable; 10, type_parameter; 10, 11; 10, 17; 11, type; 11, 12; 12, list:[PackedSequence, Optional[RnnState]]; 12, 13; 12, 14; 13, identifier:PackedSequence; 14, subscript; 14, 15; 14, 16; 15, identifier:Optional; 16, identifier:RnnState; 17, type; 17, 18; 18, generic_type; 18, 19; 18, 20; 19, identifier:Tuple; 20, type_parameter; 20, 21; 20, 31; 21, type; 21, 22; 22, generic_type; 22, 23; 22, 24; 23, identifier:Union; 24, type_parameter; 24, 25; 24, 27; 25, type; 25, 26; 26, identifier:PackedSequence; 27, type; 27, 28; 28, attribute; 28, 29; 28, 30; 29, identifier:torch; 30, identifier:Tensor; 31, type; 31, 32; 32, identifier:RnnState; 33, typed_parameter; 33, 34; 33, 35; 34, identifier:inputs; 35, type; 35, 36; 36, attribute; 36, 37; 36, 38; 37, identifier:torch; 38, identifier:Tensor; 39, typed_parameter; 39, 40; 39, 41; 40, identifier:mask; 41, type; 41, 42; 42, attribute; 42, 43; 42, 44; 43, identifier:torch; 44, identifier:Tensor; 45, typed_default_parameter; 45, 46; 45, 47; 45, 53; 46, identifier:hidden_state; 47, type; 47, 48; 48, generic_type; 48, 49; 48, 50; 49, identifier:Optional; 50, type_parameter; 50, 51; 51, type; 51, 52; 52, identifier:RnnState; 53, None; 54, block; 54, 55; 54, 64; 54, 85; 54, 92; 54, 105; 54, 134; 54, 219; 54, 229; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:batch_size; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:mask; 61, identifier:size; 62, argument_list; 62, 63; 63, integer:0; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:num_valid; 67, call; 67, 68; 67, 84; 68, attribute; 68, 69; 68, 83; 69, call; 69, 70; 69, 82; 70, attribute; 70, 71; 70, 81; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:torch; 74, identifier:sum; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 78; 76, 80; 77, identifier:mask; 78, slice; 78, 79; 79, colon; 80, integer:0; 81, identifier:int; 82, argument_list; 83, identifier:item; 84, argument_list; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:sequence_lengths; 88, call; 88, 89; 88, 90; 89, identifier:get_lengths_from_binary_sequence_mask; 90, argument_list; 90, 91; 91, identifier:mask; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 99; 93, 100; 94, pattern_list; 94, 95; 94, 96; 94, 97; 94, 98; 95, identifier:sorted_inputs; 96, identifier:sorted_sequence_lengths; 97, identifier:restoration_indices; 98, identifier:sorting_indices; 99, line_continuation:\; 100, call; 100, 101; 100, 102; 101, identifier:sort_batch_by_length; 102, argument_list; 102, 103; 102, 104; 103, identifier:inputs; 104, identifier:sequence_lengths; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:packed_sequence_input; 108, call; 108, 109; 108, 110; 109, identifier:pack_padded_sequence; 110, argument_list; 110, 111; 110, 120; 110, 131; 111, subscript; 111, 112; 111, 113; 111, 116; 111, 118; 112, identifier:sorted_inputs; 113, slice; 113, 114; 113, 115; 114, colon; 115, identifier:num_valid; 116, slice; 116, 117; 117, colon; 118, slice; 118, 119; 119, colon; 120, call; 120, 121; 120, 130; 121, attribute; 121, 122; 121, 129; 122, attribute; 122, 123; 122, 128; 123, subscript; 123, 124; 123, 125; 124, identifier:sorted_sequence_lengths; 125, slice; 125, 126; 125, 127; 126, colon; 127, identifier:num_valid; 128, identifier:data; 129, identifier:tolist; 130, argument_list; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:batch_first; 133, True; 134, if_statement; 134, 135; 134, 139; 134, 206; 135, not_operator; 135, 136; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:stateful; 139, block; 139, 140; 140, if_statement; 140, 141; 140, 144; 140, 149; 140, 182; 141, comparison_operator:is; 141, 142; 141, 143; 142, identifier:hidden_state; 143, None; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:initial_states; 148, identifier:hidden_state; 149, elif_clause; 149, 150; 149, 155; 150, call; 150, 151; 150, 152; 151, identifier:isinstance; 152, argument_list; 152, 153; 152, 154; 153, identifier:hidden_state; 154, identifier:tuple; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:initial_states; 159, list_comprehension; 159, 160; 159, 179; 160, call; 160, 161; 160, 178; 161, attribute; 161, 162; 161, 177; 162, subscript; 162, 163; 162, 170; 162, 172; 162, 175; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:state; 166, identifier:index_select; 167, argument_list; 167, 168; 167, 169; 168, integer:1; 169, identifier:sorting_indices; 170, slice; 170, 171; 171, colon; 172, slice; 172, 173; 172, 174; 173, colon; 174, identifier:num_valid; 175, slice; 175, 176; 176, colon; 177, identifier:contiguous; 178, argument_list; 179, for_in_clause; 179, 180; 179, 181; 180, identifier:state; 181, identifier:hidden_state; 182, else_clause; 182, 183; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:initial_states; 187, call; 187, 188; 187, 205; 188, attribute; 188, 189; 188, 204; 189, subscript; 189, 190; 189, 197; 189, 199; 189, 202; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:hidden_state; 193, identifier:index_select; 194, argument_list; 194, 195; 194, 196; 195, integer:1; 196, identifier:sorting_indices; 197, slice; 197, 198; 198, colon; 199, slice; 199, 200; 199, 201; 200, colon; 201, identifier:num_valid; 202, slice; 202, 203; 203, colon; 204, identifier:contiguous; 205, argument_list; 206, else_clause; 206, 207; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:initial_states; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:self; 214, identifier:_get_initial_states; 215, argument_list; 215, 216; 215, 217; 215, 218; 216, identifier:batch_size; 217, identifier:num_valid; 218, identifier:sorting_indices; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, pattern_list; 221, 222; 221, 223; 222, identifier:module_output; 223, identifier:final_states; 224, call; 224, 225; 224, 226; 225, identifier:module; 226, argument_list; 226, 227; 226, 228; 227, identifier:packed_sequence_input; 228, identifier:initial_states; 229, return_statement; 229, 230; 230, expression_list; 230, 231; 230, 232; 230, 233; 231, identifier:module_output; 232, identifier:final_states; 233, identifier:restoration_indices | def sort_and_run_forward(self,
module: Callable[[PackedSequence, Optional[RnnState]],
Tuple[Union[PackedSequence, torch.Tensor], RnnState]],
inputs: torch.Tensor,
mask: torch.Tensor,
hidden_state: Optional[RnnState] = None):
batch_size = mask.size(0)
num_valid = torch.sum(mask[:, 0]).int().item()
sequence_lengths = get_lengths_from_binary_sequence_mask(mask)
sorted_inputs, sorted_sequence_lengths, restoration_indices, sorting_indices =\
sort_batch_by_length(inputs, sequence_lengths)
packed_sequence_input = pack_padded_sequence(sorted_inputs[:num_valid, :, :],
sorted_sequence_lengths[:num_valid].data.tolist(),
batch_first=True)
if not self.stateful:
if hidden_state is None:
initial_states = hidden_state
elif isinstance(hidden_state, tuple):
initial_states = [state.index_select(1, sorting_indices)[:, :num_valid, :].contiguous()
for state in hidden_state]
else:
initial_states = hidden_state.index_select(1, sorting_indices)[:, :num_valid, :].contiguous()
else:
initial_states = self._get_initial_states(batch_size, num_valid, sorting_indices)
module_output, final_states = module(packed_sequence_input, initial_states)
return module_output, final_states, restoration_indices |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 1, 25; 2, function_name:_get_initial_states; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 13; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:batch_size; 7, type; 7, 8; 8, identifier:int; 9, typed_parameter; 9, 10; 9, 11; 10, identifier:num_valid; 11, type; 11, 12; 12, identifier:int; 13, typed_parameter; 13, 14; 13, 15; 14, identifier:sorting_indices; 15, type; 15, 16; 16, attribute; 16, 17; 16, 18; 17, identifier:torch; 18, identifier:LongTensor; 19, type; 19, 20; 20, generic_type; 20, 21; 20, 22; 21, identifier:Optional; 22, type_parameter; 22, 23; 23, type; 23, 24; 24, identifier:RnnState; 25, block; 25, 26; 25, 35; 25, 167; 26, if_statement; 26, 27; 26, 32; 27, comparison_operator:is; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_states; 31, None; 32, block; 32, 33; 33, return_statement; 33, 34; 34, None; 35, if_statement; 35, 36; 35, 48; 35, 125; 35, 159; 36, comparison_operator:>; 36, 37; 36, 38; 37, identifier:batch_size; 38, call; 38, 39; 38, 46; 39, attribute; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_states; 44, integer:0; 45, identifier:size; 46, argument_list; 46, 47; 47, integer:1; 48, block; 48, 49; 48, 64; 48, 68; 48, 110; 48, 119; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:num_states_to_concat; 52, binary_operator:-; 52, 53; 52, 54; 53, identifier:batch_size; 54, call; 54, 55; 54, 62; 55, attribute; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_states; 60, integer:0; 61, identifier:size; 62, argument_list; 62, 63; 63, integer:1; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:resized_states; 67, list:[]; 68, for_statement; 68, 69; 68, 70; 68, 73; 69, identifier:state; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:_states; 73, block; 73, 74; 73, 95; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:zeros; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:state; 80, identifier:new_zeros; 81, argument_list; 81, 82; 81, 88; 81, 89; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:state; 85, identifier:size; 86, argument_list; 86, 87; 87, integer:0; 88, identifier:num_states_to_concat; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:state; 92, identifier:size; 93, argument_list; 93, 94; 94, integer:2; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:resized_states; 99, identifier:append; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:torch; 104, identifier:cat; 105, argument_list; 105, 106; 105, 109; 106, list:[state, zeros]; 106, 107; 106, 108; 107, identifier:state; 108, identifier:zeros; 109, integer:1; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_states; 115, call; 115, 116; 115, 117; 116, identifier:tuple; 117, argument_list; 117, 118; 118, identifier:resized_states; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:correctly_shaped_states; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_states; 125, elif_clause; 125, 126; 125, 138; 126, comparison_operator:<; 126, 127; 126, 128; 127, identifier:batch_size; 128, call; 128, 129; 128, 136; 129, attribute; 129, 130; 129, 135; 130, subscript; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_states; 134, integer:0; 135, identifier:size; 136, argument_list; 136, 137; 137, integer:1; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:correctly_shaped_states; 142, call; 142, 143; 142, 144; 143, identifier:tuple; 144, generator_expression; 144, 145; 144, 154; 145, subscript; 145, 146; 145, 147; 145, 149; 145, 152; 146, identifier:state; 147, slice; 147, 148; 148, colon; 149, slice; 149, 150; 149, 151; 150, colon; 151, identifier:batch_size; 152, slice; 152, 153; 153, colon; 154, for_in_clause; 154, 155; 154, 156; 155, identifier:state; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:_states; 159, else_clause; 159, 160; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:correctly_shaped_states; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:_states; 167, if_statement; 167, 168; 167, 176; 167, 207; 168, comparison_operator:==; 168, 169; 168, 175; 169, call; 169, 170; 169, 171; 170, identifier:len; 171, argument_list; 171, 172; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:_states; 175, integer:1; 176, block; 176, 177; 176, 183; 176, 193; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:correctly_shaped_state; 180, subscript; 180, 181; 180, 182; 181, identifier:correctly_shaped_states; 182, integer:0; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:sorted_state; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:correctly_shaped_state; 189, identifier:index_select; 190, argument_list; 190, 191; 190, 192; 191, integer:1; 192, identifier:sorting_indices; 193, return_statement; 193, 194; 194, call; 194, 195; 194, 206; 195, attribute; 195, 196; 195, 205; 196, subscript; 196, 197; 196, 198; 196, 200; 196, 203; 197, identifier:sorted_state; 198, slice; 198, 199; 199, colon; 200, slice; 200, 201; 200, 202; 201, colon; 202, identifier:num_valid; 203, slice; 203, 204; 204, colon; 205, identifier:contiguous; 206, argument_list; 207, else_clause; 207, 208; 208, block; 208, 209; 208, 223; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:sorted_states; 212, list_comprehension; 212, 213; 212, 220; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:state; 216, identifier:index_select; 217, argument_list; 217, 218; 217, 219; 218, integer:1; 219, identifier:sorting_indices; 220, for_in_clause; 220, 221; 220, 222; 221, identifier:state; 222, identifier:correctly_shaped_states; 223, return_statement; 223, 224; 224, call; 224, 225; 224, 226; 225, identifier:tuple; 226, generator_expression; 226, 227; 226, 240; 227, call; 227, 228; 227, 239; 228, attribute; 228, 229; 228, 238; 229, subscript; 229, 230; 229, 231; 229, 233; 229, 236; 230, identifier:state; 231, slice; 231, 232; 232, colon; 233, slice; 233, 234; 233, 235; 234, colon; 235, identifier:num_valid; 236, slice; 236, 237; 237, colon; 238, identifier:contiguous; 239, argument_list; 240, for_in_clause; 240, 241; 240, 242; 241, identifier:state; 242, identifier:sorted_states | def _get_initial_states(self,
batch_size: int,
num_valid: int,
sorting_indices: torch.LongTensor) -> Optional[RnnState]:
if self._states is None:
return None
if batch_size > self._states[0].size(1):
num_states_to_concat = batch_size - self._states[0].size(1)
resized_states = []
for state in self._states:
zeros = state.new_zeros(state.size(0),
num_states_to_concat,
state.size(2))
resized_states.append(torch.cat([state, zeros], 1))
self._states = tuple(resized_states)
correctly_shaped_states = self._states
elif batch_size < self._states[0].size(1):
correctly_shaped_states = tuple(state[:, :batch_size, :] for state in self._states)
else:
correctly_shaped_states = self._states
if len(self._states) == 1:
correctly_shaped_state = correctly_shaped_states[0]
sorted_state = correctly_shaped_state.index_select(1, sorting_indices)
return sorted_state[:, :num_valid, :].contiguous()
else:
sorted_states = [state.index_select(1, sorting_indices)
for state in correctly_shaped_states]
return tuple(state[:, :num_valid, :].contiguous() for state in sorted_states) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 1, 17; 2, function_name:_update_states; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:final_states; 7, type; 7, 8; 8, identifier:RnnStateStorage; 9, typed_parameter; 9, 10; 9, 11; 10, identifier:restoration_indices; 11, type; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:torch; 14, identifier:LongTensor; 15, type; 15, 16; 16, None; 17, block; 17, 18; 17, 32; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:new_unsorted_states; 21, list_comprehension; 21, 22; 21, 29; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:state; 25, identifier:index_select; 26, argument_list; 26, 27; 26, 28; 27, integer:1; 28, identifier:restoration_indices; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:state; 31, identifier:final_states; 32, if_statement; 32, 33; 32, 38; 32, 53; 33, comparison_operator:is; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_states; 37, None; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_states; 44, call; 44, 45; 44, 46; 45, identifier:tuple; 46, generator_expression; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:state; 49, identifier:data; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:state; 52, identifier:new_unsorted_states; 53, else_clause; 53, 54; 54, block; 54, 55; 54, 68; 54, 79; 54, 113; 54, 117; 54, 222; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:current_state_batch_size; 58, call; 58, 59; 58, 66; 59, attribute; 59, 60; 59, 65; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_states; 64, integer:0; 65, identifier:size; 66, argument_list; 66, 67; 67, integer:1; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:new_state_batch_size; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:final_states; 75, integer:0; 76, identifier:size; 77, argument_list; 77, 78; 78, integer:1; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:used_new_rows_mask; 82, list_comprehension; 82, 83; 82, 110; 83, call; 83, 84; 83, 106; 84, attribute; 84, 85; 84, 105; 85, call; 85, 86; 85, 104; 86, attribute; 86, 87; 86, 103; 87, parenthesized_expression; 87, 88; 88, comparison_operator:!=; 88, 89; 88, 102; 89, call; 89, 90; 89, 99; 90, attribute; 90, 91; 90, 98; 91, subscript; 91, 92; 91, 93; 91, 94; 91, 96; 92, identifier:state; 93, integer:0; 94, slice; 94, 95; 95, colon; 96, slice; 96, 97; 97, colon; 98, identifier:sum; 99, argument_list; 99, 100; 100, unary_operator:-; 100, 101; 101, integer:1; 102, float:0.0; 103, identifier:float; 104, argument_list; 105, identifier:view; 106, argument_list; 106, 107; 106, 108; 106, 109; 107, integer:1; 108, identifier:new_state_batch_size; 109, integer:1; 110, for_in_clause; 110, 111; 110, 112; 111, identifier:state; 112, identifier:new_unsorted_states; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:new_states; 116, list:[]; 117, if_statement; 117, 118; 117, 121; 117, 178; 118, comparison_operator:>; 118, 119; 118, 120; 119, identifier:current_state_batch_size; 120, identifier:new_state_batch_size; 121, block; 121, 122; 122, for_statement; 122, 123; 122, 127; 122, 135; 123, pattern_list; 123, 124; 123, 125; 123, 126; 124, identifier:old_state; 125, identifier:new_state; 126, identifier:used_mask; 127, call; 127, 128; 127, 129; 128, identifier:zip; 129, argument_list; 129, 130; 129, 133; 129, 134; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_states; 133, identifier:new_unsorted_states; 134, identifier:used_new_rows_mask; 135, block; 135, 136; 135, 153; 135, 167; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:masked_old_state; 139, binary_operator:*; 139, 140; 139, 149; 140, subscript; 140, 141; 140, 142; 140, 144; 140, 147; 141, identifier:old_state; 142, slice; 142, 143; 143, colon; 144, slice; 144, 145; 144, 146; 145, colon; 146, identifier:new_state_batch_size; 147, slice; 147, 148; 148, colon; 149, parenthesized_expression; 149, 150; 150, binary_operator:-; 150, 151; 150, 152; 151, integer:1; 152, identifier:used_mask; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 164; 155, subscript; 155, 156; 155, 157; 155, 159; 155, 162; 156, identifier:old_state; 157, slice; 157, 158; 158, colon; 159, slice; 159, 160; 159, 161; 160, colon; 161, identifier:new_state_batch_size; 162, slice; 162, 163; 163, colon; 164, binary_operator:+; 164, 165; 164, 166; 165, identifier:new_state; 166, identifier:masked_old_state; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:new_states; 171, identifier:append; 172, argument_list; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:old_state; 176, identifier:detach; 177, argument_list; 178, else_clause; 178, 179; 179, block; 179, 180; 179, 184; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:new_states; 183, list:[]; 184, for_statement; 184, 185; 184, 189; 184, 197; 185, pattern_list; 185, 186; 185, 187; 185, 188; 186, identifier:old_state; 187, identifier:new_state; 188, identifier:used_mask; 189, call; 189, 190; 189, 191; 190, identifier:zip; 191, argument_list; 191, 192; 191, 195; 191, 196; 192, attribute; 192, 193; 192, 194; 193, identifier:self; 194, identifier:_states; 195, identifier:new_unsorted_states; 196, identifier:used_new_rows_mask; 197, block; 197, 198; 197, 207; 197, 211; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:masked_old_state; 201, binary_operator:*; 201, 202; 201, 203; 202, identifier:old_state; 203, parenthesized_expression; 203, 204; 204, binary_operator:-; 204, 205; 204, 206; 205, integer:1; 206, identifier:used_mask; 207, expression_statement; 207, 208; 208, augmented_assignment:+=; 208, 209; 208, 210; 209, identifier:new_state; 210, identifier:masked_old_state; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:new_states; 215, identifier:append; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:new_state; 220, identifier:detach; 221, argument_list; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:_states; 227, call; 227, 228; 227, 229; 228, identifier:tuple; 229, argument_list; 229, 230; 230, identifier:new_states | def _update_states(self,
final_states: RnnStateStorage,
restoration_indices: torch.LongTensor) -> None:
new_unsorted_states = [state.index_select(1, restoration_indices)
for state in final_states]
if self._states is None:
self._states = tuple(state.data for state in new_unsorted_states)
else:
current_state_batch_size = self._states[0].size(1)
new_state_batch_size = final_states[0].size(1)
used_new_rows_mask = [(state[0, :, :].sum(-1)
!= 0.0).float().view(1, new_state_batch_size, 1)
for state in new_unsorted_states]
new_states = []
if current_state_batch_size > new_state_batch_size:
for old_state, new_state, used_mask in zip(self._states,
new_unsorted_states,
used_new_rows_mask):
masked_old_state = old_state[:, :new_state_batch_size, :] * (1 - used_mask)
old_state[:, :new_state_batch_size, :] = new_state + masked_old_state
new_states.append(old_state.detach())
else:
new_states = []
for old_state, new_state, used_mask in zip(self._states,
new_unsorted_states,
used_new_rows_mask):
masked_old_state = old_state * (1 - used_mask)
new_state += masked_old_state
new_states.append(new_state.detach())
self._states = tuple(new_states) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 1, 27; 2, function_name:_prune_beam; 3, parameters; 3, 4; 3, 12; 3, 16; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:states; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:List; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:State; 12, typed_parameter; 12, 13; 12, 14; 13, identifier:beam_size; 14, type; 14, 15; 15, identifier:int; 16, typed_default_parameter; 16, 17; 16, 18; 16, 20; 17, identifier:sort_states; 18, type; 18, 19; 19, identifier:bool; 20, False; 21, type; 21, 22; 22, generic_type; 22, 23; 22, 24; 23, identifier:List; 24, type_parameter; 24, 25; 25, type; 25, 26; 26, identifier:State; 27, block; 27, 28; 27, 47; 27, 77; 27, 81; 27, 173; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 29, 43; 30, identifier:states_by_batch_index; 31, type; 31, 32; 32, generic_type; 32, 33; 32, 34; 33, identifier:Dict; 34, type_parameter; 34, 35; 34, 37; 35, type; 35, 36; 36, identifier:int; 37, type; 37, 38; 38, generic_type; 38, 39; 38, 40; 39, identifier:List; 40, type_parameter; 40, 41; 41, type; 41, 42; 42, identifier:State; 43, call; 43, 44; 43, 45; 44, identifier:defaultdict; 45, argument_list; 45, 46; 46, identifier:list; 47, for_statement; 47, 48; 47, 49; 47, 50; 48, identifier:state; 49, identifier:states; 50, block; 50, 51; 50, 60; 50, 68; 51, assert_statement; 51, 52; 52, comparison_operator:==; 52, 53; 52, 59; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:state; 58, identifier:batch_indices; 59, integer:1; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:batch_index; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:state; 66, identifier:batch_indices; 67, integer:0; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:states_by_batch_index; 73, identifier:batch_index; 74, identifier:append; 75, argument_list; 75, 76; 76, identifier:state; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:pruned_states; 80, list:[]; 81, for_statement; 81, 82; 81, 85; 81, 90; 82, pattern_list; 82, 83; 82, 84; 83, identifier:_; 84, identifier:instance_states; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:states_by_batch_index; 88, identifier:items; 89, argument_list; 90, block; 90, 91; 90, 158; 91, if_statement; 91, 92; 91, 93; 92, identifier:sort_states; 93, block; 93, 94; 93, 117; 93, 132; 93, 154; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:scores; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:torch; 100, identifier:cat; 101, argument_list; 101, 102; 102, list_comprehension; 102, 103; 102, 114; 103, call; 103, 104; 103, 111; 104, attribute; 104, 105; 104, 110; 105, subscript; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:state; 108, identifier:score; 109, integer:0; 110, identifier:view; 111, argument_list; 111, 112; 112, unary_operator:-; 112, 113; 113, integer:1; 114, for_in_clause; 114, 115; 114, 116; 115, identifier:state; 116, identifier:instance_states; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 122; 119, pattern_list; 119, 120; 119, 121; 120, identifier:_; 121, identifier:sorted_indices; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:scores; 125, identifier:sort; 126, argument_list; 126, 127; 126, 129; 127, unary_operator:-; 127, 128; 128, integer:1; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:descending; 131, True; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:sorted_states; 135, list_comprehension; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:instance_states; 138, identifier:i; 139, for_in_clause; 139, 140; 139, 141; 140, identifier:i; 141, call; 141, 142; 141, 153; 142, attribute; 142, 143; 142, 152; 143, call; 143, 144; 143, 151; 144, attribute; 144, 145; 144, 150; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:sorted_indices; 148, identifier:detach; 149, argument_list; 150, identifier:cpu; 151, argument_list; 152, identifier:numpy; 153, argument_list; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:instance_states; 157, identifier:sorted_states; 158, for_statement; 158, 159; 158, 160; 158, 165; 159, identifier:state; 160, subscript; 160, 161; 160, 162; 161, identifier:instance_states; 162, slice; 162, 163; 162, 164; 163, colon; 164, identifier:beam_size; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:pruned_states; 170, identifier:append; 171, argument_list; 171, 172; 172, identifier:state; 173, return_statement; 173, 174; 174, identifier:pruned_states | def _prune_beam(states: List[State],
beam_size: int,
sort_states: bool = False) -> List[State]:
states_by_batch_index: Dict[int, List[State]] = defaultdict(list)
for state in states:
assert len(state.batch_indices) == 1
batch_index = state.batch_indices[0]
states_by_batch_index[batch_index].append(state)
pruned_states = []
for _, instance_states in states_by_batch_index.items():
if sort_states:
scores = torch.cat([state.score[0].view(-1) for state in instance_states])
_, sorted_indices = scores.sort(-1, descending=True)
sorted_states = [instance_states[i] for i in sorted_indices.detach().cpu().numpy()]
instance_states = sorted_states
for state in instance_states[:beam_size]:
pruned_states.append(state)
return pruned_states |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 1, 29; 2, function_name:take_step; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 14; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:state; 7, type; 7, 8; 8, identifier:StateType; 9, typed_default_parameter; 9, 10; 9, 11; 9, 13; 10, identifier:max_actions; 11, type; 11, 12; 12, identifier:int; 13, None; 14, typed_default_parameter; 14, 15; 14, 16; 14, 22; 15, identifier:allowed_actions; 16, type; 16, 17; 17, generic_type; 17, 18; 17, 19; 18, identifier:List; 19, type_parameter; 19, 20; 20, type; 20, 21; 21, identifier:Set; 22, None; 23, type; 23, 24; 24, generic_type; 24, 25; 24, 26; 25, identifier:List; 26, type_parameter; 26, 27; 27, type; 27, 28; 28, identifier:StateType; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, identifier:NotImplementedError | def take_step(self,
state: StateType,
max_actions: int = None,
allowed_actions: List[Set] = None) -> List[StateType]:
raise NotImplementedError |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:row_sparse_pull; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:out; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:priority; 11, integer:0; 12, default_parameter; 12, 13; 12, 14; 13, identifier:row_ids; 14, None; 15, block; 15, 16; 15, 21; 15, 26; 15, 38; 15, 46; 15, 50; 15, 54; 15, 79; 15, 90; 15, 101; 15, 113; 15, 174; 16, assert_statement; 16, 17; 17, parenthesized_expression; 17, 18; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:out; 20, None; 21, assert_statement; 21, 22; 22, parenthesized_expression; 22, 23; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:row_ids; 25, None; 26, if_statement; 26, 27; 26, 32; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:row_ids; 31, identifier:NDArray; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:row_ids; 36, list:[row_ids]; 36, 37; 37, identifier:row_ids; 38, assert_statement; 38, 39; 38, 45; 39, parenthesized_expression; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:row_ids; 44, identifier:list; 45, string:"row_ids should be NDArray or list of NDArray"; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:first_out; 49, identifier:out; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:single_rowid; 53, False; 54, if_statement; 54, 55; 54, 67; 55, boolean_operator:and; 55, 56; 55, 62; 56, comparison_operator:==; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:row_ids; 61, integer:1; 62, call; 62, 63; 62, 64; 63, identifier:isinstance; 64, argument_list; 64, 65; 64, 66; 65, identifier:out; 66, identifier:list; 67, block; 67, 68; 67, 72; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:single_rowid; 71, True; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:first_out; 75, list:[out[0]]; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:out; 78, integer:0; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 85; 81, pattern_list; 81, 82; 81, 83; 81, 84; 82, identifier:ckeys; 83, identifier:cvals; 84, identifier:use_str_keys; 85, call; 85, 86; 85, 87; 86, identifier:_ctype_key_value; 87, argument_list; 87, 88; 87, 89; 88, identifier:key; 89, identifier:first_out; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 96; 92, pattern_list; 92, 93; 92, 94; 92, 95; 93, identifier:_; 94, identifier:crow_ids; 95, identifier:_; 96, call; 96, 97; 96, 98; 97, identifier:_ctype_key_value; 98, argument_list; 98, 99; 98, 100; 99, identifier:key; 100, identifier:row_ids; 101, assert_statement; 101, 102; 101, 112; 102, parenthesized_expression; 102, 103; 103, comparison_operator:==; 103, 104; 103, 108; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, identifier:crow_ids; 108, call; 108, 109; 108, 110; 109, identifier:len; 110, argument_list; 110, 111; 111, identifier:cvals; 112, string:"the number of row_ids doesn't match the number of values"; 113, if_statement; 113, 114; 113, 115; 113, 144; 114, identifier:use_str_keys; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:check_call; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:_LIB; 123, identifier:MXKVStorePullRowSparseEx; 124, argument_list; 124, 125; 124, 128; 124, 135; 124, 136; 124, 137; 124, 138; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:handle; 128, call; 128, 129; 128, 130; 129, identifier:mx_uint; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:len; 133, argument_list; 133, 134; 134, identifier:ckeys; 135, identifier:ckeys; 136, identifier:cvals; 137, identifier:crow_ids; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:ctypes; 141, identifier:c_int; 142, argument_list; 142, 143; 143, identifier:priority; 144, else_clause; 144, 145; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:check_call; 149, argument_list; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:_LIB; 153, identifier:MXKVStorePullRowSparse; 154, argument_list; 154, 155; 154, 158; 154, 165; 154, 166; 154, 167; 154, 168; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:handle; 158, call; 158, 159; 158, 160; 159, identifier:mx_uint; 160, argument_list; 160, 161; 161, call; 161, 162; 161, 163; 162, identifier:len; 163, argument_list; 163, 164; 164, identifier:ckeys; 165, identifier:ckeys; 166, identifier:cvals; 167, identifier:crow_ids; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:ctypes; 171, identifier:c_int; 172, argument_list; 172, 173; 173, identifier:priority; 174, if_statement; 174, 175; 174, 176; 175, identifier:single_rowid; 176, block; 176, 177; 177, for_statement; 177, 178; 177, 179; 177, 184; 178, identifier:out_i; 179, subscript; 179, 180; 179, 181; 180, identifier:out; 181, slice; 181, 182; 181, 183; 182, integer:1; 183, colon; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:out; 190, integer:0; 191, identifier:copyto; 192, argument_list; 192, 193; 193, identifier:out_i | def row_sparse_pull(self, key, out=None, priority=0, row_ids=None):
assert(out is not None)
assert(row_ids is not None)
if isinstance(row_ids, NDArray):
row_ids = [row_ids]
assert(isinstance(row_ids, list)), \
"row_ids should be NDArray or list of NDArray"
first_out = out
single_rowid = False
if len(row_ids) == 1 and isinstance(out, list):
single_rowid = True
first_out = [out[0]]
ckeys, cvals, use_str_keys = _ctype_key_value(key, first_out)
_, crow_ids, _ = _ctype_key_value(key, row_ids)
assert(len(crow_ids) == len(cvals)), \
"the number of row_ids doesn't match the number of values"
if use_str_keys:
check_call(_LIB.MXKVStorePullRowSparseEx(
self.handle, mx_uint(len(ckeys)), ckeys, cvals, crow_ids, ctypes.c_int(priority)))
else:
check_call(_LIB.MXKVStorePullRowSparse(
self.handle, mx_uint(len(ckeys)), ckeys, cvals, crow_ids, ctypes.c_int(priority)))
if single_rowid:
for out_i in out[1:]:
out[0].copyto(out_i) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:row_sparse_array; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:arg1; 5, default_parameter; 5, 6; 5, 7; 6, identifier:shape; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ctx; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:dtype; 13, None; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 21; 15, 125; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:arg1; 20, identifier:tuple; 21, block; 21, 22; 21, 29; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:arg_len; 25, call; 25, 26; 25, 27; 26, identifier:len; 27, argument_list; 27, 28; 28, identifier:arg1; 29, if_statement; 29, 30; 29, 33; 29, 44; 29, 67; 30, comparison_operator:<; 30, 31; 30, 32; 31, identifier:arg_len; 32, integer:2; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ValueError; 37, argument_list; 37, 38; 38, binary_operator:+; 38, 39; 38, 40; 39, string:"Unexpected length of input tuple: "; 40, call; 40, 41; 40, 42; 41, identifier:str; 42, argument_list; 42, 43; 43, identifier:arg_len; 44, elif_clause; 44, 45; 44, 48; 45, comparison_operator:>; 45, 46; 45, 47; 46, identifier:arg_len; 47, integer:2; 48, block; 48, 49; 48, 55; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:_check_shape; 52, argument_list; 52, 53; 52, 54; 53, identifier:arg1; 54, identifier:shape; 55, return_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:empty; 58, argument_list; 58, 59; 58, 60; 58, 61; 58, 64; 59, string:'row_sparse'; 60, identifier:arg1; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:ctx; 63, identifier:ctx; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:dtype; 66, identifier:dtype; 67, else_clause; 67, 68; 68, block; 68, 69; 69, if_statement; 69, 70; 69, 85; 69, 104; 70, boolean_operator:and; 70, 71; 70, 78; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:arg1; 76, integer:0; 77, identifier:integer_types; 78, call; 78, 79; 78, 80; 79, identifier:isinstance; 80, argument_list; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:arg1; 83, integer:1; 84, identifier:integer_types; 85, block; 85, 86; 85, 92; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:_check_shape; 89, argument_list; 89, 90; 89, 91; 90, identifier:arg1; 91, identifier:shape; 92, return_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:empty; 95, argument_list; 95, 96; 95, 97; 95, 98; 95, 101; 96, string:'row_sparse'; 97, identifier:arg1; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:ctx; 100, identifier:ctx; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:dtype; 103, identifier:dtype; 104, else_clause; 104, 105; 105, block; 105, 106; 106, return_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:_row_sparse_ndarray_from_definition; 109, argument_list; 109, 110; 109, 113; 109, 116; 109, 119; 109, 122; 110, subscript; 110, 111; 110, 112; 111, identifier:arg1; 112, integer:0; 113, subscript; 113, 114; 113, 115; 114, identifier:arg1; 115, integer:1; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:shape; 118, identifier:shape; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:ctx; 121, identifier:ctx; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:dtype; 124, identifier:dtype; 125, else_clause; 125, 126; 126, block; 126, 127; 127, if_statement; 127, 128; 127, 133; 127, 153; 127, 165; 128, call; 128, 129; 128, 130; 129, identifier:isinstance; 130, argument_list; 130, 131; 130, 132; 131, identifier:arg1; 132, identifier:RowSparseNDArray; 133, block; 133, 134; 133, 142; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:_check_shape; 137, argument_list; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:arg1; 140, identifier:shape; 141, identifier:shape; 142, return_statement; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:array; 145, argument_list; 145, 146; 145, 147; 145, 150; 146, identifier:arg1; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:ctx; 149, identifier:ctx; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:dtype; 152, identifier:dtype; 153, elif_clause; 153, 154; 153, 159; 154, call; 154, 155; 154, 156; 155, identifier:isinstance; 156, argument_list; 156, 157; 156, 158; 157, identifier:arg1; 158, identifier:CSRNDArray; 159, block; 159, 160; 160, raise_statement; 160, 161; 161, call; 161, 162; 161, 163; 162, identifier:ValueError; 163, argument_list; 163, 164; 164, string:"Unexpected input type: CSRNDArray"; 165, else_clause; 165, 166; 166, block; 166, 167; 166, 175; 166, 185; 166, 205; 166, 213; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:dtype; 170, call; 170, 171; 170, 172; 171, identifier:_prepare_default_dtype; 172, argument_list; 172, 173; 172, 174; 173, identifier:arg1; 174, identifier:dtype; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:dns; 178, call; 178, 179; 178, 180; 179, identifier:_array; 180, argument_list; 180, 181; 180, 182; 181, identifier:arg1; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:dtype; 184, identifier:dtype; 185, if_statement; 185, 186; 185, 195; 186, boolean_operator:and; 186, 187; 186, 190; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:ctx; 189, None; 190, comparison_operator:!=; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:dns; 193, identifier:context; 194, identifier:ctx; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:dns; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:dns; 202, identifier:as_in_context; 203, argument_list; 203, 204; 204, identifier:ctx; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:_check_shape; 208, argument_list; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:dns; 211, identifier:shape; 212, identifier:shape; 213, return_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:dns; 217, identifier:tostype; 218, argument_list; 218, 219; 219, string:'row_sparse' | def row_sparse_array(arg1, shape=None, ctx=None, dtype=None):
if isinstance(arg1, tuple):
arg_len = len(arg1)
if arg_len < 2:
raise ValueError("Unexpected length of input tuple: " + str(arg_len))
elif arg_len > 2:
_check_shape(arg1, shape)
return empty('row_sparse', arg1, ctx=ctx, dtype=dtype)
else:
if isinstance(arg1[0], integer_types) and isinstance(arg1[1], integer_types):
_check_shape(arg1, shape)
return empty('row_sparse', arg1, ctx=ctx, dtype=dtype)
else:
return _row_sparse_ndarray_from_definition(arg1[0], arg1[1], shape=shape,
ctx=ctx, dtype=dtype)
else:
if isinstance(arg1, RowSparseNDArray):
_check_shape(arg1.shape, shape)
return array(arg1, ctx=ctx, dtype=dtype)
elif isinstance(arg1, CSRNDArray):
raise ValueError("Unexpected input type: CSRNDArray")
else:
dtype = _prepare_default_dtype(arg1, dtype)
dns = _array(arg1, dtype=dtype)
if ctx is not None and dns.context != ctx:
dns = dns.as_in_context(ctx)
_check_shape(dns.shape, shape)
return dns.tostype('row_sparse') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 22; 5, 44; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:beams; 9, list_comprehension; 9, 10; 9, 11; 10, identifier:v; 11, for_in_clause; 11, 12; 11, 15; 12, tuple_pattern; 12, 13; 12, 14; 13, identifier:_; 14, identifier:v; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:entries; 20, identifier:items; 21, argument_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sortedBeams; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 27, 29; 27, 32; 28, identifier:beams; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:reverse; 31, True; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:key; 34, lambda; 34, 35; 34, 37; 35, lambda_parameters; 35, 36; 36, identifier:x; 37, binary_operator:*; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:x; 40, identifier:prTotal; 41, attribute; 41, 42; 41, 43; 42, identifier:x; 43, identifier:prText; 44, return_statement; 44, 45; 45, list_comprehension; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:x; 48, identifier:labeling; 49, for_in_clause; 49, 50; 49, 51; 50, identifier:x; 51, identifier:sortedBeams | def sort(self):
beams = [v for (_, v) in self.entries.items()]
sortedBeams = sorted(beams, reverse=True, key=lambda x: x.prTotal*x.prText)
return [x.labeling for x in sortedBeams] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:runtime; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:X; 5, identifier:y; 6, identifier:model_generator; 7, identifier:method_name; 8, block; 8, 9; 8, 19; 8, 28; 8, 32; 8, 144; 8, 153; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:old_seed; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:random; 17, identifier:seed; 18, argument_list; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:random; 25, identifier:seed; 26, argument_list; 26, 27; 27, integer:3293; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:method_reps; 31, list:[]; 32, for_statement; 32, 33; 32, 34; 32, 38; 33, identifier:i; 34, call; 34, 35; 34, 36; 35, identifier:range; 36, argument_list; 36, 37; 37, integer:1; 38, block; 38, 39; 38, 60; 38, 66; 38, 74; 38, 82; 38, 94; 38, 104; 38, 112; 38, 117; 38, 127; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 46; 41, pattern_list; 41, 42; 41, 43; 41, 44; 41, 45; 42, identifier:X_train; 43, identifier:X_test; 44, identifier:y_train; 45, identifier:_; 46, call; 46, 47; 46, 48; 47, identifier:train_test_split; 48, argument_list; 48, 49; 48, 53; 48, 54; 48, 57; 49, call; 49, 50; 49, 51; 50, identifier:__toarray; 51, argument_list; 51, 52; 52, identifier:X; 53, identifier:y; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:test_size; 56, integer:100; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:random_state; 59, identifier:i; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:model; 63, call; 63, 64; 63, 65; 64, identifier:model_generator; 65, argument_list; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:model; 70, identifier:fit; 71, argument_list; 71, 72; 71, 73; 72, identifier:X_train; 73, identifier:y_train; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:start; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:time; 80, identifier:time; 81, argument_list; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:explainer; 85, call; 85, 86; 85, 91; 86, call; 86, 87; 86, 88; 87, identifier:getattr; 88, argument_list; 88, 89; 88, 90; 89, identifier:methods; 90, identifier:method_name; 91, argument_list; 91, 92; 91, 93; 92, identifier:model; 93, identifier:X_train; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:build_time; 97, binary_operator:-; 97, 98; 97, 103; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:time; 101, identifier:time; 102, argument_list; 103, identifier:start; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:start; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:time; 110, identifier:time; 111, argument_list; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:explainer; 115, argument_list; 115, 116; 116, identifier:X_test; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:explain_time; 120, binary_operator:-; 120, 121; 120, 126; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:time; 124, identifier:time; 125, argument_list; 126, identifier:start; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:method_reps; 131, identifier:append; 132, argument_list; 132, 133; 133, binary_operator:+; 133, 134; 133, 135; 134, identifier:build_time; 135, binary_operator:/; 135, 136; 135, 139; 136, binary_operator:*; 136, 137; 136, 138; 137, identifier:explain_time; 138, float:1000.0; 139, subscript; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:X_test; 142, identifier:shape; 143, integer:0; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:np; 149, identifier:random; 150, identifier:seed; 151, argument_list; 151, 152; 152, identifier:old_seed; 153, return_statement; 153, 154; 154, expression_list; 154, 155; 154, 156; 155, None; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:np; 159, identifier:mean; 160, argument_list; 160, 161; 161, identifier:method_reps | def runtime(X, y, model_generator, method_name):
old_seed = np.random.seed()
np.random.seed(3293)
method_reps = []
for i in range(1):
X_train, X_test, y_train, _ = train_test_split(__toarray(X), y, test_size=100, random_state=i)
model = model_generator()
model.fit(X_train, y_train)
start = time.time()
explainer = getattr(methods, method_name)(model, X_train)
build_time = time.time() - start
start = time.time()
explainer(X_test)
explain_time = time.time() - start
method_reps.append(build_time + explain_time * 1000.0 / X_test.shape[0])
np.random.seed(old_seed)
return None, np.mean(method_reps) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:local_accuracy; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:X; 5, identifier:y; 6, identifier:model_generator; 7, identifier:method_name; 8, block; 8, 9; 8, 100; 8, 128; 9, function_definition; 9, 10; 9, 11; 9, 14; 10, function_name:score_map; 11, parameters; 11, 12; 11, 13; 12, identifier:true; 13, identifier:pred; 14, block; 14, 15; 14, 40; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:v; 18, call; 18, 19; 18, 20; 19, identifier:min; 20, argument_list; 20, 21; 20, 22; 21, float:1.0; 22, binary_operator:/; 22, 23; 22, 31; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:np; 26, identifier:std; 27, argument_list; 27, 28; 28, binary_operator:-; 28, 29; 28, 30; 29, identifier:pred; 30, identifier:true; 31, parenthesized_expression; 31, 32; 32, binary_operator:+; 32, 33; 32, 39; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:std; 37, argument_list; 37, 38; 38, identifier:true; 39, float:1e-8; 40, if_statement; 40, 41; 40, 44; 40, 47; 40, 54; 40, 61; 40, 68; 40, 75; 40, 82; 40, 89; 40, 96; 41, comparison_operator:<; 41, 42; 41, 43; 42, identifier:v; 43, float:1e-6; 44, block; 44, 45; 45, return_statement; 45, 46; 46, float:1.0; 47, elif_clause; 47, 48; 47, 51; 48, comparison_operator:<; 48, 49; 48, 50; 49, identifier:v; 50, float:0.01; 51, block; 51, 52; 52, return_statement; 52, 53; 53, float:0.9; 54, elif_clause; 54, 55; 54, 58; 55, comparison_operator:<; 55, 56; 55, 57; 56, identifier:v; 57, float:0.05; 58, block; 58, 59; 59, return_statement; 59, 60; 60, float:0.75; 61, elif_clause; 61, 62; 61, 65; 62, comparison_operator:<; 62, 63; 62, 64; 63, identifier:v; 64, float:0.1; 65, block; 65, 66; 66, return_statement; 66, 67; 67, float:0.6; 68, elif_clause; 68, 69; 68, 72; 69, comparison_operator:<; 69, 70; 69, 71; 70, identifier:v; 71, float:0.2; 72, block; 72, 73; 73, return_statement; 73, 74; 74, float:0.4; 75, elif_clause; 75, 76; 75, 79; 76, comparison_operator:<; 76, 77; 76, 78; 77, identifier:v; 78, float:0.3; 79, block; 79, 80; 80, return_statement; 80, 81; 81, float:0.3; 82, elif_clause; 82, 83; 82, 86; 83, comparison_operator:<; 83, 84; 83, 85; 84, identifier:v; 85, float:0.5; 86, block; 86, 87; 87, return_statement; 87, 88; 88, float:0.2; 89, elif_clause; 89, 90; 89, 93; 90, comparison_operator:<; 90, 91; 90, 92; 91, identifier:v; 92, float:0.7; 93, block; 93, 94; 94, return_statement; 94, 95; 95, float:0.1; 96, else_clause; 96, 97; 97, block; 97, 98; 98, return_statement; 98, 99; 99, float:0.0; 100, function_definition; 100, 101; 100, 102; 100, 110; 101, function_name:score_function; 102, parameters; 102, 103; 102, 104; 102, 105; 102, 106; 102, 107; 102, 108; 102, 109; 103, identifier:X_train; 104, identifier:X_test; 105, identifier:y_train; 106, identifier:y_test; 107, identifier:attr_function; 108, identifier:trained_model; 109, identifier:random_state; 110, block; 110, 111; 111, return_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:measures; 115, identifier:local_accuracy; 116, argument_list; 116, 117; 116, 118; 116, 119; 116, 120; 116, 121; 116, 125; 116, 126; 116, 127; 117, identifier:X_train; 118, identifier:y_train; 119, identifier:X_test; 120, identifier:y_test; 121, call; 121, 122; 121, 123; 122, identifier:attr_function; 123, argument_list; 123, 124; 124, identifier:X_test; 125, identifier:model_generator; 126, identifier:score_map; 127, identifier:trained_model; 128, return_statement; 128, 129; 129, expression_list; 129, 130; 129, 131; 130, None; 131, call; 131, 132; 131, 133; 132, identifier:__score_method; 133, argument_list; 133, 134; 133, 135; 133, 136; 133, 137; 133, 138; 133, 139; 134, identifier:X; 135, identifier:y; 136, None; 137, identifier:model_generator; 138, identifier:score_function; 139, identifier:method_name | def local_accuracy(X, y, model_generator, method_name):
def score_map(true, pred):
v = min(1.0, np.std(pred - true) / (np.std(true) + 1e-8))
if v < 1e-6:
return 1.0
elif v < 0.01:
return 0.9
elif v < 0.05:
return 0.75
elif v < 0.1:
return 0.6
elif v < 0.2:
return 0.4
elif v < 0.3:
return 0.3
elif v < 0.5:
return 0.2
elif v < 0.7:
return 0.1
else:
return 0.0
def score_function(X_train, X_test, y_train, y_test, attr_function, trained_model, random_state):
return measures.local_accuracy(
X_train, y_train, X_test, y_test, attr_function(X_test),
model_generator, score_map, trained_model
)
return None, __score_method(X, y, None, model_generator, score_function, method_name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_checkpoints_for_actor; 3, parameters; 3, 4; 4, identifier:actor_id; 5, block; 5, 6; 5, 19; 5, 26; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:checkpoint_info; 9, call; 9, 10; 9, 17; 10, attribute; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:ray; 14, identifier:worker; 15, identifier:global_state; 16, identifier:actor_checkpoint_info; 17, argument_list; 17, 18; 18, identifier:actor_id; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:checkpoint_info; 22, None; 23, block; 23, 24; 24, return_statement; 24, 25; 25, list:[]; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:checkpoints; 29, list_comprehension; 29, 30; 29, 35; 30, call; 30, 31; 30, 32; 31, identifier:Checkpoint; 32, argument_list; 32, 33; 32, 34; 33, identifier:checkpoint_id; 34, identifier:timestamp; 35, for_in_clause; 35, 36; 35, 39; 36, pattern_list; 36, 37; 36, 38; 37, identifier:checkpoint_id; 38, identifier:timestamp; 39, call; 39, 40; 39, 41; 40, identifier:zip; 41, argument_list; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:checkpoint_info; 44, string:"CheckpointIds"; 45, subscript; 45, 46; 45, 47; 46, identifier:checkpoint_info; 47, string:"Timestamps"; 48, return_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:sorted; 51, argument_list; 51, 52; 51, 53; 51, 61; 52, identifier:checkpoints; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:key; 55, lambda; 55, 56; 55, 58; 56, lambda_parameters; 56, 57; 57, identifier:checkpoint; 58, attribute; 58, 59; 58, 60; 59, identifier:checkpoint; 60, identifier:timestamp; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:reverse; 63, True | def get_checkpoints_for_actor(actor_id):
checkpoint_info = ray.worker.global_state.actor_checkpoint_info(actor_id)
if checkpoint_info is None:
return []
checkpoints = [
Checkpoint(checkpoint_id, timestamp) for checkpoint_id, timestamp in
zip(checkpoint_info["CheckpointIds"], checkpoint_info["Timestamps"])
]
return sorted(
checkpoints,
key=lambda checkpoint: checkpoint.timestamp,
reverse=True,
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_naturalize; 3, parameters; 3, 4; 4, identifier:string; 5, block; 5, 6; 5, 16; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:splits; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:re; 12, identifier:split; 13, argument_list; 13, 14; 13, 15; 14, string:"([0-9]+)"; 15, identifier:string; 16, return_statement; 16, 17; 17, list_comprehension; 17, 18; 17, 33; 18, conditional_expression:if; 18, 19; 18, 23; 18, 28; 19, call; 19, 20; 19, 21; 20, identifier:int; 21, argument_list; 21, 22; 22, identifier:text; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:text; 26, identifier:isdigit; 27, argument_list; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:text; 31, identifier:lower; 32, argument_list; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:text; 35, identifier:splits | def _naturalize(string):
splits = re.split("([0-9]+)", string)
return [int(text) if text.isdigit() else text.lower() for text in splits] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:mount; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:prefix; 6, identifier:adapter; 7, block; 7, 8; 7, 16; 7, 36; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 15; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:adapters; 14, identifier:prefix; 15, identifier:adapter; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:keys_to_move; 19, list_comprehension; 19, 20; 19, 21; 19, 26; 20, identifier:k; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:k; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:adapters; 26, if_clause; 26, 27; 27, comparison_operator:<; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:k; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:prefix; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:key; 38, identifier:keys_to_move; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 47; 42, subscript; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:adapters; 46, identifier:key; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:adapters; 52, identifier:pop; 53, argument_list; 53, 54; 54, identifier:key | def mount(self, prefix, adapter):
self.adapters[prefix] = adapter
keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]
for key in keys_to_move:
self.adapters[key] = self.adapters.pop(key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_outrows; 3, parameters; 3, 4; 4, identifier:outrows; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 11; 10, identifier:outrows; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:key; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:row; 16, call; 16, 17; 16, 18; 17, identifier:tuple; 18, generator_expression; 18, 19; 18, 23; 19, call; 19, 20; 19, 21; 20, identifier:str; 21, argument_list; 21, 22; 22, identifier:x; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:x; 25, identifier:row | def sorted_outrows(outrows):
return sorted(outrows, key=lambda row: tuple(str(x) for x in row)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:traceParseAction; 3, parameters; 3, 4; 4, identifier:f; 5, block; 5, 6; 5, 13; 5, 123; 5, 137; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:f; 9, call; 9, 10; 9, 11; 10, identifier:_trim_arity; 11, argument_list; 11, 12; 12, identifier:f; 13, function_definition; 13, 14; 13, 15; 13, 18; 14, function_name:z; 15, parameters; 15, 16; 16, list_splat_pattern; 16, 17; 17, identifier:paArgs; 18, block; 18, 19; 18, 25; 18, 37; 18, 59; 18, 78; 18, 108; 18, 121; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:thisFunc; 22, attribute; 22, 23; 22, 24; 23, identifier:f; 24, identifier:__name__; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 31; 27, pattern_list; 27, 28; 27, 29; 27, 30; 28, identifier:s; 29, identifier:l; 30, identifier:t; 31, subscript; 31, 32; 31, 33; 32, identifier:paArgs; 33, slice; 33, 34; 33, 36; 34, unary_operator:-; 34, 35; 35, integer:3; 36, colon; 37, if_statement; 37, 38; 37, 44; 38, comparison_operator:>; 38, 39; 38, 43; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, identifier:paArgs; 43, integer:3; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:thisFunc; 48, binary_operator:+; 48, 49; 48, 58; 49, binary_operator:+; 49, 50; 49, 57; 50, attribute; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:paArgs; 54, integer:0; 55, identifier:__class__; 56, identifier:__name__; 57, string:'.'; 58, identifier:thisFunc; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:sys; 64, identifier:stderr; 65, identifier:write; 66, argument_list; 66, 67; 67, binary_operator:%; 67, 68; 67, 69; 68, string:">>entering %s(line: '%s', %d, %r)\n"; 69, tuple; 69, 70; 69, 71; 69, 76; 69, 77; 70, identifier:thisFunc; 71, call; 71, 72; 71, 73; 72, identifier:line; 73, argument_list; 73, 74; 73, 75; 74, identifier:l; 75, identifier:s; 76, identifier:l; 77, identifier:t; 78, try_statement; 78, 79; 78, 88; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:ret; 83, call; 83, 84; 83, 85; 84, identifier:f; 85, argument_list; 85, 86; 86, list_splat; 86, 87; 87, identifier:paArgs; 88, except_clause; 88, 89; 88, 93; 89, as_pattern; 89, 90; 89, 91; 90, identifier:Exception; 91, as_pattern_target; 91, 92; 92, identifier:exc; 93, block; 93, 94; 93, 107; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:sys; 99, identifier:stderr; 100, identifier:write; 101, argument_list; 101, 102; 102, binary_operator:%; 102, 103; 102, 104; 103, string:"<<leaving %s (exception: %s)\n"; 104, tuple; 104, 105; 104, 106; 105, identifier:thisFunc; 106, identifier:exc; 107, raise_statement; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:sys; 113, identifier:stderr; 114, identifier:write; 115, argument_list; 115, 116; 116, binary_operator:%; 116, 117; 116, 118; 117, string:"<<leaving %s (ret: %r)\n"; 118, tuple; 118, 119; 118, 120; 119, identifier:thisFunc; 120, identifier:ret; 121, return_statement; 121, 122; 122, identifier:ret; 123, try_statement; 123, 124; 123, 133; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:z; 129, identifier:__name__; 130, attribute; 130, 131; 130, 132; 131, identifier:f; 132, identifier:__name__; 133, except_clause; 133, 134; 133, 135; 134, identifier:AttributeError; 135, block; 135, 136; 136, pass_statement; 137, return_statement; 137, 138; 138, identifier:z | def traceParseAction(f):
f = _trim_arity(f)
def z(*paArgs):
thisFunc = f.__name__
s,l,t = paArgs[-3:]
if len(paArgs)>3:
thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
try:
ret = f(*paArgs)
except Exception as exc:
sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
raise
sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )
return ret
try:
z.__name__ = f.__name__
except AttributeError:
pass
return z |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_tree; 3, parameters; 3, 4; 4, identifier:tree; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:OrderedDict; 9, argument_list; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 35; 13, list_comprehension; 13, 14; 13, 26; 14, tuple; 14, 15; 14, 16; 15, identifier:k; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 18, 20; 19, identifier:v; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:key; 22, call; 22, 23; 22, 24; 23, identifier:attrgetter; 24, argument_list; 24, 25; 25, string:'key'; 26, for_in_clause; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:k; 29, identifier:v; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:tree; 33, identifier:items; 34, argument_list; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:key; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:kv; 40, attribute; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:kv; 43, integer:0; 44, identifier:key | def sorted_tree(tree):
return OrderedDict(sorted([(k, sorted(v, key=attrgetter('key')))
for k, v in tree.items()],
key=lambda kv: kv[0].key)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:do_sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:environment; 5, identifier:value; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:case_sensitive; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:attribute; 14, None; 15, block; 15, 16; 15, 31; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:key_func; 19, call; 19, 20; 19, 21; 20, identifier:make_attrgetter; 21, argument_list; 21, 22; 21, 23; 21, 24; 22, identifier:environment; 23, identifier:attribute; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:postprocess; 26, conditional_expression:if; 26, 27; 26, 28; 26, 30; 27, identifier:ignore_case; 28, not_operator; 28, 29; 29, identifier:case_sensitive; 30, None; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:sorted; 34, argument_list; 34, 35; 34, 36; 34, 39; 35, identifier:value; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:key; 38, identifier:key_func; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:reverse; 41, identifier:reverse | def do_sort(
environment, value, reverse=False, case_sensitive=False, attribute=None
):
key_func = make_attrgetter(
environment, attribute,
postprocess=ignore_case if not case_sensitive else None
)
return sorted(value, key=key_func, reverse=reverse) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sorted; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:wantdirs; 7, False; 8, block; 8, 9; 8, 62; 8, 71; 8, 101; 9, function_definition; 9, 10; 9, 11; 9, 14; 10, function_name:add_dir; 11, parameters; 11, 12; 11, 13; 12, identifier:dirs; 13, identifier:d; 14, block; 14, 15; 14, 22; 14, 30; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:dirs; 19, identifier:add; 20, argument_list; 20, 21; 21, identifier:d; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:logger; 26, identifier:debug; 27, argument_list; 27, 28; 27, 29; 28, string:'add_dir added %s'; 29, identifier:d; 30, if_statement; 30, 31; 30, 36; 31, comparison_operator:!=; 31, 32; 31, 33; 32, identifier:d; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:base; 36, block; 36, 37; 36, 50; 36, 56; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, pattern_list; 39, 40; 39, 41; 40, identifier:parent; 41, identifier:_; 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:split; 48, argument_list; 48, 49; 49, identifier:d; 50, assert_statement; 50, 51; 51, comparison_operator:not; 51, 52; 51, 53; 52, identifier:parent; 53, tuple; 53, 54; 53, 55; 54, string:''; 55, string:'/'; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:add_dir; 59, argument_list; 59, 60; 59, 61; 60, identifier:dirs; 61, identifier:parent; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:result; 65, call; 65, 66; 65, 67; 66, identifier:set; 67, argument_list; 67, 68; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:files; 71, if_statement; 71, 72; 71, 73; 72, identifier:wantdirs; 73, block; 73, 74; 73, 80; 73, 97; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:dirs; 77, call; 77, 78; 77, 79; 78, identifier:set; 79, argument_list; 80, for_statement; 80, 81; 80, 82; 80, 83; 81, identifier:f; 82, identifier:result; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:add_dir; 87, argument_list; 87, 88; 87, 89; 88, identifier:dirs; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:os; 93, identifier:path; 94, identifier:dirname; 95, argument_list; 95, 96; 96, identifier:f; 97, expression_statement; 97, 98; 98, augmented_assignment:|=; 98, 99; 98, 100; 99, identifier:result; 100, identifier:dirs; 101, return_statement; 101, 102; 102, list_comprehension; 102, 103; 102, 112; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:os; 107, identifier:path; 108, identifier:join; 109, argument_list; 109, 110; 110, list_splat; 110, 111; 111, identifier:path_tuple; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:path_tuple; 114, call; 114, 115; 114, 116; 115, identifier:sorted; 116, generator_expression; 116, 117; 116, 125; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:os; 121, identifier:path; 122, identifier:split; 123, argument_list; 123, 124; 124, identifier:path; 125, for_in_clause; 125, 126; 125, 127; 126, identifier:path; 127, identifier:result | def sorted(self, wantdirs=False):
def add_dir(dirs, d):
dirs.add(d)
logger.debug('add_dir added %s', d)
if d != self.base:
parent, _ = os.path.split(d)
assert parent not in ('', '/')
add_dir(dirs, parent)
result = set(self.files)
if wantdirs:
dirs = set()
for f in result:
add_dir(dirs, os.path.dirname(f))
result |= dirs
return [os.path.join(*path_tuple) for path_tuple in
sorted(os.path.split(path) for path in result)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:next_event_indexer; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:all_dates; 5, identifier:data_query_cutoff; 6, identifier:all_sids; 7, identifier:event_dates; 8, identifier:event_timestamps; 9, identifier:event_sids; 10, block; 10, 11; 10, 18; 10, 42; 10, 51; 10, 63; 10, 75; 10, 115; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:validate_event_metadata; 14, argument_list; 14, 15; 14, 16; 14, 17; 15, identifier:event_dates; 16, identifier:event_timestamps; 17, identifier:event_sids; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:out; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:full; 25, argument_list; 25, 26; 25, 35; 25, 37; 26, tuple; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:all_dates; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:all_sids; 35, unary_operator:-; 35, 36; 36, integer:1; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:dtype; 39, attribute; 39, 40; 39, 41; 40, identifier:np; 41, identifier:int64; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:sid_ixs; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:all_sids; 48, identifier:searchsorted; 49, argument_list; 49, 50; 50, identifier:event_sids; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:dt_ixs; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:all_dates; 57, identifier:searchsorted; 58, argument_list; 58, 59; 58, 60; 59, identifier:event_dates; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:side; 62, string:'right'; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:ts_ixs; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:data_query_cutoff; 69, identifier:searchsorted; 70, argument_list; 70, 71; 70, 72; 71, identifier:event_timestamps; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:side; 74, string:'right'; 75, for_statement; 75, 76; 75, 77; 75, 90; 76, identifier:i; 77, call; 77, 78; 77, 79; 78, identifier:range; 79, argument_list; 79, 80; 79, 86; 79, 88; 80, binary_operator:-; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:event_sids; 85, integer:1; 86, unary_operator:-; 86, 87; 87, integer:1; 88, unary_operator:-; 88, 89; 89, integer:1; 90, block; 90, 91; 90, 97; 90, 103; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:start_ix; 94, subscript; 94, 95; 94, 96; 95, identifier:ts_ixs; 96, identifier:i; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:end_ix; 100, subscript; 100, 101; 100, 102; 101, identifier:dt_ixs; 102, identifier:i; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 114; 105, subscript; 105, 106; 105, 107; 105, 111; 106, identifier:out; 107, slice; 107, 108; 107, 109; 107, 110; 108, identifier:start_ix; 109, colon; 110, identifier:end_ix; 111, subscript; 111, 112; 111, 113; 112, identifier:sid_ixs; 113, identifier:i; 114, identifier:i; 115, return_statement; 115, 116; 116, identifier:out | def next_event_indexer(all_dates,
data_query_cutoff,
all_sids,
event_dates,
event_timestamps,
event_sids):
validate_event_metadata(event_dates, event_timestamps, event_sids)
out = np.full((len(all_dates), len(all_sids)), -1, dtype=np.int64)
sid_ixs = all_sids.searchsorted(event_sids)
dt_ixs = all_dates.searchsorted(event_dates, side='right')
ts_ixs = data_query_cutoff.searchsorted(event_timestamps, side='right')
for i in range(len(event_sids) - 1, -1, -1):
start_ix = ts_ixs[i]
end_ix = dt_ixs[i]
out[start_ix:end_ix, sid_ixs[i]] = i
return out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:previous_event_indexer; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:data_query_cutoff_times; 5, identifier:all_sids; 6, identifier:event_dates; 7, identifier:event_timestamps; 8, identifier:event_sids; 9, block; 9, 10; 9, 17; 9, 41; 9, 51; 9, 60; 9, 72; 9, 76; 9, 126; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:validate_event_metadata; 13, argument_list; 13, 14; 13, 15; 13, 16; 14, identifier:event_dates; 15, identifier:event_timestamps; 16, identifier:event_sids; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:out; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:np; 23, identifier:full; 24, argument_list; 24, 25; 24, 34; 24, 36; 25, tuple; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:data_query_cutoff_times; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:all_sids; 34, unary_operator:-; 34, 35; 35, integer:1; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:dtype; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:int64; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:eff_dts; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:np; 47, identifier:maximum; 48, argument_list; 48, 49; 48, 50; 49, identifier:event_dates; 50, identifier:event_timestamps; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:sid_ixs; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:all_sids; 57, identifier:searchsorted; 58, argument_list; 58, 59; 59, identifier:event_sids; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:dt_ixs; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:data_query_cutoff_times; 66, identifier:searchsorted; 67, argument_list; 67, 68; 67, 69; 68, identifier:eff_dts; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:side; 71, string:'right'; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:last_written; 75, dictionary; 76, for_statement; 76, 77; 76, 78; 76, 91; 77, identifier:i; 78, call; 78, 79; 78, 80; 79, identifier:range; 80, argument_list; 80, 81; 80, 87; 80, 89; 81, binary_operator:-; 81, 82; 81, 86; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:event_dates; 86, integer:1; 87, unary_operator:-; 87, 88; 88, integer:1; 89, unary_operator:-; 89, 90; 90, integer:1; 91, block; 91, 92; 91, 98; 91, 104; 91, 120; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:sid_ix; 95, subscript; 95, 96; 95, 97; 96, identifier:sid_ixs; 97, identifier:i; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:dt_ix; 101, subscript; 101, 102; 101, 103; 102, identifier:dt_ixs; 103, identifier:i; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 119; 106, subscript; 106, 107; 106, 108; 106, 118; 107, identifier:out; 108, slice; 108, 109; 108, 110; 108, 111; 109, identifier:dt_ix; 110, colon; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:last_written; 114, identifier:get; 115, argument_list; 115, 116; 115, 117; 116, identifier:sid_ix; 117, None; 118, identifier:sid_ix; 119, identifier:i; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:last_written; 124, identifier:sid_ix; 125, identifier:dt_ix; 126, return_statement; 126, 127; 127, identifier:out | def previous_event_indexer(data_query_cutoff_times,
all_sids,
event_dates,
event_timestamps,
event_sids):
validate_event_metadata(event_dates, event_timestamps, event_sids)
out = np.full(
(len(data_query_cutoff_times), len(all_sids)),
-1,
dtype=np.int64,
)
eff_dts = np.maximum(event_dates, event_timestamps)
sid_ixs = all_sids.searchsorted(event_sids)
dt_ixs = data_query_cutoff_times.searchsorted(eff_dts, side='right')
last_written = {}
for i in range(len(event_dates) - 1, -1, -1):
sid_ix = sid_ixs[i]
dt_ix = dt_ixs[i]
out[dt_ix:last_written.get(sid_ix, None), sid_ix] = i
last_written[sid_ix] = dt_ix
return out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:last_in_date_group; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:df; 5, identifier:data_query_cutoff_times; 6, identifier:assets; 7, default_parameter; 7, 8; 7, 9; 8, identifier:reindex; 9, True; 10, default_parameter; 10, 11; 10, 12; 11, identifier:have_sids; 12, True; 13, default_parameter; 13, 14; 13, 15; 14, identifier:extra_groupers; 15, None; 16, block; 16, 17; 16, 33; 16, 41; 16, 50; 16, 54; 16, 78; 16, 100; 16, 167; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:idx; 20, list:[data_query_cutoff_times[data_query_cutoff_times.searchsorted(
df[TS_FIELD_NAME].values,
)]]; 20, 21; 21, subscript; 21, 22; 21, 23; 22, identifier:data_query_cutoff_times; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:data_query_cutoff_times; 26, identifier:searchsorted; 27, argument_list; 27, 28; 28, attribute; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:df; 31, identifier:TS_FIELD_NAME; 32, identifier:values; 33, if_statement; 33, 34; 33, 35; 34, identifier:have_sids; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, augmented_assignment:+=; 37, 38; 37, 39; 38, identifier:idx; 39, list:[SID_FIELD_NAME]; 39, 40; 40, identifier:SID_FIELD_NAME; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:extra_groupers; 44, None; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:extra_groupers; 49, list:[]; 50, expression_statement; 50, 51; 51, augmented_assignment:+=; 51, 52; 51, 53; 52, identifier:idx; 53, identifier:extra_groupers; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:last_in_group; 57, call; 57, 58; 57, 77; 58, attribute; 58, 59; 58, 76; 59, call; 59, 60; 59, 71; 60, attribute; 60, 61; 60, 70; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:df; 64, identifier:drop; 65, argument_list; 65, 66; 65, 67; 66, identifier:TS_FIELD_NAME; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:axis; 69, integer:1; 70, identifier:groupby; 71, argument_list; 71, 72; 71, 73; 72, identifier:idx; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:sort; 75, False; 76, identifier:last; 77, argument_list; 78, for_statement; 78, 79; 78, 80; 78, 89; 79, identifier:_; 80, call; 80, 81; 80, 82; 81, identifier:range; 82, argument_list; 82, 83; 83, binary_operator:-; 83, 84; 83, 88; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, identifier:idx; 88, integer:1; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:last_in_group; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:last_in_group; 96, identifier:unstack; 97, argument_list; 97, 98; 98, unary_operator:-; 98, 99; 99, integer:1; 100, if_statement; 100, 101; 100, 102; 101, identifier:reindex; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 105; 103, 156; 104, identifier:have_sids; 105, block; 105, 106; 105, 112; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:cols; 109, attribute; 109, 110; 109, 111; 110, identifier:last_in_group; 111, identifier:columns; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:last_in_group; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:last_in_group; 118, identifier:reindex; 119, argument_list; 119, 120; 119, 123; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:index; 122, identifier:data_query_cutoff_times; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:columns; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:pd; 129, identifier:MultiIndex; 130, identifier:from_product; 131, argument_list; 131, 132; 131, 151; 132, binary_operator:+; 132, 133; 132, 149; 133, call; 133, 134; 133, 135; 134, identifier:tuple; 135, argument_list; 135, 136; 136, subscript; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:cols; 139, identifier:levels; 140, slice; 140, 141; 140, 142; 140, 143; 141, integer:0; 142, colon; 143, binary_operator:+; 143, 144; 143, 148; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, identifier:extra_groupers; 148, integer:1; 149, tuple; 149, 150; 150, identifier:assets; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:names; 153, attribute; 153, 154; 153, 155; 154, identifier:cols; 155, identifier:names; 156, else_clause; 156, 157; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:last_in_group; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:last_in_group; 164, identifier:reindex; 165, argument_list; 165, 166; 166, identifier:data_query_cutoff_times; 167, return_statement; 167, 168; 168, identifier:last_in_group | def last_in_date_group(df,
data_query_cutoff_times,
assets,
reindex=True,
have_sids=True,
extra_groupers=None):
idx = [data_query_cutoff_times[data_query_cutoff_times.searchsorted(
df[TS_FIELD_NAME].values,
)]]
if have_sids:
idx += [SID_FIELD_NAME]
if extra_groupers is None:
extra_groupers = []
idx += extra_groupers
last_in_group = df.drop(TS_FIELD_NAME, axis=1).groupby(
idx,
sort=False,
).last()
for _ in range(len(idx) - 1):
last_in_group = last_in_group.unstack(-1)
if reindex:
if have_sids:
cols = last_in_group.columns
last_in_group = last_in_group.reindex(
index=data_query_cutoff_times,
columns=pd.MultiIndex.from_product(
tuple(cols.levels[0:len(extra_groupers) + 1]) + (assets,),
names=cols.names,
),
)
else:
last_in_group = last_in_group.reindex(data_query_cutoff_times)
return last_in_group |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:risk_metric_period; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:cls; 5, identifier:start_session; 6, identifier:end_session; 7, identifier:algorithm_returns; 8, identifier:benchmark_returns; 9, identifier:algorithm_leverages; 10, block; 10, 11; 10, 29; 10, 52; 10, 66; 10, 80; 10, 96; 10, 105; 10, 117; 10, 138; 10, 213; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:algorithm_returns; 14, subscript; 14, 15; 14, 16; 15, identifier:algorithm_returns; 16, binary_operator:&; 16, 17; 16, 23; 17, parenthesized_expression; 17, 18; 18, comparison_operator:>=; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:algorithm_returns; 21, identifier:index; 22, identifier:start_session; 23, parenthesized_expression; 23, 24; 24, comparison_operator:<=; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:algorithm_returns; 27, identifier:index; 28, identifier:end_session; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:benchmark_returns; 32, subscript; 32, 33; 32, 34; 33, identifier:benchmark_returns; 34, binary_operator:&; 34, 35; 34, 41; 35, parenthesized_expression; 35, 36; 36, comparison_operator:>=; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:benchmark_returns; 39, identifier:index; 40, identifier:start_session; 41, parenthesized_expression; 41, 42; 42, comparison_operator:<=; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:benchmark_returns; 45, identifier:index; 46, subscript; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:algorithm_returns; 49, identifier:index; 50, unary_operator:-; 50, 51; 51, integer:1; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:benchmark_period_returns; 55, subscript; 55, 56; 55, 64; 56, attribute; 56, 57; 56, 63; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:ep; 60, identifier:cum_returns; 61, argument_list; 61, 62; 62, identifier:benchmark_returns; 63, identifier:iloc; 64, unary_operator:-; 64, 65; 65, integer:1; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:algorithm_period_returns; 69, subscript; 69, 70; 69, 78; 70, attribute; 70, 71; 70, 77; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:ep; 74, identifier:cum_returns; 75, argument_list; 75, 76; 76, identifier:algorithm_returns; 77, identifier:iloc; 78, unary_operator:-; 78, 79; 79, integer:1; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, pattern_list; 82, 83; 82, 84; 83, identifier:alpha; 84, identifier:beta; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:ep; 88, identifier:alpha_beta_aligned; 89, argument_list; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:algorithm_returns; 92, identifier:values; 93, attribute; 93, 94; 93, 95; 94, identifier:benchmark_returns; 95, identifier:values; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:sharpe; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:ep; 102, identifier:sharpe_ratio; 103, argument_list; 103, 104; 104, identifier:algorithm_returns; 105, if_statement; 105, 106; 105, 112; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:pd; 109, identifier:isnull; 110, argument_list; 110, 111; 111, identifier:sharpe; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:sharpe; 116, float:0.0; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:sortino; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:ep; 123, identifier:sortino_ratio; 124, argument_list; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:algorithm_returns; 127, identifier:values; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:_downside_risk; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:ep; 133, identifier:downside_risk; 134, argument_list; 134, 135; 135, attribute; 135, 136; 135, 137; 136, identifier:algorithm_returns; 137, identifier:values; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:rval; 141, dictionary; 141, 142; 141, 145; 141, 148; 141, 151; 141, 154; 141, 157; 141, 160; 141, 163; 141, 166; 141, 174; 141, 180; 141, 188; 141, 196; 141, 206; 142, pair; 142, 143; 142, 144; 143, string:'algorithm_period_return'; 144, identifier:algorithm_period_returns; 145, pair; 145, 146; 145, 147; 146, string:'benchmark_period_return'; 147, identifier:benchmark_period_returns; 148, pair; 148, 149; 148, 150; 149, string:'treasury_period_return'; 150, integer:0; 151, pair; 151, 152; 151, 153; 152, string:'excess_return'; 153, identifier:algorithm_period_returns; 154, pair; 154, 155; 154, 156; 155, string:'alpha'; 156, identifier:alpha; 157, pair; 157, 158; 157, 159; 158, string:'beta'; 159, identifier:beta; 160, pair; 160, 161; 160, 162; 161, string:'sharpe'; 162, identifier:sharpe; 163, pair; 163, 164; 163, 165; 164, string:'sortino'; 165, identifier:sortino; 166, pair; 166, 167; 166, 168; 167, string:'period_label'; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:end_session; 171, identifier:strftime; 172, argument_list; 172, 173; 173, string:"%Y-%m"; 174, pair; 174, 175; 174, 176; 175, string:'trading_days'; 176, call; 176, 177; 176, 178; 177, identifier:len; 178, argument_list; 178, 179; 179, identifier:benchmark_returns; 180, pair; 180, 181; 180, 182; 181, string:'algo_volatility'; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:ep; 185, identifier:annual_volatility; 186, argument_list; 186, 187; 187, identifier:algorithm_returns; 188, pair; 188, 189; 188, 190; 189, string:'benchmark_volatility'; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:ep; 193, identifier:annual_volatility; 194, argument_list; 194, 195; 195, identifier:benchmark_returns; 196, pair; 196, 197; 196, 198; 197, string:'max_drawdown'; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:ep; 201, identifier:max_drawdown; 202, argument_list; 202, 203; 203, attribute; 203, 204; 203, 205; 204, identifier:algorithm_returns; 205, identifier:values; 206, pair; 206, 207; 206, 208; 207, string:'max_leverage'; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:algorithm_leverages; 211, identifier:max; 212, argument_list; 213, return_statement; 213, 214; 214, dictionary_comprehension; 214, 215; 214, 232; 215, pair; 215, 216; 215, 217; 216, identifier:k; 217, parenthesized_expression; 217, 218; 218, conditional_expression:if; 218, 219; 218, 220; 218, 231; 219, None; 220, boolean_operator:and; 220, 221; 220, 224; 221, comparison_operator:!=; 221, 222; 221, 223; 222, identifier:k; 223, string:'period_label'; 224, not_operator; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:np; 228, identifier:isfinite; 229, argument_list; 229, 230; 230, identifier:v; 231, identifier:v; 232, for_in_clause; 232, 233; 232, 236; 233, pattern_list; 233, 234; 233, 235; 234, identifier:k; 235, identifier:v; 236, call; 236, 237; 236, 238; 237, identifier:iteritems; 238, argument_list; 238, 239; 239, identifier:rval | def risk_metric_period(cls,
start_session,
end_session,
algorithm_returns,
benchmark_returns,
algorithm_leverages):
algorithm_returns = algorithm_returns[
(algorithm_returns.index >= start_session) &
(algorithm_returns.index <= end_session)
]
benchmark_returns = benchmark_returns[
(benchmark_returns.index >= start_session) &
(benchmark_returns.index <= algorithm_returns.index[-1])
]
benchmark_period_returns = ep.cum_returns(benchmark_returns).iloc[-1]
algorithm_period_returns = ep.cum_returns(algorithm_returns).iloc[-1]
alpha, beta = ep.alpha_beta_aligned(
algorithm_returns.values,
benchmark_returns.values,
)
sharpe = ep.sharpe_ratio(algorithm_returns)
if pd.isnull(sharpe):
sharpe = 0.0
sortino = ep.sortino_ratio(
algorithm_returns.values,
_downside_risk=ep.downside_risk(algorithm_returns.values),
)
rval = {
'algorithm_period_return': algorithm_period_returns,
'benchmark_period_return': benchmark_period_returns,
'treasury_period_return': 0,
'excess_return': algorithm_period_returns,
'alpha': alpha,
'beta': beta,
'sharpe': sharpe,
'sortino': sortino,
'period_label': end_session.strftime("%Y-%m"),
'trading_days': len(benchmark_returns),
'algo_volatility': ep.annual_volatility(algorithm_returns),
'benchmark_volatility': ep.annual_volatility(benchmark_returns),
'max_drawdown': ep.max_drawdown(algorithm_returns.values),
'max_leverage': algorithm_leverages.max(),
}
return {
k: (
None
if k != 'period_label' and not np.isfinite(v) else
v
)
for k, v in iteritems(rval)
} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_last_data_per_qtr; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:assets_with_data; 6, identifier:columns; 7, identifier:dates; 8, identifier:data_query_cutoff_times; 9, block; 9, 10; 9, 28; 9, 34; 9, 43; 9, 54; 9, 69; 9, 78; 9, 91; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:last_per_qtr; 13, call; 13, 14; 13, 15; 14, identifier:last_in_date_group; 15, argument_list; 15, 16; 15, 19; 15, 20; 15, 21; 15, 24; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:estimates; 19, identifier:data_query_cutoff_times; 20, identifier:assets_with_data; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:reindex; 23, True; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:extra_groupers; 26, list:[NORMALIZED_QUARTERS]; 26, 27; 27, identifier:NORMALIZED_QUARTERS; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:last_per_qtr; 32, identifier:index; 33, identifier:dates; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ffill_across_cols; 37, argument_list; 37, 38; 37, 39; 37, 40; 38, identifier:last_per_qtr; 39, identifier:columns; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:name_map; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:stacked_last_per_qtr; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:last_per_qtr; 49, identifier:stack; 50, argument_list; 50, 51; 51, list:[SID_FIELD_NAME, NORMALIZED_QUARTERS]; 51, 52; 51, 53; 52, identifier:SID_FIELD_NAME; 53, identifier:NORMALIZED_QUARTERS; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:stacked_last_per_qtr; 59, identifier:index; 60, identifier:set_names; 61, argument_list; 61, 62; 61, 63; 61, 66; 62, identifier:SIMULATION_DATES; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:level; 65, integer:0; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:inplace; 68, True; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:stacked_last_per_qtr; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:stacked_last_per_qtr; 75, identifier:sort_values; 76, argument_list; 76, 77; 77, identifier:EVENT_DATE_FIELD_NAME; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:stacked_last_per_qtr; 82, identifier:EVENT_DATE_FIELD_NAME; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:pd; 86, identifier:to_datetime; 87, argument_list; 87, 88; 88, subscript; 88, 89; 88, 90; 89, identifier:stacked_last_per_qtr; 90, identifier:EVENT_DATE_FIELD_NAME; 91, return_statement; 91, 92; 92, expression_list; 92, 93; 92, 94; 93, identifier:last_per_qtr; 94, identifier:stacked_last_per_qtr | def get_last_data_per_qtr(self,
assets_with_data,
columns,
dates,
data_query_cutoff_times):
last_per_qtr = last_in_date_group(
self.estimates,
data_query_cutoff_times,
assets_with_data,
reindex=True,
extra_groupers=[NORMALIZED_QUARTERS],
)
last_per_qtr.index = dates
ffill_across_cols(last_per_qtr, columns, self.name_map)
stacked_last_per_qtr = last_per_qtr.stack(
[SID_FIELD_NAME, NORMALIZED_QUARTERS],
)
stacked_last_per_qtr.index.set_names(
SIMULATION_DATES,
level=0,
inplace=True,
)
stacked_last_per_qtr = stacked_last_per_qtr.sort_values(
EVENT_DATE_FIELD_NAME,
)
stacked_last_per_qtr[EVENT_DATE_FIELD_NAME] = pd.to_datetime(
stacked_last_per_qtr[EVENT_DATE_FIELD_NAME]
)
return last_per_qtr, stacked_last_per_qtr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_zeroth_quarter_idx; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:stacked_last_per_qtr; 6, block; 6, 7; 6, 44; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:previous_releases_per_date; 10, call; 10, 11; 10, 41; 11, attribute; 11, 12; 11, 40; 12, call; 12, 13; 12, 31; 13, attribute; 13, 14; 13, 30; 14, subscript; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:stacked_last_per_qtr; 17, identifier:loc; 18, comparison_operator:<=; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:stacked_last_per_qtr; 21, identifier:EVENT_DATE_FIELD_NAME; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:stacked_last_per_qtr; 26, identifier:index; 27, identifier:get_level_values; 28, argument_list; 28, 29; 29, identifier:SIMULATION_DATES; 30, identifier:groupby; 31, argument_list; 31, 32; 31, 37; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:level; 34, list:[SIMULATION_DATES, SID_FIELD_NAME]; 34, 35; 34, 36; 35, identifier:SIMULATION_DATES; 36, identifier:SID_FIELD_NAME; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:as_index; 39, False; 40, identifier:nth; 41, argument_list; 41, 42; 42, unary_operator:-; 42, 43; 43, integer:1; 44, return_statement; 44, 45; 45, attribute; 45, 46; 45, 47; 46, identifier:previous_releases_per_date; 47, identifier:index | def get_zeroth_quarter_idx(self, stacked_last_per_qtr):
previous_releases_per_date = stacked_last_per_qtr.loc[
stacked_last_per_qtr[EVENT_DATE_FIELD_NAME] <=
stacked_last_per_qtr.index.get_level_values(SIMULATION_DATES)
].groupby(
level=[SIMULATION_DATES, SID_FIELD_NAME],
as_index=False,
).nth(-1)
return previous_releases_per_date.index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:rank; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:method; 7, string:'ordinal'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ascending; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:mask; 13, identifier:NotSpecified; 14, default_parameter; 14, 15; 14, 16; 15, identifier:groupby; 16, identifier:NotSpecified; 17, block; 17, 18; 17, 37; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:groupby; 21, identifier:NotSpecified; 22, block; 22, 23; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:Rank; 26, argument_list; 26, 27; 26, 28; 26, 31; 26, 34; 27, identifier:self; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:method; 30, identifier:method; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:ascending; 33, identifier:ascending; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:mask; 36, identifier:mask; 37, return_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:GroupedRowTransform; 40, argument_list; 40, 41; 40, 47; 40, 51; 40, 54; 40, 57; 40, 60; 40, 63; 40, 66; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:transform; 43, conditional_expression:if; 43, 44; 43, 45; 43, 46; 44, identifier:rankdata; 45, identifier:ascending; 46, identifier:rankdata_1d_descending; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:transform_args; 49, tuple; 49, 50; 50, identifier:method; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:factor; 53, identifier:self; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:groupby; 56, identifier:groupby; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:dtype; 59, identifier:float64_dtype; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:missing_value; 62, identifier:nan; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:mask; 65, identifier:mask; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:window_safe; 68, True | def rank(self,
method='ordinal',
ascending=True,
mask=NotSpecified,
groupby=NotSpecified):
if groupby is NotSpecified:
return Rank(self, method=method, ascending=ascending, mask=mask)
return GroupedRowTransform(
transform=rankdata if ascending else rankdata_1d_descending,
transform_args=(method,),
factor=self,
groupby=groupby,
dtype=float64_dtype,
missing_value=nan,
mask=mask,
window_safe=True,
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:find_in_sorted_index; 3, parameters; 3, 4; 3, 5; 4, identifier:dts; 5, identifier:dt; 6, block; 6, 7; 6, 16; 6, 45; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:ix; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:dts; 13, identifier:searchsorted; 14, argument_list; 14, 15; 15, identifier:dt; 16, if_statement; 16, 17; 16, 29; 17, boolean_operator:or; 17, 18; 17, 24; 18, comparison_operator:==; 18, 19; 18, 20; 19, identifier:ix; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:dts; 24, comparison_operator:!=; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:dts; 27, identifier:ix; 28, identifier:dt; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:LookupError; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, string:"{dt} is not in {dts}"; 37, identifier:format; 38, argument_list; 38, 39; 38, 42; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:dt; 41, identifier:dt; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:dts; 44, identifier:dts; 45, return_statement; 45, 46; 46, identifier:ix | def find_in_sorted_index(dts, dt):
ix = dts.searchsorted(dt)
if ix == len(dts) or dts[ix] != dt:
raise LookupError("{dt} is not in {dts}".format(dt=dt, dts=dts))
return ix |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:nearest_unequal_elements; 3, parameters; 3, 4; 3, 5; 4, identifier:dts; 5, identifier:dt; 6, block; 6, 7; 6, 18; 6, 29; 6, 40; 6, 52; 6, 70; 6, 114; 6, 125; 6, 139; 7, if_statement; 7, 8; 7, 12; 8, not_operator; 8, 9; 9, attribute; 9, 10; 9, 11; 10, identifier:dts; 11, identifier:is_unique; 12, block; 12, 13; 13, raise_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:ValueError; 16, argument_list; 16, 17; 17, string:"dts must be unique"; 18, if_statement; 18, 19; 18, 23; 19, not_operator; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:dts; 22, identifier:is_monotonic_increasing; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:ValueError; 27, argument_list; 27, 28; 28, string:"dts must be sorted in increasing order"; 29, if_statement; 29, 30; 29, 35; 30, not_operator; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:dts; 35, block; 35, 36; 36, return_statement; 36, 37; 37, expression_list; 37, 38; 37, 39; 38, None; 39, None; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:sortpos; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:dts; 46, identifier:searchsorted; 47, argument_list; 47, 48; 47, 49; 48, identifier:dt; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:side; 51, string:'left'; 52, try_statement; 52, 53; 52, 60; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:sortval; 57, subscript; 57, 58; 57, 59; 58, identifier:dts; 59, identifier:sortpos; 60, except_clause; 60, 61; 60, 62; 61, identifier:IndexError; 62, block; 62, 63; 63, return_statement; 63, 64; 64, expression_list; 64, 65; 64, 69; 65, subscript; 65, 66; 65, 67; 66, identifier:dts; 67, unary_operator:-; 67, 68; 68, integer:1; 69, None; 70, if_statement; 70, 71; 70, 74; 70, 85; 70, 102; 71, comparison_operator:<; 71, 72; 71, 73; 72, identifier:dt; 73, identifier:sortval; 74, block; 74, 75; 74, 81; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:lower_ix; 78, binary_operator:-; 78, 79; 78, 80; 79, identifier:sortpos; 80, integer:1; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:upper_ix; 84, identifier:sortpos; 85, elif_clause; 85, 86; 85, 89; 86, comparison_operator:==; 86, 87; 86, 88; 87, identifier:dt; 88, identifier:sortval; 89, block; 89, 90; 89, 96; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:lower_ix; 93, binary_operator:-; 93, 94; 93, 95; 94, identifier:sortpos; 95, integer:1; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:upper_ix; 99, binary_operator:+; 99, 100; 99, 101; 100, identifier:sortpos; 101, integer:1; 102, else_clause; 102, 103; 103, block; 103, 104; 103, 108; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:lower_ix; 107, identifier:sortpos; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:upper_ix; 111, binary_operator:+; 111, 112; 111, 113; 112, identifier:sortpos; 113, integer:1; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:lower_value; 117, conditional_expression:if; 117, 118; 117, 121; 117, 124; 118, subscript; 118, 119; 118, 120; 119, identifier:dts; 120, identifier:lower_ix; 121, comparison_operator:>=; 121, 122; 121, 123; 122, identifier:lower_ix; 123, integer:0; 124, None; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:upper_value; 128, conditional_expression:if; 128, 129; 128, 132; 128, 138; 129, subscript; 129, 130; 129, 131; 130, identifier:dts; 131, identifier:upper_ix; 132, comparison_operator:<; 132, 133; 132, 134; 133, identifier:upper_ix; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, identifier:dts; 138, None; 139, return_statement; 139, 140; 140, expression_list; 140, 141; 140, 142; 141, identifier:lower_value; 142, identifier:upper_value | def nearest_unequal_elements(dts, dt):
if not dts.is_unique:
raise ValueError("dts must be unique")
if not dts.is_monotonic_increasing:
raise ValueError("dts must be sorted in increasing order")
if not len(dts):
return None, None
sortpos = dts.searchsorted(dt, side='left')
try:
sortval = dts[sortpos]
except IndexError:
return dts[-1], None
if dt < sortval:
lower_ix = sortpos - 1
upper_ix = sortpos
elif dt == sortval:
lower_ix = sortpos - 1
upper_ix = sortpos + 1
else:
lower_ix = sortpos
upper_ix = sortpos + 1
lower_value = dts[lower_ix] if lower_ix >= 0 else None
upper_value = dts[upper_ix] if upper_ix < len(dts) else None
return lower_value, upper_value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:date_sorted_sources; 3, parameters; 3, 4; 4, list_splat_pattern; 4, 5; 5, identifier:sources; 6, block; 6, 7; 6, 24; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sorted_stream; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:heapq; 13, identifier:merge; 14, argument_list; 14, 15; 15, list_splat; 15, 16; 16, generator_expression; 16, 17; 16, 21; 17, call; 17, 18; 17, 19; 18, identifier:_decorate_source; 19, argument_list; 19, 20; 20, identifier:s; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:s; 23, identifier:sources; 24, for_statement; 24, 25; 24, 28; 24, 29; 25, pattern_list; 25, 26; 25, 27; 26, identifier:_; 27, identifier:message; 28, identifier:sorted_stream; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, yield; 31, 32; 32, identifier:message | def date_sorted_sources(*sources):
sorted_stream = heapq.merge(*(_decorate_source(s) for s in sources))
for _, message in sorted_stream:
yield message |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:execution_order; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:refcounts; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:iter; 10, argument_list; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:nx; 14, identifier:topological_sort; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:graph; 21, identifier:subgraph; 22, argument_list; 22, 23; 23, set_comprehension; 23, 24; 23, 25; 23, 34; 24, identifier:term; 25, for_in_clause; 25, 26; 25, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:term; 28, identifier:refcount; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:refcounts; 32, identifier:items; 33, argument_list; 34, if_clause; 34, 35; 35, comparison_operator:>; 35, 36; 35, 37; 36, identifier:refcount; 37, integer:0 | def execution_order(self, refcounts):
return iter(nx.topological_sort(
self.graph.subgraph(
{term for term, refcount in refcounts.items() if refcount > 0},
),
)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 11; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:headers; 7, type; 7, 8; 8, identifier:str; 9, type; 9, 10; 10, string:"HTTPHeaders"; 11, block; 11, 12; 11, 18; 11, 37; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:h; 15, call; 15, 16; 15, 17; 16, identifier:cls; 17, argument_list; 18, for_statement; 18, 19; 18, 20; 18, 26; 19, identifier:line; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:_CRLF_RE; 23, identifier:split; 24, argument_list; 24, 25; 25, identifier:headers; 26, block; 26, 27; 27, if_statement; 27, 28; 27, 29; 28, identifier:line; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:h; 34, identifier:parse_line; 35, argument_list; 35, 36; 36, identifier:line; 37, return_statement; 37, 38; 38, identifier:h | def parse(cls, headers: str) -> "HTTPHeaders":
h = cls()
for line in _CRLF_RE.split(headers):
if line:
h.parse_line(line)
return h |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:lovasz_grad; 3, parameters; 3, 4; 4, identifier:gt_sorted; 5, block; 5, 6; 5, 13; 5, 21; 5, 36; 5, 54; 5, 62; 5, 89; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:p; 9, call; 9, 10; 9, 11; 10, identifier:len; 11, argument_list; 11, 12; 12, identifier:gt_sorted; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:gts; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:gt_sorted; 19, identifier:sum; 20, argument_list; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:intersection; 24, binary_operator:-; 24, 25; 24, 26; 25, identifier:gts; 26, call; 26, 27; 26, 34; 27, attribute; 27, 28; 27, 33; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:gt_sorted; 31, identifier:float; 32, argument_list; 33, identifier:cumsum; 34, argument_list; 34, 35; 35, integer:0; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:union; 39, binary_operator:+; 39, 40; 39, 41; 40, identifier:gts; 41, call; 41, 42; 41, 52; 42, attribute; 42, 43; 42, 51; 43, call; 43, 44; 43, 50; 44, attribute; 44, 45; 44, 49; 45, parenthesized_expression; 45, 46; 46, binary_operator:-; 46, 47; 46, 48; 47, integer:1; 48, identifier:gt_sorted; 49, identifier:float; 50, argument_list; 51, identifier:cumsum; 52, argument_list; 52, 53; 53, integer:0; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:jaccard; 57, binary_operator:-; 57, 58; 57, 59; 58, float:1.; 59, binary_operator:/; 59, 60; 59, 61; 60, identifier:intersection; 61, identifier:union; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:>; 63, 64; 63, 65; 64, identifier:p; 65, integer:1; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 75; 69, subscript; 69, 70; 69, 71; 70, identifier:jaccard; 71, slice; 71, 72; 71, 73; 71, 74; 72, integer:1; 73, colon; 74, identifier:p; 75, binary_operator:-; 75, 76; 75, 82; 76, subscript; 76, 77; 76, 78; 77, identifier:jaccard; 78, slice; 78, 79; 78, 80; 78, 81; 79, integer:1; 80, colon; 81, identifier:p; 82, subscript; 82, 83; 82, 84; 83, identifier:jaccard; 84, slice; 84, 85; 84, 86; 84, 87; 85, integer:0; 86, colon; 87, unary_operator:-; 87, 88; 88, integer:1; 89, return_statement; 89, 90; 90, identifier:jaccard | def lovasz_grad(gt_sorted):
p = len(gt_sorted)
gts = gt_sorted.sum()
intersection = gts - gt_sorted.float().cumsum(0)
union = gts + (1 - gt_sorted).float().cumsum(0)
jaccard = 1. - intersection / union
if p > 1:
jaccard[1:p] = jaccard[1:p] - jaccard[0:-1]
return jaccard |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 41; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 32; 3, 35; 3, 38; 4, identifier:left; 5, identifier:right; 6, default_parameter; 6, 7; 6, 8; 7, identifier:how; 8, string:"inner"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:on; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:left_on; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:right_on; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:left_index; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:right_index; 23, False; 24, default_parameter; 24, 25; 24, 26; 25, identifier:sort; 26, False; 27, default_parameter; 27, 28; 27, 29; 28, identifier:suffixes; 29, tuple; 29, 30; 29, 31; 30, string:"_x"; 31, string:"_y"; 32, default_parameter; 32, 33; 32, 34; 33, identifier:copy; 34, True; 35, default_parameter; 35, 36; 35, 37; 36, identifier:indicator; 37, False; 38, default_parameter; 38, 39; 38, 40; 39, identifier:validate; 40, None; 41, block; 41, 42; 41, 63; 42, if_statement; 42, 43; 42, 49; 43, not_operator; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:isinstance; 46, argument_list; 46, 47; 46, 48; 47, identifier:left; 48, identifier:DataFrame; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:ValueError; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, string:"can not merge DataFrame with instance of type {}"; 57, identifier:format; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:type; 61, argument_list; 61, 62; 62, identifier:right; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:left; 67, identifier:merge; 68, argument_list; 68, 69; 68, 70; 68, 73; 68, 76; 68, 79; 68, 82; 68, 85; 68, 88; 68, 91; 68, 94; 68, 97; 68, 100; 69, identifier:right; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:how; 72, identifier:how; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:on; 75, identifier:on; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:left_on; 78, identifier:left_on; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:right_on; 81, identifier:right_on; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:left_index; 84, identifier:left_index; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:right_index; 87, identifier:right_index; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:sort; 90, identifier:sort; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:suffixes; 93, identifier:suffixes; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:copy; 96, identifier:copy; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:indicator; 99, identifier:indicator; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:validate; 102, identifier:validate | def merge(
left,
right,
how="inner",
on=None,
left_on=None,
right_on=None,
left_index=False,
right_index=False,
sort=False,
suffixes=("_x", "_y"),
copy=True,
indicator=False,
validate=None,
):
if not isinstance(left, DataFrame):
raise ValueError(
"can not merge DataFrame with instance of type {}".format(type(right))
)
return left.merge(
right,
how=how,
on=on,
left_on=left_on,
right_on=right_on,
left_index=left_index,
right_index=right_index,
sort=sort,
suffixes=suffixes,
copy=copy,
indicator=indicator,
validate=validate,
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:copartition; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:axis; 6, identifier:other; 7, identifier:how_to_join; 8, identifier:sort; 9, default_parameter; 9, 10; 9, 11; 10, identifier:force_repartition; 11, False; 12, block; 12, 13; 12, 28; 12, 50; 12, 66; 12, 79; 12, 83; 12, 89; 12, 93; 12, 180; 12, 284; 13, if_statement; 13, 14; 13, 22; 14, call; 14, 15; 14, 16; 15, identifier:isinstance; 16, argument_list; 16, 17; 16, 18; 17, identifier:other; 18, call; 18, 19; 18, 20; 19, identifier:type; 20, argument_list; 20, 21; 21, identifier:self; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:other; 26, list:[other]; 26, 27; 27, identifier:other; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:index_obj; 31, parenthesized_expression; 31, 32; 32, conditional_expression:if; 32, 33; 32, 40; 32, 43; 33, list_comprehension; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:o; 36, identifier:index; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:o; 39, identifier:other; 40, comparison_operator:==; 40, 41; 40, 42; 41, identifier:axis; 42, integer:0; 43, list_comprehension; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:o; 46, identifier:columns; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:o; 49, identifier:other; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:joined_index; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_join_index_objects; 57, argument_list; 57, 58; 57, 61; 57, 62; 57, 63; 58, binary_operator:^; 58, 59; 58, 60; 59, identifier:axis; 60, integer:1; 61, identifier:index_obj; 62, identifier:how_to_join; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:sort; 65, identifier:sort; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:left_old_idx; 69, conditional_expression:if; 69, 70; 69, 73; 69, 76; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:index; 73, comparison_operator:==; 73, 74; 73, 75; 74, identifier:axis; 75, integer:0; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:columns; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:right_old_idxes; 82, identifier:index_obj; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:reindexed_self; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:data; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:reindexed_other_list; 92, list:[]; 93, function_definition; 93, 94; 93, 95; 93, 97; 94, function_name:compute_reindex; 95, parameters; 95, 96; 96, identifier:old_idx; 97, block; 97, 98; 97, 178; 98, function_definition; 98, 99; 98, 100; 98, 102; 99, function_name:reindex_partition; 100, parameters; 100, 101; 101, identifier:df; 102, block; 102, 103; 102, 176; 103, if_statement; 103, 104; 103, 107; 103, 141; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:axis; 106, integer:0; 107, block; 107, 108; 107, 114; 107, 125; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:df; 112, identifier:index; 113, identifier:old_idx; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:new_df; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:df; 120, identifier:reindex; 121, argument_list; 121, 122; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:index; 124, identifier:joined_index; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:new_df; 129, identifier:index; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:pandas; 133, identifier:RangeIndex; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:len; 137, argument_list; 137, 138; 138, attribute; 138, 139; 138, 140; 139, identifier:new_df; 140, identifier:index; 141, else_clause; 141, 142; 142, block; 142, 143; 142, 149; 142, 160; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:df; 147, identifier:columns; 148, identifier:old_idx; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:new_df; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:df; 155, identifier:reindex; 156, argument_list; 156, 157; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:columns; 159, identifier:joined_index; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:new_df; 164, identifier:columns; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:pandas; 168, identifier:RangeIndex; 169, argument_list; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:len; 172, argument_list; 172, 173; 173, attribute; 173, 174; 173, 175; 174, identifier:new_df; 175, identifier:columns; 176, return_statement; 176, 177; 177, identifier:new_df; 178, return_statement; 178, 179; 179, identifier:reindex_partition; 180, for_statement; 180, 181; 180, 182; 180, 189; 181, identifier:i; 182, call; 182, 183; 182, 184; 183, identifier:range; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:len; 187, argument_list; 187, 188; 188, identifier:other; 189, block; 189, 190; 189, 224; 189, 259; 189, 277; 190, if_statement; 190, 191; 190, 205; 190, 210; 191, boolean_operator:or; 191, 192; 191, 195; 192, comparison_operator:!=; 192, 193; 192, 194; 193, identifier:i; 194, integer:0; 195, parenthesized_expression; 195, 196; 196, boolean_operator:and; 196, 197; 196, 203; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:left_old_idx; 200, identifier:equals; 201, argument_list; 201, 202; 202, identifier:joined_index; 203, not_operator; 203, 204; 204, identifier:force_repartition; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:reindex_left; 209, None; 210, else_clause; 210, 211; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:reindex_left; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:_prepare_method; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:compute_reindex; 222, argument_list; 222, 223; 223, identifier:left_old_idx; 224, if_statement; 224, 225; 224, 236; 224, 241; 225, boolean_operator:and; 225, 226; 225, 234; 226, call; 226, 227; 226, 232; 227, attribute; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:right_old_idxes; 230, identifier:i; 231, identifier:equals; 232, argument_list; 232, 233; 233, identifier:joined_index; 234, not_operator; 234, 235; 235, identifier:force_repartition; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:reindex_right; 240, None; 241, else_clause; 241, 242; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:reindex_right; 246, call; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, subscript; 248, 249; 248, 250; 249, identifier:other; 250, identifier:i; 251, identifier:_prepare_method; 252, argument_list; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:compute_reindex; 255, argument_list; 255, 256; 256, subscript; 256, 257; 256, 258; 257, identifier:right_old_idxes; 258, identifier:i; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 264; 261, pattern_list; 261, 262; 261, 263; 262, identifier:reindexed_self; 263, identifier:reindexed_other; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:reindexed_self; 267, identifier:copartition_datasets; 268, argument_list; 268, 269; 268, 270; 268, 275; 268, 276; 269, identifier:axis; 270, attribute; 270, 271; 270, 274; 271, subscript; 271, 272; 271, 273; 272, identifier:other; 273, identifier:i; 274, identifier:data; 275, identifier:reindex_left; 276, identifier:reindex_right; 277, expression_statement; 277, 278; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:reindexed_other_list; 281, identifier:append; 282, argument_list; 282, 283; 283, identifier:reindexed_other; 284, return_statement; 284, 285; 285, expression_list; 285, 286; 285, 287; 285, 288; 286, identifier:reindexed_self; 287, identifier:reindexed_other_list; 288, identifier:joined_index | def copartition(self, axis, other, how_to_join, sort, force_repartition=False):
if isinstance(other, type(self)):
other = [other]
index_obj = (
[o.index for o in other] if axis == 0 else [o.columns for o in other]
)
joined_index = self._join_index_objects(
axis ^ 1, index_obj, how_to_join, sort=sort
)
left_old_idx = self.index if axis == 0 else self.columns
right_old_idxes = index_obj
reindexed_self = self.data
reindexed_other_list = []
def compute_reindex(old_idx):
def reindex_partition(df):
if axis == 0:
df.index = old_idx
new_df = df.reindex(index=joined_index)
new_df.index = pandas.RangeIndex(len(new_df.index))
else:
df.columns = old_idx
new_df = df.reindex(columns=joined_index)
new_df.columns = pandas.RangeIndex(len(new_df.columns))
return new_df
return reindex_partition
for i in range(len(other)):
if i != 0 or (left_old_idx.equals(joined_index) and not force_repartition):
reindex_left = None
else:
reindex_left = self._prepare_method(compute_reindex(left_old_idx))
if right_old_idxes[i].equals(joined_index) and not force_repartition:
reindex_right = None
else:
reindex_right = other[i]._prepare_method(
compute_reindex(right_old_idxes[i])
)
reindexed_self, reindexed_other = reindexed_self.copartition_datasets(
axis, other[i].data, reindex_left, reindex_right
)
reindexed_other_list.append(reindexed_other)
return reindexed_self, reindexed_other_list, joined_index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_index; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 18; 7, 29; 7, 39; 7, 48; 7, 54; 7, 89; 7, 100; 7, 110; 7, 161; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:axis; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:kwargs; 14, identifier:pop; 15, argument_list; 15, 16; 15, 17; 16, string:"axis"; 17, integer:0; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:index; 21, conditional_expression:if; 21, 22; 21, 25; 21, 26; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:columns; 25, identifier:axis; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:index; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:ascending; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:kwargs; 35, identifier:pop; 36, argument_list; 36, 37; 36, 38; 37, string:"ascending"; 38, True; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:ascending; 42, None; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ascending; 47, False; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, subscript; 50, 51; 50, 52; 51, identifier:kwargs; 52, string:"ascending"; 53, identifier:ascending; 54, function_definition; 54, 55; 54, 56; 54, 60; 55, function_name:sort_index_builder; 56, parameters; 56, 57; 56, 58; 57, identifier:df; 58, dictionary_splat_pattern; 58, 59; 59, identifier:kwargs; 60, block; 60, 61; 60, 78; 61, if_statement; 61, 62; 61, 63; 61, 70; 62, identifier:axis; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:df; 68, identifier:columns; 69, identifier:index; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:df; 76, identifier:index; 77, identifier:index; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:df; 82, identifier:sort_index; 83, argument_list; 83, 84; 83, 87; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:axis; 86, identifier:axis; 87, dictionary_splat; 87, 88; 88, identifier:kwargs; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:func; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_prepare_method; 96, argument_list; 96, 97; 96, 98; 97, identifier:sort_index_builder; 98, dictionary_splat; 98, 99; 99, identifier:kwargs; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:new_data; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:_map_across_full_axis; 107, argument_list; 107, 108; 107, 109; 108, identifier:axis; 109, identifier:func; 110, if_statement; 110, 111; 110, 112; 110, 136; 111, identifier:axis; 112, block; 112, 113; 112, 130; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:new_columns; 116, call; 116, 117; 116, 127; 117, attribute; 117, 118; 117, 126; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:pandas; 121, identifier:Series; 122, argument_list; 122, 123; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:columns; 126, identifier:sort_values; 127, argument_list; 127, 128; 128, dictionary_splat; 128, 129; 129, identifier:kwargs; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:new_index; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:index; 136, else_clause; 136, 137; 137, block; 137, 138; 137, 155; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:new_index; 141, call; 141, 142; 141, 152; 142, attribute; 142, 143; 142, 151; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:pandas; 146, identifier:Series; 147, argument_list; 147, 148; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:index; 151, identifier:sort_values; 152, argument_list; 152, 153; 153, dictionary_splat; 153, 154; 154, identifier:kwargs; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:new_columns; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:columns; 161, return_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:__constructor__; 166, argument_list; 166, 167; 166, 168; 166, 169; 166, 170; 167, identifier:new_data; 168, identifier:new_index; 169, identifier:new_columns; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:dtypes; 175, identifier:copy; 176, argument_list | def sort_index(self, **kwargs):
axis = kwargs.pop("axis", 0)
index = self.columns if axis else self.index
ascending = kwargs.pop("ascending", True)
if ascending is None:
ascending = False
kwargs["ascending"] = ascending
def sort_index_builder(df, **kwargs):
if axis:
df.columns = index
else:
df.index = index
return df.sort_index(axis=axis, **kwargs)
func = self._prepare_method(sort_index_builder, **kwargs)
new_data = self._map_across_full_axis(axis, func)
if axis:
new_columns = pandas.Series(self.columns).sort_values(**kwargs)
new_index = self.index
else:
new_index = pandas.Series(self.index).sort_values(**kwargs)
new_columns = self.columns
return self.__constructor__(
new_data, new_index, new_columns, self.dtypes.copy()
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sample_row_keys; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 32; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:data_client; 9, attribute; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_instance; 14, identifier:_client; 15, identifier:table_data_client; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:response_iterator; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:data_client; 22, identifier:sample_row_keys; 23, argument_list; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:name; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:app_profile_id; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_app_profile_id; 32, return_statement; 32, 33; 33, identifier:response_iterator | def sample_row_keys(self):
data_client = self._instance._client.table_data_client
response_iterator = data_client.sample_row_keys(
self.name, app_profile_id=self._app_profile_id
)
return response_iterator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 53; 2, function_name:search_profiles; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 39; 3, 50; 4, identifier:self; 5, identifier:parent; 6, identifier:request_metadata; 7, default_parameter; 7, 8; 7, 9; 8, identifier:profile_query; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:page_size; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:offset; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:disable_spell_check; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:order_by; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:case_sensitive_sort; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:histogram_queries; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:retry; 30, attribute; 30, 31; 30, 38; 31, attribute; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:google; 35, identifier:api_core; 36, identifier:gapic_v1; 37, identifier:method; 38, identifier:DEFAULT; 39, default_parameter; 39, 40; 39, 41; 40, identifier:timeout; 41, attribute; 41, 42; 41, 49; 42, attribute; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:google; 46, identifier:api_core; 47, identifier:gapic_v1; 48, identifier:method; 49, identifier:DEFAULT; 50, default_parameter; 50, 51; 50, 52; 51, identifier:metadata; 52, None; 53, block; 53, 54; 53, 107; 53, 142; 53, 190; 54, if_statement; 54, 55; 54, 60; 55, comparison_operator:not; 55, 56; 55, 57; 56, string:"search_profiles"; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_inner_api_calls; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_inner_api_calls; 67, string:"search_profiles"; 68, call; 68, 69; 68, 78; 69, attribute; 69, 70; 69, 77; 70, attribute; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:google; 74, identifier:api_core; 75, identifier:gapic_v1; 76, identifier:method; 77, identifier:wrap_method; 78, argument_list; 78, 79; 78, 84; 78, 93; 78, 102; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:transport; 83, identifier:search_profiles; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:default_retry; 86, attribute; 86, 87; 86, 92; 87, subscript; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_method_configs; 91, string:"SearchProfiles"; 92, identifier:retry; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:default_timeout; 95, attribute; 95, 96; 95, 101; 96, subscript; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_method_configs; 100, string:"SearchProfiles"; 101, identifier:timeout; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:client_info; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:_client_info; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:request; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:profile_service_pb2; 113, identifier:SearchProfilesRequest; 114, argument_list; 114, 115; 114, 118; 114, 121; 114, 124; 114, 127; 114, 130; 114, 133; 114, 136; 114, 139; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:parent; 117, identifier:parent; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:request_metadata; 120, identifier:request_metadata; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:profile_query; 123, identifier:profile_query; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:page_size; 126, identifier:page_size; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:offset; 129, identifier:offset; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:disable_spell_check; 132, identifier:disable_spell_check; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:order_by; 135, identifier:order_by; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:case_sensitive_sort; 138, identifier:case_sensitive_sort; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:histogram_queries; 141, identifier:histogram_queries; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:iterator; 145, call; 145, 146; 145, 153; 146, attribute; 146, 147; 146, 152; 147, attribute; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:google; 150, identifier:api_core; 151, identifier:page_iterator; 152, identifier:GRPCIterator; 153, argument_list; 153, 154; 153, 157; 153, 178; 153, 181; 153, 184; 153, 187; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:client; 156, None; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:method; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:functools; 162, identifier:partial; 163, argument_list; 163, 164; 163, 169; 163, 172; 163, 175; 164, subscript; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:_inner_api_calls; 168, string:"search_profiles"; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:retry; 171, identifier:retry; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:timeout; 174, identifier:timeout; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:metadata; 177, identifier:metadata; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:request; 180, identifier:request; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:items_field; 183, string:"histogram_query_results"; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:request_token_field; 186, string:"page_token"; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:response_token_field; 189, string:"next_page_token"; 190, return_statement; 190, 191; 191, identifier:iterator | def search_profiles(
self,
parent,
request_metadata,
profile_query=None,
page_size=None,
offset=None,
disable_spell_check=None,
order_by=None,
case_sensitive_sort=None,
histogram_queries=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
if "search_profiles" not in self._inner_api_calls:
self._inner_api_calls[
"search_profiles"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.search_profiles,
default_retry=self._method_configs["SearchProfiles"].retry,
default_timeout=self._method_configs["SearchProfiles"].timeout,
client_info=self._client_info,
)
request = profile_service_pb2.SearchProfilesRequest(
parent=parent,
request_metadata=request_metadata,
profile_query=profile_query,
page_size=page_size,
offset=offset,
disable_spell_check=disable_spell_check,
order_by=order_by,
case_sensitive_sort=case_sensitive_sort,
histogram_queries=histogram_queries,
)
iterator = google.api_core.page_iterator.GRPCIterator(
client=None,
method=functools.partial(
self._inner_api_calls["search_profiles"],
retry=retry,
timeout=timeout,
metadata=metadata,
),
request=request,
items_field="histogram_query_results",
request_token_field="page_token",
response_token_field="next_page_token",
)
return iterator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 68; 2, function_name:search_jobs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 3, 34; 3, 37; 3, 40; 3, 43; 3, 54; 3, 65; 4, identifier:self; 5, identifier:parent; 6, identifier:request_metadata; 7, default_parameter; 7, 8; 7, 9; 8, identifier:search_mode; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:job_query; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:enable_broadening; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:require_precise_result_size; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:histogram_queries; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:job_view; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:offset; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:page_size; 30, None; 31, default_parameter; 31, 32; 31, 33; 32, identifier:order_by; 33, None; 34, default_parameter; 34, 35; 34, 36; 35, identifier:diversification_level; 36, None; 37, default_parameter; 37, 38; 37, 39; 38, identifier:custom_ranking_info; 39, None; 40, default_parameter; 40, 41; 40, 42; 41, identifier:disable_keyword_match; 42, None; 43, default_parameter; 43, 44; 43, 45; 44, identifier:retry; 45, attribute; 45, 46; 45, 53; 46, attribute; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:google; 50, identifier:api_core; 51, identifier:gapic_v1; 52, identifier:method; 53, identifier:DEFAULT; 54, default_parameter; 54, 55; 54, 56; 55, identifier:timeout; 56, attribute; 56, 57; 56, 64; 57, attribute; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:google; 61, identifier:api_core; 62, identifier:gapic_v1; 63, identifier:method; 64, identifier:DEFAULT; 65, default_parameter; 65, 66; 65, 67; 66, identifier:metadata; 67, None; 68, block; 68, 69; 68, 122; 68, 172; 68, 220; 69, if_statement; 69, 70; 69, 75; 70, comparison_operator:not; 70, 71; 70, 72; 71, string:"search_jobs"; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_inner_api_calls; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 83; 78, subscript; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_inner_api_calls; 82, string:"search_jobs"; 83, call; 83, 84; 83, 93; 84, attribute; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:google; 89, identifier:api_core; 90, identifier:gapic_v1; 91, identifier:method; 92, identifier:wrap_method; 93, argument_list; 93, 94; 93, 99; 93, 108; 93, 117; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:transport; 98, identifier:search_jobs; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:default_retry; 101, attribute; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:_method_configs; 106, string:"SearchJobs"; 107, identifier:retry; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:default_timeout; 110, attribute; 110, 111; 110, 116; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_method_configs; 115, string:"SearchJobs"; 116, identifier:timeout; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:client_info; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:_client_info; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:request; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:job_service_pb2; 128, identifier:SearchJobsRequest; 129, argument_list; 129, 130; 129, 133; 129, 136; 129, 139; 129, 142; 129, 145; 129, 148; 129, 151; 129, 154; 129, 157; 129, 160; 129, 163; 129, 166; 129, 169; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:parent; 132, identifier:parent; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:request_metadata; 135, identifier:request_metadata; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:search_mode; 138, identifier:search_mode; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:job_query; 141, identifier:job_query; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:enable_broadening; 144, identifier:enable_broadening; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:require_precise_result_size; 147, identifier:require_precise_result_size; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:histogram_queries; 150, identifier:histogram_queries; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:job_view; 153, identifier:job_view; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:offset; 156, identifier:offset; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:page_size; 159, identifier:page_size; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:order_by; 162, identifier:order_by; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:diversification_level; 165, identifier:diversification_level; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:custom_ranking_info; 168, identifier:custom_ranking_info; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:disable_keyword_match; 171, identifier:disable_keyword_match; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:iterator; 175, call; 175, 176; 175, 183; 176, attribute; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:google; 180, identifier:api_core; 181, identifier:page_iterator; 182, identifier:GRPCIterator; 183, argument_list; 183, 184; 183, 187; 183, 208; 183, 211; 183, 214; 183, 217; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:client; 186, None; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:method; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:functools; 192, identifier:partial; 193, argument_list; 193, 194; 193, 199; 193, 202; 193, 205; 194, subscript; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:_inner_api_calls; 198, string:"search_jobs"; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:retry; 201, identifier:retry; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:timeout; 204, identifier:timeout; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:metadata; 207, identifier:metadata; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:request; 210, identifier:request; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:items_field; 213, string:"matching_jobs"; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:request_token_field; 216, string:"page_token"; 217, keyword_argument; 217, 218; 217, 219; 218, identifier:response_token_field; 219, string:"next_page_token"; 220, return_statement; 220, 221; 221, identifier:iterator | def search_jobs(
self,
parent,
request_metadata,
search_mode=None,
job_query=None,
enable_broadening=None,
require_precise_result_size=None,
histogram_queries=None,
job_view=None,
offset=None,
page_size=None,
order_by=None,
diversification_level=None,
custom_ranking_info=None,
disable_keyword_match=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
if "search_jobs" not in self._inner_api_calls:
self._inner_api_calls[
"search_jobs"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.search_jobs,
default_retry=self._method_configs["SearchJobs"].retry,
default_timeout=self._method_configs["SearchJobs"].timeout,
client_info=self._client_info,
)
request = job_service_pb2.SearchJobsRequest(
parent=parent,
request_metadata=request_metadata,
search_mode=search_mode,
job_query=job_query,
enable_broadening=enable_broadening,
require_precise_result_size=require_precise_result_size,
histogram_queries=histogram_queries,
job_view=job_view,
offset=offset,
page_size=page_size,
order_by=order_by,
diversification_level=diversification_level,
custom_ranking_info=custom_ranking_info,
disable_keyword_match=disable_keyword_match,
)
iterator = google.api_core.page_iterator.GRPCIterator(
client=None,
method=functools.partial(
self._inner_api_calls["search_jobs"],
retry=retry,
timeout=timeout,
metadata=metadata,
),
request=request,
items_field="matching_jobs",
request_token_field="page_token",
response_token_field="next_page_token",
)
return iterator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 46; 2, function_name:list_findings; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 32; 3, 43; 4, identifier:self; 5, identifier:parent; 6, default_parameter; 6, 7; 6, 8; 7, identifier:filter_; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:order_by; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:read_time; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:field_mask; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:page_size; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:retry; 23, attribute; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:google; 28, identifier:api_core; 29, identifier:gapic_v1; 30, identifier:method; 31, identifier:DEFAULT; 32, default_parameter; 32, 33; 32, 34; 33, identifier:timeout; 34, attribute; 34, 35; 34, 42; 35, attribute; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:google; 39, identifier:api_core; 40, identifier:gapic_v1; 41, identifier:method; 42, identifier:DEFAULT; 43, default_parameter; 43, 44; 43, 45; 44, identifier:metadata; 45, None; 46, block; 46, 47; 46, 100; 46, 126; 46, 135; 46, 142; 46, 179; 46, 227; 47, if_statement; 47, 48; 47, 53; 48, comparison_operator:not; 48, 49; 48, 50; 49, string:"list_findings"; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_inner_api_calls; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_inner_api_calls; 60, string:"list_findings"; 61, call; 61, 62; 61, 71; 62, attribute; 62, 63; 62, 70; 63, attribute; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:google; 67, identifier:api_core; 68, identifier:gapic_v1; 69, identifier:method; 70, identifier:wrap_method; 71, argument_list; 71, 72; 71, 77; 71, 86; 71, 95; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:transport; 76, identifier:list_findings; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:default_retry; 79, attribute; 79, 80; 79, 85; 80, subscript; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_method_configs; 84, string:"ListFindings"; 85, identifier:retry; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:default_timeout; 88, attribute; 88, 89; 88, 94; 89, subscript; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_method_configs; 93, string:"ListFindings"; 94, identifier:timeout; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:client_info; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_client_info; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:request; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:securitycenter_service_pb2; 106, identifier:ListFindingsRequest; 107, argument_list; 107, 108; 107, 111; 107, 114; 107, 117; 107, 120; 107, 123; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:parent; 110, identifier:parent; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:filter; 113, identifier:filter_; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:order_by; 116, identifier:order_by; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:read_time; 119, identifier:read_time; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:field_mask; 122, identifier:field_mask; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:page_size; 125, identifier:page_size; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:metadata; 129, None; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:metadata; 134, list:[]; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:metadata; 138, call; 138, 139; 138, 140; 139, identifier:list; 140, argument_list; 140, 141; 141, identifier:metadata; 142, try_statement; 142, 143; 142, 151; 142, 155; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:routing_header; 147, list:[("parent", parent)]; 147, 148; 148, tuple; 148, 149; 148, 150; 149, string:"parent"; 150, identifier:parent; 151, except_clause; 151, 152; 151, 153; 152, identifier:AttributeError; 153, block; 153, 154; 154, pass_statement; 155, else_clause; 155, 156; 156, block; 156, 157; 156, 172; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:routing_metadata; 160, call; 160, 161; 160, 170; 161, attribute; 161, 162; 161, 169; 162, attribute; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:google; 166, identifier:api_core; 167, identifier:gapic_v1; 168, identifier:routing_header; 169, identifier:to_grpc_metadata; 170, argument_list; 170, 171; 171, identifier:routing_header; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:metadata; 176, identifier:append; 177, argument_list; 177, 178; 178, identifier:routing_metadata; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:iterator; 182, call; 182, 183; 182, 190; 183, attribute; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:google; 187, identifier:api_core; 188, identifier:page_iterator; 189, identifier:GRPCIterator; 190, argument_list; 190, 191; 190, 194; 190, 215; 190, 218; 190, 221; 190, 224; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:client; 193, None; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:method; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:functools; 199, identifier:partial; 200, argument_list; 200, 201; 200, 206; 200, 209; 200, 212; 201, subscript; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:self; 204, identifier:_inner_api_calls; 205, string:"list_findings"; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:retry; 208, identifier:retry; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:timeout; 211, identifier:timeout; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:metadata; 214, identifier:metadata; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:request; 217, identifier:request; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:items_field; 220, string:"findings"; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:request_token_field; 223, string:"page_token"; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:response_token_field; 226, string:"next_page_token"; 227, return_statement; 227, 228; 228, identifier:iterator | def list_findings(
self,
parent,
filter_=None,
order_by=None,
read_time=None,
field_mask=None,
page_size=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
if "list_findings" not in self._inner_api_calls:
self._inner_api_calls[
"list_findings"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.list_findings,
default_retry=self._method_configs["ListFindings"].retry,
default_timeout=self._method_configs["ListFindings"].timeout,
client_info=self._client_info,
)
request = securitycenter_service_pb2.ListFindingsRequest(
parent=parent,
filter=filter_,
order_by=order_by,
read_time=read_time,
field_mask=field_mask,
page_size=page_size,
)
if metadata is None:
metadata = []
metadata = list(metadata)
try:
routing_header = [("parent", parent)]
except AttributeError:
pass
else:
routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata(
routing_header
)
metadata.append(routing_metadata)
iterator = google.api_core.page_iterator.GRPCIterator(
client=None,
method=functools.partial(
self._inner_api_calls["list_findings"],
retry=retry,
timeout=timeout,
metadata=metadata,
),
request=request,
items_field="findings",
request_token_field="page_token",
response_token_field="next_page_token",
)
return iterator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 49; 2, function_name:list_traces; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 35; 3, 46; 4, identifier:self; 5, identifier:project_id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:view; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:page_size; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:start_time; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:end_time; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:filter_; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:order_by; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:retry; 26, attribute; 26, 27; 26, 34; 27, attribute; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:google; 31, identifier:api_core; 32, identifier:gapic_v1; 33, identifier:method; 34, identifier:DEFAULT; 35, default_parameter; 35, 36; 35, 37; 36, identifier:timeout; 37, attribute; 37, 38; 37, 45; 38, attribute; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:google; 42, identifier:api_core; 43, identifier:gapic_v1; 44, identifier:method; 45, identifier:DEFAULT; 46, default_parameter; 46, 47; 46, 48; 47, identifier:metadata; 48, None; 49, block; 49, 50; 49, 103; 49, 132; 49, 141; 49, 148; 49, 185; 49, 233; 50, if_statement; 50, 51; 50, 56; 51, comparison_operator:not; 51, 52; 51, 53; 52, string:"list_traces"; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_inner_api_calls; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 64; 59, subscript; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_inner_api_calls; 63, string:"list_traces"; 64, call; 64, 65; 64, 74; 65, attribute; 65, 66; 65, 73; 66, attribute; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:google; 70, identifier:api_core; 71, identifier:gapic_v1; 72, identifier:method; 73, identifier:wrap_method; 74, argument_list; 74, 75; 74, 80; 74, 89; 74, 98; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:transport; 79, identifier:list_traces; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:default_retry; 82, attribute; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:_method_configs; 87, string:"ListTraces"; 88, identifier:retry; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:default_timeout; 91, attribute; 91, 92; 91, 97; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_method_configs; 96, string:"ListTraces"; 97, identifier:timeout; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:client_info; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:_client_info; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:request; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:trace_pb2; 109, identifier:ListTracesRequest; 110, argument_list; 110, 111; 110, 114; 110, 117; 110, 120; 110, 123; 110, 126; 110, 129; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:project_id; 113, identifier:project_id; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:view; 116, identifier:view; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:page_size; 119, identifier:page_size; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:start_time; 122, identifier:start_time; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:end_time; 125, identifier:end_time; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:filter; 128, identifier:filter_; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:order_by; 131, identifier:order_by; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:is; 133, 134; 133, 135; 134, identifier:metadata; 135, None; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:metadata; 140, list:[]; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:metadata; 144, call; 144, 145; 144, 146; 145, identifier:list; 146, argument_list; 146, 147; 147, identifier:metadata; 148, try_statement; 148, 149; 148, 157; 148, 161; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:routing_header; 153, list:[("project_id", project_id)]; 153, 154; 154, tuple; 154, 155; 154, 156; 155, string:"project_id"; 156, identifier:project_id; 157, except_clause; 157, 158; 157, 159; 158, identifier:AttributeError; 159, block; 159, 160; 160, pass_statement; 161, else_clause; 161, 162; 162, block; 162, 163; 162, 178; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:routing_metadata; 166, call; 166, 167; 166, 176; 167, attribute; 167, 168; 167, 175; 168, attribute; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:google; 172, identifier:api_core; 173, identifier:gapic_v1; 174, identifier:routing_header; 175, identifier:to_grpc_metadata; 176, argument_list; 176, 177; 177, identifier:routing_header; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:metadata; 182, identifier:append; 183, argument_list; 183, 184; 184, identifier:routing_metadata; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:iterator; 188, call; 188, 189; 188, 196; 189, attribute; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:google; 193, identifier:api_core; 194, identifier:page_iterator; 195, identifier:GRPCIterator; 196, argument_list; 196, 197; 196, 200; 196, 221; 196, 224; 196, 227; 196, 230; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:client; 199, None; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:method; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:functools; 205, identifier:partial; 206, argument_list; 206, 207; 206, 212; 206, 215; 206, 218; 207, subscript; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:_inner_api_calls; 211, string:"list_traces"; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:retry; 214, identifier:retry; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:timeout; 217, identifier:timeout; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:metadata; 220, identifier:metadata; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:request; 223, identifier:request; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:items_field; 226, string:"traces"; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:request_token_field; 229, string:"page_token"; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:response_token_field; 232, string:"next_page_token"; 233, return_statement; 233, 234; 234, identifier:iterator | def list_traces(
self,
project_id,
view=None,
page_size=None,
start_time=None,
end_time=None,
filter_=None,
order_by=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
if "list_traces" not in self._inner_api_calls:
self._inner_api_calls[
"list_traces"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.list_traces,
default_retry=self._method_configs["ListTraces"].retry,
default_timeout=self._method_configs["ListTraces"].timeout,
client_info=self._client_info,
)
request = trace_pb2.ListTracesRequest(
project_id=project_id,
view=view,
page_size=page_size,
start_time=start_time,
end_time=end_time,
filter=filter_,
order_by=order_by,
)
if metadata is None:
metadata = []
metadata = list(metadata)
try:
routing_header = [("project_id", project_id)]
except AttributeError:
pass
else:
routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata(
routing_header
)
metadata.append(routing_metadata)
iterator = google.api_core.page_iterator.GRPCIterator(
client=None,
method=functools.partial(
self._inner_api_calls["list_traces"],
retry=retry,
timeout=timeout,
metadata=metadata,
),
request=request,
items_field="traces",
request_token_field="page_token",
response_token_field="next_page_token",
)
return iterator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:order; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:value; 6, block; 6, 7; 6, 19; 7, if_statement; 7, 8; 7, 13; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:value; 12, identifier:str; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:value; 17, list:[value]; 17, 18; 18, identifier:value; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 27; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_order; 25, slice; 25, 26; 26, colon; 27, identifier:value | def order(self, value):
if isinstance(value, str):
value = [value]
self._order[:] = value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_canonical_headers; 3, parameters; 3, 4; 4, identifier:headers; 5, block; 5, 6; 5, 33; 5, 41; 5, 50; 5, 91; 5, 114; 5, 128; 6, if_statement; 6, 7; 6, 10; 6, 15; 7, comparison_operator:is; 7, 8; 7, 9; 8, identifier:headers; 9, None; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:headers; 14, list:[]; 15, elif_clause; 15, 16; 15, 21; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:headers; 20, identifier:dict; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:headers; 25, call; 25, 26; 25, 27; 26, identifier:list; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:headers; 31, identifier:items; 32, argument_list; 33, if_statement; 33, 34; 33, 36; 34, not_operator; 34, 35; 35, identifier:headers; 36, block; 36, 37; 37, return_statement; 37, 38; 38, expression_list; 38, 39; 38, 40; 39, list:[]; 40, list:[]; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:normalized; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:collections; 47, identifier:defaultdict; 48, argument_list; 48, 49; 49, identifier:list; 50, for_statement; 50, 51; 50, 54; 50, 55; 51, pattern_list; 51, 52; 51, 53; 52, identifier:key; 53, identifier:val; 54, identifier:headers; 55, block; 55, 56; 55, 68; 55, 82; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:key; 59, call; 59, 60; 59, 67; 60, attribute; 60, 61; 60, 66; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:key; 64, identifier:lower; 65, argument_list; 66, identifier:strip; 67, argument_list; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:val; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:MULTIPLE_SPACES; 74, identifier:sub; 75, argument_list; 75, 76; 75, 77; 76, string:" "; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:val; 80, identifier:strip; 81, argument_list; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:normalized; 87, identifier:key; 88, identifier:append; 89, argument_list; 89, 90; 90, identifier:val; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:ordered_headers; 94, call; 94, 95; 94, 96; 95, identifier:sorted; 96, generator_expression; 96, 97; 96, 105; 97, tuple; 97, 98; 97, 99; 98, identifier:key; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, string:","; 102, identifier:join; 103, argument_list; 103, 104; 104, identifier:val; 105, for_in_clause; 105, 106; 105, 109; 106, pattern_list; 106, 107; 106, 108; 107, identifier:key; 108, identifier:val; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:normalized; 112, identifier:items; 113, argument_list; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:canonical_headers; 117, list_comprehension; 117, 118; 117, 125; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, string:"{}:{}"; 121, identifier:format; 122, argument_list; 122, 123; 123, list_splat; 123, 124; 124, identifier:item; 125, for_in_clause; 125, 126; 125, 127; 126, identifier:item; 127, identifier:ordered_headers; 128, return_statement; 128, 129; 129, expression_list; 129, 130; 129, 131; 130, identifier:canonical_headers; 131, identifier:ordered_headers | def get_canonical_headers(headers):
if headers is None:
headers = []
elif isinstance(headers, dict):
headers = list(headers.items())
if not headers:
return [], []
normalized = collections.defaultdict(list)
for key, val in headers:
key = key.lower().strip()
val = MULTIPLE_SPACES.sub(" ", val.strip())
normalized[key].append(val)
ordered_headers = sorted((key, ",".join(val)) for key, val in normalized.items())
canonical_headers = ["{}:{}".format(*item) for item in ordered_headers]
return canonical_headers, ordered_headers |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sorted_resource_labels; 3, parameters; 3, 4; 4, identifier:labels; 5, block; 5, 6; 5, 18; 5, 32; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:head; 9, list_comprehension; 9, 10; 9, 11; 9, 14; 10, identifier:label; 11, for_in_clause; 11, 12; 11, 13; 12, identifier:label; 13, identifier:TOP_RESOURCE_LABELS; 14, if_clause; 14, 15; 15, comparison_operator:in; 15, 16; 15, 17; 16, identifier:label; 17, identifier:labels; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:tail; 21, call; 21, 22; 21, 23; 22, identifier:sorted; 23, generator_expression; 23, 24; 23, 25; 23, 28; 24, identifier:label; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:label; 27, identifier:labels; 28, if_clause; 28, 29; 29, comparison_operator:not; 29, 30; 29, 31; 30, identifier:label; 31, identifier:TOP_RESOURCE_LABELS; 32, return_statement; 32, 33; 33, binary_operator:+; 33, 34; 33, 35; 34, identifier:head; 35, identifier:tail | def _sorted_resource_labels(labels):
head = [label for label in TOP_RESOURCE_LABELS if label in labels]
tail = sorted(label for label in labels if label not in TOP_RESOURCE_LABELS)
return head + tail |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 45; 2, function_name:partition_read; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 31; 3, 42; 4, identifier:self; 5, identifier:session; 6, identifier:table; 7, identifier:key_set; 8, default_parameter; 8, 9; 8, 10; 9, identifier:transaction; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:index; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:columns; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:partition_options; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:retry; 22, attribute; 22, 23; 22, 30; 23, attribute; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:google; 27, identifier:api_core; 28, identifier:gapic_v1; 29, identifier:method; 30, identifier:DEFAULT; 31, default_parameter; 31, 32; 31, 33; 32, identifier:timeout; 33, attribute; 33, 34; 33, 41; 34, attribute; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:google; 38, identifier:api_core; 39, identifier:gapic_v1; 40, identifier:method; 41, identifier:DEFAULT; 42, default_parameter; 42, 43; 42, 44; 43, identifier:metadata; 44, None; 45, block; 45, 46; 45, 99; 45, 128; 45, 137; 45, 144; 45, 181; 46, if_statement; 46, 47; 46, 52; 47, comparison_operator:not; 47, 48; 47, 49; 48, string:"partition_read"; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:_inner_api_calls; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_inner_api_calls; 59, string:"partition_read"; 60, call; 60, 61; 60, 70; 61, attribute; 61, 62; 61, 69; 62, attribute; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:google; 66, identifier:api_core; 67, identifier:gapic_v1; 68, identifier:method; 69, identifier:wrap_method; 70, argument_list; 70, 71; 70, 76; 70, 85; 70, 94; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:transport; 75, identifier:partition_read; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:default_retry; 78, attribute; 78, 79; 78, 84; 79, subscript; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_method_configs; 83, string:"PartitionRead"; 84, identifier:retry; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:default_timeout; 87, attribute; 87, 88; 87, 93; 88, subscript; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_method_configs; 92, string:"PartitionRead"; 93, identifier:timeout; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:client_info; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_client_info; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:request; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:spanner_pb2; 105, identifier:PartitionReadRequest; 106, argument_list; 106, 107; 106, 110; 106, 113; 106, 116; 106, 119; 106, 122; 106, 125; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:session; 109, identifier:session; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:table; 112, identifier:table; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:key_set; 115, identifier:key_set; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:transaction; 118, identifier:transaction; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:index; 121, identifier:index; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:columns; 124, identifier:columns; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:partition_options; 127, identifier:partition_options; 128, if_statement; 128, 129; 128, 132; 129, comparison_operator:is; 129, 130; 129, 131; 130, identifier:metadata; 131, None; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:metadata; 136, list:[]; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:metadata; 140, call; 140, 141; 140, 142; 141, identifier:list; 142, argument_list; 142, 143; 143, identifier:metadata; 144, try_statement; 144, 145; 144, 153; 144, 157; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:routing_header; 149, list:[("session", session)]; 149, 150; 150, tuple; 150, 151; 150, 152; 151, string:"session"; 152, identifier:session; 153, except_clause; 153, 154; 153, 155; 154, identifier:AttributeError; 155, block; 155, 156; 156, pass_statement; 157, else_clause; 157, 158; 158, block; 158, 159; 158, 174; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:routing_metadata; 162, call; 162, 163; 162, 172; 163, attribute; 163, 164; 163, 171; 164, attribute; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:google; 168, identifier:api_core; 169, identifier:gapic_v1; 170, identifier:routing_header; 171, identifier:to_grpc_metadata; 172, argument_list; 172, 173; 173, identifier:routing_header; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:metadata; 178, identifier:append; 179, argument_list; 179, 180; 180, identifier:routing_metadata; 181, return_statement; 181, 182; 182, call; 182, 183; 182, 188; 183, subscript; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:_inner_api_calls; 187, string:"partition_read"; 188, argument_list; 188, 189; 188, 190; 188, 193; 188, 196; 189, identifier:request; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:retry; 192, identifier:retry; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:timeout; 195, identifier:timeout; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:metadata; 198, identifier:metadata | def partition_read(
self,
session,
table,
key_set,
transaction=None,
index=None,
columns=None,
partition_options=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
if "partition_read" not in self._inner_api_calls:
self._inner_api_calls[
"partition_read"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.partition_read,
default_retry=self._method_configs["PartitionRead"].retry,
default_timeout=self._method_configs["PartitionRead"].timeout,
client_info=self._client_info,
)
request = spanner_pb2.PartitionReadRequest(
session=session,
table=table,
key_set=key_set,
transaction=transaction,
index=index,
columns=columns,
partition_options=partition_options,
)
if metadata is None:
metadata = []
metadata = list(metadata)
try:
routing_header = [("session", session)]
except AttributeError:
pass
else:
routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata(
routing_header
)
metadata.append(routing_metadata)
return self._inner_api_calls["partition_read"](
request, retry=retry, timeout=timeout, metadata=metadata
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 50; 2, function_name:list_documents; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 36; 3, 47; 4, identifier:self; 5, identifier:parent; 6, identifier:collection_id; 7, default_parameter; 7, 8; 7, 9; 8, identifier:page_size; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:order_by; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:mask; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:transaction; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:read_time; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:show_missing; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:retry; 27, attribute; 27, 28; 27, 35; 28, attribute; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:google; 32, identifier:api_core; 33, identifier:gapic_v1; 34, identifier:method; 35, identifier:DEFAULT; 36, default_parameter; 36, 37; 36, 38; 37, identifier:timeout; 38, attribute; 38, 39; 38, 46; 39, attribute; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:google; 43, identifier:api_core; 44, identifier:gapic_v1; 45, identifier:method; 46, identifier:DEFAULT; 47, default_parameter; 47, 48; 47, 49; 48, identifier:metadata; 49, None; 50, block; 50, 51; 50, 104; 50, 120; 50, 152; 50, 200; 51, if_statement; 51, 52; 51, 57; 52, comparison_operator:not; 52, 53; 52, 54; 53, string:"list_documents"; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_inner_api_calls; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 65; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_inner_api_calls; 64, string:"list_documents"; 65, call; 65, 66; 65, 75; 66, attribute; 66, 67; 66, 74; 67, attribute; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:google; 71, identifier:api_core; 72, identifier:gapic_v1; 73, identifier:method; 74, identifier:wrap_method; 75, argument_list; 75, 76; 75, 81; 75, 90; 75, 99; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:transport; 80, identifier:list_documents; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:default_retry; 83, attribute; 83, 84; 83, 89; 84, subscript; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_method_configs; 88, string:"ListDocuments"; 89, identifier:retry; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:default_timeout; 92, attribute; 92, 93; 92, 98; 93, subscript; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_method_configs; 97, string:"ListDocuments"; 98, identifier:timeout; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:client_info; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_client_info; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 113; 106, attribute; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:google; 110, identifier:api_core; 111, identifier:protobuf_helpers; 112, identifier:check_oneof; 113, argument_list; 113, 114; 113, 117; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:transaction; 116, identifier:transaction; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:read_time; 119, identifier:read_time; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:request; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:firestore_pb2; 126, identifier:ListDocumentsRequest; 127, argument_list; 127, 128; 127, 131; 127, 134; 127, 137; 127, 140; 127, 143; 127, 146; 127, 149; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:parent; 130, identifier:parent; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:collection_id; 133, identifier:collection_id; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:page_size; 136, identifier:page_size; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:order_by; 139, identifier:order_by; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:mask; 142, identifier:mask; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:transaction; 145, identifier:transaction; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:read_time; 148, identifier:read_time; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:show_missing; 151, identifier:show_missing; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:iterator; 155, call; 155, 156; 155, 163; 156, attribute; 156, 157; 156, 162; 157, attribute; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:google; 160, identifier:api_core; 161, identifier:page_iterator; 162, identifier:GRPCIterator; 163, argument_list; 163, 164; 163, 167; 163, 188; 163, 191; 163, 194; 163, 197; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:client; 166, None; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:method; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:functools; 172, identifier:partial; 173, argument_list; 173, 174; 173, 179; 173, 182; 173, 185; 174, subscript; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:_inner_api_calls; 178, string:"list_documents"; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:retry; 181, identifier:retry; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:timeout; 184, identifier:timeout; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:metadata; 187, identifier:metadata; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:request; 190, identifier:request; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:items_field; 193, string:"documents"; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:request_token_field; 196, string:"page_token"; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:response_token_field; 199, string:"next_page_token"; 200, return_statement; 200, 201; 201, identifier:iterator | def list_documents(
self,
parent,
collection_id,
page_size=None,
order_by=None,
mask=None,
transaction=None,
read_time=None,
show_missing=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
if "list_documents" not in self._inner_api_calls:
self._inner_api_calls[
"list_documents"
] = google.api_core.gapic_v1.method.wrap_method(
self.transport.list_documents,
default_retry=self._method_configs["ListDocuments"].retry,
default_timeout=self._method_configs["ListDocuments"].timeout,
client_info=self._client_info,
)
google.api_core.protobuf_helpers.check_oneof(
transaction=transaction, read_time=read_time
)
request = firestore_pb2.ListDocumentsRequest(
parent=parent,
collection_id=collection_id,
page_size=page_size,
order_by=order_by,
mask=mask,
transaction=transaction,
read_time=read_time,
show_missing=show_missing,
)
iterator = google.api_core.page_iterator.GRPCIterator(
client=None,
method=functools.partial(
self._inner_api_calls["list_documents"],
retry=retry,
timeout=timeout,
metadata=metadata,
),
request=request,
items_field="documents",
request_token_field="page_token",
response_token_field="next_page_token",
)
return iterator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:predict; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:dataset; 6, default_parameter; 6, 7; 6, 8; 7, identifier:output_type; 8, string:'class'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:missing_value_action; 11, string:'auto'; 12, block; 12, 13; 12, 24; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:_check_categorical_option_type; 16, argument_list; 16, 17; 16, 18; 16, 19; 17, string:'output_type'; 18, identifier:output_type; 19, list:['class', 'margin', 'probability', 'probability_vector']; 19, 20; 19, 21; 19, 22; 19, 23; 20, string:'class'; 21, string:'margin'; 22, string:'probability'; 23, string:'probability_vector'; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 33; 26, attribute; 26, 27; 26, 32; 27, call; 27, 28; 27, 29; 28, identifier:super; 29, argument_list; 29, 30; 29, 31; 30, identifier:_Classifier; 31, identifier:self; 32, identifier:predict; 33, argument_list; 33, 34; 33, 35; 33, 38; 34, identifier:dataset; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:output_type; 37, identifier:output_type; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:missing_value_action; 40, identifier:missing_value_action | def predict(self, dataset, output_type='class', missing_value_action='auto'):
_check_categorical_option_type('output_type', output_type,
['class', 'margin', 'probability', 'probability_vector'])
return super(_Classifier, self).predict(dataset,
output_type=output_type,
missing_value_action=missing_value_action) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sort_topk_votes; 3, parameters; 3, 4; 3, 5; 4, identifier:x; 5, identifier:k; 6, block; 6, 7; 6, 33; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:y; 10, subscript; 10, 11; 10, 30; 11, call; 11, 12; 11, 13; 12, identifier:sorted; 13, argument_list; 13, 14; 13, 19; 13, 27; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:x; 17, identifier:items; 18, argument_list; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:x; 24, subscript; 24, 25; 24, 26; 25, identifier:x; 26, integer:1; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:reverse; 29, True; 30, slice; 30, 31; 30, 32; 31, colon; 32, identifier:k; 33, return_statement; 33, 34; 34, list_comprehension; 34, 35; 34, 46; 35, dictionary; 35, 36; 35, 41; 36, pair; 36, 37; 36, 38; 37, string:'class'; 38, subscript; 38, 39; 38, 40; 39, identifier:i; 40, integer:0; 41, pair; 41, 42; 41, 43; 42, string:'votes'; 43, subscript; 43, 44; 43, 45; 44, identifier:i; 45, integer:1; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:i; 48, identifier:y | def _sort_topk_votes(x, k):
y = sorted(x.items(), key=lambda x: x[1], reverse=True)[:k]
return [{'class': i[0], 'votes': i[1]} for i in y] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key_column_names; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ascending; 8, True; 9, block; 9, 10; 9, 14; 9, 18; 9, 141; 9, 158; 9, 169; 9, 226; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sort_column_names; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:sort_column_orders; 17, list:[]; 18, if_statement; 18, 19; 18, 26; 18, 32; 18, 134; 19, parenthesized_expression; 19, 20; 20, comparison_operator:==; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:type; 23, argument_list; 23, 24; 24, identifier:key_column_names; 25, identifier:str; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:sort_column_names; 30, list:[key_column_names]; 30, 31; 31, identifier:key_column_names; 32, elif_clause; 32, 33; 32, 40; 33, parenthesized_expression; 33, 34; 34, comparison_operator:==; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:type; 37, argument_list; 37, 38; 38, identifier:key_column_names; 39, identifier:list; 40, block; 40, 41; 40, 55; 40, 69; 40, 83; 40, 91; 41, if_statement; 41, 42; 41, 49; 42, parenthesized_expression; 42, 43; 43, comparison_operator:==; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:key_column_names; 48, integer:0; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:ValueError; 53, argument_list; 53, 54; 54, string:"Please provide at least one column to sort"; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:first_param_types; 58, call; 58, 59; 58, 60; 59, identifier:set; 60, argument_list; 60, 61; 61, list_comprehension; 61, 62; 61, 66; 62, call; 62, 63; 62, 64; 63, identifier:type; 64, argument_list; 64, 65; 65, identifier:i; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:i; 68, identifier:key_column_names; 69, if_statement; 69, 70; 69, 77; 70, parenthesized_expression; 70, 71; 71, comparison_operator:!=; 71, 72; 71, 76; 72, call; 72, 73; 72, 74; 73, identifier:len; 74, argument_list; 74, 75; 75, identifier:first_param_types; 76, integer:1; 77, block; 77, 78; 78, raise_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:ValueError; 81, argument_list; 81, 82; 82, string:"key_column_names element are not of the same type"; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:first_param_type; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:first_param_types; 89, identifier:pop; 90, argument_list; 91, if_statement; 91, 92; 91, 96; 91, 117; 91, 127; 92, parenthesized_expression; 92, 93; 93, comparison_operator:==; 93, 94; 93, 95; 94, identifier:first_param_type; 95, identifier:tuple; 96, block; 96, 97; 96, 107; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:sort_column_names; 100, list_comprehension; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:i; 103, integer:0; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:i; 106, identifier:key_column_names; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:sort_column_orders; 110, list_comprehension; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:i; 113, integer:1; 114, for_in_clause; 114, 115; 114, 116; 115, identifier:i; 116, identifier:key_column_names; 117, elif_clause; 117, 118; 117, 122; 118, parenthesized_expression; 118, 119; 119, comparison_operator:==; 119, 120; 119, 121; 120, identifier:first_param_type; 121, identifier:str; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:sort_column_names; 126, identifier:key_column_names; 127, else_clause; 127, 128; 128, block; 128, 129; 129, raise_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:TypeError; 132, argument_list; 132, 133; 133, string:"key_column_names type is not supported"; 134, else_clause; 134, 135; 135, block; 135, 136; 136, raise_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:TypeError; 139, argument_list; 139, 140; 140, string:"key_column_names type is not correct. Supported types are str, list of str or list of (str,bool) pair."; 141, if_statement; 141, 142; 141, 149; 142, parenthesized_expression; 142, 143; 143, comparison_operator:==; 143, 144; 143, 148; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, identifier:sort_column_orders; 148, integer:0; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:sort_column_orders; 153, list_comprehension; 153, 154; 153, 155; 154, identifier:ascending; 155, for_in_clause; 155, 156; 155, 157; 156, identifier:i; 157, identifier:sort_column_names; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:my_column_names; 161, call; 161, 162; 161, 163; 162, identifier:set; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:column_names; 168, argument_list; 169, for_statement; 169, 170; 169, 171; 169, 172; 170, identifier:column; 171, identifier:sort_column_names; 172, block; 172, 173; 172, 187; 172, 205; 173, if_statement; 173, 174; 173, 181; 174, parenthesized_expression; 174, 175; 175, comparison_operator:!=; 175, 176; 175, 180; 176, call; 176, 177; 176, 178; 177, identifier:type; 178, argument_list; 178, 179; 179, identifier:column; 180, identifier:str; 181, block; 181, 182; 182, raise_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:TypeError; 185, argument_list; 185, 186; 186, string:"Only string parameter can be passed in as column names"; 187, if_statement; 187, 188; 187, 192; 188, parenthesized_expression; 188, 189; 189, comparison_operator:not; 189, 190; 189, 191; 190, identifier:column; 191, identifier:my_column_names; 192, block; 192, 193; 193, raise_statement; 193, 194; 194, call; 194, 195; 194, 196; 195, identifier:ValueError; 196, argument_list; 196, 197; 197, binary_operator:+; 197, 198; 197, 204; 198, binary_operator:+; 198, 199; 198, 200; 199, string:"SFrame has no column named: '"; 200, call; 200, 201; 200, 202; 201, identifier:str; 202, argument_list; 202, 203; 203, identifier:column; 204, string:"'"; 205, if_statement; 205, 206; 205, 220; 206, parenthesized_expression; 206, 207; 207, comparison_operator:not; 207, 208; 207, 213; 208, attribute; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:self; 211, identifier:column; 212, identifier:dtype; 213, tuple; 213, 214; 213, 215; 213, 216; 213, 217; 214, identifier:str; 215, identifier:int; 216, identifier:float; 217, attribute; 217, 218; 217, 219; 218, identifier:datetime; 219, identifier:datetime; 220, block; 220, 221; 221, raise_statement; 221, 222; 222, call; 222, 223; 222, 224; 223, identifier:TypeError; 224, argument_list; 224, 225; 225, string:"Only columns of type (str, int, float) can be sorted"; 226, with_statement; 226, 227; 226, 232; 227, with_clause; 227, 228; 228, with_item; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:cython_context; 231, argument_list; 232, block; 232, 233; 233, return_statement; 233, 234; 234, call; 234, 235; 234, 236; 235, identifier:SFrame; 236, argument_list; 236, 237; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:_proxy; 239, call; 239, 240; 239, 245; 240, attribute; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:self; 243, identifier:__proxy__; 244, identifier:sort; 245, argument_list; 245, 246; 245, 247; 246, identifier:sort_column_names; 247, identifier:sort_column_orders | def sort(self, key_column_names, ascending=True):
sort_column_names = []
sort_column_orders = []
if (type(key_column_names) == str):
sort_column_names = [key_column_names]
elif (type(key_column_names) == list):
if (len(key_column_names) == 0):
raise ValueError("Please provide at least one column to sort")
first_param_types = set([type(i) for i in key_column_names])
if (len(first_param_types) != 1):
raise ValueError("key_column_names element are not of the same type")
first_param_type = first_param_types.pop()
if (first_param_type == tuple):
sort_column_names = [i[0] for i in key_column_names]
sort_column_orders = [i[1] for i in key_column_names]
elif(first_param_type == str):
sort_column_names = key_column_names
else:
raise TypeError("key_column_names type is not supported")
else:
raise TypeError("key_column_names type is not correct. Supported types are str, list of str or list of (str,bool) pair.")
if (len(sort_column_orders) == 0):
sort_column_orders = [ascending for i in sort_column_names]
my_column_names = set(self.column_names())
for column in sort_column_names:
if (type(column) != str):
raise TypeError("Only string parameter can be passed in as column names")
if (column not in my_column_names):
raise ValueError("SFrame has no column named: '" + str(column) + "'")
if (self[column].dtype not in (str, int, float,datetime.datetime)):
raise TypeError("Only columns of type (str, int, float) can be sorted")
with cython_context():
return SFrame(_proxy=self.__proxy__.sort(sort_column_names, sort_column_orders)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:MakeSimpleProtoClass; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:fields; 5, default_parameter; 5, 6; 5, 7; 6, identifier:full_name; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:pool; 10, None; 11, block; 11, 12; 11, 23; 11, 44; 11, 52; 11, 67; 11, 75; 11, 108; 11, 118; 11, 150; 11, 164; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:factory; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:message_factory; 18, identifier:MessageFactory; 19, argument_list; 19, 20; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:pool; 22, identifier:pool; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:full_name; 26, None; 27, block; 27, 28; 28, try_statement; 28, 29; 28, 40; 29, block; 29, 30; 29, 38; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:proto_cls; 33, call; 33, 34; 33, 35; 34, identifier:_GetMessageFromFactory; 35, argument_list; 35, 36; 35, 37; 36, identifier:factory; 37, identifier:full_name; 38, return_statement; 38, 39; 39, identifier:proto_cls; 40, except_clause; 40, 41; 40, 42; 41, identifier:KeyError; 42, block; 42, 43; 43, pass_statement; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:field_items; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:fields; 50, identifier:items; 51, argument_list; 52, if_statement; 52, 53; 52, 59; 53, not_operator; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:fields; 58, identifier:OrderedDict; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:field_items; 63, call; 63, 64; 63, 65; 64, identifier:sorted; 65, argument_list; 65, 66; 66, identifier:field_items; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:fields_hash; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:hashlib; 73, identifier:sha1; 74, argument_list; 75, for_statement; 75, 76; 75, 79; 75, 80; 76, pattern_list; 76, 77; 76, 78; 77, identifier:f_name; 78, identifier:f_type; 79, identifier:field_items; 80, block; 80, 81; 80, 93; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:fields_hash; 85, identifier:update; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:f_name; 90, identifier:encode; 91, argument_list; 91, 92; 92, string:'utf-8'; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:fields_hash; 97, identifier:update; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 106; 100, attribute; 100, 101; 100, 105; 101, call; 101, 102; 101, 103; 102, identifier:str; 103, argument_list; 103, 104; 104, identifier:f_type; 105, identifier:encode; 106, argument_list; 106, 107; 107, string:'utf-8'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:proto_file_name; 111, binary_operator:+; 111, 112; 111, 117; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:fields_hash; 115, identifier:hexdigest; 116, argument_list; 117, string:'.proto'; 118, if_statement; 118, 119; 118, 122; 119, comparison_operator:is; 119, 120; 119, 121; 120, identifier:full_name; 121, None; 122, block; 122, 123; 122, 134; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:full_name; 126, parenthesized_expression; 126, 127; 127, binary_operator:+; 127, 128; 127, 129; 128, string:'net.proto2.python.public.proto_builder.AnonymousProto_'; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:fields_hash; 132, identifier:hexdigest; 133, argument_list; 134, try_statement; 134, 135; 134, 146; 135, block; 135, 136; 135, 144; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:proto_cls; 139, call; 139, 140; 139, 141; 140, identifier:_GetMessageFromFactory; 141, argument_list; 141, 142; 141, 143; 142, identifier:factory; 143, identifier:full_name; 144, return_statement; 144, 145; 145, identifier:proto_cls; 146, except_clause; 146, 147; 146, 148; 147, identifier:KeyError; 148, block; 148, 149; 149, pass_statement; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:factory; 155, identifier:pool; 156, identifier:Add; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:_MakeFileDescriptorProto; 160, argument_list; 160, 161; 160, 162; 160, 163; 161, identifier:proto_file_name; 162, identifier:full_name; 163, identifier:field_items; 164, return_statement; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:_GetMessageFromFactory; 167, argument_list; 167, 168; 167, 169; 168, identifier:factory; 169, identifier:full_name | def MakeSimpleProtoClass(fields, full_name=None, pool=None):
factory = message_factory.MessageFactory(pool=pool)
if full_name is not None:
try:
proto_cls = _GetMessageFromFactory(factory, full_name)
return proto_cls
except KeyError:
pass
field_items = fields.items()
if not isinstance(fields, OrderedDict):
field_items = sorted(field_items)
fields_hash = hashlib.sha1()
for f_name, f_type in field_items:
fields_hash.update(f_name.encode('utf-8'))
fields_hash.update(str(f_type).encode('utf-8'))
proto_file_name = fields_hash.hexdigest() + '.proto'
if full_name is None:
full_name = ('net.proto2.python.public.proto_builder.AnonymousProto_' +
fields_hash.hexdigest())
try:
proto_cls = _GetMessageFromFactory(factory, full_name)
return proto_cls
except KeyError:
pass
factory.pool.Add(
_MakeFileDescriptorProto(proto_file_name, full_name, field_items))
return _GetMessageFromFactory(factory, full_name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:value_counts; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 15; 6, import_from_statement; 6, 7; 6, 11; 7, relative_import; 7, 8; 7, 9; 8, import_prefix; 9, dotted_name; 9, 10; 10, identifier:sframe; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:SFrame; 14, identifier:_SFrame; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 37; 17, attribute; 17, 18; 17, 36; 18, call; 18, 19; 18, 28; 19, attribute; 19, 20; 19, 27; 20, call; 20, 21; 20, 22; 21, identifier:_SFrame; 22, argument_list; 22, 23; 23, dictionary; 23, 24; 24, pair; 24, 25; 24, 26; 25, string:'value'; 26, identifier:self; 27, identifier:groupby; 28, argument_list; 28, 29; 28, 30; 29, string:'value'; 30, dictionary; 30, 31; 31, pair; 31, 32; 31, 33; 32, string:'count'; 33, attribute; 33, 34; 33, 35; 34, identifier:_aggregate; 35, identifier:COUNT; 36, identifier:sort; 37, argument_list; 37, 38; 37, 39; 38, string:'count'; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:ascending; 41, False | def value_counts(self):
from .sframe import SFrame as _SFrame
return _SFrame({'value':self}).groupby('value', {'count':_aggregate.COUNT}).sort('count', ascending=False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ascending; 7, True; 8, block; 8, 9; 8, 18; 8, 36; 8, 42; 8, 48; 9, import_from_statement; 9, 10; 9, 14; 10, relative_import; 10, 11; 10, 12; 11, import_prefix; 12, dotted_name; 12, 13; 13, identifier:sframe; 14, aliased_import; 14, 15; 14, 17; 15, dotted_name; 15, 16; 16, identifier:SFrame; 17, identifier:_SFrame; 18, if_statement; 18, 19; 18, 30; 19, comparison_operator:not; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:dtype; 23, tuple; 23, 24; 23, 25; 23, 26; 23, 27; 24, identifier:int; 25, identifier:float; 26, identifier:str; 27, attribute; 27, 28; 27, 29; 28, identifier:datetime; 29, identifier:datetime; 30, block; 30, 31; 31, raise_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:TypeError; 34, argument_list; 34, 35; 35, string:"Only sarray with type (int, float, str, datetime.datetime) can be sorted"; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:sf; 39, call; 39, 40; 39, 41; 40, identifier:_SFrame; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:sf; 46, string:'a'; 47, identifier:self; 48, return_statement; 48, 49; 49, subscript; 49, 50; 49, 57; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:sf; 53, identifier:sort; 54, argument_list; 54, 55; 54, 56; 55, string:'a'; 56, identifier:ascending; 57, string:'a' | def sort(self, ascending=True):
from .sframe import SFrame as _SFrame
if self.dtype not in (int, float, str, datetime.datetime):
raise TypeError("Only sarray with type (int, float, str, datetime.datetime) can be sorted")
sf = _SFrame()
sf['a'] = self
return sf.sort('a', ascending)['a'] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:predict; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:dataset; 6, default_parameter; 6, 7; 6, 8; 7, identifier:output_type; 8, string:'class'; 9, block; 9, 10; 9, 18; 9, 26; 9, 30; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:m; 13, subscript; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:__proxy__; 17, string:'classifier'; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:target; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:__proxy__; 25, string:'target'; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:f; 29, identifier:_BOW_FEATURE_EXTRACTOR; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:m; 34, identifier:predict; 35, argument_list; 35, 36; 35, 41; 36, call; 36, 37; 36, 38; 37, identifier:f; 38, argument_list; 38, 39; 38, 40; 39, identifier:dataset; 40, identifier:target; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:output_type; 43, identifier:output_type | def predict(self, dataset, output_type='class'):
m = self.__proxy__['classifier']
target = self.__proxy__['target']
f = _BOW_FEATURE_EXTRACTOR
return m.predict(f(dataset, target), output_type=output_type) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:format_json; 3, parameters; 3, 4; 3, 5; 4, identifier:event; 5, identifier:colored; 6, block; 6, 7; 6, 48; 7, try_statement; 7, 8; 7, 44; 8, block; 8, 9; 9, if_statement; 9, 10; 9, 18; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:event; 14, identifier:message; 15, identifier:startswith; 16, argument_list; 16, 17; 17, string:"{"; 18, block; 18, 19; 18, 30; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:msg_dict; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:json; 25, identifier:loads; 26, argument_list; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:event; 29, identifier:message; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:event; 34, identifier:message; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:json; 38, identifier:dumps; 39, argument_list; 39, 40; 39, 41; 40, identifier:msg_dict; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:indent; 43, integer:2; 44, except_clause; 44, 45; 44, 46; 45, identifier:Exception; 46, block; 46, 47; 47, pass_statement; 48, return_statement; 48, 49; 49, identifier:event | def format_json(event, colored):
try:
if event.message.startswith("{"):
msg_dict = json.loads(event.message)
event.message = json.dumps(msg_dict, indent=2)
except Exception:
pass
return event |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:explain_instance_with_data; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 13; 4, identifier:self; 5, identifier:neighborhood_data; 6, identifier:neighborhood_labels; 7, identifier:distances; 8, identifier:label; 9, identifier:num_features; 10, default_parameter; 10, 11; 10, 12; 11, identifier:feature_selection; 12, string:'auto'; 13, default_parameter; 13, 14; 13, 15; 14, identifier:model_regressor; 15, None; 16, block; 16, 17; 16, 26; 16, 34; 16, 47; 16, 69; 16, 73; 16, 88; 16, 105; 16, 124; 16, 152; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:weights; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:kernel_fn; 24, argument_list; 24, 25; 25, identifier:distances; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:labels_column; 29, subscript; 29, 30; 29, 31; 29, 33; 30, identifier:neighborhood_labels; 31, slice; 31, 32; 32, colon; 33, identifier:label; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:used_features; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:feature_selection; 41, argument_list; 41, 42; 41, 43; 41, 44; 41, 45; 41, 46; 42, identifier:neighborhood_data; 43, identifier:labels_column; 44, identifier:weights; 45, identifier:num_features; 46, identifier:feature_selection; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:model_regressor; 50, None; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:model_regressor; 55, call; 55, 56; 55, 57; 56, identifier:Ridge; 57, argument_list; 57, 58; 57, 61; 57, 64; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:alpha; 60, integer:1; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:fit_intercept; 63, True; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:random_state; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:random_state; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:easy_model; 72, identifier:model_regressor; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:easy_model; 77, identifier:fit; 78, argument_list; 78, 79; 78, 84; 78, 85; 79, subscript; 79, 80; 79, 81; 79, 83; 80, identifier:neighborhood_data; 81, slice; 81, 82; 82, colon; 83, identifier:used_features; 84, identifier:labels_column; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:sample_weight; 87, identifier:weights; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:prediction_score; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:easy_model; 94, identifier:score; 95, argument_list; 95, 96; 95, 101; 95, 102; 96, subscript; 96, 97; 96, 98; 96, 100; 97, identifier:neighborhood_data; 98, slice; 98, 99; 99, colon; 100, identifier:used_features; 101, identifier:labels_column; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:sample_weight; 104, identifier:weights; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:local_pred; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:easy_model; 111, identifier:predict; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 120; 114, attribute; 114, 115; 114, 119; 115, subscript; 115, 116; 115, 117; 115, 118; 116, identifier:neighborhood_data; 117, integer:0; 118, identifier:used_features; 119, identifier:reshape; 120, argument_list; 120, 121; 120, 122; 121, integer:1; 122, unary_operator:-; 122, 123; 123, integer:1; 124, if_statement; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:verbose; 128, block; 128, 129; 128, 137; 128, 143; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:print; 132, argument_list; 132, 133; 132, 134; 133, string:'Intercept'; 134, attribute; 134, 135; 134, 136; 135, identifier:easy_model; 136, identifier:intercept_; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:print; 140, argument_list; 140, 141; 140, 142; 141, string:'Prediction_local'; 142, identifier:local_pred; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:print; 146, argument_list; 146, 147; 146, 148; 147, string:'Right:'; 148, subscript; 148, 149; 148, 150; 148, 151; 149, identifier:neighborhood_labels; 150, integer:0; 151, identifier:label; 152, return_statement; 152, 153; 153, tuple; 153, 154; 153, 157; 153, 183; 153, 184; 154, attribute; 154, 155; 154, 156; 155, identifier:easy_model; 156, identifier:intercept_; 157, call; 157, 158; 157, 159; 158, identifier:sorted; 159, argument_list; 159, 160; 159, 167; 159, 180; 160, call; 160, 161; 160, 162; 161, identifier:zip; 162, argument_list; 162, 163; 162, 164; 163, identifier:used_features; 164, attribute; 164, 165; 164, 166; 165, identifier:easy_model; 166, identifier:coef_; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:key; 169, lambda; 169, 170; 169, 172; 170, lambda_parameters; 170, 171; 171, identifier:x; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:np; 175, identifier:abs; 176, argument_list; 176, 177; 177, subscript; 177, 178; 177, 179; 178, identifier:x; 179, integer:1; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:reverse; 182, True; 183, identifier:prediction_score; 184, identifier:local_pred | def explain_instance_with_data(self,
neighborhood_data,
neighborhood_labels,
distances,
label,
num_features,
feature_selection='auto',
model_regressor=None):
weights = self.kernel_fn(distances)
labels_column = neighborhood_labels[:, label]
used_features = self.feature_selection(neighborhood_data,
labels_column,
weights,
num_features,
feature_selection)
if model_regressor is None:
model_regressor = Ridge(alpha=1, fit_intercept=True,
random_state=self.random_state)
easy_model = model_regressor
easy_model.fit(neighborhood_data[:, used_features],
labels_column, sample_weight=weights)
prediction_score = easy_model.score(
neighborhood_data[:, used_features],
labels_column, sample_weight=weights)
local_pred = easy_model.predict(neighborhood_data[0, used_features].reshape(1, -1))
if self.verbose:
print('Intercept', easy_model.intercept_)
print('Prediction_local', local_pred,)
print('Right:', neighborhood_labels[0, label])
return (easy_model.intercept_,
sorted(zip(used_features, easy_model.coef_),
key=lambda x: np.abs(x[1]), reverse=True),
prediction_score, local_pred) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:serialize_json; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pretty; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:indent; 10, None; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 13, 16; 13, 35; 13, 49; 13, 66; 13, 77; 14, expression_statement; 14, 15; 15, string:''' Return a serialized JSON representation of objects, suitable to
send to BokehJS.
This function is typically used to serialize single python objects in
the manner expected by BokehJS. In particular, many datetime values are
automatically normalized to an expected format. Some Bokeh objects can
also be passed, but note that Bokeh models are typically properly
serialized in the context of an entire Bokeh document.
The resulting JSON always has sorted keys. By default. the output is
as compact as possible unless pretty output or indentation is requested.
Args:
obj (obj) : the object to serialize to JSON format
pretty (bool, optional) :
Whether to generate prettified output. If ``True``, spaces are
added after added after separators, and indentation and newlines
are applied. (default: False)
Pretty output can also be enabled with the environment variable
``BOKEH_PRETTY``, which overrides this argument, if set.
indent (int or None, optional) :
Amount of indentation to use in generated JSON output. If ``None``
then no indentation is used, unless pretty output is enabled,
in which case two spaces are used. (default: None)
Any additional keyword arguments are passed to ``json.dumps``, except for
some that are computed internally, and cannot be overridden:
* allow_nan
* indent
* separators
* sort_keys
Examples:
.. code-block:: python
>>> data = dict(b=np.datetime64('2017-01-01'), a = np.arange(3))
>>>print(serialize_json(data))
{"a":[0,1,2],"b":1483228800000.0}
>>> print(serialize_json(data, pretty=True))
{
"a": [
0,
1,
2
],
"b": 1483228800000.0
}
'''; 16, for_statement; 16, 17; 16, 18; 16, 22; 17, identifier:name; 18, list:['allow_nan', 'separators', 'sort_keys']; 18, 19; 18, 20; 18, 21; 19, string:'allow_nan'; 20, string:'separators'; 21, string:'sort_keys'; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:in; 24, 25; 24, 26; 25, identifier:name; 26, identifier:kwargs; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:ValueError; 31, argument_list; 31, 32; 32, binary_operator:%; 32, 33; 32, 34; 33, string:"The value of %r is computed internally, overriding is not permissable."; 34, identifier:name; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:pretty; 38, None; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:pretty; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:settings; 46, identifier:pretty; 47, argument_list; 47, 48; 48, False; 49, if_statement; 49, 50; 49, 51; 49, 58; 50, identifier:pretty; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:separators; 55, tuple; 55, 56; 55, 57; 56, string:","; 57, string:": "; 58, else_clause; 58, 59; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:separators; 63, tuple; 63, 64; 63, 65; 64, string:","; 65, string:":"; 66, if_statement; 66, 67; 66, 72; 67, boolean_operator:and; 67, 68; 67, 69; 68, identifier:pretty; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:indent; 71, None; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:indent; 76, integer:2; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:json; 81, identifier:dumps; 82, argument_list; 82, 83; 82, 84; 82, 87; 82, 90; 82, 93; 82, 96; 82, 99; 83, identifier:obj; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:cls; 86, identifier:BokehJSONEncoder; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:allow_nan; 89, False; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:indent; 92, identifier:indent; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:separators; 95, identifier:separators; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:sort_keys; 98, True; 99, dictionary_splat; 99, 100; 100, identifier:kwargs | def serialize_json(obj, pretty=None, indent=None, **kwargs):
''' Return a serialized JSON representation of objects, suitable to
send to BokehJS.
This function is typically used to serialize single python objects in
the manner expected by BokehJS. In particular, many datetime values are
automatically normalized to an expected format. Some Bokeh objects can
also be passed, but note that Bokeh models are typically properly
serialized in the context of an entire Bokeh document.
The resulting JSON always has sorted keys. By default. the output is
as compact as possible unless pretty output or indentation is requested.
Args:
obj (obj) : the object to serialize to JSON format
pretty (bool, optional) :
Whether to generate prettified output. If ``True``, spaces are
added after added after separators, and indentation and newlines
are applied. (default: False)
Pretty output can also be enabled with the environment variable
``BOKEH_PRETTY``, which overrides this argument, if set.
indent (int or None, optional) :
Amount of indentation to use in generated JSON output. If ``None``
then no indentation is used, unless pretty output is enabled,
in which case two spaces are used. (default: None)
Any additional keyword arguments are passed to ``json.dumps``, except for
some that are computed internally, and cannot be overridden:
* allow_nan
* indent
* separators
* sort_keys
Examples:
.. code-block:: python
>>> data = dict(b=np.datetime64('2017-01-01'), a = np.arange(3))
>>>print(serialize_json(data))
{"a":[0,1,2],"b":1483228800000.0}
>>> print(serialize_json(data, pretty=True))
{
"a": [
0,
1,
2
],
"b": 1483228800000.0
}
'''
for name in ['allow_nan', 'separators', 'sort_keys']:
if name in kwargs:
raise ValueError("The value of %r is computed internally, overriding is not permissable." % name)
if pretty is None:
pretty = settings.pretty(False)
if pretty:
separators=(",", ": ")
else:
separators=(",", ":")
if pretty and indent is None:
indent = 2
return json.dumps(obj, cls=BokehJSONEncoder, allow_nan=False, indent=indent, separators=separators, sort_keys=True, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_item_children; 3, parameters; 3, 4; 4, identifier:item; 5, block; 5, 6; 5, 26; 5, 49; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:children; 9, list_comprehension; 9, 10; 9, 16; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:item; 13, identifier:child; 14, argument_list; 14, 15; 15, identifier:index; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:index; 18, call; 18, 19; 18, 20; 19, identifier:range; 20, argument_list; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:item; 24, identifier:childCount; 25, argument_list; 26, for_statement; 26, 27; 26, 28; 26, 32; 27, identifier:child; 28, subscript; 28, 29; 28, 30; 29, identifier:children; 30, slice; 30, 31; 31, colon; 32, block; 32, 33; 32, 40; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:others; 36, call; 36, 37; 36, 38; 37, identifier:get_item_children; 38, argument_list; 38, 39; 39, identifier:child; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:others; 43, None; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, augmented_assignment:+=; 46, 47; 46, 48; 47, identifier:children; 48, identifier:others; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 52, 54; 53, identifier:children; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:key; 56, lambda; 56, 57; 56, 59; 57, lambda_parameters; 57, 58; 58, identifier:child; 59, attribute; 59, 60; 59, 61; 60, identifier:child; 61, identifier:line | def get_item_children(item):
children = [item.child(index) for index in range(item.childCount())]
for child in children[:]:
others = get_item_children(child)
if others is not None:
children += others
return sorted(children, key=lambda child: child.line) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:__sort_toplevel_items; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 34; 5, 93; 6, if_statement; 6, 7; 6, 12; 7, comparison_operator:is; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:show_all_files; 11, False; 12, block; 12, 13; 13, return_statement; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:current_ordered_items; 17, list_comprehension; 17, 18; 17, 24; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:topLevelItem; 22, argument_list; 22, 23; 23, identifier:index; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:index; 26, call; 26, 27; 26, 28; 27, identifier:range; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:topLevelItemCount; 33, argument_list; 34, if_statement; 34, 35; 34, 38; 34, 63; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:sort_files_alphabetically; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:new_ordered_items; 42, call; 42, 43; 42, 44; 43, identifier:sorted; 44, argument_list; 44, 45; 44, 46; 45, identifier:current_ordered_items; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:key; 48, lambda; 48, 49; 48, 51; 49, lambda_parameters; 49, 50; 50, identifier:item; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:osp; 54, identifier:basename; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:item; 60, identifier:path; 61, identifier:lower; 62, argument_list; 63, else_clause; 63, 64; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:new_ordered_items; 68, list_comprehension; 68, 69; 68, 77; 68, 82; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:editor_items; 74, identifier:get; 75, argument_list; 75, 76; 76, identifier:e_id; 77, for_in_clause; 77, 78; 77, 79; 78, identifier:e_id; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:ordered_editor_ids; 82, if_clause; 82, 83; 83, comparison_operator:is; 83, 84; 83, 92; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:editor_items; 89, identifier:get; 90, argument_list; 90, 91; 91, identifier:e_id; 92, None; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:!=; 94, 95; 94, 96; 95, identifier:current_ordered_items; 96, identifier:new_ordered_items; 97, block; 97, 98; 97, 106; 97, 112; 97, 130; 97, 147; 97, 153; 97, 159; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:selected_items; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:selectedItems; 105, argument_list; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:save_expanded_state; 111, argument_list; 112, for_statement; 112, 113; 112, 114; 112, 122; 113, identifier:index; 114, call; 114, 115; 114, 116; 115, identifier:range; 116, argument_list; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:topLevelItemCount; 121, argument_list; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:takeTopLevelItem; 128, argument_list; 128, 129; 129, integer:0; 130, for_statement; 130, 131; 130, 134; 130, 138; 131, pattern_list; 131, 132; 131, 133; 132, identifier:index; 133, identifier:item; 134, call; 134, 135; 134, 136; 135, identifier:enumerate; 136, argument_list; 136, 137; 137, identifier:new_ordered_items; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:insertTopLevelItem; 144, argument_list; 144, 145; 144, 146; 145, identifier:index; 146, identifier:item; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:restore_expanded_state; 152, argument_list; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:clearSelection; 158, argument_list; 159, if_statement; 159, 160; 159, 161; 160, identifier:selected_items; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 170; 164, attribute; 164, 165; 164, 169; 165, subscript; 165, 166; 165, 167; 166, identifier:selected_items; 167, unary_operator:-; 167, 168; 168, integer:1; 169, identifier:setSelected; 170, argument_list; 170, 171; 171, True | def __sort_toplevel_items(self):
if self.show_all_files is False:
return
current_ordered_items = [self.topLevelItem(index) for index in
range(self.topLevelItemCount())]
if self.sort_files_alphabetically:
new_ordered_items = sorted(
current_ordered_items,
key=lambda item: osp.basename(item.path.lower()))
else:
new_ordered_items = [
self.editor_items.get(e_id) for e_id in
self.ordered_editor_ids if
self.editor_items.get(e_id) is not None]
if current_ordered_items != new_ordered_items:
selected_items = self.selectedItems()
self.save_expanded_state()
for index in range(self.topLevelItemCount()):
self.takeTopLevelItem(0)
for index, item in enumerate(new_ordered_items):
self.insertTopLevelItem(index, item)
self.restore_expanded_state()
self.clearSelection()
if selected_items:
selected_items[-1].setSelected(True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sortByColumn; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:index; 6, block; 6, 7; 6, 24; 6, 34; 6, 42; 6, 96; 7, if_statement; 7, 8; 7, 14; 8, comparison_operator:==; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:sort_old; 12, list:[None]; 12, 13; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:header_class; 21, identifier:setSortIndicatorShown; 22, argument_list; 22, 23; 23, True; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:sort_order; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:header_class; 32, identifier:sortIndicatorOrder; 33, argument_list; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:sig_sort_by_column; 40, identifier:emit; 41, argument_list; 42, if_statement; 42, 43; 42, 55; 43, not_operator; 43, 44; 44, call; 44, 45; 44, 52; 45, attribute; 45, 46; 45, 51; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:model; 50, argument_list; 51, identifier:sort; 52, argument_list; 52, 53; 52, 54; 53, identifier:index; 54, identifier:sort_order; 55, block; 55, 56; 55, 95; 56, if_statement; 56, 57; 56, 65; 56, 75; 57, comparison_operator:!=; 57, 58; 57, 64; 58, call; 58, 59; 58, 60; 59, identifier:len; 60, argument_list; 60, 61; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:sort_old; 64, integer:2; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:header_class; 72, identifier:setSortIndicatorShown; 73, argument_list; 73, 74; 74, False; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:header_class; 83, identifier:setSortIndicator; 84, argument_list; 84, 85; 84, 90; 85, subscript; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:sort_old; 89, integer:0; 90, subscript; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:sort_old; 94, integer:1; 95, return_statement; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:sort_old; 101, list:[index, self.header_class.sortIndicatorOrder()]; 101, 102; 101, 103; 102, identifier:index; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:header_class; 108, identifier:sortIndicatorOrder; 109, argument_list | def sortByColumn(self, index):
if self.sort_old == [None]:
self.header_class.setSortIndicatorShown(True)
sort_order = self.header_class.sortIndicatorOrder()
self.sig_sort_by_column.emit()
if not self.model().sort(index, sort_order):
if len(self.sort_old) != 2:
self.header_class.setSortIndicatorShown(False)
else:
self.header_class.setSortIndicator(self.sort_old[0],
self.sort_old[1])
return
self.sort_old = [index, self.header_class.sortIndicatorOrder()] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:column; 6, default_parameter; 6, 7; 6, 8; 7, identifier:order; 8, attribute; 8, 9; 8, 10; 9, identifier:Qt; 10, identifier:AscendingOrder; 11, block; 11, 12; 11, 20; 11, 34; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:ascending; 15, comparison_operator:==; 15, 16; 15, 17; 16, identifier:order; 17, attribute; 17, 18; 17, 19; 18, identifier:Qt; 19, identifier:AscendingOrder; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:model; 26, identifier:sort; 27, argument_list; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:COLUMN_INDEX; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:order; 33, identifier:ascending; 34, return_statement; 34, 35; 35, True | def sort(self, column, order=Qt.AscendingOrder):
ascending = order == Qt.AscendingOrder
self.model.sort(self.COLUMN_INDEX, order=ascending)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sortByIndex; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:index; 6, block; 6, 7; 6, 20; 6, 34; 6, 48; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 18; 9, attribute; 9, 10; 9, 17; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:table_level; 15, identifier:horizontalHeader; 16, argument_list; 17, identifier:setSortIndicatorShown; 18, argument_list; 18, 19; 19, True; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:sort_order; 23, call; 23, 24; 23, 33; 24, attribute; 24, 25; 24, 32; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:table_level; 30, identifier:horizontalHeader; 31, argument_list; 32, identifier:sortIndicatorOrder; 33, argument_list; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 45; 36, attribute; 36, 37; 36, 44; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:table_index; 42, identifier:model; 43, argument_list; 44, identifier:sort; 45, argument_list; 45, 46; 45, 47; 46, identifier:index; 47, identifier:sort_order; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_sort_update; 53, argument_list | def sortByIndex(self, index):
self.table_level.horizontalHeader().setSortIndicatorShown(True)
sort_order = self.table_level.horizontalHeader().sortIndicatorOrder()
self.table_index.model().sort(index, sort_order)
self._sort_update() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_file_tabs_alphabetically; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, while_statement; 6, 7; 6, 14; 7, comparison_operator:is; 7, 8; 7, 13; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:sorted; 12, argument_list; 13, False; 14, block; 14, 15; 15, for_statement; 15, 16; 15, 17; 15, 32; 16, identifier:i; 17, call; 17, 18; 17, 19; 18, identifier:range; 19, argument_list; 19, 20; 19, 21; 20, integer:0; 21, call; 21, 22; 21, 31; 22, attribute; 22, 23; 22, 30; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:tabs; 28, identifier:tabBar; 29, argument_list; 30, identifier:count; 31, argument_list; 32, block; 32, 33; 33, if_statement; 33, 34; 33, 62; 34, parenthesized_expression; 34, 35; 35, comparison_operator:>; 35, 36; 35, 48; 36, call; 36, 37; 36, 46; 37, attribute; 37, 38; 37, 45; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:tabs; 43, identifier:tabBar; 44, argument_list; 45, identifier:tabText; 46, argument_list; 46, 47; 47, identifier:i; 48, call; 48, 49; 48, 58; 49, attribute; 49, 50; 49, 57; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:tabs; 55, identifier:tabBar; 56, argument_list; 57, identifier:tabText; 58, argument_list; 58, 59; 59, binary_operator:+; 59, 60; 59, 61; 60, identifier:i; 61, integer:1; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 74; 65, attribute; 65, 66; 65, 73; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:tabs; 71, identifier:tabBar; 72, argument_list; 73, identifier:moveTab; 74, argument_list; 74, 75; 74, 76; 75, identifier:i; 76, binary_operator:+; 76, 77; 76, 78; 77, identifier:i; 78, integer:1 | def sort_file_tabs_alphabetically(self):
while self.sorted() is False:
for i in range(0, self.tabs.tabBar().count()):
if(self.tabs.tabBar().tabText(i) >
self.tabs.tabBar().tabText(i + 1)):
self.tabs.tabBar().moveTab(i, i + 1) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_top_level_items; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:key; 6, block; 6, 7; 6, 13; 6, 39; 6, 56; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:save_expanded_state; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:items; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 18, 36; 19, list_comprehension; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:takeTopLevelItem; 24, argument_list; 24, 25; 25, integer:0; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:index; 28, call; 28, 29; 28, 30; 29, identifier:range; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:topLevelItemCount; 35, argument_list; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:key; 38, identifier:key; 39, for_statement; 39, 40; 39, 43; 39, 47; 40, pattern_list; 40, 41; 40, 42; 41, identifier:index; 42, identifier:item; 43, call; 43, 44; 43, 45; 44, identifier:enumerate; 45, argument_list; 45, 46; 46, identifier:items; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:insertTopLevelItem; 53, argument_list; 53, 54; 53, 55; 54, identifier:index; 55, identifier:item; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:restore_expanded_state; 61, argument_list | def sort_top_level_items(self, key):
self.save_expanded_state()
items = sorted([self.takeTopLevelItem(0)
for index in range(self.topLevelItemCount())], key=key)
for index, item in enumerate(items):
self.insertTopLevelItem(index, item)
self.restore_expanded_state() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:set_sorting; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:flag; 6, block; 6, 7; 6, 15; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 14; 9, subscript; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:sorting; 13, string:'status'; 14, identifier:flag; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:header; 22, argument_list; 23, identifier:setSectionsClickable; 24, argument_list; 24, 25; 25, comparison_operator:==; 25, 26; 25, 27; 26, identifier:flag; 27, identifier:ON | def set_sorting(self, flag):
self.sorting['status'] = flag
self.header().setSectionsClickable(flag == ON) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:set_filter; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:text; 6, block; 6, 7; 6, 16; 6, 41; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:pattern; 12, call; 12, 13; 12, 14; 13, identifier:get_search_regex; 14, argument_list; 14, 15; 15, identifier:text; 16, if_statement; 16, 17; 16, 20; 16, 30; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:pattern; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_parent; 27, identifier:setSortingEnabled; 28, argument_list; 28, 29; 29, False; 30, else_clause; 30, 31; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_parent; 38, identifier:setSortingEnabled; 39, argument_list; 39, 40; 40, True; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:invalidateFilter; 46, argument_list | def set_filter(self, text):
self.pattern = get_search_regex(text)
if self.pattern:
self._parent.setSortingEnabled(False)
else:
self._parent.setSortingEnabled(True)
self.invalidateFilter() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_content_hash; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 16; 5, 33; 5, 56; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:content; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:_local_config; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:relevant_content; 15, dictionary; 16, for_statement; 16, 17; 16, 18; 16, 21; 17, identifier:key; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_relevant_keys; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:relevant_content; 26, identifier:key; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:content; 30, identifier:get; 31, argument_list; 31, 32; 32, identifier:key; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:content_hash; 36, call; 36, 37; 36, 55; 37, attribute; 37, 38; 37, 54; 38, call; 38, 39; 38, 40; 39, identifier:sha256; 40, argument_list; 40, 41; 41, call; 41, 42; 41, 53; 42, attribute; 42, 43; 42, 52; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:json; 46, identifier:dumps; 47, argument_list; 47, 48; 47, 49; 48, identifier:relevant_content; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:sort_keys; 51, True; 52, identifier:encode; 53, argument_list; 54, identifier:hexdigest; 55, argument_list; 56, return_statement; 56, 57; 57, identifier:content_hash | def _get_content_hash(self):
content = self._local_config
relevant_content = {}
for key in self._relevant_keys:
relevant_content[key] = content.get(key)
content_hash = sha256(
json.dumps(relevant_content, sort_keys=True).encode()
).hexdigest()
return content_hash |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:missing_datetimes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:finite_datetimes; 6, block; 6, 7; 7, return_statement; 7, 8; 8, list_comprehension; 8, 9; 8, 10; 8, 13; 9, identifier:d; 10, for_in_clause; 10, 11; 10, 12; 11, identifier:d; 12, identifier:finite_datetimes; 13, if_clause; 13, 14; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 29; 16, attribute; 16, 17; 16, 28; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_instantiate_task_cls; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:datetime_to_parameter; 26, argument_list; 26, 27; 27, identifier:d; 28, identifier:complete; 29, argument_list | def missing_datetimes(self, finite_datetimes):
return [d for d in finite_datetimes if not self._instantiate_task_cls(self.datetime_to_parameter(d)).complete()] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_partition_tasks; 3, parameters; 3, 4; 4, identifier:worker; 5, block; 5, 6; 5, 12; 5, 27; 5, 31; 5, 52; 5, 79; 5, 96; 5, 108; 5, 125; 5, 157; 5, 188; 5, 196; 5, 204; 5, 212; 5, 220; 5, 228; 5, 236; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:task_history; 9, attribute; 9, 10; 9, 11; 10, identifier:worker; 11, identifier:_add_task_history; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:pending_tasks; 15, set_comprehension; 15, 16; 15, 17; 15, 23; 16, identifier:task; 17, for_in_clause; 17, 18; 17, 22; 18, tuple_pattern; 18, 19; 18, 20; 18, 21; 19, identifier:task; 20, identifier:status; 21, identifier:ext; 22, identifier:task_history; 23, if_clause; 23, 24; 24, comparison_operator:==; 24, 25; 24, 26; 25, identifier:status; 26, string:'PENDING'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:set_tasks; 30, dictionary; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:set_tasks; 35, string:"completed"; 36, set_comprehension; 36, 37; 36, 38; 36, 44; 37, identifier:task; 38, for_in_clause; 38, 39; 38, 43; 39, tuple_pattern; 39, 40; 39, 41; 39, 42; 40, identifier:task; 41, identifier:status; 42, identifier:ext; 43, identifier:task_history; 44, if_clause; 44, 45; 45, boolean_operator:and; 45, 46; 45, 49; 46, comparison_operator:==; 46, 47; 46, 48; 47, identifier:status; 48, string:'DONE'; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:task; 51, identifier:pending_tasks; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:set_tasks; 56, string:"already_done"; 57, set_comprehension; 57, 58; 57, 59; 57, 65; 58, identifier:task; 59, for_in_clause; 59, 60; 59, 64; 60, tuple_pattern; 60, 61; 60, 62; 60, 63; 61, identifier:task; 62, identifier:status; 63, identifier:ext; 64, identifier:task_history; 65, if_clause; 65, 66; 66, boolean_operator:and; 66, 67; 66, 74; 67, boolean_operator:and; 67, 68; 67, 71; 68, comparison_operator:==; 68, 69; 68, 70; 69, identifier:status; 70, string:'DONE'; 71, comparison_operator:not; 71, 72; 71, 73; 72, identifier:task; 73, identifier:pending_tasks; 74, comparison_operator:not; 74, 75; 74, 76; 75, identifier:task; 76, subscript; 76, 77; 76, 78; 77, identifier:set_tasks; 78, string:"completed"; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:set_tasks; 83, string:"ever_failed"; 84, set_comprehension; 84, 85; 84, 86; 84, 92; 85, identifier:task; 86, for_in_clause; 86, 87; 86, 91; 87, tuple_pattern; 87, 88; 87, 89; 87, 90; 88, identifier:task; 89, identifier:status; 90, identifier:ext; 91, identifier:task_history; 92, if_clause; 92, 93; 93, comparison_operator:==; 93, 94; 93, 95; 94, identifier:status; 95, string:'FAILED'; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:set_tasks; 100, string:"failed"; 101, binary_operator:-; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:set_tasks; 104, string:"ever_failed"; 105, subscript; 105, 106; 105, 107; 106, identifier:set_tasks; 107, string:"completed"; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:set_tasks; 112, string:"scheduling_error"; 113, set_comprehension; 113, 114; 113, 115; 113, 121; 114, identifier:task; 115, for_in_clause; 115, 116; 115, 120; 116, tuple_pattern; 116, 117; 116, 118; 116, 119; 117, identifier:task; 118, identifier:status; 119, identifier:ext; 120, identifier:task_history; 121, if_clause; 121, 122; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:status; 124, string:'UNKNOWN'; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:set_tasks; 129, string:"still_pending_ext"; 130, set_comprehension; 130, 131; 130, 132; 130, 138; 131, identifier:task; 132, for_in_clause; 132, 133; 132, 137; 133, tuple_pattern; 133, 134; 133, 135; 133, 136; 134, identifier:task; 135, identifier:status; 136, identifier:ext; 137, identifier:task_history; 138, if_clause; 138, 139; 139, boolean_operator:and; 139, 140; 139, 155; 140, boolean_operator:and; 140, 141; 140, 150; 141, boolean_operator:and; 141, 142; 141, 145; 142, comparison_operator:==; 142, 143; 142, 144; 143, identifier:status; 144, string:'PENDING'; 145, comparison_operator:not; 145, 146; 145, 147; 146, identifier:task; 147, subscript; 147, 148; 147, 149; 148, identifier:set_tasks; 149, string:"ever_failed"; 150, comparison_operator:not; 150, 151; 150, 152; 151, identifier:task; 152, subscript; 152, 153; 152, 154; 153, identifier:set_tasks; 154, string:"completed"; 155, not_operator; 155, 156; 156, identifier:ext; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 162; 159, subscript; 159, 160; 159, 161; 160, identifier:set_tasks; 161, string:"still_pending_not_ext"; 162, set_comprehension; 162, 163; 162, 164; 162, 170; 163, identifier:task; 164, for_in_clause; 164, 165; 164, 169; 165, tuple_pattern; 165, 166; 165, 167; 165, 168; 166, identifier:task; 167, identifier:status; 168, identifier:ext; 169, identifier:task_history; 170, if_clause; 170, 171; 171, boolean_operator:and; 171, 172; 171, 187; 172, boolean_operator:and; 172, 173; 172, 182; 173, boolean_operator:and; 173, 174; 173, 177; 174, comparison_operator:==; 174, 175; 174, 176; 175, identifier:status; 176, string:'PENDING'; 177, comparison_operator:not; 177, 178; 177, 179; 178, identifier:task; 179, subscript; 179, 180; 179, 181; 180, identifier:set_tasks; 181, string:"ever_failed"; 182, comparison_operator:not; 182, 183; 182, 184; 183, identifier:task; 184, subscript; 184, 185; 184, 186; 185, identifier:set_tasks; 186, string:"completed"; 187, identifier:ext; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:set_tasks; 192, string:"run_by_other_worker"; 193, call; 193, 194; 193, 195; 194, identifier:set; 195, argument_list; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:set_tasks; 200, string:"upstream_failure"; 201, call; 201, 202; 201, 203; 202, identifier:set; 203, argument_list; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 209; 206, subscript; 206, 207; 206, 208; 207, identifier:set_tasks; 208, string:"upstream_missing_dependency"; 209, call; 209, 210; 209, 211; 210, identifier:set; 211, argument_list; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:set_tasks; 216, string:"upstream_run_by_other_worker"; 217, call; 217, 218; 217, 219; 218, identifier:set; 219, argument_list; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:set_tasks; 224, string:"upstream_scheduling_error"; 225, call; 225, 226; 225, 227; 226, identifier:set; 227, argument_list; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:set_tasks; 232, string:"not_run"; 233, call; 233, 234; 233, 235; 234, identifier:set; 235, argument_list; 236, return_statement; 236, 237; 237, identifier:set_tasks | def _partition_tasks(worker):
task_history = worker._add_task_history
pending_tasks = {task for(task, status, ext) in task_history if status == 'PENDING'}
set_tasks = {}
set_tasks["completed"] = {task for (task, status, ext) in task_history if status == 'DONE' and task in pending_tasks}
set_tasks["already_done"] = {task for (task, status, ext) in task_history
if status == 'DONE' and task not in pending_tasks and task not in set_tasks["completed"]}
set_tasks["ever_failed"] = {task for (task, status, ext) in task_history if status == 'FAILED'}
set_tasks["failed"] = set_tasks["ever_failed"] - set_tasks["completed"]
set_tasks["scheduling_error"] = {task for(task, status, ext) in task_history if status == 'UNKNOWN'}
set_tasks["still_pending_ext"] = {task for (task, status, ext) in task_history
if status == 'PENDING' and task not in set_tasks["ever_failed"] and task not in set_tasks["completed"] and not ext}
set_tasks["still_pending_not_ext"] = {task for (task, status, ext) in task_history
if status == 'PENDING' and task not in set_tasks["ever_failed"] and task not in set_tasks["completed"] and ext}
set_tasks["run_by_other_worker"] = set()
set_tasks["upstream_failure"] = set()
set_tasks["upstream_missing_dependency"] = set()
set_tasks["upstream_run_by_other_worker"] = set()
set_tasks["upstream_scheduling_error"] = set()
set_tasks["not_run"] = set()
return set_tasks |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.