sequence
stringlengths 546
16.2k
| code
stringlengths 108
19.3k
|
|---|---|
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, 12; 9, 24; 9, 101; 9, 126; 9, 133; 9, 155; 9, 175; 9, 176; 9, 177; 9, 178; 9, 179; 9, 185; 9, 201; 9, 222; 9, 232; 9, 242; 9, 253; 9, 266; 9, 326; 10, expression_statement; 10, 11; 11, comment; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:method; 15, None; 16, block; 16, 17; 17, raise_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:NotImplementedError; 20, argument_list; 20, 21; 21, concatenated_string; 21, 22; 21, 23; 22, string:'only the default get_loc method is '; 23, string:'currently supported for MultiIndex'; 24, function_definition; 24, 25; 24, 26; 24, 28; 25, function_name:_maybe_to_slice; 26, parameters; 26, 27; 27, identifier:loc; 28, block; 28, 29; 28, 31; 28, 49; 28, 62; 28, 71; 28, 86; 28, 93; 28, 99; 29, expression_statement; 29, 30; 30, comment; 31, if_statement; 31, 32; 31, 46; 32, boolean_operator:or; 32, 33; 32, 41; 33, not_operator; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:loc; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:ndarray; 41, comparison_operator:!=; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:loc; 44, identifier:dtype; 45, string:'int64'; 46, block; 46, 47; 47, return_statement; 47, 48; 48, identifier:loc; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:loc; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:lib; 55, identifier:maybe_indices_to_slice; 56, argument_list; 56, 57; 56, 58; 57, identifier:loc; 58, call; 58, 59; 58, 60; 59, identifier:len; 60, argument_list; 60, 61; 61, identifier:self; 62, if_statement; 62, 63; 62, 68; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:loc; 67, identifier:slice; 68, block; 68, 69; 69, return_statement; 69, 70; 70, identifier:loc; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:mask; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:np; 77, identifier:empty; 78, argument_list; 78, 79; 78, 83; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:self; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:dtype; 85, string:'bool'; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:mask; 90, identifier:fill; 91, argument_list; 91, 92; 92, False; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:mask; 97, identifier:loc; 98, True; 99, return_statement; 99, 100; 100, identifier:mask; 101, if_statement; 101, 102; 101, 108; 102, not_operator; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:isinstance; 105, argument_list; 105, 106; 105, 107; 106, identifier:key; 107, identifier:tuple; 108, block; 108, 109; 108, 121; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:loc; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:_get_level_indexer; 116, argument_list; 116, 117; 116, 118; 117, identifier:key; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:level; 120, integer:0; 121, return_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:_maybe_to_slice; 124, argument_list; 124, 125; 125, identifier:loc; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:keylen; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:key; 133, if_statement; 133, 134; 133, 139; 134, comparison_operator:<; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:nlevels; 138, identifier:keylen; 139, block; 139, 140; 140, raise_statement; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:KeyError; 143, argument_list; 143, 144; 144, call; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, concatenated_string; 146, 147; 146, 148; 147, string:'Key length ({0}) exceeds index depth ({1})'; 148, string:''; 149, identifier:format; 150, argument_list; 150, 151; 150, 152; 151, identifier:keylen; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:nlevels; 155, if_statement; 155, 156; 155, 165; 156, boolean_operator:and; 156, 157; 156, 162; 157, comparison_operator:==; 157, 158; 157, 159; 158, identifier:keylen; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:nlevels; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:is_unique; 165, block; 165, 166; 166, return_statement; 166, 167; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:_engine; 172, identifier:get_loc; 173, argument_list; 173, 174; 174, identifier:key; 175, comment; 176, comment; 177, comment; 178, comment; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:i; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:lexsort_depth; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 190; 187, pattern_list; 187, 188; 187, 189; 188, identifier:lead_key; 189, identifier:follow_key; 190, expression_list; 190, 191; 190, 196; 191, subscript; 191, 192; 191, 193; 192, identifier:key; 193, slice; 193, 194; 193, 195; 194, colon; 195, identifier:i; 196, subscript; 196, 197; 196, 198; 197, identifier:key; 198, slice; 198, 199; 198, 200; 199, identifier:i; 200, colon; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, pattern_list; 203, 204; 203, 205; 204, identifier:start; 205, identifier:stop; 206, parenthesized_expression; 206, 207; 207, conditional_expression:if; 207, 208; 207, 215; 207, 216; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:slice_locs; 212, argument_list; 212, 213; 212, 214; 213, identifier:lead_key; 214, identifier:lead_key; 215, identifier:lead_key; 216, tuple; 216, 217; 216, 218; 217, integer:0; 218, call; 218, 219; 218, 220; 219, identifier:len; 220, argument_list; 220, 221; 221, identifier:self; 222, if_statement; 222, 223; 222, 226; 223, comparison_operator:==; 223, 224; 223, 225; 224, identifier:start; 225, identifier:stop; 226, block; 226, 227; 227, raise_statement; 227, 228; 228, call; 228, 229; 228, 230; 229, identifier:KeyError; 230, argument_list; 230, 231; 231, identifier:key; 232, if_statement; 232, 233; 232, 235; 233, not_operator; 233, 234; 234, identifier:follow_key; 235, block; 235, 236; 236, return_statement; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:slice; 239, argument_list; 239, 240; 239, 241; 240, identifier:start; 241, identifier:stop; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:warnings; 246, identifier:warn; 247, argument_list; 247, 248; 247, 249; 247, 250; 248, string:'indexing past lexsort depth may impact performance.'; 249, identifier:PerformanceWarning; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:stacklevel; 252, integer:10; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:loc; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:np; 259, identifier:arange; 260, argument_list; 260, 261; 260, 262; 260, 263; 261, identifier:start; 262, identifier:stop; 263, keyword_argument; 263, 264; 263, 265; 264, identifier:dtype; 265, string:'int64'; 266, for_statement; 266, 267; 266, 270; 266, 278; 267, pattern_list; 267, 268; 267, 269; 268, identifier:i; 269, identifier:k; 270, call; 270, 271; 270, 272; 271, identifier:enumerate; 272, argument_list; 272, 273; 272, 274; 273, identifier:follow_key; 274, call; 274, 275; 274, 276; 275, identifier:len; 276, argument_list; 276, 277; 277, identifier:lead_key; 278, block; 278, 279; 278, 300; 278, 314; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:mask; 282, comparison_operator:==; 282, 283; 282, 290; 283, subscript; 283, 284; 283, 289; 284, subscript; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:self; 287, identifier:codes; 288, identifier:i; 289, identifier:loc; 290, call; 290, 291; 290, 298; 291, attribute; 291, 292; 291, 297; 292, subscript; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:self; 295, identifier:levels; 296, identifier:i; 297, identifier:get_loc; 298, argument_list; 298, 299; 299, identifier:k; 300, if_statement; 300, 301; 300, 307; 301, not_operator; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:mask; 305, identifier:all; 306, argument_list; 307, block; 307, 308; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:loc; 311, subscript; 311, 312; 311, 313; 312, identifier:loc; 313, identifier:mask; 314, if_statement; 314, 315; 314, 320; 315, not_operator; 315, 316; 316, call; 316, 317; 316, 318; 317, identifier:len; 318, argument_list; 318, 319; 319, identifier:loc; 320, block; 320, 321; 321, raise_statement; 321, 322; 322, call; 322, 323; 322, 324; 323, identifier:KeyError; 324, argument_list; 324, 325; 325, identifier:key; 326, return_statement; 326, 327; 327, parenthesized_expression; 327, 328; 328, conditional_expression:if; 328, 329; 328, 333; 328, 341; 329, call; 329, 330; 329, 331; 330, identifier:_maybe_to_slice; 331, argument_list; 331, 332; 332, identifier:loc; 333, comparison_operator:!=; 333, 334; 333, 338; 334, call; 334, 335; 334, 336; 335, identifier:len; 336, argument_list; 336, 337; 337, identifier:loc; 338, binary_operator:-; 338, 339; 338, 340; 339, identifier:stop; 340, identifier:start; 341, call; 341, 342; 341, 343; 342, identifier:slice; 343, argument_list; 343, 344; 343, 345; 344, identifier:start; 345, identifier:stop | def get_loc(self, key, method=None):
"""
Get location for a label or a tuple of labels as an integer, slice or
boolean mask.
Parameters
----------
key : label or tuple of labels (one for each level)
method : None
Returns
-------
loc : int, slice object or boolean mask
If the key is past the lexsort depth, the return may be a
boolean mask array, otherwise it is always a slice or int.
Examples
---------
>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')])
>>> mi.get_loc('b')
slice(1, 3, None)
>>> mi.get_loc(('b', 'e'))
1
Notes
------
The key cannot be a slice, list of same-level labels, a boolean mask,
or a sequence of such. If you want to use those, use
:meth:`MultiIndex.get_locs` instead.
See Also
--------
Index.get_loc : The get_loc method for (single-level) index.
MultiIndex.slice_locs : Get slice location given start label(s) and
end label(s).
MultiIndex.get_locs : Get location for a label/slice/list/mask or a
sequence of such.
"""
if method is not None:
raise NotImplementedError('only the default get_loc method is '
'currently supported for MultiIndex')
def _maybe_to_slice(loc):
"""convert integer indexer to boolean mask or slice if possible"""
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)
# -- partial selection or non-unique index
# break the key into 2 parts based on the lexsort_depth of the index;
# the first part returns a continuous slice of the index; the 2nd part
# needs linear search within the slice
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, 12; 9, 19; 9, 26; 9, 37; 9, 54; 9, 55; 9, 73; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_validate_sort_keyword; 17, argument_list; 17, 18; 18, identifier:sort; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_assert_can_do_setop; 24, argument_list; 24, 25; 25, identifier:other; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:other; 30, identifier:result_names; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_convert_can_do_setop; 35, argument_list; 35, 36; 36, identifier:other; 37, if_statement; 37, 38; 37, 51; 38, boolean_operator:or; 38, 39; 38, 45; 39, comparison_operator:==; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:other; 44, integer:0; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:equals; 49, argument_list; 49, 50; 50, identifier:other; 51, block; 51, 52; 52, return_statement; 52, 53; 53, identifier:self; 54, comment; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:uniq_tuples; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:lib; 61, identifier:fast_unique_multiple; 62, argument_list; 62, 63; 62, 70; 63, list:[self._ndarray_values,
other._ndarray_values]; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_ndarray_values; 67, attribute; 67, 68; 67, 69; 68, identifier:other; 69, identifier:_ndarray_values; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:sort; 72, identifier:sort; 73, return_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:MultiIndex; 77, identifier:from_arrays; 78, argument_list; 78, 79; 78, 84; 78, 87; 79, call; 79, 80; 79, 81; 80, identifier:lzip; 81, argument_list; 81, 82; 82, list_splat; 82, 83; 83, identifier:uniq_tuples; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:sortorder; 86, integer:0; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:names; 89, identifier:result_names | def union(self, other, sort=None):
"""
Form the union of two MultiIndex objects
Parameters
----------
other : MultiIndex or array / Index of tuples
sort : False or None, default None
Whether to sort the resulting Index.
* None : Sort the result, except when
1. `self` and `other` are equal.
2. `self` has length 0.
3. Some values in `self` or `other` cannot be compared.
A RuntimeWarning is issued in this case.
* False : do not sort the result.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
Index
>>> index.union(index2)
"""
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
# TODO: Index.union returns other when `len(self)` is 0.
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, 12; 9, 19; 9, 26; 9, 37; 9, 47; 9, 53; 9, 59; 9, 71; 9, 83; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_validate_sort_keyword; 17, argument_list; 17, 18; 18, identifier:sort; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_assert_can_do_setop; 24, argument_list; 24, 25; 25, identifier:other; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:other; 30, identifier:result_names; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_convert_can_do_setop; 35, argument_list; 35, 36; 36, identifier:other; 37, if_statement; 37, 38; 37, 44; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:equals; 42, argument_list; 42, 43; 43, identifier:other; 44, block; 44, 45; 45, return_statement; 45, 46; 46, identifier:self; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:self_tuples; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_ndarray_values; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:other_tuples; 56, attribute; 56, 57; 56, 58; 57, identifier:other; 58, identifier:_ndarray_values; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:uniq_tuples; 62, binary_operator:&; 62, 63; 62, 67; 63, call; 63, 64; 63, 65; 64, identifier:set; 65, argument_list; 65, 66; 66, identifier:self_tuples; 67, call; 67, 68; 67, 69; 68, identifier:set; 69, argument_list; 69, 70; 70, identifier:other_tuples; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:sort; 74, None; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:uniq_tuples; 79, call; 79, 80; 79, 81; 80, identifier:sorted; 81, argument_list; 81, 82; 82, identifier:uniq_tuples; 83, if_statement; 83, 84; 83, 90; 83, 114; 84, comparison_operator:==; 84, 85; 84, 89; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, identifier:uniq_tuples; 89, integer:0; 90, block; 90, 91; 91, return_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:MultiIndex; 94, argument_list; 94, 95; 94, 100; 94, 108; 94, 111; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:levels; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:levels; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:codes; 102, binary_operator:*; 102, 103; 102, 105; 103, list:[[]]; 103, 104; 104, list:[]; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:nlevels; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:names; 110, identifier:result_names; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:verify_integrity; 113, False; 114, else_clause; 114, 115; 115, block; 115, 116; 116, return_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:MultiIndex; 120, identifier:from_arrays; 121, argument_list; 121, 122; 121, 127; 121, 130; 122, call; 122, 123; 122, 124; 123, identifier:lzip; 124, argument_list; 124, 125; 125, list_splat; 125, 126; 126, identifier:uniq_tuples; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:sortorder; 129, integer:0; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:names; 132, identifier:result_names | def intersection(self, other, sort=False):
"""
Form the intersection of two MultiIndex objects.
Parameters
----------
other : MultiIndex or array / Index of tuples
sort : False or None, default False
Sort the resulting MultiIndex if possible
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default from ``True`` to ``False``, to match
behaviour from before 0.24.0
Returns
-------
Index
"""
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, 12; 9, 19; 9, 26; 9, 37; 9, 47; 9, 78; 9, 86; 9, 95; 9, 114; 9, 134; 9, 145; 9, 157; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_validate_sort_keyword; 17, argument_list; 17, 18; 18, identifier:sort; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_assert_can_do_setop; 24, argument_list; 24, 25; 25, identifier:other; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:other; 30, identifier:result_names; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_convert_can_do_setop; 35, argument_list; 35, 36; 36, identifier:other; 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:other; 43, integer:0; 44, block; 44, 45; 45, return_statement; 45, 46; 46, identifier:self; 47, if_statement; 47, 48; 47, 54; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:equals; 52, argument_list; 52, 53; 53, identifier:other; 54, block; 54, 55; 55, return_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:MultiIndex; 58, argument_list; 58, 59; 58, 64; 58, 72; 58, 75; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:levels; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:levels; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:codes; 66, binary_operator:*; 66, 67; 66, 69; 67, list:[[]]; 67, 68; 68, list:[]; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:nlevels; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:names; 74, identifier:result_names; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:verify_integrity; 77, False; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:this; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_get_unique_index; 85, argument_list; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:indexer; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:this; 92, identifier:get_indexer; 93, argument_list; 93, 94; 94, identifier:other; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:indexer; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:indexer; 101, identifier:take; 102, argument_list; 102, 103; 103, subscript; 103, 104; 103, 113; 104, call; 104, 105; 104, 112; 105, attribute; 105, 106; 105, 111; 106, parenthesized_expression; 106, 107; 107, comparison_operator:!=; 107, 108; 107, 109; 108, identifier:indexer; 109, unary_operator:-; 109, 110; 110, integer:1; 111, identifier:nonzero; 112, argument_list; 113, integer:0; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:label_diff; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:np; 120, identifier:setdiff1d; 121, argument_list; 121, 122; 121, 130; 121, 131; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:np; 125, identifier:arange; 126, argument_list; 126, 127; 127, attribute; 127, 128; 127, 129; 128, identifier:this; 129, identifier:size; 130, identifier:indexer; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:assume_unique; 133, True; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:difference; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:this; 141, identifier:values; 142, identifier:take; 143, argument_list; 143, 144; 144, identifier:label_diff; 145, if_statement; 145, 146; 145, 149; 146, comparison_operator:is; 146, 147; 146, 148; 147, identifier:sort; 148, None; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:difference; 153, call; 153, 154; 153, 155; 154, identifier:sorted; 155, argument_list; 155, 156; 156, identifier:difference; 157, if_statement; 157, 158; 157, 164; 157, 191; 158, comparison_operator:==; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:difference; 163, integer:0; 164, block; 164, 165; 165, return_statement; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:MultiIndex; 168, argument_list; 168, 169; 168, 177; 168, 185; 168, 188; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:levels; 171, binary_operator:*; 171, 172; 171, 174; 172, list:[[]]; 172, 173; 173, list:[]; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:nlevels; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:codes; 179, binary_operator:*; 179, 180; 179, 182; 180, list:[[]]; 180, 181; 181, list:[]; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:nlevels; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:names; 187, identifier:result_names; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:verify_integrity; 190, False; 191, else_clause; 191, 192; 192, block; 192, 193; 193, return_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:MultiIndex; 197, identifier:from_tuples; 198, argument_list; 198, 199; 198, 200; 198, 203; 199, identifier:difference; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:sortorder; 202, integer:0; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:names; 205, identifier:result_names | def difference(self, other, sort=None):
"""
Compute set difference of two MultiIndex objects
Parameters
----------
other : MultiIndex
sort : False or None, default None
Sort the resulting MultiIndex if possible
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
Returns
-------
diff : MultiIndex
"""
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, 8; 5, 15; 5, 28; 5, 32; 5, 44; 5, 54; 5, 63; 5, 72; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:values; 11, call; 11, 12; 11, 13; 12, identifier:_ensure_arraylike; 13, argument_list; 13, 14; 14, identifier:values; 15, if_statement; 15, 16; 15, 20; 15, 21; 16, call; 16, 17; 16, 18; 17, identifier:is_extension_array_dtype; 18, argument_list; 18, 19; 19, identifier:values; 20, comment; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:values; 26, identifier:unique; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:original; 31, identifier:values; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 40; 34, pattern_list; 34, 35; 34, 36; 34, 37; 34, 38; 34, 39; 35, identifier:htable; 36, identifier:_; 37, identifier:values; 38, identifier:dtype; 39, identifier:ndtype; 40, call; 40, 41; 40, 42; 41, identifier:_get_hashtable_algo; 42, argument_list; 42, 43; 43, identifier:values; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:table; 47, call; 47, 48; 47, 49; 48, identifier:htable; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:values; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:uniques; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:table; 60, identifier:unique; 61, argument_list; 61, 62; 62, identifier:values; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:uniques; 66, call; 66, 67; 66, 68; 67, identifier:_reconstruct_data; 68, argument_list; 68, 69; 68, 70; 68, 71; 69, identifier:uniques; 70, identifier:dtype; 71, identifier:original; 72, return_statement; 72, 73; 73, identifier:uniques | def unique(values):
"""
Hash table-based unique. Uniques are returned in order
of appearance. This does NOT sort.
Significantly faster than numpy.unique. Includes NA values.
Parameters
----------
values : 1d array-like
Returns
-------
numpy.ndarray or ExtensionArray
The return can be:
* Index : when the input is an Index
* Categorical : when the input is a Categorical dtype
* ndarray : when the input is a Series/ndarray
Return numpy.ndarray or ExtensionArray.
See Also
--------
Index.unique
Series.unique
Examples
--------
>>> pd.unique(pd.Series([2, 1, 3, 3]))
array([2, 1, 3])
>>> pd.unique(pd.Series([2] + [1] * 5))
array([2, 1])
>>> pd.unique(pd.Series([pd.Timestamp('20160101'),
... pd.Timestamp('20160101')]))
array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]')
>>> pd.unique(pd.Series([pd.Timestamp('20160101', tz='US/Eastern'),
... pd.Timestamp('20160101', tz='US/Eastern')]))
array([Timestamp('2016-01-01 00:00:00-0500', tz='US/Eastern')],
dtype=object)
>>> pd.unique(pd.Index([pd.Timestamp('20160101', tz='US/Eastern'),
... pd.Timestamp('20160101', tz='US/Eastern')]))
DatetimeIndex(['2016-01-01 00:00:00-05:00'],
... dtype='datetime64[ns, US/Eastern]', freq=None)
>>> pd.unique(list('baabc'))
array(['b', 'a', 'c'], dtype=object)
An unordered Categorical will return categories in the
order of appearance.
>>> pd.unique(pd.Series(pd.Categorical(list('baabc'))))
[b, a, c]
Categories (3, object): [b, a, c]
>>> pd.unique(pd.Series(pd.Categorical(list('baabc'),
... categories=list('abc'))))
[b, a, c]
Categories (3, object): [b, a, c]
An ordered Categorical preserves the category ordering.
>>> pd.unique(pd.Series(pd.Categorical(list('baabc'),
... categories=list('abc'),
... ordered=True)))
[b, a, c]
Categories (3, object): [a < b < c]
An array of tuples
>>> pd.unique([('a', 'b'), ('b', 'a'), ('a', 'c'), ('b', 'a')])
array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object)
"""
values = _ensure_arraylike(values)
if is_extension_array_dtype(values):
# Dispatch to extension dtype's unique.
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, 23; 20, 32; 20, 41; 20, 249; 20, 263; 20, 279; 21, expression_statement; 21, 22; 22, comment; 23, import_from_statement; 23, 24; 23, 28; 23, 30; 24, dotted_name; 24, 25; 24, 26; 24, 27; 25, identifier:pandas; 26, identifier:core; 27, identifier:series; 28, dotted_name; 28, 29; 29, identifier:Series; 30, dotted_name; 30, 31; 31, identifier:Index; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:name; 35, call; 35, 36; 35, 37; 36, identifier:getattr; 37, argument_list; 37, 38; 37, 39; 37, 40; 38, identifier:values; 39, string:'name'; 40, None; 41, if_statement; 41, 42; 41, 45; 41, 167; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:bins; 44, None; 45, block; 45, 46; 45, 82; 45, 83; 45, 94; 45, 106; 45, 119; 45, 127; 45, 128; 45, 153; 45, 154; 46, try_statement; 46, 47; 46, 74; 47, block; 47, 48; 47, 56; 47, 63; 48, import_from_statement; 48, 49; 48, 54; 49, dotted_name; 49, 50; 49, 51; 49, 52; 49, 53; 50, identifier:pandas; 51, identifier:core; 52, identifier:reshape; 53, identifier:tile; 54, dotted_name; 54, 55; 55, identifier:cut; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:values; 59, call; 59, 60; 59, 61; 60, identifier:Series; 61, argument_list; 61, 62; 62, identifier:values; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:ii; 66, call; 66, 67; 66, 68; 67, identifier:cut; 68, argument_list; 68, 69; 68, 70; 68, 71; 69, identifier:values; 70, identifier:bins; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:include_lowest; 73, True; 74, except_clause; 74, 75; 74, 76; 75, identifier:TypeError; 76, block; 76, 77; 77, raise_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:TypeError; 80, argument_list; 80, 81; 81, string:"bins argument only works with numeric data."; 82, comment; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:result; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:ii; 89, identifier:value_counts; 90, argument_list; 90, 91; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:dropna; 93, identifier:dropna; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:result; 97, subscript; 97, 98; 97, 99; 98, identifier:result; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:result; 103, identifier:index; 104, identifier:notna; 105, argument_list; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:result; 110, identifier:index; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:result; 115, identifier:index; 116, identifier:astype; 117, argument_list; 117, 118; 118, string:'interval'; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:result; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:result; 125, identifier:sort_index; 126, argument_list; 127, comment; 128, if_statement; 128, 129; 128, 141; 129, boolean_operator:and; 129, 130; 129, 131; 130, identifier:dropna; 131, call; 131, 132; 131, 140; 132, attribute; 132, 133; 132, 139; 133, parenthesized_expression; 133, 134; 134, comparison_operator:==; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:result; 137, identifier:values; 138, integer:0; 139, identifier:all; 140, argument_list; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:result; 145, subscript; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:result; 148, identifier:iloc; 149, slice; 149, 150; 149, 151; 149, 152; 150, integer:0; 151, colon; 152, integer:0; 153, comment; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:counts; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:np; 160, identifier:array; 161, argument_list; 161, 162; 162, list:[len(ii)]; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:len; 165, argument_list; 165, 166; 166, identifier:ii; 167, else_clause; 167, 168; 168, block; 168, 169; 169, if_statement; 169, 170; 169, 179; 169, 180; 169, 209; 170, boolean_operator:or; 170, 171; 170, 175; 171, call; 171, 172; 171, 173; 172, identifier:is_extension_array_dtype; 173, argument_list; 173, 174; 174, identifier:values; 175, call; 175, 176; 175, 177; 176, identifier:is_sparse; 177, argument_list; 177, 178; 178, identifier:values; 179, comment; 180, block; 180, 181; 180, 197; 180, 203; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:result; 184, call; 184, 185; 184, 193; 185, attribute; 185, 186; 185, 192; 186, attribute; 186, 187; 186, 191; 187, call; 187, 188; 187, 189; 188, identifier:Series; 189, argument_list; 189, 190; 190, identifier:values; 191, identifier:_values; 192, identifier:value_counts; 193, argument_list; 193, 194; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:dropna; 196, identifier:dropna; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:result; 201, identifier:name; 202, identifier:name; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:counts; 206, attribute; 206, 207; 206, 208; 207, identifier:result; 208, identifier:values; 209, else_clause; 209, 210; 210, block; 210, 211; 210, 221; 210, 236; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 216; 213, pattern_list; 213, 214; 213, 215; 214, identifier:keys; 215, identifier:counts; 216, call; 216, 217; 216, 218; 217, identifier:_value_counts_arraylike; 218, argument_list; 218, 219; 218, 220; 219, identifier:values; 220, identifier:dropna; 221, if_statement; 221, 222; 221, 228; 222, not_operator; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:isinstance; 225, argument_list; 225, 226; 225, 227; 226, identifier:keys; 227, identifier:Index; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:keys; 232, call; 232, 233; 232, 234; 233, identifier:Index; 234, argument_list; 234, 235; 235, identifier:keys; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:result; 239, call; 239, 240; 239, 241; 240, identifier:Series; 241, argument_list; 241, 242; 241, 243; 241, 246; 242, identifier:counts; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:index; 245, identifier:keys; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:name; 248, identifier:name; 249, if_statement; 249, 250; 249, 251; 250, identifier:sort; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:result; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:result; 258, identifier:sort_values; 259, argument_list; 259, 260; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:ascending; 262, identifier:ascending; 263, if_statement; 263, 264; 263, 265; 264, identifier:normalize; 265, block; 265, 266; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:result; 269, binary_operator:/; 269, 270; 269, 271; 270, identifier:result; 271, call; 271, 272; 271, 273; 272, identifier:float; 273, argument_list; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:counts; 277, identifier:sum; 278, argument_list; 279, return_statement; 279, 280; 280, identifier:result | def value_counts(values, sort=True, ascending=False, normalize=False,
bins=None, dropna=True):
"""
Compute a histogram of the counts of non-null values.
Parameters
----------
values : ndarray (1-d)
sort : boolean, default True
Sort by values
ascending : boolean, default False
Sort in ascending order
normalize: boolean, default False
If True then compute a relative histogram
bins : integer, optional
Rather than count values, group them into half-open bins,
convenience for pd.cut, only works with numeric data
dropna : boolean, default True
Don't include counts of NaN
Returns
-------
value_counts : Series
"""
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.")
# count, remove nulls (from the index), and but the bins
result = ii.value_counts(dropna=dropna)
result = result[result.index.notna()]
result.index = result.index.astype('interval')
result = result.sort_index()
# if we are dropna and we have NO values
if dropna and (result.values == 0).all():
result = result.iloc[0:0]
# normalizing is by len of all (regardless of dropna)
counts = np.array([len(ii)])
else:
if is_extension_array_dtype(values) or is_sparse(values):
# handle Categorical and sparse,
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, 10; 7, 31; 7, 40; 8, expression_statement; 8, 9; 9, comment; 10, if_statement; 10, 11; 10, 19; 11, boolean_operator:or; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:is_integer; 14, argument_list; 14, 15; 15, identifier:ascending; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:ascending; 18, None; 19, block; 19, 20; 19, 27; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:args; 23, binary_operator:+; 23, 24; 23, 26; 24, tuple; 24, 25; 25, identifier:ascending; 26, identifier:args; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:ascending; 30, True; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:validate_argsort_kind; 34, argument_list; 34, 35; 34, 36; 34, 37; 35, identifier:args; 36, identifier:kwargs; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:max_fname_arg_count; 39, integer:3; 40, return_statement; 40, 41; 41, identifier:ascending | def validate_argsort_with_ascending(ascending, args, kwargs):
"""
If 'Categorical.argsort' is called via the 'numpy' library, the
first parameter in its signature is 'axis', which takes either
an integer or 'None', so check if the 'ascending' parameter has
either integer type or is None, since 'ascending' itself should
be a boolean
"""
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, 47; 44, 94; 45, expression_statement; 45, 46; 46, comment; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:op; 50, call; 50, 51; 50, 52; 51, identifier:_AsOfMerge; 52, argument_list; 52, 53; 52, 54; 52, 55; 52, 58; 52, 61; 52, 64; 52, 67; 52, 70; 52, 73; 52, 76; 52, 79; 52, 82; 52, 85; 52, 88; 52, 91; 53, identifier:left; 54, identifier:right; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:on; 57, identifier:on; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:left_on; 60, identifier:left_on; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:right_on; 63, identifier:right_on; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:left_index; 66, identifier:left_index; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:right_index; 69, identifier:right_index; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:by; 72, identifier:by; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:left_by; 75, identifier:left_by; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:right_by; 78, identifier:right_by; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:suffixes; 81, identifier:suffixes; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:how; 84, string:'asof'; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:tolerance; 87, identifier:tolerance; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:allow_exact_matches; 90, identifier:allow_exact_matches; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:direction; 93, identifier:direction; 94, return_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:op; 98, identifier:get_result; 99, 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'):
"""Perform an asof merge. This is similar to a left-join except that we
match on nearest key rather than equal keys.
Both DataFrames must be sorted by the key.
For each row in the left DataFrame:
- A "backward" search selects the last row in the right DataFrame whose
'on' key is less than or equal to the left's key.
- A "forward" search selects the first row in the right DataFrame whose
'on' key is greater than or equal to the left's key.
- A "nearest" search selects the row in the right DataFrame whose 'on'
key is closest in absolute distance to the left's key.
The default is "backward" and is compatible in versions below 0.20.0.
The direction parameter was added in version 0.20.0 and introduces
"forward" and "nearest".
Optionally match on equivalent keys with 'by' before searching with 'on'.
.. versionadded:: 0.19.0
Parameters
----------
left : DataFrame
right : DataFrame
on : label
Field name to join on. Must be found in both DataFrames.
The data MUST be ordered. Furthermore this must be a numeric column,
such as datetimelike, integer, or float. On or left_on/right_on
must be given.
left_on : label
Field name to join on in left DataFrame.
right_on : label
Field name to join on in right DataFrame.
left_index : boolean
Use the index of the left DataFrame as the join key.
.. versionadded:: 0.19.2
right_index : boolean
Use the index of the right DataFrame as the join key.
.. versionadded:: 0.19.2
by : column name or list of column names
Match on these columns before performing merge operation.
left_by : column name
Field names to match on in the left DataFrame.
.. versionadded:: 0.19.2
right_by : column name
Field names to match on in the right DataFrame.
.. versionadded:: 0.19.2
suffixes : 2-length sequence (tuple, list, ...)
Suffix to apply to overlapping column names in the left and right
side, respectively.
tolerance : integer or Timedelta, optional, default None
Select asof tolerance within this range; must be compatible
with the merge index.
allow_exact_matches : boolean, default True
- If True, allow matching with the same 'on' value
(i.e. less-than-or-equal-to / greater-than-or-equal-to)
- If False, don't match the same 'on' value
(i.e., strictly less-than / strictly greater-than)
direction : 'backward' (default), 'forward', or 'nearest'
Whether to search for prior, subsequent, or closest matches.
.. versionadded:: 0.20.0
Returns
-------
merged : DataFrame
See Also
--------
merge
merge_ordered
Examples
--------
>>> left = pd.DataFrame({'a': [1, 5, 10], 'left_val': ['a', 'b', 'c']})
>>> left
a left_val
0 1 a
1 5 b
2 10 c
>>> right = pd.DataFrame({'a': [1, 2, 3, 6, 7],
... 'right_val': [1, 2, 3, 6, 7]})
>>> right
a right_val
0 1 1
1 2 2
2 3 3
3 6 6
4 7 7
>>> pd.merge_asof(left, right, on='a')
a left_val right_val
0 1 a 1
1 5 b 3
2 10 c 7
>>> pd.merge_asof(left, right, on='a', allow_exact_matches=False)
a left_val right_val
0 1 a NaN
1 5 b 3.0
2 10 c 7.0
>>> pd.merge_asof(left, right, on='a', direction='forward')
a left_val right_val
0 1 a 1.0
1 5 b 6.0
2 10 c NaN
>>> pd.merge_asof(left, right, on='a', direction='nearest')
a left_val right_val
0 1 a 1
1 5 b 6
2 10 c 7
We can use indexed DataFrames as well.
>>> left = pd.DataFrame({'left_val': ['a', 'b', 'c']}, index=[1, 5, 10])
>>> left
left_val
1 a
5 b
10 c
>>> right = pd.DataFrame({'right_val': [1, 2, 3, 6, 7]},
... index=[1, 2, 3, 6, 7])
>>> right
right_val
1 1
2 2
3 3
6 6
7 7
>>> pd.merge_asof(left, right, left_index=True, right_index=True)
left_val right_val
1 a 1
5 b 3
10 c 7
Here is a real-world times-series example
>>> quotes
time ticker bid ask
0 2016-05-25 13:30:00.023 GOOG 720.50 720.93
1 2016-05-25 13:30:00.023 MSFT 51.95 51.96
2 2016-05-25 13:30:00.030 MSFT 51.97 51.98
3 2016-05-25 13:30:00.041 MSFT 51.99 52.00
4 2016-05-25 13:30:00.048 GOOG 720.50 720.93
5 2016-05-25 13:30:00.049 AAPL 97.99 98.01
6 2016-05-25 13:30:00.072 GOOG 720.50 720.88
7 2016-05-25 13:30:00.075 MSFT 52.01 52.03
>>> trades
time ticker price quantity
0 2016-05-25 13:30:00.023 MSFT 51.95 75
1 2016-05-25 13:30:00.038 MSFT 51.95 155
2 2016-05-25 13:30:00.048 GOOG 720.77 100
3 2016-05-25 13:30:00.048 GOOG 720.92 100
4 2016-05-25 13:30:00.048 AAPL 98.00 100
By default we are taking the asof of the quotes
>>> pd.merge_asof(trades, quotes,
... on='time',
... by='ticker')
time ticker price quantity bid ask
0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96
1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98
2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
We only asof within 2ms between the quote time and the trade time
>>> pd.merge_asof(trades, quotes,
... on='time',
... by='ticker',
... tolerance=pd.Timedelta('2ms'))
time ticker price quantity bid ask
0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96
1 2016-05-25 13:30:00.038 MSFT 51.95 155 NaN NaN
2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93
3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93
4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
We only asof within 10ms between the quote time and the trade time
and we exclude exact matches on time. However *prior* data will
propagate forward
>>> pd.merge_asof(trades, quotes,
... on='time',
... by='ticker',
... tolerance=pd.Timedelta('10ms'),
... allow_exact_matches=False)
time ticker price quantity bid ask
0 2016-05-25 13:30:00.023 MSFT 51.95 75 NaN NaN
1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98
2 2016-05-25 13:30:00.048 GOOG 720.77 100 NaN NaN
3 2016-05-25 13:30:00.048 GOOG 720.92 100 NaN NaN
4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN
"""
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, 79; 8, 87; 8, 101; 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, comment; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:all_modules; 82, binary_operator:+; 82, 83; 82, 86; 83, binary_operator:+; 83, 84; 83, 85; 84, identifier:module_names; 85, identifier:nb_imports; 86, identifier:parent_modules; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:mods; 90, list_comprehension; 90, 91; 90, 98; 91, call; 91, 92; 91, 93; 92, identifier:import_mod; 93, argument_list; 93, 94; 93, 95; 94, identifier:m; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:ignore_errors; 97, True; 98, for_in_clause; 98, 99; 98, 100; 99, identifier:m; 100, identifier:all_modules; 101, return_statement; 101, 102; 102, list_comprehension; 102, 103; 102, 104; 102, 107; 103, identifier:m; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:m; 106, identifier:mods; 107, if_clause; 107, 108; 108, comparison_operator:is; 108, 109; 108, 110; 109, identifier:m; 110, 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)] # Imports parent modules - a.b.c = [a, a.b, a.b.c]
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, 26; 23, 38; 23, 58; 23, 65; 23, 84; 23, 88; 23, 96; 23, 104; 23, 112; 23, 120; 23, 142; 24, expression_statement; 24, 25; 25, comment; 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:tokens; 31, identifier:str; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:ValueError; 36, argument_list; 36, 37; 37, string:"Expected to receive a list of tokens. Received a string instead"; 38, if_statement; 38, 39; 38, 46; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:tokens; 44, integer:0; 45, identifier:list; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:tokens; 50, list_comprehension; 50, 51; 50, 52; 50, 55; 51, identifier:p; 52, for_in_clause; 52, 53; 52, 54; 53, identifier:o; 54, identifier:tokens; 55, for_in_clause; 55, 56; 55, 57; 56, identifier:p; 57, identifier:o; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:freq; 61, call; 61, 62; 61, 63; 62, identifier:Counter; 63, argument_list; 63, 64; 64, identifier:tokens; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:int2tok; 68, list_comprehension; 68, 69; 68, 70; 68, 80; 69, identifier:o; 70, for_in_clause; 70, 71; 70, 74; 71, pattern_list; 71, 72; 71, 73; 72, identifier:o; 73, identifier:c; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:freq; 77, identifier:most_common; 78, argument_list; 78, 79; 79, identifier:max_vocab; 80, if_clause; 80, 81; 81, comparison_operator:>; 81, 82; 81, 83; 82, identifier:c; 83, identifier:min_freq; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:unk_id; 87, integer:3; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:int2tok; 92, identifier:insert; 93, argument_list; 93, 94; 93, 95; 94, integer:0; 95, identifier:bos_tok; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:int2tok; 100, identifier:insert; 101, argument_list; 101, 102; 101, 103; 102, integer:1; 103, identifier:pad_tok; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:int2tok; 108, identifier:insert; 109, argument_list; 109, 110; 109, 111; 110, integer:2; 111, identifier:eos_tok; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:int2tok; 116, identifier:insert; 117, argument_list; 117, 118; 117, 119; 118, identifier:unk_id; 119, identifier:unk_tok; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:tok2int; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:collections; 126, identifier:defaultdict; 127, argument_list; 127, 128; 127, 130; 128, lambda; 128, 129; 129, identifier:unk_id; 130, dictionary_comprehension; 130, 131; 130, 134; 131, pair; 131, 132; 131, 133; 132, identifier:v; 133, identifier:k; 134, for_in_clause; 134, 135; 134, 138; 135, pattern_list; 135, 136; 135, 137; 136, identifier:k; 137, identifier:v; 138, call; 138, 139; 138, 140; 139, identifier:enumerate; 140, argument_list; 140, 141; 141, identifier:int2tok; 142, return_statement; 142, 143; 143, expression_list; 143, 144; 143, 145; 144, identifier:int2tok; 145, identifier:tok2int | def numericalize_tok(tokens, max_vocab=50000, min_freq=0, unk_tok="_unk_", pad_tok="_pad_", bos_tok="_bos_", eos_tok="_eos_"):
"""Takes in text tokens and returns int2tok and tok2int converters
Arguments:
tokens(list): List of tokens. Can be a list of strings, or a list of lists of strings.
max_vocab(int): Number of tokens to return in the vocab (sorted by frequency)
min_freq(int): Minimum number of instances a token must be present in order to be preserved.
unk_tok(str): Token to use when unknown tokens are encountered in the source text.
pad_tok(str): Token to use when padding sequences.
"""
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, 9; 6, 13; 6, 31; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:d; 12, dictionary; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:token; 15, identifier:my_list; 16, block; 16, 17; 16, 25; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:d; 21, identifier:setdefault; 22, argument_list; 22, 23; 22, 24; 23, identifier:token; 24, integer:0; 25, expression_statement; 25, 26; 26, augmented_assignment:+=; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:d; 29, identifier:token; 30, integer:1; 31, return_statement; 31, 32; 32, subscript; 32, 33; 32, 52; 33, call; 33, 34; 33, 35; 34, identifier:sorted; 35, argument_list; 35, 36; 35, 41; 35, 49; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:d; 39, identifier:items; 40, argument_list; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:key; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:operator; 46, identifier:itemgetter; 47, argument_list; 47, 48; 48, integer:1; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:reverse; 51, True; 52, slice; 52, 53; 52, 54; 53, colon; 54, identifier:print_total_threshold | def get_freq_tuples(my_list, print_total_threshold):
""" Turn a list of errors into frequency-sorted tuples thresholded by a certain total number """
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, 9; 6, 29; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:levels; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:map; 17, argument_list; 17, 18; 17, 28; 18, lambda; 18, 19; 18, 21; 19, lambda_parameters; 19, 20; 20, identifier:arc; 21, binary_operator:-; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:arc; 24, string:"end"; 25, subscript; 25, 26; 25, 27; 26, identifier:arc; 27, string:"start"; 28, identifier:arcs; 29, return_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:sorted; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:list; 35, argument_list; 35, 36; 36, identifier:levels | def get_levels(self, arcs):
"""Calculate available arc height "levels".
Used to calculate arrow heights dynamically and without wasting space.
args (list): Individual arcs and their start, end, direction and label.
RETURNS (list): Arc levels sorted from lowest to highest.
"""
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, 8; 5, 24; 5, 47; 5, 62; 5, 90; 6, expression_statement; 6, 7; 7, comment; 8, try_statement; 8, 9; 8, 20; 9, block; 9, 10; 9, 17; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:first_command; 13, call; 13, 14; 13, 15; 14, identifier:next; 15, argument_list; 15, 16; 16, identifier:corrected_commands; 17, expression_statement; 17, 18; 18, yield; 18, 19; 19, identifier:first_command; 20, except_clause; 20, 21; 20, 22; 21, identifier:StopIteration; 22, block; 22, 23; 23, return_statement; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:without_duplicates; 27, set_comprehension; 27, 28; 27, 29; 27, 43; 28, identifier:command; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:command; 31, call; 31, 32; 31, 33; 32, identifier:sorted; 33, argument_list; 33, 34; 33, 35; 34, identifier:corrected_commands; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:key; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:command; 40, attribute; 40, 41; 40, 42; 41, identifier:command; 42, identifier:priority; 43, if_clause; 43, 44; 44, comparison_operator:!=; 44, 45; 44, 46; 45, identifier:command; 46, identifier:first_command; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:sorted_commands; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 52, 54; 53, identifier:without_duplicates; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:key; 56, lambda; 56, 57; 56, 59; 57, lambda_parameters; 57, 58; 58, identifier:corrected_command; 59, attribute; 59, 60; 59, 61; 60, identifier:corrected_command; 61, identifier:priority; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:logs; 66, identifier:debug; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:'Corrected commands: '; 71, identifier:format; 72, argument_list; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, string:', '; 76, identifier:join; 77, generator_expression; 77, 78; 77, 84; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, string:u'{}'; 81, identifier:format; 82, argument_list; 82, 83; 83, identifier:cmd; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:cmd; 86, binary_operator:+; 86, 87; 86, 89; 87, list:[first_command]; 87, 88; 88, identifier:first_command; 89, identifier:sorted_commands; 90, for_statement; 90, 91; 90, 92; 90, 93; 91, identifier:command; 92, identifier:sorted_commands; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, yield; 95, 96; 96, identifier:command | def organize_commands(corrected_commands):
"""Yields sorted commands without duplicates.
:type corrected_commands: Iterable[thefuck.types.CorrectedCommand]
:rtype: Iterable[thefuck.types.CorrectedCommand]
"""
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, 8; 5, 33; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:corrected_commands; 11, generator_expression; 11, 12; 11, 13; 11, 18; 11, 25; 12, identifier:corrected; 13, for_in_clause; 13, 14; 13, 15; 14, identifier:rule; 15, call; 15, 16; 15, 17; 16, identifier:get_rules; 17, argument_list; 18, if_clause; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:rule; 22, identifier:is_match; 23, argument_list; 23, 24; 24, identifier:command; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:corrected; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:rule; 30, identifier:get_corrected_commands; 31, argument_list; 31, 32; 32, identifier:command; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:organize_commands; 36, argument_list; 36, 37; 37, identifier:corrected_commands | def get_corrected_commands(command):
"""Returns generator with sorted and unique corrected commands.
:type command: thefuck.types.Command
:rtype: Iterable[thefuck.types.CorrectedCommand]
"""
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, 18; 15, 30; 15, 34; 15, 71; 15, 75; 15, 111; 15, 120; 16, expression_statement; 16, 17; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:limit_clause; 21, conditional_expression:if; 21, 22; 21, 28; 21, 29; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, string:'LIMIT {}'; 25, identifier:format; 26, argument_list; 26, 27; 27, identifier:limit; 28, identifier:limit; 29, string:''; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:order_by_clause; 33, string:''; 34, if_statement; 34, 35; 34, 36; 35, identifier:order_by; 36, block; 36, 37; 36, 41; 36, 42; 36, 60; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:l; 40, list:[]; 41, comment; 42, for_statement; 42, 43; 42, 46; 42, 47; 43, pattern_list; 43, 44; 43, 45; 44, identifier:field; 45, identifier:desc; 46, identifier:order_by; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:l; 52, identifier:append; 53, argument_list; 53, 54; 54, conditional_expression:if; 54, 55; 54, 58; 54, 59; 55, binary_operator:+; 55, 56; 55, 57; 56, identifier:field; 57, string:' DESC'; 58, identifier:desc; 59, string:''; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:order_by_clause; 63, binary_operator:+; 63, 64; 63, 65; 64, string:'ORDER BY '; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, string:', '; 68, identifier:join; 69, argument_list; 69, 70; 70, identifier:l; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:where_clause; 74, string:''; 75, if_statement; 75, 76; 75, 77; 76, identifier:filters; 77, block; 77, 78; 77, 82; 77, 83; 77, 100; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:l; 81, list:[]; 82, comment; 83, for_statement; 83, 84; 83, 87; 83, 92; 84, pattern_list; 84, 85; 84, 86; 85, identifier:field; 86, identifier:value; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:filters; 90, identifier:items; 91, argument_list; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:l; 97, identifier:append; 98, argument_list; 98, 99; 99, string:f"{field} = '{value}'"; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:where_clause; 103, binary_operator:+; 103, 104; 103, 105; 104, string:'WHERE '; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, string:' AND '; 108, identifier:join; 109, argument_list; 109, 110; 110, identifier:l; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:sql; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:textwrap; 117, identifier:dedent; 118, argument_list; 118, 119; 119, comment; 120, return_statement; 120, 121; 121, identifier:sql | def _partition_query(
cls, table_name, limit=0, order_by=None, filters=None):
"""Returns a partition query
:param table_name: the name of the table to get partitions from
:type table_name: str
:param limit: the number of partitions to be returned
:type limit: int
:param order_by: a list of tuples of field name and a boolean
that determines if that field should be sorted in descending
order
:type order_by: list of (str, bool) tuples
:param filters: dict of field name and filter value combinations
"""
limit_clause = 'LIMIT {}'.format(limit) if limit else ''
order_by_clause = ''
if order_by:
l = [] # noqa: E741
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 = [] # noqa: E741
for field, value in filters.items():
l.append(f"{field} = '{value}'")
where_clause = 'WHERE ' + ' AND '.join(l)
sql = textwrap.dedent(f"""\
SELECT * FROM "{table_name}$partitions"
{where_clause}
{order_by_clause}
{limit_clause}
""")
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, 8; 5, 30; 5, 37; 5, 41; 5, 125; 6, expression_statement; 6, 7; 7, comment; 8, function_definition; 8, 9; 8, 10; 8, 13; 9, function_name:swap; 10, parameters; 10, 11; 10, 12; 11, identifier:i; 12, identifier:j; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 23; 16, pattern_list; 16, 17; 16, 20; 17, subscript; 17, 18; 17, 19; 18, identifier:arr; 19, identifier:i; 20, subscript; 20, 21; 20, 22; 21, identifier:arr; 22, identifier:j; 23, expression_list; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:arr; 26, identifier:j; 27, subscript; 27, 28; 27, 29; 28, identifier:arr; 29, identifier:i; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:n; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:arr; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:swapped; 40, True; 41, while_statement; 41, 42; 41, 43; 42, identifier:swapped; 43, block; 43, 44; 43, 48; 43, 79; 43, 86; 43, 90; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:swapped; 47, False; 48, for_statement; 48, 49; 48, 50; 48, 55; 49, identifier:i; 50, call; 50, 51; 50, 52; 51, identifier:range; 52, argument_list; 52, 53; 52, 54; 53, integer:1; 54, identifier:n; 55, block; 55, 56; 56, if_statement; 56, 57; 56, 66; 57, comparison_operator:>; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 60; 59, identifier:arr; 60, binary_operator:-; 60, 61; 60, 62; 61, identifier:i; 62, integer:1; 63, subscript; 63, 64; 63, 65; 64, identifier:arr; 65, identifier:i; 66, block; 66, 67; 66, 75; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:swap; 70, argument_list; 70, 71; 70, 74; 71, binary_operator:-; 71, 72; 71, 73; 72, identifier:i; 73, integer:1; 74, identifier:i; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:swapped; 78, True; 79, if_statement; 79, 80; 79, 83; 80, comparison_operator:==; 80, 81; 80, 82; 81, identifier:swapped; 82, False; 83, block; 83, 84; 84, return_statement; 84, 85; 85, identifier:arr; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:swapped; 89, False; 90, for_statement; 90, 91; 90, 92; 90, 101; 91, identifier:i; 92, call; 92, 93; 92, 94; 93, identifier:range; 94, argument_list; 94, 95; 94, 98; 94, 99; 95, binary_operator:-; 95, 96; 95, 97; 96, identifier:n; 97, integer:1; 98, integer:0; 99, unary_operator:-; 99, 100; 100, integer:1; 101, block; 101, 102; 102, if_statement; 102, 103; 102, 112; 103, comparison_operator:>; 103, 104; 103, 109; 104, subscript; 104, 105; 104, 106; 105, identifier:arr; 106, binary_operator:-; 106, 107; 106, 108; 107, identifier:i; 108, integer:1; 109, subscript; 109, 110; 109, 111; 110, identifier:arr; 111, identifier:i; 112, block; 112, 113; 112, 121; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:swap; 116, argument_list; 116, 117; 116, 120; 117, binary_operator:-; 117, 118; 117, 119; 118, identifier:i; 119, integer:1; 120, identifier:i; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:swapped; 124, True; 125, return_statement; 125, 126; 126, identifier:arr | def cocktail_shaker_sort(arr):
"""
Cocktail_shaker_sort
Sorting a given array
mutation of bubble sort
reference: https://en.wikipedia.org/wiki/Cocktail_shaker_sort
Worst-case performance: O(N^2)
"""
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, 11; 8, 20; 8, 21; 8, 126; 8, 142; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:last_parent; 14, binary_operator://; 14, 15; 14, 19; 15, parenthesized_expression; 15, 16; 16, binary_operator:-; 16, 17; 16, 18; 17, identifier:end; 18, integer:1; 19, integer:2; 20, comment; 21, for_statement; 21, 22; 21, 23; 21, 31; 22, identifier:parent; 23, call; 23, 24; 23, 25; 24, identifier:range; 25, argument_list; 25, 26; 25, 27; 25, 29; 26, identifier:last_parent; 27, unary_operator:-; 27, 28; 28, integer:1; 29, unary_operator:-; 29, 30; 30, integer:1; 31, block; 31, 32; 31, 36; 31, 37; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:current_parent; 35, identifier:parent; 36, comment; 37, while_statement; 37, 38; 37, 41; 37, 42; 38, comparison_operator:<=; 38, 39; 38, 40; 39, identifier:current_parent; 40, identifier:last_parent; 41, comment; 42, block; 42, 43; 42, 51; 42, 74; 42, 75; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:child; 46, binary_operator:+; 46, 47; 46, 50; 47, binary_operator:*; 47, 48; 47, 49; 48, integer:2; 49, identifier:current_parent; 50, integer:1; 51, if_statement; 51, 52; 51, 67; 52, boolean_operator:and; 52, 53; 52, 58; 53, comparison_operator:<=; 53, 54; 53, 57; 54, binary_operator:+; 54, 55; 54, 56; 55, identifier:child; 56, integer:1; 57, identifier:end; 58, comparison_operator:<; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:arr; 61, identifier:child; 62, subscript; 62, 63; 62, 64; 63, identifier:arr; 64, binary_operator:+; 64, 65; 64, 66; 65, identifier:child; 66, integer:1; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:child; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:child; 73, integer:1; 74, comment; 75, if_statement; 75, 76; 75, 83; 75, 122; 75, 123; 76, comparison_operator:>; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:arr; 79, identifier:child; 80, subscript; 80, 81; 80, 82; 81, identifier:arr; 82, identifier:current_parent; 83, block; 83, 84; 83, 100; 83, 104; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 93; 86, pattern_list; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:arr; 89, identifier:current_parent; 90, subscript; 90, 91; 90, 92; 91, identifier:arr; 92, identifier:child; 93, expression_list; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:arr; 96, identifier:child; 97, subscript; 97, 98; 97, 99; 98, identifier:arr; 99, identifier:current_parent; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:current_parent; 103, identifier:child; 104, if_statement; 104, 105; 104, 106; 105, identifier:simulation; 106, block; 106, 107; 106, 113; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:iteration; 110, binary_operator:+; 110, 111; 110, 112; 111, identifier:iteration; 112, integer:1; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:print; 116, argument_list; 116, 117; 116, 118; 116, 119; 116, 120; 117, string:"iteration"; 118, identifier:iteration; 119, string:":"; 120, list_splat; 120, 121; 121, identifier:arr; 122, comment; 123, else_clause; 123, 124; 124, block; 124, 125; 125, break_statement; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 135; 128, pattern_list; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:arr; 131, integer:0; 132, subscript; 132, 133; 132, 134; 133, identifier:arr; 134, identifier:end; 135, expression_list; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:arr; 138, identifier:end; 139, subscript; 139, 140; 139, 141; 140, identifier:arr; 141, integer:0; 142, return_statement; 142, 143; 143, identifier:iteration | def max_heapify(arr, end, simulation, iteration):
""" Max heapify helper for max_heap_sort
"""
last_parent = (end - 1) // 2
# Iterate from last parent to first
for parent in range(last_parent, -1, -1):
current_parent = parent
# Iterate from current_parent to last_parent
while current_parent <= last_parent:
# Find greatest child of current_parent
child = 2 * current_parent + 1
if child + 1 <= end and arr[child] < arr[child + 1]:
child = child + 1
# Swap if child is greater than parent
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)
# If no swap occured, no need to keep iterating
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, 11; 8, 12; 8, 13; 8, 22; 8, 33; 8, 34; 8, 158; 9, expression_statement; 9, 10; 10, comment; 11, comment; 12, comment; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:end; 16, binary_operator:-; 16, 17; 16, 21; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, identifier:arr; 21, integer:1; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:last_parent; 25, binary_operator://; 25, 26; 25, 32; 26, parenthesized_expression; 26, 27; 27, binary_operator:-; 27, 28; 27, 31; 28, binary_operator:-; 28, 29; 28, 30; 29, identifier:end; 30, identifier:start; 31, integer:1; 32, integer:2; 33, comment; 34, for_statement; 34, 35; 34, 36; 34, 44; 35, identifier:parent; 36, call; 36, 37; 36, 38; 37, identifier:range; 38, argument_list; 38, 39; 38, 40; 38, 42; 39, identifier:last_parent; 40, unary_operator:-; 40, 41; 41, integer:1; 42, unary_operator:-; 42, 43; 43, integer:1; 44, block; 44, 45; 44, 49; 44, 50; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:current_parent; 48, identifier:parent; 49, comment; 50, while_statement; 50, 51; 50, 54; 50, 55; 51, comparison_operator:<=; 51, 52; 51, 53; 52, identifier:current_parent; 53, identifier:last_parent; 54, comment; 55, block; 55, 56; 55, 64; 55, 93; 55, 94; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:child; 59, binary_operator:+; 59, 60; 59, 63; 60, binary_operator:*; 60, 61; 60, 62; 61, integer:2; 62, identifier:current_parent; 63, integer:1; 64, if_statement; 64, 65; 64, 86; 65, boolean_operator:and; 65, 66; 65, 73; 66, comparison_operator:<=; 66, 67; 66, 70; 67, binary_operator:+; 67, 68; 67, 69; 68, identifier:child; 69, integer:1; 70, binary_operator:-; 70, 71; 70, 72; 71, identifier:end; 72, identifier:start; 73, comparison_operator:>; 73, 74; 73, 79; 74, subscript; 74, 75; 74, 76; 75, identifier:arr; 76, binary_operator:+; 76, 77; 76, 78; 77, identifier:child; 78, identifier:start; 79, subscript; 79, 80; 79, 81; 80, identifier:arr; 81, binary_operator:+; 81, 82; 81, 85; 82, binary_operator:+; 82, 83; 82, 84; 83, identifier:child; 84, integer:1; 85, identifier:start; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:child; 90, binary_operator:+; 90, 91; 90, 92; 91, identifier:child; 92, integer:1; 93, comment; 94, if_statement; 94, 95; 94, 106; 94, 154; 94, 155; 95, comparison_operator:<; 95, 96; 95, 101; 96, subscript; 96, 97; 96, 98; 97, identifier:arr; 98, binary_operator:+; 98, 99; 98, 100; 99, identifier:child; 100, identifier:start; 101, subscript; 101, 102; 101, 103; 102, identifier:arr; 103, binary_operator:+; 103, 104; 103, 105; 104, identifier:current_parent; 105, identifier:start; 106, block; 106, 107; 106, 132; 106, 136; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 120; 108, 121; 109, pattern_list; 109, 110; 109, 115; 110, subscript; 110, 111; 110, 112; 111, identifier:arr; 112, binary_operator:+; 112, 113; 112, 114; 113, identifier:current_parent; 114, identifier:start; 115, subscript; 115, 116; 115, 117; 116, identifier:arr; 117, binary_operator:+; 117, 118; 117, 119; 118, identifier:child; 119, identifier:start; 120, line_continuation:\; 121, expression_list; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 124; 123, identifier:arr; 124, binary_operator:+; 124, 125; 124, 126; 125, identifier:child; 126, identifier:start; 127, subscript; 127, 128; 127, 129; 128, identifier:arr; 129, binary_operator:+; 129, 130; 129, 131; 130, identifier:current_parent; 131, identifier:start; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:current_parent; 135, identifier:child; 136, if_statement; 136, 137; 136, 138; 137, identifier:simulation; 138, block; 138, 139; 138, 145; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:iteration; 142, binary_operator:+; 142, 143; 142, 144; 143, identifier:iteration; 144, integer:1; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:print; 148, argument_list; 148, 149; 148, 150; 148, 151; 148, 152; 149, string:"iteration"; 150, identifier:iteration; 151, string:":"; 152, list_splat; 152, 153; 153, identifier:arr; 154, comment; 155, else_clause; 155, 156; 156, block; 156, 157; 157, break_statement; 158, return_statement; 158, 159; 159, identifier:iteration | def min_heapify(arr, start, simulation, iteration):
""" Min heapify helper for min_heap_sort
"""
# Offset last_parent by the start (last_parent calculated as if start index was 0)
# All array accesses need to be offset by start
end = len(arr) - 1
last_parent = (end - start - 1) // 2
# Iterate from last parent to first
for parent in range(last_parent, -1, -1):
current_parent = parent
# Iterate from current_parent to last_parent
while current_parent <= last_parent:
# Find lesser child of current_parent
child = 2 * current_parent + 1
if child + 1 <= end - start and arr[child + start] > arr[
child + 1 + start]:
child = child + 1
# Swap if child is less than parent
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)
# If no swap occured, no need to keep iterating
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, 8; 5, 15; 5, 22; 5, 102; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:len_arr; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:arr; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:<=; 16, 17; 16, 18; 17, identifier:len_arr; 18, integer:1; 19, block; 19, 20; 20, return_statement; 20, 21; 21, identifier:arr; 22, for_statement; 22, 23; 22, 24; 22, 34; 22, 35; 23, identifier:cur; 24, call; 24, 25; 24, 26; 25, identifier:range; 26, argument_list; 26, 27; 26, 31; 26, 32; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:arr; 31, integer:1; 32, unary_operator:-; 32, 33; 33, integer:1; 34, comment; 35, block; 35, 36; 35, 53; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:index_max; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:arr; 42, identifier:index; 43, argument_list; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:max; 46, argument_list; 46, 47; 47, subscript; 47, 48; 47, 49; 48, identifier:arr; 49, slice; 49, 50; 49, 51; 49, 52; 50, integer:0; 51, colon; 52, identifier:cur; 53, if_statement; 53, 54; 53, 59; 53, 60; 54, comparison_operator:!=; 54, 55; 54, 58; 55, binary_operator:+; 55, 56; 55, 57; 56, identifier:index_max; 57, integer:1; 58, identifier:cur; 59, comment; 60, block; 60, 61; 60, 86; 60, 87; 61, if_statement; 61, 62; 61, 65; 61, 66; 62, comparison_operator:!=; 62, 63; 62, 64; 63, identifier:index_max; 64, integer:0; 65, comment; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 76; 69, subscript; 69, 70; 69, 71; 70, identifier:arr; 71, slice; 71, 72; 71, 73; 72, colon; 73, binary_operator:+; 73, 74; 73, 75; 74, identifier:index_max; 75, integer:1; 76, call; 76, 77; 76, 78; 77, identifier:reversed; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:arr; 81, slice; 81, 82; 81, 83; 82, colon; 83, binary_operator:+; 83, 84; 83, 85; 84, identifier:index_max; 85, integer:1; 86, comment; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 94; 89, subscript; 89, 90; 89, 91; 90, identifier:arr; 91, slice; 91, 92; 91, 93; 92, colon; 93, identifier:cur; 94, call; 94, 95; 94, 96; 95, identifier:reversed; 96, argument_list; 96, 97; 97, subscript; 97, 98; 97, 99; 98, identifier:arr; 99, slice; 99, 100; 99, 101; 100, colon; 101, identifier:cur; 102, return_statement; 102, 103; 103, identifier:arr | def pancake_sort(arr):
"""
Pancake_sort
Sorting a given array
mutation of selection sort
reference: https://www.geeksforgeeks.org/pancake-sorting/
Overall time complexity : O(N^2)
"""
len_arr = len(arr)
if len_arr <= 1:
return arr
for cur in range(len(arr), 1, -1):
#Finding index of maximum number in arr
index_max = arr.index(max(arr[0:cur]))
if index_max+1 != cur:
#Needs moving
if index_max != 0:
#reverse from 0 to index_max
arr[:index_max+1] = reversed(arr[:index_max+1])
# Reverse list
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, 14; 11, 57; 11, 64; 12, expression_statement; 12, 13; 13, comment; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:get_alphanum_key_func; 16, parameters; 16, 17; 17, identifier:key; 18, block; 18, 19; 18, 36; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:convert; 22, lambda; 22, 23; 22, 25; 23, lambda_parameters; 23, 24; 24, identifier:text; 25, conditional_expression:if; 25, 26; 25, 30; 25, 35; 26, call; 26, 27; 26, 28; 27, identifier:int; 28, argument_list; 28, 29; 29, identifier:text; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:text; 33, identifier:isdigit; 34, argument_list; 35, identifier:text; 36, return_statement; 36, 37; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:s; 40, list_comprehension; 40, 41; 40, 45; 41, call; 41, 42; 41, 43; 42, identifier:convert; 43, argument_list; 43, 44; 44, identifier:c; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:c; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:re; 50, identifier:split; 51, argument_list; 51, 52; 51, 53; 52, string:'([0-9]+)'; 53, call; 53, 54; 53, 55; 54, identifier:key; 55, argument_list; 55, 56; 56, identifier:s; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:sort_key; 60, call; 60, 61; 60, 62; 61, identifier:get_alphanum_key_func; 62, argument_list; 62, 63; 63, identifier:key; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:list; 68, identifier:sort; 69, argument_list; 69, 70; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:key; 72, identifier:sort_key | def natural_sort(list, key=lambda s:s):
"""
Sort the list into natural alphanumeric order.
"""
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, 10; 7, 17; 7, 26; 7, 50; 7, 63; 7, 71; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:data; 13, call; 13, 14; 13, 15; 14, identifier:_read_words; 15, argument_list; 15, 16; 16, identifier:filename; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:counter; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:collections; 23, identifier:Counter; 24, argument_list; 24, 25; 25, identifier:data; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:count_pairs; 29, call; 29, 30; 29, 31; 30, identifier:sorted; 31, argument_list; 31, 32; 31, 37; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:counter; 35, identifier:items; 36, argument_list; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:key; 39, lambda; 39, 40; 39, 42; 40, lambda_parameters; 40, 41; 41, identifier:x; 42, tuple; 42, 43; 42, 47; 43, unary_operator:-; 43, 44; 44, subscript; 44, 45; 44, 46; 45, identifier:x; 46, integer:1; 47, subscript; 47, 48; 47, 49; 48, identifier:x; 49, integer:0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:words; 54, identifier:_; 55, call; 55, 56; 55, 57; 56, identifier:list; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:zip; 60, argument_list; 60, 61; 61, list_splat; 61, 62; 62, identifier:count_pairs; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:words; 66, subscript; 66, 67; 66, 68; 67, identifier:words; 68, slice; 68, 69; 68, 70; 69, colon; 70, identifier:vocab_size; 71, with_statement; 71, 72; 71, 82; 72, with_clause; 72, 73; 73, with_item; 73, 74; 74, as_pattern; 74, 75; 74, 80; 75, call; 75, 76; 75, 77; 76, identifier:open; 77, argument_list; 77, 78; 77, 79; 78, identifier:vocab_path; 79, string:"w"; 80, as_pattern_target; 80, 81; 81, identifier:f; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:f; 87, identifier:write; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, string:"\n"; 92, identifier:join; 93, argument_list; 93, 94; 94, identifier:words | def _build_vocab(filename, vocab_path, vocab_size):
"""Reads a file to build a vocabulary of `vocab_size` most common words.
The vocabulary is sorted by occurrence count and has one word per line.
Originally from:
https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/reader.py
Args:
filename: file to read list of words from.
vocab_path: path where to save the vocabulary.
vocab_size: size of the vocabulary to generate.
"""
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, 14; 11, 18; 11, 122; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:stepfiles; 17, list:[]; 18, for_statement; 18, 19; 18, 20; 18, 28; 19, identifier:filename; 20, call; 20, 21; 20, 22; 21, identifier:_try_twice_tf_glob; 22, argument_list; 22, 23; 23, binary_operator:+; 23, 24; 23, 27; 24, binary_operator:+; 24, 25; 24, 26; 25, identifier:path_prefix; 26, string:"*-[0-9]*"; 27, identifier:path_suffix; 28, block; 28, 29; 28, 44; 28, 66; 28, 72; 28, 95; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:basename; 32, conditional_expression:if; 32, 33; 32, 42; 32, 43; 33, subscript; 33, 34; 33, 35; 34, identifier:filename; 35, slice; 35, 36; 35, 37; 36, colon; 37, unary_operator:-; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:path_suffix; 42, identifier:path_suffix; 43, identifier:filename; 44, try_statement; 44, 45; 44, 61; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:steps; 49, call; 49, 50; 49, 51; 50, identifier:int; 51, argument_list; 51, 52; 52, subscript; 52, 53; 52, 59; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:basename; 56, identifier:rsplit; 57, argument_list; 57, 58; 58, string:"-"; 59, unary_operator:-; 59, 60; 60, integer:1; 61, except_clause; 61, 62; 61, 63; 61, 64; 62, identifier:ValueError; 63, comment; 64, block; 64, 65; 65, continue_statement; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:<; 67, 68; 67, 69; 68, identifier:steps; 69, identifier:min_steps; 70, block; 70, 71; 71, continue_statement; 72, if_statement; 72, 73; 72, 82; 73, not_operator; 73, 74; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:os; 78, identifier:path; 79, identifier:exists; 80, argument_list; 80, 81; 81, identifier:filename; 82, block; 82, 83; 82, 94; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:tf; 88, identifier:logging; 89, identifier:info; 90, argument_list; 90, 91; 91, binary_operator:+; 91, 92; 91, 93; 92, identifier:filename; 93, string:" was deleted, so skipping it"; 94, continue_statement; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:stepfiles; 99, identifier:append; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:StepFile; 103, argument_list; 103, 104; 103, 105; 103, 113; 103, 121; 104, identifier:basename; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:os; 109, identifier:path; 110, identifier:getmtime; 111, argument_list; 111, 112; 112, identifier:filename; 113, call; 113, 114; 113, 119; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:os; 117, identifier:path; 118, identifier:getctime; 119, argument_list; 119, 120; 120, identifier:filename; 121, identifier:steps; 122, return_statement; 122, 123; 123, call; 123, 124; 123, 125; 124, identifier:sorted; 125, argument_list; 125, 126; 125, 127; 126, identifier:stepfiles; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:key; 129, lambda; 129, 130; 129, 132; 130, lambda_parameters; 130, 131; 131, identifier:x; 132, unary_operator:-; 132, 133; 133, attribute; 133, 134; 133, 135; 134, identifier:x; 135, identifier:steps | def _read_stepfiles_list(path_prefix, path_suffix=".index", min_steps=0):
"""Return list of StepFiles sorted by step from files at path_prefix."""
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: # The -[0-9]* part is not an integer.
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, 17; 14, 79; 15, expression_statement; 15, 16; 16, comment; 17, function_definition; 17, 18; 17, 19; 17, 21; 18, function_name:remove_callables; 19, parameters; 19, 20; 20, identifier:x; 21, block; 21, 22; 21, 24; 21, 77; 22, expression_statement; 22, 23; 23, comment; 24, if_statement; 24, 25; 24, 30; 24, 55; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:x; 29, identifier:dict; 30, block; 30, 31; 31, return_statement; 31, 32; 32, dictionary_comprehension; 32, 33; 32, 39; 32, 49; 33, pair; 33, 34; 33, 35; 34, identifier:k; 35, call; 35, 36; 35, 37; 36, identifier:remove_callables; 37, argument_list; 37, 38; 38, identifier:v; 39, for_in_clause; 39, 40; 39, 43; 40, pattern_list; 40, 41; 40, 42; 41, identifier:k; 42, identifier:v; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:six; 46, identifier:iteritems; 47, argument_list; 47, 48; 48, identifier:x; 49, if_clause; 49, 50; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:callable; 53, argument_list; 53, 54; 54, identifier:v; 55, elif_clause; 55, 56; 55, 61; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:x; 60, identifier:list; 61, block; 61, 62; 62, return_statement; 62, 63; 63, list_comprehension; 63, 64; 63, 68; 63, 71; 64, call; 64, 65; 64, 66; 65, identifier:remove_callables; 66, argument_list; 66, 67; 67, identifier:i; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:i; 70, identifier:x; 71, if_clause; 71, 72; 72, not_operator; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:callable; 75, argument_list; 75, 76; 76, identifier:i; 77, return_statement; 77, 78; 78, identifier:x; 79, return_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:json; 83, identifier:dumps; 84, argument_list; 84, 85; 84, 93; 84, 96; 84, 99; 85, call; 85, 86; 85, 87; 86, identifier:remove_callables; 87, argument_list; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:values; 92, argument_list; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:indent; 95, identifier:indent; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:separators; 98, identifier:separators; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:sort_keys; 101, identifier:sort_keys | def to_json(self, indent=None, separators=None, sort_keys=False):
"""Serializes the hyperparameters into JSON.
Args:
indent: If a non-negative integer, JSON array elements and object members
will be pretty-printed with that indent level. An indent level of 0, or
negative, will only insert newlines. `None` (the default) selects the
most compact representation.
separators: Optional `(item_separator, key_separator)` tuple. Default is
`(', ', ': ')`.
sort_keys: If `True`, the output dictionaries will be sorted by key.
Returns:
A JSON string.
"""
def remove_callables(x):
"""Omit callable elements from input with arbitrary nesting."""
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, 9; 6, 17; 6, 25; 6, 42; 6, 58; 6, 64; 6, 80; 6, 81; 6, 82; 6, 83; 6, 87; 6, 103; 6, 209; 6, 233; 6, 239; 6, 245; 6, 254; 6, 266; 6, 278; 6, 290; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:height; 12, subscript; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:inputs; 15, identifier:shape; 16, integer:0; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:width; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:inputs; 23, identifier:shape; 24, integer:1; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:neg_inf_r0; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:tf; 31, identifier:constant; 32, argument_list; 32, 33; 32, 37; 33, unary_operator:-; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:inf; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:dtype; 39, attribute; 39, 40; 39, 41; 40, identifier:tf; 41, identifier:float32; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:ones; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:tf; 48, identifier:ones; 49, argument_list; 49, 50; 49, 53; 50, list:[height, width]; 50, 51; 50, 52; 51, identifier:height; 52, identifier:width; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:dtype; 55, attribute; 55, 56; 55, 57; 56, identifier:tf; 57, identifier:float32; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:neg_inf_r2; 61, binary_operator:*; 61, 62; 61, 63; 62, identifier:ones; 63, identifier:neg_inf_r0; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:inputs; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:tf; 70, identifier:where; 71, argument_list; 71, 72; 71, 78; 71, 79; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:tf; 75, identifier:is_nan; 76, argument_list; 76, 77; 77, identifier:inputs; 78, identifier:neg_inf_r2; 79, identifier:inputs; 80, comment; 81, comment; 82, comment; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:tmp; 86, identifier:inputs; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:topk_r2; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:tf; 93, identifier:zeros; 94, argument_list; 94, 95; 94, 98; 95, list:[height, k]; 95, 96; 95, 97; 96, identifier:height; 97, identifier:k; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:dtype; 100, attribute; 100, 101; 100, 102; 101, identifier:tf; 102, identifier:float32; 103, for_statement; 103, 104; 103, 105; 103, 109; 104, identifier:i; 105, call; 105, 106; 105, 107; 106, identifier:range; 107, argument_list; 107, 108; 108, identifier:k; 109, block; 109, 110; 109, 125; 109, 161; 109, 180; 109, 198; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:kth_order_statistic; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:tf; 116, identifier:reduce_max; 117, argument_list; 117, 118; 117, 119; 117, 122; 118, identifier:tmp; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:axis; 121, integer:1; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:keepdims; 124, True; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:k_mask; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:tf; 131, identifier:tile; 132, argument_list; 132, 133; 132, 158; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:tf; 136, identifier:expand_dims; 137, argument_list; 137, 138; 137, 157; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:tf; 141, identifier:equal; 142, argument_list; 142, 143; 142, 149; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:tf; 146, identifier:range; 147, argument_list; 147, 148; 148, identifier:k; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:tf; 152, identifier:fill; 153, argument_list; 153, 154; 153, 156; 154, list:[k]; 154, 155; 155, identifier:k; 156, identifier:i; 157, integer:0; 158, list:[height, 1]; 158, 159; 158, 160; 159, identifier:height; 160, integer:1; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:topk_r2; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:tf; 167, identifier:where; 168, argument_list; 168, 169; 168, 170; 168, 179; 169, identifier:k_mask; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:tf; 173, identifier:tile; 174, argument_list; 174, 175; 174, 176; 175, identifier:kth_order_statistic; 176, list:[1, k]; 176, 177; 176, 178; 177, integer:1; 178, identifier:k; 179, identifier:topk_r2; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:ge_r2; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:tf; 186, identifier:greater_equal; 187, argument_list; 187, 188; 187, 189; 188, identifier:inputs; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:tf; 192, identifier:tile; 193, argument_list; 193, 194; 193, 195; 194, identifier:kth_order_statistic; 195, list:[1, width]; 195, 196; 195, 197; 196, integer:1; 197, identifier:width; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:tmp; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:tf; 204, identifier:where; 205, argument_list; 205, 206; 205, 207; 205, 208; 206, identifier:ge_r2; 207, identifier:neg_inf_r2; 208, identifier:inputs; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:log2_ceiling; 212, call; 212, 213; 212, 214; 213, identifier:int; 214, argument_list; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:math; 218, identifier:ceil; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:math; 223, identifier:log; 224, argument_list; 224, 225; 224, 232; 225, call; 225, 226; 225, 227; 226, identifier:float; 227, argument_list; 227, 228; 228, call; 228, 229; 228, 230; 229, identifier:int; 230, argument_list; 230, 231; 231, identifier:width; 232, integer:2; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:next_power_of_two; 236, binary_operator:<<; 236, 237; 236, 238; 237, integer:1; 238, identifier:log2_ceiling; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:count_mask; 242, binary_operator:-; 242, 243; 242, 244; 243, identifier:next_power_of_two; 244, integer:1; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:mask_r0; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:tf; 251, identifier:constant; 252, argument_list; 252, 253; 253, identifier:count_mask; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:mask_r2; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:tf; 260, identifier:fill; 261, argument_list; 261, 262; 261, 265; 262, list:[height, k]; 262, 263; 262, 264; 263, identifier:height; 264, identifier:k; 265, identifier:mask_r0; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:topk_r2_s32; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:tf; 272, identifier:bitcast; 273, argument_list; 273, 274; 273, 275; 274, identifier:topk_r2; 275, attribute; 275, 276; 275, 277; 276, identifier:tf; 277, identifier:int32; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:topk_indices_r2; 281, call; 281, 282; 281, 287; 282, attribute; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:tf; 285, identifier:bitwise; 286, identifier:bitwise_and; 287, argument_list; 287, 288; 287, 289; 288, identifier:topk_r2_s32; 289, identifier:mask_r2; 290, return_statement; 290, 291; 291, expression_list; 291, 292; 291, 293; 292, identifier:topk_r2; 293, identifier:topk_indices_r2 | def _create_topk_unique(inputs, k):
"""Creates the top k values in sorted order with indices.
Args:
inputs: A tensor with rank of 2. [batch_size, original_size].
k: An integer, number of top elements to select.
Returns:
topk_r2: A tensor, the k largest elements. [batch_size, k].
topk_indices_r2: A tensor, indices of the top k values. [batch_size, 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)
# Select the current largest value k times and keep them in topk_r2. The
# selected largest values are marked as the smallest value to avoid being
# selected again.
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, 9; 6, 24; 6, 34; 6, 46; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:unique_inputs; 12, call; 12, 13; 12, 14; 13, identifier:_create_make_unique; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:tf; 18, identifier:cast; 19, argument_list; 19, 20; 19, 21; 20, identifier:inputs; 21, attribute; 21, 22; 21, 23; 22, identifier:tf; 23, identifier:float32; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:top_values; 28, identifier:indices; 29, call; 29, 30; 29, 31; 30, identifier:_create_topk_unique; 31, argument_list; 31, 32; 31, 33; 32, identifier:unique_inputs; 33, identifier:k; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:top_values; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:tf; 40, identifier:cast; 41, argument_list; 41, 42; 41, 43; 42, identifier:top_values; 43, attribute; 43, 44; 43, 45; 44, identifier:inputs; 45, identifier:dtype; 46, return_statement; 46, 47; 47, expression_list; 47, 48; 47, 49; 48, identifier:top_values; 49, identifier:indices | def top_k_with_unique(inputs, k):
"""Finds the values and indices of the k largests entries.
Instead of doing sort like tf.nn.top_k, this function finds the max value
k times. The running time is proportional to k, which is be faster when k
is small. The current implementation supports only inputs of rank 2.
In addition, iota is used to replace the lower bits of each element, this
makes the selection more stable when there are equal elements. The
overhead is that output values are approximated.
Args:
inputs: A tensor with rank of 2. [batch_size, original_size].
k: An integer, number of top elements to select.
Returns:
top_values: A tensor, the k largest elements in sorted order.
[batch_size, k].
indices: A tensor, indices of the top_values. [batch_size, 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, 10; 7, 29; 7, 58; 7, 79; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 15; 12, pattern_list; 12, 13; 12, 14; 13, identifier:batch; 14, identifier:k; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:tf; 18, identifier:unstack; 19, argument_list; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:tf; 23, identifier:shape; 24, argument_list; 24, 25; 25, identifier:indices; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:num; 28, integer:2; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:indices_flat; 32, binary_operator:+; 32, 33; 32, 42; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:tf; 36, identifier:reshape; 37, argument_list; 37, 38; 37, 39; 38, identifier:indices; 39, list:[-1]; 39, 40; 40, unary_operator:-; 40, 41; 41, integer:1; 42, binary_operator:*; 42, 43; 42, 57; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:tf; 46, identifier:div; 47, argument_list; 47, 48; 47, 56; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:tf; 51, identifier:range; 52, argument_list; 52, 53; 53, binary_operator:*; 53, 54; 53, 55; 54, identifier:batch; 55, identifier:k; 56, identifier:k; 57, identifier:n; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:ret_flat; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:tf; 64, identifier:unsorted_segment_sum; 65, argument_list; 65, 66; 65, 75; 65, 76; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:tf; 69, identifier:reshape; 70, argument_list; 70, 71; 70, 72; 71, identifier:values; 72, list:[-1]; 72, 73; 73, unary_operator:-; 73, 74; 74, integer:1; 75, identifier:indices_flat; 76, binary_operator:*; 76, 77; 76, 78; 77, identifier:batch; 78, identifier:n; 79, return_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:tf; 83, identifier:reshape; 84, argument_list; 84, 85; 84, 86; 85, identifier:ret_flat; 86, list:[batch, n]; 86, 87; 86, 88; 87, identifier:batch; 88, identifier:n | def _rowwise_unsorted_segment_sum(values, indices, n):
"""UnsortedSegmentSum on each row.
Args:
values: a `Tensor` with shape `[batch_size, k]`.
indices: an integer `Tensor` with shape `[batch_size, k]`.
n: an integer.
Returns:
A `Tensor` with the same type as `values` and shape `[batch_size, 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, 11; 8, 20; 8, 78; 8, 101; 8, 116; 8, 117; 8, 121; 8, 125; 8, 151; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:tf; 16, identifier:logging; 17, identifier:info; 18, argument_list; 18, 19; 19, string:"Getting sorted inputs"; 20, with_statement; 20, 21; 20, 34; 21, with_clause; 21, 22; 22, with_item; 22, 23; 23, as_pattern; 23, 24; 23, 32; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:tf; 28, identifier:gfile; 29, identifier:Open; 30, argument_list; 30, 31; 31, identifier:filename; 32, as_pattern_target; 32, 33; 33, identifier:f; 34, block; 34, 35; 34, 43; 34, 52; 34, 64; 34, 65; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:text; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:f; 41, identifier:read; 42, argument_list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:records; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:text; 49, identifier:split; 50, argument_list; 50, 51; 51, identifier:delimiter; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:inputs; 55, list_comprehension; 55, 56; 55, 61; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:record; 59, identifier:strip; 60, argument_list; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:record; 63, identifier:records; 64, comment; 65, if_statement; 65, 66; 65, 71; 66, not_operator; 66, 67; 67, subscript; 67, 68; 67, 69; 68, identifier:inputs; 69, unary_operator:-; 69, 70; 70, integer:1; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:inputs; 76, identifier:pop; 77, argument_list; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:input_lens; 81, list_comprehension; 81, 82; 81, 93; 82, tuple; 82, 83; 82, 84; 83, identifier:i; 84, unary_operator:-; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:line; 91, identifier:split; 92, argument_list; 93, for_in_clause; 93, 94; 93, 97; 94, pattern_list; 94, 95; 94, 96; 95, identifier:i; 96, identifier:line; 97, call; 97, 98; 97, 99; 98, identifier:enumerate; 99, argument_list; 99, 100; 100, identifier:inputs; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:sorted_input_lens; 104, call; 104, 105; 104, 106; 105, identifier:sorted; 106, argument_list; 106, 107; 106, 108; 107, identifier:input_lens; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:key; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:operator; 113, identifier:itemgetter; 114, argument_list; 114, 115; 115, integer:1; 116, comment; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:sorted_keys; 120, dictionary; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:sorted_inputs; 124, list:[]; 125, for_statement; 125, 126; 125, 131; 125, 135; 126, pattern_list; 126, 127; 126, 128; 127, identifier:i; 128, tuple_pattern; 128, 129; 128, 130; 129, identifier:index; 130, identifier:_; 131, call; 131, 132; 131, 133; 132, identifier:enumerate; 133, argument_list; 133, 134; 134, identifier:sorted_input_lens; 135, block; 135, 136; 135, 145; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:sorted_inputs; 140, identifier:append; 141, argument_list; 141, 142; 142, subscript; 142, 143; 142, 144; 143, identifier:inputs; 144, identifier:index; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:sorted_keys; 149, identifier:index; 150, identifier:i; 151, return_statement; 151, 152; 152, expression_list; 152, 153; 152, 154; 153, identifier:sorted_inputs; 154, identifier:sorted_keys | def _get_sorted_inputs(filename, delimiter="\n"):
"""Returning inputs sorted according to decreasing length.
This causes inputs of similar lengths to be processed in the same batch,
facilitating early stopping for short sequences.
Longer sequences are sorted first so that if you're going to get OOMs,
you'll see it in the first batch.
Args:
filename: path to file with inputs, 1 per line.
delimiter: str, delimits records in the file.
Returns:
a sorted list of inputs
"""
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]
# Strip the last empty line.
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))
# We'll need the keys to rearrange the inputs back into their original order
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, 19; 16, 43; 16, 57; 16, 67; 16, 85; 16, 86; 16, 87; 16, 101; 16, 111; 17, expression_statement; 17, 18; 18, comment; 19, if_statement; 19, 20; 19, 37; 20, boolean_operator:or; 20, 21; 20, 29; 21, not_operator; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:tensor; 26, attribute; 26, 27; 26, 28; 27, identifier:torch; 28, identifier:Tensor; 29, not_operator; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:isinstance; 32, argument_list; 32, 33; 32, 34; 33, identifier:sequence_lengths; 34, attribute; 34, 35; 34, 36; 35, identifier:torch; 36, identifier:Tensor; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:ConfigurationError; 41, argument_list; 41, 42; 42, string:"Both the tensor and sequence lengths must be torch.Tensors."; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, pattern_list; 45, 46; 45, 47; 46, identifier:sorted_sequence_lengths; 47, identifier:permutation_index; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:sequence_lengths; 51, identifier:sort; 52, argument_list; 52, 53; 52, 54; 53, integer:0; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:descending; 56, True; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:sorted_tensor; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:tensor; 63, identifier:index_select; 64, argument_list; 64, 65; 64, 66; 65, integer:0; 66, identifier:permutation_index; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:index_range; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:torch; 73, identifier:arange; 74, argument_list; 74, 75; 74, 76; 74, 80; 75, integer:0; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, identifier:sequence_lengths; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:device; 82, attribute; 82, 83; 82, 84; 83, identifier:sequence_lengths; 84, identifier:device; 85, comment; 86, comment; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, pattern_list; 89, 90; 89, 91; 90, identifier:_; 91, identifier:reverse_mapping; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:permutation_index; 95, identifier:sort; 96, argument_list; 96, 97; 96, 98; 97, integer:0; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:descending; 100, False; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:restoration_indices; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:index_range; 107, identifier:index_select; 108, argument_list; 108, 109; 108, 110; 109, integer:0; 110, identifier:reverse_mapping; 111, return_statement; 111, 112; 112, expression_list; 112, 113; 112, 114; 112, 115; 112, 116; 113, identifier:sorted_tensor; 114, identifier:sorted_sequence_lengths; 115, identifier:restoration_indices; 116, identifier:permutation_index | def sort_batch_by_length(tensor: torch.Tensor, sequence_lengths: torch.Tensor):
"""
Sort a batch first tensor by some specified lengths.
Parameters
----------
tensor : torch.FloatTensor, required.
A batch first Pytorch tensor.
sequence_lengths : torch.LongTensor, required.
A tensor representing the lengths of some dimension of the tensor which
we want to sort by.
Returns
-------
sorted_tensor : torch.FloatTensor
The original tensor sorted along the batch dimension with respect to sequence_lengths.
sorted_sequence_lengths : torch.LongTensor
The original sequence_lengths sorted by decreasing size.
restoration_indices : torch.LongTensor
Indices into the sorted_tensor such that
``sorted_tensor.index_select(0, restoration_indices) == original_tensor``
permutation_index : torch.LongTensor
The indices used to sort the tensor. This is useful if you want to sort many
tensors using the same ordering.
"""
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)
# This is the equivalent of zipping with index, sorting by the original
# sequence lengths and returning the now sorted indices.
_, 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, 18; 15, 19; 15, 25; 16, expression_statement; 16, 17; 17, comment; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:new_indent; 22, binary_operator:+; 22, 23; 22, 24; 23, identifier:indent; 24, string:" "; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, string:""; 29, identifier:join; 30, argument_list; 30, 31; 31, list:[
# opening brace + newline
"{\n",
# "type": "...", (if present)
f'{new_indent}"type": "{config.typ3}",\n' if config.typ3 else '',
# render each item
"".join(_render(item, new_indent) for item in config.items),
# indent and close the brace
indent,
"}\n"
]; 31, 32; 31, 33; 31, 34; 31, 35; 31, 41; 31, 42; 31, 57; 31, 58; 31, 59; 32, comment; 33, string:"{\n"; 34, comment; 35, conditional_expression:if; 35, 36; 35, 37; 35, 40; 36, string:f'{new_indent}"type": "{config.typ3}",\n'; 37, attribute; 37, 38; 37, 39; 38, identifier:config; 39, identifier:typ3; 40, string:''; 41, comment; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, string:""; 45, identifier:join; 46, generator_expression; 46, 47; 46, 52; 47, call; 47, 48; 47, 49; 48, identifier:_render; 49, argument_list; 49, 50; 49, 51; 50, identifier:item; 51, identifier:new_indent; 52, for_in_clause; 52, 53; 52, 54; 53, identifier:item; 54, attribute; 54, 55; 54, 56; 55, identifier:config; 56, identifier:items; 57, comment; 58, identifier:indent; 59, string:"}\n" | def render_config(config: Config, indent: str = "") -> str:
"""
Pretty-print a config in sort-of-JSON+comments.
"""
# Add four spaces to the indent.
new_indent = indent + " "
return "".join([
# opening brace + newline
"{\n",
# "type": "...", (if present)
f'{new_indent}"type": "{config.typ3}",\n' if config.typ3 else '',
# render each item
"".join(_render(item, new_indent) for item in config.items),
# indent and close the brace
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, 57; 54, 58; 54, 59; 54, 60; 54, 61; 54, 70; 54, 91; 54, 98; 54, 111; 54, 112; 54, 141; 54, 142; 54, 227; 54, 228; 54, 238; 55, expression_statement; 55, 56; 56, comment; 57, comment; 58, comment; 59, comment; 60, comment; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:batch_size; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:mask; 67, identifier:size; 68, argument_list; 68, 69; 69, integer:0; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:num_valid; 73, call; 73, 74; 73, 90; 74, attribute; 74, 75; 74, 89; 75, call; 75, 76; 75, 88; 76, attribute; 76, 77; 76, 87; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:torch; 80, identifier:sum; 81, argument_list; 81, 82; 82, subscript; 82, 83; 82, 84; 82, 86; 83, identifier:mask; 84, slice; 84, 85; 85, colon; 86, integer:0; 87, identifier:int; 88, argument_list; 89, identifier:item; 90, argument_list; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:sequence_lengths; 94, call; 94, 95; 94, 96; 95, identifier:get_lengths_from_binary_sequence_mask; 96, argument_list; 96, 97; 97, identifier:mask; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 105; 99, 106; 100, pattern_list; 100, 101; 100, 102; 100, 103; 100, 104; 101, identifier:sorted_inputs; 102, identifier:sorted_sequence_lengths; 103, identifier:restoration_indices; 104, identifier:sorting_indices; 105, line_continuation:\; 106, call; 106, 107; 106, 108; 107, identifier:sort_batch_by_length; 108, argument_list; 108, 109; 108, 110; 109, identifier:inputs; 110, identifier:sequence_lengths; 111, comment; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:packed_sequence_input; 115, call; 115, 116; 115, 117; 116, identifier:pack_padded_sequence; 117, argument_list; 117, 118; 117, 127; 117, 138; 118, subscript; 118, 119; 118, 120; 118, 123; 118, 125; 119, identifier:sorted_inputs; 120, slice; 120, 121; 120, 122; 121, colon; 122, identifier:num_valid; 123, slice; 123, 124; 124, colon; 125, slice; 125, 126; 126, colon; 127, call; 127, 128; 127, 137; 128, attribute; 128, 129; 128, 136; 129, attribute; 129, 130; 129, 135; 130, subscript; 130, 131; 130, 132; 131, identifier:sorted_sequence_lengths; 132, slice; 132, 133; 132, 134; 133, colon; 134, identifier:num_valid; 135, identifier:data; 136, identifier:tolist; 137, argument_list; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:batch_first; 140, True; 141, comment; 142, if_statement; 142, 143; 142, 147; 142, 214; 143, not_operator; 143, 144; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:stateful; 147, block; 147, 148; 148, if_statement; 148, 149; 148, 152; 148, 157; 148, 190; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:hidden_state; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:initial_states; 156, identifier:hidden_state; 157, elif_clause; 157, 158; 157, 163; 158, call; 158, 159; 158, 160; 159, identifier:isinstance; 160, argument_list; 160, 161; 160, 162; 161, identifier:hidden_state; 162, identifier:tuple; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:initial_states; 167, list_comprehension; 167, 168; 167, 187; 168, call; 168, 169; 168, 186; 169, attribute; 169, 170; 169, 185; 170, subscript; 170, 171; 170, 178; 170, 180; 170, 183; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:state; 174, identifier:index_select; 175, argument_list; 175, 176; 175, 177; 176, integer:1; 177, identifier:sorting_indices; 178, slice; 178, 179; 179, colon; 180, slice; 180, 181; 180, 182; 181, colon; 182, identifier:num_valid; 183, slice; 183, 184; 184, colon; 185, identifier:contiguous; 186, argument_list; 187, for_in_clause; 187, 188; 187, 189; 188, identifier:state; 189, identifier:hidden_state; 190, else_clause; 190, 191; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:initial_states; 195, call; 195, 196; 195, 213; 196, attribute; 196, 197; 196, 212; 197, subscript; 197, 198; 197, 205; 197, 207; 197, 210; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:hidden_state; 201, identifier:index_select; 202, argument_list; 202, 203; 202, 204; 203, integer:1; 204, identifier:sorting_indices; 205, slice; 205, 206; 206, colon; 207, slice; 207, 208; 207, 209; 208, colon; 209, identifier:num_valid; 210, slice; 210, 211; 211, colon; 212, identifier:contiguous; 213, argument_list; 214, else_clause; 214, 215; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:initial_states; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:_get_initial_states; 223, argument_list; 223, 224; 223, 225; 223, 226; 224, identifier:batch_size; 225, identifier:num_valid; 226, identifier:sorting_indices; 227, comment; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 233; 230, pattern_list; 230, 231; 230, 232; 231, identifier:module_output; 232, identifier:final_states; 233, call; 233, 234; 233, 235; 234, identifier:module; 235, argument_list; 235, 236; 235, 237; 236, identifier:packed_sequence_input; 237, identifier:initial_states; 238, return_statement; 238, 239; 239, expression_list; 239, 240; 239, 241; 239, 242; 240, identifier:module_output; 241, identifier:final_states; 242, 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):
"""
This function exists because Pytorch RNNs require that their inputs be sorted
before being passed as input. As all of our Seq2xxxEncoders use this functionality,
it is provided in a base class. This method can be called on any module which
takes as input a ``PackedSequence`` and some ``hidden_state``, which can either be a
tuple of tensors or a tensor.
As all of our Seq2xxxEncoders have different return types, we return `sorted`
outputs from the module, which is called directly. Additionally, we return the
indices into the batch dimension required to restore the tensor to it's correct,
unsorted order and the number of valid batch elements (i.e the number of elements
in the batch which are not completely masked). This un-sorting and re-padding
of the module outputs is left to the subclasses because their outputs have different
types and handling them smoothly here is difficult.
Parameters
----------
module : ``Callable[[PackedSequence, Optional[RnnState]],
Tuple[Union[PackedSequence, torch.Tensor], RnnState]]``, required.
A function to run on the inputs. In most cases, this is a ``torch.nn.Module``.
inputs : ``torch.Tensor``, required.
A tensor of shape ``(batch_size, sequence_length, embedding_size)`` representing
the inputs to the Encoder.
mask : ``torch.Tensor``, required.
A tensor of shape ``(batch_size, sequence_length)``, representing masked and
non-masked elements of the sequence for each element in the batch.
hidden_state : ``Optional[RnnState]``, (default = None).
A single tensor of shape (num_layers, batch_size, hidden_size) representing the
state of an RNN with or a tuple of
tensors of shapes (num_layers, batch_size, hidden_size) and
(num_layers, batch_size, memory_size), representing the hidden state and memory
state of an LSTM-like RNN.
Returns
-------
module_output : ``Union[torch.Tensor, PackedSequence]``.
A Tensor or PackedSequence representing the output of the Pytorch Module.
The batch size dimension will be equal to ``num_valid``, as sequences of zero
length are clipped off before the module is called, as Pytorch cannot handle
zero length sequences.
final_states : ``Optional[RnnState]``
A Tensor representing the hidden state of the Pytorch Module. This can either
be a single tensor of shape (num_layers, num_valid, hidden_size), for instance in
the case of a GRU, or a tuple of tensors, such as those required for an LSTM.
restoration_indices : ``torch.LongTensor``
A tensor of shape ``(batch_size,)``, describing the re-indexing required to transform
the outputs back to their original batch order.
"""
# In some circumstances you may have sequences of zero length. ``pack_padded_sequence``
# requires all sequence lengths to be > 0, so remove sequences of zero length before
# calling self._module, then fill with zeros.
# First count how many sequences are empty.
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)
# Now create a PackedSequence with only the non-empty, sorted sequences.
packed_sequence_input = pack_padded_sequence(sorted_inputs[:num_valid, :, :],
sorted_sequence_lengths[:num_valid].data.tolist(),
batch_first=True)
# Prepare the initial states.
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)
# Actually call the module on the sorted PackedSequence.
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, 28; 25, 29; 25, 30; 25, 39; 25, 40; 25, 178; 25, 179; 25, 180; 25, 181; 25, 182; 25, 183; 26, expression_statement; 26, 27; 27, comment; 28, comment; 29, comment; 30, if_statement; 30, 31; 30, 36; 31, comparison_operator:is; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_states; 35, None; 36, block; 36, 37; 37, return_statement; 37, 38; 38, None; 39, comment; 40, if_statement; 40, 41; 40, 53; 40, 54; 40, 55; 40, 135; 40, 170; 41, comparison_operator:>; 41, 42; 41, 43; 42, identifier:batch_size; 43, call; 43, 44; 43, 51; 44, attribute; 44, 45; 44, 50; 45, subscript; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_states; 49, integer:0; 50, identifier:size; 51, argument_list; 51, 52; 52, integer:1; 53, comment; 54, comment; 55, block; 55, 56; 55, 71; 55, 75; 55, 76; 55, 120; 55, 129; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:num_states_to_concat; 59, binary_operator:-; 59, 60; 59, 61; 60, identifier:batch_size; 61, call; 61, 62; 61, 69; 62, attribute; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_states; 67, integer:0; 68, identifier:size; 69, argument_list; 69, 70; 70, integer:1; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:resized_states; 74, list:[]; 75, comment; 76, for_statement; 76, 77; 76, 78; 76, 81; 76, 82; 76, 83; 77, identifier:state; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_states; 81, comment; 82, comment; 83, block; 83, 84; 83, 105; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:zeros; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:state; 90, identifier:new_zeros; 91, argument_list; 91, 92; 91, 98; 91, 99; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:state; 95, identifier:size; 96, argument_list; 96, 97; 97, integer:0; 98, identifier:num_states_to_concat; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:state; 102, identifier:size; 103, argument_list; 103, 104; 104, integer:2; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:resized_states; 109, identifier:append; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:torch; 114, identifier:cat; 115, argument_list; 115, 116; 115, 119; 116, list:[state, zeros]; 116, 117; 116, 118; 117, identifier:state; 118, identifier:zeros; 119, integer:1; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_states; 125, call; 125, 126; 125, 127; 126, identifier:tuple; 127, argument_list; 127, 128; 128, identifier:resized_states; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:correctly_shaped_states; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:_states; 135, elif_clause; 135, 136; 135, 148; 135, 149; 136, comparison_operator:<; 136, 137; 136, 138; 137, identifier:batch_size; 138, call; 138, 139; 138, 146; 139, attribute; 139, 140; 139, 145; 140, subscript; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:_states; 144, integer:0; 145, identifier:size; 146, argument_list; 146, 147; 147, integer:1; 148, comment; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:correctly_shaped_states; 153, call; 153, 154; 153, 155; 154, identifier:tuple; 155, generator_expression; 155, 156; 155, 165; 156, subscript; 156, 157; 156, 158; 156, 160; 156, 163; 157, identifier:state; 158, slice; 158, 159; 159, colon; 160, slice; 160, 161; 160, 162; 161, colon; 162, identifier:batch_size; 163, slice; 163, 164; 164, colon; 165, for_in_clause; 165, 166; 165, 167; 166, identifier:state; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:_states; 170, else_clause; 170, 171; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:correctly_shaped_states; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:_states; 178, comment; 179, comment; 180, comment; 181, comment; 182, comment; 183, if_statement; 183, 184; 183, 192; 183, 193; 183, 194; 183, 225; 184, comparison_operator:==; 184, 185; 184, 191; 185, call; 185, 186; 185, 187; 186, identifier:len; 187, argument_list; 187, 188; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:_states; 191, integer:1; 192, comment; 193, comment; 194, block; 194, 195; 194, 201; 194, 211; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:correctly_shaped_state; 198, subscript; 198, 199; 198, 200; 199, identifier:correctly_shaped_states; 200, integer:0; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:sorted_state; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:correctly_shaped_state; 207, identifier:index_select; 208, argument_list; 208, 209; 208, 210; 209, integer:1; 210, identifier:sorting_indices; 211, return_statement; 211, 212; 212, call; 212, 213; 212, 224; 213, attribute; 213, 214; 213, 223; 214, subscript; 214, 215; 214, 216; 214, 218; 214, 221; 215, identifier:sorted_state; 216, slice; 216, 217; 217, colon; 218, slice; 218, 219; 218, 220; 219, colon; 220, identifier:num_valid; 221, slice; 221, 222; 222, colon; 223, identifier:contiguous; 224, argument_list; 225, else_clause; 225, 226; 225, 227; 226, comment; 227, block; 227, 228; 227, 242; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:sorted_states; 231, list_comprehension; 231, 232; 231, 239; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:state; 235, identifier:index_select; 236, argument_list; 236, 237; 236, 238; 237, integer:1; 238, identifier:sorting_indices; 239, for_in_clause; 239, 240; 239, 241; 240, identifier:state; 241, identifier:correctly_shaped_states; 242, return_statement; 242, 243; 243, call; 243, 244; 243, 245; 244, identifier:tuple; 245, generator_expression; 245, 246; 245, 259; 246, call; 246, 247; 246, 258; 247, attribute; 247, 248; 247, 257; 248, subscript; 248, 249; 248, 250; 248, 252; 248, 255; 249, identifier:state; 250, slice; 250, 251; 251, colon; 252, slice; 252, 253; 252, 254; 253, colon; 254, identifier:num_valid; 255, slice; 255, 256; 256, colon; 257, identifier:contiguous; 258, argument_list; 259, for_in_clause; 259, 260; 259, 261; 260, identifier:state; 261, identifier:sorted_states | def _get_initial_states(self,
batch_size: int,
num_valid: int,
sorting_indices: torch.LongTensor) -> Optional[RnnState]:
"""
Returns an initial state for use in an RNN. Additionally, this method handles
the batch size changing across calls by mutating the state to append initial states
for new elements in the batch. Finally, it also handles sorting the states
with respect to the sequence lengths of elements in the batch and removing rows
which are completely padded. Importantly, this `mutates` the state if the
current batch size is larger than when it was previously called.
Parameters
----------
batch_size : ``int``, required.
The batch size can change size across calls to stateful RNNs, so we need
to know if we need to expand or shrink the states before returning them.
Expanded states will be set to zero.
num_valid : ``int``, required.
The batch may contain completely padded sequences which get removed before
the sequence is passed through the encoder. We also need to clip these off
of the state too.
sorting_indices ``torch.LongTensor``, required.
Pytorch RNNs take sequences sorted by length. When we return the states to be
used for a given call to ``module.forward``, we need the states to match up to
the sorted sequences, so before returning them, we sort the states using the
same indices used to sort the sequences.
Returns
-------
This method has a complex return type because it has to deal with the first time it
is called, when it has no state, and the fact that types of RNN have heterogeneous
states.
If it is the first time the module has been called, it returns ``None``, regardless
of the type of the ``Module``.
Otherwise, for LSTMs, it returns a tuple of ``torch.Tensors`` with shape
``(num_layers, num_valid, state_size)`` and ``(num_layers, num_valid, memory_size)``
respectively, or for GRUs, it returns a single ``torch.Tensor`` of shape
``(num_layers, num_valid, state_size)``.
"""
# We don't know the state sizes the first time calling forward,
# so we let the module define what it's initial hidden state looks like.
if self._states is None:
return None
# Otherwise, we have some previous states.
if batch_size > self._states[0].size(1):
# This batch is larger than the all previous states.
# If so, resize the states.
num_states_to_concat = batch_size - self._states[0].size(1)
resized_states = []
# state has shape (num_layers, batch_size, hidden_size)
for state in self._states:
# This _must_ be inside the loop because some
# RNNs have states with different last dimension sizes.
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):
# This batch is smaller than the previous one.
correctly_shaped_states = tuple(state[:, :batch_size, :] for state in self._states)
else:
correctly_shaped_states = self._states
# At this point, our states are of shape (num_layers, batch_size, hidden_size).
# However, the encoder uses sorted sequences and additionally removes elements
# of the batch which are fully padded. We need the states to match up to these
# sorted and filtered sequences, so we do that in the next two blocks before
# returning the state/s.
if len(self._states) == 1:
# GRUs only have a single state. This `unpacks` it from the
# tuple and returns the tensor directly.
correctly_shaped_state = correctly_shaped_states[0]
sorted_state = correctly_shaped_state.index_select(1, sorting_indices)
return sorted_state[:, :num_valid, :].contiguous()
else:
# LSTMs have a state tuple of (state, memory).
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, 20; 17, 21; 17, 22; 17, 36; 18, expression_statement; 18, 19; 19, comment; 20, comment; 21, comment; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:new_unsorted_states; 25, list_comprehension; 25, 26; 25, 33; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:state; 29, identifier:index_select; 30, argument_list; 30, 31; 30, 32; 31, integer:1; 32, identifier:restoration_indices; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:state; 35, identifier:final_states; 36, if_statement; 36, 37; 36, 42; 36, 43; 36, 44; 36, 59; 37, comparison_operator:is; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_states; 41, None; 42, comment; 43, comment; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_states; 50, call; 50, 51; 50, 52; 51, identifier:tuple; 52, generator_expression; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:state; 55, identifier:data; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:state; 58, identifier:new_unsorted_states; 59, else_clause; 59, 60; 59, 61; 59, 62; 59, 63; 59, 64; 59, 65; 59, 66; 60, comment; 61, comment; 62, comment; 63, comment; 64, comment; 65, comment; 66, block; 66, 67; 66, 80; 66, 91; 66, 92; 66, 126; 66, 130; 66, 244; 66, 245; 66, 246; 66, 247; 66, 248; 66, 249; 66, 250; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:current_state_batch_size; 70, call; 70, 71; 70, 78; 71, attribute; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:_states; 76, integer:0; 77, identifier:size; 78, argument_list; 78, 79; 79, integer:1; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:new_state_batch_size; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:final_states; 87, integer:0; 88, identifier:size; 89, argument_list; 89, 90; 90, integer:1; 91, comment; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:used_new_rows_mask; 95, list_comprehension; 95, 96; 95, 123; 96, call; 96, 97; 96, 119; 97, attribute; 97, 98; 97, 118; 98, call; 98, 99; 98, 117; 99, attribute; 99, 100; 99, 116; 100, parenthesized_expression; 100, 101; 101, comparison_operator:!=; 101, 102; 101, 115; 102, call; 102, 103; 102, 112; 103, attribute; 103, 104; 103, 111; 104, subscript; 104, 105; 104, 106; 104, 107; 104, 109; 105, identifier:state; 106, integer:0; 107, slice; 107, 108; 108, colon; 109, slice; 109, 110; 110, colon; 111, identifier:sum; 112, argument_list; 112, 113; 113, unary_operator:-; 113, 114; 114, integer:1; 115, float:0.0; 116, identifier:float; 117, argument_list; 118, identifier:view; 119, argument_list; 119, 120; 119, 121; 119, 122; 120, integer:1; 121, identifier:new_state_batch_size; 122, integer:1; 123, for_in_clause; 123, 124; 123, 125; 124, identifier:state; 125, identifier:new_unsorted_states; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:new_states; 129, list:[]; 130, if_statement; 130, 131; 130, 134; 130, 135; 130, 136; 130, 196; 131, comparison_operator:>; 131, 132; 131, 133; 132, identifier:current_state_batch_size; 133, identifier:new_state_batch_size; 134, comment; 135, comment; 136, block; 136, 137; 137, for_statement; 137, 138; 137, 142; 137, 150; 137, 151; 137, 152; 138, pattern_list; 138, 139; 138, 140; 138, 141; 139, identifier:old_state; 140, identifier:new_state; 141, identifier:used_mask; 142, call; 142, 143; 142, 144; 143, identifier:zip; 144, argument_list; 144, 145; 144, 148; 144, 149; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:_states; 148, identifier:new_unsorted_states; 149, identifier:used_new_rows_mask; 150, comment; 151, comment; 152, block; 152, 153; 152, 170; 152, 171; 152, 185; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:masked_old_state; 156, binary_operator:*; 156, 157; 156, 166; 157, subscript; 157, 158; 157, 159; 157, 161; 157, 164; 158, identifier:old_state; 159, slice; 159, 160; 160, colon; 161, slice; 161, 162; 161, 163; 162, colon; 163, identifier:new_state_batch_size; 164, slice; 164, 165; 165, colon; 166, parenthesized_expression; 166, 167; 167, binary_operator:-; 167, 168; 167, 169; 168, integer:1; 169, identifier:used_mask; 170, comment; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 182; 173, subscript; 173, 174; 173, 175; 173, 177; 173, 180; 174, identifier:old_state; 175, slice; 175, 176; 176, colon; 177, slice; 177, 178; 177, 179; 178, colon; 179, identifier:new_state_batch_size; 180, slice; 180, 181; 181, colon; 182, binary_operator:+; 182, 183; 182, 184; 183, identifier:new_state; 184, identifier:masked_old_state; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:new_states; 189, identifier:append; 190, argument_list; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:old_state; 194, identifier:detach; 195, argument_list; 196, else_clause; 196, 197; 196, 198; 196, 199; 197, comment; 198, comment; 199, block; 199, 200; 199, 204; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:new_states; 203, list:[]; 204, for_statement; 204, 205; 204, 209; 204, 217; 204, 218; 205, pattern_list; 205, 206; 205, 207; 205, 208; 206, identifier:old_state; 207, identifier:new_state; 208, identifier:used_mask; 209, call; 209, 210; 209, 211; 210, identifier:zip; 211, argument_list; 211, 212; 211, 215; 211, 216; 212, attribute; 212, 213; 212, 214; 213, identifier:self; 214, identifier:_states; 215, identifier:new_unsorted_states; 216, identifier:used_new_rows_mask; 217, comment; 218, block; 218, 219; 218, 228; 218, 229; 218, 233; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:masked_old_state; 222, binary_operator:*; 222, 223; 222, 224; 223, identifier:old_state; 224, parenthesized_expression; 224, 225; 225, binary_operator:-; 225, 226; 225, 227; 226, integer:1; 227, identifier:used_mask; 228, comment; 229, expression_statement; 229, 230; 230, augmented_assignment:+=; 230, 231; 230, 232; 231, identifier:new_state; 232, identifier:masked_old_state; 233, expression_statement; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:new_states; 237, identifier:append; 238, argument_list; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:new_state; 242, identifier:detach; 243, argument_list; 244, comment; 245, comment; 246, comment; 247, comment; 248, comment; 249, comment; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:_states; 255, call; 255, 256; 255, 257; 256, identifier:tuple; 257, argument_list; 257, 258; 258, identifier:new_states | def _update_states(self,
final_states: RnnStateStorage,
restoration_indices: torch.LongTensor) -> None:
"""
After the RNN has run forward, the states need to be updated.
This method just sets the state to the updated new state, performing
several pieces of book-keeping along the way - namely, unsorting the
states and ensuring that the states of completely padded sequences are
not updated. Finally, it also detaches the state variable from the
computational graph, such that the graph can be garbage collected after
each batch iteration.
Parameters
----------
final_states : ``RnnStateStorage``, required.
The hidden states returned as output from the RNN.
restoration_indices : ``torch.LongTensor``, required.
The indices that invert the sorting used in ``sort_and_run_forward``
to order the states with respect to the lengths of the sequences in
the batch.
"""
# TODO(Mark): seems weird to sort here, but append zeros in the subclasses.
# which way around is best?
new_unsorted_states = [state.index_select(1, restoration_indices)
for state in final_states]
if self._states is None:
# We don't already have states, so just set the
# ones we receive to be the current state.
self._states = tuple(state.data for state in new_unsorted_states)
else:
# Now we've sorted the states back so that they correspond to the original
# indices, we need to figure out what states we need to update, because if we
# didn't use a state for a particular row, we want to preserve its state.
# Thankfully, the rows which are all zero in the state correspond exactly
# to those which aren't used, so we create masks of shape (new_batch_size,),
# denoting which states were used in the RNN computation.
current_state_batch_size = self._states[0].size(1)
new_state_batch_size = final_states[0].size(1)
# Masks for the unused states of shape (1, new_batch_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:
# The new state is smaller than the old one,
# so just update the indices which we used.
for old_state, new_state, used_mask in zip(self._states,
new_unsorted_states,
used_new_rows_mask):
# zero out all rows in the previous state
# which _were_ used in the current state.
masked_old_state = old_state[:, :new_state_batch_size, :] * (1 - used_mask)
# The old state is larger, so update the relevant parts of it.
old_state[:, :new_state_batch_size, :] = new_state + masked_old_state
new_states.append(old_state.detach())
else:
# The states are the same size, so we just have to
# deal with the possibility that some rows weren't used.
new_states = []
for old_state, new_state, used_mask in zip(self._states,
new_unsorted_states,
used_new_rows_mask):
# zero out all rows which _were_ used in the current state.
masked_old_state = old_state * (1 - used_mask)
# The old state is larger, so update the relevant parts of it.
new_state += masked_old_state
new_states.append(new_state.detach())
# It looks like there should be another case handled here - when
# the current_state_batch_size < new_state_batch_size. However,
# this never happens, because the states themeselves are mutated
# by appending zeros when calling _get_inital_states, meaning that
# the new states are either of equal size, or smaller, in the case
# that there are some unused elements (zero-length) for the RNN computation.
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, 30; 27, 49; 27, 79; 27, 83; 27, 175; 28, expression_statement; 28, 29; 29, comment; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 31, 45; 32, identifier:states_by_batch_index; 33, type; 33, 34; 34, generic_type; 34, 35; 34, 36; 35, identifier:Dict; 36, type_parameter; 36, 37; 36, 39; 37, type; 37, 38; 38, identifier:int; 39, type; 39, 40; 40, generic_type; 40, 41; 40, 42; 41, identifier:List; 42, type_parameter; 42, 43; 43, type; 43, 44; 44, identifier:State; 45, call; 45, 46; 45, 47; 46, identifier:defaultdict; 47, argument_list; 47, 48; 48, identifier:list; 49, for_statement; 49, 50; 49, 51; 49, 52; 50, identifier:state; 51, identifier:states; 52, block; 52, 53; 52, 62; 52, 70; 53, assert_statement; 53, 54; 54, comparison_operator:==; 54, 55; 54, 61; 55, call; 55, 56; 55, 57; 56, identifier:len; 57, argument_list; 57, 58; 58, attribute; 58, 59; 58, 60; 59, identifier:state; 60, identifier:batch_indices; 61, integer:1; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:batch_index; 65, subscript; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:state; 68, identifier:batch_indices; 69, integer:0; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:states_by_batch_index; 75, identifier:batch_index; 76, identifier:append; 77, argument_list; 77, 78; 78, identifier:state; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:pruned_states; 82, list:[]; 83, for_statement; 83, 84; 83, 87; 83, 92; 84, pattern_list; 84, 85; 84, 86; 85, identifier:_; 86, identifier:instance_states; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:states_by_batch_index; 90, identifier:items; 91, argument_list; 92, block; 92, 93; 92, 160; 93, if_statement; 93, 94; 93, 95; 94, identifier:sort_states; 95, block; 95, 96; 95, 119; 95, 134; 95, 156; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:scores; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:torch; 102, identifier:cat; 103, argument_list; 103, 104; 104, list_comprehension; 104, 105; 104, 116; 105, call; 105, 106; 105, 113; 106, attribute; 106, 107; 106, 112; 107, subscript; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:state; 110, identifier:score; 111, integer:0; 112, identifier:view; 113, argument_list; 113, 114; 114, unary_operator:-; 114, 115; 115, integer:1; 116, for_in_clause; 116, 117; 116, 118; 117, identifier:state; 118, identifier:instance_states; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, pattern_list; 121, 122; 121, 123; 122, identifier:_; 123, identifier:sorted_indices; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:scores; 127, identifier:sort; 128, argument_list; 128, 129; 128, 131; 129, unary_operator:-; 129, 130; 130, integer:1; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:descending; 133, True; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:sorted_states; 137, list_comprehension; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:instance_states; 140, identifier:i; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:i; 143, call; 143, 144; 143, 155; 144, attribute; 144, 145; 144, 154; 145, call; 145, 146; 145, 153; 146, attribute; 146, 147; 146, 152; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:sorted_indices; 150, identifier:detach; 151, argument_list; 152, identifier:cpu; 153, argument_list; 154, identifier:numpy; 155, argument_list; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:instance_states; 159, identifier:sorted_states; 160, for_statement; 160, 161; 160, 162; 160, 167; 161, identifier:state; 162, subscript; 162, 163; 162, 164; 163, identifier:instance_states; 164, slice; 164, 165; 164, 166; 165, colon; 166, identifier:beam_size; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:pruned_states; 172, identifier:append; 173, argument_list; 173, 174; 174, identifier:state; 175, return_statement; 175, 176; 176, identifier:pruned_states | def _prune_beam(states: List[State],
beam_size: int,
sort_states: bool = False) -> List[State]:
"""
This method can be used to prune the set of unfinished states on a beam or finished states
at the end of search. In the former case, the states need not be sorted because the all come
from the same decoding step, which does the sorting. However, if the states are finished and
this method is called at the end of the search, they need to be sorted because they come
from different decoding steps.
"""
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; 29, 32; 30, expression_statement; 30, 31; 31, comment; 32, raise_statement; 32, 33; 33, identifier:NotImplementedError | def take_step(self,
state: StateType,
max_actions: int = None,
allowed_actions: List[Set] = None) -> List[StateType]:
"""
The main method in the ``TransitionFunction`` API. This function defines the computation
done at each step of decoding and returns a ranked list of next states.
The input state is `grouped`, to allow for efficient computation, but the output states
should all have a ``group_size`` of 1, to make things easier on the decoding algorithm.
They will get regrouped later as needed.
Because of the way we handle grouping in the decoder states, constructing a new state is
actually a relatively expensive operation. If you know a priori that only some of the
states will be needed (either because you have a set of gold action sequences, or you have
a fixed beam size), passing that information into this function will keep us from
constructing more states than we need, which will greatly speed up your computation.
IMPORTANT: This method `must` returns states already sorted by their score, otherwise
``BeamSearch`` and other methods will break. For efficiency, we do not perform an
additional sort in those methods.
ALSO IMPORTANT: When ``allowed_actions`` is given and ``max_actions`` is not, we assume you
want to evaluate all possible states and do not need any sorting (e.g., this is true for
maximum marginal likelihood training that does not use a beam search). In this case, we
may skip the sorting step for efficiency reasons.
Parameters
----------
state : ``State``
The current state of the decoder, which we will take a step `from`. We may be grouping
together computation for several states here. Because we can have several states for
each instance in the original batch being evaluated at the same time, we use
``group_size`` for this kind of batching, and ``batch_size`` for the `original` batch
in ``model.forward.``
max_actions : ``int``, optional
If you know that you will only need a certain number of states out of this (e.g., in a
beam search), you can pass in the max number of actions that you need, and we will only
construct that many states (for each `batch` instance - `not` for each `group`
instance!). This can save a whole lot of computation if you have an action space
that's much larger than your beam size.
allowed_actions : ``List[Set]``, optional
If the ``DecoderTrainer`` has constraints on which actions need to be evaluated (e.g.,
maximum marginal likelihood only needs to evaluate action sequences in a given set),
you can pass those constraints here, to avoid constructing state objects unnecessarily.
If there are no constraints from the trainer, passing a value of ``None`` here will
allow all actions to be considered.
This is a list because it is `batched` - every instance in the batch has a set of
allowed actions. Note that the size of this list is the ``group_size`` in the
``State``, `not` the ``batch_size`` of ``model.forward``. The training algorithm needs
to convert from the `batched` allowed action sequences that it has to a `grouped`
allowed action sequence list.
Returns
-------
next_states : ``List[State]``
A list of next states, ordered by score.
"""
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, 18; 15, 23; 15, 28; 15, 40; 15, 48; 15, 52; 15, 53; 15, 57; 15, 82; 15, 93; 15, 104; 15, 116; 15, 177; 15, 178; 15, 179; 16, expression_statement; 16, 17; 17, comment; 18, assert_statement; 18, 19; 19, parenthesized_expression; 19, 20; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:out; 22, None; 23, assert_statement; 23, 24; 24, parenthesized_expression; 24, 25; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:row_ids; 27, None; 28, if_statement; 28, 29; 28, 34; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:row_ids; 33, identifier:NDArray; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:row_ids; 38, list:[row_ids]; 38, 39; 39, identifier:row_ids; 40, assert_statement; 40, 41; 40, 47; 41, parenthesized_expression; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:row_ids; 46, identifier:list; 47, string:"row_ids should be NDArray or list of NDArray"; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:first_out; 51, identifier:out; 52, comment; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:single_rowid; 56, False; 57, if_statement; 57, 58; 57, 70; 58, boolean_operator:and; 58, 59; 58, 65; 59, comparison_operator:==; 59, 60; 59, 64; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:row_ids; 64, integer:1; 65, call; 65, 66; 65, 67; 66, identifier:isinstance; 67, argument_list; 67, 68; 67, 69; 68, identifier:out; 69, identifier:list; 70, block; 70, 71; 70, 75; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:single_rowid; 74, True; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:first_out; 78, list:[out[0]]; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:out; 81, integer:0; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 88; 84, pattern_list; 84, 85; 84, 86; 84, 87; 85, identifier:ckeys; 86, identifier:cvals; 87, identifier:use_str_keys; 88, call; 88, 89; 88, 90; 89, identifier:_ctype_key_value; 90, argument_list; 90, 91; 90, 92; 91, identifier:key; 92, identifier:first_out; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 99; 95, pattern_list; 95, 96; 95, 97; 95, 98; 96, identifier:_; 97, identifier:crow_ids; 98, identifier:_; 99, call; 99, 100; 99, 101; 100, identifier:_ctype_key_value; 101, argument_list; 101, 102; 101, 103; 102, identifier:key; 103, identifier:row_ids; 104, assert_statement; 104, 105; 104, 115; 105, parenthesized_expression; 105, 106; 106, comparison_operator:==; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:len; 109, argument_list; 109, 110; 110, identifier:crow_ids; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, identifier:cvals; 115, string:"the number of row_ids doesn't match the number of values"; 116, if_statement; 116, 117; 116, 118; 116, 147; 117, identifier:use_str_keys; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:check_call; 122, argument_list; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:_LIB; 126, identifier:MXKVStorePullRowSparseEx; 127, argument_list; 127, 128; 127, 131; 127, 138; 127, 139; 127, 140; 127, 141; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:handle; 131, call; 131, 132; 131, 133; 132, identifier:mx_uint; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, identifier:ckeys; 138, identifier:ckeys; 139, identifier:cvals; 140, identifier:crow_ids; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:ctypes; 144, identifier:c_int; 145, argument_list; 145, 146; 146, identifier:priority; 147, else_clause; 147, 148; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:check_call; 152, argument_list; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:_LIB; 156, identifier:MXKVStorePullRowSparse; 157, argument_list; 157, 158; 157, 161; 157, 168; 157, 169; 157, 170; 157, 171; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:handle; 161, call; 161, 162; 161, 163; 162, identifier:mx_uint; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:len; 166, argument_list; 166, 167; 167, identifier:ckeys; 168, identifier:ckeys; 169, identifier:cvals; 170, identifier:crow_ids; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:ctypes; 174, identifier:c_int; 175, argument_list; 175, 176; 176, identifier:priority; 177, comment; 178, comment; 179, if_statement; 179, 180; 179, 181; 180, identifier:single_rowid; 181, block; 181, 182; 182, for_statement; 182, 183; 182, 184; 182, 189; 183, identifier:out_i; 184, subscript; 184, 185; 184, 186; 185, identifier:out; 186, slice; 186, 187; 186, 188; 187, integer:1; 188, colon; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 197; 192, attribute; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:out; 195, integer:0; 196, identifier:copyto; 197, argument_list; 197, 198; 198, identifier:out_i | def row_sparse_pull(self, key, out=None, priority=0, row_ids=None):
""" Pulls a single RowSparseNDArray value or a sequence of RowSparseNDArray values \
from the store with specified row_ids. When there is only one row_id, KVStoreRowSparsePull \
is invoked just once and the result is broadcast to all the rest of outputs.
`row_sparse_pull` is executed asynchronously after all previous
`pull`/`row_sparse_pull` calls and the last `push` call for the
same input key(s) are finished.
The returned values are guaranteed to be the latest values in the store.
Parameters
----------
key : str, int, or sequence of str or int
Keys.
out: RowSparseNDArray or list of RowSparseNDArray or list of list of RowSparseNDArray
Values corresponding to the keys. The stype is expected to be row_sparse
priority : int, optional
The priority of the pull operation.
Higher priority pull operations are likely to be executed before
other pull actions.
row_ids : NDArray or list of NDArray
The row_ids for which to pull for each value. Each row_id is an 1-D NDArray \
whose values don't have to be unique nor sorted.
Examples
--------
>>> shape = (3, 3)
>>> kv.init('3', mx.nd.ones(shape).tostype('row_sparse'))
>>> a = mx.nd.sparse.zeros('row_sparse', shape)
>>> row_ids = mx.nd.array([0, 2], dtype='int64')
>>> kv.row_sparse_pull('3', out=a, row_ids=row_ids)
>>> print a.asnumpy()
[[ 1. 1. 1.]
[ 0. 0. 0.]
[ 1. 1. 1.]]
>>> duplicate_row_ids = mx.nd.array([2, 2], dtype='int64')
>>> kv.row_sparse_pull('3', out=a, row_ids=duplicate_row_ids)
>>> print a.asnumpy()
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 1. 1. 1.]]
>>> unsorted_row_ids = mx.nd.array([1, 0], dtype='int64')
>>> kv.row_sparse_pull('3', out=a, row_ids=unsorted_row_ids)
>>> print a.asnumpy()
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 0. 0. 0.]]
"""
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
# whether row_ids are the same
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)))
# the result can be copied to other devices without invoking row_sparse_pull
# if the indices are the same
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; 14, 17; 14, 18; 15, expression_statement; 15, 16; 16, comment; 17, comment; 18, if_statement; 18, 19; 18, 24; 18, 132; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:arg1; 23, identifier:tuple; 24, block; 24, 25; 24, 32; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:arg_len; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:arg1; 32, if_statement; 32, 33; 32, 36; 32, 47; 32, 71; 33, comparison_operator:<; 33, 34; 33, 35; 34, identifier:arg_len; 35, integer:2; 36, block; 36, 37; 37, raise_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:ValueError; 40, argument_list; 40, 41; 41, binary_operator:+; 41, 42; 41, 43; 42, string:"Unexpected length of input tuple: "; 43, call; 43, 44; 43, 45; 44, identifier:str; 45, argument_list; 45, 46; 46, identifier:arg_len; 47, elif_clause; 47, 48; 47, 51; 47, 52; 48, comparison_operator:>; 48, 49; 48, 50; 49, identifier:arg_len; 50, integer:2; 51, comment; 52, block; 52, 53; 52, 59; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:_check_shape; 56, argument_list; 56, 57; 56, 58; 57, identifier:arg1; 58, identifier:shape; 59, return_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:empty; 62, argument_list; 62, 63; 62, 64; 62, 65; 62, 68; 63, string:'row_sparse'; 64, identifier:arg1; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:ctx; 67, identifier:ctx; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:dtype; 70, identifier:dtype; 71, else_clause; 71, 72; 71, 73; 72, comment; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 90; 74, 91; 74, 110; 75, boolean_operator:and; 75, 76; 75, 83; 76, call; 76, 77; 76, 78; 77, identifier:isinstance; 78, argument_list; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:arg1; 81, integer:0; 82, identifier:integer_types; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:arg1; 88, integer:1; 89, identifier:integer_types; 90, comment; 91, block; 91, 92; 91, 98; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:_check_shape; 95, argument_list; 95, 96; 95, 97; 96, identifier:arg1; 97, identifier:shape; 98, return_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:empty; 101, argument_list; 101, 102; 101, 103; 101, 104; 101, 107; 102, string:'row_sparse'; 103, identifier:arg1; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:ctx; 106, identifier:ctx; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:dtype; 109, identifier:dtype; 110, else_clause; 110, 111; 110, 112; 111, comment; 112, block; 112, 113; 113, return_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:_row_sparse_ndarray_from_definition; 116, argument_list; 116, 117; 116, 120; 116, 123; 116, 126; 116, 129; 117, subscript; 117, 118; 117, 119; 118, identifier:arg1; 119, integer:0; 120, subscript; 120, 121; 120, 122; 121, identifier:arg1; 122, integer:1; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:shape; 125, identifier:shape; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:ctx; 128, identifier:ctx; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:dtype; 131, identifier:dtype; 132, else_clause; 132, 133; 132, 134; 133, comment; 134, block; 134, 135; 135, if_statement; 135, 136; 135, 141; 135, 142; 135, 162; 135, 174; 136, call; 136, 137; 136, 138; 137, identifier:isinstance; 138, argument_list; 138, 139; 138, 140; 139, identifier:arg1; 140, identifier:RowSparseNDArray; 141, comment; 142, block; 142, 143; 142, 151; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:_check_shape; 146, argument_list; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:arg1; 149, identifier:shape; 150, identifier:shape; 151, return_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:array; 154, argument_list; 154, 155; 154, 156; 154, 159; 155, identifier:arg1; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:ctx; 158, identifier:ctx; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:dtype; 161, identifier:dtype; 162, elif_clause; 162, 163; 162, 168; 163, call; 163, 164; 163, 165; 164, identifier:isinstance; 165, argument_list; 165, 166; 165, 167; 166, identifier:arg1; 167, identifier:CSRNDArray; 168, block; 168, 169; 169, raise_statement; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:ValueError; 172, argument_list; 172, 173; 173, string:"Unexpected input type: CSRNDArray"; 174, else_clause; 174, 175; 174, 176; 174, 177; 174, 178; 175, comment; 176, comment; 177, comment; 178, block; 178, 179; 178, 187; 178, 188; 178, 189; 178, 199; 178, 219; 178, 227; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:dtype; 182, call; 182, 183; 182, 184; 183, identifier:_prepare_default_dtype; 184, argument_list; 184, 185; 184, 186; 185, identifier:arg1; 186, identifier:dtype; 187, comment; 188, comment; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:dns; 192, call; 192, 193; 192, 194; 193, identifier:_array; 194, argument_list; 194, 195; 194, 196; 195, identifier:arg1; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:dtype; 198, identifier:dtype; 199, if_statement; 199, 200; 199, 209; 200, boolean_operator:and; 200, 201; 200, 204; 201, comparison_operator:is; 201, 202; 201, 203; 202, identifier:ctx; 203, None; 204, comparison_operator:!=; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:dns; 207, identifier:context; 208, identifier:ctx; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:dns; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:dns; 216, identifier:as_in_context; 217, argument_list; 217, 218; 218, identifier:ctx; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:_check_shape; 222, argument_list; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:dns; 225, identifier:shape; 226, identifier:shape; 227, return_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:dns; 231, identifier:tostype; 232, argument_list; 232, 233; 233, string:'row_sparse' | def row_sparse_array(arg1, shape=None, ctx=None, dtype=None):
"""Creates a `RowSparseNDArray`, a multidimensional row sparse array with a set of \
tensor slices at given indices.
The RowSparseNDArray can be instantiated in several ways:
- row_sparse_array(D):
to construct a RowSparseNDArray with a dense ndarray ``D``
- **D** (*array_like*) - An object exposing the array interface, an object whose \
`__array__` method returns an array, or any (nested) sequence.
- **ctx** (*Context, optional*) - Device context \
(default is the current default context).
- **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \
The default dtype is ``D.dtype`` if ``D`` is an NDArray or numpy.ndarray, \
float32 otherwise.
- row_sparse_array(S)
to construct a RowSparseNDArray with a sparse ndarray ``S``
- **S** (*RowSparseNDArray*) - A sparse ndarray.
- **ctx** (*Context, optional*) - Device context \
(default is the current default context).
- **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \
The default dtype is ``S.dtype``.
- row_sparse_array((D0, D1 .. Dn))
to construct an empty RowSparseNDArray with shape ``(D0, D1, ... Dn)``
- **D0, D1 .. Dn** (*int*) - The shape of the ndarray
- **ctx** (*Context, optional*) - Device context \
(default is the current default context).
- **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \
The default dtype is float32.
- row_sparse_array((data, indices))
to construct a RowSparseNDArray based on the definition of row sparse format \
using two separate arrays, \
where the `indices` stores the indices of the row slices with non-zeros,
while the values are stored in `data`. The corresponding NDArray ``dense``
represented by RowSparseNDArray ``rsp`` has \
``dense[rsp.indices[i], :, :, :, ...] = rsp.data[i, :, :, :, ...]``
The row indices for are expected to be **sorted in ascending order.** \
- **data** (*array_like*) - An object exposing the array interface, which \
holds all the non-zero row slices of the array.
- **indices** (*array_like*) - An object exposing the array interface, which \
stores the row index for each row slice with non-zero elements.
- **shape** (*tuple of int, optional*) - The shape of the array. The default \
shape is inferred from the indices and indptr arrays.
- **ctx** (*Context, optional*) - Device context \
(default is the current default context).
- **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \
The default dtype is float32.
Parameters
----------
arg1 : NDArray, numpy.ndarray, RowSparseNDArray, tuple of int or tuple of array_like
The argument to help instantiate the row sparse ndarray. See above for further details.
shape : tuple of int, optional
The shape of the row sparse ndarray. (Default value = None)
ctx : Context, optional
Device context (default is the current default context).
dtype : str or numpy.dtype, optional
The data type of the output array. (Default value = None)
Returns
-------
RowSparseNDArray
An `RowSparseNDArray` with the `row_sparse` storage representation.
Examples
--------
>>> a = mx.nd.sparse.row_sparse_array(([[1, 2], [3, 4]], [1, 4]), shape=(6, 2))
>>> a.asnumpy()
array([[ 0., 0.],
[ 1., 2.],
[ 0., 0.],
[ 0., 0.],
[ 3., 4.],
[ 0., 0.]], dtype=float32)
See Also
--------
RowSparseNDArray : MXNet NDArray in row sparse format.
"""
# construct a row sparse array from (D0, D1 ..) or (data, indices)
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:
# empty ndarray with shape
_check_shape(arg1, shape)
return empty('row_sparse', arg1, ctx=ctx, dtype=dtype)
else:
# len(arg1) = 2, is either shape or (data, indices)
if isinstance(arg1[0], integer_types) and isinstance(arg1[1], integer_types):
# empty ndarray with shape
_check_shape(arg1, shape)
return empty('row_sparse', arg1, ctx=ctx, dtype=dtype)
else:
# data, indices, indptr
return _row_sparse_ndarray_from_definition(arg1[0], arg1[1], shape=shape,
ctx=ctx, dtype=dtype)
else:
# construct a row sparse ndarray from a dense / sparse array
if isinstance(arg1, RowSparseNDArray):
# construct a row sparse ndarray from RowSparseNDArray
_check_shape(arg1.shape, shape)
return array(arg1, ctx=ctx, dtype=dtype)
elif isinstance(arg1, CSRNDArray):
raise ValueError("Unexpected input type: CSRNDArray")
else:
# construct a csr matrix from a dense one
# prepare default dtype since mx.nd.array doesn't use default values
# based on source_array
dtype = _prepare_default_dtype(arg1, dtype)
# create dns array with provided dtype. ctx is not passed since copy across
# ctx requires dtype to be the same
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, 8; 5, 24; 5, 46; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:beams; 11, list_comprehension; 11, 12; 11, 13; 12, identifier:v; 13, for_in_clause; 13, 14; 13, 17; 14, tuple_pattern; 14, 15; 14, 16; 15, identifier:_; 16, identifier:v; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:entries; 22, identifier:items; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:sortedBeams; 27, call; 27, 28; 27, 29; 28, identifier:sorted; 29, argument_list; 29, 30; 29, 31; 29, 34; 30, identifier:beams; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:reverse; 33, True; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:key; 36, lambda; 36, 37; 36, 39; 37, lambda_parameters; 37, 38; 38, identifier:x; 39, binary_operator:*; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:x; 42, identifier:prTotal; 43, attribute; 43, 44; 43, 45; 44, identifier:x; 45, identifier:prText; 46, return_statement; 46, 47; 47, list_comprehension; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:x; 50, identifier:labeling; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:x; 53, identifier:sortedBeams | def sort(self):
"""
return beam-labelings, sorted by probability
"""
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, 11; 8, 21; 8, 30; 8, 31; 8, 35; 8, 151; 8, 160; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:old_seed; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:random; 19, identifier:seed; 20, argument_list; 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:np; 26, identifier:random; 27, identifier:seed; 28, argument_list; 28, 29; 29, integer:3293; 30, comment; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:method_reps; 34, list:[]; 35, for_statement; 35, 36; 35, 37; 35, 41; 36, identifier:i; 37, call; 37, 38; 37, 39; 38, identifier:range; 39, argument_list; 39, 40; 40, integer:1; 41, block; 41, 42; 41, 63; 41, 64; 41, 70; 41, 78; 41, 79; 41, 87; 41, 99; 41, 109; 41, 117; 41, 122; 41, 132; 41, 133; 41, 134; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 49; 44, pattern_list; 44, 45; 44, 46; 44, 47; 44, 48; 45, identifier:X_train; 46, identifier:X_test; 47, identifier:y_train; 48, identifier:_; 49, call; 49, 50; 49, 51; 50, identifier:train_test_split; 51, argument_list; 51, 52; 51, 56; 51, 57; 51, 60; 52, call; 52, 53; 52, 54; 53, identifier:__toarray; 54, argument_list; 54, 55; 55, identifier:X; 56, identifier:y; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:test_size; 59, integer:100; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:random_state; 62, identifier:i; 63, comment; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:model; 67, call; 67, 68; 67, 69; 68, identifier:model_generator; 69, argument_list; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:model; 74, identifier:fit; 75, argument_list; 75, 76; 75, 77; 76, identifier:X_train; 77, identifier:y_train; 78, comment; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:start; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:time; 85, identifier:time; 86, argument_list; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:explainer; 90, call; 90, 91; 90, 96; 91, call; 91, 92; 91, 93; 92, identifier:getattr; 93, argument_list; 93, 94; 93, 95; 94, identifier:methods; 95, identifier:method_name; 96, argument_list; 96, 97; 96, 98; 97, identifier:model; 98, identifier:X_train; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:build_time; 102, binary_operator:-; 102, 103; 102, 108; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:time; 106, identifier:time; 107, argument_list; 108, identifier:start; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:start; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:time; 115, identifier:time; 116, argument_list; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:explainer; 120, argument_list; 120, 121; 121, identifier:X_test; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:explain_time; 125, binary_operator:-; 125, 126; 125, 131; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:time; 129, identifier:time; 130, argument_list; 131, identifier:start; 132, comment; 133, comment; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:method_reps; 138, identifier:append; 139, argument_list; 139, 140; 140, binary_operator:+; 140, 141; 140, 142; 141, identifier:build_time; 142, binary_operator:/; 142, 143; 142, 146; 143, binary_operator:*; 143, 144; 143, 145; 144, identifier:explain_time; 145, float:1000.0; 146, subscript; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:X_test; 149, identifier:shape; 150, integer:0; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:np; 156, identifier:random; 157, identifier:seed; 158, argument_list; 158, 159; 159, identifier:old_seed; 160, return_statement; 160, 161; 161, expression_list; 161, 162; 161, 163; 162, None; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:np; 166, identifier:mean; 167, argument_list; 167, 168; 168, identifier:method_reps | def runtime(X, y, model_generator, method_name):
""" Runtime
transform = "negate"
sort_order = 1
"""
old_seed = np.random.seed()
np.random.seed(3293)
# average the method scores over several train/test splits
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)
# define the model we are going to explain
model = model_generator()
model.fit(X_train, y_train)
# evaluate each method
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
# we always normalize the explain time as though we were explaining 1000 samples
# even if to reduce the runtime of the benchmark we do less (like just 100)
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, 11; 8, 104; 8, 132; 9, expression_statement; 9, 10; 10, comment; 11, function_definition; 11, 12; 11, 13; 11, 16; 12, function_name:score_map; 13, parameters; 13, 14; 13, 15; 14, identifier:true; 15, identifier:pred; 16, block; 16, 17; 16, 19; 16, 44; 17, expression_statement; 17, 18; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:v; 22, call; 22, 23; 22, 24; 23, identifier:min; 24, argument_list; 24, 25; 24, 26; 25, float:1.0; 26, binary_operator:/; 26, 27; 26, 35; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:np; 30, identifier:std; 31, argument_list; 31, 32; 32, binary_operator:-; 32, 33; 32, 34; 33, identifier:pred; 34, identifier:true; 35, parenthesized_expression; 35, 36; 36, binary_operator:+; 36, 37; 36, 43; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:std; 41, argument_list; 41, 42; 42, identifier:true; 43, float:1e-8; 44, if_statement; 44, 45; 44, 48; 44, 51; 44, 58; 44, 65; 44, 72; 44, 79; 44, 86; 44, 93; 44, 100; 45, comparison_operator:<; 45, 46; 45, 47; 46, identifier:v; 47, float:1e-6; 48, block; 48, 49; 49, return_statement; 49, 50; 50, float:1.0; 51, elif_clause; 51, 52; 51, 55; 52, comparison_operator:<; 52, 53; 52, 54; 53, identifier:v; 54, float:0.01; 55, block; 55, 56; 56, return_statement; 56, 57; 57, float:0.9; 58, elif_clause; 58, 59; 58, 62; 59, comparison_operator:<; 59, 60; 59, 61; 60, identifier:v; 61, float:0.05; 62, block; 62, 63; 63, return_statement; 63, 64; 64, float:0.75; 65, elif_clause; 65, 66; 65, 69; 66, comparison_operator:<; 66, 67; 66, 68; 67, identifier:v; 68, float:0.1; 69, block; 69, 70; 70, return_statement; 70, 71; 71, float:0.6; 72, elif_clause; 72, 73; 72, 76; 73, comparison_operator:<; 73, 74; 73, 75; 74, identifier:v; 75, float:0.2; 76, block; 76, 77; 77, return_statement; 77, 78; 78, float:0.4; 79, elif_clause; 79, 80; 79, 83; 80, comparison_operator:<; 80, 81; 80, 82; 81, identifier:v; 82, float:0.3; 83, block; 83, 84; 84, return_statement; 84, 85; 85, float:0.3; 86, elif_clause; 86, 87; 86, 90; 87, comparison_operator:<; 87, 88; 87, 89; 88, identifier:v; 89, float:0.5; 90, block; 90, 91; 91, return_statement; 91, 92; 92, float:0.2; 93, elif_clause; 93, 94; 93, 97; 94, comparison_operator:<; 94, 95; 94, 96; 95, identifier:v; 96, float:0.7; 97, block; 97, 98; 98, return_statement; 98, 99; 99, float:0.1; 100, else_clause; 100, 101; 101, block; 101, 102; 102, return_statement; 102, 103; 103, float:0.0; 104, function_definition; 104, 105; 104, 106; 104, 114; 105, function_name:score_function; 106, parameters; 106, 107; 106, 108; 106, 109; 106, 110; 106, 111; 106, 112; 106, 113; 107, identifier:X_train; 108, identifier:X_test; 109, identifier:y_train; 110, identifier:y_test; 111, identifier:attr_function; 112, identifier:trained_model; 113, identifier:random_state; 114, block; 114, 115; 115, return_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:measures; 119, identifier:local_accuracy; 120, argument_list; 120, 121; 120, 122; 120, 123; 120, 124; 120, 125; 120, 129; 120, 130; 120, 131; 121, identifier:X_train; 122, identifier:y_train; 123, identifier:X_test; 124, identifier:y_test; 125, call; 125, 126; 125, 127; 126, identifier:attr_function; 127, argument_list; 127, 128; 128, identifier:X_test; 129, identifier:model_generator; 130, identifier:score_map; 131, identifier:trained_model; 132, return_statement; 132, 133; 133, expression_list; 133, 134; 133, 135; 134, None; 135, call; 135, 136; 135, 137; 136, identifier:__score_method; 137, argument_list; 137, 138; 137, 139; 137, 140; 137, 141; 137, 142; 137, 143; 138, identifier:X; 139, identifier:y; 140, None; 141, identifier:model_generator; 142, identifier:score_function; 143, identifier:method_name | def local_accuracy(X, y, model_generator, method_name):
""" Local Accuracy
transform = "identity"
sort_order = 2
"""
def score_map(true, pred):
""" Converts local accuracy from % of standard deviation to numerical scores for coloring.
"""
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, 8; 5, 21; 5, 28; 5, 50; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:checkpoint_info; 11, call; 11, 12; 11, 19; 12, attribute; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:ray; 16, identifier:worker; 17, identifier:global_state; 18, identifier:actor_checkpoint_info; 19, argument_list; 19, 20; 20, identifier:actor_id; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:checkpoint_info; 24, None; 25, block; 25, 26; 26, return_statement; 26, 27; 27, list:[]; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:checkpoints; 31, list_comprehension; 31, 32; 31, 37; 32, call; 32, 33; 32, 34; 33, identifier:Checkpoint; 34, argument_list; 34, 35; 34, 36; 35, identifier:checkpoint_id; 36, identifier:timestamp; 37, for_in_clause; 37, 38; 37, 41; 38, pattern_list; 38, 39; 38, 40; 39, identifier:checkpoint_id; 40, identifier:timestamp; 41, call; 41, 42; 41, 43; 42, identifier:zip; 43, argument_list; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:checkpoint_info; 46, string:"CheckpointIds"; 47, subscript; 47, 48; 47, 49; 48, identifier:checkpoint_info; 49, string:"Timestamps"; 50, return_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:sorted; 53, argument_list; 53, 54; 53, 55; 53, 63; 54, identifier:checkpoints; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:key; 57, lambda; 57, 58; 57, 60; 58, lambda_parameters; 58, 59; 59, identifier:checkpoint; 60, attribute; 60, 61; 60, 62; 61, identifier:checkpoint; 62, identifier:timestamp; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:reverse; 65, True | def get_checkpoints_for_actor(actor_id):
"""Get the available checkpoints for the given actor ID, return a list
sorted by checkpoint timestamp in descending order.
"""
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, 8; 5, 18; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:splits; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:re; 14, identifier:split; 15, argument_list; 15, 16; 15, 17; 16, string:"([0-9]+)"; 17, identifier:string; 18, return_statement; 18, 19; 19, list_comprehension; 19, 20; 19, 35; 20, conditional_expression:if; 20, 21; 20, 25; 20, 30; 21, call; 21, 22; 21, 23; 22, identifier:int; 23, argument_list; 23, 24; 24, identifier:text; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:text; 28, identifier:isdigit; 29, argument_list; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:text; 33, identifier:lower; 34, argument_list; 35, for_in_clause; 35, 36; 35, 37; 36, identifier:text; 37, identifier:splits | def _naturalize(string):
"""Provides a natural representation for string for nice sorting."""
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, 10; 7, 18; 7, 38; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 17; 12, subscript; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:adapters; 16, identifier:prefix; 17, identifier:adapter; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:keys_to_move; 21, list_comprehension; 21, 22; 21, 23; 21, 28; 22, identifier:k; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:k; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:adapters; 28, if_clause; 28, 29; 29, comparison_operator:<; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:k; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, identifier:prefix; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:key; 40, identifier:keys_to_move; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 49; 44, subscript; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:adapters; 48, identifier:key; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:adapters; 54, identifier:pop; 55, argument_list; 55, 56; 56, identifier:key | def mount(self, prefix, adapter):
"""Registers a connection adapter to a prefix.
Adapters are sorted in descending order by prefix length.
"""
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; 1, 6; 2, function_name:sorted_outrows; 3, parameters; 3, 4; 4, identifier:outrows; 5, comment; 6, block; 6, 7; 6, 9; 6, 10; 6, 11; 6, 12; 6, 13; 6, 14; 6, 15; 6, 16; 6, 17; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, comment; 11, comment; 12, comment; 13, comment; 14, comment; 15, comment; 16, comment; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 20, 22; 21, identifier:outrows; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:key; 24, lambda; 24, 25; 24, 27; 25, lambda_parameters; 25, 26; 26, identifier:row; 27, call; 27, 28; 27, 29; 28, identifier:tuple; 29, generator_expression; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:str; 32, argument_list; 32, 33; 33, identifier:x; 34, for_in_clause; 34, 35; 34, 36; 35, identifier:x; 36, identifier:row | def sorted_outrows(outrows):
# type: (Iterable[InstalledCSVRow]) -> List[InstalledCSVRow]
"""
Return the given rows of a RECORD file in sorted order.
Each row is a 3-tuple (path, hash, size) and corresponds to a record of
a RECORD file (see PEP 376 and PEP 427 for details). For the rows
passed to this function, the size can be an integer as an int or string,
or the empty string.
"""
# Normally, there should only be one row per path, in which case the
# second and third elements don't come into play when sorting.
# However, in cases in the wild where a path might happen to occur twice,
# we don't want the sort operation to trigger an error (but still want
# determinism). Since the third element can be an int or string, we
# coerce each element to a string to avoid a TypeError in this case.
# For additional background, see--
# https://github.com/pypa/pip/issues/5868
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, 8; 5, 15; 5, 125; 5, 139; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:f; 11, call; 11, 12; 11, 13; 12, identifier:_trim_arity; 13, argument_list; 13, 14; 14, identifier:f; 15, function_definition; 15, 16; 15, 17; 15, 20; 16, function_name:z; 17, parameters; 17, 18; 18, list_splat_pattern; 18, 19; 19, identifier:paArgs; 20, block; 20, 21; 20, 27; 20, 39; 20, 61; 20, 80; 20, 110; 20, 123; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:thisFunc; 24, attribute; 24, 25; 24, 26; 25, identifier:f; 26, identifier:__name__; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 33; 29, pattern_list; 29, 30; 29, 31; 29, 32; 30, identifier:s; 31, identifier:l; 32, identifier:t; 33, subscript; 33, 34; 33, 35; 34, identifier:paArgs; 35, slice; 35, 36; 35, 38; 36, unary_operator:-; 36, 37; 37, integer:3; 38, colon; 39, if_statement; 39, 40; 39, 46; 40, comparison_operator:>; 40, 41; 40, 45; 41, call; 41, 42; 41, 43; 42, identifier:len; 43, argument_list; 43, 44; 44, identifier:paArgs; 45, integer:3; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:thisFunc; 50, binary_operator:+; 50, 51; 50, 60; 51, binary_operator:+; 51, 52; 51, 59; 52, attribute; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:paArgs; 56, integer:0; 57, identifier:__class__; 58, identifier:__name__; 59, string:'.'; 60, identifier:thisFunc; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:sys; 66, identifier:stderr; 67, identifier:write; 68, argument_list; 68, 69; 69, binary_operator:%; 69, 70; 69, 71; 70, string:">>entering %s(line: '%s', %d, %r)\n"; 71, tuple; 71, 72; 71, 73; 71, 78; 71, 79; 72, identifier:thisFunc; 73, call; 73, 74; 73, 75; 74, identifier:line; 75, argument_list; 75, 76; 75, 77; 76, identifier:l; 77, identifier:s; 78, identifier:l; 79, identifier:t; 80, try_statement; 80, 81; 80, 90; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:ret; 85, call; 85, 86; 85, 87; 86, identifier:f; 87, argument_list; 87, 88; 88, list_splat; 88, 89; 89, identifier:paArgs; 90, except_clause; 90, 91; 90, 95; 91, as_pattern; 91, 92; 91, 93; 92, identifier:Exception; 93, as_pattern_target; 93, 94; 94, identifier:exc; 95, block; 95, 96; 95, 109; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:sys; 101, identifier:stderr; 102, identifier:write; 103, argument_list; 103, 104; 104, binary_operator:%; 104, 105; 104, 106; 105, string:"<<leaving %s (exception: %s)\n"; 106, tuple; 106, 107; 106, 108; 107, identifier:thisFunc; 108, identifier:exc; 109, raise_statement; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:sys; 115, identifier:stderr; 116, identifier:write; 117, argument_list; 117, 118; 118, binary_operator:%; 118, 119; 118, 120; 119, string:"<<leaving %s (ret: %r)\n"; 120, tuple; 120, 121; 120, 122; 121, identifier:thisFunc; 122, identifier:ret; 123, return_statement; 123, 124; 124, identifier:ret; 125, try_statement; 125, 126; 125, 135; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:z; 131, identifier:__name__; 132, attribute; 132, 133; 132, 134; 133, identifier:f; 134, identifier:__name__; 135, except_clause; 135, 136; 135, 137; 136, identifier:AttributeError; 137, block; 137, 138; 138, pass_statement; 139, return_statement; 139, 140; 140, identifier:z | def traceParseAction(f):
"""Decorator for debugging parse actions.
When the parse action is called, this decorator will print
``">> entering method-name(line:<current_source_line>, <parse_location>, <matched_tokens>)"``.
When the parse action completes, the decorator will print
``"<<"`` followed by the returned value, or any exception that the parse action raised.
Example::
wd = Word(alphas)
@traceParseAction
def remove_duplicate_chars(tokens):
return ''.join(sorted(set(''.join(tokens))))
wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
prints::
>>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
<<leaving remove_duplicate_chars (ret: 'dfjkls')
['dfjkls']
"""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:OrderedDict; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:sorted; 14, argument_list; 14, 15; 14, 37; 15, list_comprehension; 15, 16; 15, 28; 16, tuple; 16, 17; 16, 18; 17, identifier:k; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 20, 22; 21, identifier:v; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:key; 24, call; 24, 25; 24, 26; 25, identifier:attrgetter; 26, argument_list; 26, 27; 27, string:'key'; 28, for_in_clause; 28, 29; 28, 32; 29, pattern_list; 29, 30; 29, 31; 30, identifier:k; 31, identifier:v; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:tree; 35, identifier:items; 36, argument_list; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:key; 39, lambda; 39, 40; 39, 42; 40, lambda_parameters; 40, 41; 41, identifier:kv; 42, attribute; 42, 43; 42, 46; 43, subscript; 43, 44; 43, 45; 44, identifier:kv; 45, integer:0; 46, identifier:key | def sorted_tree(tree):
"""Sorts the dict representation of the tree
The root packages as well as the intermediate packages are sorted
in the alphabetical order of the package names.
:param dict tree: the pkg dependency tree obtained by calling
`construct_tree` function
:returns: sorted tree
:rtype: collections.OrderedDict
"""
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, 18; 15, 33; 16, expression_statement; 16, 17; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:key_func; 21, call; 21, 22; 21, 23; 22, identifier:make_attrgetter; 23, argument_list; 23, 24; 23, 25; 23, 26; 24, identifier:environment; 25, identifier:attribute; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:postprocess; 28, conditional_expression:if; 28, 29; 28, 30; 28, 32; 29, identifier:ignore_case; 30, not_operator; 30, 31; 31, identifier:case_sensitive; 32, None; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:sorted; 36, argument_list; 36, 37; 36, 38; 36, 41; 37, identifier:value; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, identifier:key_func; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:reverse; 43, identifier:reverse | def do_sort(
environment, value, reverse=False, case_sensitive=False, attribute=None
):
"""Sort an iterable. Per default it sorts ascending, if you pass it
true as first argument it will reverse the sorting.
If the iterable is made of strings the third parameter can be used to
control the case sensitiveness of the comparison which is disabled by
default.
.. sourcecode:: jinja
{% for item in iterable|sort %}
...
{% endfor %}
It is also possible to sort by an attribute (for example to sort
by the date of an object) by specifying the `attribute` parameter:
.. sourcecode:: jinja
{% for item in iterable|sort(attribute='date') %}
...
{% endfor %}
.. versionchanged:: 2.6
The `attribute` parameter was added.
"""
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, 11; 8, 64; 8, 73; 8, 74; 8, 104; 9, expression_statement; 9, 10; 10, comment; 11, function_definition; 11, 12; 11, 13; 11, 16; 12, function_name:add_dir; 13, parameters; 13, 14; 13, 15; 14, identifier:dirs; 15, identifier:d; 16, block; 16, 17; 16, 24; 16, 32; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:dirs; 21, identifier:add; 22, argument_list; 22, 23; 23, identifier:d; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:logger; 28, identifier:debug; 29, argument_list; 29, 30; 29, 31; 30, string:'add_dir added %s'; 31, identifier:d; 32, if_statement; 32, 33; 32, 38; 33, comparison_operator:!=; 33, 34; 33, 35; 34, identifier:d; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:base; 38, block; 38, 39; 38, 52; 38, 58; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, pattern_list; 41, 42; 41, 43; 42, identifier:parent; 43, identifier:_; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:os; 48, identifier:path; 49, identifier:split; 50, argument_list; 50, 51; 51, identifier:d; 52, assert_statement; 52, 53; 53, comparison_operator:not; 53, 54; 53, 55; 54, identifier:parent; 55, tuple; 55, 56; 55, 57; 56, string:''; 57, string:'/'; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:add_dir; 61, argument_list; 61, 62; 61, 63; 62, identifier:dirs; 63, identifier:parent; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:result; 67, call; 67, 68; 67, 69; 68, identifier:set; 69, argument_list; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:files; 73, comment; 74, if_statement; 74, 75; 74, 76; 75, identifier:wantdirs; 76, block; 76, 77; 76, 83; 76, 100; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:dirs; 80, call; 80, 81; 80, 82; 81, identifier:set; 82, argument_list; 83, for_statement; 83, 84; 83, 85; 83, 86; 84, identifier:f; 85, identifier:result; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:add_dir; 90, argument_list; 90, 91; 90, 92; 91, identifier:dirs; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:os; 96, identifier:path; 97, identifier:dirname; 98, argument_list; 98, 99; 99, identifier:f; 100, expression_statement; 100, 101; 101, augmented_assignment:|=; 101, 102; 101, 103; 102, identifier:result; 103, identifier:dirs; 104, return_statement; 104, 105; 105, list_comprehension; 105, 106; 105, 115; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:os; 110, identifier:path; 111, identifier:join; 112, argument_list; 112, 113; 113, list_splat; 113, 114; 114, identifier:path_tuple; 115, for_in_clause; 115, 116; 115, 117; 116, identifier:path_tuple; 117, call; 117, 118; 117, 119; 118, identifier:sorted; 119, generator_expression; 119, 120; 119, 128; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:os; 124, identifier:path; 125, identifier:split; 126, argument_list; 126, 127; 127, identifier:path; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:path; 130, identifier:result | def sorted(self, wantdirs=False):
"""
Return sorted files in directory order
"""
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) # make a copy!
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, 13; 10, 20; 10, 44; 10, 53; 10, 54; 10, 55; 10, 67; 10, 79; 10, 80; 10, 81; 10, 82; 10, 83; 10, 84; 10, 124; 11, expression_statement; 11, 12; 12, comment; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:validate_event_metadata; 16, argument_list; 16, 17; 16, 18; 16, 19; 17, identifier:event_dates; 18, identifier:event_timestamps; 19, identifier:event_sids; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:out; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:np; 26, identifier:full; 27, argument_list; 27, 28; 27, 37; 27, 39; 28, tuple; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:all_dates; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:all_sids; 37, unary_operator:-; 37, 38; 38, integer:1; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:dtype; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:int64; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:sid_ixs; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:all_sids; 50, identifier:searchsorted; 51, argument_list; 51, 52; 52, identifier:event_sids; 53, comment; 54, comment; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:dt_ixs; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:all_dates; 61, identifier:searchsorted; 62, argument_list; 62, 63; 62, 64; 63, identifier:event_dates; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:side; 66, string:'right'; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:ts_ixs; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:data_query_cutoff; 73, identifier:searchsorted; 74, argument_list; 74, 75; 74, 76; 75, identifier:event_timestamps; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:side; 78, string:'right'; 79, comment; 80, comment; 81, comment; 82, comment; 83, comment; 84, for_statement; 84, 85; 84, 86; 84, 99; 85, identifier:i; 86, call; 86, 87; 86, 88; 87, identifier:range; 88, argument_list; 88, 89; 88, 95; 88, 97; 89, binary_operator:-; 89, 90; 89, 94; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:event_sids; 94, integer:1; 95, unary_operator:-; 95, 96; 96, integer:1; 97, unary_operator:-; 97, 98; 98, integer:1; 99, block; 99, 100; 99, 106; 99, 112; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:start_ix; 103, subscript; 103, 104; 103, 105; 104, identifier:ts_ixs; 105, identifier:i; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:end_ix; 109, subscript; 109, 110; 109, 111; 110, identifier:dt_ixs; 111, identifier:i; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 123; 114, subscript; 114, 115; 114, 116; 114, 120; 115, identifier:out; 116, slice; 116, 117; 116, 118; 116, 119; 117, identifier:start_ix; 118, colon; 119, identifier:end_ix; 120, subscript; 120, 121; 120, 122; 121, identifier:sid_ixs; 122, identifier:i; 123, identifier:i; 124, return_statement; 124, 125; 125, identifier:out | def next_event_indexer(all_dates,
data_query_cutoff,
all_sids,
event_dates,
event_timestamps,
event_sids):
"""
Construct an index array that, when applied to an array of values, produces
a 2D array containing the values associated with the next event for each
sid at each moment in time.
Locations where no next event was known will be filled with -1.
Parameters
----------
all_dates : ndarray[datetime64[ns], ndim=1]
Row labels for the target output.
data_query_cutoff : pd.DatetimeIndex
The boundaries for the given trading sessions in ``all_dates``.
all_sids : ndarray[int, ndim=1]
Column labels for the target output.
event_dates : ndarray[datetime64[ns], ndim=1]
Dates on which each input events occurred/will occur. ``event_dates``
must be in sorted order, and may not contain any NaT values.
event_timestamps : ndarray[datetime64[ns], ndim=1]
Dates on which we learned about each input event.
event_sids : ndarray[int, ndim=1]
Sids assocated with each input event.
Returns
-------
indexer : ndarray[int, ndim=2]
An array of shape (len(all_dates), len(all_sids)) of indices into
``event_{dates,timestamps,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)
# side='right' here ensures that we include the event date itself
# if it's in all_dates.
dt_ixs = all_dates.searchsorted(event_dates, side='right')
ts_ixs = data_query_cutoff.searchsorted(event_timestamps, side='right')
# Walk backward through the events, writing the index of the event into
# slots ranging from the event's timestamp to its asof. This depends for
# correctness on the fact that event_dates is sorted in ascending order,
# because we need to overwrite later events with earlier ones if their
# eligible windows overlap.
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, 12; 9, 19; 9, 43; 9, 53; 9, 62; 9, 74; 9, 75; 9, 76; 9, 77; 9, 78; 9, 79; 9, 83; 9, 133; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:validate_event_metadata; 15, argument_list; 15, 16; 15, 17; 15, 18; 16, identifier:event_dates; 17, identifier:event_timestamps; 18, identifier:event_sids; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:out; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:full; 26, argument_list; 26, 27; 26, 36; 26, 38; 27, tuple; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:data_query_cutoff_times; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:all_sids; 36, unary_operator:-; 36, 37; 37, integer:1; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:dtype; 40, attribute; 40, 41; 40, 42; 41, identifier:np; 42, identifier:int64; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:eff_dts; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:np; 49, identifier:maximum; 50, argument_list; 50, 51; 50, 52; 51, identifier:event_dates; 52, identifier:event_timestamps; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:sid_ixs; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:all_sids; 59, identifier:searchsorted; 60, argument_list; 60, 61; 61, identifier:event_sids; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:dt_ixs; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:data_query_cutoff_times; 68, identifier:searchsorted; 69, argument_list; 69, 70; 69, 71; 70, identifier:eff_dts; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:side; 73, string:'right'; 74, comment; 75, comment; 76, comment; 77, comment; 78, comment; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:last_written; 82, dictionary; 83, for_statement; 83, 84; 83, 85; 83, 98; 84, identifier:i; 85, call; 85, 86; 85, 87; 86, identifier:range; 87, argument_list; 87, 88; 87, 94; 87, 96; 88, binary_operator:-; 88, 89; 88, 93; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:event_dates; 93, integer:1; 94, unary_operator:-; 94, 95; 95, integer:1; 96, unary_operator:-; 96, 97; 97, integer:1; 98, block; 98, 99; 98, 105; 98, 111; 98, 127; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:sid_ix; 102, subscript; 102, 103; 102, 104; 103, identifier:sid_ixs; 104, identifier:i; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:dt_ix; 108, subscript; 108, 109; 108, 110; 109, identifier:dt_ixs; 110, identifier:i; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 126; 113, subscript; 113, 114; 113, 115; 113, 125; 114, identifier:out; 115, slice; 115, 116; 115, 117; 115, 118; 116, identifier:dt_ix; 117, colon; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:last_written; 121, identifier:get; 122, argument_list; 122, 123; 122, 124; 123, identifier:sid_ix; 124, None; 125, identifier:sid_ix; 126, identifier:i; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:last_written; 131, identifier:sid_ix; 132, identifier:dt_ix; 133, return_statement; 133, 134; 134, identifier:out | def previous_event_indexer(data_query_cutoff_times,
all_sids,
event_dates,
event_timestamps,
event_sids):
"""
Construct an index array that, when applied to an array of values, produces
a 2D array containing the values associated with the previous event for
each sid at each moment in time.
Locations where no previous event was known will be filled with -1.
Parameters
----------
data_query_cutoff : pd.DatetimeIndex
The boundaries for the given trading sessions.
all_dates : ndarray[datetime64[ns], ndim=1]
Row labels for the target output.
all_sids : ndarray[int, ndim=1]
Column labels for the target output.
event_dates : ndarray[datetime64[ns], ndim=1]
Dates on which each input events occurred/will occur. ``event_dates``
must be in sorted order, and may not contain any NaT values.
event_timestamps : ndarray[datetime64[ns], ndim=1]
Dates on which we learned about each input event.
event_sids : ndarray[int, ndim=1]
Sids assocated with each input event.
Returns
-------
indexer : ndarray[int, ndim=2]
An array of shape (len(all_dates), len(all_sids)) of indices into
``event_{dates,timestamps,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')
# Walk backwards through the events, writing the index of the event into
# slots ranging from max(event_date, event_timestamp) to the start of the
# previously-written event. This depends for correctness on the fact that
# event_dates is sorted in ascending order, because we need to have written
# later events so we know where to stop forward-filling earlier events.
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, 19; 16, 35; 16, 43; 16, 52; 16, 56; 16, 80; 16, 81; 16, 82; 16, 83; 16, 84; 16, 106; 16, 173; 17, expression_statement; 17, 18; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:idx; 22, list:[data_query_cutoff_times[data_query_cutoff_times.searchsorted(
df[TS_FIELD_NAME].values,
)]]; 22, 23; 23, subscript; 23, 24; 23, 25; 24, identifier:data_query_cutoff_times; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:data_query_cutoff_times; 28, identifier:searchsorted; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:df; 33, identifier:TS_FIELD_NAME; 34, identifier:values; 35, if_statement; 35, 36; 35, 37; 36, identifier:have_sids; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, augmented_assignment:+=; 39, 40; 39, 41; 40, identifier:idx; 41, list:[SID_FIELD_NAME]; 41, 42; 42, identifier:SID_FIELD_NAME; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:extra_groupers; 46, None; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:extra_groupers; 51, list:[]; 52, expression_statement; 52, 53; 53, augmented_assignment:+=; 53, 54; 53, 55; 54, identifier:idx; 55, identifier:extra_groupers; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:last_in_group; 59, call; 59, 60; 59, 79; 60, attribute; 60, 61; 60, 78; 61, call; 61, 62; 61, 73; 62, attribute; 62, 63; 62, 72; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:df; 66, identifier:drop; 67, argument_list; 67, 68; 67, 69; 68, identifier:TS_FIELD_NAME; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:axis; 71, integer:1; 72, identifier:groupby; 73, argument_list; 73, 74; 73, 75; 74, identifier:idx; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:sort; 77, False; 78, identifier:last; 79, argument_list; 80, comment; 81, comment; 82, comment; 83, comment; 84, for_statement; 84, 85; 84, 86; 84, 95; 85, identifier:_; 86, call; 86, 87; 86, 88; 87, identifier:range; 88, argument_list; 88, 89; 89, binary_operator:-; 89, 90; 89, 94; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:idx; 94, integer:1; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:last_in_group; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:last_in_group; 102, identifier:unstack; 103, argument_list; 103, 104; 104, unary_operator:-; 104, 105; 105, integer:1; 106, if_statement; 106, 107; 106, 108; 107, identifier:reindex; 108, block; 108, 109; 109, if_statement; 109, 110; 109, 111; 109, 162; 110, identifier:have_sids; 111, block; 111, 112; 111, 118; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:cols; 115, attribute; 115, 116; 115, 117; 116, identifier:last_in_group; 117, identifier:columns; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:last_in_group; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:last_in_group; 124, identifier:reindex; 125, argument_list; 125, 126; 125, 129; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:index; 128, identifier:data_query_cutoff_times; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:columns; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:pd; 135, identifier:MultiIndex; 136, identifier:from_product; 137, argument_list; 137, 138; 137, 157; 138, binary_operator:+; 138, 139; 138, 155; 139, call; 139, 140; 139, 141; 140, identifier:tuple; 141, argument_list; 141, 142; 142, subscript; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:cols; 145, identifier:levels; 146, slice; 146, 147; 146, 148; 146, 149; 147, integer:0; 148, colon; 149, binary_operator:+; 149, 150; 149, 154; 150, call; 150, 151; 150, 152; 151, identifier:len; 152, argument_list; 152, 153; 153, identifier:extra_groupers; 154, integer:1; 155, tuple; 155, 156; 156, identifier:assets; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:names; 159, attribute; 159, 160; 159, 161; 160, identifier:cols; 161, identifier:names; 162, else_clause; 162, 163; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:last_in_group; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:last_in_group; 170, identifier:reindex; 171, argument_list; 171, 172; 172, identifier:data_query_cutoff_times; 173, return_statement; 173, 174; 174, identifier:last_in_group | def last_in_date_group(df,
data_query_cutoff_times,
assets,
reindex=True,
have_sids=True,
extra_groupers=None):
"""
Determine the last piece of information known on each date in the date
index for each group. Input df MUST be sorted such that the correct last
item is chosen from each group.
Parameters
----------
df : pd.DataFrame
The DataFrame containing the data to be grouped. Must be sorted so that
the correct last item is chosen from each group.
data_query_cutoff_times : pd.DatetimeIndex
The dates to use for grouping and reindexing.
assets : pd.Int64Index
The assets that should be included in the column multiindex.
reindex : bool
Whether or not the DataFrame should be reindexed against the date
index. This will add back any dates to the index that were grouped
away.
have_sids : bool
Whether or not the DataFrame has sids. If it does, they will be used
in the groupby.
extra_groupers : list of str
Any extra field names that should be included in the groupby.
Returns
-------
last_in_group : pd.DataFrame
A DataFrame with dates as the index and fields used in the groupby as
levels of a multiindex of columns.
"""
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 the number of things that we're grouping by (except TS), unstack
# the df. Done this way because of an unresolved pandas bug whereby
# passing a list of levels with mixed dtypes to unstack causes the
# resulting DataFrame to have all object-type columns.
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, 13; 10, 31; 10, 32; 10, 55; 10, 69; 10, 83; 10, 99; 10, 108; 10, 109; 10, 110; 10, 111; 10, 112; 10, 113; 10, 114; 10, 115; 10, 127; 10, 148; 10, 223; 10, 224; 10, 225; 11, expression_statement; 11, 12; 12, comment; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:algorithm_returns; 16, subscript; 16, 17; 16, 18; 17, identifier:algorithm_returns; 18, binary_operator:&; 18, 19; 18, 25; 19, parenthesized_expression; 19, 20; 20, comparison_operator:>=; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:algorithm_returns; 23, identifier:index; 24, identifier:start_session; 25, parenthesized_expression; 25, 26; 26, comparison_operator:<=; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:algorithm_returns; 29, identifier:index; 30, identifier:end_session; 31, comment; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:benchmark_returns; 35, subscript; 35, 36; 35, 37; 36, identifier:benchmark_returns; 37, binary_operator:&; 37, 38; 37, 44; 38, parenthesized_expression; 38, 39; 39, comparison_operator:>=; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:benchmark_returns; 42, identifier:index; 43, identifier:start_session; 44, parenthesized_expression; 44, 45; 45, comparison_operator:<=; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:benchmark_returns; 48, identifier:index; 49, subscript; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:algorithm_returns; 52, identifier:index; 53, unary_operator:-; 53, 54; 54, integer:1; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:benchmark_period_returns; 58, subscript; 58, 59; 58, 67; 59, attribute; 59, 60; 59, 66; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:ep; 63, identifier:cum_returns; 64, argument_list; 64, 65; 65, identifier:benchmark_returns; 66, identifier:iloc; 67, unary_operator:-; 67, 68; 68, integer:1; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:algorithm_period_returns; 72, subscript; 72, 73; 72, 81; 73, attribute; 73, 74; 73, 80; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:ep; 77, identifier:cum_returns; 78, argument_list; 78, 79; 79, identifier:algorithm_returns; 80, identifier:iloc; 81, unary_operator:-; 81, 82; 82, integer:1; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, pattern_list; 85, 86; 85, 87; 86, identifier:alpha; 87, identifier:beta; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:ep; 91, identifier:alpha_beta_aligned; 92, argument_list; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:algorithm_returns; 95, identifier:values; 96, attribute; 96, 97; 96, 98; 97, identifier:benchmark_returns; 98, identifier:values; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:sharpe; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:ep; 105, identifier:sharpe_ratio; 106, argument_list; 106, 107; 107, identifier:algorithm_returns; 108, comment; 109, comment; 110, comment; 111, comment; 112, comment; 113, comment; 114, comment; 115, if_statement; 115, 116; 115, 122; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:pd; 119, identifier:isnull; 120, argument_list; 120, 121; 121, identifier:sharpe; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:sharpe; 126, float:0.0; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:sortino; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:ep; 133, identifier:sortino_ratio; 134, argument_list; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:algorithm_returns; 137, identifier:values; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:_downside_risk; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:ep; 143, identifier:downside_risk; 144, argument_list; 144, 145; 145, attribute; 145, 146; 145, 147; 146, identifier:algorithm_returns; 147, identifier:values; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:rval; 151, dictionary; 151, 152; 151, 155; 151, 158; 151, 161; 151, 164; 151, 167; 151, 170; 151, 173; 151, 176; 151, 184; 151, 190; 151, 198; 151, 206; 151, 216; 152, pair; 152, 153; 152, 154; 153, string:'algorithm_period_return'; 154, identifier:algorithm_period_returns; 155, pair; 155, 156; 155, 157; 156, string:'benchmark_period_return'; 157, identifier:benchmark_period_returns; 158, pair; 158, 159; 158, 160; 159, string:'treasury_period_return'; 160, integer:0; 161, pair; 161, 162; 161, 163; 162, string:'excess_return'; 163, identifier:algorithm_period_returns; 164, pair; 164, 165; 164, 166; 165, string:'alpha'; 166, identifier:alpha; 167, pair; 167, 168; 167, 169; 168, string:'beta'; 169, identifier:beta; 170, pair; 170, 171; 170, 172; 171, string:'sharpe'; 172, identifier:sharpe; 173, pair; 173, 174; 173, 175; 174, string:'sortino'; 175, identifier:sortino; 176, pair; 176, 177; 176, 178; 177, string:'period_label'; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:end_session; 181, identifier:strftime; 182, argument_list; 182, 183; 183, string:"%Y-%m"; 184, pair; 184, 185; 184, 186; 185, string:'trading_days'; 186, call; 186, 187; 186, 188; 187, identifier:len; 188, argument_list; 188, 189; 189, identifier:benchmark_returns; 190, pair; 190, 191; 190, 192; 191, string:'algo_volatility'; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:ep; 195, identifier:annual_volatility; 196, argument_list; 196, 197; 197, identifier:algorithm_returns; 198, pair; 198, 199; 198, 200; 199, string:'benchmark_volatility'; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:ep; 203, identifier:annual_volatility; 204, argument_list; 204, 205; 205, identifier:benchmark_returns; 206, pair; 206, 207; 206, 208; 207, string:'max_drawdown'; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:ep; 211, identifier:max_drawdown; 212, argument_list; 212, 213; 213, attribute; 213, 214; 213, 215; 214, identifier:algorithm_returns; 215, identifier:values; 216, pair; 216, 217; 216, 218; 217, string:'max_leverage'; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:algorithm_leverages; 221, identifier:max; 222, argument_list; 223, comment; 224, comment; 225, return_statement; 225, 226; 226, dictionary_comprehension; 226, 227; 226, 244; 227, pair; 227, 228; 227, 229; 228, identifier:k; 229, parenthesized_expression; 229, 230; 230, conditional_expression:if; 230, 231; 230, 232; 230, 243; 231, None; 232, boolean_operator:and; 232, 233; 232, 236; 233, comparison_operator:!=; 233, 234; 233, 235; 234, identifier:k; 235, string:'period_label'; 236, not_operator; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:np; 240, identifier:isfinite; 241, argument_list; 241, 242; 242, identifier:v; 243, identifier:v; 244, for_in_clause; 244, 245; 244, 248; 245, pattern_list; 245, 246; 245, 247; 246, identifier:k; 247, identifier:v; 248, call; 248, 249; 248, 250; 249, identifier:iteritems; 250, argument_list; 250, 251; 251, identifier:rval | def risk_metric_period(cls,
start_session,
end_session,
algorithm_returns,
benchmark_returns,
algorithm_leverages):
"""
Creates a dictionary representing the state of the risk report.
Parameters
----------
start_session : pd.Timestamp
Start of period (inclusive) to produce metrics on
end_session : pd.Timestamp
End of period (inclusive) to produce metrics on
algorithm_returns : pd.Series(pd.Timestamp -> float)
Series of algorithm returns as of the end of each session
benchmark_returns : pd.Series(pd.Timestamp -> float)
Series of benchmark returns as of the end of each session
algorithm_leverages : pd.Series(pd.Timestamp -> float)
Series of algorithm leverages as of the end of each session
Returns
-------
risk_metric : dict[str, any]
Dict of metrics that with fields like:
{
'algorithm_period_return': 0.0,
'benchmark_period_return': 0.0,
'treasury_period_return': 0,
'excess_return': 0.0,
'alpha': 0.0,
'beta': 0.0,
'sharpe': 0.0,
'sortino': 0.0,
'period_label': '1970-01',
'trading_days': 0,
'algo_volatility': 0.0,
'benchmark_volatility': 0.0,
'max_drawdown': 0.0,
'max_leverage': 0.0,
}
"""
algorithm_returns = algorithm_returns[
(algorithm_returns.index >= start_session) &
(algorithm_returns.index <= end_session)
]
# Benchmark needs to be masked to the same dates as the algo returns
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)
# The consumer currently expects a 0.0 value for sharpe in period,
# this differs from cumulative which was np.nan.
# When factoring out the sharpe_ratio, the different return types
# were collapsed into `np.nan`.
# TODO: Either fix consumer to accept `np.nan` or make the
# `sharpe_ratio` return type configurable.
# In the meantime, convert nan values to 0.0
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(),
}
# check if a field in rval is nan or inf, and replace it with None
# except period_label which is always a str
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, 12; 9, 13; 9, 14; 9, 15; 9, 33; 9, 39; 9, 40; 9, 49; 9, 50; 9, 61; 9, 62; 9, 77; 9, 86; 9, 99; 10, expression_statement; 10, 11; 11, comment; 12, comment; 13, comment; 14, comment; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:last_per_qtr; 18, call; 18, 19; 18, 20; 19, identifier:last_in_date_group; 20, argument_list; 20, 21; 20, 24; 20, 25; 20, 26; 20, 29; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:estimates; 24, identifier:data_query_cutoff_times; 25, identifier:assets_with_data; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:reindex; 28, True; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:extra_groupers; 31, list:[NORMALIZED_QUARTERS]; 31, 32; 32, identifier:NORMALIZED_QUARTERS; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:last_per_qtr; 37, identifier:index; 38, identifier:dates; 39, comment; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:ffill_across_cols; 43, argument_list; 43, 44; 43, 45; 43, 46; 44, identifier:last_per_qtr; 45, identifier:columns; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:name_map; 49, comment; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:stacked_last_per_qtr; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:last_per_qtr; 56, identifier:stack; 57, argument_list; 57, 58; 58, list:[SID_FIELD_NAME, NORMALIZED_QUARTERS]; 58, 59; 58, 60; 59, identifier:SID_FIELD_NAME; 60, identifier:NORMALIZED_QUARTERS; 61, comment; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:stacked_last_per_qtr; 67, identifier:index; 68, identifier:set_names; 69, argument_list; 69, 70; 69, 71; 69, 74; 70, identifier:SIMULATION_DATES; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:level; 73, integer:0; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:inplace; 76, True; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:stacked_last_per_qtr; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:stacked_last_per_qtr; 83, identifier:sort_values; 84, argument_list; 84, 85; 85, identifier:EVENT_DATE_FIELD_NAME; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:stacked_last_per_qtr; 90, identifier:EVENT_DATE_FIELD_NAME; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:pd; 94, identifier:to_datetime; 95, argument_list; 95, 96; 96, subscript; 96, 97; 96, 98; 97, identifier:stacked_last_per_qtr; 98, identifier:EVENT_DATE_FIELD_NAME; 99, return_statement; 99, 100; 100, expression_list; 100, 101; 100, 102; 101, identifier:last_per_qtr; 102, identifier:stacked_last_per_qtr | def get_last_data_per_qtr(self,
assets_with_data,
columns,
dates,
data_query_cutoff_times):
"""
Determine the last piece of information we know for each column on each
date in the index for each sid and quarter.
Parameters
----------
assets_with_data : pd.Index
Index of all assets that appear in the raw data given to the
loader.
columns : iterable of BoundColumn
The columns that need to be loaded from the raw data.
data_query_cutoff_times : pd.DatetimeIndex
The calendar of dates for which data should be loaded.
Returns
-------
stacked_last_per_qtr : pd.DataFrame
A DataFrame indexed by [dates, sid, normalized_quarters] that has
the latest information for each row of the index, sorted by event
date.
last_per_qtr : pd.DataFrame
A DataFrame with columns that are a MultiIndex of [
self.estimates.columns, normalized_quarters, sid].
"""
# Get a DataFrame indexed by date with a MultiIndex of columns of
# [self.estimates.columns, normalized_quarters, sid], where each cell
# contains the latest data for that day.
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
# Forward fill values for each quarter/sid/dataset column.
ffill_across_cols(last_per_qtr, columns, self.name_map)
# Stack quarter and sid into the index.
stacked_last_per_qtr = last_per_qtr.stack(
[SID_FIELD_NAME, NORMALIZED_QUARTERS],
)
# Set date index name for ease of reference
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, 9; 6, 48; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:previous_releases_per_date; 12, call; 12, 13; 12, 45; 13, attribute; 13, 14; 13, 44; 14, call; 14, 15; 14, 33; 15, attribute; 15, 16; 15, 32; 16, subscript; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:stacked_last_per_qtr; 19, identifier:loc; 20, comparison_operator:<=; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:stacked_last_per_qtr; 23, identifier:EVENT_DATE_FIELD_NAME; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:stacked_last_per_qtr; 28, identifier:index; 29, identifier:get_level_values; 30, argument_list; 30, 31; 31, identifier:SIMULATION_DATES; 32, identifier:groupby; 33, argument_list; 33, 34; 33, 39; 33, 42; 33, 43; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:level; 36, list:[SIMULATION_DATES, SID_FIELD_NAME]; 36, 37; 36, 38; 37, identifier:SIMULATION_DATES; 38, identifier:SID_FIELD_NAME; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:as_index; 41, False; 42, comment; 43, comment; 44, identifier:nth; 45, argument_list; 45, 46; 46, unary_operator:-; 46, 47; 47, integer:1; 48, return_statement; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:previous_releases_per_date; 51, identifier:index | def get_zeroth_quarter_idx(self, stacked_last_per_qtr):
"""
Filters for releases that are on or after each simulation date and
determines the previous quarter by picking out the most recent
release relative to each date in the index.
Parameters
----------
stacked_last_per_qtr : pd.DataFrame
A DataFrame with index of calendar dates, sid, and normalized
quarters with each row being the latest estimate for the row's
index values, sorted by event date.
Returns
-------
previous_releases_per_date_index : pd.MultiIndex
An index of calendar dates, sid, and normalized quarters, for only
the rows that have a previous event.
"""
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,
# Here we take advantage of the fact that `stacked_last_per_qtr` is
# sorted by event date.
).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, 20; 17, 39; 18, expression_statement; 18, 19; 19, comment; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:groupby; 23, identifier:NotSpecified; 24, block; 24, 25; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:Rank; 28, argument_list; 28, 29; 28, 30; 28, 33; 28, 36; 29, identifier:self; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:method; 32, identifier:method; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:ascending; 35, identifier:ascending; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:mask; 38, identifier:mask; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:GroupedRowTransform; 42, argument_list; 42, 43; 42, 49; 42, 53; 42, 56; 42, 59; 42, 62; 42, 65; 42, 68; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:transform; 45, conditional_expression:if; 45, 46; 45, 47; 45, 48; 46, identifier:rankdata; 47, identifier:ascending; 48, identifier:rankdata_1d_descending; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:transform_args; 51, tuple; 51, 52; 52, identifier:method; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:factor; 55, identifier:self; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:groupby; 58, identifier:groupby; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:dtype; 61, identifier:float64_dtype; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:missing_value; 64, identifier:nan; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:mask; 67, identifier:mask; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:window_safe; 70, True | def rank(self,
method='ordinal',
ascending=True,
mask=NotSpecified,
groupby=NotSpecified):
"""
Construct a new Factor representing the sorted rank of each column
within each row.
Parameters
----------
method : str, {'ordinal', 'min', 'max', 'dense', 'average'}
The method used to assign ranks to tied elements. See
`scipy.stats.rankdata` for a full description of the semantics for
each ranking method. Default is 'ordinal'.
ascending : bool, optional
Whether to return sorted rank in ascending or descending order.
Default is True.
mask : zipline.pipeline.Filter, optional
A Filter representing assets to consider when computing ranks.
If mask is supplied, ranks are computed ignoring any asset/date
pairs for which `mask` produces a value of False.
groupby : zipline.pipeline.Classifier, optional
A classifier defining partitions over which to perform ranking.
Returns
-------
ranks : zipline.pipeline.factors.Rank
A new factor that will compute the ranking of the data produced by
`self`.
Notes
-----
The default value for `method` is different from the default for
`scipy.stats.rankdata`. See that function's documentation for a full
description of the valid inputs to `method`.
Missing or non-existent data on a given day will cause an asset to be
given a rank of NaN for that day.
See Also
--------
:func:`scipy.stats.rankdata`
:class:`zipline.pipeline.factors.factor.Rank`
"""
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, 9; 6, 18; 6, 47; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:ix; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:dts; 15, identifier:searchsorted; 16, argument_list; 16, 17; 17, identifier:dt; 18, if_statement; 18, 19; 18, 31; 19, boolean_operator:or; 19, 20; 19, 26; 20, comparison_operator:==; 20, 21; 20, 22; 21, identifier:ix; 22, call; 22, 23; 22, 24; 23, identifier:len; 24, argument_list; 24, 25; 25, identifier:dts; 26, comparison_operator:!=; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:dts; 29, identifier:ix; 30, identifier:dt; 31, block; 31, 32; 32, raise_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:LookupError; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, string:"{dt} is not in {dts}"; 39, identifier:format; 40, argument_list; 40, 41; 40, 44; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:dt; 43, identifier:dt; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:dts; 46, identifier:dts; 47, return_statement; 47, 48; 48, identifier:ix | def find_in_sorted_index(dts, dt):
"""
Find the index of ``dt`` in ``dts``.
This function should be used instead of `dts.get_loc(dt)` if the index is
large enough that we don't want to initialize a hash table in ``dts``. In
particular, this should always be used on minutely trading calendars.
Parameters
----------
dts : pd.DatetimeIndex
Index in which to look up ``dt``. **Must be sorted**.
dt : pd.Timestamp
``dt`` to be looked up.
Returns
-------
ix : int
Integer index such that dts[ix] == dt.
Raises
------
KeyError
If dt is not in ``dts``.
"""
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, 9; 6, 20; 6, 31; 6, 42; 6, 54; 6, 73; 6, 117; 6, 128; 6, 142; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 14; 10, not_operator; 10, 11; 11, attribute; 11, 12; 11, 13; 12, identifier:dts; 13, identifier:is_unique; 14, block; 14, 15; 15, raise_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:ValueError; 18, argument_list; 18, 19; 19, string:"dts must be unique"; 20, if_statement; 20, 21; 20, 25; 21, not_operator; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:dts; 24, identifier:is_monotonic_increasing; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:ValueError; 29, argument_list; 29, 30; 30, string:"dts must be sorted in increasing order"; 31, if_statement; 31, 32; 31, 37; 32, not_operator; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:dts; 37, block; 37, 38; 38, return_statement; 38, 39; 39, expression_list; 39, 40; 39, 41; 40, None; 41, None; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:sortpos; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:dts; 48, identifier:searchsorted; 49, argument_list; 49, 50; 49, 51; 50, identifier:dt; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:side; 53, string:'left'; 54, try_statement; 54, 55; 54, 62; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:sortval; 59, subscript; 59, 60; 59, 61; 60, identifier:dts; 61, identifier:sortpos; 62, except_clause; 62, 63; 62, 64; 62, 65; 63, identifier:IndexError; 64, comment; 65, block; 65, 66; 66, return_statement; 66, 67; 67, expression_list; 67, 68; 67, 72; 68, subscript; 68, 69; 68, 70; 69, identifier:dts; 70, unary_operator:-; 70, 71; 71, integer:1; 72, None; 73, if_statement; 73, 74; 73, 77; 73, 88; 73, 105; 74, comparison_operator:<; 74, 75; 74, 76; 75, identifier:dt; 76, identifier:sortval; 77, block; 77, 78; 77, 84; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:lower_ix; 81, binary_operator:-; 81, 82; 81, 83; 82, identifier:sortpos; 83, integer:1; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:upper_ix; 87, identifier:sortpos; 88, elif_clause; 88, 89; 88, 92; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:dt; 91, identifier:sortval; 92, block; 92, 93; 92, 99; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:lower_ix; 96, binary_operator:-; 96, 97; 96, 98; 97, identifier:sortpos; 98, integer:1; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:upper_ix; 102, binary_operator:+; 102, 103; 102, 104; 103, identifier:sortpos; 104, integer:1; 105, else_clause; 105, 106; 106, block; 106, 107; 106, 111; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:lower_ix; 110, identifier:sortpos; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:upper_ix; 114, binary_operator:+; 114, 115; 114, 116; 115, identifier:sortpos; 116, integer:1; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:lower_value; 120, conditional_expression:if; 120, 121; 120, 124; 120, 127; 121, subscript; 121, 122; 121, 123; 122, identifier:dts; 123, identifier:lower_ix; 124, comparison_operator:>=; 124, 125; 124, 126; 125, identifier:lower_ix; 126, integer:0; 127, None; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:upper_value; 131, conditional_expression:if; 131, 132; 131, 135; 131, 141; 132, subscript; 132, 133; 132, 134; 133, identifier:dts; 134, identifier:upper_ix; 135, comparison_operator:<; 135, 136; 135, 137; 136, identifier:upper_ix; 137, call; 137, 138; 137, 139; 138, identifier:len; 139, argument_list; 139, 140; 140, identifier:dts; 141, None; 142, return_statement; 142, 143; 143, expression_list; 143, 144; 143, 145; 144, identifier:lower_value; 145, identifier:upper_value | def nearest_unequal_elements(dts, dt):
"""
Find values in ``dts`` closest but not equal to ``dt``.
Returns a pair of (last_before, first_after).
When ``dt`` is less than any element in ``dts``, ``last_before`` is None.
When ``dt`` is greater any element in ``dts``, ``first_after`` is None.
``dts`` must be unique and sorted in increasing order.
Parameters
----------
dts : pd.DatetimeIndex
Dates in which to search.
dt : pd.Timestamp
Date for which to find bounds.
"""
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:
# dt is greater than any value in the array.
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, 9; 6, 26; 6, 27; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sorted_stream; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:heapq; 15, identifier:merge; 16, argument_list; 16, 17; 17, list_splat; 17, 18; 18, generator_expression; 18, 19; 18, 23; 19, call; 19, 20; 19, 21; 20, identifier:_decorate_source; 21, argument_list; 21, 22; 22, identifier:s; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:s; 25, identifier:sources; 26, comment; 27, for_statement; 27, 28; 27, 31; 27, 32; 28, pattern_list; 28, 29; 28, 30; 29, identifier:_; 30, identifier:message; 31, identifier:sorted_stream; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, yield; 34, 35; 35, identifier:message | def date_sorted_sources(*sources):
"""
Takes an iterable of sources, generating namestrings and
piping their output into date_sort.
"""
sorted_stream = heapq.merge(*(_decorate_source(s) for s in sources))
# Strip out key decoration
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; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:iter; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:nx; 16, identifier:topological_sort; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:graph; 23, identifier:subgraph; 24, argument_list; 24, 25; 25, set_comprehension; 25, 26; 25, 27; 25, 36; 26, identifier:term; 27, for_in_clause; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:term; 30, identifier:refcount; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:refcounts; 34, identifier:items; 35, argument_list; 36, if_clause; 36, 37; 37, comparison_operator:>; 37, 38; 37, 39; 38, identifier:refcount; 39, integer:0 | def execution_order(self, refcounts):
"""
Return a topologically-sorted iterator over the terms in ``self`` which
need to be computed.
"""
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, 14; 11, 20; 11, 39; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:h; 17, call; 17, 18; 17, 19; 18, identifier:cls; 19, argument_list; 20, for_statement; 20, 21; 20, 22; 20, 28; 21, identifier:line; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:_CRLF_RE; 25, identifier:split; 26, argument_list; 26, 27; 27, identifier:headers; 28, block; 28, 29; 29, if_statement; 29, 30; 29, 31; 30, identifier:line; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:h; 36, identifier:parse_line; 37, argument_list; 37, 38; 38, identifier:line; 39, return_statement; 39, 40; 40, identifier:h | def parse(cls, headers: str) -> "HTTPHeaders":
"""Returns a dictionary from HTTP header text.
>>> h = HTTPHeaders.parse("Content-Type: text/html\\r\\nContent-Length: 42\\r\\n")
>>> sorted(h.items())
[('Content-Length', '42'), ('Content-Type', 'text/html')]
.. versionchanged:: 5.1
Raises `HTTPInputError` on malformed headers instead of a
mix of `KeyError`, and `ValueError`.
"""
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, 8; 5, 15; 5, 23; 5, 38; 5, 56; 5, 64; 5, 92; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:p; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:gt_sorted; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:gts; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:gt_sorted; 21, identifier:sum; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:intersection; 26, binary_operator:-; 26, 27; 26, 28; 27, identifier:gts; 28, call; 28, 29; 28, 36; 29, attribute; 29, 30; 29, 35; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:gt_sorted; 33, identifier:float; 34, argument_list; 35, identifier:cumsum; 36, argument_list; 36, 37; 37, integer:0; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:union; 41, binary_operator:+; 41, 42; 41, 43; 42, identifier:gts; 43, call; 43, 44; 43, 54; 44, attribute; 44, 45; 44, 53; 45, call; 45, 46; 45, 52; 46, attribute; 46, 47; 46, 51; 47, parenthesized_expression; 47, 48; 48, binary_operator:-; 48, 49; 48, 50; 49, integer:1; 50, identifier:gt_sorted; 51, identifier:float; 52, argument_list; 53, identifier:cumsum; 54, argument_list; 54, 55; 55, integer:0; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:jaccard; 59, binary_operator:-; 59, 60; 59, 61; 60, float:1.; 61, binary_operator:/; 61, 62; 61, 63; 62, identifier:intersection; 63, identifier:union; 64, if_statement; 64, 65; 64, 68; 64, 69; 65, comparison_operator:>; 65, 66; 65, 67; 66, identifier:p; 67, integer:1; 68, comment; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 78; 72, subscript; 72, 73; 72, 74; 73, identifier:jaccard; 74, slice; 74, 75; 74, 76; 74, 77; 75, integer:1; 76, colon; 77, identifier:p; 78, binary_operator:-; 78, 79; 78, 85; 79, subscript; 79, 80; 79, 81; 80, identifier:jaccard; 81, slice; 81, 82; 81, 83; 81, 84; 82, integer:1; 83, colon; 84, identifier:p; 85, subscript; 85, 86; 85, 87; 86, identifier:jaccard; 87, slice; 87, 88; 87, 89; 87, 90; 88, integer:0; 89, colon; 90, unary_operator:-; 90, 91; 91, integer:1; 92, return_statement; 92, 93; 93, identifier:jaccard | def lovasz_grad(gt_sorted):
"""
Computes gradient of the Lovasz extension w.r.t sorted errors
See Alg. 1 in paper
"""
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: # cover 1-pixel case
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, 44; 41, 65; 42, expression_statement; 42, 43; 43, comment; 44, if_statement; 44, 45; 44, 51; 45, not_operator; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:isinstance; 48, argument_list; 48, 49; 48, 50; 49, identifier:left; 50, identifier:DataFrame; 51, block; 51, 52; 52, raise_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:ValueError; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, string:"can not merge DataFrame with instance of type {}"; 59, identifier:format; 60, argument_list; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:type; 63, argument_list; 63, 64; 64, identifier:right; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:left; 69, identifier:merge; 70, argument_list; 70, 71; 70, 72; 70, 75; 70, 78; 70, 81; 70, 84; 70, 87; 70, 90; 70, 93; 70, 96; 70, 99; 70, 102; 71, identifier:right; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:how; 74, identifier:how; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:on; 77, identifier:on; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:left_on; 80, identifier:left_on; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:right_on; 83, identifier:right_on; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:left_index; 86, identifier:left_index; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:right_index; 89, identifier:right_index; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:sort; 92, identifier:sort; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:suffixes; 95, identifier:suffixes; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:copy; 98, identifier:copy; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:indicator; 101, identifier:indicator; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:validate; 104, 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,
):
"""Database style join, where common columns in "on" are merged.
Args:
left: DataFrame.
right: DataFrame.
how: What type of join to use.
on: The common column name(s) to join on. If None, and left_on and
right_on are also None, will default to all commonly named
columns.
left_on: The column(s) on the left to use for the join.
right_on: The column(s) on the right to use for the join.
left_index: Use the index from the left as the join keys.
right_index: Use the index from the right as the join keys.
sort: Sort the join keys lexicographically in the result.
suffixes: Add this suffix to the common names not in the "on".
copy: Does nothing in our implementation
indicator: Adds a column named _merge to the DataFrame with
metadata from the merge about each row.
validate: Checks if merge is a specific type.
Returns:
A merged Dataframe
"""
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, 15; 12, 30; 12, 52; 12, 68; 12, 69; 12, 70; 12, 83; 12, 87; 12, 88; 12, 94; 12, 98; 12, 187; 12, 293; 13, expression_statement; 13, 14; 14, comment; 15, if_statement; 15, 16; 15, 24; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:other; 20, call; 20, 21; 20, 22; 21, identifier:type; 22, argument_list; 22, 23; 23, identifier:self; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:other; 28, list:[other]; 28, 29; 29, identifier:other; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:index_obj; 33, parenthesized_expression; 33, 34; 34, conditional_expression:if; 34, 35; 34, 42; 34, 45; 35, list_comprehension; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:o; 38, identifier:index; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:o; 41, identifier:other; 42, comparison_operator:==; 42, 43; 42, 44; 43, identifier:axis; 44, integer:0; 45, list_comprehension; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:o; 48, identifier:columns; 49, for_in_clause; 49, 50; 49, 51; 50, identifier:o; 51, identifier:other; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:joined_index; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_join_index_objects; 59, argument_list; 59, 60; 59, 63; 59, 64; 59, 65; 60, binary_operator:^; 60, 61; 60, 62; 61, identifier:axis; 62, integer:1; 63, identifier:index_obj; 64, identifier:how_to_join; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:sort; 67, identifier:sort; 68, comment; 69, comment; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:left_old_idx; 73, conditional_expression:if; 73, 74; 73, 77; 73, 80; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:index; 77, comparison_operator:==; 77, 78; 77, 79; 78, identifier:axis; 79, integer:0; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:columns; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:right_old_idxes; 86, identifier:index_obj; 87, comment; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:reindexed_self; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:data; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:reindexed_other_list; 97, list:[]; 98, function_definition; 98, 99; 98, 100; 98, 102; 99, function_name:compute_reindex; 100, parameters; 100, 101; 101, identifier:old_idx; 102, block; 102, 103; 102, 105; 102, 185; 103, expression_statement; 103, 104; 104, comment; 105, function_definition; 105, 106; 105, 107; 105, 109; 106, function_name:reindex_partition; 107, parameters; 107, 108; 108, identifier:df; 109, block; 109, 110; 109, 183; 110, if_statement; 110, 111; 110, 114; 110, 148; 111, comparison_operator:==; 111, 112; 111, 113; 112, identifier:axis; 113, integer:0; 114, block; 114, 115; 114, 121; 114, 132; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:df; 119, identifier:index; 120, identifier:old_idx; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:new_df; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:df; 127, identifier:reindex; 128, argument_list; 128, 129; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:index; 131, identifier:joined_index; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:new_df; 136, identifier:index; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:pandas; 140, identifier:RangeIndex; 141, argument_list; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:len; 144, argument_list; 144, 145; 145, attribute; 145, 146; 145, 147; 146, identifier:new_df; 147, identifier:index; 148, else_clause; 148, 149; 149, block; 149, 150; 149, 156; 149, 167; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:df; 154, identifier:columns; 155, identifier:old_idx; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:new_df; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:df; 162, identifier:reindex; 163, argument_list; 163, 164; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:columns; 166, identifier:joined_index; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:new_df; 171, identifier:columns; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:pandas; 175, identifier:RangeIndex; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:len; 179, argument_list; 179, 180; 180, attribute; 180, 181; 180, 182; 181, identifier:new_df; 182, identifier:columns; 183, return_statement; 183, 184; 184, identifier:new_df; 185, return_statement; 185, 186; 186, identifier:reindex_partition; 187, for_statement; 187, 188; 187, 189; 187, 196; 187, 197; 187, 198; 188, identifier:i; 189, call; 189, 190; 189, 191; 190, identifier:range; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:len; 194, argument_list; 194, 195; 195, identifier:other; 196, comment; 197, comment; 198, block; 198, 199; 198, 233; 198, 268; 198, 286; 199, if_statement; 199, 200; 199, 214; 199, 219; 200, boolean_operator:or; 200, 201; 200, 204; 201, comparison_operator:!=; 201, 202; 201, 203; 202, identifier:i; 203, integer:0; 204, parenthesized_expression; 204, 205; 205, boolean_operator:and; 205, 206; 205, 212; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:left_old_idx; 209, identifier:equals; 210, argument_list; 210, 211; 211, identifier:joined_index; 212, not_operator; 212, 213; 213, identifier:force_repartition; 214, block; 214, 215; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:reindex_left; 218, None; 219, else_clause; 219, 220; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:reindex_left; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:_prepare_method; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:compute_reindex; 231, argument_list; 231, 232; 232, identifier:left_old_idx; 233, if_statement; 233, 234; 233, 245; 233, 250; 234, boolean_operator:and; 234, 235; 234, 243; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:right_old_idxes; 239, identifier:i; 240, identifier:equals; 241, argument_list; 241, 242; 242, identifier:joined_index; 243, not_operator; 243, 244; 244, identifier:force_repartition; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:reindex_right; 249, None; 250, else_clause; 250, 251; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:reindex_right; 255, call; 255, 256; 255, 261; 256, attribute; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:other; 259, identifier:i; 260, identifier:_prepare_method; 261, argument_list; 261, 262; 262, call; 262, 263; 262, 264; 263, identifier:compute_reindex; 264, argument_list; 264, 265; 265, subscript; 265, 266; 265, 267; 266, identifier:right_old_idxes; 267, identifier:i; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 273; 270, pattern_list; 270, 271; 270, 272; 271, identifier:reindexed_self; 272, identifier:reindexed_other; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:reindexed_self; 276, identifier:copartition_datasets; 277, argument_list; 277, 278; 277, 279; 277, 284; 277, 285; 278, identifier:axis; 279, attribute; 279, 280; 279, 283; 280, subscript; 280, 281; 280, 282; 281, identifier:other; 282, identifier:i; 283, identifier:data; 284, identifier:reindex_left; 285, identifier:reindex_right; 286, expression_statement; 286, 287; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:reindexed_other_list; 290, identifier:append; 291, argument_list; 291, 292; 292, identifier:reindexed_other; 293, return_statement; 293, 294; 294, expression_list; 294, 295; 294, 296; 294, 297; 295, identifier:reindexed_self; 296, identifier:reindexed_other_list; 297, identifier:joined_index | def copartition(self, axis, other, how_to_join, sort, force_repartition=False):
"""Copartition two QueryCompiler objects.
Args:
axis: The axis to copartition along.
other: The other Query Compiler(s) to copartition against.
how_to_join: How to manage joining the index object ("left", "right", etc.)
sort: Whether or not to sort the joined index.
force_repartition: Whether or not to force the repartitioning. By default,
this method will skip repartitioning if it is possible. This is because
reindexing is extremely inefficient. Because this method is used to
`join` or `append`, it is vital that the internal indices match.
Returns:
A tuple (left query compiler, right query compiler list, joined index).
"""
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
)
# We have to set these because otherwise when we perform the functions it may
# end up serializing this entire object.
left_old_idx = self.index if axis == 0 else self.columns
right_old_idxes = index_obj
# Start with this and we'll repartition the first time, and then not again.
reindexed_self = self.data
reindexed_other_list = []
def compute_reindex(old_idx):
"""Create a function based on the old index and axis.
Args:
old_idx: The old index/columns
Returns:
A function that will be run in each partition.
"""
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 the indices are equal we can skip partitioning so long as we are not
# forced to repartition. See note above about `force_repartition`.
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, 10; 7, 20; 7, 31; 7, 32; 7, 33; 7, 34; 7, 44; 7, 53; 7, 59; 7, 94; 7, 105; 7, 115; 7, 166; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:axis; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:kwargs; 16, identifier:pop; 17, argument_list; 17, 18; 17, 19; 18, string:"axis"; 19, integer:0; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:index; 23, conditional_expression:if; 23, 24; 23, 27; 23, 28; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:columns; 27, identifier:axis; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:index; 31, comment; 32, comment; 33, comment; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:ascending; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:kwargs; 40, identifier:pop; 41, argument_list; 41, 42; 41, 43; 42, string:"ascending"; 43, True; 44, if_statement; 44, 45; 44, 48; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:ascending; 47, None; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:ascending; 52, False; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:kwargs; 57, string:"ascending"; 58, identifier:ascending; 59, function_definition; 59, 60; 59, 61; 59, 65; 60, function_name:sort_index_builder; 61, parameters; 61, 62; 61, 63; 62, identifier:df; 63, dictionary_splat_pattern; 63, 64; 64, identifier:kwargs; 65, block; 65, 66; 65, 83; 66, if_statement; 66, 67; 66, 68; 66, 75; 67, identifier:axis; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:df; 73, identifier:columns; 74, identifier:index; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:df; 81, identifier:index; 82, identifier:index; 83, return_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:df; 87, identifier:sort_index; 88, argument_list; 88, 89; 88, 92; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:axis; 91, identifier:axis; 92, dictionary_splat; 92, 93; 93, identifier:kwargs; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:func; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:_prepare_method; 101, argument_list; 101, 102; 101, 103; 102, identifier:sort_index_builder; 103, dictionary_splat; 103, 104; 104, identifier:kwargs; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:new_data; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:_map_across_full_axis; 112, argument_list; 112, 113; 112, 114; 113, identifier:axis; 114, identifier:func; 115, if_statement; 115, 116; 115, 117; 115, 141; 116, identifier:axis; 117, block; 117, 118; 117, 135; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:new_columns; 121, call; 121, 122; 121, 132; 122, attribute; 122, 123; 122, 131; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:pandas; 126, identifier:Series; 127, argument_list; 127, 128; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:columns; 131, identifier:sort_values; 132, argument_list; 132, 133; 133, dictionary_splat; 133, 134; 134, identifier:kwargs; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:new_index; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:index; 141, else_clause; 141, 142; 142, block; 142, 143; 142, 160; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:new_index; 146, call; 146, 147; 146, 157; 147, attribute; 147, 148; 147, 156; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:pandas; 151, identifier:Series; 152, argument_list; 152, 153; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:index; 156, identifier:sort_values; 157, argument_list; 157, 158; 158, dictionary_splat; 158, 159; 159, identifier:kwargs; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:new_columns; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:columns; 166, return_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:__constructor__; 171, argument_list; 171, 172; 171, 173; 171, 174; 171, 175; 172, identifier:new_data; 173, identifier:new_index; 174, identifier:new_columns; 175, call; 175, 176; 175, 181; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:dtypes; 180, identifier:copy; 181, argument_list | def sort_index(self, **kwargs):
"""Sorts the data with respect to either the columns or the indices.
Returns:
DataManager containing the data sorted by columns or indices.
"""
axis = kwargs.pop("axis", 0)
index = self.columns if axis else self.index
# sort_index can have ascending be None and behaves as if it is False.
# sort_values cannot have ascending be None. Thus, the following logic is to
# convert the ascending argument to one that works with sort_values
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, 8; 5, 18; 5, 34; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:data_client; 11, attribute; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_instance; 16, identifier:_client; 17, identifier:table_data_client; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:response_iterator; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:data_client; 24, identifier:sample_row_keys; 25, argument_list; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:name; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:app_profile_id; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_app_profile_id; 34, return_statement; 34, 35; 35, identifier:response_iterator | def sample_row_keys(self):
"""Read a sample of row keys in the table.
For example:
.. literalinclude:: snippets_table.py
:start-after: [START bigtable_sample_row_keys]
:end-before: [END bigtable_sample_row_keys]
The returned row keys will delimit contiguous sections of the table of
approximately equal size, which can be used to break up the data for
distributed tasks like mapreduces.
The elements in the iterator are a SampleRowKeys response and they have
the properties ``offset_bytes`` and ``row_key``. They occur in sorted
order. The table might have contents before the first row key in the
list and after the last one, but a key containing the empty string
indicates "end of table" and will be the last response given, if
present.
.. note::
Row keys in this list may not have ever been written to or read
from, and users should therefore not make any assumptions about the
row key structure that are specific to their use case.
The ``offset_bytes`` field on a response indicates the approximate
total storage space used by all rows in the table which precede
``row_key``. Buffering the contents of all rows between two subsequent
samples would require space roughly equal to the difference in their
``offset_bytes`` fields.
:rtype: :class:`~google.cloud.exceptions.GrpcRendezvous`
:returns: A cancel-able iterator. Can be consumed by calling ``next()``
or by casting to a :class:`list` and can be cancelled by
calling ``cancel()``.
"""
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, 56; 53, 57; 53, 110; 53, 145; 53, 193; 54, expression_statement; 54, 55; 55, comment; 56, comment; 57, if_statement; 57, 58; 57, 63; 58, comparison_operator:not; 58, 59; 58, 60; 59, string:"search_profiles"; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_inner_api_calls; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:_inner_api_calls; 70, string:"search_profiles"; 71, call; 71, 72; 71, 81; 72, attribute; 72, 73; 72, 80; 73, attribute; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:google; 77, identifier:api_core; 78, identifier:gapic_v1; 79, identifier:method; 80, identifier:wrap_method; 81, argument_list; 81, 82; 81, 87; 81, 96; 81, 105; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:transport; 86, identifier:search_profiles; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:default_retry; 89, attribute; 89, 90; 89, 95; 90, subscript; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:_method_configs; 94, string:"SearchProfiles"; 95, identifier:retry; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:default_timeout; 98, attribute; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:_method_configs; 103, string:"SearchProfiles"; 104, identifier:timeout; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:client_info; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:_client_info; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:request; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:profile_service_pb2; 116, identifier:SearchProfilesRequest; 117, argument_list; 117, 118; 117, 121; 117, 124; 117, 127; 117, 130; 117, 133; 117, 136; 117, 139; 117, 142; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:parent; 120, identifier:parent; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:request_metadata; 123, identifier:request_metadata; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:profile_query; 126, identifier:profile_query; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:page_size; 129, identifier:page_size; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:offset; 132, identifier:offset; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:disable_spell_check; 135, identifier:disable_spell_check; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:order_by; 138, identifier:order_by; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:case_sensitive_sort; 141, identifier:case_sensitive_sort; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:histogram_queries; 144, identifier:histogram_queries; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:iterator; 148, call; 148, 149; 148, 156; 149, attribute; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:google; 153, identifier:api_core; 154, identifier:page_iterator; 155, identifier:GRPCIterator; 156, argument_list; 156, 157; 156, 160; 156, 181; 156, 184; 156, 187; 156, 190; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:client; 159, None; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:method; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:functools; 165, identifier:partial; 166, argument_list; 166, 167; 166, 172; 166, 175; 166, 178; 167, subscript; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_inner_api_calls; 171, string:"search_profiles"; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:retry; 174, identifier:retry; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:timeout; 177, identifier:timeout; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:metadata; 180, identifier:metadata; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:request; 183, identifier:request; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:items_field; 186, string:"histogram_query_results"; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:request_token_field; 189, string:"page_token"; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:response_token_field; 192, string:"next_page_token"; 193, return_statement; 193, 194; 194, 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,
):
"""
Searches for profiles within a tenant.
For example, search by raw queries "software engineer in Mountain View"
or search by structured filters (location filter, education filter,
etc.).
See ``SearchProfilesRequest`` for more information.
Example:
>>> from google.cloud import talent_v4beta1
>>>
>>> client = talent_v4beta1.ProfileServiceClient()
>>>
>>> parent = client.tenant_path('[PROJECT]', '[TENANT]')
>>>
>>> # TODO: Initialize `request_metadata`:
>>> request_metadata = {}
>>>
>>> # Iterate over all results
>>> for element in client.search_profiles(parent, request_metadata):
... # process element
... pass
>>>
>>>
>>> # Alternatively:
>>>
>>> # Iterate over results one page at a time
>>> for page in client.search_profiles(parent, request_metadata).pages:
... for element in page:
... # process element
... pass
Args:
parent (str): Required.
The resource name of the tenant to search within.
The format is "projects/{project\_id}/tenants/{tenant\_id}", for
example, "projects/api-test-project/tenants/foo".
request_metadata (Union[dict, ~google.cloud.talent_v4beta1.types.RequestMetadata]): Required.
The meta information collected about the profile search user. This is used
to improve the search quality of the service. These values are provided by
users, and must be precise and consistent.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.RequestMetadata`
profile_query (Union[dict, ~google.cloud.talent_v4beta1.types.ProfileQuery]): Optional.
Search query to execute. See ``ProfileQuery`` for more details.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.ProfileQuery`
page_size (int): The maximum number of resources contained in the
underlying API response. If page streaming is performed per-
resource, this parameter does not affect the return value. If page
streaming is performed per-page, this determines the maximum number
of resources in a page.
offset (int): Optional.
An integer that specifies the current offset (that is, starting result)
in search results. This field is only considered if ``page_token`` is
unset.
The maximum allowed value is 5000. Otherwise an error is thrown.
For example, 0 means to search from the first profile, and 10 means to
search from the 11th profile. This can be used for pagination, for
example pageSize = 10 and offset = 10 means to search from the second
page.
disable_spell_check (bool): Optional.
This flag controls the spell-check feature. If ``false``, the service
attempts to correct a misspelled query.
For example, "enginee" is corrected to "engineer".
order_by (str): Optional.
The criteria that determines how search results are sorted. Defaults is
"relevance desc" if no value is specified.
Supported options are:
- "relevance desc": By descending relevance, as determined by the API
algorithms.
- "update\_date desc": Sort by ``Profile.update_date`` in descending
order (recently updated profiles first).
- "create\_date desc": Sort by ``Profile.create_date`` in descending
order (recently created profiles first).
- "first\_name": Sort by ``PersonStrcuturedName.given_name`` in
ascending order.
- "first\_name desc": Sort by ``PersonStrcuturedName.given_name`` in
descending order.
- "last\_name": Sort by ``PersonStrcuturedName.family_name`` in
ascending order.
- "last\_name desc": Sort by ``PersonStrcuturedName.family_name`` in
ascending order.
case_sensitive_sort (bool): Optional.
When sort by field is based on alphabetical order, sort values case
sensitively (based on ASCII) when the value is set to true. Default value
is case in-sensitive sort (false).
histogram_queries (list[Union[dict, ~google.cloud.talent_v4beta1.types.HistogramQuery]]): Optional.
A list of expressions specifies histogram requests against matching
profiles for ``SearchProfilesRequest``.
The expression syntax looks like a function definition with optional
parameters.
Function syntax: function\_name(histogram\_facet[, list of buckets])
Data types:
- Histogram facet: facet names with format [a-zA-Z][a-zA-Z0-9\_]+.
- String: string like "any string with backslash escape for quote(")."
- Number: whole number and floating point number like 10, -1 and -0.01.
- List: list of elements with comma(,) separator surrounded by square
brackets. For example, [1, 2, 3] and ["one", "two", "three"].
Built-in constants:
- MIN (minimum number similar to java Double.MIN\_VALUE)
- MAX (maximum number similar to java Double.MAX\_VALUE)
Built-in functions:
- bucket(start, end[, label]) Bucket build-in function creates a bucket
with range of \`start, end). Note that the end is exclusive. For
example, bucket(1, MAX, "positive number") or bucket(1, 10).
Histogram Facets:
- admin1: Admin1 is a global placeholder for referring to state,
province, or the particular term a country uses to define the
geographic structure below the country level. Examples include states
codes such as "CA", "IL", "NY", and provinces, such as "BC".
- locality: Locality is a global placeholder for referring to city,
town, or the particular term a country uses to define the geographic
structure below the admin1 level. Examples include city names such as
"Mountain View" and "New York".
- extended\_locality: Extended locality is concatenated version of
admin1 and locality with comma separator. For example, "Mountain
View, CA" and "New York, NY".
- postal\_code: Postal code of profile which follows locale code.
- country: Country code (ISO-3166-1 alpha-2 code) of profile, such as
US, JP, GB.
- job\_title: Normalized job titles specified in EmploymentHistory.
- company\_name: Normalized company name of profiles to match on.
- institution: The school name. For example, "MIT", "University of
California, Berkeley"
- degree: Highest education degree in ISCED code. Each value in degree
covers specific level of education, without any expansion to upper
nor lower levels of education degree.
- experience\_in\_months: experience in months. 0 means 0 month to 1
month (exclusive).
- application\_date: The application date specifies application start
dates. See [ApplicationDateFilter\` for more details.
- application\_outcome\_reason: The application outcome reason
specifies the outcome reasons of job application. See
``ApplicationOutcomeReasonFilter`` for more details.
- application\_last\_stage: The application last stage specifies the
last stage of job application. See ``ApplicationLastStageFilter`` for
more details.
- application\_job\_title: The application job title specifies the job
applied for in the application. See ``ApplicationJobFilter`` for more
details.
- application\_status: The application status specifies the status of
job application. See ``ApplicationStatusFilter`` for more details.
- hirable\_status: Hirable status specifies the profile's hirable
status.
- string\_custom\_attribute: String custom attributes. Values can be
accessed via square bracket notation like
string\_custom\_attribute["key1"].
- numeric\_custom\_attribute: Numeric custom attributes. Values can be
accessed via square bracket notation like
numeric\_custom\_attribute["key1"].
Example expressions:
- count(admin1)
- count(experience\_in\_months, [bucket(0, 12, "1 year"), bucket(12,
36, "1-3 years"), bucket(36, MAX, "3+ years")])
- count(string\_custom\_attribute["assigned\_recruiter"])
- count(numeric\_custom\_attribute["favorite\_number"], [bucket(MIN, 0,
"negative"), bucket(0, MAX, "non-negative")])
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.HistogramQuery`
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will not
be retried.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.gax.PageIterator` instance. By default, this
is an iterable of :class:`~google.cloud.talent_v4beta1.types.HistogramQueryResult` instances.
This object can also be configured to iterate over the pages
of the response through the `options` parameter.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
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, 71; 68, 72; 68, 125; 68, 175; 68, 223; 69, expression_statement; 69, 70; 70, comment; 71, comment; 72, if_statement; 72, 73; 72, 78; 73, comparison_operator:not; 73, 74; 73, 75; 74, string:"search_jobs"; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:_inner_api_calls; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 86; 81, subscript; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_inner_api_calls; 85, string:"search_jobs"; 86, call; 86, 87; 86, 96; 87, attribute; 87, 88; 87, 95; 88, attribute; 88, 89; 88, 94; 89, attribute; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:google; 92, identifier:api_core; 93, identifier:gapic_v1; 94, identifier:method; 95, identifier:wrap_method; 96, argument_list; 96, 97; 96, 102; 96, 111; 96, 120; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:transport; 101, identifier:search_jobs; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:default_retry; 104, attribute; 104, 105; 104, 110; 105, subscript; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:_method_configs; 109, string:"SearchJobs"; 110, identifier:retry; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:default_timeout; 113, attribute; 113, 114; 113, 119; 114, subscript; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:_method_configs; 118, string:"SearchJobs"; 119, identifier:timeout; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:client_info; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_client_info; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:request; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:job_service_pb2; 131, identifier:SearchJobsRequest; 132, argument_list; 132, 133; 132, 136; 132, 139; 132, 142; 132, 145; 132, 148; 132, 151; 132, 154; 132, 157; 132, 160; 132, 163; 132, 166; 132, 169; 132, 172; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:parent; 135, identifier:parent; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:request_metadata; 138, identifier:request_metadata; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:search_mode; 141, identifier:search_mode; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:job_query; 144, identifier:job_query; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:enable_broadening; 147, identifier:enable_broadening; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:require_precise_result_size; 150, identifier:require_precise_result_size; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:histogram_queries; 153, identifier:histogram_queries; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:job_view; 156, identifier:job_view; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:offset; 159, identifier:offset; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:page_size; 162, identifier:page_size; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:order_by; 165, identifier:order_by; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:diversification_level; 168, identifier:diversification_level; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:custom_ranking_info; 171, identifier:custom_ranking_info; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:disable_keyword_match; 174, identifier:disable_keyword_match; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:iterator; 178, call; 178, 179; 178, 186; 179, attribute; 179, 180; 179, 185; 180, attribute; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:google; 183, identifier:api_core; 184, identifier:page_iterator; 185, identifier:GRPCIterator; 186, argument_list; 186, 187; 186, 190; 186, 211; 186, 214; 186, 217; 186, 220; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:client; 189, None; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:method; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:functools; 195, identifier:partial; 196, argument_list; 196, 197; 196, 202; 196, 205; 196, 208; 197, subscript; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:_inner_api_calls; 201, string:"search_jobs"; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:retry; 204, identifier:retry; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:timeout; 207, identifier:timeout; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:metadata; 210, identifier:metadata; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:request; 213, identifier:request; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:items_field; 216, string:"matching_jobs"; 217, keyword_argument; 217, 218; 217, 219; 218, identifier:request_token_field; 219, string:"page_token"; 220, keyword_argument; 220, 221; 220, 222; 221, identifier:response_token_field; 222, string:"next_page_token"; 223, return_statement; 223, 224; 224, 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,
):
"""
Searches for jobs using the provided ``SearchJobsRequest``.
This call constrains the ``visibility`` of jobs present in the database,
and only returns jobs that the caller has permission to search against.
Example:
>>> from google.cloud import talent_v4beta1
>>>
>>> client = talent_v4beta1.JobServiceClient()
>>>
>>> parent = client.project_path('[PROJECT]')
>>>
>>> # TODO: Initialize `request_metadata`:
>>> request_metadata = {}
>>>
>>> # Iterate over all results
>>> for element in client.search_jobs(parent, request_metadata):
... # process element
... pass
>>>
>>>
>>> # Alternatively:
>>>
>>> # Iterate over results one page at a time
>>> for page in client.search_jobs(parent, request_metadata).pages:
... for element in page:
... # process element
... pass
Args:
parent (str): Required.
The resource name of the project to search within.
The format is "projects/{project\_id}", for example,
"projects/api-test-project".
request_metadata (Union[dict, ~google.cloud.talent_v4beta1.types.RequestMetadata]): Required.
The meta information collected about the job searcher, used to improve
the search quality of the service.. The identifiers, (such as
``user_id``) are provided by users, and must be unique and consistent.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.RequestMetadata`
search_mode (~google.cloud.talent_v4beta1.types.SearchMode): Optional.
Mode of a search.
Defaults to ``SearchMode.JOB_SEARCH``.
job_query (Union[dict, ~google.cloud.talent_v4beta1.types.JobQuery]): Optional.
Query used to search against jobs, such as keyword, location filters, etc.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.JobQuery`
enable_broadening (bool): Optional.
Controls whether to broaden the search when it produces sparse results.
Broadened queries append results to the end of the matching results
list.
Defaults to false.
require_precise_result_size (bool): Optional.
Controls if the search job request requires the return of a precise
count of the first 300 results. Setting this to ``true`` ensures
consistency in the number of results per page. Best practice is to set
this value to true if a client allows users to jump directly to a
non-sequential search results page.
Enabling this flag may adversely impact performance.
Defaults to false.
histogram_queries (list[Union[dict, ~google.cloud.talent_v4beta1.types.HistogramQuery]]): Optional.
An expression specifies a histogram request against matching jobs.
Expression syntax is an aggregation function call with histogram facets
and other options.
Available aggregation function calls are: \*
``count(string_histogram_facet)``: Count the number of matching
entities, for each distinct attribute value. \*
``count(numeric_histogram_facet, list of buckets)``: Count the number of
matching entities within each bucket.
Data types:
- Histogram facet: facet names with format [a-zA-Z][a-zA-Z0-9\_]+.
- String: string like "any string with backslash escape for quote(")."
- Number: whole number and floating point number like 10, -1 and -0.01.
- List: list of elements with comma(,) separator surrounded by square
brackets, for example, [1, 2, 3] and ["one", "two", "three"].
Built-in constants:
- MIN (minimum number similar to java Double.MIN\_VALUE)
- MAX (maximum number similar to java Double.MAX\_VALUE)
Built-in functions:
- bucket(start, end[, label]): bucket built-in function creates a
bucket with range of \`start, end). Note that the end is exclusive,
for example, bucket(1, MAX, "positive number") or bucket(1, 10).
Job histogram facets:
- company\_id: histogram by [Job.distributor\_company\_id\`.
- company\_display\_name: histogram by ``Job.company_display_name``.
- employment\_type: histogram by ``Job.employment_types``, for example,
"FULL\_TIME", "PART\_TIME".
- company\_size: histogram by ``CompanySize``, for example, "SMALL",
"MEDIUM", "BIG".
- publish\_time\_in\_month: histogram by the ``Job.publish_time`` in
months. Must specify list of numeric buckets in spec.
- publish\_time\_in\_year: histogram by the ``Job.publish_time`` in
years. Must specify list of numeric buckets in spec.
- degree\_type: histogram by the ``Job.degree_type``, for example,
"Bachelors", "Masters".
- job\_level: histogram by the ``Job.job_level``, for example, "Entry
Level".
- country: histogram by the country code of jobs, for example, "US",
"FR".
- admin1: histogram by the admin1 code of jobs, which is a global
placeholder referring to the state, province, or the particular term
a country uses to define the geographic structure below the country
level, for example, "CA", "IL".
- city: histogram by a combination of the "city name, admin1 code". For
example, "Mountain View, CA", "New York, NY".
- admin1\_country: histogram by a combination of the "admin1 code,
country", for example, "CA, US", "IL, US".
- city\_coordinate: histogram by the city center's GPS coordinates
(latitude and longitude), for example, 37.4038522,-122.0987765. Since
the coordinates of a city center can change, customers may need to
refresh them periodically.
- locale: histogram by the ``Job.language_code``, for example, "en-US",
"fr-FR".
- language: histogram by the language subtag of the
``Job.language_code``, for example, "en", "fr".
- category: histogram by the ``JobCategory``, for example,
"COMPUTER\_AND\_IT", "HEALTHCARE".
- base\_compensation\_unit: histogram by the ``CompensationUnit`` of
base salary, for example, "WEEKLY", "MONTHLY".
- base\_compensation: histogram by the base salary. Must specify list
of numeric buckets to group results by.
- annualized\_base\_compensation: histogram by the base annualized
salary. Must specify list of numeric buckets to group results by.
- annualized\_total\_compensation: histogram by the total annualized
salary. Must specify list of numeric buckets to group results by.
- string\_custom\_attribute: histogram by string
``Job.custom_attributes``. Values can be accessed via square bracket
notations like string\_custom\_attribute["key1"].
- numeric\_custom\_attribute: histogram by numeric
``Job.custom_attributes``. Values can be accessed via square bracket
notations like numeric\_custom\_attribute["key1"]. Must specify list
of numeric buckets to group results by.
Example expressions: \* count(admin1) \* count(base\_compensation,
[bucket(1000, 10000), bucket(10000, 100000), bucket(100000, MAX)]) \*
count(string\_custom\_attribute["some-string-custom-attribute"]) \*
count(numeric\_custom\_attribute["some-numeric-custom-attribute"],
[bucket(MIN, 0, "negative"), bucket(0, MAX, "non-negative"])
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.HistogramQuery`
job_view (~google.cloud.talent_v4beta1.types.JobView): Optional.
The desired job attributes returned for jobs in the search response.
Defaults to ``JobView.SMALL`` if no value is specified.
offset (int): Optional.
An integer that specifies the current offset (that is, starting result
location, amongst the jobs deemed by the API as relevant) in search
results. This field is only considered if ``page_token`` is unset.
For example, 0 means to return results starting from the first matching
job, and 10 means to return from the 11th job. This can be used for
pagination, (for example, pageSize = 10 and offset = 10 means to return
from the second page).
page_size (int): The maximum number of resources contained in the
underlying API response. If page streaming is performed per-
resource, this parameter does not affect the return value. If page
streaming is performed per-page, this determines the maximum number
of resources in a page.
order_by (str): Optional.
The criteria determining how search results are sorted. Default is
"relevance desc".
Supported options are:
- "relevance desc": By relevance descending, as determined by the API
algorithms. Relevance thresholding of query results is only available
with this ordering.
- "posting``_``\ publish\ ``_``\ time desc": By
``Job.posting_publish_time`` descending.
- "posting``_``\ update\ ``_``\ time desc": By
``Job.posting_update_time`` descending.
- "title": By ``Job.title`` ascending.
- "title desc": By ``Job.title`` descending.
- "annualized``_``\ base\ ``_``\ compensation": By job's
``CompensationInfo.annualized_base_compensation_range`` ascending.
Jobs whose annualized base compensation is unspecified are put at the
end of search results.
- "annualized``_``\ base\ ``_``\ compensation desc": By job's
``CompensationInfo.annualized_base_compensation_range`` descending.
Jobs whose annualized base compensation is unspecified are put at the
end of search results.
- "annualized``_``\ total\ ``_``\ compensation": By job's
``CompensationInfo.annualized_total_compensation_range`` ascending.
Jobs whose annualized base compensation is unspecified are put at the
end of search results.
- "annualized``_``\ total\ ``_``\ compensation desc": By job's
``CompensationInfo.annualized_total_compensation_range`` descending.
Jobs whose annualized base compensation is unspecified are put at the
end of search results.
- "custom``_``\ ranking desc": By the relevance score adjusted to the
``SearchJobsRequest.custom_ranking_info.ranking_expression`` with
weight factor assigned by
``SearchJobsRequest.custom_ranking_info.importance_level`` in
descending order.
- "location``_``\ distance": By the distance between the location on
jobs and locations specified in the
``SearchJobsRequest.job_query.location_filters``. When this order is
selected, the ``SearchJobsRequest.job_query.location_filters`` must
not be empty. When a job has multiple locations, the location closest
to one of the locations specified in the location filter will be used
to calculate location distance. Distance is calculated by the
distance between two lat/long coordinates, with a precision of 10e-4
degrees (11.3 meters). Jobs that don't have locations specified will
be ranked below jobs having locations. Diversification strategy is
still applied unless explicitly disabled in
``SearchJobsRequest.diversification_level``.
diversification_level (~google.cloud.talent_v4beta1.types.DiversificationLevel): Optional.
Controls whether highly similar jobs are returned next to each other in
the search results. Jobs are identified as highly similar based on their
titles, job categories, and locations. Highly similar results are
clustered so that only one representative job of the cluster is
displayed to the job seeker higher up in the results, with the other
jobs being displayed lower down in the results.
Defaults to ``DiversificationLevel.SIMPLE`` if no value is specified.
custom_ranking_info (Union[dict, ~google.cloud.talent_v4beta1.types.CustomRankingInfo]): Optional.
Controls over how job documents get ranked on top of existing relevance
score (determined by API algorithm).
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.talent_v4beta1.types.CustomRankingInfo`
disable_keyword_match (bool): Optional.
Controls whether to disable exact keyword match on ``Job.job_title``,
``Job.description``, ``Job.company_display_name``, [Job.locations][0],
``Job.qualifications``. When disable keyword match is turned off, a
keyword match returns jobs that do not match given category filters when
there are matching keywords. For example, for the query "program
manager," a result is returned even if the job posting has the title
"software developer," which doesn't fall into "program manager"
ontology, but does have "program manager" appearing in its description.
For queries like "cloud" that don't contain title or location specific
ontology, jobs with "cloud" keyword matches are returned regardless of
this flag's value.
Please use ``Company.keyword_searchable_custom_fields`` or
``Company.keyword_searchable_custom_attributes`` if company specific
globally matched custom field/attribute string values is needed.
Enabling keyword match improves recall of subsequent search requests.
Defaults to false.
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will not
be retried.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.gax.PageIterator` instance. By default, this
is an iterable of :class:`~google.cloud.talent_v4beta1.types.MatchingJob` instances.
This object can also be configured to iterate over the pages
of the response through the `options` parameter.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
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, 49; 46, 50; 46, 103; 46, 129; 46, 138; 46, 145; 46, 182; 46, 230; 47, expression_statement; 47, 48; 48, comment; 49, comment; 50, if_statement; 50, 51; 50, 56; 51, comparison_operator:not; 51, 52; 51, 53; 52, string:"list_findings"; 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_findings"; 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_findings; 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:"ListFindings"; 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:"ListFindings"; 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:securitycenter_service_pb2; 109, identifier:ListFindingsRequest; 110, argument_list; 110, 111; 110, 114; 110, 117; 110, 120; 110, 123; 110, 126; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:parent; 113, identifier:parent; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:filter; 116, identifier:filter_; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:order_by; 119, identifier:order_by; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:read_time; 122, identifier:read_time; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:field_mask; 125, identifier:field_mask; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:page_size; 128, identifier:page_size; 129, if_statement; 129, 130; 129, 133; 130, comparison_operator:is; 130, 131; 130, 132; 131, identifier:metadata; 132, None; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:metadata; 137, list:[]; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:metadata; 141, call; 141, 142; 141, 143; 142, identifier:list; 143, argument_list; 143, 144; 144, identifier:metadata; 145, try_statement; 145, 146; 145, 154; 145, 158; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:routing_header; 150, list:[("parent", parent)]; 150, 151; 151, tuple; 151, 152; 151, 153; 152, string:"parent"; 153, identifier:parent; 154, except_clause; 154, 155; 154, 156; 155, identifier:AttributeError; 156, block; 156, 157; 157, pass_statement; 158, else_clause; 158, 159; 159, block; 159, 160; 159, 175; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:routing_metadata; 163, call; 163, 164; 163, 173; 164, attribute; 164, 165; 164, 172; 165, attribute; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:google; 169, identifier:api_core; 170, identifier:gapic_v1; 171, identifier:routing_header; 172, identifier:to_grpc_metadata; 173, argument_list; 173, 174; 174, identifier:routing_header; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:metadata; 179, identifier:append; 180, argument_list; 180, 181; 181, identifier:routing_metadata; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:iterator; 185, call; 185, 186; 185, 193; 186, attribute; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:google; 190, identifier:api_core; 191, identifier:page_iterator; 192, identifier:GRPCIterator; 193, argument_list; 193, 194; 193, 197; 193, 218; 193, 221; 193, 224; 193, 227; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:client; 196, None; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:method; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:functools; 202, identifier:partial; 203, argument_list; 203, 204; 203, 209; 203, 212; 203, 215; 204, subscript; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:_inner_api_calls; 208, string:"list_findings"; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:retry; 211, identifier:retry; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:timeout; 214, identifier:timeout; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:metadata; 217, identifier:metadata; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:request; 220, identifier:request; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:items_field; 223, string:"findings"; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:request_token_field; 226, string:"page_token"; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:response_token_field; 229, string:"next_page_token"; 230, return_statement; 230, 231; 231, 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,
):
"""
Lists an organization or source's findings.
To list across all sources provide a ``-`` as the source id. Example:
/v1beta1/organizations/123/sources/-/findings
Example:
>>> from google.cloud import securitycenter_v1beta1
>>>
>>> client = securitycenter_v1beta1.SecurityCenterClient()
>>>
>>> parent = client.source_path('[ORGANIZATION]', '[SOURCE]')
>>>
>>> # Iterate over all results
>>> for element in client.list_findings(parent):
... # process element
... pass
>>>
>>>
>>> # Alternatively:
>>>
>>> # Iterate over results one page at a time
>>> for page in client.list_findings(parent).pages:
... for element in page:
... # process element
... pass
Args:
parent (str): Name of the source the findings belong to. Its format is
"organizations/[organization\_id]/sources/[source\_id]". To list across
all sources provide a source\_id of ``-``. For example:
organizations/123/sources/-
filter_ (str): Expression that defines the filter to apply across findings. The
expression is a list of one or more restrictions combined via logical
operators ``AND`` and ``OR``. Parentheses are not supported, and ``OR``
has higher precedence than ``AND``.
Restrictions have the form ``<field> <operator> <value>`` and may have a
``-`` character in front of them to indicate negation. Examples include:
- name
- source\_properties.a\_property
- security\_marks.marks.marka
The supported operators are:
- ``=`` for all value types.
- ``>``, ``<``, ``>=``, ``<=`` for integer values.
- ``:``, meaning substring matching, for strings.
The supported value types are:
- string literals in quotes.
- integer literals without quotes.
- boolean literals ``true`` and ``false`` without quotes.
For example, ``source_properties.size = 100`` is a valid filter string.
order_by (str): Expression that defines what fields and order to use for sorting. The
string value should follow SQL syntax: comma separated list of fields.
For example: "name,resource\_properties.a\_property". The default
sorting order is ascending. To specify descending order for a field, a
suffix " desc" should be appended to the field name. For example: "name
desc,source\_properties.a\_property". Redundant space characters in the
syntax are insignificant. "name desc,source\_properties.a\_property" and
" name desc , source\_properties.a\_property " are equivalent.
read_time (Union[dict, ~google.cloud.securitycenter_v1beta1.types.Timestamp]): Time used as a reference point when filtering findings. The filter is
limited to findings existing at the supplied time and their values are
those at that specific time. Absence of this field will default to the
API's version of NOW.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.securitycenter_v1beta1.types.Timestamp`
field_mask (Union[dict, ~google.cloud.securitycenter_v1beta1.types.FieldMask]): Optional.
A field mask to specify the Finding fields to be listed in the response.
An empty field mask will list all fields.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.securitycenter_v1beta1.types.FieldMask`
page_size (int): The maximum number of resources contained in the
underlying API response. If page streaming is performed per-
resource, this parameter does not affect the return value. If page
streaming is performed per-page, this determines the maximum number
of resources in a page.
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will not
be retried.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.gax.PageIterator` instance. By default, this
is an iterable of :class:`~google.cloud.securitycenter_v1beta1.types.Finding` instances.
This object can also be configured to iterate over the pages
of the response through the `options` parameter.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
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, 52; 49, 53; 49, 106; 49, 135; 49, 144; 49, 151; 49, 188; 49, 236; 50, expression_statement; 50, 51; 51, comment; 52, comment; 53, if_statement; 53, 54; 53, 59; 54, comparison_operator:not; 54, 55; 54, 56; 55, string:"list_traces"; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_inner_api_calls; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 67; 62, subscript; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:_inner_api_calls; 66, string:"list_traces"; 67, call; 67, 68; 67, 77; 68, attribute; 68, 69; 68, 76; 69, attribute; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:google; 73, identifier:api_core; 74, identifier:gapic_v1; 75, identifier:method; 76, identifier:wrap_method; 77, argument_list; 77, 78; 77, 83; 77, 92; 77, 101; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:transport; 82, identifier:list_traces; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:default_retry; 85, attribute; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:_method_configs; 90, string:"ListTraces"; 91, identifier:retry; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:default_timeout; 94, attribute; 94, 95; 94, 100; 95, subscript; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_method_configs; 99, string:"ListTraces"; 100, identifier:timeout; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:client_info; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:_client_info; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:request; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:trace_pb2; 112, identifier:ListTracesRequest; 113, argument_list; 113, 114; 113, 117; 113, 120; 113, 123; 113, 126; 113, 129; 113, 132; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:project_id; 116, identifier:project_id; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:view; 119, identifier:view; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:page_size; 122, identifier:page_size; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:start_time; 125, identifier:start_time; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:end_time; 128, identifier:end_time; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:filter; 131, identifier:filter_; 132, keyword_argument; 132, 133; 132, 134; 133, identifier:order_by; 134, identifier:order_by; 135, if_statement; 135, 136; 135, 139; 136, comparison_operator:is; 136, 137; 136, 138; 137, identifier:metadata; 138, None; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:metadata; 143, list:[]; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:metadata; 147, call; 147, 148; 147, 149; 148, identifier:list; 149, argument_list; 149, 150; 150, identifier:metadata; 151, try_statement; 151, 152; 151, 160; 151, 164; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:routing_header; 156, list:[("project_id", project_id)]; 156, 157; 157, tuple; 157, 158; 157, 159; 158, string:"project_id"; 159, identifier:project_id; 160, except_clause; 160, 161; 160, 162; 161, identifier:AttributeError; 162, block; 162, 163; 163, pass_statement; 164, else_clause; 164, 165; 165, block; 165, 166; 165, 181; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:routing_metadata; 169, call; 169, 170; 169, 179; 170, attribute; 170, 171; 170, 178; 171, attribute; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:google; 175, identifier:api_core; 176, identifier:gapic_v1; 177, identifier:routing_header; 178, identifier:to_grpc_metadata; 179, argument_list; 179, 180; 180, identifier:routing_header; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:metadata; 185, identifier:append; 186, argument_list; 186, 187; 187, identifier:routing_metadata; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:iterator; 191, call; 191, 192; 191, 199; 192, attribute; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:google; 196, identifier:api_core; 197, identifier:page_iterator; 198, identifier:GRPCIterator; 199, argument_list; 199, 200; 199, 203; 199, 224; 199, 227; 199, 230; 199, 233; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:client; 202, None; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:method; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:functools; 208, identifier:partial; 209, argument_list; 209, 210; 209, 215; 209, 218; 209, 221; 210, subscript; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:_inner_api_calls; 214, string:"list_traces"; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:retry; 217, identifier:retry; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:timeout; 220, identifier:timeout; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:metadata; 223, identifier:metadata; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:request; 226, identifier:request; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:items_field; 229, string:"traces"; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:request_token_field; 232, string:"page_token"; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:response_token_field; 235, string:"next_page_token"; 236, return_statement; 236, 237; 237, 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,
):
"""
Returns of a list of traces that match the specified filter conditions.
Example:
>>> from google.cloud import trace_v1
>>>
>>> client = trace_v1.TraceServiceClient()
>>>
>>> # TODO: Initialize `project_id`:
>>> project_id = ''
>>>
>>> # Iterate over all results
>>> for element in client.list_traces(project_id):
... # process element
... pass
>>>
>>>
>>> # Alternatively:
>>>
>>> # Iterate over results one page at a time
>>> for page in client.list_traces(project_id).pages:
... for element in page:
... # process element
... pass
Args:
project_id (str): ID of the Cloud project where the trace data is stored.
view (~google.cloud.trace_v1.types.ViewType): Type of data returned for traces in the list. Optional. Default is
``MINIMAL``.
page_size (int): The maximum number of resources contained in the
underlying API response. If page streaming is performed per-
resource, this parameter does not affect the return value. If page
streaming is performed per-page, this determines the maximum number
of resources in a page.
start_time (Union[dict, ~google.cloud.trace_v1.types.Timestamp]): Start of the time interval (inclusive) during which the trace data was
collected from the application.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.trace_v1.types.Timestamp`
end_time (Union[dict, ~google.cloud.trace_v1.types.Timestamp]): End of the time interval (inclusive) during which the trace data was
collected from the application.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.trace_v1.types.Timestamp`
filter_ (str): An optional filter against labels for the request.
By default, searches use prefix matching. To specify exact match,
prepend a plus symbol (``+``) to the search term. Multiple terms are
ANDed. Syntax:
- ``root:NAME_PREFIX`` or ``NAME_PREFIX``: Return traces where any root
span starts with ``NAME_PREFIX``.
- ``+root:NAME`` or ``+NAME``: Return traces where any root span's name
is exactly ``NAME``.
- ``span:NAME_PREFIX``: Return traces where any span starts with
``NAME_PREFIX``.
- ``+span:NAME``: Return traces where any span's name is exactly
``NAME``.
- ``latency:DURATION``: Return traces whose overall latency is greater
or equal to than ``DURATION``. Accepted units are nanoseconds
(``ns``), milliseconds (``ms``), and seconds (``s``). Default is
``ms``. For example, ``latency:24ms`` returns traces whose overall
latency is greater than or equal to 24 milliseconds.
- ``label:LABEL_KEY``: Return all traces containing the specified label
key (exact match, case-sensitive) regardless of the key:value pair's
value (including empty values).
- ``LABEL_KEY:VALUE_PREFIX``: Return all traces containing the
specified label key (exact match, case-sensitive) whose value starts
with ``VALUE_PREFIX``. Both a key and a value must be specified.
- ``+LABEL_KEY:VALUE``: Return all traces containing a key:value pair
exactly matching the specified text. Both a key and a value must be
specified.
- ``method:VALUE``: Equivalent to ``/http/method:VALUE``.
- ``url:VALUE``: Equivalent to ``/http/url:VALUE``.
order_by (str): Field used to sort the returned traces. Optional. Can be one of the
following:
- ``trace_id``
- ``name`` (``name`` field of root span in the trace)
- ``duration`` (difference between ``end_time`` and ``start_time``
fields of the root span)
- ``start`` (``start_time`` field of the root span)
Descending order can be specified by appending ``desc`` to the sort
field (for example, ``name desc``).
Only one sort field is permitted.
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will not
be retried.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.gax.PageIterator` instance. By default, this
is an iterable of :class:`~google.cloud.trace_v1.types.Trace` instances.
This object can also be configured to iterate over the pages
of the response through the `options` parameter.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
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, 9; 6, 21; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 15; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:value; 14, identifier:str; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:value; 19, list:[value]; 19, 20; 20, identifier:value; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 29; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_order; 27, slice; 27, 28; 28, colon; 29, identifier:value | def order(self, value):
"""Set the fields used to sort query results.
Sort fields will be applied in the order specified.
:type value: str or sequence of strings
:param value: Each value is a string giving the name of the
property on which to sort, optionally preceded by a
hyphen (-) to specify descending order.
Omitting the hyphen implies ascending order.
"""
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, 8; 5, 35; 5, 43; 5, 52; 5, 93; 5, 116; 5, 130; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 12; 8, 17; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:headers; 11, None; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:headers; 16, list:[]; 17, elif_clause; 17, 18; 17, 23; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:headers; 22, identifier:dict; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:headers; 27, call; 27, 28; 27, 29; 28, identifier:list; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:headers; 33, identifier:items; 34, argument_list; 35, if_statement; 35, 36; 35, 38; 36, not_operator; 36, 37; 37, identifier:headers; 38, block; 38, 39; 39, return_statement; 39, 40; 40, expression_list; 40, 41; 40, 42; 41, list:[]; 42, list:[]; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:normalized; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:collections; 49, identifier:defaultdict; 50, argument_list; 50, 51; 51, identifier:list; 52, for_statement; 52, 53; 52, 56; 52, 57; 53, pattern_list; 53, 54; 53, 55; 54, identifier:key; 55, identifier:val; 56, identifier:headers; 57, block; 57, 58; 57, 70; 57, 84; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:key; 61, call; 61, 62; 61, 69; 62, attribute; 62, 63; 62, 68; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:key; 66, identifier:lower; 67, argument_list; 68, identifier:strip; 69, argument_list; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:val; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:MULTIPLE_SPACES; 76, identifier:sub; 77, argument_list; 77, 78; 77, 79; 78, string:" "; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:val; 82, identifier:strip; 83, argument_list; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:normalized; 89, identifier:key; 90, identifier:append; 91, argument_list; 91, 92; 92, identifier:val; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:ordered_headers; 96, call; 96, 97; 96, 98; 97, identifier:sorted; 98, generator_expression; 98, 99; 98, 107; 99, tuple; 99, 100; 99, 101; 100, identifier:key; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, string:","; 104, identifier:join; 105, argument_list; 105, 106; 106, identifier:val; 107, for_in_clause; 107, 108; 107, 111; 108, pattern_list; 108, 109; 108, 110; 109, identifier:key; 110, identifier:val; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:normalized; 114, identifier:items; 115, argument_list; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:canonical_headers; 119, list_comprehension; 119, 120; 119, 127; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, string:"{}:{}"; 123, identifier:format; 124, argument_list; 124, 125; 125, list_splat; 125, 126; 126, identifier:item; 127, for_in_clause; 127, 128; 127, 129; 128, identifier:item; 129, identifier:ordered_headers; 130, return_statement; 130, 131; 131, expression_list; 131, 132; 131, 133; 132, identifier:canonical_headers; 133, identifier:ordered_headers | def get_canonical_headers(headers):
"""Canonicalize headers for signing.
See:
https://cloud.google.com/storage/docs/access-control/signed-urls#about-canonical-extension-headers
:type headers: Union[dict|List(Tuple(str,str))]
:param headers:
(Optional) Additional HTTP headers to be included as part of the
signed URLs. See:
https://cloud.google.com/storage/docs/xml-api/reference-headers
Requests using the signed URL *must* pass the specified header
(name and value) with each request for the URL.
:rtype: str
:returns: List of headers, normalized / sortted per the URL refernced above.
"""
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, 8; 5, 20; 5, 34; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:head; 11, list_comprehension; 11, 12; 11, 13; 11, 16; 12, identifier:label; 13, for_in_clause; 13, 14; 13, 15; 14, identifier:label; 15, identifier:TOP_RESOURCE_LABELS; 16, if_clause; 16, 17; 17, comparison_operator:in; 17, 18; 17, 19; 18, identifier:label; 19, identifier:labels; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:tail; 23, call; 23, 24; 23, 25; 24, identifier:sorted; 25, generator_expression; 25, 26; 25, 27; 25, 30; 26, identifier:label; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:label; 29, identifier:labels; 30, if_clause; 30, 31; 31, comparison_operator:not; 31, 32; 31, 33; 32, identifier:label; 33, identifier:TOP_RESOURCE_LABELS; 34, return_statement; 34, 35; 35, binary_operator:+; 35, 36; 35, 37; 36, identifier:head; 37, identifier:tail | def _sorted_resource_labels(labels):
"""Sort label names, putting well-known resource labels first."""
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, 48; 45, 49; 45, 102; 45, 131; 45, 140; 45, 147; 45, 184; 46, expression_statement; 46, 47; 47, comment; 48, comment; 49, if_statement; 49, 50; 49, 55; 50, comparison_operator:not; 50, 51; 50, 52; 51, string:"partition_read"; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:_inner_api_calls; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:_inner_api_calls; 62, string:"partition_read"; 63, call; 63, 64; 63, 73; 64, attribute; 64, 65; 64, 72; 65, attribute; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:google; 69, identifier:api_core; 70, identifier:gapic_v1; 71, identifier:method; 72, identifier:wrap_method; 73, argument_list; 73, 74; 73, 79; 73, 88; 73, 97; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:transport; 78, identifier:partition_read; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:default_retry; 81, attribute; 81, 82; 81, 87; 82, subscript; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_method_configs; 86, string:"PartitionRead"; 87, identifier:retry; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:default_timeout; 90, attribute; 90, 91; 90, 96; 91, subscript; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_method_configs; 95, string:"PartitionRead"; 96, identifier:timeout; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:client_info; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_client_info; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:request; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:spanner_pb2; 108, identifier:PartitionReadRequest; 109, argument_list; 109, 110; 109, 113; 109, 116; 109, 119; 109, 122; 109, 125; 109, 128; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:session; 112, identifier:session; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:table; 115, identifier:table; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:key_set; 118, identifier:key_set; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:transaction; 121, identifier:transaction; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:index; 124, identifier:index; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:columns; 127, identifier:columns; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:partition_options; 130, identifier:partition_options; 131, if_statement; 131, 132; 131, 135; 132, comparison_operator:is; 132, 133; 132, 134; 133, identifier:metadata; 134, None; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:metadata; 139, list:[]; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:metadata; 143, call; 143, 144; 143, 145; 144, identifier:list; 145, argument_list; 145, 146; 146, identifier:metadata; 147, try_statement; 147, 148; 147, 156; 147, 160; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:routing_header; 152, list:[("session", session)]; 152, 153; 153, tuple; 153, 154; 153, 155; 154, string:"session"; 155, identifier:session; 156, except_clause; 156, 157; 156, 158; 157, identifier:AttributeError; 158, block; 158, 159; 159, pass_statement; 160, else_clause; 160, 161; 161, block; 161, 162; 161, 177; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:routing_metadata; 165, call; 165, 166; 165, 175; 166, attribute; 166, 167; 166, 174; 167, attribute; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:google; 171, identifier:api_core; 172, identifier:gapic_v1; 173, identifier:routing_header; 174, identifier:to_grpc_metadata; 175, argument_list; 175, 176; 176, identifier:routing_header; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:metadata; 181, identifier:append; 182, argument_list; 182, 183; 183, identifier:routing_metadata; 184, return_statement; 184, 185; 185, call; 185, 186; 185, 191; 186, subscript; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:self; 189, identifier:_inner_api_calls; 190, string:"partition_read"; 191, argument_list; 191, 192; 191, 193; 191, 196; 191, 199; 192, identifier:request; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:retry; 195, identifier:retry; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:timeout; 198, identifier:timeout; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:metadata; 201, 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,
):
"""
Creates a set of partition tokens that can be used to execute a read
operation in parallel. Each of the returned partition tokens can be used
by ``StreamingRead`` to specify a subset of the read result to read. The
same session and read-only transaction must be used by the
PartitionReadRequest used to create the partition tokens and the
ReadRequests that use the partition tokens. There are no ordering
guarantees on rows returned among the returned partition tokens, or even
within each individual StreamingRead call issued with a
partition\_token.
Partition tokens become invalid when the session used to create them is
deleted, is idle for too long, begins a new transaction, or becomes too
old. When any of these happen, it is not possible to resume the read,
and the whole operation must be restarted from the beginning.
Example:
>>> from google.cloud import spanner_v1
>>>
>>> client = spanner_v1.SpannerClient()
>>>
>>> session = client.session_path('[PROJECT]', '[INSTANCE]', '[DATABASE]', '[SESSION]')
>>>
>>> # TODO: Initialize `table`:
>>> table = ''
>>>
>>> # TODO: Initialize `key_set`:
>>> key_set = {}
>>>
>>> response = client.partition_read(session, table, key_set)
Args:
session (str): Required. The session used to create the partitions.
table (str): Required. The name of the table in the database to be read.
key_set (Union[dict, ~google.cloud.spanner_v1.types.KeySet]): Required. ``key_set`` identifies the rows to be yielded. ``key_set``
names the primary keys of the rows in ``table`` to be yielded, unless
``index`` is present. If ``index`` is present, then ``key_set`` instead
names index keys in ``index``.
It is not an error for the ``key_set`` to name rows that do not exist in
the database. Read yields nothing for nonexistent rows.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.spanner_v1.types.KeySet`
transaction (Union[dict, ~google.cloud.spanner_v1.types.TransactionSelector]): Read only snapshot transactions are supported, read/write and single use
transactions are not.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.spanner_v1.types.TransactionSelector`
index (str): If non-empty, the name of an index on ``table``. This index is used
instead of the table primary key when interpreting ``key_set`` and
sorting result rows. See ``key_set`` for further information.
columns (list[str]): The columns of ``table`` to be returned for each row matching this
request.
partition_options (Union[dict, ~google.cloud.spanner_v1.types.PartitionOptions]): Additional options that affect how many partitions are created.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.spanner_v1.types.PartitionOptions`
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will not
be retried.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.cloud.spanner_v1.types.PartitionResponse` instance.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
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, 53; 50, 54; 50, 107; 50, 108; 50, 109; 50, 125; 50, 157; 50, 205; 51, expression_statement; 51, 52; 52, comment; 53, comment; 54, if_statement; 54, 55; 54, 60; 55, comparison_operator:not; 55, 56; 55, 57; 56, string:"list_documents"; 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:"list_documents"; 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:list_documents; 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:"ListDocuments"; 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:"ListDocuments"; 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, comment; 108, comment; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 118; 111, attribute; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:google; 115, identifier:api_core; 116, identifier:protobuf_helpers; 117, identifier:check_oneof; 118, argument_list; 118, 119; 118, 122; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:transaction; 121, identifier:transaction; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:read_time; 124, identifier:read_time; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:request; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:firestore_pb2; 131, identifier:ListDocumentsRequest; 132, argument_list; 132, 133; 132, 136; 132, 139; 132, 142; 132, 145; 132, 148; 132, 151; 132, 154; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:parent; 135, identifier:parent; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:collection_id; 138, identifier:collection_id; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:page_size; 141, identifier:page_size; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:order_by; 144, identifier:order_by; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:mask; 147, identifier:mask; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:transaction; 150, identifier:transaction; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:read_time; 153, identifier:read_time; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:show_missing; 156, identifier:show_missing; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:iterator; 160, call; 160, 161; 160, 168; 161, attribute; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:google; 165, identifier:api_core; 166, identifier:page_iterator; 167, identifier:GRPCIterator; 168, argument_list; 168, 169; 168, 172; 168, 193; 168, 196; 168, 199; 168, 202; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:client; 171, None; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:method; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:functools; 177, identifier:partial; 178, argument_list; 178, 179; 178, 184; 178, 187; 178, 190; 179, subscript; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:_inner_api_calls; 183, string:"list_documents"; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:retry; 186, identifier:retry; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:timeout; 189, identifier:timeout; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:metadata; 192, identifier:metadata; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:request; 195, identifier:request; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:items_field; 198, string:"documents"; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:request_token_field; 201, string:"page_token"; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:response_token_field; 204, string:"next_page_token"; 205, return_statement; 205, 206; 206, 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,
):
"""
Lists documents.
Example:
>>> from google.cloud import firestore_v1beta1
>>>
>>> client = firestore_v1beta1.FirestoreClient()
>>>
>>> parent = client.any_path_path('[PROJECT]', '[DATABASE]', '[DOCUMENT]', '[ANY_PATH]')
>>>
>>> # TODO: Initialize `collection_id`:
>>> collection_id = ''
>>>
>>> # Iterate over all results
>>> for element in client.list_documents(parent, collection_id):
... # process element
... pass
>>>
>>>
>>> # Alternatively:
>>>
>>> # Iterate over results one page at a time
>>> for page in client.list_documents(parent, collection_id).pages:
... for element in page:
... # process element
... pass
Args:
parent (str): The parent resource name. In the format:
``projects/{project_id}/databases/{database_id}/documents`` or
``projects/{project_id}/databases/{database_id}/documents/{document_path}``.
For example: ``projects/my-project/databases/my-database/documents`` or
``projects/my-project/databases/my-database/documents/chatrooms/my-chatroom``
collection_id (str): The collection ID, relative to ``parent``, to list. For example:
``chatrooms`` or ``messages``.
page_size (int): The maximum number of resources contained in the
underlying API response. If page streaming is performed per-
resource, this parameter does not affect the return value. If page
streaming is performed per-page, this determines the maximum number
of resources in a page.
order_by (str): The order to sort results by. For example: ``priority desc, name``.
mask (Union[dict, ~google.cloud.firestore_v1beta1.types.DocumentMask]): The fields to return. If not set, returns all fields.
If a document has a field that is not present in this mask, that field
will not be returned in the response.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.firestore_v1beta1.types.DocumentMask`
transaction (bytes): Reads documents in a transaction.
read_time (Union[dict, ~google.cloud.firestore_v1beta1.types.Timestamp]): Reads documents as they were at the given time.
This may not be older than 60 seconds.
If a dict is provided, it must be of the same form as the protobuf
message :class:`~google.cloud.firestore_v1beta1.types.Timestamp`
show_missing (bool): If the list should show missing documents. A missing document is a
document that does not exist but has sub-documents. These documents will
be returned with a key but will not have fields,
``Document.create_time``, or ``Document.update_time`` set.
Requests with ``show_missing`` may not specify ``where`` or
``order_by``.
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will not
be retried.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.gax.PageIterator` instance. By default, this
is an iterable of :class:`~google.cloud.firestore_v1beta1.types.Document` instances.
This object can also be configured to iterate over the pages
of the response through the `options` parameter.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
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,
)
# Sanity check: We have some fields which are mutually exclusive;
# raise ValueError if more than one is sent.
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, 15; 12, 26; 13, expression_statement; 13, 14; 14, comment; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:_check_categorical_option_type; 18, argument_list; 18, 19; 18, 20; 18, 21; 19, string:'output_type'; 20, identifier:output_type; 21, list:['class', 'margin', 'probability', 'probability_vector']; 21, 22; 21, 23; 21, 24; 21, 25; 22, string:'class'; 23, string:'margin'; 24, string:'probability'; 25, string:'probability_vector'; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 35; 28, attribute; 28, 29; 28, 34; 29, call; 29, 30; 29, 31; 30, identifier:super; 31, argument_list; 31, 32; 31, 33; 32, identifier:_Classifier; 33, identifier:self; 34, identifier:predict; 35, argument_list; 35, 36; 35, 37; 35, 40; 36, identifier:dataset; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:output_type; 39, identifier:output_type; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:missing_value_action; 42, identifier:missing_value_action | def predict(self, dataset, output_type='class', missing_value_action='auto'):
"""
A flexible and advanced prediction API.
The target column is provided during
:func:`~turicreate.decision_tree.create`. If the target column is in the
`dataset` it will be ignored.
Parameters
----------
dataset : SFrame
A dataset that has the same columns that were used during training.
If the target column exists in ``dataset`` it will be ignored
while making predictions.
output_type : {'probability', 'margin', 'class', 'probability_vector'}, optional.
Form of the predictions which are one of:
- 'probability': Prediction probability associated with the True
class (not applicable for multi-class classification)
- 'margin': Margin associated with the prediction (not applicable
for multi-class classification)
- 'probability_vector': Prediction probability associated with each
class as a vector. The probability of the first class (sorted
alphanumerically by name of the class in the training set) is in
position 0 of the vector, the second in position 1 and so on.
- 'class': Class prediction. For multi-class classification, this
returns the class with maximum probability.
missing_value_action : str, optional
Action to perform when missing values are encountered. Can be
one of:
- 'auto': By default the model will treat missing value as is.
- 'impute': Proceed with evaluation by filling in the missing
values with the mean of the training data. Missing
values are also imputed if an entire column of data is
missing during evaluation.
- 'error': Do not proceed with evaluation and terminate with
an error message.
Returns
-------
out : SArray
Predicted target value for each example (i.e. row) in the dataset.
See Also
----------
create, evaluate, classify
Examples
--------
>>> m.predict(testdata)
>>> m.predict(testdata, output_type='probability')
>>> m.predict(testdata, output_type='margin')
"""
_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, 9; 6, 35; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:y; 12, subscript; 12, 13; 12, 32; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 21; 15, 29; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:x; 19, identifier:items; 20, argument_list; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:key; 23, lambda; 23, 24; 23, 26; 24, lambda_parameters; 24, 25; 25, identifier:x; 26, subscript; 26, 27; 26, 28; 27, identifier:x; 28, integer:1; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:reverse; 31, True; 32, slice; 32, 33; 32, 34; 33, colon; 34, identifier:k; 35, return_statement; 35, 36; 36, list_comprehension; 36, 37; 36, 48; 37, dictionary; 37, 38; 37, 43; 38, pair; 38, 39; 38, 40; 39, string:'class'; 40, subscript; 40, 41; 40, 42; 41, identifier:i; 42, integer:0; 43, pair; 43, 44; 43, 45; 44, string:'votes'; 45, subscript; 45, 46; 45, 47; 46, identifier:i; 47, integer:1; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:i; 50, identifier:y | def _sort_topk_votes(x, k):
"""
Sort a dictionary of classes and corresponding vote totals according to the
votes, then truncate to the highest 'k' classes.
"""
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, 12; 9, 16; 9, 20; 9, 21; 9, 144; 9, 145; 9, 162; 9, 163; 9, 174; 9, 231; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:sort_column_names; 15, list:[]; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:sort_column_orders; 19, list:[]; 20, comment; 21, if_statement; 21, 22; 21, 29; 21, 35; 21, 137; 22, parenthesized_expression; 22, 23; 23, comparison_operator:==; 23, 24; 23, 28; 24, call; 24, 25; 24, 26; 25, identifier:type; 26, argument_list; 26, 27; 27, identifier:key_column_names; 28, identifier:str; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:sort_column_names; 33, list:[key_column_names]; 33, 34; 34, identifier:key_column_names; 35, elif_clause; 35, 36; 35, 43; 36, parenthesized_expression; 36, 37; 37, comparison_operator:==; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:type; 40, argument_list; 40, 41; 41, identifier:key_column_names; 42, identifier:list; 43, block; 43, 44; 43, 58; 43, 72; 43, 86; 43, 94; 44, if_statement; 44, 45; 44, 52; 45, parenthesized_expression; 45, 46; 46, comparison_operator:==; 46, 47; 46, 51; 47, call; 47, 48; 47, 49; 48, identifier:len; 49, argument_list; 49, 50; 50, identifier:key_column_names; 51, integer:0; 52, block; 52, 53; 53, raise_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:ValueError; 56, argument_list; 56, 57; 57, string:"Please provide at least one column to sort"; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:first_param_types; 61, call; 61, 62; 61, 63; 62, identifier:set; 63, argument_list; 63, 64; 64, list_comprehension; 64, 65; 64, 69; 65, call; 65, 66; 65, 67; 66, identifier:type; 67, argument_list; 67, 68; 68, identifier:i; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:i; 71, identifier:key_column_names; 72, if_statement; 72, 73; 72, 80; 73, parenthesized_expression; 73, 74; 74, comparison_operator:!=; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:first_param_types; 79, integer:1; 80, block; 80, 81; 81, raise_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:ValueError; 84, argument_list; 84, 85; 85, string:"key_column_names element are not of the same type"; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:first_param_type; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:first_param_types; 92, identifier:pop; 93, argument_list; 94, if_statement; 94, 95; 94, 99; 94, 120; 94, 130; 95, parenthesized_expression; 95, 96; 96, comparison_operator:==; 96, 97; 96, 98; 97, identifier:first_param_type; 98, identifier:tuple; 99, block; 99, 100; 99, 110; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:sort_column_names; 103, list_comprehension; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:i; 106, integer:0; 107, for_in_clause; 107, 108; 107, 109; 108, identifier:i; 109, identifier:key_column_names; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:sort_column_orders; 113, list_comprehension; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:i; 116, integer:1; 117, for_in_clause; 117, 118; 117, 119; 118, identifier:i; 119, identifier:key_column_names; 120, elif_clause; 120, 121; 120, 125; 121, parenthesized_expression; 121, 122; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:first_param_type; 124, identifier:str; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:sort_column_names; 129, identifier:key_column_names; 130, else_clause; 130, 131; 131, block; 131, 132; 132, raise_statement; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:TypeError; 135, argument_list; 135, 136; 136, string:"key_column_names type is not supported"; 137, else_clause; 137, 138; 138, block; 138, 139; 139, raise_statement; 139, 140; 140, call; 140, 141; 140, 142; 141, identifier:TypeError; 142, argument_list; 142, 143; 143, string:"key_column_names type is not correct. Supported types are str, list of str or list of (str,bool) pair."; 144, comment; 145, if_statement; 145, 146; 145, 153; 146, parenthesized_expression; 146, 147; 147, comparison_operator:==; 147, 148; 147, 152; 148, call; 148, 149; 148, 150; 149, identifier:len; 150, argument_list; 150, 151; 151, identifier:sort_column_orders; 152, integer:0; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:sort_column_orders; 157, list_comprehension; 157, 158; 157, 159; 158, identifier:ascending; 159, for_in_clause; 159, 160; 159, 161; 160, identifier:i; 161, identifier:sort_column_names; 162, comment; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:my_column_names; 166, call; 166, 167; 166, 168; 167, identifier:set; 168, argument_list; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:column_names; 173, argument_list; 174, for_statement; 174, 175; 174, 176; 174, 177; 175, identifier:column; 176, identifier:sort_column_names; 177, block; 177, 178; 177, 192; 177, 210; 178, if_statement; 178, 179; 178, 186; 179, parenthesized_expression; 179, 180; 180, comparison_operator:!=; 180, 181; 180, 185; 181, call; 181, 182; 181, 183; 182, identifier:type; 183, argument_list; 183, 184; 184, identifier:column; 185, identifier:str; 186, block; 186, 187; 187, raise_statement; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:TypeError; 190, argument_list; 190, 191; 191, string:"Only string parameter can be passed in as column names"; 192, if_statement; 192, 193; 192, 197; 193, parenthesized_expression; 193, 194; 194, comparison_operator:not; 194, 195; 194, 196; 195, identifier:column; 196, identifier:my_column_names; 197, block; 197, 198; 198, raise_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:ValueError; 201, argument_list; 201, 202; 202, binary_operator:+; 202, 203; 202, 209; 203, binary_operator:+; 203, 204; 203, 205; 204, string:"SFrame has no column named: '"; 205, call; 205, 206; 205, 207; 206, identifier:str; 207, argument_list; 207, 208; 208, identifier:column; 209, string:"'"; 210, if_statement; 210, 211; 210, 225; 211, parenthesized_expression; 211, 212; 212, comparison_operator:not; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:self; 216, identifier:column; 217, identifier:dtype; 218, tuple; 218, 219; 218, 220; 218, 221; 218, 222; 219, identifier:str; 220, identifier:int; 221, identifier:float; 222, attribute; 222, 223; 222, 224; 223, identifier:datetime; 224, identifier:datetime; 225, block; 225, 226; 226, raise_statement; 226, 227; 227, call; 227, 228; 227, 229; 228, identifier:TypeError; 229, argument_list; 229, 230; 230, string:"Only columns of type (str, int, float) can be sorted"; 231, with_statement; 231, 232; 231, 237; 232, with_clause; 232, 233; 233, with_item; 233, 234; 234, call; 234, 235; 234, 236; 235, identifier:cython_context; 236, argument_list; 237, block; 237, 238; 238, return_statement; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:SFrame; 241, argument_list; 241, 242; 242, keyword_argument; 242, 243; 242, 244; 243, identifier:_proxy; 244, call; 244, 245; 244, 250; 245, attribute; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:__proxy__; 249, identifier:sort; 250, argument_list; 250, 251; 250, 252; 251, identifier:sort_column_names; 252, identifier:sort_column_orders | def sort(self, key_column_names, ascending=True):
"""
Sort current SFrame by the given columns, using the given sort order.
Only columns that are type of str, int and float can be sorted.
Parameters
----------
key_column_names : str | list of str | list of (str, bool) pairs
Names of columns to be sorted. The result will be sorted first by
first column, followed by second column, and so on. All columns will
be sorted in the same order as governed by the `ascending`
parameter. To control the sort ordering for each column
individually, `key_column_names` must be a list of (str, bool) pairs.
Given this case, the first value is the column name and the second
value is a boolean indicating whether the sort order is ascending.
ascending : bool, optional
Sort all columns in the given order.
Returns
-------
out : SFrame
A new SFrame that is sorted according to given sort criteria
See Also
--------
topk
Examples
--------
Suppose 'sf' is an sframe that has three columns 'a', 'b', 'c'.
To sort by column 'a', ascending
>>> sf = turicreate.SFrame({'a':[1,3,2,1],
... 'b':['a','c','b','b'],
... 'c':['x','y','z','y']})
>>> sf
+---+---+---+
| a | b | c |
+---+---+---+
| 1 | a | x |
| 3 | c | y |
| 2 | b | z |
| 1 | b | y |
+---+---+---+
[4 rows x 3 columns]
>>> sf.sort('a')
+---+---+---+
| a | b | c |
+---+---+---+
| 1 | a | x |
| 1 | b | y |
| 2 | b | z |
| 3 | c | y |
+---+---+---+
[4 rows x 3 columns]
To sort by column 'a', descending
>>> sf.sort('a', ascending = False)
+---+---+---+
| a | b | c |
+---+---+---+
| 3 | c | y |
| 2 | b | z |
| 1 | a | x |
| 1 | b | y |
+---+---+---+
[4 rows x 3 columns]
To sort by column 'a' and 'b', all ascending
>>> sf.sort(['a', 'b'])
+---+---+---+
| a | b | c |
+---+---+---+
| 1 | a | x |
| 1 | b | y |
| 2 | b | z |
| 3 | c | y |
+---+---+---+
[4 rows x 3 columns]
To sort by column 'a' ascending, and then by column 'c' descending
>>> sf.sort([('a', True), ('c', False)])
+---+---+---+
| a | b | c |
+---+---+---+
| 1 | b | y |
| 1 | a | x |
| 2 | b | z |
| 3 | c | y |
+---+---+---+
[4 rows x 3 columns]
"""
sort_column_names = []
sort_column_orders = []
# validate key_column_names
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.")
# use the second parameter if the sort order is not given
if (len(sort_column_orders) == 0):
sort_column_orders = [ascending for i in sort_column_names]
# make sure all column exists
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, 14; 11, 25; 11, 47; 11, 48; 11, 49; 11, 50; 11, 58; 11, 73; 11, 74; 11, 75; 11, 83; 11, 116; 11, 126; 11, 127; 11, 160; 11, 161; 11, 175; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:factory; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:message_factory; 20, identifier:MessageFactory; 21, argument_list; 21, 22; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:pool; 24, identifier:pool; 25, if_statement; 25, 26; 25, 29; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:full_name; 28, None; 29, block; 29, 30; 30, try_statement; 30, 31; 30, 42; 31, block; 31, 32; 31, 40; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:proto_cls; 35, call; 35, 36; 35, 37; 36, identifier:_GetMessageFromFactory; 37, argument_list; 37, 38; 37, 39; 38, identifier:factory; 39, identifier:full_name; 40, return_statement; 40, 41; 41, identifier:proto_cls; 42, except_clause; 42, 43; 42, 44; 42, 45; 43, identifier:KeyError; 44, comment; 45, block; 45, 46; 46, pass_statement; 47, comment; 48, comment; 49, comment; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:field_items; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:fields; 56, identifier:items; 57, argument_list; 58, if_statement; 58, 59; 58, 65; 59, not_operator; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:isinstance; 62, argument_list; 62, 63; 62, 64; 63, identifier:fields; 64, identifier:OrderedDict; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:field_items; 69, call; 69, 70; 69, 71; 70, identifier:sorted; 71, argument_list; 71, 72; 72, identifier:field_items; 73, comment; 74, comment; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:fields_hash; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:hashlib; 81, identifier:sha1; 82, argument_list; 83, for_statement; 83, 84; 83, 87; 83, 88; 84, pattern_list; 84, 85; 84, 86; 85, identifier:f_name; 86, identifier:f_type; 87, identifier:field_items; 88, block; 88, 89; 88, 101; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:fields_hash; 93, identifier:update; 94, argument_list; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:f_name; 98, identifier:encode; 99, argument_list; 99, 100; 100, string:'utf-8'; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:fields_hash; 105, identifier:update; 106, argument_list; 106, 107; 107, call; 107, 108; 107, 114; 108, attribute; 108, 109; 108, 113; 109, call; 109, 110; 109, 111; 110, identifier:str; 111, argument_list; 111, 112; 112, identifier:f_type; 113, identifier:encode; 114, argument_list; 114, 115; 115, string:'utf-8'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:proto_file_name; 119, binary_operator:+; 119, 120; 119, 125; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:fields_hash; 123, identifier:hexdigest; 124, argument_list; 125, string:'.proto'; 126, comment; 127, if_statement; 127, 128; 127, 131; 128, comparison_operator:is; 128, 129; 128, 130; 129, identifier:full_name; 130, None; 131, block; 131, 132; 131, 143; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:full_name; 135, parenthesized_expression; 135, 136; 136, binary_operator:+; 136, 137; 136, 138; 137, string:'net.proto2.python.public.proto_builder.AnonymousProto_'; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:fields_hash; 141, identifier:hexdigest; 142, argument_list; 143, try_statement; 143, 144; 143, 155; 144, block; 144, 145; 144, 153; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:proto_cls; 148, call; 148, 149; 148, 150; 149, identifier:_GetMessageFromFactory; 150, argument_list; 150, 151; 150, 152; 151, identifier:factory; 152, identifier:full_name; 153, return_statement; 153, 154; 154, identifier:proto_cls; 155, except_clause; 155, 156; 155, 157; 155, 158; 156, identifier:KeyError; 157, comment; 158, block; 158, 159; 159, pass_statement; 160, comment; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:factory; 166, identifier:pool; 167, identifier:Add; 168, argument_list; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:_MakeFileDescriptorProto; 171, argument_list; 171, 172; 171, 173; 171, 174; 172, identifier:proto_file_name; 173, identifier:full_name; 174, identifier:field_items; 175, return_statement; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:_GetMessageFromFactory; 178, argument_list; 178, 179; 178, 180; 179, identifier:factory; 180, identifier:full_name | def MakeSimpleProtoClass(fields, full_name=None, pool=None):
"""Create a Protobuf class whose fields are basic types.
Note: this doesn't validate field names!
Args:
fields: dict of {name: field_type} mappings for each field in the proto. If
this is an OrderedDict the order will be maintained, otherwise the
fields will be sorted by name.
full_name: optional str, the fully-qualified name of the proto type.
pool: optional DescriptorPool instance.
Returns:
a class, the new protobuf class with a FileDescriptor.
"""
factory = message_factory.MessageFactory(pool=pool)
if full_name is not None:
try:
proto_cls = _GetMessageFromFactory(factory, full_name)
return proto_cls
except KeyError:
# The factory's DescriptorPool doesn't know about this class yet.
pass
# Get a list of (name, field_type) tuples from the fields dict. If fields was
# an OrderedDict we keep the order, but otherwise we sort the field to ensure
# consistent ordering.
field_items = fields.items()
if not isinstance(fields, OrderedDict):
field_items = sorted(field_items)
# Use a consistent file name that is unlikely to conflict with any imported
# proto files.
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 the proto is anonymous, use the same hash to name it.
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:
# The factory's DescriptorPool doesn't know about this class yet.
pass
# This is the first time we see this proto: add a new descriptor to the pool.
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, 8; 5, 17; 6, expression_statement; 6, 7; 7, comment; 8, import_from_statement; 8, 9; 8, 13; 9, relative_import; 9, 10; 9, 11; 10, import_prefix; 11, dotted_name; 11, 12; 12, identifier:sframe; 13, aliased_import; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:SFrame; 16, identifier:_SFrame; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 39; 19, attribute; 19, 20; 19, 38; 20, call; 20, 21; 20, 30; 21, attribute; 21, 22; 21, 29; 22, call; 22, 23; 22, 24; 23, identifier:_SFrame; 24, argument_list; 24, 25; 25, dictionary; 25, 26; 26, pair; 26, 27; 26, 28; 27, string:'value'; 28, identifier:self; 29, identifier:groupby; 30, argument_list; 30, 31; 30, 32; 31, string:'value'; 32, dictionary; 32, 33; 33, pair; 33, 34; 33, 35; 34, string:'count'; 35, attribute; 35, 36; 35, 37; 36, identifier:_aggregate; 37, identifier:COUNT; 38, identifier:sort; 39, argument_list; 39, 40; 39, 41; 40, string:'count'; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:ascending; 43, False | def value_counts(self):
"""
Return an SFrame containing counts of unique values. The resulting
SFrame will be sorted in descending frequency.
Returns
-------
out : SFrame
An SFrame containing 2 columns : 'value', and 'count'. The SFrame will
be sorted in descending order by the column 'count'.
See Also
--------
SFrame.summary
Examples
--------
>>> sa = turicreate.SArray([1,1,2,2,2,2,3,3,3,3,3,3,3])
>>> sa.value_counts()
Columns:
value int
count int
Rows: 3
Data:
+-------+-------+
| value | count |
+-------+-------+
| 3 | 7 |
| 2 | 4 |
| 1 | 2 |
+-------+-------+
[3 rows x 2 columns]
"""
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, 11; 8, 20; 8, 38; 8, 44; 8, 50; 9, expression_statement; 9, 10; 10, comment; 11, import_from_statement; 11, 12; 11, 16; 12, relative_import; 12, 13; 12, 14; 13, import_prefix; 14, dotted_name; 14, 15; 15, identifier:sframe; 16, aliased_import; 16, 17; 16, 19; 17, dotted_name; 17, 18; 18, identifier:SFrame; 19, identifier:_SFrame; 20, if_statement; 20, 21; 20, 32; 21, comparison_operator:not; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:dtype; 25, tuple; 25, 26; 25, 27; 25, 28; 25, 29; 26, identifier:int; 27, identifier:float; 28, identifier:str; 29, attribute; 29, 30; 29, 31; 30, identifier:datetime; 31, identifier:datetime; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:TypeError; 36, argument_list; 36, 37; 37, string:"Only sarray with type (int, float, str, datetime.datetime) can be sorted"; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:sf; 41, call; 41, 42; 41, 43; 42, identifier:_SFrame; 43, argument_list; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:sf; 48, string:'a'; 49, identifier:self; 50, return_statement; 50, 51; 51, subscript; 51, 52; 51, 59; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:sf; 55, identifier:sort; 56, argument_list; 56, 57; 56, 58; 57, string:'a'; 58, identifier:ascending; 59, string:'a' | def sort(self, ascending=True):
"""
Sort all values in this SArray.
Sort only works for sarray of type str, int and float, otherwise TypeError
will be raised. Creates a new, sorted SArray.
Parameters
----------
ascending: boolean, optional
If true, the sarray values are sorted in ascending order, otherwise,
descending order.
Returns
-------
out: SArray
Examples
--------
>>> sa = SArray([3,2,1])
>>> sa.sort()
dtype: int
Rows: 3
[1, 2, 3]
"""
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, 12; 9, 20; 9, 28; 9, 32; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:m; 15, subscript; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:__proxy__; 19, string:'classifier'; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:target; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:__proxy__; 27, string:'target'; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:f; 31, identifier:_BOW_FEATURE_EXTRACTOR; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:m; 36, identifier:predict; 37, argument_list; 37, 38; 37, 43; 38, call; 38, 39; 38, 40; 39, identifier:f; 40, argument_list; 40, 41; 40, 42; 41, identifier:dataset; 42, identifier:target; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:output_type; 45, identifier:output_type | def predict(self, dataset, output_type='class'):
"""
Return predictions for ``dataset``, using the trained model.
Parameters
----------
dataset : SFrame
dataset of new observations. Must include columns with the same
names as the features used for model training, but does not require
a target column. Additional columns are ignored.
output_type : {'class', 'probability_vector'}, optional
Form of the predictions which are one of:
- 'probability_vector': Prediction probability associated with each
class as a vector. The probability of the first class (sorted
alphanumerically by name of the class in the training set) is in
position 0 of the vector, the second in position 1 and so on.
- 'class': Class prediction. For multi-class classification, this
returns the class with maximum probability.
Returns
-------
out : SArray
An SArray with model predictions.
See Also
----------
create, evaluate, classify
Examples
--------
>>> import turicreate as tc
>>> dataset = tc.SFrame({'rating': [1, 5], 'text': ['hate it', 'love it']})
>>> m = tc.text_classifier.create(dataset, 'rating', features=['text'])
>>> m.predict(dataset)
"""
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, 9; 6, 51; 7, expression_statement; 7, 8; 8, comment; 9, try_statement; 9, 10; 9, 46; 10, block; 10, 11; 11, if_statement; 11, 12; 11, 20; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:event; 16, identifier:message; 17, identifier:startswith; 18, argument_list; 18, 19; 19, string:"{"; 20, block; 20, 21; 20, 32; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:msg_dict; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:json; 27, identifier:loads; 28, argument_list; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:event; 31, identifier:message; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:event; 36, identifier:message; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:json; 40, identifier:dumps; 41, argument_list; 41, 42; 41, 43; 42, identifier:msg_dict; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:indent; 45, integer:2; 46, except_clause; 46, 47; 46, 48; 46, 49; 47, identifier:Exception; 48, comment; 49, block; 49, 50; 50, pass_statement; 51, return_statement; 51, 52; 52, identifier:event | def format_json(event, colored):
"""
If the event message is a JSON string, then pretty print the JSON with 2 indents and sort the keys. This makes
it very easy to visually parse and search JSON data
"""
try:
if event.message.startswith("{"):
msg_dict = json.loads(event.message)
event.message = json.dumps(msg_dict, indent=2)
except Exception:
# Skip if the event message was not JSON
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, 19; 16, 28; 16, 36; 16, 49; 16, 71; 16, 75; 16, 90; 16, 107; 16, 126; 16, 154; 17, expression_statement; 17, 18; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:weights; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:kernel_fn; 26, argument_list; 26, 27; 27, identifier:distances; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:labels_column; 31, subscript; 31, 32; 31, 33; 31, 35; 32, identifier:neighborhood_labels; 33, slice; 33, 34; 34, colon; 35, identifier:label; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:used_features; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:feature_selection; 43, argument_list; 43, 44; 43, 45; 43, 46; 43, 47; 43, 48; 44, identifier:neighborhood_data; 45, identifier:labels_column; 46, identifier:weights; 47, identifier:num_features; 48, identifier:feature_selection; 49, if_statement; 49, 50; 49, 53; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:model_regressor; 52, None; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:model_regressor; 57, call; 57, 58; 57, 59; 58, identifier:Ridge; 59, argument_list; 59, 60; 59, 63; 59, 66; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:alpha; 62, integer:1; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:fit_intercept; 65, True; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:random_state; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:random_state; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:easy_model; 74, identifier:model_regressor; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:easy_model; 79, identifier:fit; 80, argument_list; 80, 81; 80, 86; 80, 87; 81, subscript; 81, 82; 81, 83; 81, 85; 82, identifier:neighborhood_data; 83, slice; 83, 84; 84, colon; 85, identifier:used_features; 86, identifier:labels_column; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:sample_weight; 89, identifier:weights; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:prediction_score; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:easy_model; 96, identifier:score; 97, argument_list; 97, 98; 97, 103; 97, 104; 98, subscript; 98, 99; 98, 100; 98, 102; 99, identifier:neighborhood_data; 100, slice; 100, 101; 101, colon; 102, identifier:used_features; 103, identifier:labels_column; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:sample_weight; 106, identifier:weights; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:local_pred; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:easy_model; 113, identifier:predict; 114, argument_list; 114, 115; 115, call; 115, 116; 115, 122; 116, attribute; 116, 117; 116, 121; 117, subscript; 117, 118; 117, 119; 117, 120; 118, identifier:neighborhood_data; 119, integer:0; 120, identifier:used_features; 121, identifier:reshape; 122, argument_list; 122, 123; 122, 124; 123, integer:1; 124, unary_operator:-; 124, 125; 125, integer:1; 126, if_statement; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:verbose; 130, block; 130, 131; 130, 139; 130, 145; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:print; 134, argument_list; 134, 135; 134, 136; 135, string:'Intercept'; 136, attribute; 136, 137; 136, 138; 137, identifier:easy_model; 138, identifier:intercept_; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 142; 141, identifier:print; 142, argument_list; 142, 143; 142, 144; 143, string:'Prediction_local'; 144, identifier:local_pred; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:print; 148, argument_list; 148, 149; 148, 150; 149, string:'Right:'; 150, subscript; 150, 151; 150, 152; 150, 153; 151, identifier:neighborhood_labels; 152, integer:0; 153, identifier:label; 154, return_statement; 154, 155; 155, tuple; 155, 156; 155, 159; 155, 185; 155, 186; 156, attribute; 156, 157; 156, 158; 157, identifier:easy_model; 158, identifier:intercept_; 159, call; 159, 160; 159, 161; 160, identifier:sorted; 161, argument_list; 161, 162; 161, 169; 161, 182; 162, call; 162, 163; 162, 164; 163, identifier:zip; 164, argument_list; 164, 165; 164, 166; 165, identifier:used_features; 166, attribute; 166, 167; 166, 168; 167, identifier:easy_model; 168, identifier:coef_; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:key; 171, lambda; 171, 172; 171, 174; 172, lambda_parameters; 172, 173; 173, identifier:x; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:np; 177, identifier:abs; 178, argument_list; 178, 179; 179, subscript; 179, 180; 179, 181; 180, identifier:x; 181, integer:1; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:reverse; 184, True; 185, identifier:prediction_score; 186, identifier:local_pred | def explain_instance_with_data(self,
neighborhood_data,
neighborhood_labels,
distances,
label,
num_features,
feature_selection='auto',
model_regressor=None):
"""Takes perturbed data, labels and distances, returns explanation.
Args:
neighborhood_data: perturbed data, 2d array. first element is
assumed to be the original data point.
neighborhood_labels: corresponding perturbed labels. should have as
many columns as the number of possible labels.
distances: distances to original data point.
label: label for which we want an explanation
num_features: maximum number of features in explanation
feature_selection: how to select num_features. options are:
'forward_selection': iteratively add features to the model.
This is costly when num_features is high
'highest_weights': selects the features that have the highest
product of absolute weight * original data point when
learning with all the features
'lasso_path': chooses features based on the lasso
regularization path
'none': uses all features, ignores num_features
'auto': uses forward_selection if num_features <= 6, and
'highest_weights' otherwise.
model_regressor: sklearn regressor to use in explanation.
Defaults to Ridge regression if None. Must have
model_regressor.coef_ and 'sample_weight' as a parameter
to model_regressor.fit()
Returns:
(intercept, exp, score, local_pred):
intercept is a float.
exp is a sorted list of tuples, where each tuple (x,y) corresponds
to the feature id (x) and the local weight (y). The list is sorted
by decreasing absolute value of y.
score is the R^2 value of the returned explanation
local_pred is the prediction of the explanation model on the original instance
"""
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, 17; 13, 36; 13, 50; 13, 67; 13, 78; 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, comment; 17, for_statement; 17, 18; 17, 19; 17, 23; 18, identifier:name; 19, list:['allow_nan', 'separators', 'sort_keys']; 19, 20; 19, 21; 19, 22; 20, string:'allow_nan'; 21, string:'separators'; 22, string:'sort_keys'; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:name; 27, identifier:kwargs; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:ValueError; 32, argument_list; 32, 33; 33, binary_operator:%; 33, 34; 33, 35; 34, string:"The value of %r is computed internally, overriding is not permissable."; 35, identifier:name; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:pretty; 39, None; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:pretty; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:settings; 47, identifier:pretty; 48, argument_list; 48, 49; 49, False; 50, if_statement; 50, 51; 50, 52; 50, 59; 51, identifier:pretty; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:separators; 56, tuple; 56, 57; 56, 58; 57, string:","; 58, string:": "; 59, else_clause; 59, 60; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:separators; 64, tuple; 64, 65; 64, 66; 65, string:","; 66, string:":"; 67, if_statement; 67, 68; 67, 73; 68, boolean_operator:and; 68, 69; 68, 70; 69, identifier:pretty; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:indent; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:indent; 77, integer:2; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:json; 82, identifier:dumps; 83, argument_list; 83, 84; 83, 85; 83, 88; 83, 91; 83, 94; 83, 97; 83, 100; 84, identifier:obj; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:cls; 87, identifier:BokehJSONEncoder; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:allow_nan; 90, False; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:indent; 93, identifier:indent; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:separators; 96, identifier:separators; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:sort_keys; 99, True; 100, dictionary_splat; 100, 101; 101, 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
}
'''
# these args to json.dumps are computed internally and should not be passed along
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, 8; 5, 28; 5, 51; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:children; 11, list_comprehension; 11, 12; 11, 18; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:item; 15, identifier:child; 16, argument_list; 16, 17; 17, identifier:index; 18, for_in_clause; 18, 19; 18, 20; 19, identifier:index; 20, call; 20, 21; 20, 22; 21, identifier:range; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:item; 26, identifier:childCount; 27, argument_list; 28, for_statement; 28, 29; 28, 30; 28, 34; 29, identifier:child; 30, subscript; 30, 31; 30, 32; 31, identifier:children; 32, slice; 32, 33; 33, colon; 34, block; 34, 35; 34, 42; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:others; 38, call; 38, 39; 38, 40; 39, identifier:get_item_children; 40, argument_list; 40, 41; 41, identifier:child; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:others; 45, None; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, augmented_assignment:+=; 48, 49; 48, 50; 49, identifier:children; 50, identifier:others; 51, return_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:sorted; 54, argument_list; 54, 55; 54, 56; 55, identifier:children; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:key; 58, lambda; 58, 59; 58, 61; 59, lambda_parameters; 59, 60; 60, identifier:child; 61, attribute; 61, 62; 61, 63; 62, identifier:child; 63, identifier:line | def get_item_children(item):
"""Return a sorted list of all the children items of '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, 8; 5, 16; 5, 36; 5, 95; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 14; 9, comparison_operator:is; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:show_all_files; 13, False; 14, block; 14, 15; 15, return_statement; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:current_ordered_items; 19, list_comprehension; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:topLevelItem; 24, argument_list; 24, 25; 25, identifier:index; 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, if_statement; 36, 37; 36, 40; 36, 65; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:sort_files_alphabetically; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:new_ordered_items; 44, call; 44, 45; 44, 46; 45, identifier:sorted; 46, argument_list; 46, 47; 46, 48; 47, identifier:current_ordered_items; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:key; 50, lambda; 50, 51; 50, 53; 51, lambda_parameters; 51, 52; 52, identifier:item; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:osp; 56, identifier:basename; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:item; 62, identifier:path; 63, identifier:lower; 64, argument_list; 65, else_clause; 65, 66; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:new_ordered_items; 70, list_comprehension; 70, 71; 70, 79; 70, 84; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:editor_items; 76, identifier:get; 77, argument_list; 77, 78; 78, identifier:e_id; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:e_id; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:ordered_editor_ids; 84, if_clause; 84, 85; 85, comparison_operator:is; 85, 86; 85, 94; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:editor_items; 91, identifier:get; 92, argument_list; 92, 93; 93, identifier:e_id; 94, None; 95, if_statement; 95, 96; 95, 99; 96, comparison_operator:!=; 96, 97; 96, 98; 97, identifier:current_ordered_items; 98, identifier:new_ordered_items; 99, block; 99, 100; 99, 108; 99, 114; 99, 132; 99, 149; 99, 155; 99, 161; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:selected_items; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:selectedItems; 107, argument_list; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:save_expanded_state; 113, argument_list; 114, for_statement; 114, 115; 114, 116; 114, 124; 115, identifier:index; 116, call; 116, 117; 116, 118; 117, identifier:range; 118, argument_list; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:topLevelItemCount; 123, argument_list; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:takeTopLevelItem; 130, argument_list; 130, 131; 131, integer:0; 132, for_statement; 132, 133; 132, 136; 132, 140; 133, pattern_list; 133, 134; 133, 135; 134, identifier:index; 135, identifier:item; 136, call; 136, 137; 136, 138; 137, identifier:enumerate; 138, argument_list; 138, 139; 139, identifier:new_ordered_items; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:insertTopLevelItem; 146, argument_list; 146, 147; 146, 148; 147, identifier:index; 148, identifier:item; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:restore_expanded_state; 154, argument_list; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:clearSelection; 160, argument_list; 161, if_statement; 161, 162; 161, 163; 162, identifier:selected_items; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 172; 166, attribute; 166, 167; 166, 171; 167, subscript; 167, 168; 167, 169; 168, identifier:selected_items; 169, unary_operator:-; 169, 170; 170, integer:1; 171, identifier:setSelected; 172, argument_list; 172, 173; 173, True | def __sort_toplevel_items(self):
"""
Sort the root file items in alphabetical order if
'sort_files_alphabetically' is True, else order the items as
specified in the 'self.ordered_editor_ids' list.
"""
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, 9; 6, 26; 6, 36; 6, 44; 6, 98; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 16; 10, comparison_operator:==; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:sort_old; 14, list:[None]; 14, 15; 15, None; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:header_class; 23, identifier:setSortIndicatorShown; 24, argument_list; 24, 25; 25, True; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:sort_order; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:header_class; 34, identifier:sortIndicatorOrder; 35, argument_list; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:sig_sort_by_column; 42, identifier:emit; 43, argument_list; 44, if_statement; 44, 45; 44, 57; 45, not_operator; 45, 46; 46, call; 46, 47; 46, 54; 47, attribute; 47, 48; 47, 53; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:model; 52, argument_list; 53, identifier:sort; 54, argument_list; 54, 55; 54, 56; 55, identifier:index; 56, identifier:sort_order; 57, block; 57, 58; 57, 97; 58, if_statement; 58, 59; 58, 67; 58, 77; 59, comparison_operator:!=; 59, 60; 59, 66; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:sort_old; 66, integer:2; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:header_class; 74, identifier:setSortIndicatorShown; 75, argument_list; 75, 76; 76, False; 77, else_clause; 77, 78; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:header_class; 85, identifier:setSortIndicator; 86, argument_list; 86, 87; 86, 92; 87, subscript; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:sort_old; 91, integer:0; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:sort_old; 96, integer:1; 97, return_statement; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:sort_old; 103, list:[index, self.header_class.sortIndicatorOrder()]; 103, 104; 103, 105; 104, identifier:index; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:header_class; 110, identifier:sortIndicatorOrder; 111, argument_list | def sortByColumn(self, index):
"""Implement a column sort."""
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, 14; 11, 22; 11, 36; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:ascending; 17, comparison_operator:==; 17, 18; 17, 19; 18, identifier:order; 19, attribute; 19, 20; 19, 21; 20, identifier:Qt; 21, identifier:AscendingOrder; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:model; 28, identifier:sort; 29, argument_list; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:COLUMN_INDEX; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:order; 35, identifier:ascending; 36, return_statement; 36, 37; 37, True | def sort(self, column, order=Qt.AscendingOrder):
"""Overriding sort method."""
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, 9; 6, 22; 6, 36; 6, 50; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 20; 11, attribute; 11, 12; 11, 19; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:table_level; 17, identifier:horizontalHeader; 18, argument_list; 19, identifier:setSortIndicatorShown; 20, argument_list; 20, 21; 21, True; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sort_order; 25, call; 25, 26; 25, 35; 26, attribute; 26, 27; 26, 34; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:table_level; 32, identifier:horizontalHeader; 33, argument_list; 34, identifier:sortIndicatorOrder; 35, argument_list; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 47; 38, attribute; 38, 39; 38, 46; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:table_index; 44, identifier:model; 45, argument_list; 46, identifier:sort; 47, argument_list; 47, 48; 47, 49; 48, identifier:index; 49, identifier:sort_order; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:_sort_update; 55, argument_list | def sortByIndex(self, index):
"""Implement a Index sort."""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, while_statement; 8, 9; 8, 16; 9, comparison_operator:is; 9, 10; 9, 15; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:sorted; 14, argument_list; 15, False; 16, block; 16, 17; 17, for_statement; 17, 18; 17, 19; 17, 34; 18, identifier:i; 19, call; 19, 20; 19, 21; 20, identifier:range; 21, argument_list; 21, 22; 21, 23; 22, integer:0; 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:tabs; 30, identifier:tabBar; 31, argument_list; 32, identifier:count; 33, argument_list; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 64; 36, parenthesized_expression; 36, 37; 37, comparison_operator:>; 37, 38; 37, 50; 38, call; 38, 39; 38, 48; 39, attribute; 39, 40; 39, 47; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:tabs; 45, identifier:tabBar; 46, argument_list; 47, identifier:tabText; 48, argument_list; 48, 49; 49, identifier:i; 50, call; 50, 51; 50, 60; 51, attribute; 51, 52; 51, 59; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:tabs; 57, identifier:tabBar; 58, argument_list; 59, identifier:tabText; 60, argument_list; 60, 61; 61, binary_operator:+; 61, 62; 61, 63; 62, identifier:i; 63, integer:1; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 76; 67, attribute; 67, 68; 67, 75; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:tabs; 73, identifier:tabBar; 74, argument_list; 75, identifier:moveTab; 76, argument_list; 76, 77; 76, 78; 77, identifier:i; 78, binary_operator:+; 78, 79; 78, 80; 79, identifier:i; 80, integer:1 | def sort_file_tabs_alphabetically(self):
"""Sort open tabs alphabetically."""
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, 9; 6, 15; 6, 41; 6, 58; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:save_expanded_state; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:items; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 20, 38; 21, list_comprehension; 21, 22; 21, 28; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:takeTopLevelItem; 26, argument_list; 26, 27; 27, integer:0; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:index; 30, call; 30, 31; 30, 32; 31, identifier:range; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:topLevelItemCount; 37, argument_list; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, identifier:key; 41, for_statement; 41, 42; 41, 45; 41, 49; 42, pattern_list; 42, 43; 42, 44; 43, identifier:index; 44, identifier:item; 45, call; 45, 46; 45, 47; 46, identifier:enumerate; 47, argument_list; 47, 48; 48, identifier:items; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:insertTopLevelItem; 55, argument_list; 55, 56; 55, 57; 56, identifier:index; 57, identifier:item; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:restore_expanded_state; 63, argument_list | def sort_top_level_items(self, key):
"""Sorting tree wrt top level items"""
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, 9; 6, 17; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 16; 11, subscript; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:sorting; 15, string:'status'; 16, identifier:flag; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 26; 19, attribute; 19, 20; 19, 25; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:header; 24, argument_list; 25, identifier:setSectionsClickable; 26, argument_list; 26, 27; 27, comparison_operator:==; 27, 28; 27, 29; 28, identifier:flag; 29, identifier:ON | def set_sorting(self, flag):
"""Enable result sorting after search is complete."""
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, 9; 6, 18; 6, 43; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:pattern; 14, call; 14, 15; 14, 16; 15, identifier:get_search_regex; 16, argument_list; 16, 17; 17, identifier:text; 18, if_statement; 18, 19; 18, 22; 18, 32; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:pattern; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_parent; 29, identifier:setSortingEnabled; 30, argument_list; 30, 31; 31, False; 32, else_clause; 32, 33; 33, block; 33, 34; 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:_parent; 40, identifier:setSortingEnabled; 41, argument_list; 41, 42; 42, True; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:invalidateFilter; 48, argument_list | def set_filter(self, text):
"""Set regular expression for filter."""
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; 1, 6; 2, function_name:_get_content_hash; 3, parameters; 3, 4; 4, identifier:self; 5, comment; 6, block; 6, 7; 6, 9; 6, 15; 6, 19; 6, 36; 6, 59; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:content; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_local_config; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:relevant_content; 18, dictionary; 19, for_statement; 19, 20; 19, 21; 19, 24; 20, identifier:key; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_relevant_keys; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:relevant_content; 29, identifier:key; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:content; 33, identifier:get; 34, argument_list; 34, 35; 35, identifier:key; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:content_hash; 39, call; 39, 40; 39, 58; 40, attribute; 40, 41; 40, 57; 41, call; 41, 42; 41, 43; 42, identifier:sha256; 43, argument_list; 43, 44; 44, call; 44, 45; 44, 56; 45, attribute; 45, 46; 45, 55; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:json; 49, identifier:dumps; 50, argument_list; 50, 51; 50, 52; 51, identifier:relevant_content; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:sort_keys; 54, True; 55, identifier:encode; 56, argument_list; 57, identifier:hexdigest; 58, argument_list; 59, return_statement; 59, 60; 60, identifier:content_hash | def _get_content_hash(self): # type: () -> str
"""
Returns the sha256 hash of the sorted content of the pyproject file.
"""
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; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, return_statement; 9, 10; 10, list_comprehension; 10, 11; 10, 12; 10, 15; 11, identifier:d; 12, for_in_clause; 12, 13; 12, 14; 13, identifier:d; 14, identifier:finite_datetimes; 15, if_clause; 15, 16; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 31; 18, attribute; 18, 19; 18, 30; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_instantiate_task_cls; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:datetime_to_parameter; 28, argument_list; 28, 29; 29, identifier:d; 30, identifier:complete; 31, argument_list | def missing_datetimes(self, finite_datetimes):
"""
Override in subclasses to do bulk checks.
Returns a sorted list.
This is a conservative base implementation that brutally checks completeness, instance by instance.
Inadvisable as it may be slow.
"""
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, 8; 5, 14; 5, 29; 5, 33; 5, 54; 5, 81; 5, 98; 5, 110; 5, 127; 5, 159; 5, 190; 5, 198; 5, 206; 5, 214; 5, 222; 5, 230; 5, 238; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:task_history; 11, attribute; 11, 12; 11, 13; 12, identifier:worker; 13, identifier:_add_task_history; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:pending_tasks; 17, set_comprehension; 17, 18; 17, 19; 17, 25; 18, identifier:task; 19, for_in_clause; 19, 20; 19, 24; 20, tuple_pattern; 20, 21; 20, 22; 20, 23; 21, identifier:task; 22, identifier:status; 23, identifier:ext; 24, identifier:task_history; 25, if_clause; 25, 26; 26, comparison_operator:==; 26, 27; 26, 28; 27, identifier:status; 28, string:'PENDING'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:set_tasks; 32, dictionary; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:set_tasks; 37, string:"completed"; 38, set_comprehension; 38, 39; 38, 40; 38, 46; 39, identifier:task; 40, for_in_clause; 40, 41; 40, 45; 41, tuple_pattern; 41, 42; 41, 43; 41, 44; 42, identifier:task; 43, identifier:status; 44, identifier:ext; 45, identifier:task_history; 46, if_clause; 46, 47; 47, boolean_operator:and; 47, 48; 47, 51; 48, comparison_operator:==; 48, 49; 48, 50; 49, identifier:status; 50, string:'DONE'; 51, comparison_operator:in; 51, 52; 51, 53; 52, identifier:task; 53, identifier:pending_tasks; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:set_tasks; 58, string:"already_done"; 59, set_comprehension; 59, 60; 59, 61; 59, 67; 60, identifier:task; 61, for_in_clause; 61, 62; 61, 66; 62, tuple_pattern; 62, 63; 62, 64; 62, 65; 63, identifier:task; 64, identifier:status; 65, identifier:ext; 66, identifier:task_history; 67, if_clause; 67, 68; 68, boolean_operator:and; 68, 69; 68, 76; 69, boolean_operator:and; 69, 70; 69, 73; 70, comparison_operator:==; 70, 71; 70, 72; 71, identifier:status; 72, string:'DONE'; 73, comparison_operator:not; 73, 74; 73, 75; 74, identifier:task; 75, identifier:pending_tasks; 76, comparison_operator:not; 76, 77; 76, 78; 77, identifier:task; 78, subscript; 78, 79; 78, 80; 79, identifier:set_tasks; 80, string:"completed"; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:set_tasks; 85, string:"ever_failed"; 86, set_comprehension; 86, 87; 86, 88; 86, 94; 87, identifier:task; 88, for_in_clause; 88, 89; 88, 93; 89, tuple_pattern; 89, 90; 89, 91; 89, 92; 90, identifier:task; 91, identifier:status; 92, identifier:ext; 93, identifier:task_history; 94, if_clause; 94, 95; 95, comparison_operator:==; 95, 96; 95, 97; 96, identifier:status; 97, string:'FAILED'; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:set_tasks; 102, string:"failed"; 103, binary_operator:-; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:set_tasks; 106, string:"ever_failed"; 107, subscript; 107, 108; 107, 109; 108, identifier:set_tasks; 109, string:"completed"; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:set_tasks; 114, string:"scheduling_error"; 115, set_comprehension; 115, 116; 115, 117; 115, 123; 116, identifier:task; 117, for_in_clause; 117, 118; 117, 122; 118, tuple_pattern; 118, 119; 118, 120; 118, 121; 119, identifier:task; 120, identifier:status; 121, identifier:ext; 122, identifier:task_history; 123, if_clause; 123, 124; 124, comparison_operator:==; 124, 125; 124, 126; 125, identifier:status; 126, string:'UNKNOWN'; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:set_tasks; 131, string:"still_pending_ext"; 132, set_comprehension; 132, 133; 132, 134; 132, 140; 133, identifier:task; 134, for_in_clause; 134, 135; 134, 139; 135, tuple_pattern; 135, 136; 135, 137; 135, 138; 136, identifier:task; 137, identifier:status; 138, identifier:ext; 139, identifier:task_history; 140, if_clause; 140, 141; 141, boolean_operator:and; 141, 142; 141, 157; 142, boolean_operator:and; 142, 143; 142, 152; 143, boolean_operator:and; 143, 144; 143, 147; 144, comparison_operator:==; 144, 145; 144, 146; 145, identifier:status; 146, string:'PENDING'; 147, comparison_operator:not; 147, 148; 147, 149; 148, identifier:task; 149, subscript; 149, 150; 149, 151; 150, identifier:set_tasks; 151, string:"ever_failed"; 152, comparison_operator:not; 152, 153; 152, 154; 153, identifier:task; 154, subscript; 154, 155; 154, 156; 155, identifier:set_tasks; 156, string:"completed"; 157, not_operator; 157, 158; 158, identifier:ext; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 164; 161, subscript; 161, 162; 161, 163; 162, identifier:set_tasks; 163, string:"still_pending_not_ext"; 164, set_comprehension; 164, 165; 164, 166; 164, 172; 165, identifier:task; 166, for_in_clause; 166, 167; 166, 171; 167, tuple_pattern; 167, 168; 167, 169; 167, 170; 168, identifier:task; 169, identifier:status; 170, identifier:ext; 171, identifier:task_history; 172, if_clause; 172, 173; 173, boolean_operator:and; 173, 174; 173, 189; 174, boolean_operator:and; 174, 175; 174, 184; 175, boolean_operator:and; 175, 176; 175, 179; 176, comparison_operator:==; 176, 177; 176, 178; 177, identifier:status; 178, string:'PENDING'; 179, comparison_operator:not; 179, 180; 179, 181; 180, identifier:task; 181, subscript; 181, 182; 181, 183; 182, identifier:set_tasks; 183, string:"ever_failed"; 184, comparison_operator:not; 184, 185; 184, 186; 185, identifier:task; 186, subscript; 186, 187; 186, 188; 187, identifier:set_tasks; 188, string:"completed"; 189, identifier:ext; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:set_tasks; 194, string:"run_by_other_worker"; 195, call; 195, 196; 195, 197; 196, identifier:set; 197, argument_list; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:set_tasks; 202, string:"upstream_failure"; 203, call; 203, 204; 203, 205; 204, identifier:set; 205, argument_list; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:set_tasks; 210, string:"upstream_missing_dependency"; 211, call; 211, 212; 211, 213; 212, identifier:set; 213, argument_list; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:set_tasks; 218, string:"upstream_run_by_other_worker"; 219, call; 219, 220; 219, 221; 220, identifier:set; 221, argument_list; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:set_tasks; 226, string:"upstream_scheduling_error"; 227, call; 227, 228; 227, 229; 228, identifier:set; 229, argument_list; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:set_tasks; 234, string:"not_run"; 235, call; 235, 236; 235, 237; 236, identifier:set; 237, argument_list; 238, return_statement; 238, 239; 239, identifier:set_tasks | def _partition_tasks(worker):
"""
Takes a worker and sorts out tasks based on their status.
Still_pending_not_ext is only used to get upstream_failure, upstream_missing_dependency and run_by_other_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