nodes
stringlengths 501
22.4k
| edges
stringlengths 138
5.07k
| code
stringlengths 108
19.3k
|
|---|---|---|
0, module; 1, function_definition; 2, function_name:get; 3, parameters; 4, block; 5, identifier:self; 6, identifier:slug; 7, expression_statement; 8, expression_statement; 9, comment:# check if is accessible from api; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, return_statement; 20, comment:"""Get list of mappings.
Url parameters:
- from: filter "mappings from"
- to: filter "mappings to"
- page
- per_page
- match_type: s=substring, e=exact, sw=startswith
- sortby: 'from' or 'to'
"""; 21, assignment; 22, call; 23, assignment; 24, call; 25, call; 26, call; 27, call; 28, call; 29, call; 30, assignment; 31, call; 32, identifier:kb; 33, call; 34, identifier:check_knowledge_access; 35, argument_list; 36, identifier:parser; 37, call; 38, attribute; 39, argument_list; 40, attribute; 41, argument_list; 42, attribute; 43, argument_list; 44, attribute; 45, argument_list; 46, attribute; 47, argument_list; 48, attribute; 49, argument_list; 50, identifier:args; 51, call; 52, attribute; 53, argument_list; 54, attribute; 55, argument_list; 56, identifier:kb; 57, attribute; 58, argument_list; 59, identifier:parser; 60, identifier:add_argument; 61, string; 62, keyword_argument; 63, keyword_argument; 64, identifier:parser; 65, identifier:add_argument; 66, string; 67, keyword_argument; 68, keyword_argument; 69, identifier:parser; 70, identifier:add_argument; 71, string; 72, keyword_argument; 73, keyword_argument; 74, identifier:parser; 75, identifier:add_argument; 76, string; 77, keyword_argument; 78, keyword_argument; 79, identifier:parser; 80, identifier:add_argument; 81, string; 82, keyword_argument; 83, keyword_argument; 84, identifier:parser; 85, identifier:add_argument; 86, string; 87, keyword_argument; 88, keyword_argument; 89, attribute; 90, argument_list; 91, identifier:KnwKBMappingsResource; 92, line_continuation:\; 93, identifier:search_mappings; 94, identifier:kb; 95, subscript; 96, subscript; 97, subscript; 98, subscript; 99, subscript; 100, subscript; 101, identifier:api; 102, identifier:get_kb_by_slug; 103, identifier:slug; 104, identifier:reqparse; 105, identifier:RequestParser; 106, string_content:from; 107, identifier:type; 108, identifier:str; 109, identifier:help; 110, string:"Return only entries where 'from' matches this."; 111, string_content:to; 112, identifier:type; 113, identifier:str; 114, identifier:help; 115, string:"Return only entries where 'to' matches this."; 116, string_content:page; 117, identifier:type; 118, identifier:int; 119, identifier:help; 120, string:"Require a specific page"; 121, string_content:per_page; 122, identifier:type; 123, identifier:int; 124, identifier:help; 125, string:"Set how much result per page"; 126, string_content:match_type; 127, identifier:type; 128, identifier:str; 129, identifier:help; 130, string:"s=substring, e=exact, sw=startswith"; 131, string_content:sortby; 132, identifier:type; 133, identifier:str; 134, identifier:help; 135, string:"the sorting criteria ('from' or 'to')"; 136, identifier:parser; 137, identifier:parse_args; 138, identifier:args; 139, string; 140, identifier:args; 141, string; 142, identifier:args; 143, string; 144, identifier:args; 145, string; 146, identifier:args; 147, string; 148, identifier:args; 149, string; 150, string_content:from; 151, string_content:to; 152, string_content:match_type; 153, string_content:sortby; 154, string_content:page; 155, string_content:per_page | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 7, 20; 8, 21; 10, 22; 11, 23; 12, 24; 13, 25; 14, 26; 15, 27; 16, 28; 17, 29; 18, 30; 19, 31; 21, 32; 21, 33; 22, 34; 22, 35; 23, 36; 23, 37; 24, 38; 24, 39; 25, 40; 25, 41; 26, 42; 26, 43; 27, 44; 27, 45; 28, 46; 28, 47; 29, 48; 29, 49; 30, 50; 30, 51; 31, 52; 31, 53; 33, 54; 33, 55; 35, 56; 37, 57; 37, 58; 38, 59; 38, 60; 39, 61; 39, 62; 39, 63; 40, 64; 40, 65; 41, 66; 41, 67; 41, 68; 42, 69; 42, 70; 43, 71; 43, 72; 43, 73; 44, 74; 44, 75; 45, 76; 45, 77; 45, 78; 46, 79; 46, 80; 47, 81; 47, 82; 47, 83; 48, 84; 48, 85; 49, 86; 49, 87; 49, 88; 51, 89; 51, 90; 52, 91; 52, 92; 52, 93; 53, 94; 53, 95; 53, 96; 53, 97; 53, 98; 53, 99; 53, 100; 54, 101; 54, 102; 55, 103; 57, 104; 57, 105; 61, 106; 62, 107; 62, 108; 63, 109; 63, 110; 66, 111; 67, 112; 67, 113; 68, 114; 68, 115; 71, 116; 72, 117; 72, 118; 73, 119; 73, 120; 76, 121; 77, 122; 77, 123; 78, 124; 78, 125; 81, 126; 82, 127; 82, 128; 83, 129; 83, 130; 86, 131; 87, 132; 87, 133; 88, 134; 88, 135; 89, 136; 89, 137; 95, 138; 95, 139; 96, 140; 96, 141; 97, 142; 97, 143; 98, 144; 98, 145; 99, 146; 99, 147; 100, 148; 100, 149; 139, 150; 141, 151; 143, 152; 145, 153; 147, 154; 149, 155 | def get(self, slug):
"""Get list of mappings.
Url parameters:
- from: filter "mappings from"
- to: filter "mappings to"
- page
- per_page
- match_type: s=substring, e=exact, sw=startswith
- sortby: 'from' or 'to'
"""
kb = api.get_kb_by_slug(slug)
# check if is accessible from api
check_knowledge_access(kb)
parser = reqparse.RequestParser()
parser.add_argument(
'from', type=str,
help="Return only entries where 'from' matches this.")
parser.add_argument(
'to', type=str,
help="Return only entries where 'to' matches this.")
parser.add_argument('page', type=int,
help="Require a specific page")
parser.add_argument('per_page', type=int,
help="Set how much result per page")
parser.add_argument('match_type', type=str,
help="s=substring, e=exact, sw=startswith")
parser.add_argument('sortby', type=str,
help="the sorting criteria ('from' or 'to')")
args = parser.parse_args()
return KnwKBMappingsResource \
.search_mappings(kb, args['from'], args['to'],
args['match_type'], args['sortby'],
args['page'], args['per_page']) |
0, module; 1, function_definition; 2, function_name:pretty; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, return_statement; 10, string:"sort values and format output for viewing and comparing in test scenarios"; 11, assignment; 12, pattern_list; 13, call; 14, block; 15, identifier:pretty_obj; 16, identifier:pretty_obj; 17, call; 18, identifier:key; 19, identifier:value; 20, identifier:sorted; 21, argument_list; 22, if_statement; 23, identifier:OrderedDict; 24, argument_list; 25, call; 26, comparison_operator:value is None; 27, block; 28, elif_clause; 29, elif_clause; 30, elif_clause; 31, else_clause; 32, identifier:iteritems; 33, argument_list; 34, identifier:value; 35, None; 36, expression_statement; 37, call; 38, block; 39, call; 40, block; 41, call; 42, block; 43, block; 44, attribute; 45, assignment; 46, identifier:is_str_or_unicode; 47, argument_list; 48, expression_statement; 49, identifier:isinstance; 50, argument_list; 51, expression_statement; 52, identifier:isinstance; 53, argument_list; 54, expression_statement; 55, expression_statement; 56, identifier:self; 57, identifier:__dict__; 58, subscript; 59, None; 60, identifier:value; 61, assignment; 62, identifier:value; 63, identifier:list; 64, assignment; 65, identifier:value; 66, identifier:dict; 67, assignment; 68, assignment; 69, identifier:pretty_obj; 70, identifier:key; 71, subscript; 72, call; 73, subscript; 74, list; 75, subscript; 76, dictionary; 77, subscript; 78, call; 79, identifier:pretty_obj; 80, identifier:key; 81, attribute; 82, argument_list; 83, identifier:pretty_obj; 84, identifier:key; 85, identifier:pretty_obj; 86, identifier:key; 87, identifier:pretty_obj; 88, identifier:key; 89, identifier:unicode_value; 90, argument_list; 91, attribute; 92, identifier:get; 93, identifier:key; 94, identifier:value; 95, identifier:self; 96, identifier:__dict__ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 8, 14; 9, 15; 11, 16; 11, 17; 12, 18; 12, 19; 13, 20; 13, 21; 14, 22; 17, 23; 17, 24; 21, 25; 22, 26; 22, 27; 22, 28; 22, 29; 22, 30; 22, 31; 25, 32; 25, 33; 26, 34; 26, 35; 27, 36; 28, 37; 28, 38; 29, 39; 29, 40; 30, 41; 30, 42; 31, 43; 33, 44; 36, 45; 37, 46; 37, 47; 38, 48; 39, 49; 39, 50; 40, 51; 41, 52; 41, 53; 42, 54; 43, 55; 44, 56; 44, 57; 45, 58; 45, 59; 47, 60; 48, 61; 50, 62; 50, 63; 51, 64; 53, 65; 53, 66; 54, 67; 55, 68; 58, 69; 58, 70; 61, 71; 61, 72; 64, 73; 64, 74; 67, 75; 67, 76; 68, 77; 68, 78; 71, 79; 71, 80; 72, 81; 72, 82; 73, 83; 73, 84; 75, 85; 75, 86; 77, 87; 77, 88; 78, 89; 78, 90; 81, 91; 81, 92; 82, 93; 90, 94; 91, 95; 91, 96 | def pretty(self):
"sort values and format output for viewing and comparing in test scenarios"
pretty_obj = OrderedDict()
for key, value in sorted(iteritems(self.__dict__)):
if value is None:
pretty_obj[key] = None
elif is_str_or_unicode(value):
pretty_obj[key] = self.__dict__.get(key)
elif isinstance(value, list):
pretty_obj[key] = []
elif isinstance(value, dict):
pretty_obj[key] = {}
else:
pretty_obj[key] = unicode_value(value)
return pretty_obj |
0, module; 1, function_definition; 2, function_name:import_directory; 3, parameters; 4, type; 5, block; 6, typed_parameter; 7, typed_parameter; 8, default_parameter; 9, None; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, for_statement; 16, identifier:module_basename; 17, type; 18, identifier:directory; 19, type; 20, identifier:sort_key; 21, None; 22, string; 23, call; 24, call; 25, assignment; 26, assignment; 27, identifier:modulename; 28, call; 29, block; 30, identifier:str; 31, identifier:str; 32, string_content:Load all python modules in directory and directory's children.
Parameters
----------
:``module_basename``: module name prefix for loaded modules
:``directory``: directory to load python modules from
:``sort_key``: function to sort module names with before loading; 33, attribute; 34, argument_list; 35, attribute; 36, argument_list; 37, identifier:filenames; 38, call; 39, identifier:modulenames; 40, call; 41, identifier:sorted; 42, argument_list; 43, try_statement; 44, identifier:logger; 45, identifier:info; 46, string; 47, identifier:module_basename; 48, identifier:logger; 49, identifier:info; 50, string; 51, identifier:directory; 52, attribute; 53, argument_list; 54, identifier:_filenames_to_modulenames; 55, argument_list; 56, identifier:modulenames; 57, keyword_argument; 58, block; 59, except_clause; 60, else_clause; 61, string_content:loading submodules of %s; 62, string_content:loading modules from %s; 63, identifier:itertools; 64, identifier:chain; 65, list_splat; 66, identifier:filenames; 67, identifier:module_basename; 68, identifier:directory; 69, identifier:key; 70, identifier:sort_key; 71, expression_statement; 72, identifier:ImportError; 73, block; 74, block; 75, list_comprehension; 76, call; 77, expression_statement; 78, expression_statement; 79, expression_statement; 80, list_comprehension; 81, for_in_clause; 82, if_clause; 83, attribute; 84, argument_list; 85, call; 86, call; 87, call; 88, call; 89, for_in_clause; 90, identifier:_; 91, call; 92, call; 93, identifier:importlib; 94, identifier:import_module; 95, identifier:modulename; 96, attribute; 97, argument_list; 98, attribute; 99, argument_list; 100, attribute; 101, argument_list; 102, attribute; 103, argument_list; 104, identifier:filename; 105, subscript; 106, attribute; 107, argument_list; 108, identifier:len; 109, argument_list; 110, identifier:logger; 111, identifier:warning; 112, string; 113, identifier:modulename; 114, identifier:logger; 115, identifier:exception; 116, string; 117, identifier:logger; 118, identifier:info; 119, string; 120, identifier:modulename; 121, attribute; 122, identifier:join; 123, subscript; 124, identifier:filename; 125, identifier:_; 126, integer:2; 127, identifier:os; 128, identifier:walk; 129, identifier:directory; 130, subscript; 131, string_content:failed loading %s; 132, string_content:module loading failure; 133, string_content:successfully loaded %s; 134, identifier:os; 135, identifier:path; 136, identifier:_; 137, integer:0; 138, identifier:_; 139, integer:2 | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 3, 8; 4, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 14; 5, 15; 6, 16; 6, 17; 7, 18; 7, 19; 8, 20; 8, 21; 10, 22; 11, 23; 12, 24; 13, 25; 14, 26; 15, 27; 15, 28; 15, 29; 17, 30; 19, 31; 22, 32; 23, 33; 23, 34; 24, 35; 24, 36; 25, 37; 25, 38; 26, 39; 26, 40; 28, 41; 28, 42; 29, 43; 33, 44; 33, 45; 34, 46; 34, 47; 35, 48; 35, 49; 36, 50; 36, 51; 38, 52; 38, 53; 40, 54; 40, 55; 42, 56; 42, 57; 43, 58; 43, 59; 43, 60; 46, 61; 50, 62; 52, 63; 52, 64; 53, 65; 55, 66; 55, 67; 55, 68; 57, 69; 57, 70; 58, 71; 59, 72; 59, 73; 60, 74; 65, 75; 71, 76; 73, 77; 73, 78; 74, 79; 75, 80; 75, 81; 75, 82; 76, 83; 76, 84; 77, 85; 78, 86; 79, 87; 80, 88; 80, 89; 81, 90; 81, 91; 82, 92; 83, 93; 83, 94; 84, 95; 85, 96; 85, 97; 86, 98; 86, 99; 87, 100; 87, 101; 88, 102; 88, 103; 89, 104; 89, 105; 91, 106; 91, 107; 92, 108; 92, 109; 96, 110; 96, 111; 97, 112; 97, 113; 98, 114; 98, 115; 99, 116; 100, 117; 100, 118; 101, 119; 101, 120; 102, 121; 102, 122; 103, 123; 103, 124; 105, 125; 105, 126; 106, 127; 106, 128; 107, 129; 109, 130; 112, 131; 116, 132; 119, 133; 121, 134; 121, 135; 123, 136; 123, 137; 130, 138; 130, 139 | def import_directory(module_basename: str, directory: str, sort_key = None) -> None:
'''Load all python modules in directory and directory's children.
Parameters
----------
:``module_basename``: module name prefix for loaded modules
:``directory``: directory to load python modules from
:``sort_key``: function to sort module names with before loading
'''
logger.info('loading submodules of %s', module_basename)
logger.info('loading modules from %s', directory)
filenames = itertools.chain(*[ [ os.path.join(_[0], filename) for filename in _[2] ] for _ in os.walk(directory) if len(_[2]) ])
modulenames = _filenames_to_modulenames(filenames, module_basename, directory)
for modulename in sorted(modulenames, key = sort_key):
try:
importlib.import_module(modulename)
except ImportError:
logger.warning('failed loading %s', modulename)
logger.exception('module loading failure')
else:
logger.info('successfully loaded %s', modulename) |
0, module; 1, function_definition; 2, function_name:read; 3, parameters; 4, block; 5, identifier:self; 6, identifier:given_file; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, expression_statement; 11, with_statement; 12, if_statement; 13, expression_statement; 14, return_statement; 15, comment:"""
Read given_file to self.contents
Will ignoring duplicate lines if self.unique is True
Will sort self.contents after reading file if self.sorted is True
"""; 16, boolean_operator; 17, block; 18, assignment; 19, call; 20, with_clause; 21, block; 22, attribute; 23, block; 24, call; 25, True; 26, comparison_operator:self.unique is not False; 27, comparison_operator:self.unique is not True; 28, raise_statement; 29, attribute; 30, call; 31, attribute; 32, argument_list; 33, with_item; 34, for_statement; 35, identifier:self; 36, identifier:sorted; 37, expression_statement; 38, attribute; 39, argument_list; 40, attribute; 41, False; 42, attribute; 43, True; 44, call; 45, identifier:self; 46, identifier:filename; 47, attribute; 48, argument_list; 49, identifier:self; 50, identifier:log; 51, call; 52, as_pattern; 53, identifier:line; 54, identifier:handle; 55, block; 56, call; 57, identifier:self; 58, identifier:log; 59, call; 60, identifier:self; 61, identifier:unique; 62, identifier:self; 63, identifier:unique; 64, identifier:AttributeError; 65, argument_list; 66, identifier:str; 67, identifier:strip; 68, identifier:given_file; 69, attribute; 70, argument_list; 71, call; 72, as_pattern_target; 73, expression_statement; 74, if_statement; 75, if_statement; 76, attribute; 77, argument_list; 78, attribute; 79, argument_list; 80, string:"Attribute 'unique' is not True or False."; 81, string; 82, identifier:format; 83, attribute; 84, identifier:open; 85, argument_list; 86, identifier:handle; 87, assignment; 88, comparison_operator:line is None; 89, block; 90, boolean_operator; 91, block; 92, identifier:self; 93, identifier:sort; 94, string; 95, identifier:format; 96, call; 97, string_content:Read-only opening {0}; 98, identifier:self; 99, identifier:filename; 100, attribute; 101, string; 102, identifier:line; 103, call; 104, identifier:line; 105, None; 106, expression_statement; 107, comment:# Blank lines that were just \n become None so convert them to empty string.; 108, comparison_operator:self.unique is False; 109, comparison_operator:line not in self.contents; 110, expression_statement; 111, string_content:Read {0} lines.; 112, identifier:len; 113, argument_list; 114, identifier:self; 115, identifier:filename; 116, string_content:r; 117, attribute; 118, argument_list; 119, assignment; 120, attribute; 121, False; 122, identifier:line; 123, attribute; 124, call; 125, attribute; 126, identifier:line; 127, identifier:rstrip; 128, string; 129, identifier:line; 130, string; 131, identifier:self; 132, identifier:unique; 133, identifier:self; 134, identifier:contents; 135, attribute; 136, argument_list; 137, identifier:self; 138, identifier:contents; 139, string_content; 140, attribute; 141, identifier:append; 142, identifier:line; 143, escape_sequence:\r; 144, escape_sequence:\n; 145, identifier:self; 146, identifier:contents | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 8, 16; 8, 17; 9, 18; 10, 19; 11, 20; 11, 21; 12, 22; 12, 23; 13, 24; 14, 25; 16, 26; 16, 27; 17, 28; 18, 29; 18, 30; 19, 31; 19, 32; 20, 33; 21, 34; 22, 35; 22, 36; 23, 37; 24, 38; 24, 39; 26, 40; 26, 41; 27, 42; 27, 43; 28, 44; 29, 45; 29, 46; 30, 47; 30, 48; 31, 49; 31, 50; 32, 51; 33, 52; 34, 53; 34, 54; 34, 55; 37, 56; 38, 57; 38, 58; 39, 59; 40, 60; 40, 61; 42, 62; 42, 63; 44, 64; 44, 65; 47, 66; 47, 67; 48, 68; 51, 69; 51, 70; 52, 71; 52, 72; 55, 73; 55, 74; 55, 75; 56, 76; 56, 77; 59, 78; 59, 79; 65, 80; 69, 81; 69, 82; 70, 83; 71, 84; 71, 85; 72, 86; 73, 87; 74, 88; 74, 89; 75, 90; 75, 91; 76, 92; 76, 93; 78, 94; 78, 95; 79, 96; 81, 97; 83, 98; 83, 99; 85, 100; 85, 101; 87, 102; 87, 103; 88, 104; 88, 105; 89, 106; 89, 107; 90, 108; 90, 109; 91, 110; 94, 111; 96, 112; 96, 113; 100, 114; 100, 115; 101, 116; 103, 117; 103, 118; 106, 119; 108, 120; 108, 121; 109, 122; 109, 123; 110, 124; 113, 125; 117, 126; 117, 127; 118, 128; 119, 129; 119, 130; 120, 131; 120, 132; 123, 133; 123, 134; 124, 135; 124, 136; 125, 137; 125, 138; 128, 139; 135, 140; 135, 141; 136, 142; 139, 143; 139, 144; 140, 145; 140, 146 | def read(self, given_file):
"""
Read given_file to self.contents
Will ignoring duplicate lines if self.unique is True
Will sort self.contents after reading file if self.sorted is True
"""
if self.unique is not False and self.unique is not True:
raise AttributeError("Attribute 'unique' is not True or False.")
self.filename = str.strip(given_file)
self.log('Read-only opening {0}'.format(self.filename))
with open(self.filename, 'r') as handle:
for line in handle:
line = line.rstrip('\r\n')
if line is None:
line = '' # Blank lines that were just \n become None so convert them to empty string.
if self.unique is False or line not in self.contents:
self.contents.append(line)
if self.sorted:
self.sort()
self.log('Read {0} lines.'.format(len(self.contents)))
return True |
0, module; 1, function_definition; 2, function_name:force_clear_lock; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, return_statement; 8, string; 9, call; 10, string_content:Kick out whoever currently owns the namespace global lock.
This is intended as purely a last-resort tool. If another
process has managed to get the global lock for a very long time,
or if it requested the lock with a long expiration and then
crashed, this can make the system functional again. If the
original lock holder is still alive, its session calls may fail
with exceptions.; 11, attribute; 12, argument_list; 13, call; 14, identifier:delete; 15, attribute; 16, attribute; 17, argument_list; 18, identifier:self; 19, identifier:_lock_name; 20, identifier:redis; 21, identifier:Redis; 22, keyword_argument; 23, identifier:connection_pool; 24, attribute; 25, identifier:self; 26, identifier:pool | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 8, 10; 9, 11; 9, 12; 11, 13; 11, 14; 12, 15; 13, 16; 13, 17; 15, 18; 15, 19; 16, 20; 16, 21; 17, 22; 22, 23; 22, 24; 24, 25; 24, 26 | def force_clear_lock(self):
'''Kick out whoever currently owns the namespace global lock.
This is intended as purely a last-resort tool. If another
process has managed to get the global lock for a very long time,
or if it requested the lock with a long expiration and then
crashed, this can make the system functional again. If the
original lock holder is still alive, its session calls may fail
with exceptions.
'''
return redis.Redis(connection_pool=self.pool).delete(self._lock_name) |
0, module; 1, function_definition; 2, function_name:prettyprint; 3, parameters; 4, block; 5, identifier:d; 6, expression_statement; 7, expression_statement; 8, comment:"""Print dicttree in Json-like format. keys are sorted
"""; 9, call; 10, identifier:print; 11, argument_list; 12, call; 13, attribute; 14, argument_list; 15, identifier:json; 16, identifier:dumps; 17, identifier:d; 18, keyword_argument; 19, keyword_argument; 20, keyword_argument; 21, identifier:sort_keys; 22, True; 23, identifier:indent; 24, integer:4; 25, identifier:separators; 26, tuple; 27, string:","; 28, string:": " | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 9, 10; 9, 11; 11, 12; 12, 13; 12, 14; 13, 15; 13, 16; 14, 17; 14, 18; 14, 19; 14, 20; 18, 21; 18, 22; 19, 23; 19, 24; 20, 25; 20, 26; 26, 27; 26, 28 | def prettyprint(d):
"""Print dicttree in Json-like format. keys are sorted
"""
print(json.dumps(d, sort_keys=True,
indent=4, separators=("," , ": "))) |
0, module; 1, function_definition; 2, function_name:_is_iterable; 3, parameters; 4, block; 5, identifier:val; 6, expression_statement; 7, try_statement; 8, comment:"""Ensure that a value is iterable and not some sort of string"""; 9, block; 10, except_clause; 11, else_clause; 12, expression_statement; 13, tuple; 14, block; 15, block; 16, call; 17, identifier:ValueError; 18, identifier:TypeError; 19, return_statement; 20, return_statement; 21, identifier:iter; 22, argument_list; 23, False; 24, not_operator; 25, identifier:val; 26, call; 27, identifier:isinstance; 28, argument_list; 29, identifier:val; 30, identifier:basestring | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 7, 10; 7, 11; 9, 12; 10, 13; 10, 14; 11, 15; 12, 16; 13, 17; 13, 18; 14, 19; 15, 20; 16, 21; 16, 22; 19, 23; 20, 24; 22, 25; 24, 26; 26, 27; 26, 28; 28, 29; 28, 30 | def _is_iterable(val):
"""Ensure that a value is iterable and not some sort of string"""
try:
iter(val)
except (ValueError, TypeError):
return False
else:
return not isinstance(val, basestring) |
0, module; 1, function_definition; 2, function_name:square_off; 3, parameters; 4, block; 5, identifier:series; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, return_statement; 11, identifier:time_delta; 12, None; 13, identifier:transition_seconds; 14, integer:1; 15, comment:"""Insert samples in regularly sampled data to produce stairsteps from ramps when plotted.
New samples are 1 second (1e9 ns) before each existing samples, to facilitate plotting and sorting
>>> square_off(pd.Series(range(3), index=pd.date_range('2014-01-01', periods=3, freq='15m')),
... time_delta=5.5) # doctest: +NORMALIZE_WHITESPACE
2014-01-31 00:00:00 0
2014-01-31 00:00:05.500000 0
2015-04-30 00:00:00 1
2015-04-30 00:00:05.500000 1
2016-07-31 00:00:00 2
2016-07-31 00:00:05.500000 2
dtype: int64
>>> square_off(pd.Series(range(2), index=pd.date_range('2014-01-01', periods=2, freq='15min')),
... transition_seconds=2.5) # doctest: +NORMALIZE_WHITESPACE
2014-01-01 00:00:00 0
2014-01-01 00:14:57.500000 0
2014-01-01 00:15:00 1
2014-01-01 00:29:57.500000 1
dtype: int64
"""; 16, identifier:time_delta; 17, comment:# int, float means delta is in seconds (not years!); 18, block; 19, else_clause; 20, call; 21, if_statement; 22, expression_statement; 23, block; 24, attribute; 25, argument_list; 26, call; 27, block; 28, assignment; 29, expression_statement; 30, expression_statement; 31, expression_statement; 32, expression_statement; 33, call; 34, identifier:sort_index; 35, identifier:isinstance; 36, argument_list; 37, expression_statement; 38, identifier:new_times; 39, binary_operator:series.index + time_delta; 40, assignment; 41, assignment; 42, assignment; 43, assignment; 44, attribute; 45, argument_list; 46, identifier:time_delta; 47, tuple; 48, assignment; 49, attribute; 50, identifier:time_delta; 51, identifier:diff; 52, call; 53, identifier:time_delta; 54, call; 55, identifier:new_times; 56, binary_operator:series.index + time_delta; 57, identifier:new_times; 58, binary_operator:pd.DatetimeIndex(new_times) - datetime.timedelta(0, transition_seconds); 59, identifier:pd; 60, identifier:concat; 61, list; 62, identifier:int; 63, identifier:float; 64, identifier:time_delta; 65, call; 66, identifier:series; 67, identifier:index; 68, attribute; 69, argument_list; 70, attribute; 71, argument_list; 72, attribute; 73, identifier:time_delta; 74, call; 75, call; 76, identifier:series; 77, call; 78, attribute; 79, argument_list; 80, identifier:np; 81, identifier:diff; 82, attribute; 83, identifier:np; 84, identifier:append; 85, identifier:diff; 86, list; 87, identifier:series; 88, identifier:index; 89, attribute; 90, argument_list; 91, attribute; 92, argument_list; 93, attribute; 94, argument_list; 95, identifier:datetime; 96, identifier:timedelta; 97, integer:0; 98, identifier:time_delta; 99, identifier:series; 100, identifier:index; 101, subscript; 102, identifier:pd; 103, identifier:DatetimeIndex; 104, identifier:new_times; 105, identifier:datetime; 106, identifier:timedelta; 107, integer:0; 108, identifier:transition_seconds; 109, identifier:pd; 110, identifier:Series; 111, attribute; 112, keyword_argument; 113, identifier:diff; 114, unary_operator; 115, identifier:series; 116, identifier:values; 117, identifier:index; 118, identifier:new_times; 119, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 7, 14; 8, 15; 9, 16; 9, 17; 9, 18; 9, 19; 10, 20; 18, 21; 18, 22; 19, 23; 20, 24; 20, 25; 21, 26; 21, 27; 22, 28; 23, 29; 23, 30; 23, 31; 23, 32; 24, 33; 24, 34; 26, 35; 26, 36; 27, 37; 28, 38; 28, 39; 29, 40; 30, 41; 31, 42; 32, 43; 33, 44; 33, 45; 36, 46; 36, 47; 37, 48; 39, 49; 39, 50; 40, 51; 40, 52; 41, 53; 41, 54; 42, 55; 42, 56; 43, 57; 43, 58; 44, 59; 44, 60; 45, 61; 47, 62; 47, 63; 48, 64; 48, 65; 49, 66; 49, 67; 52, 68; 52, 69; 54, 70; 54, 71; 56, 72; 56, 73; 58, 74; 58, 75; 61, 76; 61, 77; 65, 78; 65, 79; 68, 80; 68, 81; 69, 82; 70, 83; 70, 84; 71, 85; 71, 86; 72, 87; 72, 88; 74, 89; 74, 90; 75, 91; 75, 92; 77, 93; 77, 94; 78, 95; 78, 96; 79, 97; 79, 98; 82, 99; 82, 100; 86, 101; 89, 102; 89, 103; 90, 104; 91, 105; 91, 106; 92, 107; 92, 108; 93, 109; 93, 110; 94, 111; 94, 112; 101, 113; 101, 114; 111, 115; 111, 116; 112, 117; 112, 118; 114, 119 | def square_off(series, time_delta=None, transition_seconds=1):
"""Insert samples in regularly sampled data to produce stairsteps from ramps when plotted.
New samples are 1 second (1e9 ns) before each existing samples, to facilitate plotting and sorting
>>> square_off(pd.Series(range(3), index=pd.date_range('2014-01-01', periods=3, freq='15m')),
... time_delta=5.5) # doctest: +NORMALIZE_WHITESPACE
2014-01-31 00:00:00 0
2014-01-31 00:00:05.500000 0
2015-04-30 00:00:00 1
2015-04-30 00:00:05.500000 1
2016-07-31 00:00:00 2
2016-07-31 00:00:05.500000 2
dtype: int64
>>> square_off(pd.Series(range(2), index=pd.date_range('2014-01-01', periods=2, freq='15min')),
... transition_seconds=2.5) # doctest: +NORMALIZE_WHITESPACE
2014-01-01 00:00:00 0
2014-01-01 00:14:57.500000 0
2014-01-01 00:15:00 1
2014-01-01 00:29:57.500000 1
dtype: int64
"""
if time_delta:
# int, float means delta is in seconds (not years!)
if isinstance(time_delta, (int, float)):
time_delta = datetime.timedelta(0, time_delta)
new_times = series.index + time_delta
else:
diff = np.diff(series.index)
time_delta = np.append(diff, [diff[-1]])
new_times = series.index + time_delta
new_times = pd.DatetimeIndex(new_times) - datetime.timedelta(0, transition_seconds)
return pd.concat([series, pd.Series(series.values, index=new_times)]).sort_index() |
0, module; 1, function_definition; 2, function_name:sortframe; 3, parameters; 4, block; 5, identifier:frame; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, return_statement; 12, string; 13, assignment; 14, assignment; 15, assignment; 16, assignment; 17, identifier:frame; 18, string_content:sorts particles for a frame; 19, identifier:d; 20, subscript; 21, identifier:sortedargs; 22, call; 23, identifier:d; 24, subscript; 25, subscript; 26, identifier:d; 27, identifier:frame; 28, string; 29, attribute; 30, argument_list; 31, identifier:d; 32, identifier:sortedargs; 33, identifier:frame; 34, string; 35, string_content:data; 36, identifier:np; 37, identifier:lexsort; 38, list; 39, string_content:data; 40, subscript; 41, subscript; 42, subscript; 43, identifier:d; 44, string; 45, identifier:d; 46, string; 47, identifier:d; 48, string; 49, string_content:xi; 50, string_content:yi; 51, string_content:zi | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 11, 17; 12, 18; 13, 19; 13, 20; 14, 21; 14, 22; 15, 23; 15, 24; 16, 25; 16, 26; 20, 27; 20, 28; 22, 29; 22, 30; 24, 31; 24, 32; 25, 33; 25, 34; 28, 35; 29, 36; 29, 37; 30, 38; 34, 39; 38, 40; 38, 41; 38, 42; 40, 43; 40, 44; 41, 45; 41, 46; 42, 47; 42, 48; 44, 49; 46, 50; 48, 51 | def sortframe(frame):
'''
sorts particles for a frame
'''
d = frame['data'];
sortedargs = np.lexsort([d['xi'],d['yi'],d['zi']])
d = d[sortedargs];
frame['data']=d;
return frame; |
0, module; 1, function_definition; 2, function_name:get_release_id; 3, parameters; 4, block; 5, default_parameter; 6, expression_statement; 7, comment:# pylint: disable=invalid-name; 8, expression_statement; 9, if_statement; 10, return_statement; 11, identifier:version; 12, None; 13, comment:"""Get a unique, time-based identifier for a deployment
that optionally, also includes some sort of version number
or release.
If a version is supplied, the release ID will be of the form
'$timestamp-$version'. For example:
>>> get_release_id(version='1.4.1')
'20140214231159-1.4.1'
If the version is not supplied the release ID will be of the
form '$timestamp'. For example:
>>> get_release_id()
'20140214231159'
The timestamp component of this release ID will be generated
using the current time in UTC.
:param str version: Version to include in the release ID
:return: Unique name for this particular deployment
:rtype: str
"""; 14, assignment; 15, comparison_operator:version is None; 16, block; 17, call; 18, identifier:ts; 19, call; 20, identifier:version; 21, None; 22, return_statement; 23, attribute; 24, argument_list; 25, attribute; 26, argument_list; 27, identifier:ts; 28, string; 29, identifier:format; 30, identifier:ts; 31, identifier:version; 32, call; 33, identifier:strftime; 34, identifier:RELEASE_DATE_FMT; 35, string_content:{0}-{1}; 36, attribute; 37, argument_list; 38, identifier:datetime; 39, identifier:utcnow | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 5, 11; 5, 12; 6, 13; 8, 14; 9, 15; 9, 16; 10, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 17, 23; 17, 24; 19, 25; 19, 26; 22, 27; 23, 28; 23, 29; 24, 30; 24, 31; 25, 32; 25, 33; 26, 34; 28, 35; 32, 36; 32, 37; 36, 38; 36, 39 | def get_release_id(version=None):
"""Get a unique, time-based identifier for a deployment
that optionally, also includes some sort of version number
or release.
If a version is supplied, the release ID will be of the form
'$timestamp-$version'. For example:
>>> get_release_id(version='1.4.1')
'20140214231159-1.4.1'
If the version is not supplied the release ID will be of the
form '$timestamp'. For example:
>>> get_release_id()
'20140214231159'
The timestamp component of this release ID will be generated
using the current time in UTC.
:param str version: Version to include in the release ID
:return: Unique name for this particular deployment
:rtype: str
"""
# pylint: disable=invalid-name
ts = datetime.utcnow().strftime(RELEASE_DATE_FMT)
if version is None:
return ts
return '{0}-{1}'.format(ts, version) |
0, module; 1, function_definition; 2, function_name:group_objects_by; 3, parameters; 4, block; 5, identifier:self; 6, identifier:list; 7, identifier:attr; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, return_statement; 14, identifier:valueLabel; 15, string:"value"; 16, identifier:childrenLabel; 17, string:"children"; 18, comment:"""
Generates a group object based on the attribute value on of the given attr value that is passed in.
:param list list: A list of dictionary objects
:param str attr: The attribute that the dictionaries should be sorted upon
:param str valueLabel: What to call the key of the field we're sorting upon
:param str childrenLabel: What to call the list of child objects on the group object
:returns: list of grouped objects by a given attribute
:rtype: list
"""; 19, assignment; 20, identifier:obj; 21, identifier:list; 22, block; 23, identifier:groups; 24, identifier:groups; 25, list; 26, expression_statement; 27, if_statement; 28, expression_statement; 29, expression_statement; 30, for_statement; 31, if_statement; 32, assignment; 33, not_operator; 34, block; 35, assignment; 36, assignment; 37, identifier:i; 38, call; 39, block; 40, not_operator; 41, block; 42, identifier:val; 43, call; 44, identifier:val; 45, pass_statement; 46, identifier:newGroup; 47, dictionary; 48, identifier:found; 49, False; 50, identifier:range; 51, argument_list; 52, if_statement; 53, identifier:found; 54, expression_statement; 55, attribute; 56, argument_list; 57, pair; 58, pair; 59, pair; 60, integer:0; 61, call; 62, comparison_operator:val == groups[i].get(valueLabel); 63, block; 64, call; 65, identifier:obj; 66, identifier:get; 67, identifier:attr; 68, string:"attribute"; 69, identifier:attr; 70, identifier:valueLabel; 71, identifier:val; 72, identifier:childrenLabel; 73, list; 74, identifier:len; 75, argument_list; 76, identifier:val; 77, call; 78, expression_statement; 79, expression_statement; 80, pass_statement; 81, attribute; 82, argument_list; 83, identifier:obj; 84, identifier:groups; 85, attribute; 86, argument_list; 87, assignment; 88, call; 89, identifier:groups; 90, identifier:append; 91, identifier:newGroup; 92, subscript; 93, identifier:get; 94, identifier:valueLabel; 95, identifier:found; 96, True; 97, attribute; 98, argument_list; 99, identifier:groups; 100, identifier:i; 101, subscript; 102, identifier:append; 103, identifier:obj; 104, subscript; 105, identifier:childrenLabel; 106, identifier:groups; 107, identifier:i | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 8, 14; 8, 15; 9, 16; 9, 17; 10, 18; 11, 19; 12, 20; 12, 21; 12, 22; 13, 23; 19, 24; 19, 25; 22, 26; 22, 27; 22, 28; 22, 29; 22, 30; 22, 31; 26, 32; 27, 33; 27, 34; 28, 35; 29, 36; 30, 37; 30, 38; 30, 39; 31, 40; 31, 41; 32, 42; 32, 43; 33, 44; 34, 45; 35, 46; 35, 47; 36, 48; 36, 49; 38, 50; 38, 51; 39, 52; 40, 53; 41, 54; 43, 55; 43, 56; 47, 57; 47, 58; 47, 59; 51, 60; 51, 61; 52, 62; 52, 63; 54, 64; 55, 65; 55, 66; 56, 67; 57, 68; 57, 69; 58, 70; 58, 71; 59, 72; 59, 73; 61, 74; 61, 75; 62, 76; 62, 77; 63, 78; 63, 79; 63, 80; 64, 81; 64, 82; 73, 83; 75, 84; 77, 85; 77, 86; 78, 87; 79, 88; 81, 89; 81, 90; 82, 91; 85, 92; 85, 93; 86, 94; 87, 95; 87, 96; 88, 97; 88, 98; 92, 99; 92, 100; 97, 101; 97, 102; 98, 103; 101, 104; 101, 105; 104, 106; 104, 107 | def group_objects_by(self, list, attr, valueLabel="value", childrenLabel="children"):
"""
Generates a group object based on the attribute value on of the given attr value that is passed in.
:param list list: A list of dictionary objects
:param str attr: The attribute that the dictionaries should be sorted upon
:param str valueLabel: What to call the key of the field we're sorting upon
:param str childrenLabel: What to call the list of child objects on the group object
:returns: list of grouped objects by a given attribute
:rtype: list
"""
groups = []
for obj in list:
val = obj.get(attr)
if not val:
pass
newGroup = {"attribute": attr, valueLabel: val, childrenLabel: [obj]}
found = False
for i in range(0,len(groups)):
if val == groups[i].get(valueLabel):
found = True
groups[i][childrenLabel].append(obj)
pass
if not found:
groups.append(newGroup)
return groups |
0, module; 1, function_definition; 2, function_name:sorts_query; 3, parameters; 4, block; 5, identifier:sortables; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, return_statement; 10, comment:""" Turn the Sortables into a SQL ORDER BY query """; 11, assignment; 12, identifier:sortable; 13, identifier:sortables; 14, block; 15, call; 16, identifier:stmts; 17, list; 18, if_statement; 19, attribute; 20, argument_list; 21, attribute; 22, block; 23, else_clause; 24, string; 25, identifier:format; 26, call; 27, identifier:sortable; 28, identifier:desc; 29, expression_statement; 30, block; 31, string_content:ORDER BY {}; 32, attribute; 33, argument_list; 34, call; 35, expression_statement; 36, string; 37, identifier:join; 38, identifier:stmts; 39, attribute; 40, argument_list; 41, call; 42, string_content:,; 43, identifier:stmts; 44, identifier:append; 45, call; 46, attribute; 47, argument_list; 48, attribute; 49, argument_list; 50, identifier:stmts; 51, identifier:append; 52, call; 53, string; 54, identifier:format; 55, attribute; 56, attribute; 57, argument_list; 58, string_content:{} DESC; 59, identifier:sortable; 60, identifier:field; 61, string; 62, identifier:format; 63, attribute; 64, string_content:{} ASC; 65, identifier:sortable; 66, identifier:field | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 8, 14; 9, 15; 11, 16; 11, 17; 14, 18; 15, 19; 15, 20; 18, 21; 18, 22; 18, 23; 19, 24; 19, 25; 20, 26; 21, 27; 21, 28; 22, 29; 23, 30; 24, 31; 26, 32; 26, 33; 29, 34; 30, 35; 32, 36; 32, 37; 33, 38; 34, 39; 34, 40; 35, 41; 36, 42; 39, 43; 39, 44; 40, 45; 41, 46; 41, 47; 45, 48; 45, 49; 46, 50; 46, 51; 47, 52; 48, 53; 48, 54; 49, 55; 52, 56; 52, 57; 53, 58; 55, 59; 55, 60; 56, 61; 56, 62; 57, 63; 61, 64; 63, 65; 63, 66 | def sorts_query(sortables):
""" Turn the Sortables into a SQL ORDER BY query """
stmts = []
for sortable in sortables:
if sortable.desc:
stmts.append('{} DESC'.format(sortable.field))
else:
stmts.append('{} ASC'.format(sortable.field))
return ' ORDER BY {}'.format(', '.join(stmts)) |
0, module; 1, function_definition; 2, function_name:search; 3, parameters; 4, block; 5, identifier:self; 6, identifier:rtype; 7, dictionary_splat_pattern; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, if_statement; 18, expression_statement; 19, if_statement; 20, expression_statement; 21, expression_statement; 22, expression_statement; 23, expression_statement; 24, expression_statement; 25, expression_statement; 26, if_statement; 27, expression_statement; 28, if_statement; 29, return_statement; 30, identifier:kwargs; 31, comment:""" Search for the model by assorted criteria
Quite a bit needs to happen for a search processing!
The breakdown is we need to apply the query parameters
where applicable. These include pagination, sorting,
& filtering.
Additionally, models can declare there own static
filters or static query that should be applied. For
static filters a model can opt-in with a `search_filters`
property & for a static query to append a `search_query`
property must be present.
"""; 32, assignment; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, assignment; 38, assignment; 39, augmented_assignment; 40, identifier:filters; 41, block; 42, assignment; 43, boolean_operator; 44, block; 45, elif_clause; 46, augmented_assignment; 47, augmented_assignment; 48, augmented_assignment; 49, call; 50, assignment; 51, assignment; 52, identifier:models; 53, block; 54, assignment; 55, boolean_operator; 56, block; 57, identifier:models; 58, identifier:model; 59, call; 60, identifier:param; 61, dictionary; 62, identifier:pages; 63, call; 64, identifier:sorts; 65, call; 66, identifier:query; 67, comment:"""
SELECT {cols}, count(*) OVER() as _count
FROM {table}
"""; 68, identifier:query; 69, call; 70, identifier:filters; 71, call; 72, identifier:filters; 73, boolean_operator; 74, expression_statement; 75, expression_statement; 76, identifier:model_query; 77, boolean_operator; 78, identifier:filters; 79, identifier:model_query; 80, expression_statement; 81, identifier:model_query; 82, block; 83, identifier:query; 84, identifier:model_query; 85, identifier:query; 86, identifier:sorts; 87, identifier:query; 88, identifier:pages; 89, attribute; 90, argument_list; 91, identifier:result; 92, call; 93, identifier:models; 94, list_comprehension; 95, expression_statement; 96, identifier:pages; 97, call; 98, identifier:pages; 99, identifier:result; 100, expression_statement; 101, identifier:rtype_to_model; 102, argument_list; 103, attribute; 104, argument_list; 105, attribute; 106, argument_list; 107, attribute; 108, argument_list; 109, attribute; 110, argument_list; 111, call; 112, list; 113, assignment; 114, augmented_assignment; 115, call; 116, string; 117, assignment; 118, expression_statement; 119, attribute; 120, identifier:send; 121, attribute; 122, keyword_argument; 123, attribute; 124, argument_list; 125, call; 126, for_in_clause; 127, call; 128, attribute; 129, argument_list; 130, assignment; 131, identifier:rtype; 132, identifier:self; 133, identifier:pages_query; 134, call; 135, identifier:self; 136, identifier:sorts_query; 137, call; 138, identifier:query; 139, identifier:format; 140, keyword_argument; 141, keyword_argument; 142, identifier:kwargs; 143, identifier:get; 144, string; 145, list; 146, identifier:getattr; 147, argument_list; 148, pattern_list; 149, call; 150, identifier:query; 151, identifier:where; 152, identifier:getattr; 153, argument_list; 154, identifier:model_query; 155, binary_operator:' AND ' + model_query; 156, assignment; 157, identifier:signals; 158, identifier:pre_search; 159, identifier:model; 160, identifier:__class__; 161, identifier:model; 162, identifier:model; 163, identifier:self; 164, identifier:query; 165, identifier:query; 166, keyword_argument; 167, identifier:model; 168, argument_list; 169, identifier:res; 170, identifier:result; 171, attribute; 172, argument_list; 173, identifier:kwargs; 174, identifier:get; 175, string; 176, attribute; 177, subscript; 178, attribute; 179, argument_list; 180, attribute; 181, argument_list; 182, identifier:cols; 183, call; 184, identifier:table; 185, identifier:rtype; 186, string_content:filters; 187, identifier:model; 188, string; 189, list; 190, identifier:where; 191, identifier:param; 192, attribute; 193, argument_list; 194, identifier:model; 195, string; 196, string; 197, string; 198, identifier:model_query; 199, identifier:model_query; 200, binary_operator:' WHERE ' + model_query; 201, identifier:param; 202, identifier:param; 203, identifier:res; 204, attribute; 205, identifier:send; 206, attribute; 207, keyword_argument; 208, string_content:pages; 209, identifier:pages; 210, identifier:total; 211, subscript; 212, string; 213, identifier:kwargs; 214, identifier:get; 215, string; 216, identifier:kwargs; 217, identifier:get; 218, string; 219, list; 220, attribute; 221, argument_list; 222, string_content:search_filters; 223, identifier:self; 224, identifier:filters_query; 225, identifier:filters; 226, string_content:search_query; 227, string_content:AND; 228, string; 229, identifier:model_query; 230, identifier:signals; 231, identifier:post_search; 232, identifier:model; 233, identifier:__class__; 234, identifier:models; 235, identifier:result; 236, identifier:result; 237, integer:0; 238, string_content:_count; 239, string_content:pages; 240, string_content:sorts; 241, call; 242, identifier:self; 243, identifier:field_cols; 244, identifier:model; 245, string_content:WHERE; 246, identifier:Sortable; 247, argument_list; 248, attribute; 249, attribute; 250, identifier:SORT; 251, identifier:goldman; 252, identifier:config | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 7, 30; 8, 31; 9, 32; 10, 33; 11, 34; 12, 35; 13, 36; 14, 37; 15, 38; 16, 39; 17, 40; 17, 41; 18, 42; 19, 43; 19, 44; 19, 45; 20, 46; 21, 47; 22, 48; 23, 49; 24, 50; 25, 51; 26, 52; 26, 53; 27, 54; 28, 55; 28, 56; 29, 57; 32, 58; 32, 59; 33, 60; 33, 61; 34, 62; 34, 63; 35, 64; 35, 65; 36, 66; 36, 67; 37, 68; 37, 69; 38, 70; 38, 71; 39, 72; 39, 73; 41, 74; 41, 75; 42, 76; 42, 77; 43, 78; 43, 79; 44, 80; 45, 81; 45, 82; 46, 83; 46, 84; 47, 85; 47, 86; 48, 87; 48, 88; 49, 89; 49, 90; 50, 91; 50, 92; 51, 93; 51, 94; 53, 95; 54, 96; 54, 97; 55, 98; 55, 99; 56, 100; 59, 101; 59, 102; 63, 103; 63, 104; 65, 105; 65, 106; 69, 107; 69, 108; 71, 109; 71, 110; 73, 111; 73, 112; 74, 113; 75, 114; 77, 115; 77, 116; 80, 117; 82, 118; 89, 119; 89, 120; 90, 121; 90, 122; 92, 123; 92, 124; 94, 125; 94, 126; 95, 127; 97, 128; 97, 129; 100, 130; 102, 131; 103, 132; 103, 133; 104, 134; 105, 135; 105, 136; 106, 137; 107, 138; 107, 139; 108, 140; 108, 141; 109, 142; 109, 143; 110, 144; 110, 145; 111, 146; 111, 147; 113, 148; 113, 149; 114, 150; 114, 151; 115, 152; 115, 153; 117, 154; 117, 155; 118, 156; 119, 157; 119, 158; 121, 159; 121, 160; 122, 161; 122, 162; 123, 163; 123, 164; 124, 165; 124, 166; 125, 167; 125, 168; 126, 169; 126, 170; 127, 171; 127, 172; 128, 173; 128, 174; 129, 175; 130, 176; 130, 177; 134, 178; 134, 179; 137, 180; 137, 181; 140, 182; 140, 183; 141, 184; 141, 185; 144, 186; 147, 187; 147, 188; 147, 189; 148, 190; 148, 191; 149, 192; 149, 193; 153, 194; 153, 195; 153, 196; 155, 197; 155, 198; 156, 199; 156, 200; 166, 201; 166, 202; 168, 203; 171, 204; 171, 205; 172, 206; 172, 207; 175, 208; 176, 209; 176, 210; 177, 211; 177, 212; 178, 213; 178, 214; 179, 215; 180, 216; 180, 217; 181, 218; 181, 219; 183, 220; 183, 221; 188, 222; 192, 223; 192, 224; 193, 225; 195, 226; 197, 227; 200, 228; 200, 229; 204, 230; 204, 231; 206, 232; 206, 233; 207, 234; 207, 235; 211, 236; 211, 237; 212, 238; 215, 239; 218, 240; 219, 241; 220, 242; 220, 243; 221, 244; 228, 245; 241, 246; 241, 247; 247, 248; 248, 249; 248, 250; 249, 251; 249, 252 | def search(self, rtype, **kwargs):
""" Search for the model by assorted criteria
Quite a bit needs to happen for a search processing!
The breakdown is we need to apply the query parameters
where applicable. These include pagination, sorting,
& filtering.
Additionally, models can declare there own static
filters or static query that should be applied. For
static filters a model can opt-in with a `search_filters`
property & for a static query to append a `search_query`
property must be present.
"""
model = rtype_to_model(rtype)
param = {}
pages = self.pages_query(kwargs.get('pages'))
sorts = self.sorts_query(kwargs.get(
'sorts', [Sortable(goldman.config.SORT)]
))
query = """
SELECT {cols}, count(*) OVER() as _count
FROM {table}
"""
query = query.format(
cols=self.field_cols(model),
table=rtype,
)
filters = kwargs.get('filters', [])
filters += getattr(model, 'search_filters', []) or []
if filters:
where, param = self.filters_query(filters)
query += where
model_query = getattr(model, 'search_query', '') or ''
if filters and model_query:
model_query = ' AND ' + model_query
elif model_query:
model_query = ' WHERE ' + model_query
query += model_query
query += sorts
query += pages
signals.pre_search.send(model.__class__, model=model)
result = self.query(query, param=param)
models = [model(res) for res in result]
if models:
signals.post_search.send(model.__class__, models=result)
pages = kwargs.get('pages')
if pages and result:
pages.total = result[0]['_count']
return models |
0, module; 1, function_definition; 2, function_name:force_seek; 3, parameters; 4, block; 5, identifier:fd; 6, identifier:offset; 7, default_parameter; 8, expression_statement; 9, try_statement; 10, identifier:chunk; 11, identifier:CHUNK; 12, comment:""" Force adjustment of read cursort to specified offset
This function takes a file descriptor ``fd`` and tries to seek to position
specified by ``offset`` argument. If the descriptor does not support the
``seek()`` method, it will fall back to ``emulate_seek()``.
The optional ``chunk`` argument can be used to adjust the chunk size for
``emulate_seek()``.
"""; 13, block; 14, except_clause; 15, expression_statement; 16, tuple; 17, comment:# This file handle probably has no seek(); 18, block; 19, call; 20, identifier:AttributeError; 21, attribute; 22, expression_statement; 23, attribute; 24, argument_list; 25, identifier:io; 26, identifier:UnsupportedOperation; 27, call; 28, identifier:fd; 29, identifier:seek; 30, identifier:offset; 31, identifier:emulate_seek; 32, argument_list; 33, identifier:fd; 34, identifier:offset; 35, identifier:chunk | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 7, 10; 7, 11; 8, 12; 9, 13; 9, 14; 13, 15; 14, 16; 14, 17; 14, 18; 15, 19; 16, 20; 16, 21; 18, 22; 19, 23; 19, 24; 21, 25; 21, 26; 22, 27; 23, 28; 23, 29; 24, 30; 27, 31; 27, 32; 32, 33; 32, 34; 32, 35 | def force_seek(fd, offset, chunk=CHUNK):
""" Force adjustment of read cursort to specified offset
This function takes a file descriptor ``fd`` and tries to seek to position
specified by ``offset`` argument. If the descriptor does not support the
``seek()`` method, it will fall back to ``emulate_seek()``.
The optional ``chunk`` argument can be used to adjust the chunk size for
``emulate_seek()``.
"""
try:
fd.seek(offset)
except (AttributeError, io.UnsupportedOperation):
# This file handle probably has no seek()
emulate_seek(fd, offset, chunk) |
0, module; 1, function_definition; 2, function_name:append; 3, parameters; 4, block; 5, identifier:self; 6, identifier:hcont; 7, identifier:value; 8, default_parameter; 9, expression_statement; 10, assert_statement; 11, if_statement; 12, expression_statement; 13, identifier:score; 14, None; 15, comment:""" If sort_field is specified, score must be None.
If sort_field is not specified, score is mandatory. """; 16, comparison_operator:(score is None) != (self.field.sort_field is None); 17, comparison_operator:score is None; 18, block; 19, call; 20, parenthesized_expression; 21, parenthesized_expression; 22, identifier:score; 23, None; 24, expression_statement; 25, attribute; 26, argument_list; 27, comparison_operator:score is None; 28, comparison_operator:self.field.sort_field is None; 29, assignment; 30, identifier:ContainerFieldWriter; 31, identifier:append; 32, identifier:self; 33, identifier:hcont; 34, identifier:value; 35, identifier:score; 36, identifier:score; 37, None; 38, attribute; 39, None; 40, identifier:score; 41, call; 42, attribute; 43, identifier:sort_field; 44, identifier:getattr; 45, argument_list; 46, identifier:self; 47, identifier:field; 48, identifier:value; 49, attribute; 50, attribute; 51, identifier:name; 52, attribute; 53, identifier:sort_field; 54, identifier:self; 55, identifier:field | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 8, 13; 8, 14; 9, 15; 10, 16; 11, 17; 11, 18; 12, 19; 16, 20; 16, 21; 17, 22; 17, 23; 18, 24; 19, 25; 19, 26; 20, 27; 21, 28; 24, 29; 25, 30; 25, 31; 26, 32; 26, 33; 26, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 38, 42; 38, 43; 41, 44; 41, 45; 42, 46; 42, 47; 45, 48; 45, 49; 49, 50; 49, 51; 50, 52; 50, 53; 52, 54; 52, 55 | def append(self, hcont, value, score = None):
""" If sort_field is specified, score must be None.
If sort_field is not specified, score is mandatory. """
assert (score is None) != (self.field.sort_field is None)
if score is None:
score = getattr(value, self.field.sort_field.name)
ContainerFieldWriter.append(self, hcont, value, score) |
0, module; 1, function_definition; 2, function_name:raise_errors_on_nested_writes; 3, parameters; 4, block; 5, identifier:method_name; 6, identifier:serializer; 7, identifier:validated_data; 8, expression_statement; 9, comment:# Ensure we don't have a writable nested field. For example:; 10, comment:#; 11, comment:# class UserSerializer(ModelSerializer):; 12, comment:# ...; 13, comment:# profile = ProfileSerializer(); 14, assert_statement; 15, comment:# Ensure we don't have a writable dotted-source field. For example:; 16, comment:#; 17, comment:# class UserSerializer(ModelSerializer):; 18, comment:# ...; 19, comment:# address = serializer.CharField('profile.address'); 20, assert_statement; 21, comment:"""
Give explicit errors when users attempt to pass writable nested data.
If we don't do this explicitly they'd get a less helpful error when
calling `.save()` on the serializer.
We don't *automatically* support these sorts of nested writes because
there are too many ambiguities to define a default behavior.
Eg. Suppose we have a `UserSerializer` with a nested profile. How should
we handle the case of an update, where the `profile` relationship does
not exist? Any of the following might be valid:
* Raise an application error.
* Silently ignore the nested part of the update.
* Automatically create a profile instance.
"""; 22, not_operator; 23, parenthesized_expression; 24, not_operator; 25, parenthesized_expression; 26, call; 27, call; 28, call; 29, call; 30, identifier:any; 31, generator_expression; 32, attribute; 33, argument_list; 34, identifier:any; 35, generator_expression; 36, attribute; 37, argument_list; 38, boolean_operator; 39, for_in_clause; 40, concatenated_string; 41, identifier:format; 42, keyword_argument; 43, keyword_argument; 44, keyword_argument; 45, boolean_operator; 46, for_in_clause; 47, concatenated_string; 48, identifier:format; 49, keyword_argument; 50, keyword_argument; 51, keyword_argument; 52, boolean_operator; 53, call; 54, pattern_list; 55, call; 56, string; 57, string; 58, string; 59, string; 60, identifier:method_name; 61, identifier:method_name; 62, identifier:module; 63, attribute; 64, identifier:class_name; 65, attribute; 66, boolean_operator; 67, call; 68, pattern_list; 69, call; 70, string; 71, string; 72, string; 73, string; 74, identifier:method_name; 75, identifier:method_name; 76, identifier:module; 77, attribute; 78, identifier:class_name; 79, attribute; 80, call; 81, parenthesized_expression; 82, identifier:isinstance; 83, argument_list; 84, identifier:key; 85, identifier:field; 86, attribute; 87, argument_list; 88, string_content:The `.{method_name}()` method does not support writable nested; 89, string_content; 90, string_content:serializer `{module}.{class_name}`, or set `read_only=True` on; 91, string_content:nested serializer fields.; 92, attribute; 93, identifier:__module__; 94, attribute; 95, identifier:__name__; 96, comparison_operator:'.' in field.source; 97, parenthesized_expression; 98, identifier:isinstance; 99, argument_list; 100, identifier:key; 101, identifier:field; 102, attribute; 103, argument_list; 104, string_content:The `.{method_name}()` method does not support writable dotted-source; 105, string_content; 106, string_content:serializer `{module}.{class_name}`, or set `read_only=True` on; 107, string_content:dotted-source serializer fields.; 108, attribute; 109, identifier:__module__; 110, attribute; 111, identifier:__name__; 112, identifier:isinstance; 113, argument_list; 114, comparison_operator:key in validated_data; 115, subscript; 116, tuple; 117, attribute; 118, identifier:items; 119, escape_sequence:\n; 120, identifier:serializer; 121, identifier:__class__; 122, identifier:serializer; 123, identifier:__class__; 124, string; 125, attribute; 126, comparison_operator:key in validated_data; 127, subscript; 128, tuple; 129, attribute; 130, identifier:items; 131, escape_sequence:\n; 132, identifier:serializer; 133, identifier:__class__; 134, identifier:serializer; 135, identifier:__class__; 136, identifier:field; 137, identifier:BaseSerializer; 138, identifier:key; 139, identifier:validated_data; 140, identifier:validated_data; 141, identifier:key; 142, identifier:list; 143, identifier:dict; 144, identifier:serializer; 145, identifier:fields; 146, string_content:.; 147, identifier:field; 148, identifier:source; 149, identifier:key; 150, identifier:validated_data; 151, identifier:validated_data; 152, identifier:key; 153, identifier:list; 154, identifier:dict; 155, identifier:serializer; 156, identifier:fields | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 8, 21; 14, 22; 14, 23; 20, 24; 20, 25; 22, 26; 23, 27; 24, 28; 25, 29; 26, 30; 26, 31; 27, 32; 27, 33; 28, 34; 28, 35; 29, 36; 29, 37; 31, 38; 31, 39; 32, 40; 32, 41; 33, 42; 33, 43; 33, 44; 35, 45; 35, 46; 36, 47; 36, 48; 37, 49; 37, 50; 37, 51; 38, 52; 38, 53; 39, 54; 39, 55; 40, 56; 40, 57; 40, 58; 40, 59; 42, 60; 42, 61; 43, 62; 43, 63; 44, 64; 44, 65; 45, 66; 45, 67; 46, 68; 46, 69; 47, 70; 47, 71; 47, 72; 47, 73; 49, 74; 49, 75; 50, 76; 50, 77; 51, 78; 51, 79; 52, 80; 52, 81; 53, 82; 53, 83; 54, 84; 54, 85; 55, 86; 55, 87; 56, 88; 57, 89; 58, 90; 59, 91; 63, 92; 63, 93; 65, 94; 65, 95; 66, 96; 66, 97; 67, 98; 67, 99; 68, 100; 68, 101; 69, 102; 69, 103; 70, 104; 71, 105; 72, 106; 73, 107; 77, 108; 77, 109; 79, 110; 79, 111; 80, 112; 80, 113; 81, 114; 83, 115; 83, 116; 86, 117; 86, 118; 89, 119; 92, 120; 92, 121; 94, 122; 94, 123; 96, 124; 96, 125; 97, 126; 99, 127; 99, 128; 102, 129; 102, 130; 105, 131; 108, 132; 108, 133; 110, 134; 110, 135; 113, 136; 113, 137; 114, 138; 114, 139; 115, 140; 115, 141; 116, 142; 116, 143; 117, 144; 117, 145; 124, 146; 125, 147; 125, 148; 126, 149; 126, 150; 127, 151; 127, 152; 128, 153; 128, 154; 129, 155; 129, 156 | def raise_errors_on_nested_writes(method_name, serializer, validated_data):
"""
Give explicit errors when users attempt to pass writable nested data.
If we don't do this explicitly they'd get a less helpful error when
calling `.save()` on the serializer.
We don't *automatically* support these sorts of nested writes because
there are too many ambiguities to define a default behavior.
Eg. Suppose we have a `UserSerializer` with a nested profile. How should
we handle the case of an update, where the `profile` relationship does
not exist? Any of the following might be valid:
* Raise an application error.
* Silently ignore the nested part of the update.
* Automatically create a profile instance.
"""
# Ensure we don't have a writable nested field. For example:
#
# class UserSerializer(ModelSerializer):
# ...
# profile = ProfileSerializer()
assert not any(
isinstance(field, BaseSerializer) and
(key in validated_data) and
isinstance(validated_data[key], (list, dict))
for key, field in serializer.fields.items()
), (
'The `.{method_name}()` method does not support writable nested'
'fields by default.\nWrite an explicit `.{method_name}()` method for '
'serializer `{module}.{class_name}`, or set `read_only=True` on '
'nested serializer fields.'.format(
method_name=method_name,
module=serializer.__class__.__module__,
class_name=serializer.__class__.__name__
)
)
# Ensure we don't have a writable dotted-source field. For example:
#
# class UserSerializer(ModelSerializer):
# ...
# address = serializer.CharField('profile.address')
assert not any(
'.' in field.source and
(key in validated_data) and
isinstance(validated_data[key], (list, dict))
for key, field in serializer.fields.items()
), (
'The `.{method_name}()` method does not support writable dotted-source '
'fields by default.\nWrite an explicit `.{method_name}()` method for '
'serializer `{module}.{class_name}`, or set `read_only=True` on '
'dotted-source serializer fields.'.format(
method_name=method_name,
module=serializer.__class__.__module__,
class_name=serializer.__class__.__name__
)
) |
0, module; 1, function_definition; 2, function_name:threenum; 3, parameters; 4, block; 5, identifier:h5file; 6, identifier:var; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, for_statement; 19, expression_statement; 20, expression_statement; 21, return_statement; 22, identifier:post_col; 23, string; 24, comment:""" Calculates the three number summary for a variable.
The three number summary is the minimum, maximum and the mean
of the data. Traditionally one would summerise data with the
five number summary: max, min, 1st, 2nd (median), 3rd quartile.
But quantiles are hard to calculate without sorting the data
which hard to do out-of-core.
"""; 25, assignment; 26, assignment; 27, assignment; 28, assignment; 29, assignment; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, identifier:x; 35, call; 36, block; 37, call; 38, assignment; 39, tuple; 40, string_content:mult; 41, identifier:f; 42, call; 43, identifier:d; 44, subscript; 45, identifier:w; 46, subscript; 47, identifier:s; 48, subscript; 49, identifier:n; 50, subscript; 51, identifier:maxval; 52, unary_operator; 53, identifier:minval; 54, call; 55, identifier:total; 56, integer:0; 57, identifier:wsum; 58, integer:0; 59, identifier:range; 60, argument_list; 61, expression_statement; 62, expression_statement; 63, expression_statement; 64, expression_statement; 65, expression_statement; 66, expression_statement; 67, expression_statement; 68, expression_statement; 69, expression_statement; 70, attribute; 71, argument_list; 72, identifier:mean; 73, binary_operator:total/float(wsum); 74, identifier:minval; 75, identifier:maxval; 76, identifier:mean; 77, attribute; 78, argument_list; 79, identifier:f; 80, identifier:var; 81, identifier:f; 82, identifier:post_col; 83, attribute; 84, integer:0; 85, attribute; 86, integer:0; 87, call; 88, attribute; 89, argument_list; 90, integer:0; 91, identifier:n; 92, identifier:s; 93, assignment; 94, assignment; 95, assignment; 96, assignment; 97, assignment; 98, assignment; 99, assignment; 100, augmented_assignment; 101, augmented_assignment; 102, identifier:f; 103, identifier:close; 104, identifier:total; 105, call; 106, identifier:h5py; 107, identifier:File; 108, identifier:h5file; 109, string; 110, identifier:d; 111, identifier:chunks; 112, identifier:d; 113, identifier:shape; 114, attribute; 115, argument_list; 116, identifier:np; 117, identifier:abs; 118, subscript; 119, identifier:aN; 120, unary_operator; 121, identifier:d_c; 122, subscript; 123, identifier:w_c; 124, subscript; 125, identifier:chunk_max; 126, call; 127, identifier:chunk_min; 128, call; 129, identifier:maxval; 130, conditional_expression:chunk_max if chunk_max > maxval else maxval; 131, identifier:minval; 132, conditional_expression:chunk_min if chunk_min < minval else minval; 133, identifier:total; 134, call; 135, identifier:wsum; 136, call; 137, identifier:float; 138, argument_list; 139, string_content:r; 140, identifier:np; 141, identifier:abs; 142, subscript; 143, identifier:d; 144, integer:0; 145, call; 146, subscript; 147, identifier:aN; 148, subscript; 149, identifier:aN; 150, attribute; 151, argument_list; 152, attribute; 153, argument_list; 154, identifier:chunk_max; 155, comparison_operator:chunk_max > maxval; 156, identifier:maxval; 157, identifier:chunk_min; 158, comparison_operator:chunk_min < minval; 159, identifier:minval; 160, attribute; 161, argument_list; 162, attribute; 163, argument_list; 164, identifier:wsum; 165, identifier:d; 166, integer:0; 167, attribute; 168, argument_list; 169, identifier:d; 170, slice; 171, identifier:w; 172, slice; 173, identifier:np; 174, identifier:max; 175, identifier:d_c; 176, identifier:np; 177, identifier:min; 178, identifier:d_c; 179, identifier:chunk_max; 180, identifier:maxval; 181, identifier:chunk_min; 182, identifier:minval; 183, identifier:np; 184, identifier:sum; 185, binary_operator:w_c*d_c; 186, identifier:np; 187, identifier:sum; 188, identifier:w_c; 189, identifier:np; 190, identifier:logical_or; 191, call; 192, call; 193, identifier:x; 194, binary_operator:x+s; 195, identifier:x; 196, binary_operator:x+s; 197, identifier:w_c; 198, identifier:d_c; 199, attribute; 200, argument_list; 201, attribute; 202, argument_list; 203, identifier:x; 204, identifier:s; 205, identifier:x; 206, identifier:s; 207, identifier:np; 208, identifier:isnan; 209, subscript; 210, identifier:np; 211, identifier:isinf; 212, subscript; 213, identifier:d; 214, slice; 215, identifier:d; 216, slice; 217, identifier:x; 218, binary_operator:x+s; 219, identifier:x; 220, binary_operator:x+s; 221, identifier:x; 222, identifier:s; 223, identifier:x; 224, identifier:s | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 7, 22; 7, 23; 8, 24; 9, 25; 10, 26; 11, 27; 12, 28; 13, 29; 14, 30; 15, 31; 16, 32; 17, 33; 18, 34; 18, 35; 18, 36; 19, 37; 20, 38; 21, 39; 23, 40; 25, 41; 25, 42; 26, 43; 26, 44; 27, 45; 27, 46; 28, 47; 28, 48; 29, 49; 29, 50; 30, 51; 30, 52; 31, 53; 31, 54; 32, 55; 32, 56; 33, 57; 33, 58; 35, 59; 35, 60; 36, 61; 36, 62; 36, 63; 36, 64; 36, 65; 36, 66; 36, 67; 36, 68; 36, 69; 37, 70; 37, 71; 38, 72; 38, 73; 39, 74; 39, 75; 39, 76; 42, 77; 42, 78; 44, 79; 44, 80; 46, 81; 46, 82; 48, 83; 48, 84; 50, 85; 50, 86; 52, 87; 54, 88; 54, 89; 60, 90; 60, 91; 60, 92; 61, 93; 62, 94; 63, 95; 64, 96; 65, 97; 66, 98; 67, 99; 68, 100; 69, 101; 70, 102; 70, 103; 73, 104; 73, 105; 77, 106; 77, 107; 78, 108; 78, 109; 83, 110; 83, 111; 85, 112; 85, 113; 87, 114; 87, 115; 88, 116; 88, 117; 89, 118; 93, 119; 93, 120; 94, 121; 94, 122; 95, 123; 95, 124; 96, 125; 96, 126; 97, 127; 97, 128; 98, 129; 98, 130; 99, 131; 99, 132; 100, 133; 100, 134; 101, 135; 101, 136; 105, 137; 105, 138; 109, 139; 114, 140; 114, 141; 115, 142; 118, 143; 118, 144; 120, 145; 122, 146; 122, 147; 124, 148; 124, 149; 126, 150; 126, 151; 128, 152; 128, 153; 130, 154; 130, 155; 130, 156; 132, 157; 132, 158; 132, 159; 134, 160; 134, 161; 136, 162; 136, 163; 138, 164; 142, 165; 142, 166; 145, 167; 145, 168; 146, 169; 146, 170; 148, 171; 148, 172; 150, 173; 150, 174; 151, 175; 152, 176; 152, 177; 153, 178; 155, 179; 155, 180; 158, 181; 158, 182; 160, 183; 160, 184; 161, 185; 162, 186; 162, 187; 163, 188; 167, 189; 167, 190; 168, 191; 168, 192; 170, 193; 170, 194; 172, 195; 172, 196; 185, 197; 185, 198; 191, 199; 191, 200; 192, 201; 192, 202; 194, 203; 194, 204; 196, 205; 196, 206; 199, 207; 199, 208; 200, 209; 201, 210; 201, 211; 202, 212; 209, 213; 209, 214; 212, 215; 212, 216; 214, 217; 214, 218; 216, 219; 216, 220; 218, 221; 218, 222; 220, 223; 220, 224 | def threenum(h5file, var, post_col='mult'):
""" Calculates the three number summary for a variable.
The three number summary is the minimum, maximum and the mean
of the data. Traditionally one would summerise data with the
five number summary: max, min, 1st, 2nd (median), 3rd quartile.
But quantiles are hard to calculate without sorting the data
which hard to do out-of-core.
"""
f = h5py.File(h5file, 'r')
d = f[var]
w = f[post_col]
s = d.chunks[0]
n = d.shape[0]
maxval = -np.abs(d[0])
minval = np.abs(d[0])
total = 0
wsum = 0
for x in range(0, n, s):
aN = ~np.logical_or(np.isnan(d[x:x+s]), np.isinf(d[x:x+s]))
d_c = d[x:x+s][aN]
w_c = w[x:x+s][aN]
chunk_max = np.max(d_c)
chunk_min = np.min(d_c)
maxval = chunk_max if chunk_max > maxval else maxval
minval = chunk_min if chunk_min < minval else minval
total += np.sum(w_c*d_c)
wsum += np.sum(w_c)
f.close()
mean = total/float(wsum)
return (minval, maxval, mean) |
0, module; 1, function_definition; 2, function_name:_filter_keys; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, function_definition; 11, return_statement; 12, identifier:content_id; 13, None; 14, identifier:prefix; 15, None; 16, identifier:subtopic_id; 17, None; 18, string; 19, function_name:accept; 20, parameters; 21, block; 22, identifier:accept; 23, string_content:Filter out-of-order labels by key tuple.
:class:`Label` always sorts by `(cid1,cid2,sid1,sid2)`, but
for efficient lookups on `cid2` this class also stores in
order `(cid2,cid1,sid2,sid1)`. Filter out things that are
in the wrong order. But, if an original query specified
`content_id` or `subtopic_id`, account for the possibility
that something might be apparently out-of-order but its
dual will not be in the query at all.; 24, identifier:kvp; 25, expression_statement; 26, comment:# In general we'll accept the label if; 27, comment:# it's the natural order; l.content_id1 == cid1; 28, expression_statement; 29, if_statement; 30, comment:# If we're not looking for subtopic IDs, then accept records; 31, comment:# matching the content ID that are in natural order; 32, if_statement; 33, comment:# The scan range doesn't include subtopic IDs (the key schema; 34, comment:# is oriented towards querying content-to-content labels); 35, comment:# so we need to accept records where either part matches; 36, comment:# (if both parts match then the record is its own dual); 37, if_statement; 38, if_statement; 39, return_statement; 40, assignment; 41, assignment; 42, comparison_operator:content_id is not None; 43, comment:# We will only see tuples where content_id1 is the; 44, comment:# requested content ID; 45, block; 46, elif_clause; 47, elif_clause; 48, comparison_operator:subtopic_id is None; 49, block; 50, comparison_operator:subtopic_id == subtopic_id1; 51, block; 52, boolean_operator; 53, block; 54, False; 55, tuple_pattern; 56, subscript; 57, identifier:is_sorted; 58, parenthesized_expression; 59, identifier:content_id; 60, None; 61, assert_statement; 62, comparison_operator:prefix is not None; 63, block; 64, not_operator; 65, comment:# We'll see both orderings of everything, reject the; 66, comment:# unsorted ones; 67, block; 68, identifier:subtopic_id; 69, None; 70, if_statement; 71, return_statement; 72, identifier:subtopic_id; 73, identifier:subtopic_id1; 74, return_statement; 75, comparison_operator:content_id == content_id2; 76, comparison_operator:subtopic_id == subtopic_id2; 77, return_statement; 78, identifier:content_id1; 79, identifier:content_id2; 80, identifier:subtopic_id1; 81, identifier:subtopic_id2; 82, identifier:annotator_id; 83, identifier:inverted_epoch_ticks; 84, identifier:kvp; 85, integer:0; 86, boolean_operator; 87, comparison_operator:content_id1 == content_id; 88, identifier:prefix; 89, None; 90, assert_statement; 91, comment:# If we'll see both orderings of this record, only; 92, comment:# accept the sorted one; 93, if_statement; 94, identifier:is_sorted; 95, return_statement; 96, comparison_operator:content_id2 != content_id; 97, block; 98, comparison_operator:subtopic_id1 <= subtopic_id2; 99, True; 100, identifier:content_id; 101, identifier:content_id2; 102, identifier:subtopic_id; 103, identifier:subtopic_id2; 104, True; 105, comparison_operator:content_id1 < content_id2; 106, parenthesized_expression; 107, identifier:content_id1; 108, identifier:content_id; 109, call; 110, boolean_operator; 111, block; 112, False; 113, identifier:content_id2; 114, identifier:content_id; 115, return_statement; 116, comment:# will never see its dual; 117, identifier:subtopic_id1; 118, identifier:subtopic_id2; 119, identifier:content_id1; 120, identifier:content_id2; 121, boolean_operator; 122, attribute; 123, argument_list; 124, call; 125, not_operator; 126, return_statement; 127, True; 128, comparison_operator:content_id1 == content_id2; 129, comparison_operator:subtopic_id1 <= subtopic_id2; 130, identifier:content_id1; 131, identifier:startswith; 132, identifier:prefix; 133, attribute; 134, argument_list; 135, identifier:is_sorted; 136, False; 137, identifier:content_id1; 138, identifier:content_id2; 139, identifier:subtopic_id1; 140, identifier:subtopic_id2; 141, identifier:content_id2; 142, identifier:startswith; 143, identifier:prefix | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 7, 15; 8, 16; 8, 17; 9, 18; 10, 19; 10, 20; 10, 21; 11, 22; 18, 23; 20, 24; 21, 25; 21, 26; 21, 27; 21, 28; 21, 29; 21, 30; 21, 31; 21, 32; 21, 33; 21, 34; 21, 35; 21, 36; 21, 37; 21, 38; 21, 39; 25, 40; 28, 41; 29, 42; 29, 43; 29, 44; 29, 45; 29, 46; 29, 47; 32, 48; 32, 49; 37, 50; 37, 51; 38, 52; 38, 53; 39, 54; 40, 55; 40, 56; 41, 57; 41, 58; 42, 59; 42, 60; 45, 61; 46, 62; 46, 63; 47, 64; 47, 65; 47, 66; 47, 67; 48, 68; 48, 69; 49, 70; 49, 71; 50, 72; 50, 73; 51, 74; 52, 75; 52, 76; 53, 77; 55, 78; 55, 79; 55, 80; 55, 81; 55, 82; 55, 83; 56, 84; 56, 85; 58, 86; 61, 87; 62, 88; 62, 89; 63, 90; 63, 91; 63, 92; 63, 93; 64, 94; 67, 95; 70, 96; 70, 97; 71, 98; 74, 99; 75, 100; 75, 101; 76, 102; 76, 103; 77, 104; 86, 105; 86, 106; 87, 107; 87, 108; 90, 109; 93, 110; 93, 111; 95, 112; 96, 113; 96, 114; 97, 115; 97, 116; 98, 117; 98, 118; 105, 119; 105, 120; 106, 121; 109, 122; 109, 123; 110, 124; 110, 125; 111, 126; 115, 127; 121, 128; 121, 129; 122, 130; 122, 131; 123, 132; 124, 133; 124, 134; 125, 135; 126, 136; 128, 137; 128, 138; 129, 139; 129, 140; 133, 141; 133, 142; 134, 143 | def _filter_keys(self, content_id=None, prefix=None, subtopic_id=None):
'''Filter out-of-order labels by key tuple.
:class:`Label` always sorts by `(cid1,cid2,sid1,sid2)`, but
for efficient lookups on `cid2` this class also stores in
order `(cid2,cid1,sid2,sid1)`. Filter out things that are
in the wrong order. But, if an original query specified
`content_id` or `subtopic_id`, account for the possibility
that something might be apparently out-of-order but its
dual will not be in the query at all.
'''
def accept(kvp):
(content_id1, content_id2, subtopic_id1, subtopic_id2,
annotator_id, inverted_epoch_ticks) = kvp[0]
# In general we'll accept the label if
# it's the natural order; l.content_id1 == cid1
is_sorted = (content_id1 < content_id2 or
(content_id1 == content_id2 and
subtopic_id1 <= subtopic_id2))
if content_id is not None:
# We will only see tuples where content_id1 is the
# requested content ID
assert content_id1 == content_id
elif prefix is not None:
assert content_id1.startswith(prefix)
# If we'll see both orderings of this record, only
# accept the sorted one
if content_id2.startswith(prefix) and not is_sorted:
return False
elif not is_sorted:
# We'll see both orderings of everything, reject the
# unsorted ones
return False
# If we're not looking for subtopic IDs, then accept records
# matching the content ID that are in natural order
if subtopic_id is None:
if content_id2 != content_id:
return True # will never see its dual
return subtopic_id1 <= subtopic_id2
# The scan range doesn't include subtopic IDs (the key schema
# is oriented towards querying content-to-content labels)
# so we need to accept records where either part matches
# (if both parts match then the record is its own dual)
if subtopic_id == subtopic_id1:
return True
if content_id == content_id2 and subtopic_id == subtopic_id2:
return True
return False
return accept |
0, module; 1, function_definition; 2, function_name:topological_sorting; 3, parameters; 4, block; 5, identifier:nodes; 6, identifier:relations; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, while_statement; 14, if_statement; 15, return_statement; 16, string; 17, assignment; 18, assignment; 19, assignment; 20, assignment; 21, assignment; 22, identifier:free; 23, block; 24, not_operator; 25, block; 26, identifier:ret; 27, string_content:An implementation of Kahn's algorithm.; 28, identifier:ret; 29, list; 30, identifier:nodes; 31, binary_operator:set(nodes) | _nodes(relations); 32, identifier:inc; 33, call; 34, identifier:out; 35, call; 36, identifier:free; 37, call; 38, expression_statement; 39, expression_statement; 40, expression_statement; 41, for_statement; 42, call; 43, raise_statement; 44, call; 45, call; 46, identifier:_incoming; 47, argument_list; 48, identifier:_outgoing; 49, argument_list; 50, identifier:_free_nodes; 51, argument_list; 52, assignment; 53, call; 54, assignment; 55, identifier:m; 56, identifier:out_n; 57, block; 58, identifier:all; 59, generator_expression; 60, call; 61, identifier:set; 62, argument_list; 63, identifier:_nodes; 64, argument_list; 65, identifier:relations; 66, identifier:relations; 67, identifier:nodes; 68, identifier:inc; 69, identifier:n; 70, call; 71, attribute; 72, argument_list; 73, identifier:out_n; 74, call; 75, expression_statement; 76, expression_statement; 77, if_statement; 78, boolean_operator; 79, for_in_clause; 80, identifier:ValueError; 81, argument_list; 82, identifier:nodes; 83, identifier:relations; 84, attribute; 85, argument_list; 86, identifier:ret; 87, identifier:append; 88, identifier:n; 89, identifier:list; 90, argument_list; 91, call; 92, call; 93, call; 94, block; 95, call; 96, call; 97, identifier:node; 98, identifier:nodes; 99, string:"Cycle detected"; 100, identifier:free; 101, identifier:pop; 102, subscript; 103, attribute; 104, argument_list; 105, attribute; 106, argument_list; 107, identifier:_is_free; 108, argument_list; 109, expression_statement; 110, identifier:_is_free; 111, argument_list; 112, identifier:_is_free; 113, argument_list; 114, identifier:out; 115, identifier:n; 116, subscript; 117, identifier:remove; 118, identifier:m; 119, subscript; 120, identifier:remove; 121, identifier:n; 122, identifier:m; 123, identifier:inc; 124, call; 125, identifier:node; 126, identifier:inc; 127, identifier:node; 128, identifier:out; 129, identifier:out; 130, identifier:n; 131, identifier:inc; 132, identifier:m; 133, attribute; 134, argument_list; 135, identifier:free; 136, identifier:add; 137, identifier:m | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 7, 16; 8, 17; 9, 18; 10, 19; 11, 20; 12, 21; 13, 22; 13, 23; 14, 24; 14, 25; 15, 26; 16, 27; 17, 28; 17, 29; 18, 30; 18, 31; 19, 32; 19, 33; 20, 34; 20, 35; 21, 36; 21, 37; 23, 38; 23, 39; 23, 40; 23, 41; 24, 42; 25, 43; 31, 44; 31, 45; 33, 46; 33, 47; 35, 48; 35, 49; 37, 50; 37, 51; 38, 52; 39, 53; 40, 54; 41, 55; 41, 56; 41, 57; 42, 58; 42, 59; 43, 60; 44, 61; 44, 62; 45, 63; 45, 64; 47, 65; 49, 66; 51, 67; 51, 68; 52, 69; 52, 70; 53, 71; 53, 72; 54, 73; 54, 74; 57, 75; 57, 76; 57, 77; 59, 78; 59, 79; 60, 80; 60, 81; 62, 82; 64, 83; 70, 84; 70, 85; 71, 86; 71, 87; 72, 88; 74, 89; 74, 90; 75, 91; 76, 92; 77, 93; 77, 94; 78, 95; 78, 96; 79, 97; 79, 98; 81, 99; 84, 100; 84, 101; 90, 102; 91, 103; 91, 104; 92, 105; 92, 106; 93, 107; 93, 108; 94, 109; 95, 110; 95, 111; 96, 112; 96, 113; 102, 114; 102, 115; 103, 116; 103, 117; 104, 118; 105, 119; 105, 120; 106, 121; 108, 122; 108, 123; 109, 124; 111, 125; 111, 126; 113, 127; 113, 128; 116, 129; 116, 130; 119, 131; 119, 132; 124, 133; 124, 134; 133, 135; 133, 136; 134, 137 | def topological_sorting(nodes, relations):
'''An implementation of Kahn's algorithm.
'''
ret = []
nodes = set(nodes) | _nodes(relations)
inc = _incoming(relations)
out = _outgoing(relations)
free = _free_nodes(nodes, inc)
while free:
n = free.pop()
ret.append(n)
out_n = list(out[n])
for m in out_n:
out[n].remove(m)
inc[m].remove(n)
if _is_free(m, inc):
free.add(m)
if not all(_is_free(node, inc) and _is_free(node, out) for node in nodes):
raise ValueError("Cycle detected")
return ret |
0, module; 1, function_definition; 2, function_name:solve_resource; 3, parameters; 4, block; 5, identifier:self; 6, identifier:value; 7, identifier:resource; 8, expression_statement; 9, for_statement; 10, raise_statement; 11, comment:"""Solve the given resource for the given value.
The solving is done by the first resource solver class that returns ``True`` when calling
its ``can_solve`` method for the given resource, and that doesn't raise a ``CannotSolve``
exception.
Arguments
---------
value : ?
A value to be solved with the given resource.
resource : dataql.resources.Resource
An instance of a subclass of ``Resource`` to be solved with the given value.
Returns
-------
The solved result.
Raises
------
dataql.solvers.exceptions.SolveFailure
If no solvers were able to solve the resource. This happen if a solver says that
it can solve a resource (by returning ``True`` when calling its ``can_solve`` method,
but raises a ``CannotSolve`` exception during solving).
Example
-------
>>> from datetime import date
>>> registry = Registry()
>>> registry.register(date, ['day', 'month', 'year', 'strftime'])
>>> from dataql.resources import Field, Filter, List, Object, PosArg, SliceFilter
>>> registry.solve_resource(date(2015, 6, 1), Field('day'))
1
# Create an object from which we'll want an object (``date``) and a list (``dates``)
>>> obj = EntryPoints(registry,
... date = date(2015, 6, 1),
... dates = [date(2015, 6, 1), date(2015, 6, 2), date(2015, 6, 3)],
... )
>>> from pprint import pprint # will sort the dicts by keys
>>> pprint(registry.solve_resource(
... obj,
... # Omit single filter as it's auto-created with the name of the resource.
... Object('date', resources=[Field('day'), Field('month'), Field('year')])
... ))
{'day': 1, 'month': 6, 'year': 2015}
>>> registry.solve_resource(
... obj,
... # Omit single filter as it's auto-created with the name of the resource.
... List('dates', resources=[Field('day'), Field('month'), Field('year')])
... )
[[1, 6, 2015], [2, 6, 2015], [3, 6, 2015]]
>>> registry.solve_resource(
... obj,
... Field('dates', filters=[Filter('dates'), SliceFilter(1)])
... )
'2015-06-02'
# List of fields
>>> registry.solve_resource(
... obj,
... List('dates',
... filters=[Filter('dates'), SliceFilter(slice(1, None, None))],
... resources=[Field('date', filters=[Filter('strftime', args=[PosArg('%F')])])]
... )
... )
['2015-06-02', '2015-06-03']
# List of objects
>>> registry.solve_resource(
... obj,
... List('dates',
... filters=[Filter('dates'), SliceFilter(slice(1, None, None))],
... resources=[Object(None, resources=[
... Field('date', filters=[Filter('strftime', args=[PosArg('%F')])])
... ]
... )]
... ))
[{'date': '2015-06-02'}, {'date': '2015-06-03'}]
# List of list
>>> pprint(registry.solve_resource(
... obj,
... List(None,
... filters=[Filter('dates'), SliceFilter(slice(None, None, 2))],
... resources=[
... Field(None, [Filter('strftime', args=[PosArg('%F')])]),
... Object(None, resources=[Field('day'), Field('month'), Field('year')]),
... ]
... )
... ))
[['2015-06-01', {'day': 1, 'month': 6, 'year': 2015}],
['2015-06-03', {'day': 3, 'month': 6, 'year': 2015}]]
# Test the dict-like approach
>>> class MyDict(dict):
... foo = 1
... bar = 2
>>> registry.register(MyDict, ['foo', 'baz'])
>>> d = MyDict(baz=3, qux=4)
>>> registry.solve_resource(d, Field('foo'))
1
>>> registry.solve_resource(d, Field('bar')) # doctest: +ELLIPSIS
Traceback (most recent call last):
dataql...AttributeNotFound: `bar` is not an allowed attribute for `...MyDict`
>>> registry.solve_resource(d, Field('baz'))
3
>>> registry.solve_resource(d, Field('qux')) # doctest: +ELLIPSIS
Traceback (most recent call last):
dataql...AttributeNotFound: `qux` is not an allowed attribute for `...MyDict`
# Example of ``SolveFailure`` exception.
>>> from dataql.solvers.exceptions import CannotSolve
>>> raise SolveFailure(registry, Field('fromtimestamp'), date)
Traceback (most recent call last):
dataql.solvers.exceptions.SolveFailure: Unable to solve `<Field[fromtimestamp]>`.
"""; 12, identifier:solver; 13, call; 14, block; 15, call; 16, attribute; 17, argument_list; 18, try_statement; 19, identifier:SolveFailure; 20, argument_list; 21, identifier:self; 22, identifier:get_resource_solvers; 23, identifier:resource; 24, block; 25, except_clause; 26, identifier:self; 27, identifier:resource; 28, identifier:value; 29, return_statement; 30, identifier:CannotSolve; 31, block; 32, call; 33, continue_statement; 34, attribute; 35, argument_list; 36, identifier:solver; 37, identifier:solve; 38, identifier:value; 39, identifier:resource | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 8, 11; 9, 12; 9, 13; 9, 14; 10, 15; 13, 16; 13, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 17, 23; 18, 24; 18, 25; 20, 26; 20, 27; 20, 28; 24, 29; 25, 30; 25, 31; 29, 32; 31, 33; 32, 34; 32, 35; 34, 36; 34, 37; 35, 38; 35, 39 | def solve_resource(self, value, resource):
"""Solve the given resource for the given value.
The solving is done by the first resource solver class that returns ``True`` when calling
its ``can_solve`` method for the given resource, and that doesn't raise a ``CannotSolve``
exception.
Arguments
---------
value : ?
A value to be solved with the given resource.
resource : dataql.resources.Resource
An instance of a subclass of ``Resource`` to be solved with the given value.
Returns
-------
The solved result.
Raises
------
dataql.solvers.exceptions.SolveFailure
If no solvers were able to solve the resource. This happen if a solver says that
it can solve a resource (by returning ``True`` when calling its ``can_solve`` method,
but raises a ``CannotSolve`` exception during solving).
Example
-------
>>> from datetime import date
>>> registry = Registry()
>>> registry.register(date, ['day', 'month', 'year', 'strftime'])
>>> from dataql.resources import Field, Filter, List, Object, PosArg, SliceFilter
>>> registry.solve_resource(date(2015, 6, 1), Field('day'))
1
# Create an object from which we'll want an object (``date``) and a list (``dates``)
>>> obj = EntryPoints(registry,
... date = date(2015, 6, 1),
... dates = [date(2015, 6, 1), date(2015, 6, 2), date(2015, 6, 3)],
... )
>>> from pprint import pprint # will sort the dicts by keys
>>> pprint(registry.solve_resource(
... obj,
... # Omit single filter as it's auto-created with the name of the resource.
... Object('date', resources=[Field('day'), Field('month'), Field('year')])
... ))
{'day': 1, 'month': 6, 'year': 2015}
>>> registry.solve_resource(
... obj,
... # Omit single filter as it's auto-created with the name of the resource.
... List('dates', resources=[Field('day'), Field('month'), Field('year')])
... )
[[1, 6, 2015], [2, 6, 2015], [3, 6, 2015]]
>>> registry.solve_resource(
... obj,
... Field('dates', filters=[Filter('dates'), SliceFilter(1)])
... )
'2015-06-02'
# List of fields
>>> registry.solve_resource(
... obj,
... List('dates',
... filters=[Filter('dates'), SliceFilter(slice(1, None, None))],
... resources=[Field('date', filters=[Filter('strftime', args=[PosArg('%F')])])]
... )
... )
['2015-06-02', '2015-06-03']
# List of objects
>>> registry.solve_resource(
... obj,
... List('dates',
... filters=[Filter('dates'), SliceFilter(slice(1, None, None))],
... resources=[Object(None, resources=[
... Field('date', filters=[Filter('strftime', args=[PosArg('%F')])])
... ]
... )]
... ))
[{'date': '2015-06-02'}, {'date': '2015-06-03'}]
# List of list
>>> pprint(registry.solve_resource(
... obj,
... List(None,
... filters=[Filter('dates'), SliceFilter(slice(None, None, 2))],
... resources=[
... Field(None, [Filter('strftime', args=[PosArg('%F')])]),
... Object(None, resources=[Field('day'), Field('month'), Field('year')]),
... ]
... )
... ))
[['2015-06-01', {'day': 1, 'month': 6, 'year': 2015}],
['2015-06-03', {'day': 3, 'month': 6, 'year': 2015}]]
# Test the dict-like approach
>>> class MyDict(dict):
... foo = 1
... bar = 2
>>> registry.register(MyDict, ['foo', 'baz'])
>>> d = MyDict(baz=3, qux=4)
>>> registry.solve_resource(d, Field('foo'))
1
>>> registry.solve_resource(d, Field('bar')) # doctest: +ELLIPSIS
Traceback (most recent call last):
dataql...AttributeNotFound: `bar` is not an allowed attribute for `...MyDict`
>>> registry.solve_resource(d, Field('baz'))
3
>>> registry.solve_resource(d, Field('qux')) # doctest: +ELLIPSIS
Traceback (most recent call last):
dataql...AttributeNotFound: `qux` is not an allowed attribute for `...MyDict`
# Example of ``SolveFailure`` exception.
>>> from dataql.solvers.exceptions import CannotSolve
>>> raise SolveFailure(registry, Field('fromtimestamp'), date)
Traceback (most recent call last):
dataql.solvers.exceptions.SolveFailure: Unable to solve `<Field[fromtimestamp]>`.
"""
for solver in self.get_resource_solvers(resource):
try:
return solver.solve(value, resource)
except CannotSolve:
continue
raise SolveFailure(self, resource, value) |
0, module; 1, function_definition; 2, function_name:incrementName; 3, parameters; 4, block; 5, identifier:nameList; 6, identifier:name; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, for_statement; 11, return_statement; 12, comment:"""
return a name that is unique in a given nameList through
attaching a number to it
>>> l = []
now we will add 3xfoo 2xbar and one klaus to our list:
>>> l.append( incrementName(l,'foo') )
>>> l.append( incrementName(l,'bar') )
>>> l.append( incrementName(l,'foo') )
>>> l.append( incrementName(l,'foo') )
>>> l.append( incrementName(l,'bar') )
>>> l.append( incrementName(l,'klaus') )
>>> print sorted(l)
['bar', 'bar2', 'foo', 'foo2', 'foo3', 'klaus']
"""; 13, comparison_operator:name not in nameList; 14, block; 15, assignment; 16, identifier:n; 17, call; 18, block; 19, identifier:newName; 20, identifier:name; 21, identifier:nameList; 22, return_statement; 23, identifier:newName; 24, binary_operator:name + str(1); 25, identifier:range; 26, argument_list; 27, expression_statement; 28, for_statement; 29, if_statement; 30, identifier:name; 31, identifier:name; 32, call; 33, integer:1; 34, binary_operator:len(nameList) + 2; 35, assignment; 36, identifier:b; 37, identifier:nameList; 38, block; 39, not_operator; 40, block; 41, identifier:str; 42, argument_list; 43, call; 44, integer:2; 45, identifier:found; 46, False; 47, expression_statement; 48, if_statement; 49, identifier:found; 50, break_statement; 51, integer:1; 52, identifier:len; 53, argument_list; 54, assignment; 55, comparison_operator:b == newName; 56, block; 57, identifier:nameList; 58, identifier:newName; 59, binary_operator:name + str(n); 60, identifier:b; 61, identifier:newName; 62, expression_statement; 63, identifier:name; 64, call; 65, assignment; 66, identifier:str; 67, argument_list; 68, identifier:found; 69, True; 70, identifier:n | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 8, 14; 9, 15; 10, 16; 10, 17; 10, 18; 11, 19; 13, 20; 13, 21; 14, 22; 15, 23; 15, 24; 17, 25; 17, 26; 18, 27; 18, 28; 18, 29; 22, 30; 24, 31; 24, 32; 26, 33; 26, 34; 27, 35; 28, 36; 28, 37; 28, 38; 29, 39; 29, 40; 32, 41; 32, 42; 34, 43; 34, 44; 35, 45; 35, 46; 38, 47; 38, 48; 39, 49; 40, 50; 42, 51; 43, 52; 43, 53; 47, 54; 48, 55; 48, 56; 53, 57; 54, 58; 54, 59; 55, 60; 55, 61; 56, 62; 59, 63; 59, 64; 62, 65; 64, 66; 64, 67; 65, 68; 65, 69; 67, 70 | def incrementName(nameList, name):
"""
return a name that is unique in a given nameList through
attaching a number to it
>>> l = []
now we will add 3xfoo 2xbar and one klaus to our list:
>>> l.append( incrementName(l,'foo') )
>>> l.append( incrementName(l,'bar') )
>>> l.append( incrementName(l,'foo') )
>>> l.append( incrementName(l,'foo') )
>>> l.append( incrementName(l,'bar') )
>>> l.append( incrementName(l,'klaus') )
>>> print sorted(l)
['bar', 'bar2', 'foo', 'foo2', 'foo3', 'klaus']
"""
if name not in nameList:
return name
newName = name + str(1)
for n in range(1, len(nameList) + 2):
found = False
for b in nameList:
newName = name + str(n)
if b == newName:
found = True
if not found:
break
return newName |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:polylines; 6, expression_statement; 7, for_statement; 8, comment:"""
sort points within polyline
p0-p1-p2...
"""; 9, pattern_list; 10, call; 11, block; 12, identifier:n; 13, identifier:c; 14, identifier:enumerate; 15, argument_list; 16, expression_statement; 17, if_statement; 18, identifier:polylines; 19, assignment; 20, comparison_operator:l > 2; 21, comment:# DEFINE FIRST AND LAST INDEX A THOSE TWO POINTS THAT; 22, comment:# HAVE THE BIGGEST DIFFERENCE FROM A MIDDLE:; 23, block; 24, identifier:l; 25, call; 26, identifier:l; 27, integer:2; 28, expression_statement; 29, expression_statement; 30, expression_statement; 31, expression_statement; 32, expression_statement; 33, expression_statement; 34, expression_statement; 35, expression_statement; 36, expression_statement; 37, expression_statement; 38, expression_statement; 39, identifier:len; 40, argument_list; 41, assignment; 42, assignment; 43, assignment; 44, assignment; 45, assignment; 46, assignment; 47, assignment; 48, assignment; 49, assignment; 50, assignment; 51, assignment; 52, identifier:c; 53, identifier:mid; 54, call; 55, identifier:distV; 56, parenthesized_expression; 57, identifier:dists; 58, call; 59, identifier:firstI; 60, call; 61, identifier:sign; 62, call; 63, identifier:dd; 64, call; 65, subscript; 66, integer:0; 67, identifier:lastI; 68, call; 69, identifier:ind; 70, call; 71, identifier:c; 72, subscript; 73, subscript; 74, identifier:c; 75, attribute; 76, argument_list; 77, binary_operator:c - mid; 78, identifier:norm; 79, argument_list; 80, attribute; 81, argument_list; 82, attribute; 83, argument_list; 84, attribute; 85, argument_list; 86, identifier:dists; 87, unary_operator; 88, attribute; 89, argument_list; 90, identifier:_sort; 91, argument_list; 92, identifier:c; 93, identifier:ind; 94, identifier:polylines; 95, identifier:n; 96, identifier:c; 97, identifier:mean; 98, keyword_argument; 99, identifier:c; 100, identifier:mid; 101, identifier:distV; 102, keyword_argument; 103, identifier:np; 104, identifier:argmax; 105, identifier:dists; 106, identifier:np; 107, identifier:sign; 108, subscript; 109, identifier:np; 110, identifier:logical_or; 111, comparison_operator:np.sign(distV[:, 0]) != sign[0]; 112, comparison_operator:np.sign(distV[:, 1]) != sign[1]; 113, identifier:dd; 114, identifier:np; 115, identifier:argmax; 116, identifier:dists; 117, identifier:c; 118, identifier:firstI; 119, identifier:lastI; 120, identifier:axis; 121, integer:0; 122, identifier:axis; 123, unary_operator; 124, identifier:distV; 125, identifier:firstI; 126, call; 127, subscript; 128, call; 129, subscript; 130, integer:1; 131, attribute; 132, argument_list; 133, identifier:sign; 134, integer:0; 135, attribute; 136, argument_list; 137, identifier:sign; 138, integer:1; 139, identifier:np; 140, identifier:sign; 141, subscript; 142, identifier:np; 143, identifier:sign; 144, subscript; 145, identifier:distV; 146, slice; 147, integer:0; 148, identifier:distV; 149, slice; 150, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 7, 10; 7, 11; 9, 12; 9, 13; 10, 14; 10, 15; 11, 16; 11, 17; 15, 18; 16, 19; 17, 20; 17, 21; 17, 22; 17, 23; 19, 24; 19, 25; 20, 26; 20, 27; 23, 28; 23, 29; 23, 30; 23, 31; 23, 32; 23, 33; 23, 34; 23, 35; 23, 36; 23, 37; 23, 38; 25, 39; 25, 40; 28, 41; 29, 42; 30, 43; 31, 44; 32, 45; 33, 46; 34, 47; 35, 48; 36, 49; 37, 50; 38, 51; 40, 52; 41, 53; 41, 54; 42, 55; 42, 56; 43, 57; 43, 58; 44, 59; 44, 60; 45, 61; 45, 62; 46, 63; 46, 64; 47, 65; 47, 66; 48, 67; 48, 68; 49, 69; 49, 70; 50, 71; 50, 72; 51, 73; 51, 74; 54, 75; 54, 76; 56, 77; 58, 78; 58, 79; 60, 80; 60, 81; 62, 82; 62, 83; 64, 84; 64, 85; 65, 86; 65, 87; 68, 88; 68, 89; 70, 90; 70, 91; 72, 92; 72, 93; 73, 94; 73, 95; 75, 96; 75, 97; 76, 98; 77, 99; 77, 100; 79, 101; 79, 102; 80, 103; 80, 104; 81, 105; 82, 106; 82, 107; 83, 108; 84, 109; 84, 110; 85, 111; 85, 112; 87, 113; 88, 114; 88, 115; 89, 116; 91, 117; 91, 118; 91, 119; 98, 120; 98, 121; 102, 122; 102, 123; 108, 124; 108, 125; 111, 126; 111, 127; 112, 128; 112, 129; 123, 130; 126, 131; 126, 132; 127, 133; 127, 134; 128, 135; 128, 136; 129, 137; 129, 138; 131, 139; 131, 140; 132, 141; 135, 142; 135, 143; 136, 144; 141, 145; 141, 146; 141, 147; 144, 148; 144, 149; 144, 150 | def sort(polylines):
"""
sort points within polyline
p0-p1-p2...
"""
for n, c in enumerate(polylines):
l = len(c)
if l > 2:
# DEFINE FIRST AND LAST INDEX A THOSE TWO POINTS THAT
# HAVE THE BIGGEST DIFFERENCE FROM A MIDDLE:
mid = c.mean(axis=0)
distV = (c - mid)
dists = norm(distV, axis=-1)
firstI = np.argmax(dists)
sign = np.sign(distV[firstI])
dd = np.logical_or(np.sign(distV[:, 0]) != sign[0],
np.sign(distV[:, 1]) != sign[1])
dists[~dd] = 0
lastI = np.argmax(dists)
ind = _sort(c, firstI, lastI)
c = c[ind]
polylines[n] = c |
0, module; 1, function_definition; 2, function_name:get_queryset; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, comment:"""Query for the most voted messages sorting by the sum of
voted and after by date."""; 12, assignment; 13, assignment; 14, assignment; 15, call; 16, identifier:queryset; 17, call; 18, identifier:sql; 19, comment:"""
SELECT
count(sav.id)
FROM
colab_superarchives_vote AS sav
WHERE
colab_superarchives_message.id = sav.message_id
"""; 20, identifier:messages; 21, call; 22, attribute; 23, argument_list; 24, attribute; 25, argument_list; 26, attribute; 27, argument_list; 28, identifier:messages; 29, identifier:order_by; 30, string; 31, string; 32, call; 33, identifier:get_queryset; 34, identifier:queryset; 35, identifier:extra; 36, keyword_argument; 37, string_content:-vote_count; 38, string_content:received_time; 39, identifier:super; 40, argument_list; 41, identifier:select; 42, dictionary; 43, identifier:MostVotedManager; 44, identifier:self; 45, pair; 46, string; 47, identifier:sql; 48, string_content:vote_count | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 10, 15; 12, 16; 12, 17; 13, 18; 13, 19; 14, 20; 14, 21; 15, 22; 15, 23; 17, 24; 17, 25; 21, 26; 21, 27; 22, 28; 22, 29; 23, 30; 23, 31; 24, 32; 24, 33; 26, 34; 26, 35; 27, 36; 30, 37; 31, 38; 32, 39; 32, 40; 36, 41; 36, 42; 40, 43; 40, 44; 42, 45; 45, 46; 45, 47; 46, 48 | def get_queryset(self):
"""Query for the most voted messages sorting by the sum of
voted and after by date."""
queryset = super(MostVotedManager, self).get_queryset()
sql = """
SELECT
count(sav.id)
FROM
colab_superarchives_vote AS sav
WHERE
colab_superarchives_message.id = sav.message_id
"""
messages = queryset.extra(
select={
'vote_count': sql,
}
)
return messages.order_by('-vote_count', 'received_time') |
0, module; 1, function_definition; 2, function_name:deleteByOrigIndex; 3, parameters; 4, block; 5, identifier:self; 6, identifier:index; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, for_statement; 11, expression_statement; 12, expression_statement; 13, return_statement; 14, comment:"""Removes a single entry from the list given the index reference.
The index, in this instance, is a reference to the *original* list
indexing as seen when the list was first inserted into PLOD.
An example:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "wigs": 68 },
... {"name": "Larry", "age": 18, "wigs": [3, 2, 9]},
... {"name": "Joe", "age": 20, "income": 15000, "wigs": [1, 2, 3]},
... {"name": "Bill", "age": 19, "income": 29000 },
... ]
>>> myPLOD = PLOD(test)
>>> print myPLOD.sort("name").returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
>>> print myPLOD.deleteByOrigIndex(0).returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
As you can see in the example, the list was sorted by 'name', which
placed 'Bill' as the first entry. Yet, when the deleteByOrigIndex was
passed a zero (for the first entry), it removed 'Jim' instead since
it was the original first entry.
:param index:
An integer representing the place of entry in the original list
of dictionaries.
:return:
self
"""; 15, assignment; 16, assignment; 17, pattern_list; 18, call; 19, block; 20, assignment; 21, assignment; 22, identifier:self; 23, identifier:result; 24, list; 25, identifier:result_tracker; 26, list; 27, identifier:counter; 28, identifier:row; 29, identifier:enumerate; 30, argument_list; 31, if_statement; 32, attribute; 33, identifier:result; 34, attribute; 35, identifier:result_tracker; 36, attribute; 37, comparison_operator:self.index_track[counter] != index; 38, block; 39, identifier:self; 40, identifier:table; 41, identifier:self; 42, identifier:index_track; 43, identifier:self; 44, identifier:table; 45, subscript; 46, identifier:index; 47, expression_statement; 48, expression_statement; 49, attribute; 50, identifier:counter; 51, call; 52, call; 53, identifier:self; 54, identifier:index_track; 55, attribute; 56, argument_list; 57, attribute; 58, argument_list; 59, identifier:result; 60, identifier:append; 61, identifier:row; 62, identifier:result_tracker; 63, identifier:append; 64, subscript; 65, attribute; 66, identifier:counter; 67, identifier:self; 68, identifier:index_track | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 8, 15; 9, 16; 10, 17; 10, 18; 10, 19; 11, 20; 12, 21; 13, 22; 15, 23; 15, 24; 16, 25; 16, 26; 17, 27; 17, 28; 18, 29; 18, 30; 19, 31; 20, 32; 20, 33; 21, 34; 21, 35; 30, 36; 31, 37; 31, 38; 32, 39; 32, 40; 34, 41; 34, 42; 36, 43; 36, 44; 37, 45; 37, 46; 38, 47; 38, 48; 45, 49; 45, 50; 47, 51; 48, 52; 49, 53; 49, 54; 51, 55; 51, 56; 52, 57; 52, 58; 55, 59; 55, 60; 56, 61; 57, 62; 57, 63; 58, 64; 64, 65; 64, 66; 65, 67; 65, 68 | def deleteByOrigIndex(self, index):
"""Removes a single entry from the list given the index reference.
The index, in this instance, is a reference to the *original* list
indexing as seen when the list was first inserted into PLOD.
An example:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "wigs": 68 },
... {"name": "Larry", "age": 18, "wigs": [3, 2, 9]},
... {"name": "Joe", "age": 20, "income": 15000, "wigs": [1, 2, 3]},
... {"name": "Bill", "age": 19, "income": 29000 },
... ]
>>> myPLOD = PLOD(test)
>>> print myPLOD.sort("name").returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
>>> print myPLOD.deleteByOrigIndex(0).returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
As you can see in the example, the list was sorted by 'name', which
placed 'Bill' as the first entry. Yet, when the deleteByOrigIndex was
passed a zero (for the first entry), it removed 'Jim' instead since
it was the original first entry.
:param index:
An integer representing the place of entry in the original list
of dictionaries.
:return:
self
"""
result = []
result_tracker = []
for counter, row in enumerate(self.table):
if self.index_track[counter] != index:
result.append(row)
result_tracker.append(self.index_track[counter])
self.table = result
self.index_track = result_tracker
return self |
0, module; 1, function_definition; 2, function_name:deleteByOrigIndexList; 3, parameters; 4, block; 5, identifier:self; 6, identifier:indexList; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, expression_statement; 14, return_statement; 15, comment:"""Remove entries from the list given the index references.
The index, in this instance, is a reference to the *original* list
indexing as seen when the list was first inserted into PLOD.
An example:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "wigs": 68 },
... {"name": "Larry", "age": 18, "wigs": [3, 2, 9]},
... {"name": "Joe", "age": 20, "income": 15000, "wigs": [1, 2, 3]},
... {"name": "Bill", "age": 19, "income": 29000 },
... ]
>>> myPLOD = PLOD(test)
>>> print myPLOD.sort("name").returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
>>> listA = [0, 1]
>>> print myPLOD.deleteByOrigIndexList(listA).returnString()
[
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
As you can see in the example, the list was sorted by 'name', which
rearranged the entries. Yet, when the deleteByOrigIndexList was
passed a [0, 1] (for the first and second entries), it removed 'Jim'
and "Larry" since those were the original first and second entries.
:param indexList:
A list of integer representing the places of entry in the original
list of dictionaries.
:return:
self
"""; 16, assignment; 17, assignment; 18, assignment; 19, identifier:row; 20, attribute; 21, block; 22, assignment; 23, assignment; 24, identifier:self; 25, identifier:result; 26, list; 27, identifier:result_tracker; 28, list; 29, identifier:counter; 30, integer:0; 31, identifier:self; 32, identifier:table; 33, if_statement; 34, expression_statement; 35, attribute; 36, identifier:result; 37, attribute; 38, identifier:result_tracker; 39, not_operator; 40, block; 41, augmented_assignment; 42, identifier:self; 43, identifier:table; 44, identifier:self; 45, identifier:index_track; 46, comparison_operator:counter in indexList; 47, expression_statement; 48, expression_statement; 49, identifier:counter; 50, integer:1; 51, identifier:counter; 52, identifier:indexList; 53, call; 54, call; 55, attribute; 56, argument_list; 57, attribute; 58, argument_list; 59, identifier:result; 60, identifier:append; 61, identifier:row; 62, identifier:result_tracker; 63, identifier:append; 64, subscript; 65, attribute; 66, identifier:counter; 67, identifier:self; 68, identifier:index_track | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 11, 20; 11, 21; 12, 22; 13, 23; 14, 24; 16, 25; 16, 26; 17, 27; 17, 28; 18, 29; 18, 30; 20, 31; 20, 32; 21, 33; 21, 34; 22, 35; 22, 36; 23, 37; 23, 38; 33, 39; 33, 40; 34, 41; 35, 42; 35, 43; 37, 44; 37, 45; 39, 46; 40, 47; 40, 48; 41, 49; 41, 50; 46, 51; 46, 52; 47, 53; 48, 54; 53, 55; 53, 56; 54, 57; 54, 58; 55, 59; 55, 60; 56, 61; 57, 62; 57, 63; 58, 64; 64, 65; 64, 66; 65, 67; 65, 68 | def deleteByOrigIndexList(self, indexList):
"""Remove entries from the list given the index references.
The index, in this instance, is a reference to the *original* list
indexing as seen when the list was first inserted into PLOD.
An example:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "wigs": 68 },
... {"name": "Larry", "age": 18, "wigs": [3, 2, 9]},
... {"name": "Joe", "age": 20, "income": 15000, "wigs": [1, 2, 3]},
... {"name": "Bill", "age": 19, "income": 29000 },
... ]
>>> myPLOD = PLOD(test)
>>> print myPLOD.sort("name").returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
>>> listA = [0, 1]
>>> print myPLOD.deleteByOrigIndexList(listA).returnString()
[
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
As you can see in the example, the list was sorted by 'name', which
rearranged the entries. Yet, when the deleteByOrigIndexList was
passed a [0, 1] (for the first and second entries), it removed 'Jim'
and "Larry" since those were the original first and second entries.
:param indexList:
A list of integer representing the places of entry in the original
list of dictionaries.
:return:
self
"""
result = []
result_tracker = []
counter = 0
for row in self.table:
if not counter in indexList:
result.append(row)
result_tracker.append(self.index_track[counter])
counter += 1
self.table = result
self.index_track = result_tracker
return self |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, identifier:key; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, for_statement; 11, return_statement; 12, identifier:reverse; 13, False; 14, identifier:none_greater; 15, False; 16, string:'''Sort the list in the order of the dictionary key.
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "wigs": 68 },
... {"name": "Larry", "age": 18, "wigs": [3, 2, 9]},
... {"name": "Joe", "age": 20, "income": 15000, "wigs": [1, 2, 3]},
... {"name": "Bill", "age": 19, "income": 29000 },
... ]
>>> print PLOD(test).sort("name").returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
>>> print PLOD(test).sort("income").returnString()
[
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68}
]
>>> print PLOD(test).sort(["age", "income"]).returnString()
[
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]},
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]}
]
.. versionadded:: 0.0.2
:param key:
A dictionary key (or a list of keys) that should be the
basis of the sorting.
:param reverse:
Defaults to False. If True, then list is sorted decrementally.
:param none_greater:
Defaults to False. If True, then entries missing the key/value
pair are considered be of greater value than the non-missing values.
:returns: self
'''; 17, identifier:i; 18, call; 19, block; 20, identifier:self; 21, identifier:range; 22, argument_list; 23, expression_statement; 24, for_statement; 25, if_statement; 26, integer:0; 27, call; 28, assignment; 29, identifier:j; 30, call; 31, block; 32, comparison_operator:i!=min; 33, block; 34, identifier:len; 35, argument_list; 36, identifier:min; 37, identifier:i; 38, identifier:range; 39, argument_list; 40, if_statement; 41, identifier:i; 42, identifier:min; 43, expression_statement; 44, comment:# swap; 45, expression_statement; 46, comment:# swap; 47, attribute; 48, binary_operator:i + 1; 49, call; 50, call; 51, block; 52, assignment; 53, assignment; 54, identifier:self; 55, identifier:table; 56, identifier:i; 57, integer:1; 58, identifier:len; 59, argument_list; 60, attribute; 61, argument_list; 62, expression_statement; 63, pattern_list; 64, expression_list; 65, pattern_list; 66, expression_list; 67, attribute; 68, identifier:internal; 69, identifier:is_first_lessor; 70, subscript; 71, subscript; 72, identifier:key; 73, keyword_argument; 74, keyword_argument; 75, assignment; 76, subscript; 77, subscript; 78, subscript; 79, subscript; 80, subscript; 81, subscript; 82, subscript; 83, subscript; 84, identifier:self; 85, identifier:table; 86, attribute; 87, identifier:j; 88, attribute; 89, identifier:min; 90, identifier:none_greater; 91, identifier:none_greater; 92, identifier:reverse; 93, identifier:reverse; 94, identifier:min; 95, identifier:j; 96, attribute; 97, identifier:i; 98, attribute; 99, identifier:min; 100, attribute; 101, identifier:min; 102, attribute; 103, identifier:i; 104, attribute; 105, identifier:i; 106, attribute; 107, identifier:min; 108, attribute; 109, identifier:min; 110, attribute; 111, identifier:i; 112, identifier:self; 113, identifier:table; 114, identifier:self; 115, identifier:table; 116, identifier:self; 117, identifier:table; 118, identifier:self; 119, identifier:table; 120, identifier:self; 121, identifier:table; 122, identifier:self; 123, identifier:table; 124, identifier:self; 125, identifier:index_track; 126, identifier:self; 127, identifier:index_track; 128, identifier:self; 129, identifier:index_track; 130, identifier:self; 131, identifier:index_track | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 7, 12; 7, 13; 8, 14; 8, 15; 9, 16; 10, 17; 10, 18; 10, 19; 11, 20; 18, 21; 18, 22; 19, 23; 19, 24; 19, 25; 22, 26; 22, 27; 23, 28; 24, 29; 24, 30; 24, 31; 25, 32; 25, 33; 27, 34; 27, 35; 28, 36; 28, 37; 30, 38; 30, 39; 31, 40; 32, 41; 32, 42; 33, 43; 33, 44; 33, 45; 33, 46; 35, 47; 39, 48; 39, 49; 40, 50; 40, 51; 43, 52; 45, 53; 47, 54; 47, 55; 48, 56; 48, 57; 49, 58; 49, 59; 50, 60; 50, 61; 51, 62; 52, 63; 52, 64; 53, 65; 53, 66; 59, 67; 60, 68; 60, 69; 61, 70; 61, 71; 61, 72; 61, 73; 61, 74; 62, 75; 63, 76; 63, 77; 64, 78; 64, 79; 65, 80; 65, 81; 66, 82; 66, 83; 67, 84; 67, 85; 70, 86; 70, 87; 71, 88; 71, 89; 73, 90; 73, 91; 74, 92; 74, 93; 75, 94; 75, 95; 76, 96; 76, 97; 77, 98; 77, 99; 78, 100; 78, 101; 79, 102; 79, 103; 80, 104; 80, 105; 81, 106; 81, 107; 82, 108; 82, 109; 83, 110; 83, 111; 86, 112; 86, 113; 88, 114; 88, 115; 96, 116; 96, 117; 98, 118; 98, 119; 100, 120; 100, 121; 102, 122; 102, 123; 104, 124; 104, 125; 106, 126; 106, 127; 108, 128; 108, 129; 110, 130; 110, 131 | def sort(self, key, reverse=False, none_greater=False):
'''Sort the list in the order of the dictionary key.
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "wigs": 68 },
... {"name": "Larry", "age": 18, "wigs": [3, 2, 9]},
... {"name": "Joe", "age": 20, "income": 15000, "wigs": [1, 2, 3]},
... {"name": "Bill", "age": 19, "income": 29000 },
... ]
>>> print PLOD(test).sort("name").returnString()
[
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
]
>>> print PLOD(test).sort("income").returnString()
[
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]},
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]},
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 18, income: 93000, name: 'Jim' , wigs: 68}
]
>>> print PLOD(test).sort(["age", "income"]).returnString()
[
{age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]},
{age: 18, income: 93000, name: 'Jim' , wigs: 68},
{age: 19, income: 29000, name: 'Bill' , wigs: None },
{age: 20, income: 15000, name: 'Joe' , wigs: [1, 2, 3]}
]
.. versionadded:: 0.0.2
:param key:
A dictionary key (or a list of keys) that should be the
basis of the sorting.
:param reverse:
Defaults to False. If True, then list is sorted decrementally.
:param none_greater:
Defaults to False. If True, then entries missing the key/value
pair are considered be of greater value than the non-missing values.
:returns: self
'''
for i in range(0, len(self.table)):
min = i
for j in range(i + 1, len(self.table)):
if internal.is_first_lessor(self.table[j], self.table[min], key, none_greater=none_greater, reverse=reverse):
min = j
if i!=min:
self.table[i], self.table[min] = self.table[min], self.table[i] # swap
self.index_track[i], self.index_track[min] = self.index_track[min], self.index_track[i] # swap
return self |
0, module; 1, function_definition; 2, function_name:returnIndexList; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, for_statement; 11, return_statement; 12, identifier:limit; 13, False; 14, string:'''Return a list of integers that are list-index references to the
original list of dictionaries."
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "order": 2},
... {"name": "Larry", "age": 18, "order": 3},
... {"name": "Joe", "age": 20, "income": 15000, "order": 1},
... {"name": "Bill", "age": 19, "income": 29000, "order": 4},
... ]
>>> print PLOD(test).returnIndexList()
[0, 1, 2, 3]
>>> print PLOD(test).sort("name").returnIndexList()
[3, 0, 2, 1]
:param limit:
A number limiting the quantity of entries to return. Defaults to
False, which means that the full list is returned.
:return:
A list of integers representing the original indices.
'''; 15, comparison_operator:limit==False; 16, block; 17, assignment; 18, identifier:i; 19, call; 20, block; 21, identifier:result; 22, identifier:limit; 23, False; 24, return_statement; 25, identifier:result; 26, list; 27, identifier:range; 28, argument_list; 29, if_statement; 30, attribute; 31, identifier:limit; 32, comparison_operator:len(self.table)>i; 33, block; 34, identifier:self; 35, identifier:index_track; 36, call; 37, identifier:i; 38, expression_statement; 39, identifier:len; 40, argument_list; 41, call; 42, attribute; 43, attribute; 44, argument_list; 45, identifier:self; 46, identifier:table; 47, identifier:result; 48, identifier:append; 49, subscript; 50, attribute; 51, identifier:i; 52, identifier:self; 53, identifier:index_track | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 8, 15; 8, 16; 9, 17; 10, 18; 10, 19; 10, 20; 11, 21; 15, 22; 15, 23; 16, 24; 17, 25; 17, 26; 19, 27; 19, 28; 20, 29; 24, 30; 28, 31; 29, 32; 29, 33; 30, 34; 30, 35; 32, 36; 32, 37; 33, 38; 36, 39; 36, 40; 38, 41; 40, 42; 41, 43; 41, 44; 42, 45; 42, 46; 43, 47; 43, 48; 44, 49; 49, 50; 49, 51; 50, 52; 50, 53 | def returnIndexList(self, limit=False):
'''Return a list of integers that are list-index references to the
original list of dictionaries."
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "order": 2},
... {"name": "Larry", "age": 18, "order": 3},
... {"name": "Joe", "age": 20, "income": 15000, "order": 1},
... {"name": "Bill", "age": 19, "income": 29000, "order": 4},
... ]
>>> print PLOD(test).returnIndexList()
[0, 1, 2, 3]
>>> print PLOD(test).sort("name").returnIndexList()
[3, 0, 2, 1]
:param limit:
A number limiting the quantity of entries to return. Defaults to
False, which means that the full list is returned.
:return:
A list of integers representing the original indices.
'''
if limit==False:
return self.index_track
result = []
for i in range(limit):
if len(self.table)>i:
result.append(self.index_track[i])
return result |
0, module; 1, function_definition; 2, function_name:returnValue; 3, parameters; 4, block; 5, identifier:self; 6, identifier:key; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, expression_statement; 12, return_statement; 13, identifier:last; 14, False; 15, string:'''Return the key's value for the first entry in the current list.
If 'last=True', then the last entry is referenced."
Returns None is the list is empty or the key is missing.
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "order": 2},
... {"name": "Larry", "age": 18, "order": 3},
... {"name": "Joe", "age": 20, "income": 15000, "order": 1},
... {"name": "Bill", "age": 19, "income": 29000, "order": 4},
... ]
>>> print PLOD(test).returnValue("name")
Jim
>>> print PLOD(test).sort("name").returnValue("name", last=True)
Larry
>>> print PLOD(test).sort("name").returnValue("income", last=True)
None
:param last:
If True, the last entry is used rather than the first.
:return:
A value, or None if the list is empty or the key is missing.
'''; 16, assignment; 17, not_operator; 18, block; 19, assignment; 20, call; 21, identifier:row; 22, call; 23, identifier:row; 24, return_statement; 25, identifier:dict_row; 26, call; 27, attribute; 28, argument_list; 29, attribute; 30, argument_list; 31, None; 32, attribute; 33, argument_list; 34, identifier:dict_row; 35, identifier:get; 36, identifier:key; 37, None; 38, identifier:self; 39, identifier:returnOneEntry; 40, keyword_argument; 41, identifier:internal; 42, identifier:convert_to_dict; 43, identifier:row; 44, identifier:last; 45, identifier:last | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 7, 14; 8, 15; 9, 16; 10, 17; 10, 18; 11, 19; 12, 20; 16, 21; 16, 22; 17, 23; 18, 24; 19, 25; 19, 26; 20, 27; 20, 28; 22, 29; 22, 30; 24, 31; 26, 32; 26, 33; 27, 34; 27, 35; 28, 36; 28, 37; 29, 38; 29, 39; 30, 40; 32, 41; 32, 42; 33, 43; 40, 44; 40, 45 | def returnValue(self, key, last=False):
'''Return the key's value for the first entry in the current list.
If 'last=True', then the last entry is referenced."
Returns None is the list is empty or the key is missing.
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "order": 2},
... {"name": "Larry", "age": 18, "order": 3},
... {"name": "Joe", "age": 20, "income": 15000, "order": 1},
... {"name": "Bill", "age": 19, "income": 29000, "order": 4},
... ]
>>> print PLOD(test).returnValue("name")
Jim
>>> print PLOD(test).sort("name").returnValue("name", last=True)
Larry
>>> print PLOD(test).sort("name").returnValue("income", last=True)
None
:param last:
If True, the last entry is used rather than the first.
:return:
A value, or None if the list is empty or the key is missing.
'''
row = self.returnOneEntry(last=last)
if not row:
return None
dict_row = internal.convert_to_dict(row)
return dict_row.get(key, None) |
0, module; 1, function_definition; 2, function_name:returnValueList; 3, parameters; 4, block; 5, identifier:self; 6, identifier:key_list; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, expression_statement; 13, for_statement; 14, return_statement; 15, identifier:last; 16, False; 17, string:'''Return a list of key values for the first entry in the current list.
If 'last=True', then the last entry is referenced."
Returns None is the list is empty. If a key is missing, then
that entry in the list is None.
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "order": 2},
... {"name": "Larry", "age": 18, "order": 3},
... {"name": "Joe", "age": 20, "income": 15000, "order": 1},
... {"name": "Bill", "age": 19, "income": 29000, "order": 4},
... ]
>>> print PLOD(test).returnValueList(["name", "income"])
['Jim', 93000]
>>> print PLOD(test).sort("name").returnValueList(["name", "income"], last=True)
['Larry', None]
:param last:
If True, the last entry is used rather than the first.
:return:
A value, or None if the list is empty.
'''; 18, assignment; 19, assignment; 20, not_operator; 21, block; 22, assignment; 23, identifier:field; 24, identifier:key_list; 25, block; 26, identifier:result; 27, identifier:result; 28, list; 29, identifier:row; 30, call; 31, identifier:row; 32, return_statement; 33, identifier:dict_row; 34, call; 35, expression_statement; 36, attribute; 37, argument_list; 38, None; 39, attribute; 40, argument_list; 41, call; 42, identifier:self; 43, identifier:returnOneEntry; 44, keyword_argument; 45, identifier:internal; 46, identifier:convert_to_dict; 47, identifier:row; 48, attribute; 49, argument_list; 50, identifier:last; 51, identifier:last; 52, identifier:result; 53, identifier:append; 54, call; 55, attribute; 56, argument_list; 57, identifier:dict_row; 58, identifier:get; 59, identifier:field; 60, None | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 7, 16; 8, 17; 9, 18; 10, 19; 11, 20; 11, 21; 12, 22; 13, 23; 13, 24; 13, 25; 14, 26; 18, 27; 18, 28; 19, 29; 19, 30; 20, 31; 21, 32; 22, 33; 22, 34; 25, 35; 30, 36; 30, 37; 32, 38; 34, 39; 34, 40; 35, 41; 36, 42; 36, 43; 37, 44; 39, 45; 39, 46; 40, 47; 41, 48; 41, 49; 44, 50; 44, 51; 48, 52; 48, 53; 49, 54; 54, 55; 54, 56; 55, 57; 55, 58; 56, 59; 56, 60 | def returnValueList(self, key_list, last=False):
'''Return a list of key values for the first entry in the current list.
If 'last=True', then the last entry is referenced."
Returns None is the list is empty. If a key is missing, then
that entry in the list is None.
Example of use:
>>> test = [
... {"name": "Jim", "age": 18, "income": 93000, "order": 2},
... {"name": "Larry", "age": 18, "order": 3},
... {"name": "Joe", "age": 20, "income": 15000, "order": 1},
... {"name": "Bill", "age": 19, "income": 29000, "order": 4},
... ]
>>> print PLOD(test).returnValueList(["name", "income"])
['Jim', 93000]
>>> print PLOD(test).sort("name").returnValueList(["name", "income"], last=True)
['Larry', None]
:param last:
If True, the last entry is used rather than the first.
:return:
A value, or None if the list is empty.
'''
result = []
row = self.returnOneEntry(last=last)
if not row:
return None
dict_row = internal.convert_to_dict(row)
for field in key_list:
result.append(dict_row.get(field, None))
return result |
0, module; 1, function_definition; 2, function_name:sort_seq_records; 3, parameters; 4, block; 5, identifier:self; 6, identifier:seq_records; 7, expression_statement; 8, for_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, for_statement; 17, return_statement; 18, comment:"""Checks that SeqExpandedRecords are sorted by gene_code and then by voucher code.
The dashes in taxon names need to be converted to underscores so the
dataset will be accepted by Biopython to do format conversions.
"""; 19, identifier:seq_record; 20, identifier:seq_records; 21, block; 22, assignment; 23, assignment; 24, call; 25, assignment; 26, assignment; 27, call; 28, assignment; 29, identifier:gene_code; 30, identifier:sorted_gene_codes; 31, block; 32, identifier:sorted_seq_records; 33, expression_statement; 34, identifier:unsorted_gene_codes; 35, call; 36, identifier:sorted_gene_codes; 37, call; 38, attribute; 39, argument_list; 40, identifier:unsorted_voucher_codes; 41, call; 42, identifier:sorted_voucher_codes; 43, call; 44, attribute; 45, argument_list; 46, identifier:sorted_seq_records; 47, list; 48, for_statement; 49, assignment; 50, identifier:set; 51, argument_list; 52, identifier:list; 53, argument_list; 54, identifier:sorted_gene_codes; 55, identifier:sort; 56, keyword_argument; 57, identifier:set; 58, argument_list; 59, identifier:list; 60, argument_list; 61, identifier:sorted_voucher_codes; 62, identifier:sort; 63, keyword_argument; 64, identifier:voucher_code; 65, identifier:sorted_voucher_codes; 66, block; 67, attribute; 68, call; 69, list_comprehension; 70, identifier:unsorted_gene_codes; 71, identifier:key; 72, lambda; 73, list_comprehension; 74, identifier:unsorted_voucher_codes; 75, identifier:key; 76, lambda; 77, for_statement; 78, identifier:seq_record; 79, identifier:voucher_code; 80, attribute; 81, argument_list; 82, attribute; 83, for_in_clause; 84, lambda_parameters; 85, call; 86, attribute; 87, for_in_clause; 88, lambda_parameters; 89, call; 90, identifier:seq_record; 91, identifier:seq_records; 92, block; 93, attribute; 94, identifier:replace; 95, string:"-"; 96, string:"_"; 97, identifier:i; 98, identifier:gene_code; 99, identifier:i; 100, identifier:seq_records; 101, identifier:x; 102, attribute; 103, argument_list; 104, identifier:i; 105, identifier:voucher_code; 106, identifier:i; 107, identifier:seq_records; 108, identifier:x; 109, attribute; 110, argument_list; 111, expression_statement; 112, if_statement; 113, identifier:seq_record; 114, identifier:voucher_code; 115, identifier:x; 116, identifier:lower; 117, identifier:x; 118, identifier:lower; 119, assignment; 120, identifier:should_be_done; 121, block; 122, identifier:should_be_done; 123, parenthesized_expression; 124, expression_statement; 125, boolean_operator; 126, call; 127, comparison_operator:seq_record.gene_code == gene_code; 128, comparison_operator:seq_record.voucher_code == voucher_code; 129, attribute; 130, argument_list; 131, attribute; 132, identifier:gene_code; 133, attribute; 134, identifier:voucher_code; 135, identifier:sorted_seq_records; 136, identifier:append; 137, identifier:seq_record; 138, identifier:seq_record; 139, identifier:gene_code; 140, identifier:seq_record; 141, identifier:voucher_code | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 7, 18; 8, 19; 8, 20; 8, 21; 9, 22; 10, 23; 11, 24; 12, 25; 13, 26; 14, 27; 15, 28; 16, 29; 16, 30; 16, 31; 17, 32; 21, 33; 22, 34; 22, 35; 23, 36; 23, 37; 24, 38; 24, 39; 25, 40; 25, 41; 26, 42; 26, 43; 27, 44; 27, 45; 28, 46; 28, 47; 31, 48; 33, 49; 35, 50; 35, 51; 37, 52; 37, 53; 38, 54; 38, 55; 39, 56; 41, 57; 41, 58; 43, 59; 43, 60; 44, 61; 44, 62; 45, 63; 48, 64; 48, 65; 48, 66; 49, 67; 49, 68; 51, 69; 53, 70; 56, 71; 56, 72; 58, 73; 60, 74; 63, 75; 63, 76; 66, 77; 67, 78; 67, 79; 68, 80; 68, 81; 69, 82; 69, 83; 72, 84; 72, 85; 73, 86; 73, 87; 76, 88; 76, 89; 77, 90; 77, 91; 77, 92; 80, 93; 80, 94; 81, 95; 81, 96; 82, 97; 82, 98; 83, 99; 83, 100; 84, 101; 85, 102; 85, 103; 86, 104; 86, 105; 87, 106; 87, 107; 88, 108; 89, 109; 89, 110; 92, 111; 92, 112; 93, 113; 93, 114; 102, 115; 102, 116; 109, 117; 109, 118; 111, 119; 112, 120; 112, 121; 119, 122; 119, 123; 121, 124; 123, 125; 124, 126; 125, 127; 125, 128; 126, 129; 126, 130; 127, 131; 127, 132; 128, 133; 128, 134; 129, 135; 129, 136; 130, 137; 131, 138; 131, 139; 133, 140; 133, 141 | def sort_seq_records(self, seq_records):
"""Checks that SeqExpandedRecords are sorted by gene_code and then by voucher code.
The dashes in taxon names need to be converted to underscores so the
dataset will be accepted by Biopython to do format conversions.
"""
for seq_record in seq_records:
seq_record.voucher_code = seq_record.voucher_code.replace("-", "_")
unsorted_gene_codes = set([i.gene_code for i in seq_records])
sorted_gene_codes = list(unsorted_gene_codes)
sorted_gene_codes.sort(key=lambda x: x.lower())
unsorted_voucher_codes = set([i.voucher_code for i in seq_records])
sorted_voucher_codes = list(unsorted_voucher_codes)
sorted_voucher_codes.sort(key=lambda x: x.lower())
sorted_seq_records = []
for gene_code in sorted_gene_codes:
for voucher_code in sorted_voucher_codes:
for seq_record in seq_records:
should_be_done = (
seq_record.gene_code == gene_code and
seq_record.voucher_code == voucher_code
)
if should_be_done:
sorted_seq_records.append(seq_record)
return sorted_seq_records |
0, module; 1, function_definition; 2, function_name:extractFromSQLFile; 3, parameters; 4, block; 5, identifier:self; 6, identifier:filePointer; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, comment:# reading file and splitting it into lines; 11, expression_statement; 12, expression_statement; 13, for_statement; 14, comment:# forming SQL statements from all lines provided; 15, expression_statement; 16, expression_statement; 17, for_statement; 18, return_statement; 19, identifier:delimiter; 20, string:";"; 21, comment:"""
Process an SQL file and extract all the queries sorted.
:param filePointer: <io.TextIOWrapper> file pointer to SQL file
:return: <list> list of queries
"""; 22, assignment; 23, assignment; 24, assignment; 25, identifier:c; 26, identifier:data; 27, block; 28, assignment; 29, assignment; 30, identifier:line; 31, identifier:dataLines; 32, comment:# ignoring comments; 33, block; 34, identifier:statements; 35, identifier:data; 36, call; 37, identifier:dataLines; 38, list; 39, identifier:dataLinesIndex; 40, integer:0; 41, if_statement; 42, if_statement; 43, identifier:statements; 44, list; 45, identifier:statementsIndex; 46, integer:0; 47, if_statement; 48, comment:# removing spaces; 49, expression_statement; 50, comment:# ignoring blank lines; 51, if_statement; 52, comment:# appending each character to it's statement until delimiter is reached; 53, for_statement; 54, attribute; 55, argument_list; 56, comparison_operator:len(dataLines) - 1 < dataLinesIndex; 57, block; 58, boolean_operator; 59, block; 60, else_clause; 61, boolean_operator; 62, block; 63, assignment; 64, comparison_operator:len(line) == 0; 65, block; 66, identifier:c; 67, identifier:line; 68, block; 69, identifier:filePointer; 70, identifier:read; 71, binary_operator:len(dataLines) - 1; 72, identifier:dataLinesIndex; 73, expression_statement; 74, boolean_operator; 75, comparison_operator:c == "\n"; 76, expression_statement; 77, block; 78, call; 79, call; 80, continue_statement; 81, identifier:line; 82, call; 83, call; 84, integer:0; 85, continue_statement; 86, if_statement; 87, expression_statement; 88, if_statement; 89, call; 90, integer:1; 91, call; 92, comparison_operator:c == "\r\n"; 93, comparison_operator:c == "\r"; 94, identifier:c; 95, string:"\n"; 96, augmented_assignment; 97, expression_statement; 98, attribute; 99, argument_list; 100, attribute; 101, argument_list; 102, attribute; 103, argument_list; 104, identifier:len; 105, argument_list; 106, comparison_operator:len(statements) - 1 < statementsIndex; 107, block; 108, assignment; 109, comparison_operator:c == delimiter; 110, block; 111, identifier:len; 112, argument_list; 113, attribute; 114, argument_list; 115, identifier:c; 116, string:"\r\n"; 117, identifier:c; 118, string:"\r"; 119, identifier:dataLinesIndex; 120, integer:1; 121, assignment; 122, identifier:line; 123, identifier:startswith; 124, string:"--"; 125, identifier:line; 126, identifier:startswith; 127, string:"#"; 128, identifier:line; 129, identifier:strip; 130, identifier:line; 131, binary_operator:len(statements) - 1; 132, identifier:statementsIndex; 133, expression_statement; 134, subscript; 135, call; 136, identifier:c; 137, identifier:delimiter; 138, expression_statement; 139, identifier:dataLines; 140, identifier:dataLines; 141, identifier:append; 142, string:""; 143, subscript; 144, call; 145, call; 146, integer:1; 147, call; 148, identifier:statements; 149, identifier:statementsIndex; 150, attribute; 151, argument_list; 152, augmented_assignment; 153, identifier:dataLines; 154, identifier:dataLinesIndex; 155, attribute; 156, argument_list; 157, identifier:len; 158, argument_list; 159, attribute; 160, argument_list; 161, string:"{}{}"; 162, identifier:format; 163, subscript; 164, identifier:c; 165, identifier:statementsIndex; 166, integer:1; 167, string:"{}{}"; 168, identifier:format; 169, subscript; 170, identifier:c; 171, identifier:statements; 172, identifier:statements; 173, identifier:append; 174, string:""; 175, identifier:statements; 176, identifier:statementsIndex; 177, identifier:dataLines; 178, identifier:dataLinesIndex | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 7, 19; 7, 20; 8, 21; 9, 22; 11, 23; 12, 24; 13, 25; 13, 26; 13, 27; 15, 28; 16, 29; 17, 30; 17, 31; 17, 32; 17, 33; 18, 34; 22, 35; 22, 36; 23, 37; 23, 38; 24, 39; 24, 40; 27, 41; 27, 42; 28, 43; 28, 44; 29, 45; 29, 46; 33, 47; 33, 48; 33, 49; 33, 50; 33, 51; 33, 52; 33, 53; 36, 54; 36, 55; 41, 56; 41, 57; 42, 58; 42, 59; 42, 60; 47, 61; 47, 62; 49, 63; 51, 64; 51, 65; 53, 66; 53, 67; 53, 68; 54, 69; 54, 70; 56, 71; 56, 72; 57, 73; 58, 74; 58, 75; 59, 76; 60, 77; 61, 78; 61, 79; 62, 80; 63, 81; 63, 82; 64, 83; 64, 84; 65, 85; 68, 86; 68, 87; 68, 88; 71, 89; 71, 90; 73, 91; 74, 92; 74, 93; 75, 94; 75, 95; 76, 96; 77, 97; 78, 98; 78, 99; 79, 100; 79, 101; 82, 102; 82, 103; 83, 104; 83, 105; 86, 106; 86, 107; 87, 108; 88, 109; 88, 110; 89, 111; 89, 112; 91, 113; 91, 114; 92, 115; 92, 116; 93, 117; 93, 118; 96, 119; 96, 120; 97, 121; 98, 122; 98, 123; 99, 124; 100, 125; 100, 126; 101, 127; 102, 128; 102, 129; 105, 130; 106, 131; 106, 132; 107, 133; 108, 134; 108, 135; 109, 136; 109, 137; 110, 138; 112, 139; 113, 140; 113, 141; 114, 142; 121, 143; 121, 144; 131, 145; 131, 146; 133, 147; 134, 148; 134, 149; 135, 150; 135, 151; 138, 152; 143, 153; 143, 154; 144, 155; 144, 156; 145, 157; 145, 158; 147, 159; 147, 160; 150, 161; 150, 162; 151, 163; 151, 164; 152, 165; 152, 166; 155, 167; 155, 168; 156, 169; 156, 170; 158, 171; 159, 172; 159, 173; 160, 174; 163, 175; 163, 176; 169, 177; 169, 178 | def extractFromSQLFile(self, filePointer, delimiter=";"):
"""
Process an SQL file and extract all the queries sorted.
:param filePointer: <io.TextIOWrapper> file pointer to SQL file
:return: <list> list of queries
"""
data = filePointer.read()
# reading file and splitting it into lines
dataLines = []
dataLinesIndex = 0
for c in data:
if len(dataLines) - 1 < dataLinesIndex:
dataLines.append("")
if c == "\r\n" or c == "\r" or c == "\n":
dataLinesIndex += 1
else:
dataLines[dataLinesIndex] = "{}{}".format(
dataLines[dataLinesIndex],
c
)
# forming SQL statements from all lines provided
statements = []
statementsIndex = 0
for line in dataLines:
# ignoring comments
if line.startswith("--") or line.startswith("#"):
continue
# removing spaces
line = line.strip()
# ignoring blank lines
if len(line) == 0:
continue
# appending each character to it's statement until delimiter is reached
for c in line:
if len(statements) - 1 < statementsIndex:
statements.append("")
statements[statementsIndex] = "{}{}".format(
statements[statementsIndex],
c
)
if c == delimiter:
statementsIndex += 1
return statements |
0, module; 1, function_definition; 2, function_name:sort_data; 3, parameters; 4, block; 5, identifier:self; 6, identifier:data; 7, identifier:sort_key; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, return_statement; 14, identifier:reverse; 15, False; 16, comment:"""Sort dataset."""; 17, assignment; 18, assignment; 19, identifier:line; 20, identifier:lines; 21, block; 22, identifier:sorted_data; 23, identifier:sorted_data; 24, list; 25, identifier:lines; 26, call; 27, expression_statement; 28, identifier:sorted; 29, argument_list; 30, call; 31, identifier:data; 32, keyword_argument; 33, keyword_argument; 34, attribute; 35, argument_list; 36, identifier:key; 37, lambda; 38, identifier:reverse; 39, identifier:reverse; 40, identifier:sorted_data; 41, identifier:append; 42, identifier:line; 43, lambda_parameters; 44, subscript; 45, identifier:k; 46, identifier:k; 47, identifier:sort_key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 8, 14; 8, 15; 9, 16; 10, 17; 11, 18; 12, 19; 12, 20; 12, 21; 13, 22; 17, 23; 17, 24; 18, 25; 18, 26; 21, 27; 26, 28; 26, 29; 27, 30; 29, 31; 29, 32; 29, 33; 30, 34; 30, 35; 32, 36; 32, 37; 33, 38; 33, 39; 34, 40; 34, 41; 35, 42; 37, 43; 37, 44; 43, 45; 44, 46; 44, 47 | async def sort_data(self, data, sort_key, reverse=False):
"""Sort dataset."""
sorted_data = []
lines = sorted(data, key=lambda k: k[sort_key], reverse=reverse)
for line in lines:
sorted_data.append(line)
return sorted_data |
0, module; 1, function_definition; 2, function_name:get_ceiling; 3, parameters; 4, type; 5, comment:# type: ignore; 6, block; 7, typed_parameter; 8, identifier:Cloud; 9, expression_statement; 10, for_statement; 11, return_statement; 12, identifier:clouds; 13, type; 14, comment:"""
Returns ceiling layer from Cloud-List or None if none found
Assumes that the clouds are already sorted lowest to highest
Only 'Broken', 'Overcast', and 'Vertical Visibility' are considdered ceilings
Prevents errors due to lack of cloud information (eg. '' or 'FEW///')
"""; 15, identifier:cloud; 16, identifier:clouds; 17, block; 18, None; 19, list; 20, if_statement; 21, identifier:Cloud; 22, boolean_operator; 23, block; 24, attribute; 25, comparison_operator:cloud.type in ('OVC', 'BKN', 'VV'); 26, return_statement; 27, identifier:cloud; 28, identifier:altitude; 29, attribute; 30, tuple; 31, identifier:cloud; 32, identifier:cloud; 33, identifier:type; 34, string; 35, string; 36, string; 37, string_content:OVC; 38, string_content:BKN; 39, string_content:VV | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 1, 6; 3, 7; 4, 8; 6, 9; 6, 10; 6, 11; 7, 12; 7, 13; 9, 14; 10, 15; 10, 16; 10, 17; 11, 18; 13, 19; 17, 20; 19, 21; 20, 22; 20, 23; 22, 24; 22, 25; 23, 26; 24, 27; 24, 28; 25, 29; 25, 30; 26, 31; 29, 32; 29, 33; 30, 34; 30, 35; 30, 36; 34, 37; 35, 38; 36, 39 | def get_ceiling(clouds: [Cloud]) -> Cloud: # type: ignore
"""
Returns ceiling layer from Cloud-List or None if none found
Assumes that the clouds are already sorted lowest to highest
Only 'Broken', 'Overcast', and 'Vertical Visibility' are considdered ceilings
Prevents errors due to lack of cloud information (eg. '' or 'FEW///')
"""
for cloud in clouds:
if cloud.altitude and cloud.type in ('OVC', 'BKN', 'VV'):
return cloud
return None |
0, module; 1, function_definition; 2, function_name:_finish_filter; 3, parameters; 4, block; 5, identifier:self; 6, identifier:lst; 7, identifier:key; 8, identifier:include_self; 9, identifier:exclusive; 10, identifier:biggest_first; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, if_statement; 15, expression_statement; 16, expression_statement; 17, comment:# RoW in both key and lst, but not defined; only RoW remains if exclusive; 18, if_statement; 19, comment:# If RoW not resolved, make it the smallest; 20, if_statement; 21, return_statement; 22, comment:"""Finish filtering a GIS operation. Can optionally exclude the input key, sort results, and exclude overlapping results. Internal function, not normally called directly."""; 23, assignment; 24, assignment; 25, boolean_operator; 26, block; 27, call; 28, assignment; 29, boolean_operator; 30, block; 31, elif_clause; 32, boolean_operator; 33, block; 34, identifier:lst; 35, identifier:key; 36, call; 37, identifier:locations; 38, list_comprehension; 39, not_operator; 40, comparison_operator:key in locations; 41, expression_statement; 42, attribute; 43, argument_list; 44, identifier:lst; 45, list_comprehension; 46, boolean_operator; 47, identifier:exclusive; 48, return_statement; 49, identifier:exclusive; 50, block; 51, comparison_operator:'RoW' not in self; 52, comparison_operator:'RoW' in lst; 53, expression_statement; 54, attribute; 55, argument_list; 56, subscript; 57, for_in_clause; 58, identifier:include_self; 59, identifier:key; 60, identifier:locations; 61, call; 62, identifier:lst; 63, identifier:sort; 64, keyword_argument; 65, keyword_argument; 66, identifier:x; 67, for_in_clause; 68, comparison_operator:key == 'RoW'; 69, comparison_operator:'RoW' not in self; 70, conditional_expression:['RoW'] if 'RoW' in lst else []; 71, expression_statement; 72, while_statement; 73, expression_statement; 74, string; 75, identifier:self; 76, string; 77, identifier:lst; 78, assignment; 79, identifier:self; 80, identifier:_actual_key; 81, identifier:key; 82, identifier:x; 83, integer:0; 84, identifier:x; 85, identifier:lst; 86, attribute; 87, argument_list; 88, identifier:key; 89, lambda; 90, identifier:reverse; 91, identifier:biggest_first; 92, pattern_list; 93, identifier:lst; 94, identifier:key; 95, string; 96, string; 97, identifier:self; 98, list; 99, comparison_operator:'RoW' in lst; 100, list; 101, assignment; 102, identifier:lst; 103, block; 104, assignment; 105, string_content:RoW; 106, string_content:RoW; 107, subscript; 108, call; 109, identifier:lst; 110, identifier:pop; 111, call; 112, lambda_parameters; 113, subscript; 114, identifier:x; 115, identifier:y; 116, string_content:RoW; 117, string_content:RoW; 118, string; 119, string; 120, identifier:lst; 121, pattern_list; 122, expression_list; 123, expression_statement; 124, expression_statement; 125, if_statement; 126, identifier:lst; 127, identifier:remaining; 128, identifier:lst; 129, conditional_expression:-1 if biggest_first else 0; 130, attribute; 131, argument_list; 132, attribute; 133, argument_list; 134, identifier:x; 135, identifier:x; 136, integer:1; 137, string_content:RoW; 138, string_content:RoW; 139, identifier:removed; 140, identifier:remaining; 141, call; 142, list; 143, assignment; 144, assignment; 145, not_operator; 146, block; 147, unary_operator; 148, identifier:biggest_first; 149, integer:0; 150, identifier:lst; 151, identifier:pop; 152, call; 153, identifier:locations; 154, identifier:index; 155, identifier:key; 156, identifier:set; 157, argument_list; 158, identifier:current; 159, call; 160, identifier:faces; 161, subscript; 162, call; 163, expression_statement; 164, expression_statement; 165, integer:1; 166, attribute; 167, argument_list; 168, attribute; 169, argument_list; 170, identifier:self; 171, identifier:current; 172, attribute; 173, argument_list; 174, call; 175, call; 176, identifier:lst; 177, identifier:index; 178, string; 179, identifier:lst; 180, identifier:pop; 181, integer:0; 182, identifier:faces; 183, identifier:intersection; 184, identifier:removed; 185, attribute; 186, argument_list; 187, attribute; 188, argument_list; 189, string_content:RoW; 190, identifier:removed; 191, identifier:update; 192, identifier:faces; 193, identifier:remaining; 194, identifier:append; 195, identifier:current | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 11, 22; 12, 23; 13, 24; 14, 25; 14, 26; 15, 27; 16, 28; 18, 29; 18, 30; 18, 31; 20, 32; 20, 33; 21, 34; 23, 35; 23, 36; 24, 37; 24, 38; 25, 39; 25, 40; 26, 41; 27, 42; 27, 43; 28, 44; 28, 45; 29, 46; 29, 47; 30, 48; 31, 49; 31, 50; 32, 51; 32, 52; 33, 53; 36, 54; 36, 55; 38, 56; 38, 57; 39, 58; 40, 59; 40, 60; 41, 61; 42, 62; 42, 63; 43, 64; 43, 65; 45, 66; 45, 67; 46, 68; 46, 69; 48, 70; 50, 71; 50, 72; 50, 73; 51, 74; 51, 75; 52, 76; 52, 77; 53, 78; 54, 79; 54, 80; 55, 81; 56, 82; 56, 83; 57, 84; 57, 85; 61, 86; 61, 87; 64, 88; 64, 89; 65, 90; 65, 91; 67, 92; 67, 93; 68, 94; 68, 95; 69, 96; 69, 97; 70, 98; 70, 99; 70, 100; 71, 101; 72, 102; 72, 103; 73, 104; 74, 105; 76, 106; 78, 107; 78, 108; 86, 109; 86, 110; 87, 111; 89, 112; 89, 113; 92, 114; 92, 115; 95, 116; 96, 117; 98, 118; 99, 119; 99, 120; 101, 121; 101, 122; 103, 123; 103, 124; 103, 125; 104, 126; 104, 127; 107, 128; 107, 129; 108, 130; 108, 131; 111, 132; 111, 133; 112, 134; 113, 135; 113, 136; 118, 137; 119, 138; 121, 139; 121, 140; 122, 141; 122, 142; 123, 143; 124, 144; 125, 145; 125, 146; 129, 147; 129, 148; 129, 149; 130, 150; 130, 151; 131, 152; 132, 153; 132, 154; 133, 155; 141, 156; 141, 157; 143, 158; 143, 159; 144, 160; 144, 161; 145, 162; 146, 163; 146, 164; 147, 165; 152, 166; 152, 167; 159, 168; 159, 169; 161, 170; 161, 171; 162, 172; 162, 173; 163, 174; 164, 175; 166, 176; 166, 177; 167, 178; 168, 179; 168, 180; 169, 181; 172, 182; 172, 183; 173, 184; 174, 185; 174, 186; 175, 187; 175, 188; 178, 189; 185, 190; 185, 191; 186, 192; 187, 193; 187, 194; 188, 195 | def _finish_filter(self, lst, key, include_self, exclusive, biggest_first):
"""Finish filtering a GIS operation. Can optionally exclude the input key, sort results, and exclude overlapping results. Internal function, not normally called directly."""
key = self._actual_key(key)
locations = [x[0] for x in lst]
if not include_self and key in locations:
lst.pop(locations.index(key))
lst.sort(key=lambda x: x[1], reverse=biggest_first)
lst = [x for x, y in lst]
# RoW in both key and lst, but not defined; only RoW remains if exclusive
if key == 'RoW' and 'RoW' not in self and exclusive:
return ['RoW'] if 'RoW' in lst else []
elif exclusive:
removed, remaining = set(), []
while lst:
current = lst.pop(0)
faces = self[current]
if not faces.intersection(removed):
removed.update(faces)
remaining.append(current)
lst = remaining
# If RoW not resolved, make it the smallest
if 'RoW' not in self and 'RoW' in lst:
lst[-1 if biggest_first else 0] = lst.pop(lst.index('RoW'))
return lst |
0, module; 1, function_definition; 2, function_name:intersects; 3, parameters; 4, block; 5, identifier:self; 6, identifier:key; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, expression_statement; 15, expression_statement; 16, return_statement; 17, identifier:include_self; 18, False; 19, identifier:exclusive; 20, False; 21, identifier:biggest_first; 22, True; 23, identifier:only; 24, None; 25, comment:"""Get all locations that intersect this location.
Note that sorting is done by first by number of faces intersecting ``key``; the total number of faces in the intersected region is only used to break sorting ties.
If the ``resolved_row`` context manager is not used, ``RoW`` doesn't have a spatial definition, and therefore nothing intersects it. ``.intersects("RoW")`` returns a list with with ``RoW`` or nothing.
"""; 26, assignment; 27, boolean_operator; 28, block; 29, assignment; 30, assignment; 31, call; 32, identifier:possibles; 33, conditional_expression:self.topology if only is None else {k: self[k] for k in only}; 34, comparison_operator:key == 'RoW'; 35, comparison_operator:'RoW' not in self; 36, return_statement; 37, identifier:faces; 38, subscript; 39, identifier:lst; 40, list_comprehension; 41, attribute; 42, argument_list; 43, attribute; 44, comparison_operator:only is None; 45, dictionary_comprehension; 46, identifier:key; 47, string; 48, string; 49, identifier:self; 50, conditional_expression:['RoW'] if 'RoW' in possibles else []; 51, identifier:self; 52, identifier:key; 53, tuple; 54, for_in_clause; 55, if_clause; 56, identifier:self; 57, identifier:_finish_filter; 58, identifier:lst; 59, identifier:key; 60, identifier:include_self; 61, identifier:exclusive; 62, identifier:biggest_first; 63, identifier:self; 64, identifier:topology; 65, identifier:only; 66, None; 67, pair; 68, for_in_clause; 69, string_content:RoW; 70, string_content:RoW; 71, list; 72, comparison_operator:'RoW' in possibles; 73, list; 74, identifier:k; 75, tuple; 76, pattern_list; 77, call; 78, parenthesized_expression; 79, identifier:k; 80, subscript; 81, identifier:k; 82, identifier:only; 83, string; 84, string; 85, identifier:possibles; 86, call; 87, call; 88, identifier:k; 89, identifier:v; 90, attribute; 91, argument_list; 92, call; 93, identifier:self; 94, identifier:k; 95, string_content:RoW; 96, string_content:RoW; 97, identifier:len; 98, argument_list; 99, identifier:len; 100, argument_list; 101, identifier:possibles; 102, identifier:items; 103, attribute; 104, argument_list; 105, call; 106, identifier:v; 107, identifier:faces; 108, identifier:intersection; 109, identifier:v; 110, attribute; 111, argument_list; 112, identifier:v; 113, identifier:intersection; 114, identifier:faces | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 7, 17; 7, 18; 8, 19; 8, 20; 9, 21; 9, 22; 10, 23; 10, 24; 11, 25; 12, 26; 13, 27; 13, 28; 14, 29; 15, 30; 16, 31; 26, 32; 26, 33; 27, 34; 27, 35; 28, 36; 29, 37; 29, 38; 30, 39; 30, 40; 31, 41; 31, 42; 33, 43; 33, 44; 33, 45; 34, 46; 34, 47; 35, 48; 35, 49; 36, 50; 38, 51; 38, 52; 40, 53; 40, 54; 40, 55; 41, 56; 41, 57; 42, 58; 42, 59; 42, 60; 42, 61; 42, 62; 43, 63; 43, 64; 44, 65; 44, 66; 45, 67; 45, 68; 47, 69; 48, 70; 50, 71; 50, 72; 50, 73; 53, 74; 53, 75; 54, 76; 54, 77; 55, 78; 67, 79; 67, 80; 68, 81; 68, 82; 71, 83; 72, 84; 72, 85; 75, 86; 75, 87; 76, 88; 76, 89; 77, 90; 77, 91; 78, 92; 80, 93; 80, 94; 83, 95; 84, 96; 86, 97; 86, 98; 87, 99; 87, 100; 90, 101; 90, 102; 92, 103; 92, 104; 98, 105; 100, 106; 103, 107; 103, 108; 104, 109; 105, 110; 105, 111; 110, 112; 110, 113; 111, 114 | def intersects(self, key, include_self=False, exclusive=False, biggest_first=True, only=None):
"""Get all locations that intersect this location.
Note that sorting is done by first by number of faces intersecting ``key``; the total number of faces in the intersected region is only used to break sorting ties.
If the ``resolved_row`` context manager is not used, ``RoW`` doesn't have a spatial definition, and therefore nothing intersects it. ``.intersects("RoW")`` returns a list with with ``RoW`` or nothing.
"""
possibles = self.topology if only is None else {k: self[k] for k in only}
if key == 'RoW' and 'RoW' not in self:
return ['RoW'] if 'RoW' in possibles else []
faces = self[key]
lst = [
(k, (len(v.intersection(faces)), len(v)))
for k, v in possibles.items()
if (faces.intersection(v))
]
return self._finish_filter(lst, key, include_self, exclusive, biggest_first) |
0, module; 1, function_definition; 2, function_name:group_by_key_func; 3, parameters; 4, block; 5, identifier:iterable; 6, identifier:key_func; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""
Create a dictionary from an iterable such that the keys are the result of evaluating a key function on elements
of the iterable and the values are lists of elements all of which correspond to the key.
>>> def si(d): return sorted(d.items())
>>> si(group_by_key_func("a bb ccc d ee fff".split(), len))
[(1, ['a', 'd']), (2, ['bb', 'ee']), (3, ['ccc', 'fff'])]
>>> si(group_by_key_func([-1, 0, 1, 3, 6, 8, 9, 2], lambda x: x % 2))
[(0, [0, 6, 8, 2]), (1, [-1, 1, 3, 9])]
"""; 12, assignment; 13, identifier:item; 14, identifier:iterable; 15, block; 16, identifier:result; 17, identifier:result; 18, call; 19, expression_statement; 20, identifier:defaultdict; 21, argument_list; 22, call; 23, identifier:list; 24, attribute; 25, argument_list; 26, subscript; 27, identifier:append; 28, identifier:item; 29, identifier:result; 30, call; 31, identifier:key_func; 32, argument_list; 33, identifier:item | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 9, 14; 9, 15; 10, 16; 12, 17; 12, 18; 15, 19; 18, 20; 18, 21; 19, 22; 21, 23; 22, 24; 22, 25; 24, 26; 24, 27; 25, 28; 26, 29; 26, 30; 30, 31; 30, 32; 32, 33 | def group_by_key_func(iterable, key_func):
"""
Create a dictionary from an iterable such that the keys are the result of evaluating a key function on elements
of the iterable and the values are lists of elements all of which correspond to the key.
>>> def si(d): return sorted(d.items())
>>> si(group_by_key_func("a bb ccc d ee fff".split(), len))
[(1, ['a', 'd']), (2, ['bb', 'ee']), (3, ['ccc', 'fff'])]
>>> si(group_by_key_func([-1, 0, 1, 3, 6, 8, 9, 2], lambda x: x % 2))
[(0, [0, 6, 8, 2]), (1, [-1, 1, 3, 9])]
"""
result = defaultdict(list)
for item in iterable:
result[key_func(item)].append(item)
return result |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:line; 6, expression_statement; 7, expression_statement; 8, comment:# if (x0**2+y0**2)**0.5 < (x1**2+y1**2)**0.5:; 9, comment:# return (x1,y1,x0,y0); 10, comment:# return line; 11, comment:#; 12, comment:# if x1 < x0:; 13, comment:# return (x1,y1,x0,y0); 14, comment:# return line; 15, expression_statement; 16, if_statement; 17, if_statement; 18, return_statement; 19, comment:"""
change point position if x1,y0 < x0,y0
"""; 20, assignment; 21, assignment; 22, comparison_operator:abs(x1 - x0) > abs(y1 - y0); 23, block; 24, elif_clause; 25, identifier:turn; 26, block; 27, identifier:line; 28, pattern_list; 29, identifier:line; 30, identifier:turn; 31, False; 32, call; 33, call; 34, if_statement; 35, comparison_operator:y1 < y0; 36, block; 37, return_statement; 38, comment:# return line[(2,3,0,1)]; 39, identifier:x0; 40, identifier:y0; 41, identifier:x1; 42, identifier:y1; 43, identifier:abs; 44, argument_list; 45, identifier:abs; 46, argument_list; 47, comparison_operator:x1 < x0; 48, block; 49, identifier:y1; 50, identifier:y0; 51, expression_statement; 52, tuple; 53, binary_operator:x1 - x0; 54, binary_operator:y1 - y0; 55, identifier:x1; 56, identifier:x0; 57, expression_statement; 58, assignment; 59, identifier:x1; 60, identifier:y1; 61, identifier:x0; 62, identifier:y0; 63, identifier:x1; 64, identifier:x0; 65, identifier:y1; 66, identifier:y0; 67, assignment; 68, identifier:turn; 69, True; 70, identifier:turn; 71, True | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 6, 19; 7, 20; 15, 21; 16, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 20, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 23, 34; 24, 35; 24, 36; 26, 37; 26, 38; 28, 39; 28, 40; 28, 41; 28, 42; 32, 43; 32, 44; 33, 45; 33, 46; 34, 47; 34, 48; 35, 49; 35, 50; 36, 51; 37, 52; 44, 53; 46, 54; 47, 55; 47, 56; 48, 57; 51, 58; 52, 59; 52, 60; 52, 61; 52, 62; 53, 63; 53, 64; 54, 65; 54, 66; 57, 67; 58, 68; 58, 69; 67, 70; 67, 71 | def sort(line):
"""
change point position if x1,y0 < x0,y0
"""
x0, y0, x1, y1 = line
# if (x0**2+y0**2)**0.5 < (x1**2+y1**2)**0.5:
# return (x1,y1,x0,y0)
# return line
#
# if x1 < x0:
# return (x1,y1,x0,y0)
# return line
turn = False
if abs(x1 - x0) > abs(y1 - y0):
if x1 < x0:
turn = True
elif y1 < y0:
turn = True
if turn:
return (x1, y1, x0, y0)
# return line[(2,3,0,1)]
return line |
0, module; 1, function_definition; 2, function_name:vectorizable_features; 3, parameters; 4, block; 5, identifier:fcs; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, string; 10, assignment; 11, call; 12, string_content:Discovers the ordered set of vectorizable features in ``fcs``.
Returns a list of feature names, sorted lexicographically.
Feature names are only included if the corresponding
features are vectorizable (i.e., they are an instance of
:class:`collections.Mapping`).; 13, identifier:is_mapping; 14, lambda; 15, identifier:sorted; 16, argument_list; 17, lambda_parameters; 18, call; 19, call; 20, identifier:obj; 21, identifier:isinstance; 22, argument_list; 23, identifier:set; 24, argument_list; 25, identifier:obj; 26, attribute; 27, list_comprehension; 28, identifier:collections; 29, identifier:Mapping; 30, identifier:name; 31, for_in_clause; 32, for_in_clause; 33, if_clause; 34, identifier:fc; 35, identifier:fcs; 36, identifier:name; 37, identifier:fc; 38, call; 39, identifier:is_mapping; 40, argument_list; 41, subscript; 42, identifier:fc; 43, identifier:name | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 9, 12; 10, 13; 10, 14; 11, 15; 11, 16; 14, 17; 14, 18; 16, 19; 17, 20; 18, 21; 18, 22; 19, 23; 19, 24; 22, 25; 22, 26; 24, 27; 26, 28; 26, 29; 27, 30; 27, 31; 27, 32; 27, 33; 31, 34; 31, 35; 32, 36; 32, 37; 33, 38; 38, 39; 38, 40; 40, 41; 41, 42; 41, 43 | def vectorizable_features(fcs):
'''Discovers the ordered set of vectorizable features in ``fcs``.
Returns a list of feature names, sorted lexicographically.
Feature names are only included if the corresponding
features are vectorizable (i.e., they are an instance of
:class:`collections.Mapping`).
'''
is_mapping = lambda obj: isinstance(obj, collections.Mapping)
return sorted(set([name for fc in fcs for name in fc if is_mapping(fc[name])])) |
0, module; 1, function_definition; 2, function_name:extension_sort_key; 3, parameters; 4, block; 5, identifier:extension; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, comment:"""Returns the sorting key for an extension.
The sorting key can be used to sort a list of extensions
into the order that is used in the Khronos C OpenGL headers.
:param Extension extension: Extension to produce sort key for
:returns: A sorting key
"""; 11, assignment; 12, assignment; 13, conditional_expression:(0, name) if category in ('ARB', 'KHR', 'OES') else (1, name); 14, identifier:name; 15, attribute; 16, identifier:category; 17, subscript; 18, tuple; 19, comparison_operator:category in ('ARB', 'KHR', 'OES'); 20, tuple; 21, identifier:extension; 22, identifier:name; 23, call; 24, integer:1; 25, integer:0; 26, identifier:name; 27, identifier:category; 28, tuple; 29, integer:1; 30, identifier:name; 31, attribute; 32, argument_list; 33, string; 34, string; 35, string; 36, identifier:name; 37, identifier:split; 38, string; 39, integer:2; 40, string_content:ARB; 41, string_content:KHR; 42, string_content:OES; 43, string_content:_ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 9, 13; 11, 14; 11, 15; 12, 16; 12, 17; 13, 18; 13, 19; 13, 20; 15, 21; 15, 22; 17, 23; 17, 24; 18, 25; 18, 26; 19, 27; 19, 28; 20, 29; 20, 30; 23, 31; 23, 32; 28, 33; 28, 34; 28, 35; 31, 36; 31, 37; 32, 38; 32, 39; 33, 40; 34, 41; 35, 42; 38, 43 | def extension_sort_key(extension):
"""Returns the sorting key for an extension.
The sorting key can be used to sort a list of extensions
into the order that is used in the Khronos C OpenGL headers.
:param Extension extension: Extension to produce sort key for
:returns: A sorting key
"""
name = extension.name
category = name.split('_', 2)[1]
return (0, name) if category in ('ARB', 'KHR', 'OES') else (1, name) |
0, module; 1, function_definition; 2, function_name:estimate; 3, parameters; 4, block; 5, identifier:self; 6, identifier:upgrades; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""Estimate the time needed to apply upgrades.
If an upgrades does not specify and estimate it is assumed to be
in the order of 1 second.
:param upgrades: List of upgrades sorted in topological order.
"""; 12, assignment; 13, identifier:u; 14, identifier:upgrades; 15, block; 16, identifier:val; 17, identifier:val; 18, integer:0; 19, expression_statement; 20, augmented_assignment; 21, identifier:val; 22, call; 23, attribute; 24, argument_list; 25, identifier:u; 26, identifier:estimate | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 9, 14; 9, 15; 10, 16; 12, 17; 12, 18; 15, 19; 19, 20; 20, 21; 20, 22; 22, 23; 22, 24; 23, 25; 23, 26 | def estimate(self, upgrades):
"""Estimate the time needed to apply upgrades.
If an upgrades does not specify and estimate it is assumed to be
in the order of 1 second.
:param upgrades: List of upgrades sorted in topological order.
"""
val = 0
for u in upgrades:
val += u.estimate()
return val |
0, module; 1, function_definition; 2, function_name:human_estimate; 3, parameters; 4, block; 5, identifier:self; 6, identifier:upgrades; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, comment:"""Make a human readable estimated time to completion string.
:param upgrades: List of upgrades sorted in topological order.
"""; 11, assignment; 12, comparison_operator:val < 60; 13, block; 14, elif_clause; 15, elif_clause; 16, elif_clause; 17, elif_clause; 18, elif_clause; 19, elif_clause; 20, elif_clause; 21, elif_clause; 22, else_clause; 23, identifier:val; 24, call; 25, identifier:val; 26, integer:60; 27, return_statement; 28, comparison_operator:val < 300; 29, block; 30, comparison_operator:val < 600; 31, block; 32, comparison_operator:val < 1800; 33, block; 34, comparison_operator:val < 3600; 35, block; 36, comparison_operator:val < 3 * 3600; 37, block; 38, comparison_operator:val < 6 * 3600; 39, block; 40, comparison_operator:val < 12 * 3600; 41, block; 42, comparison_operator:val < 86400; 43, block; 44, block; 45, attribute; 46, argument_list; 47, string:"less than 1 minute"; 48, identifier:val; 49, integer:300; 50, return_statement; 51, identifier:val; 52, integer:600; 53, return_statement; 54, identifier:val; 55, integer:1800; 56, return_statement; 57, identifier:val; 58, integer:3600; 59, return_statement; 60, identifier:val; 61, binary_operator:3 * 3600; 62, return_statement; 63, identifier:val; 64, binary_operator:6 * 3600; 65, return_statement; 66, identifier:val; 67, binary_operator:12 * 3600; 68, return_statement; 69, identifier:val; 70, integer:86400; 71, return_statement; 72, return_statement; 73, identifier:self; 74, identifier:estimate; 75, identifier:upgrades; 76, string:"less than 5 minutes"; 77, string:"less than 10 minutes"; 78, string:"less than 30 minutes"; 79, string:"less than 1 hour"; 80, integer:3; 81, integer:3600; 82, string:"less than 3 hours"; 83, integer:6; 84, integer:3600; 85, string:"less than 6 hours"; 86, integer:12; 87, integer:3600; 88, string:"less than 12 hours"; 89, string:"less than 1 day"; 90, string:"more than 1 day" | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 7, 10; 8, 11; 9, 12; 9, 13; 9, 14; 9, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 9, 21; 9, 22; 11, 23; 11, 24; 12, 25; 12, 26; 13, 27; 14, 28; 14, 29; 15, 30; 15, 31; 16, 32; 16, 33; 17, 34; 17, 35; 18, 36; 18, 37; 19, 38; 19, 39; 20, 40; 20, 41; 21, 42; 21, 43; 22, 44; 24, 45; 24, 46; 27, 47; 28, 48; 28, 49; 29, 50; 30, 51; 30, 52; 31, 53; 32, 54; 32, 55; 33, 56; 34, 57; 34, 58; 35, 59; 36, 60; 36, 61; 37, 62; 38, 63; 38, 64; 39, 65; 40, 66; 40, 67; 41, 68; 42, 69; 42, 70; 43, 71; 44, 72; 45, 73; 45, 74; 46, 75; 50, 76; 53, 77; 56, 78; 59, 79; 61, 80; 61, 81; 62, 82; 64, 83; 64, 84; 65, 85; 67, 86; 67, 87; 68, 88; 71, 89; 72, 90 | def human_estimate(self, upgrades):
"""Make a human readable estimated time to completion string.
:param upgrades: List of upgrades sorted in topological order.
"""
val = self.estimate(upgrades)
if val < 60:
return "less than 1 minute"
elif val < 300:
return "less than 5 minutes"
elif val < 600:
return "less than 10 minutes"
elif val < 1800:
return "less than 30 minutes"
elif val < 3600:
return "less than 1 hour"
elif val < 3 * 3600:
return "less than 3 hours"
elif val < 6 * 3600:
return "less than 6 hours"
elif val < 12 * 3600:
return "less than 12 hours"
elif val < 86400:
return "less than 1 day"
else:
return "more than 1 day" |
0, module; 1, function_definition; 2, function_name:pre_upgrade_checks; 3, parameters; 4, block; 5, identifier:self; 6, identifier:upgrades; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, for_statement; 11, expression_statement; 12, expression_statement; 13, comment:"""Run upgrade pre-checks prior to applying upgrades.
Pre-checks should
in general be fast to execute. Pre-checks may the use the wait_for_user
function, to query the user for confirmation, but should respect the
--yes-i-know option to run unattended.
All pre-checks will be executed even if one fails, however if one pre-
check fails, the upgrade process will be stopped and the user warned.
:param upgrades: List of upgrades sorted in topological order.
"""; 14, assignment; 15, identifier:check; 16, attribute; 17, block; 18, identifier:u; 19, identifier:upgrades; 20, block; 21, call; 22, call; 23, identifier:errors; 24, list; 25, identifier:self; 26, identifier:global_pre_upgrade; 27, expression_statement; 28, try_statement; 29, expression_statement; 30, try_statement; 31, attribute; 32, argument_list; 33, attribute; 34, argument_list; 35, call; 36, block; 37, except_clause; 38, call; 39, block; 40, except_clause; 41, identifier:self; 42, identifier:_teardown_log_prefix; 43, identifier:self; 44, identifier:_check_errors; 45, identifier:errors; 46, concatenated_string; 47, attribute; 48, argument_list; 49, expression_statement; 50, as_pattern; 51, block; 52, attribute; 53, argument_list; 54, expression_statement; 55, as_pattern; 56, block; 57, string:"Pre-upgrade check for %s failed with the"; 58, string:" following errors:"; 59, identifier:self; 60, identifier:_setup_log_prefix; 61, keyword_argument; 62, call; 63, identifier:RuntimeError; 64, as_pattern_target; 65, expression_statement; 66, identifier:self; 67, identifier:_setup_log_prefix; 68, keyword_argument; 69, call; 70, identifier:RuntimeError; 71, as_pattern_target; 72, expression_statement; 73, identifier:plugin_id; 74, attribute; 75, identifier:check; 76, argument_list; 77, identifier:e; 78, call; 79, identifier:plugin_id; 80, attribute; 81, attribute; 82, argument_list; 83, identifier:e; 84, call; 85, identifier:check; 86, identifier:__name__; 87, attribute; 88, argument_list; 89, identifier:u; 90, identifier:name; 91, identifier:u; 92, identifier:pre_upgrade; 93, attribute; 94, argument_list; 95, identifier:errors; 96, identifier:append; 97, tuple; 98, identifier:errors; 99, identifier:append; 100, tuple; 101, attribute; 102, attribute; 103, attribute; 104, attribute; 105, identifier:check; 106, identifier:__name__; 107, identifier:e; 108, identifier:args; 109, identifier:u; 110, identifier:name; 111, identifier:e; 112, identifier:args | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 8, 14; 9, 15; 9, 16; 9, 17; 10, 18; 10, 19; 10, 20; 11, 21; 12, 22; 14, 23; 14, 24; 16, 25; 16, 26; 17, 27; 17, 28; 20, 29; 20, 30; 21, 31; 21, 32; 22, 33; 22, 34; 27, 35; 28, 36; 28, 37; 29, 38; 30, 39; 30, 40; 31, 41; 31, 42; 33, 43; 33, 44; 34, 45; 34, 46; 35, 47; 35, 48; 36, 49; 37, 50; 37, 51; 38, 52; 38, 53; 39, 54; 40, 55; 40, 56; 46, 57; 46, 58; 47, 59; 47, 60; 48, 61; 49, 62; 50, 63; 50, 64; 51, 65; 52, 66; 52, 67; 53, 68; 54, 69; 55, 70; 55, 71; 56, 72; 61, 73; 61, 74; 62, 75; 62, 76; 64, 77; 65, 78; 68, 79; 68, 80; 69, 81; 69, 82; 71, 83; 72, 84; 74, 85; 74, 86; 78, 87; 78, 88; 80, 89; 80, 90; 81, 91; 81, 92; 84, 93; 84, 94; 87, 95; 87, 96; 88, 97; 93, 98; 93, 99; 94, 100; 97, 101; 97, 102; 100, 103; 100, 104; 101, 105; 101, 106; 102, 107; 102, 108; 103, 109; 103, 110; 104, 111; 104, 112 | def pre_upgrade_checks(self, upgrades):
"""Run upgrade pre-checks prior to applying upgrades.
Pre-checks should
in general be fast to execute. Pre-checks may the use the wait_for_user
function, to query the user for confirmation, but should respect the
--yes-i-know option to run unattended.
All pre-checks will be executed even if one fails, however if one pre-
check fails, the upgrade process will be stopped and the user warned.
:param upgrades: List of upgrades sorted in topological order.
"""
errors = []
for check in self.global_pre_upgrade:
self._setup_log_prefix(plugin_id=check.__name__)
try:
check()
except RuntimeError as e:
errors.append((check.__name__, e.args))
for u in upgrades:
self._setup_log_prefix(plugin_id=u.name)
try:
u.pre_upgrade()
except RuntimeError as e:
errors.append((u.name, e.args))
self._teardown_log_prefix()
self._check_errors(errors, "Pre-upgrade check for %s failed with the"
" following errors:") |
0, module; 1, function_definition; 2, function_name:post_upgrade_checks; 3, parameters; 4, block; 5, identifier:self; 6, identifier:upgrades; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, for_statement; 11, expression_statement; 12, expression_statement; 13, comment:"""Run post-upgrade checks after applying all pending upgrades.
Post checks may be used to emit warnings encountered when applying an
upgrade, but post-checks can also be used to advice the user to run
re-indexing or similar long running processes.
Post-checks may query for user-input, but should respect the
--yes-i-know option to run in an unattended mode.
All applied upgrades post-checks are executed.
:param upgrades: List of upgrades sorted in topological order.
"""; 14, assignment; 15, identifier:u; 16, identifier:upgrades; 17, block; 18, identifier:check; 19, attribute; 20, block; 21, call; 22, call; 23, identifier:errors; 24, list; 25, expression_statement; 26, try_statement; 27, identifier:self; 28, identifier:global_post_upgrade; 29, expression_statement; 30, try_statement; 31, attribute; 32, argument_list; 33, attribute; 34, argument_list; 35, call; 36, block; 37, except_clause; 38, call; 39, block; 40, except_clause; 41, identifier:self; 42, identifier:_teardown_log_prefix; 43, identifier:self; 44, identifier:_check_errors; 45, identifier:errors; 46, concatenated_string; 47, attribute; 48, argument_list; 49, expression_statement; 50, as_pattern; 51, block; 52, attribute; 53, argument_list; 54, expression_statement; 55, as_pattern; 56, block; 57, string:"Post-upgrade check for %s failed with the "; 58, string:"following errors:"; 59, identifier:self; 60, identifier:_setup_log_prefix; 61, keyword_argument; 62, call; 63, identifier:RuntimeError; 64, as_pattern_target; 65, expression_statement; 66, identifier:self; 67, identifier:_setup_log_prefix; 68, keyword_argument; 69, call; 70, identifier:RuntimeError; 71, as_pattern_target; 72, expression_statement; 73, identifier:plugin_id; 74, attribute; 75, attribute; 76, argument_list; 77, identifier:e; 78, call; 79, identifier:plugin_id; 80, attribute; 81, identifier:check; 82, argument_list; 83, identifier:e; 84, call; 85, identifier:u; 86, identifier:name; 87, identifier:u; 88, identifier:post_upgrade; 89, attribute; 90, argument_list; 91, identifier:check; 92, identifier:__name__; 93, attribute; 94, argument_list; 95, identifier:errors; 96, identifier:append; 97, tuple; 98, identifier:errors; 99, identifier:append; 100, tuple; 101, attribute; 102, attribute; 103, attribute; 104, attribute; 105, identifier:u; 106, identifier:name; 107, identifier:e; 108, identifier:args; 109, identifier:check; 110, identifier:__name__; 111, identifier:e; 112, identifier:args | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 8, 14; 9, 15; 9, 16; 9, 17; 10, 18; 10, 19; 10, 20; 11, 21; 12, 22; 14, 23; 14, 24; 17, 25; 17, 26; 19, 27; 19, 28; 20, 29; 20, 30; 21, 31; 21, 32; 22, 33; 22, 34; 25, 35; 26, 36; 26, 37; 29, 38; 30, 39; 30, 40; 31, 41; 31, 42; 33, 43; 33, 44; 34, 45; 34, 46; 35, 47; 35, 48; 36, 49; 37, 50; 37, 51; 38, 52; 38, 53; 39, 54; 40, 55; 40, 56; 46, 57; 46, 58; 47, 59; 47, 60; 48, 61; 49, 62; 50, 63; 50, 64; 51, 65; 52, 66; 52, 67; 53, 68; 54, 69; 55, 70; 55, 71; 56, 72; 61, 73; 61, 74; 62, 75; 62, 76; 64, 77; 65, 78; 68, 79; 68, 80; 69, 81; 69, 82; 71, 83; 72, 84; 74, 85; 74, 86; 75, 87; 75, 88; 78, 89; 78, 90; 80, 91; 80, 92; 84, 93; 84, 94; 89, 95; 89, 96; 90, 97; 93, 98; 93, 99; 94, 100; 97, 101; 97, 102; 100, 103; 100, 104; 101, 105; 101, 106; 102, 107; 102, 108; 103, 109; 103, 110; 104, 111; 104, 112 | def post_upgrade_checks(self, upgrades):
"""Run post-upgrade checks after applying all pending upgrades.
Post checks may be used to emit warnings encountered when applying an
upgrade, but post-checks can also be used to advice the user to run
re-indexing or similar long running processes.
Post-checks may query for user-input, but should respect the
--yes-i-know option to run in an unattended mode.
All applied upgrades post-checks are executed.
:param upgrades: List of upgrades sorted in topological order.
"""
errors = []
for u in upgrades:
self._setup_log_prefix(plugin_id=u.name)
try:
u.post_upgrade()
except RuntimeError as e:
errors.append((u.name, e.args))
for check in self.global_post_upgrade:
self._setup_log_prefix(plugin_id=check.__name__)
try:
check()
except RuntimeError as e:
errors.append((check.__name__, e.args))
self._teardown_log_prefix()
self._check_errors(errors, "Post-upgrade check for %s failed with the "
"following errors:") |
0, module; 1, function_definition; 2, function_name:order_upgrades; 3, parameters; 4, block; 5, identifier:self; 6, identifier:upgrades; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, comment:# Removed already applied upgrades (assumes all dependencies prior to; 12, comment:# this upgrade has been applied).; 13, for_statement; 14, comment:# Check for missing dependencies; 15, for_statement; 16, comment:# Nodes with no incoming edges; 17, expression_statement; 18, expression_statement; 19, while_statement; 20, for_statement; 21, return_statement; 22, identifier:history; 23, None; 24, comment:"""Order upgrades according to their dependencies.
(topological sort using
Kahn's algorithm - http://en.wikipedia.org/wiki/Topological_sorting).
:param upgrades: Dict of upgrades
:param history: Dict of applied upgrades
"""; 25, assignment; 26, assignment; 27, identifier:node_id; 28, call; 29, block; 30, pattern_list; 31, call; 32, block; 33, assignment; 34, assignment; 35, identifier:start_nodes; 36, comment:# Append node_n to list (it has no incoming edges); 37, block; 38, pattern_list; 39, call; 40, block; 41, call; 42, identifier:history; 43, boolean_operator; 44, pattern_list; 45, call; 46, attribute; 47, argument_list; 48, expression_statement; 49, while_statement; 50, identifier:node_id; 51, identifier:depends_on; 52, attribute; 53, argument_list; 54, for_statement; 55, identifier:start_nodes; 56, list_comprehension; 57, identifier:topo_order; 58, list; 59, expression_statement; 60, expression_statement; 61, comment:# For each node m with and edge from n to m; 62, for_statement; 63, identifier:node; 64, identifier:edges; 65, attribute; 66, argument_list; 67, if_statement; 68, identifier:map; 69, argument_list; 70, identifier:history; 71, dictionary; 72, identifier:graph_incoming; 73, identifier:graph_outgoing; 74, attribute; 75, argument_list; 76, identifier:six; 77, identifier:iterkeys; 78, identifier:history; 79, assignment; 80, identifier:start_nodes; 81, block; 82, identifier:six; 83, identifier:iteritems; 84, identifier:graph_incoming; 85, identifier:d; 86, identifier:depends_on; 87, block; 88, identifier:x; 89, for_in_clause; 90, if_clause; 91, assignment; 92, call; 93, identifier:node_m; 94, subscript; 95, comment:# Remove the edge n to m; 96, block; 97, identifier:six; 98, identifier:iteritems; 99, identifier:graph_incoming; 100, identifier:edges; 101, block; 102, lambda; 103, identifier:topo_order; 104, identifier:self; 105, identifier:_create_graph; 106, identifier:upgrades; 107, identifier:history; 108, identifier:start_nodes; 109, list; 110, expression_statement; 111, comment:# Remove from direct dependents; 112, try_statement; 113, comment:# Remove all prior dependencies; 114, if_statement; 115, if_statement; 116, identifier:x; 117, call; 118, comparison_operator:len(graph_incoming[x]) == 0; 119, identifier:node_n; 120, call; 121, attribute; 122, argument_list; 123, identifier:graph_outgoing; 124, identifier:node_n; 125, expression_statement; 126, comment:# If m has no incoming edges, add it to start_nodes.; 127, if_statement; 128, raise_statement; 129, lambda_parameters; 130, subscript; 131, identifier:node_id; 132, assignment; 133, block; 134, except_clause; 135, comparison_operator:node in graph_incoming; 136, comment:# Get dependencies, remove node, and recursively; 137, comment:# remove all dependencies.; 138, block; 139, comparison_operator:d not in graph_incoming; 140, block; 141, attribute; 142, argument_list; 143, call; 144, integer:0; 145, attribute; 146, argument_list; 147, identifier:topo_order; 148, identifier:append; 149, identifier:node_n; 150, assignment; 151, not_operator; 152, block; 153, call; 154, identifier:x; 155, identifier:upgrades; 156, identifier:x; 157, identifier:node; 158, call; 159, for_statement; 160, identifier:KeyError; 161, block; 162, identifier:node; 163, identifier:graph_incoming; 164, expression_statement; 165, comment:# Add dependencies to check; 166, for_statement; 167, delete_statement; 168, identifier:d; 169, identifier:graph_incoming; 170, raise_statement; 171, identifier:six; 172, identifier:iterkeys; 173, identifier:graph_incoming; 174, identifier:len; 175, argument_list; 176, identifier:start_nodes; 177, identifier:pop; 178, subscript; 179, list_comprehension; 180, subscript; 181, expression_statement; 182, identifier:RuntimeError; 183, argument_list; 184, attribute; 185, argument_list; 186, identifier:d; 187, subscript; 188, block; 189, expression_statement; 190, assignment; 191, identifier:d; 192, identifier:depends_on; 193, block; 194, subscript; 195, call; 196, subscript; 197, identifier:graph_incoming; 198, identifier:node_m; 199, identifier:x; 200, for_in_clause; 201, if_clause; 202, identifier:graph_incoming; 203, identifier:node_m; 204, call; 205, binary_operator:"The upgrades have at least one cyclic "
"dependency involving %s." % node; 206, identifier:start_nodes; 207, identifier:pop; 208, identifier:graph_outgoing; 209, identifier:node; 210, expression_statement; 211, call; 212, identifier:depends_on; 213, subscript; 214, expression_statement; 215, expression_statement; 216, identifier:graph_incoming; 217, identifier:node; 218, identifier:RuntimeError; 219, argument_list; 220, identifier:graph_incoming; 221, identifier:x; 222, identifier:x; 223, subscript; 224, comparison_operator:x != node_n; 225, attribute; 226, argument_list; 227, concatenated_string; 228, identifier:node; 229, assignment; 230, attribute; 231, argument_list; 232, identifier:graph_incoming; 233, identifier:node; 234, assignment; 235, call; 236, binary_operator:"Upgrade %s depends on an unknown"
" upgrade %s" % (node_id, d); 237, identifier:graph_incoming; 238, identifier:node_m; 239, identifier:x; 240, identifier:node_n; 241, identifier:start_nodes; 242, identifier:append; 243, identifier:node_m; 244, string:"The upgrades have at least one cyclic "; 245, string:"dependency involving %s."; 246, subscript; 247, list_comprehension; 248, identifier:warnings; 249, identifier:warn; 250, binary_operator:"Ghost upgrade %s detected" % node; 251, subscript; 252, list_comprehension; 253, attribute; 254, argument_list; 255, concatenated_string; 256, tuple; 257, identifier:graph_incoming; 258, identifier:d; 259, identifier:x; 260, for_in_clause; 261, if_clause; 262, string:"Ghost upgrade %s detected"; 263, identifier:node; 264, identifier:graph_outgoing; 265, identifier:d; 266, identifier:x; 267, for_in_clause; 268, if_clause; 269, identifier:start_nodes; 270, identifier:append; 271, identifier:d; 272, string:"Upgrade %s depends on an unknown"; 273, string:" upgrade %s"; 274, identifier:node_id; 275, identifier:d; 276, identifier:x; 277, subscript; 278, comparison_operator:x != node; 279, identifier:x; 280, subscript; 281, comparison_operator:x != node; 282, identifier:graph_incoming; 283, identifier:d; 284, identifier:x; 285, identifier:node; 286, identifier:graph_outgoing; 287, identifier:d; 288, identifier:x; 289, identifier:node | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 7, 22; 7, 23; 8, 24; 9, 25; 10, 26; 13, 27; 13, 28; 13, 29; 15, 30; 15, 31; 15, 32; 17, 33; 18, 34; 19, 35; 19, 36; 19, 37; 20, 38; 20, 39; 20, 40; 21, 41; 25, 42; 25, 43; 26, 44; 26, 45; 28, 46; 28, 47; 29, 48; 29, 49; 30, 50; 30, 51; 31, 52; 31, 53; 32, 54; 33, 55; 33, 56; 34, 57; 34, 58; 37, 59; 37, 60; 37, 61; 37, 62; 38, 63; 38, 64; 39, 65; 39, 66; 40, 67; 41, 68; 41, 69; 43, 70; 43, 71; 44, 72; 44, 73; 45, 74; 45, 75; 46, 76; 46, 77; 47, 78; 48, 79; 49, 80; 49, 81; 52, 82; 52, 83; 53, 84; 54, 85; 54, 86; 54, 87; 56, 88; 56, 89; 56, 90; 59, 91; 60, 92; 62, 93; 62, 94; 62, 95; 62, 96; 65, 97; 65, 98; 66, 99; 67, 100; 67, 101; 69, 102; 69, 103; 74, 104; 74, 105; 75, 106; 75, 107; 79, 108; 79, 109; 81, 110; 81, 111; 81, 112; 81, 113; 81, 114; 87, 115; 89, 116; 89, 117; 90, 118; 91, 119; 91, 120; 92, 121; 92, 122; 94, 123; 94, 124; 96, 125; 96, 126; 96, 127; 101, 128; 102, 129; 102, 130; 109, 131; 110, 132; 112, 133; 112, 134; 114, 135; 114, 136; 114, 137; 114, 138; 115, 139; 115, 140; 117, 141; 117, 142; 118, 143; 118, 144; 120, 145; 120, 146; 121, 147; 121, 148; 122, 149; 125, 150; 127, 151; 127, 152; 128, 153; 129, 154; 130, 155; 130, 156; 132, 157; 132, 158; 133, 159; 134, 160; 134, 161; 135, 162; 135, 163; 138, 164; 138, 165; 138, 166; 138, 167; 139, 168; 139, 169; 140, 170; 141, 171; 141, 172; 142, 173; 143, 174; 143, 175; 145, 176; 145, 177; 150, 178; 150, 179; 151, 180; 152, 181; 153, 182; 153, 183; 158, 184; 158, 185; 159, 186; 159, 187; 159, 188; 161, 189; 164, 190; 166, 191; 166, 192; 166, 193; 167, 194; 170, 195; 175, 196; 178, 197; 178, 198; 179, 199; 179, 200; 179, 201; 180, 202; 180, 203; 181, 204; 183, 205; 184, 206; 184, 207; 187, 208; 187, 209; 188, 210; 189, 211; 190, 212; 190, 213; 193, 214; 193, 215; 194, 216; 194, 217; 195, 218; 195, 219; 196, 220; 196, 221; 200, 222; 200, 223; 201, 224; 204, 225; 204, 226; 205, 227; 205, 228; 210, 229; 211, 230; 211, 231; 213, 232; 213, 233; 214, 234; 215, 235; 219, 236; 223, 237; 223, 238; 224, 239; 224, 240; 225, 241; 225, 242; 226, 243; 227, 244; 227, 245; 229, 246; 229, 247; 230, 248; 230, 249; 231, 250; 234, 251; 234, 252; 235, 253; 235, 254; 236, 255; 236, 256; 246, 257; 246, 258; 247, 259; 247, 260; 247, 261; 250, 262; 250, 263; 251, 264; 251, 265; 252, 266; 252, 267; 252, 268; 253, 269; 253, 270; 254, 271; 255, 272; 255, 273; 256, 274; 256, 275; 260, 276; 260, 277; 261, 278; 267, 279; 267, 280; 268, 281; 277, 282; 277, 283; 278, 284; 278, 285; 280, 286; 280, 287; 281, 288; 281, 289 | def order_upgrades(self, upgrades, history=None):
"""Order upgrades according to their dependencies.
(topological sort using
Kahn's algorithm - http://en.wikipedia.org/wiki/Topological_sorting).
:param upgrades: Dict of upgrades
:param history: Dict of applied upgrades
"""
history = history or {}
graph_incoming, graph_outgoing = self._create_graph(upgrades, history)
# Removed already applied upgrades (assumes all dependencies prior to
# this upgrade has been applied).
for node_id in six.iterkeys(history):
start_nodes = [node_id, ]
while start_nodes:
node = start_nodes.pop()
# Remove from direct dependents
try:
for d in graph_outgoing[node]:
graph_incoming[d] = [x for x in graph_incoming[d]
if x != node]
except KeyError:
warnings.warn("Ghost upgrade %s detected" % node)
# Remove all prior dependencies
if node in graph_incoming:
# Get dependencies, remove node, and recursively
# remove all dependencies.
depends_on = graph_incoming[node]
# Add dependencies to check
for d in depends_on:
graph_outgoing[d] = [x for x in graph_outgoing[d]
if x != node]
start_nodes.append(d)
del graph_incoming[node]
# Check for missing dependencies
for node_id, depends_on in six.iteritems(graph_incoming):
for d in depends_on:
if d not in graph_incoming:
raise RuntimeError("Upgrade %s depends on an unknown"
" upgrade %s" % (node_id, d))
# Nodes with no incoming edges
start_nodes = [x for x in six.iterkeys(graph_incoming)
if len(graph_incoming[x]) == 0]
topo_order = []
while start_nodes:
# Append node_n to list (it has no incoming edges)
node_n = start_nodes.pop()
topo_order.append(node_n)
# For each node m with and edge from n to m
for node_m in graph_outgoing[node_n]:
# Remove the edge n to m
graph_incoming[node_m] = [x for x in graph_incoming[node_m]
if x != node_n]
# If m has no incoming edges, add it to start_nodes.
if not graph_incoming[node_m]:
start_nodes.append(node_m)
for node, edges in six.iteritems(graph_incoming):
if edges:
raise RuntimeError("The upgrades have at least one cyclic "
"dependency involving %s." % node)
return map(lambda x: upgrades[x], topo_order) |
0, module; 1, function_definition; 2, function_name:_validate_field; 3, parameters; 4, block; 5, identifier:param; 6, identifier:fields; 7, expression_statement; 8, if_statement; 9, comment:""" Ensure the sortable field exists on the model """; 10, comparison_operator:param.field not in fields; 11, block; 12, attribute; 13, identifier:fields; 14, raise_statement; 15, identifier:param; 16, identifier:field; 17, call; 18, identifier:InvalidQueryParams; 19, argument_list; 20, dictionary_splat; 21, dictionary; 22, pair; 23, pair; 24, pair; 25, string; 26, binary_operator:'The sort query param value of "%s" is '
'invalid. That field does not exist on the '
'resource being requested.' % param.raw_field; 27, string; 28, identifier:LINK; 29, string; 30, identifier:PARAM; 31, string_content:detail; 32, concatenated_string; 33, attribute; 34, string_content:links; 35, string_content:parameter; 36, string:'The sort query param value of "%s" is '; 37, string; 38, string; 39, identifier:param; 40, identifier:raw_field; 41, string_content:invalid. That field does not exist on the; 42, string_content:resource being requested. | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 7, 9; 8, 10; 8, 11; 10, 12; 10, 13; 11, 14; 12, 15; 12, 16; 14, 17; 17, 18; 17, 19; 19, 20; 20, 21; 21, 22; 21, 23; 21, 24; 22, 25; 22, 26; 23, 27; 23, 28; 24, 29; 24, 30; 25, 31; 26, 32; 26, 33; 27, 34; 29, 35; 32, 36; 32, 37; 32, 38; 33, 39; 33, 40; 37, 41; 38, 42 | def _validate_field(param, fields):
""" Ensure the sortable field exists on the model """
if param.field not in fields:
raise InvalidQueryParams(**{
'detail': 'The sort query param value of "%s" is '
'invalid. That field does not exist on the '
'resource being requested.' % param.raw_field,
'links': LINK,
'parameter': PARAM,
}) |
0, module; 1, function_definition; 2, function_name:_validate_no_rels; 3, parameters; 4, block; 5, identifier:param; 6, identifier:rels; 7, expression_statement; 8, if_statement; 9, comment:""" Ensure the sortable field is not on a relationship """; 10, comparison_operator:param.field in rels; 11, block; 12, attribute; 13, identifier:rels; 14, raise_statement; 15, identifier:param; 16, identifier:field; 17, call; 18, identifier:InvalidQueryParams; 19, argument_list; 20, dictionary_splat; 21, dictionary; 22, pair; 23, pair; 24, pair; 25, string; 26, binary_operator:'The sort query param value of "%s" is not '
'supported. Sorting on relationships is not '
'currently supported' % param.raw_field; 27, string; 28, identifier:LINK; 29, string; 30, identifier:PARAM; 31, string_content:detail; 32, concatenated_string; 33, attribute; 34, string_content:links; 35, string_content:parameter; 36, string:'The sort query param value of "%s" is not '; 37, string; 38, string; 39, identifier:param; 40, identifier:raw_field; 41, string_content:supported. Sorting on relationships is not; 42, string_content:currently supported | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 7, 9; 8, 10; 8, 11; 10, 12; 10, 13; 11, 14; 12, 15; 12, 16; 14, 17; 17, 18; 17, 19; 19, 20; 20, 21; 21, 22; 21, 23; 21, 24; 22, 25; 22, 26; 23, 27; 23, 28; 24, 29; 24, 30; 25, 31; 26, 32; 26, 33; 27, 34; 29, 35; 32, 36; 32, 37; 32, 38; 33, 39; 33, 40; 37, 41; 38, 42 | def _validate_no_rels(param, rels):
""" Ensure the sortable field is not on a relationship """
if param.field in rels:
raise InvalidQueryParams(**{
'detail': 'The sort query param value of "%s" is not '
'supported. Sorting on relationships is not '
'currently supported' % param.raw_field,
'links': LINK,
'parameter': PARAM,
}) |
0, module; 1, function_definition; 2, function_name:init; 3, parameters; 4, block; 5, identifier:req; 6, identifier:model; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, return_statement; 14, comment:""" Determine the sorting preference by query parameter
Return an array of Sortable objects.
"""; 15, assignment; 16, assignment; 17, assignment; 18, assignment; 19, identifier:param; 20, identifier:params; 21, block; 22, identifier:params; 23, identifier:rels; 24, attribute; 25, identifier:fields; 26, attribute; 27, identifier:params; 28, boolean_operator; 29, identifier:params; 30, list_comprehension; 31, expression_statement; 32, expression_statement; 33, identifier:model; 34, identifier:relationships; 35, identifier:model; 36, identifier:all_fields; 37, call; 38, list; 39, call; 40, for_in_clause; 41, call; 42, call; 43, attribute; 44, argument_list; 45, attribute; 46, identifier:Sortable; 47, argument_list; 48, identifier:param; 49, identifier:params; 50, identifier:_validate_no_rels; 51, argument_list; 52, identifier:_validate_field; 53, argument_list; 54, identifier:req; 55, identifier:get_param_as_list; 56, string; 57, attribute; 58, identifier:SORT; 59, call; 60, identifier:param; 61, identifier:rels; 62, identifier:param; 63, identifier:fields; 64, string_content:sort; 65, identifier:goldman; 66, identifier:config; 67, attribute; 68, argument_list; 69, identifier:param; 70, identifier:lower | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 8, 15; 9, 16; 10, 17; 11, 18; 12, 19; 12, 20; 12, 21; 13, 22; 15, 23; 15, 24; 16, 25; 16, 26; 17, 27; 17, 28; 18, 29; 18, 30; 21, 31; 21, 32; 24, 33; 24, 34; 26, 35; 26, 36; 28, 37; 28, 38; 30, 39; 30, 40; 31, 41; 32, 42; 37, 43; 37, 44; 38, 45; 39, 46; 39, 47; 40, 48; 40, 49; 41, 50; 41, 51; 42, 52; 42, 53; 43, 54; 43, 55; 44, 56; 45, 57; 45, 58; 47, 59; 51, 60; 51, 61; 53, 62; 53, 63; 56, 64; 57, 65; 57, 66; 59, 67; 59, 68; 67, 69; 67, 70 | def init(req, model):
""" Determine the sorting preference by query parameter
Return an array of Sortable objects.
"""
rels = model.relationships
fields = model.all_fields
params = req.get_param_as_list('sort') or [goldman.config.SORT]
params = [Sortable(param.lower()) for param in params]
for param in params:
_validate_no_rels(param, rels)
_validate_field(param, fields)
return params |
0, module; 1, function_definition; 2, function_name:get_allposts; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, try_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, expression_statement; 14, return_statement; 15, string; 16, assignment; 17, block; 18, except_clause; 19, assignment; 20, assignment; 21, assignment; 22, identifier:j; 23, call; 24, block; 25, assignment; 26, identifier:newlist; 27, string_content:Return all posts in blog sorted by date; 28, identifier:result; 29, call; 30, expression_statement; 31, block; 32, identifier:delta; 33, binary_operator:(total_posts / 10) + 1; 34, identifier:all_posts; 35, list; 36, identifier:posts_ids; 37, list; 38, identifier:range; 39, argument_list; 40, expression_statement; 41, expression_statement; 42, expression_statement; 43, if_statement; 44, for_statement; 45, identifier:newlist; 46, call; 47, attribute; 48, argument_list; 49, assignment; 50, raise_statement; 51, parenthesized_expression; 52, integer:1; 53, identifier:delta; 54, assignment; 55, assignment; 56, assignment; 57, not_operator; 58, block; 59, identifier:i; 60, identifier:posts; 61, block; 62, identifier:sorted; 63, argument_list; 64, attribute; 65, identifier:posts; 66, attribute; 67, keyword_argument; 68, keyword_argument; 69, identifier:total_posts; 70, subscript; 71, call; 72, binary_operator:total_posts / 10; 73, identifier:start; 74, binary_operator:j * 10; 75, identifier:end; 76, binary_operator:(j + 1) * 10; 77, identifier:posts; 78, subscript; 79, call; 80, break_statement; 81, if_statement; 82, expression_statement; 83, expression_statement; 84, expression_statement; 85, expression_statement; 86, expression_statement; 87, expression_statement; 88, expression_statement; 89, expression_statement; 90, expression_statement; 91, expression_statement; 92, expression_statement; 93, expression_statement; 94, identifier:all_posts; 95, keyword_argument; 96, identifier:self; 97, identifier:client; 98, identifier:self; 99, identifier:blog; 100, identifier:offset; 101, integer:0; 102, identifier:limit; 103, integer:1; 104, identifier:result; 105, string; 106, attribute; 107, argument_list; 108, identifier:total_posts; 109, integer:10; 110, identifier:j; 111, integer:10; 112, parenthesized_expression; 113, integer:10; 114, call; 115, string; 116, identifier:len; 117, argument_list; 118, comparison_operator:i['id'] in posts_ids; 119, block; 120, assignment; 121, assignment; 122, assignment; 123, assignment; 124, assignment; 125, assignment; 126, assignment; 127, assignment; 128, assignment; 129, assignment; 130, call; 131, call; 132, identifier:key; 133, lambda; 134, string_content:total_posts; 135, identifier:phasetumblr_errors; 136, identifier:TumblrBlogException; 137, subscript; 138, binary_operator:j + 1; 139, attribute; 140, argument_list; 141, string_content:posts; 142, identifier:posts; 143, subscript; 144, identifier:posts_ids; 145, continue_statement; 146, identifier:description; 147, call; 148, identifier:body; 149, call; 150, identifier:post; 151, dictionary; 152, subscript; 153, subscript; 154, subscript; 155, subscript; 156, subscript; 157, call; 158, subscript; 159, subscript; 160, subscript; 161, subscript; 162, subscript; 163, identifier:body; 164, subscript; 165, identifier:description; 166, attribute; 167, argument_list; 168, attribute; 169, argument_list; 170, lambda_parameters; 171, subscript; 172, subscript; 173, string; 174, identifier:j; 175, integer:1; 176, attribute; 177, identifier:posts; 178, attribute; 179, keyword_argument; 180, keyword_argument; 181, identifier:i; 182, string; 183, identifier:split_body; 184, argument_list; 185, identifier:split_body; 186, argument_list; 187, identifier:post; 188, string; 189, identifier:i; 190, string; 191, identifier:post; 192, string; 193, identifier:i; 194, string; 195, identifier:post; 196, string; 197, attribute; 198, argument_list; 199, identifier:post; 200, string; 201, identifier:i; 202, string; 203, identifier:post; 204, string; 205, identifier:i; 206, string; 207, identifier:post; 208, string; 209, identifier:post; 210, string; 211, identifier:all_posts; 212, identifier:append; 213, identifier:post; 214, identifier:posts_ids; 215, identifier:append; 216, subscript; 217, identifier:k; 218, identifier:k; 219, string; 220, identifier:result; 221, string; 222, string_content:msg; 223, identifier:self; 224, identifier:client; 225, identifier:self; 226, identifier:blog; 227, identifier:offset; 228, identifier:start; 229, identifier:limit; 230, identifier:end; 231, string_content:id; 232, subscript; 233, subscript; 234, integer:1; 235, string_content:title; 236, string_content:title; 237, string_content:link; 238, string_content:post_url; 239, string_content:date; 240, identifier:datetime; 241, identifier:strptime; 242, subscript; 243, string; 244, string_content:tags; 245, string_content:tags; 246, string_content:id; 247, string_content:id; 248, string_content:body; 249, string_content:description; 250, identifier:i; 251, string; 252, string_content:date; 253, string_content:meta; 254, identifier:i; 255, string; 256, identifier:i; 257, string; 258, identifier:i; 259, string; 260, string_content:%Y-%m-%d %H:%M:%S %Z; 261, string_content:id; 262, string_content:body; 263, string_content:body; 264, string_content:date | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 7, 16; 8, 17; 8, 18; 9, 19; 10, 20; 11, 21; 12, 22; 12, 23; 12, 24; 13, 25; 14, 26; 15, 27; 16, 28; 16, 29; 17, 30; 18, 31; 19, 32; 19, 33; 20, 34; 20, 35; 21, 36; 21, 37; 23, 38; 23, 39; 24, 40; 24, 41; 24, 42; 24, 43; 24, 44; 25, 45; 25, 46; 29, 47; 29, 48; 30, 49; 31, 50; 33, 51; 33, 52; 39, 53; 40, 54; 41, 55; 42, 56; 43, 57; 43, 58; 44, 59; 44, 60; 44, 61; 46, 62; 46, 63; 47, 64; 47, 65; 48, 66; 48, 67; 48, 68; 49, 69; 49, 70; 50, 71; 51, 72; 54, 73; 54, 74; 55, 75; 55, 76; 56, 77; 56, 78; 57, 79; 58, 80; 61, 81; 61, 82; 61, 83; 61, 84; 61, 85; 61, 86; 61, 87; 61, 88; 61, 89; 61, 90; 61, 91; 61, 92; 61, 93; 63, 94; 63, 95; 64, 96; 64, 97; 66, 98; 66, 99; 67, 100; 67, 101; 68, 102; 68, 103; 70, 104; 70, 105; 71, 106; 71, 107; 72, 108; 72, 109; 74, 110; 74, 111; 76, 112; 76, 113; 78, 114; 78, 115; 79, 116; 79, 117; 81, 118; 81, 119; 82, 120; 83, 121; 84, 122; 85, 123; 86, 124; 87, 125; 88, 126; 89, 127; 90, 128; 91, 129; 92, 130; 93, 131; 95, 132; 95, 133; 105, 134; 106, 135; 106, 136; 107, 137; 112, 138; 114, 139; 114, 140; 115, 141; 117, 142; 118, 143; 118, 144; 119, 145; 120, 146; 120, 147; 121, 148; 121, 149; 122, 150; 122, 151; 123, 152; 123, 153; 124, 154; 124, 155; 125, 156; 125, 157; 126, 158; 126, 159; 127, 160; 127, 161; 128, 162; 128, 163; 129, 164; 129, 165; 130, 166; 130, 167; 131, 168; 131, 169; 133, 170; 133, 171; 137, 172; 137, 173; 138, 174; 138, 175; 139, 176; 139, 177; 140, 178; 140, 179; 140, 180; 143, 181; 143, 182; 147, 183; 147, 184; 149, 185; 149, 186; 152, 187; 152, 188; 153, 189; 153, 190; 154, 191; 154, 192; 155, 193; 155, 194; 156, 195; 156, 196; 157, 197; 157, 198; 158, 199; 158, 200; 159, 201; 159, 202; 160, 203; 160, 204; 161, 205; 161, 206; 162, 207; 162, 208; 164, 209; 164, 210; 166, 211; 166, 212; 167, 213; 168, 214; 168, 215; 169, 216; 170, 217; 171, 218; 171, 219; 172, 220; 172, 221; 173, 222; 176, 223; 176, 224; 178, 225; 178, 226; 179, 227; 179, 228; 180, 229; 180, 230; 182, 231; 184, 232; 186, 233; 186, 234; 188, 235; 190, 236; 192, 237; 194, 238; 196, 239; 197, 240; 197, 241; 198, 242; 198, 243; 200, 244; 202, 245; 204, 246; 206, 247; 208, 248; 210, 249; 216, 250; 216, 251; 219, 252; 221, 253; 232, 254; 232, 255; 233, 256; 233, 257; 242, 258; 242, 259; 243, 260; 251, 261; 255, 262; 257, 263; 259, 264 | def get_allposts(self):
''' Return all posts in blog sorted by date
'''
result = self.client.posts(self.blog, offset = 0, limit = 1)
try:
total_posts = result['total_posts']
except:
raise phasetumblr_errors.TumblrBlogException(result['meta']['msg'])
delta = (total_posts / 10) + 1
all_posts = []
posts_ids = []
for j in range(delta):
start = j * 10
end = (j + 1) * 10
posts = self.client.posts(self.blog, offset = start, limit = end)['posts']
if not len(posts):
break
for i in posts:
if i['id'] in posts_ids:
continue
description = split_body(i['body'])
body = split_body(i['body'], 1)
post = {}
post['title'] = i['title']
post['link'] = i['post_url']
post['date'] = datetime.strptime(i['date'], '%Y-%m-%d %H:%M:%S %Z')
post['tags'] = i['tags']
post['id'] = i['id']
post['body'] = body
post['description'] = description
all_posts.append(post)
posts_ids.append(i['id'])
newlist = sorted(all_posts, key=lambda k: k['date'])
return newlist |
0, module; 1, function_definition; 2, function_name:sort_dict_by_key; 3, parameters; 4, block; 5, identifier:obj; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""
Sort dict by its keys
>>> sort_dict_by_key(dict(c=1, b=2, a=3, d=4))
OrderedDict([('a', 3), ('b', 2), ('c', 1), ('d', 4)])
"""; 10, assignment; 11, call; 12, identifier:sort_func; 13, lambda; 14, identifier:OrderedDict; 15, argument_list; 16, lambda_parameters; 17, subscript; 18, call; 19, identifier:x; 20, identifier:x; 21, integer:0; 22, identifier:sorted; 23, argument_list; 24, call; 25, keyword_argument; 26, attribute; 27, argument_list; 28, identifier:key; 29, identifier:sort_func; 30, identifier:obj; 31, identifier:items | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 16, 19; 17, 20; 17, 21; 18, 22; 18, 23; 23, 24; 23, 25; 24, 26; 24, 27; 25, 28; 25, 29; 26, 30; 26, 31 | def sort_dict_by_key(obj):
"""
Sort dict by its keys
>>> sort_dict_by_key(dict(c=1, b=2, a=3, d=4))
OrderedDict([('a', 3), ('b', 2), ('c', 1), ('d', 4)])
"""
sort_func = lambda x: x[0]
return OrderedDict(sorted(obj.items(), key=sort_func)) |
0, module; 1, function_definition; 2, function_name:sortBy; 3, parameters; 4, block; 5, identifier:self; 6, list_splat_pattern; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, identifier:args; 12, string; 13, assignment; 14, identifier:k; 15, identifier:args; 16, block; 17, identifier:self; 18, string_content:sort results by given criteria; 19, identifier:criteria; 20, list; 21, if_statement; 22, string; 23, string; 24, comparison_operator:k in criteria; 25, block; 26, string_content:seeds; 27, string_content:size; 28, identifier:k; 29, identifier:criteria; 30, expression_statement; 31, assignment; 32, attribute; 33, call; 34, identifier:self; 35, identifier:results; 36, identifier:sorted; 37, argument_list; 38, attribute; 39, keyword_argument; 40, keyword_argument; 41, identifier:self; 42, identifier:results; 43, identifier:key; 44, call; 45, identifier:reverse; 46, True; 47, identifier:attrgetter; 48, argument_list; 49, identifier:k | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 12, 18; 13, 19; 13, 20; 16, 21; 20, 22; 20, 23; 21, 24; 21, 25; 22, 26; 23, 27; 24, 28; 24, 29; 25, 30; 30, 31; 31, 32; 31, 33; 32, 34; 32, 35; 33, 36; 33, 37; 37, 38; 37, 39; 37, 40; 38, 41; 38, 42; 39, 43; 39, 44; 40, 45; 40, 46; 44, 47; 44, 48; 48, 49 | def sortBy(self, *args):
'''sort results by given criteria'''
criteria = ['seeds', 'size']
for k in args:
if k in criteria:
self.results = sorted(
self.results, key=attrgetter(k), reverse=True)
return self |
0, module; 1, function_definition; 2, function_name:rate_limited; 3, parameters; 4, block; 5, identifier:max_per_second; 6, expression_statement; 7, import_statement; 8, expression_statement; 9, expression_statement; 10, function_definition; 11, return_statement; 12, comment:""" Sort of based off of an answer about
rate limiting on Stack Overflow.
Definitely **not** thread safe, so
don't even think about it, buddy.
"""; 13, dotted_name; 14, assignment; 15, assignment; 16, function_name:decorate; 17, parameters; 18, block; 19, identifier:decorate; 20, identifier:datetime; 21, identifier:min_request_time; 22, call; 23, identifier:last_time_called; 24, list; 25, identifier:func; 26, function_definition; 27, return_statement; 28, attribute; 29, argument_list; 30, None; 31, function_name:rate_limited_function; 32, parameters; 33, block; 34, call; 35, identifier:datetime; 36, identifier:timedelta; 37, keyword_argument; 38, list_splat_pattern; 39, dictionary_splat_pattern; 40, if_statement; 41, expression_statement; 42, expression_statement; 43, return_statement; 44, attribute; 45, argument_list; 46, identifier:seconds; 47, identifier:max_per_second; 48, identifier:args; 49, identifier:kwargs; 50, subscript; 51, block; 52, assignment; 53, assignment; 54, identifier:ret; 55, identifier:functools; 56, identifier:update_wrapper; 57, identifier:rate_limited_function; 58, identifier:func; 59, identifier:last_time_called; 60, integer:0; 61, expression_statement; 62, if_statement; 63, identifier:ret; 64, call; 65, subscript; 66, call; 67, assignment; 68, comparison_operator:delta < datetime.timedelta.min; 69, block; 70, elif_clause; 71, identifier:func; 72, argument_list; 73, identifier:last_time_called; 74, integer:0; 75, attribute; 76, argument_list; 77, identifier:delta; 78, binary_operator:datetime.datetime.now() - last_time_called[0]; 79, identifier:delta; 80, attribute; 81, raise_statement; 82, comparison_operator:delta < min_request_time; 83, block; 84, list_splat; 85, dictionary_splat; 86, attribute; 87, identifier:now; 88, call; 89, subscript; 90, attribute; 91, identifier:min; 92, expression_list; 93, identifier:delta; 94, identifier:min_request_time; 95, expression_statement; 96, raise_statement; 97, identifier:args; 98, identifier:kwargs; 99, identifier:datetime; 100, identifier:datetime; 101, attribute; 102, argument_list; 103, identifier:last_time_called; 104, integer:0; 105, identifier:datetime; 106, identifier:timedelta; 107, attribute; 108, string:"Call the Doc!"; 109, assignment; 110, expression_list; 111, attribute; 112, identifier:now; 113, attribute; 114, identifier:TimeIsBackToFront; 115, identifier:msg; 116, call; 117, attribute; 118, identifier:msg; 119, identifier:datetime; 120, identifier:datetime; 121, identifier:chrw; 122, identifier:exceptions; 123, attribute; 124, argument_list; 125, attribute; 126, identifier:RequestRateTooHigh; 127, string:"Last request was {0}, should be at least {1}"; 128, identifier:format; 129, identifier:delta; 130, identifier:min_request_time; 131, identifier:chrw; 132, identifier:exceptions | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 10, 17; 10, 18; 11, 19; 13, 20; 14, 21; 14, 22; 15, 23; 15, 24; 17, 25; 18, 26; 18, 27; 22, 28; 22, 29; 24, 30; 26, 31; 26, 32; 26, 33; 27, 34; 28, 35; 28, 36; 29, 37; 32, 38; 32, 39; 33, 40; 33, 41; 33, 42; 33, 43; 34, 44; 34, 45; 37, 46; 37, 47; 38, 48; 39, 49; 40, 50; 40, 51; 41, 52; 42, 53; 43, 54; 44, 55; 44, 56; 45, 57; 45, 58; 50, 59; 50, 60; 51, 61; 51, 62; 52, 63; 52, 64; 53, 65; 53, 66; 61, 67; 62, 68; 62, 69; 62, 70; 64, 71; 64, 72; 65, 73; 65, 74; 66, 75; 66, 76; 67, 77; 67, 78; 68, 79; 68, 80; 69, 81; 70, 82; 70, 83; 72, 84; 72, 85; 75, 86; 75, 87; 78, 88; 78, 89; 80, 90; 80, 91; 81, 92; 82, 93; 82, 94; 83, 95; 83, 96; 84, 97; 85, 98; 86, 99; 86, 100; 88, 101; 88, 102; 89, 103; 89, 104; 90, 105; 90, 106; 92, 107; 92, 108; 95, 109; 96, 110; 101, 111; 101, 112; 107, 113; 107, 114; 109, 115; 109, 116; 110, 117; 110, 118; 111, 119; 111, 120; 113, 121; 113, 122; 116, 123; 116, 124; 117, 125; 117, 126; 123, 127; 123, 128; 124, 129; 124, 130; 125, 131; 125, 132 | def rate_limited(max_per_second):
""" Sort of based off of an answer about
rate limiting on Stack Overflow.
Definitely **not** thread safe, so
don't even think about it, buddy.
"""
import datetime
min_request_time = datetime.timedelta(seconds=max_per_second)
last_time_called = [None]
def decorate(func):
def rate_limited_function(*args, **kwargs):
if last_time_called[0]:
delta = datetime.datetime.now() - last_time_called[0]
if delta < datetime.timedelta.min:
raise chrw.exceptions.TimeIsBackToFront, "Call the Doc!"
elif delta < min_request_time:
msg = "Last request was {0}, should be at least {1}".format(
delta, min_request_time
)
raise chrw.exceptions.RequestRateTooHigh, msg
ret = func(*args, **kwargs)
last_time_called[0] = datetime.datetime.now()
return ret
return functools.update_wrapper(rate_limited_function, func)
return decorate |
0, module; 1, function_definition; 2, function_name:monotony; 3, parameters; 4, block; 5, identifier:seq; 6, expression_statement; 7, if_statement; 8, comment:"""Determine the monotony of a sequence
:param seq: a sequence
:returns: 1 if the sequence is sorted (increasing)
:returns: 0 if it is not sorted
:returns: -1 if it is sorted in reverse order (decreasing)
>>> monotony([1, 2, 3])
1
>>> monotony([1, 3, 2])
0
>>> monotony([3, 2, 1])
-1
"""; 9, comparison_operator:seq == sorted(seq); 10, block; 11, elif_clause; 12, else_clause; 13, identifier:seq; 14, call; 15, return_statement; 16, comparison_operator:seq == list(reversed(sorted(seq))); 17, block; 18, block; 19, identifier:sorted; 20, argument_list; 21, integer:1; 22, identifier:seq; 23, call; 24, return_statement; 25, return_statement; 26, identifier:seq; 27, identifier:list; 28, argument_list; 29, unary_operator; 30, integer:0; 31, call; 32, integer:1; 33, identifier:reversed; 34, argument_list; 35, call; 36, identifier:sorted; 37, argument_list; 38, identifier:seq | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 7, 10; 7, 11; 7, 12; 9, 13; 9, 14; 10, 15; 11, 16; 11, 17; 12, 18; 14, 19; 14, 20; 15, 21; 16, 22; 16, 23; 17, 24; 18, 25; 20, 26; 23, 27; 23, 28; 24, 29; 25, 30; 28, 31; 29, 32; 31, 33; 31, 34; 34, 35; 35, 36; 35, 37; 37, 38 | def monotony(seq):
"""Determine the monotony of a sequence
:param seq: a sequence
:returns: 1 if the sequence is sorted (increasing)
:returns: 0 if it is not sorted
:returns: -1 if it is sorted in reverse order (decreasing)
>>> monotony([1, 2, 3])
1
>>> monotony([1, 3, 2])
0
>>> monotony([3, 2, 1])
-1
"""
if seq == sorted(seq):
return 1
elif seq == list(reversed(sorted(seq))):
return -1
else:
return 0 |
0, module; 1, function_definition; 2, function_name:variables; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""
Returns all documented module level variables in the module
sorted alphabetically as a list of `pydoc.Variable`.
"""; 10, assignment; 11, call; 12, identifier:p; 13, lambda; 14, identifier:sorted; 15, argument_list; 16, lambda_parameters; 17, boolean_operator; 18, call; 19, identifier:o; 20, call; 21, call; 22, identifier:filter; 23, argument_list; 24, identifier:isinstance; 25, argument_list; 26, attribute; 27, argument_list; 28, identifier:p; 29, call; 30, identifier:o; 31, identifier:Variable; 32, identifier:self; 33, identifier:_docfilter; 34, identifier:o; 35, attribute; 36, argument_list; 37, attribute; 38, identifier:values; 39, identifier:self; 40, identifier:doc | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 16, 19; 17, 20; 17, 21; 18, 22; 18, 23; 20, 24; 20, 25; 21, 26; 21, 27; 23, 28; 23, 29; 25, 30; 25, 31; 26, 32; 26, 33; 27, 34; 29, 35; 29, 36; 35, 37; 35, 38; 37, 39; 37, 40 | def variables(self):
"""
Returns all documented module level variables in the module
sorted alphabetically as a list of `pydoc.Variable`.
"""
p = lambda o: isinstance(o, Variable) and self._docfilter(o)
return sorted(filter(p, self.doc.values())) |
0, module; 1, function_definition; 2, function_name:classes; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""
Returns all documented module level classes in the module
sorted alphabetically as a list of `pydoc.Class`.
"""; 10, assignment; 11, call; 12, identifier:p; 13, lambda; 14, identifier:sorted; 15, argument_list; 16, lambda_parameters; 17, boolean_operator; 18, call; 19, identifier:o; 20, call; 21, call; 22, identifier:filter; 23, argument_list; 24, identifier:isinstance; 25, argument_list; 26, attribute; 27, argument_list; 28, identifier:p; 29, call; 30, identifier:o; 31, identifier:Class; 32, identifier:self; 33, identifier:_docfilter; 34, identifier:o; 35, attribute; 36, argument_list; 37, attribute; 38, identifier:values; 39, identifier:self; 40, identifier:doc | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 16, 19; 17, 20; 17, 21; 18, 22; 18, 23; 20, 24; 20, 25; 21, 26; 21, 27; 23, 28; 23, 29; 25, 30; 25, 31; 26, 32; 26, 33; 27, 34; 29, 35; 29, 36; 35, 37; 35, 38; 37, 39; 37, 40 | def classes(self):
"""
Returns all documented module level classes in the module
sorted alphabetically as a list of `pydoc.Class`.
"""
p = lambda o: isinstance(o, Class) and self._docfilter(o)
return sorted(filter(p, self.doc.values())) |
0, module; 1, function_definition; 2, function_name:functions; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""
Returns all documented module level functions in the module
sorted alphabetically as a list of `pydoc.Function`.
"""; 10, assignment; 11, call; 12, identifier:p; 13, lambda; 14, identifier:sorted; 15, argument_list; 16, lambda_parameters; 17, boolean_operator; 18, call; 19, identifier:o; 20, call; 21, call; 22, identifier:filter; 23, argument_list; 24, identifier:isinstance; 25, argument_list; 26, attribute; 27, argument_list; 28, identifier:p; 29, call; 30, identifier:o; 31, identifier:Function; 32, identifier:self; 33, identifier:_docfilter; 34, identifier:o; 35, attribute; 36, argument_list; 37, attribute; 38, identifier:values; 39, identifier:self; 40, identifier:doc | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 16, 19; 17, 20; 17, 21; 18, 22; 18, 23; 20, 24; 20, 25; 21, 26; 21, 27; 23, 28; 23, 29; 25, 30; 25, 31; 26, 32; 26, 33; 27, 34; 29, 35; 29, 36; 35, 37; 35, 38; 37, 39; 37, 40 | def functions(self):
"""
Returns all documented module level functions in the module
sorted alphabetically as a list of `pydoc.Function`.
"""
p = lambda o: isinstance(o, Function) and self._docfilter(o)
return sorted(filter(p, self.doc.values())) |
0, module; 1, function_definition; 2, function_name:submodules; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""
Returns all documented sub-modules in the module sorted
alphabetically as a list of `pydoc.Module`.
"""; 10, assignment; 11, call; 12, identifier:p; 13, lambda; 14, identifier:sorted; 15, argument_list; 16, lambda_parameters; 17, boolean_operator; 18, call; 19, identifier:o; 20, call; 21, call; 22, identifier:filter; 23, argument_list; 24, identifier:isinstance; 25, argument_list; 26, attribute; 27, argument_list; 28, identifier:p; 29, call; 30, identifier:o; 31, identifier:Module; 32, identifier:self; 33, identifier:_docfilter; 34, identifier:o; 35, attribute; 36, argument_list; 37, attribute; 38, identifier:values; 39, identifier:self; 40, identifier:doc | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 16, 19; 17, 20; 17, 21; 18, 22; 18, 23; 20, 24; 20, 25; 21, 26; 21, 27; 23, 28; 23, 29; 25, 30; 25, 31; 26, 32; 26, 33; 27, 34; 29, 35; 29, 36; 35, 37; 35, 38; 37, 39; 37, 40 | def submodules(self):
"""
Returns all documented sub-modules in the module sorted
alphabetically as a list of `pydoc.Module`.
"""
p = lambda o: isinstance(o, Module) and self._docfilter(o)
return sorted(filter(p, self.doc.values())) |
0, module; 1, function_definition; 2, function_name:class_variables; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""
Returns all documented class variables in the class, sorted
alphabetically as a list of `pydoc.Variable`.
"""; 10, assignment; 11, call; 12, identifier:p; 13, lambda; 14, identifier:filter; 15, argument_list; 16, lambda_parameters; 17, boolean_operator; 18, identifier:p; 19, call; 20, identifier:o; 21, call; 22, call; 23, attribute; 24, argument_list; 25, identifier:isinstance; 26, argument_list; 27, attribute; 28, argument_list; 29, attribute; 30, identifier:values; 31, identifier:o; 32, identifier:Variable; 33, attribute; 34, identifier:_docfilter; 35, identifier:o; 36, identifier:self; 37, identifier:doc; 38, identifier:self; 39, identifier:module | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 15, 19; 16, 20; 17, 21; 17, 22; 19, 23; 19, 24; 21, 25; 21, 26; 22, 27; 22, 28; 23, 29; 23, 30; 26, 31; 26, 32; 27, 33; 27, 34; 28, 35; 29, 36; 29, 37; 33, 38; 33, 39 | def class_variables(self):
"""
Returns all documented class variables in the class, sorted
alphabetically as a list of `pydoc.Variable`.
"""
p = lambda o: isinstance(o, Variable) and self.module._docfilter(o)
return filter(p, self.doc.values()) |
0, module; 1, function_definition; 2, function_name:BEDIterator; 3, parameters; 4, block; 5, identifier:filehandle; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, if_statement; 15, for_statement; 16, identifier:sortedby; 17, None; 18, identifier:verbose; 19, False; 20, identifier:scoreType; 21, identifier:int; 22, identifier:dropAfter; 23, None; 24, comment:"""
Get an iterator for a BED file
:param filehandle: this can be either a string, or a stream-like object. In
the former case, it is treated as a filename. The format
of the file/stream must be BED.
:param sortedby: if None, order is not checked.
if == ITERATOR_SORTED_START, elements in file must
be sorted by chrom and start index (an exception
is raised if they are not)
if == ITERATOR_SORTED_END, element must be sorted
by chrom and end index.
:param verbose: if True, output additional progress messages to stderr
:param scoreType: The data type for scores (the fifth column) in the BED
file.
:param dropAfter: an int indicating that any fields after and including this
field should be ignored as they don't conform to the BED
format. By default, None, meaning we use all fields. Index
from zero.
:return: iterator where subsequent calls to next() yield the next BED
element in the stream as a GenomicInterval object.
"""; 25, assignment; 26, assignment; 27, comparison_operator:type(filehandle).__name__ == "str"; 28, block; 29, identifier:verbose; 30, block; 31, identifier:line; 32, identifier:filehandle; 33, block; 34, identifier:chromsSeen; 35, call; 36, identifier:prev; 37, None; 38, attribute; 39, string:"str"; 40, expression_statement; 41, try_statement; 42, if_statement; 43, if_statement; 44, try_statement; 45, comment:# sorting by name?; 46, if_statement; 47, comment:# first item; 48, if_statement; 49, comment:# on same chrom as the prev item, make sure order is right; 50, if_statement; 51, comment:# starting a new chrom.. make sure we haven't already seen it; 52, if_statement; 53, comment:# all good..; 54, expression_statement; 55, expression_statement; 56, identifier:set; 57, argument_list; 58, call; 59, identifier:__name__; 60, assignment; 61, block; 62, except_clause; 63, identifier:verbose; 64, block; 65, comparison_operator:line.strip() == ""; 66, block; 67, block; 68, except_clause; 69, parenthesized_expression; 70, block; 71, comparison_operator:prev is None; 72, block; 73, boolean_operator; 74, block; 75, boolean_operator; 76, block; 77, yield; 78, assignment; 79, identifier:type; 80, argument_list; 81, identifier:filehandle; 82, call; 83, expression_statement; 84, as_pattern; 85, block; 86, expression_statement; 87, expression_statement; 88, call; 89, string:""; 90, continue_statement; 91, expression_statement; 92, as_pattern; 93, block; 94, boolean_operator; 95, raise_statement; 96, identifier:prev; 97, None; 98, expression_statement; 99, boolean_operator; 100, comparison_operator:e.chrom == prev.chrom; 101, if_statement; 102, if_statement; 103, comparison_operator:prev is not None; 104, comparison_operator:prev.chrom != e.chrom; 105, if_statement; 106, expression_statement; 107, identifier:e; 108, identifier:prev; 109, identifier:e; 110, identifier:filehandle; 111, identifier:open; 112, argument_list; 113, assignment; 114, tuple; 115, as_pattern_target; 116, expression_statement; 117, expression_statement; 118, assignment; 119, call; 120, attribute; 121, argument_list; 122, assignment; 123, identifier:GenomicIntervalError; 124, as_pattern_target; 125, raise_statement; 126, parenthesized_expression; 127, parenthesized_expression; 128, call; 129, call; 130, comparison_operator:prev is not None; 131, comparison_operator:sortedby is not None; 132, attribute; 133, attribute; 134, boolean_operator; 135, block; 136, boolean_operator; 137, block; 138, identifier:prev; 139, None; 140, attribute; 141, attribute; 142, boolean_operator; 143, block; 144, call; 145, identifier:filehandle; 146, identifier:pind; 147, call; 148, identifier:AttributeError; 149, identifier:OSError; 150, identifier:e; 151, call; 152, assignment; 153, attribute; 154, call; 155, attribute; 156, argument_list; 157, identifier:line; 158, identifier:strip; 159, identifier:e; 160, call; 161, identifier:e; 162, call; 163, boolean_operator; 164, comparison_operator:prev.name > e.name; 165, identifier:BEDError; 166, argument_list; 167, attribute; 168, argument_list; 169, identifier:prev; 170, None; 171, identifier:sortedby; 172, None; 173, identifier:e; 174, identifier:chrom; 175, identifier:prev; 176, identifier:chrom; 177, comparison_operator:sortedby == ITERATOR_SORTED_START; 178, comparison_operator:prev.start > e.start; 179, raise_statement; 180, comparison_operator:sortedby == ITERATOR_SORTED_END; 181, comparison_operator:prev.end > e.end; 182, raise_statement; 183, identifier:prev; 184, identifier:chrom; 185, identifier:e; 186, identifier:chrom; 187, parenthesized_expression; 188, line_continuation:\; 189, parenthesized_expression; 190, try_statement; 191, raise_statement; 192, attribute; 193, argument_list; 194, identifier:ProgressIndicator; 195, argument_list; 196, attribute; 197, argument_list; 198, identifier:verbose; 199, False; 200, identifier:pind; 201, identifier:done; 202, attribute; 203, argument_list; 204, identifier:pind; 205, identifier:showProgress; 206, identifier:parseBEDString; 207, argument_list; 208, identifier:BEDError; 209, argument_list; 210, comparison_operator:sortedby == ITERATOR_SORTED_NAME; 211, comparison_operator:prev is not None; 212, attribute; 213, attribute; 214, binary_operator:"bed file " + filehandle.name +
" not sorted by element name" +
" found " + e.name + " after " +
prev.name; 215, identifier:chromsSeen; 216, identifier:add; 217, attribute; 218, identifier:sortedby; 219, identifier:ITERATOR_SORTED_START; 220, attribute; 221, attribute; 222, call; 223, identifier:sortedby; 224, identifier:ITERATOR_SORTED_END; 225, attribute; 226, attribute; 227, call; 228, boolean_operator; 229, boolean_operator; 230, block; 231, except_clause; 232, call; 233, identifier:chromsSeen; 234, identifier:add; 235, attribute; 236, keyword_argument; 237, keyword_argument; 238, keyword_argument; 239, attribute; 240, identifier:write; 241, binary_operator:"BEDIterator -- warning: " +
"unable to show progress for stream"; 242, identifier:filehandle; 243, identifier:tell; 244, identifier:line; 245, identifier:scoreType; 246, keyword_argument; 247, binary_operator:str(e) + " on line " + line; 248, identifier:sortedby; 249, identifier:ITERATOR_SORTED_NAME; 250, identifier:prev; 251, None; 252, identifier:prev; 253, identifier:name; 254, identifier:e; 255, identifier:name; 256, binary_operator:"bed file " + filehandle.name +
" not sorted by element name" +
" found " + e.name + " after "; 257, attribute; 258, identifier:e; 259, identifier:chrom; 260, identifier:prev; 261, identifier:start; 262, identifier:e; 263, identifier:start; 264, identifier:BEDError; 265, argument_list; 266, identifier:prev; 267, identifier:end; 268, identifier:e; 269, identifier:end; 270, identifier:BEDError; 271, argument_list; 272, boolean_operator; 273, comparison_operator:sortedby == ITERATOR_SORTED_CHROM; 274, comparison_operator:e.chrom in chromsSeen; 275, comparison_operator:prev.chrom > e.chrom; 276, expression_statement; 277, identifier:AttributeError; 278, block; 279, identifier:BEDError; 280, argument_list; 281, identifier:e; 282, identifier:chrom; 283, identifier:totalToDo; 284, call; 285, identifier:messagePrefix; 286, string:"completed"; 287, identifier:messageSuffix; 288, binary_operator:"of processing " +
filehandle.name; 289, identifier:sys; 290, identifier:stderr; 291, string:"BEDIterator -- warning: "; 292, string:"unable to show progress for stream"; 293, identifier:dropAfter; 294, identifier:dropAfter; 295, binary_operator:str(e) + " on line "; 296, identifier:line; 297, binary_operator:"bed file " + filehandle.name +
" not sorted by element name" +
" found " + e.name; 298, string:" after "; 299, identifier:prev; 300, identifier:name; 301, binary_operator:"bed file " + filehandle.name +
" not sorted by start index - saw item " +
str(prev) + " before " + str(e); 302, binary_operator:"bed file " + filehandle.name +
" not sorted by end index - saw item " +
str(prev) + " before " + str(e); 303, comparison_operator:sortedby == ITERATOR_SORTED_START; 304, comparison_operator:sortedby == ITERATOR_SORTED_END; 305, identifier:sortedby; 306, identifier:ITERATOR_SORTED_CHROM; 307, attribute; 308, identifier:chromsSeen; 309, attribute; 310, attribute; 311, assignment; 312, expression_statement; 313, binary_operator:"BED file " + e_fn + " not sorted by chrom"; 314, attribute; 315, argument_list; 316, string:"of processing "; 317, attribute; 318, call; 319, string:" on line "; 320, binary_operator:"bed file " + filehandle.name +
" not sorted by element name" +
" found "; 321, attribute; 322, binary_operator:"bed file " + filehandle.name +
" not sorted by start index - saw item " +
str(prev) + " before "; 323, call; 324, binary_operator:"bed file " + filehandle.name +
" not sorted by end index - saw item " +
str(prev) + " before "; 325, call; 326, identifier:sortedby; 327, identifier:ITERATOR_SORTED_START; 328, identifier:sortedby; 329, identifier:ITERATOR_SORTED_END; 330, identifier:e; 331, identifier:chrom; 332, identifier:prev; 333, identifier:chrom; 334, identifier:e; 335, identifier:chrom; 336, identifier:e_fn; 337, attribute; 338, assignment; 339, binary_operator:"BED file " + e_fn; 340, string:" not sorted by chrom"; 341, attribute; 342, identifier:getsize; 343, attribute; 344, identifier:filehandle; 345, identifier:name; 346, identifier:str; 347, argument_list; 348, binary_operator:"bed file " + filehandle.name +
" not sorted by element name"; 349, string:" found "; 350, identifier:e; 351, identifier:name; 352, binary_operator:"bed file " + filehandle.name +
" not sorted by start index - saw item " +
str(prev); 353, string:" before "; 354, identifier:str; 355, argument_list; 356, binary_operator:"bed file " + filehandle.name +
" not sorted by end index - saw item " +
str(prev); 357, string:" before "; 358, identifier:str; 359, argument_list; 360, identifier:filehandle; 361, identifier:name; 362, identifier:e_fn; 363, string:"UNNAMED STREAM"; 364, string:"BED file "; 365, identifier:e_fn; 366, identifier:os; 367, identifier:path; 368, identifier:filehandle; 369, identifier:name; 370, identifier:e; 371, binary_operator:"bed file " + filehandle.name; 372, string:" not sorted by element name"; 373, binary_operator:"bed file " + filehandle.name +
" not sorted by start index - saw item "; 374, call; 375, identifier:e; 376, binary_operator:"bed file " + filehandle.name +
" not sorted by end index - saw item "; 377, call; 378, identifier:e; 379, string:"bed file "; 380, attribute; 381, binary_operator:"bed file " + filehandle.name; 382, string:" not sorted by start index - saw item "; 383, identifier:str; 384, argument_list; 385, binary_operator:"bed file " + filehandle.name; 386, string:" not sorted by end index - saw item "; 387, identifier:str; 388, argument_list; 389, identifier:filehandle; 390, identifier:name; 391, string:"bed file "; 392, attribute; 393, identifier:prev; 394, string:"bed file "; 395, attribute; 396, identifier:prev; 397, identifier:filehandle; 398, identifier:name; 399, identifier:filehandle; 400, identifier:name | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 6, 16; 6, 17; 7, 18; 7, 19; 8, 20; 8, 21; 9, 22; 9, 23; 10, 24; 11, 25; 12, 26; 13, 27; 13, 28; 14, 29; 14, 30; 15, 31; 15, 32; 15, 33; 25, 34; 25, 35; 26, 36; 26, 37; 27, 38; 27, 39; 28, 40; 30, 41; 33, 42; 33, 43; 33, 44; 33, 45; 33, 46; 33, 47; 33, 48; 33, 49; 33, 50; 33, 51; 33, 52; 33, 53; 33, 54; 33, 55; 35, 56; 35, 57; 38, 58; 38, 59; 40, 60; 41, 61; 41, 62; 42, 63; 42, 64; 43, 65; 43, 66; 44, 67; 44, 68; 46, 69; 46, 70; 48, 71; 48, 72; 50, 73; 50, 74; 52, 75; 52, 76; 54, 77; 55, 78; 58, 79; 58, 80; 60, 81; 60, 82; 61, 83; 62, 84; 62, 85; 64, 86; 64, 87; 65, 88; 65, 89; 66, 90; 67, 91; 68, 92; 68, 93; 69, 94; 70, 95; 71, 96; 71, 97; 72, 98; 73, 99; 73, 100; 74, 101; 74, 102; 75, 103; 75, 104; 76, 105; 76, 106; 77, 107; 78, 108; 78, 109; 80, 110; 82, 111; 82, 112; 83, 113; 84, 114; 84, 115; 85, 116; 85, 117; 86, 118; 87, 119; 88, 120; 88, 121; 91, 122; 92, 123; 92, 124; 93, 125; 94, 126; 94, 127; 95, 128; 98, 129; 99, 130; 99, 131; 100, 132; 100, 133; 101, 134; 101, 135; 102, 136; 102, 137; 103, 138; 103, 139; 104, 140; 104, 141; 105, 142; 105, 143; 106, 144; 112, 145; 113, 146; 113, 147; 114, 148; 114, 149; 115, 150; 116, 151; 117, 152; 118, 153; 118, 154; 119, 155; 119, 156; 120, 157; 120, 158; 122, 159; 122, 160; 124, 161; 125, 162; 126, 163; 127, 164; 128, 165; 128, 166; 129, 167; 129, 168; 130, 169; 130, 170; 131, 171; 131, 172; 132, 173; 132, 174; 133, 175; 133, 176; 134, 177; 134, 178; 135, 179; 136, 180; 136, 181; 137, 182; 140, 183; 140, 184; 141, 185; 141, 186; 142, 187; 142, 188; 142, 189; 143, 190; 143, 191; 144, 192; 144, 193; 147, 194; 147, 195; 151, 196; 151, 197; 152, 198; 152, 199; 153, 200; 153, 201; 154, 202; 154, 203; 155, 204; 155, 205; 160, 206; 160, 207; 162, 208; 162, 209; 163, 210; 163, 211; 164, 212; 164, 213; 166, 214; 167, 215; 167, 216; 168, 217; 177, 218; 177, 219; 178, 220; 178, 221; 179, 222; 180, 223; 180, 224; 181, 225; 181, 226; 182, 227; 187, 228; 189, 229; 190, 230; 190, 231; 191, 232; 192, 233; 192, 234; 193, 235; 195, 236; 195, 237; 195, 238; 196, 239; 196, 240; 197, 241; 202, 242; 202, 243; 207, 244; 207, 245; 207, 246; 209, 247; 210, 248; 210, 249; 211, 250; 211, 251; 212, 252; 212, 253; 213, 254; 213, 255; 214, 256; 214, 257; 217, 258; 217, 259; 220, 260; 220, 261; 221, 262; 221, 263; 222, 264; 222, 265; 225, 266; 225, 267; 226, 268; 226, 269; 227, 270; 227, 271; 228, 272; 228, 273; 229, 274; 229, 275; 230, 276; 231, 277; 231, 278; 232, 279; 232, 280; 235, 281; 235, 282; 236, 283; 236, 284; 237, 285; 237, 286; 238, 287; 238, 288; 239, 289; 239, 290; 241, 291; 241, 292; 246, 293; 246, 294; 247, 295; 247, 296; 256, 297; 256, 298; 257, 299; 257, 300; 265, 301; 271, 302; 272, 303; 272, 304; 273, 305; 273, 306; 274, 307; 274, 308; 275, 309; 275, 310; 276, 311; 278, 312; 280, 313; 284, 314; 284, 315; 288, 316; 288, 317; 295, 318; 295, 319; 297, 320; 297, 321; 301, 322; 301, 323; 302, 324; 302, 325; 303, 326; 303, 327; 304, 328; 304, 329; 307, 330; 307, 331; 309, 332; 309, 333; 310, 334; 310, 335; 311, 336; 311, 337; 312, 338; 313, 339; 313, 340; 314, 341; 314, 342; 315, 343; 317, 344; 317, 345; 318, 346; 318, 347; 320, 348; 320, 349; 321, 350; 321, 351; 322, 352; 322, 353; 323, 354; 323, 355; 324, 356; 324, 357; 325, 358; 325, 359; 337, 360; 337, 361; 338, 362; 338, 363; 339, 364; 339, 365; 341, 366; 341, 367; 343, 368; 343, 369; 347, 370; 348, 371; 348, 372; 352, 373; 352, 374; 355, 375; 356, 376; 356, 377; 359, 378; 371, 379; 371, 380; 373, 381; 373, 382; 374, 383; 374, 384; 376, 385; 376, 386; 377, 387; 377, 388; 380, 389; 380, 390; 381, 391; 381, 392; 384, 393; 385, 394; 385, 395; 388, 396; 392, 397; 392, 398; 395, 399; 395, 400 | def BEDIterator(filehandle, sortedby=None, verbose=False, scoreType=int,
dropAfter=None):
"""
Get an iterator for a BED file
:param filehandle: this can be either a string, or a stream-like object. In
the former case, it is treated as a filename. The format
of the file/stream must be BED.
:param sortedby: if None, order is not checked.
if == ITERATOR_SORTED_START, elements in file must
be sorted by chrom and start index (an exception
is raised if they are not)
if == ITERATOR_SORTED_END, element must be sorted
by chrom and end index.
:param verbose: if True, output additional progress messages to stderr
:param scoreType: The data type for scores (the fifth column) in the BED
file.
:param dropAfter: an int indicating that any fields after and including this
field should be ignored as they don't conform to the BED
format. By default, None, meaning we use all fields. Index
from zero.
:return: iterator where subsequent calls to next() yield the next BED
element in the stream as a GenomicInterval object.
"""
chromsSeen = set()
prev = None
if type(filehandle).__name__ == "str":
filehandle = open(filehandle)
if verbose:
try:
pind = ProgressIndicator(totalToDo=os.path.getsize(filehandle.name),
messagePrefix="completed",
messageSuffix="of processing " +
filehandle.name)
except (AttributeError, OSError) as e:
sys.stderr.write("BEDIterator -- warning: " +
"unable to show progress for stream")
verbose = False
for line in filehandle:
if verbose:
pind.done = filehandle.tell()
pind.showProgress()
if line.strip() == "":
continue
try:
e = parseBEDString(line, scoreType, dropAfter=dropAfter)
except GenomicIntervalError as e:
raise BEDError(str(e) + " on line " + line)
# sorting by name?
if ((sortedby == ITERATOR_SORTED_NAME and prev is not None) and
(prev.name > e.name)):
raise BEDError("bed file " + filehandle.name +
" not sorted by element name" +
" found " + e.name + " after " +
prev.name)
# first item
if prev is None:
chromsSeen.add(e.chrom)
# on same chrom as the prev item, make sure order is right
if prev is not None and sortedby is not None and e.chrom == prev.chrom:
if sortedby == ITERATOR_SORTED_START and prev.start > e.start:
raise BEDError("bed file " + filehandle.name +
" not sorted by start index - saw item " +
str(prev) + " before " + str(e))
if sortedby == ITERATOR_SORTED_END and prev.end > e.end:
raise BEDError("bed file " + filehandle.name +
" not sorted by end index - saw item " +
str(prev) + " before " + str(e))
# starting a new chrom.. make sure we haven't already seen it
if prev is not None and prev.chrom != e.chrom:
if (sortedby == ITERATOR_SORTED_START or
sortedby == ITERATOR_SORTED_END or
sortedby == ITERATOR_SORTED_CHROM) and\
(e.chrom in chromsSeen or prev.chrom > e.chrom):
try:
e_fn = filehandle.name
except AttributeError:
e_fn = "UNNAMED STREAM"
raise BEDError("BED file " + e_fn + " not sorted by chrom")
chromsSeen.add(e.chrom)
# all good..
yield e
prev = e |
0, module; 1, function_definition; 2, function_name:compress_and_sort_index; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, try_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, comment:# Include UTF-8 BOM in header.; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, for_statement; 18, expression_statement; 19, expression_statement; 20, with_statement; 21, expression_statement; 22, return_statement; 23, comment:"""Sort index, add header, and compress.
:rtype: bool
:returns: True
"""; 24, assignment; 25, block; 26, except_clause; 27, assignment; 28, assignment; 29, assignment; 30, assignment; 31, assignment; 32, assignment; 33, call; 34, identifier:line; 35, identifier:sorted_index; 36, block; 37, assignment; 38, call; 39, with_clause; 40, block; 41, call; 42, True; 43, identifier:idx_fname; 44, call; 45, expression_statement; 46, identifier:IOError; 47, block; 48, identifier:index; 49, list_comprehension; 50, identifier:sorted_index; 51, call; 52, identifier:gzip_idx_fname; 53, binary_operator:idx_fname + '.gz'; 54, identifier:header; 55, list; 56, identifier:s; 57, call; 58, identifier:writer; 59, call; 60, attribute; 61, argument_list; 62, expression_statement; 63, identifier:compressed_index; 64, call; 65, attribute; 66, argument_list; 67, with_item; 68, expression_statement; 69, attribute; 70, argument_list; 71, attribute; 72, argument_list; 73, assignment; 74, return_statement; 75, identifier:x; 76, for_in_clause; 77, if_clause; 78, identifier:sorted; 79, argument_list; 80, identifier:idx_fname; 81, string; 82, string; 83, string; 84, string; 85, string; 86, string; 87, string; 88, string; 89, string; 90, attribute; 91, argument_list; 92, attribute; 93, argument_list; 94, identifier:writer; 95, identifier:writerow; 96, identifier:header; 97, call; 98, identifier:inline_compress_chunk; 99, argument_list; 100, identifier:s; 101, identifier:close; 102, as_pattern; 103, call; 104, identifier:os; 105, identifier:remove; 106, identifier:idx_fname; 107, string; 108, identifier:format; 109, dictionary_splat; 110, identifier:reader; 111, call; 112, False; 113, identifier:x; 114, identifier:reader; 115, identifier:x; 116, identifier:index; 117, keyword_argument; 118, string_content:.gz; 119, string_content; 120, string_content:msg_id; 121, string_content:from; 122, string_content:newsgroups; 123, string_content:subject; 124, string_content:references; 125, string_content:start; 126, string_content:length; 127, identifier:cStringIO; 128, identifier:StringIO; 129, identifier:csv; 130, identifier:writer; 131, identifier:s; 132, keyword_argument; 133, attribute; 134, argument_list; 135, call; 136, call; 137, as_pattern_target; 138, attribute; 139, argument_list; 140, string_content:{name}.{date}.mbox.csv; 141, attribute; 142, attribute; 143, argument_list; 144, identifier:key; 145, call; 146, escape_sequence:\xef; 147, escape_sequence:\xbb; 148, escape_sequence:\xbf; 149, identifier:dialect; 150, string; 151, identifier:writer; 152, identifier:writerow; 153, identifier:line; 154, attribute; 155, argument_list; 156, identifier:open; 157, argument_list; 158, identifier:fp; 159, identifier:fp; 160, identifier:write; 161, identifier:compressed_index; 162, identifier:self; 163, identifier:__dict__; 164, identifier:csv; 165, identifier:reader; 166, call; 167, keyword_argument; 168, identifier:itemgetter; 169, argument_list; 170, string_content:excel-tab; 171, identifier:s; 172, identifier:getvalue; 173, identifier:gzip_idx_fname; 174, string; 175, identifier:open; 176, argument_list; 177, identifier:dialect; 178, string; 179, integer:0; 180, string_content:ab; 181, identifier:idx_fname; 182, string_content:excel-tab | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 6, 23; 7, 24; 8, 25; 8, 26; 9, 27; 10, 28; 11, 29; 13, 30; 14, 31; 15, 32; 16, 33; 17, 34; 17, 35; 17, 36; 18, 37; 19, 38; 20, 39; 20, 40; 21, 41; 22, 42; 24, 43; 24, 44; 25, 45; 26, 46; 26, 47; 27, 48; 27, 49; 28, 50; 28, 51; 29, 52; 29, 53; 30, 54; 30, 55; 31, 56; 31, 57; 32, 58; 32, 59; 33, 60; 33, 61; 36, 62; 37, 63; 37, 64; 38, 65; 38, 66; 39, 67; 40, 68; 41, 69; 41, 70; 44, 71; 44, 72; 45, 73; 47, 74; 49, 75; 49, 76; 49, 77; 51, 78; 51, 79; 53, 80; 53, 81; 55, 82; 55, 83; 55, 84; 55, 85; 55, 86; 55, 87; 55, 88; 55, 89; 57, 90; 57, 91; 59, 92; 59, 93; 60, 94; 60, 95; 61, 96; 62, 97; 64, 98; 64, 99; 65, 100; 65, 101; 67, 102; 68, 103; 69, 104; 69, 105; 70, 106; 71, 107; 71, 108; 72, 109; 73, 110; 73, 111; 74, 112; 76, 113; 76, 114; 77, 115; 79, 116; 79, 117; 81, 118; 82, 119; 83, 120; 84, 121; 85, 122; 86, 123; 87, 124; 88, 125; 89, 126; 90, 127; 90, 128; 92, 129; 92, 130; 93, 131; 93, 132; 97, 133; 97, 134; 99, 135; 102, 136; 102, 137; 103, 138; 103, 139; 107, 140; 109, 141; 111, 142; 111, 143; 117, 144; 117, 145; 119, 146; 119, 147; 119, 148; 132, 149; 132, 150; 133, 151; 133, 152; 134, 153; 135, 154; 135, 155; 136, 156; 136, 157; 137, 158; 138, 159; 138, 160; 139, 161; 141, 162; 141, 163; 142, 164; 142, 165; 143, 166; 143, 167; 145, 168; 145, 169; 150, 170; 154, 171; 154, 172; 157, 173; 157, 174; 166, 175; 166, 176; 167, 177; 167, 178; 169, 179; 174, 180; 176, 181; 178, 182 | def compress_and_sort_index(self):
"""Sort index, add header, and compress.
:rtype: bool
:returns: True
"""
idx_fname = '{name}.{date}.mbox.csv'.format(**self.__dict__)
try:
reader = csv.reader(open(idx_fname), dialect='excel-tab')
except IOError:
return False
index = [x for x in reader if x]
sorted_index = sorted(index, key=itemgetter(0))
gzip_idx_fname = idx_fname + '.gz'
# Include UTF-8 BOM in header.
header = [
'\xef\xbb\xbf#date', 'msg_id', 'from', 'newsgroups', 'subject', 'references',
'start', 'length',
]
s = cStringIO.StringIO()
writer = csv.writer(s, dialect='excel-tab')
writer.writerow(header)
for line in sorted_index:
writer.writerow(line)
compressed_index = inline_compress_chunk(s.getvalue())
s.close()
with open(gzip_idx_fname, 'ab') as fp:
fp.write(compressed_index)
os.remove(idx_fname)
return True |
0, module; 1, function_definition; 2, function_name:_sort; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, comment:"""
Sort versions by their version number
"""; 9, assignment; 10, attribute; 11, call; 12, identifier:self; 13, identifier:versions; 14, identifier:OrderedDict; 15, argument_list; 16, call; 17, identifier:sorted; 18, argument_list; 19, call; 20, keyword_argument; 21, attribute; 22, argument_list; 23, identifier:key; 24, lambda; 25, attribute; 26, identifier:items; 27, lambda_parameters; 28, subscript; 29, identifier:self; 30, identifier:versions; 31, identifier:v; 32, identifier:v; 33, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 9, 10; 9, 11; 10, 12; 10, 13; 11, 14; 11, 15; 15, 16; 16, 17; 16, 18; 18, 19; 18, 20; 19, 21; 19, 22; 20, 23; 20, 24; 21, 25; 21, 26; 24, 27; 24, 28; 25, 29; 25, 30; 27, 31; 28, 32; 28, 33 | def _sort(self):
"""
Sort versions by their version number
"""
self.versions = OrderedDict(sorted(self.versions.items(), key=lambda v: v[0])) |
0, module; 1, function_definition; 2, function_name:get_workspace_activities; 3, parameters; 4, block; 5, identifier:brain; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, identifier:limit; 12, integer:1; 13, comment:""" Return the workspace activities sorted by reverse chronological
order
Regarding the time value:
- the datetime value contains the time in international format
(machine readable)
- the title value contains the absolute date and time of the post
"""; 14, assignment; 15, assignment; 16, list_comprehension; 17, identifier:mb; 18, call; 19, identifier:items; 20, call; 21, dictionary; 22, for_in_clause; 23, identifier:queryUtility; 24, argument_list; 25, attribute; 26, argument_list; 27, pair; 28, pair; 29, pair; 30, pair; 31, identifier:item; 32, identifier:items; 33, identifier:IMicroblogTool; 34, identifier:mb; 35, identifier:context_values; 36, call; 37, keyword_argument; 38, string; 39, attribute; 40, string; 41, string; 42, string; 43, attribute; 44, string; 45, dictionary; 46, attribute; 47, argument_list; 48, identifier:limit; 49, identifier:limit; 50, string_content:subject; 51, identifier:item; 52, identifier:creator; 53, string_content:verb; 54, string_content:published; 55, string_content:object; 56, identifier:item; 57, identifier:text; 58, string_content:time; 59, pair; 60, pair; 61, identifier:brain; 62, identifier:getObject; 63, string; 64, call; 65, string; 66, call; 67, string_content:datetime; 68, attribute; 69, argument_list; 70, string_content:title; 71, attribute; 72, argument_list; 73, attribute; 74, identifier:strftime; 75, string; 76, attribute; 77, identifier:strftime; 78, string; 79, identifier:item; 80, identifier:date; 81, string_content:%Y-%m-%d; 82, identifier:item; 83, identifier:date; 84, string_content:%d %B %Y, %H:%M | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 18, 23; 18, 24; 20, 25; 20, 26; 21, 27; 21, 28; 21, 29; 21, 30; 22, 31; 22, 32; 24, 33; 25, 34; 25, 35; 26, 36; 26, 37; 27, 38; 27, 39; 28, 40; 28, 41; 29, 42; 29, 43; 30, 44; 30, 45; 36, 46; 36, 47; 37, 48; 37, 49; 38, 50; 39, 51; 39, 52; 40, 53; 41, 54; 42, 55; 43, 56; 43, 57; 44, 58; 45, 59; 45, 60; 46, 61; 46, 62; 59, 63; 59, 64; 60, 65; 60, 66; 63, 67; 64, 68; 64, 69; 65, 70; 66, 71; 66, 72; 68, 73; 68, 74; 69, 75; 71, 76; 71, 77; 72, 78; 73, 79; 73, 80; 75, 81; 76, 82; 76, 83; 78, 84 | def get_workspace_activities(brain, limit=1):
""" Return the workspace activities sorted by reverse chronological
order
Regarding the time value:
- the datetime value contains the time in international format
(machine readable)
- the title value contains the absolute date and time of the post
"""
mb = queryUtility(IMicroblogTool)
items = mb.context_values(brain.getObject(), limit=limit)
return [
{
'subject': item.creator,
'verb': 'published',
'object': item.text,
'time': {
'datetime': item.date.strftime('%Y-%m-%d'),
'title': item.date.strftime('%d %B %Y, %H:%M'),
}
} for item in items
] |
0, module; 1, function_definition; 2, function_name:sort_by; 3, parameters; 4, block; 5, identifier:items; 6, identifier:attr; 7, expression_statement; 8, function_definition; 9, return_statement; 10, comment:"""
General sort filter - sorts by either attribute or key.
"""; 11, function_name:key_func; 12, parameters; 13, block; 14, call; 15, identifier:item; 16, try_statement; 17, identifier:sorted; 18, argument_list; 19, block; 20, except_clause; 21, identifier:items; 22, keyword_argument; 23, return_statement; 24, identifier:AttributeError; 25, block; 26, identifier:key; 27, identifier:key_func; 28, call; 29, try_statement; 30, identifier:getattr; 31, argument_list; 32, block; 33, except_clause; 34, identifier:item; 35, identifier:attr; 36, return_statement; 37, identifier:TypeError; 38, block; 39, subscript; 40, expression_statement; 41, comment:# Reraise AttributeError; 42, identifier:item; 43, identifier:attr; 44, call; 45, identifier:getattr; 46, argument_list; 47, identifier:item; 48, identifier:attr | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 7, 10; 8, 11; 8, 12; 8, 13; 9, 14; 12, 15; 13, 16; 14, 17; 14, 18; 16, 19; 16, 20; 18, 21; 18, 22; 19, 23; 20, 24; 20, 25; 22, 26; 22, 27; 23, 28; 25, 29; 28, 30; 28, 31; 29, 32; 29, 33; 31, 34; 31, 35; 32, 36; 33, 37; 33, 38; 36, 39; 38, 40; 38, 41; 39, 42; 39, 43; 40, 44; 44, 45; 44, 46; 46, 47; 46, 48 | def sort_by(items, attr):
"""
General sort filter - sorts by either attribute or key.
"""
def key_func(item):
try:
return getattr(item, attr)
except AttributeError:
try:
return item[attr]
except TypeError:
getattr(item, attr) # Reraise AttributeError
return sorted(items, key=key_func) |
0, module; 1, function_definition; 2, function_name:sorted_migrations; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, if_statement; 8, return_statement; 9, comment:"""
Sort migrations if necessary and store in self._sorted_migrations
"""; 10, not_operator; 11, block; 12, attribute; 13, attribute; 14, expression_statement; 15, identifier:self; 16, identifier:_sorted_migrations; 17, identifier:self; 18, identifier:_sorted_migrations; 19, assignment; 20, attribute; 21, call; 22, identifier:self; 23, identifier:_sorted_migrations; 24, identifier:sorted; 25, argument_list; 26, call; 27, comment:# sort on the key... the migration number; 28, keyword_argument; 29, attribute; 30, argument_list; 31, identifier:key; 32, lambda; 33, attribute; 34, identifier:items; 35, lambda_parameters; 36, subscript; 37, identifier:self; 38, identifier:migration_registry; 39, identifier:migration_tuple; 40, identifier:migration_tuple; 41, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 7, 11; 8, 12; 10, 13; 11, 14; 12, 15; 12, 16; 13, 17; 13, 18; 14, 19; 19, 20; 19, 21; 20, 22; 20, 23; 21, 24; 21, 25; 25, 26; 25, 27; 25, 28; 26, 29; 26, 30; 28, 31; 28, 32; 29, 33; 29, 34; 32, 35; 32, 36; 33, 37; 33, 38; 35, 39; 36, 40; 36, 41 | def sorted_migrations(self):
"""
Sort migrations if necessary and store in self._sorted_migrations
"""
if not self._sorted_migrations:
self._sorted_migrations = sorted(
self.migration_registry.items(),
# sort on the key... the migration number
key=lambda migration_tuple: migration_tuple[0])
return self._sorted_migrations |
0, module; 1, function_definition; 2, function_name:_sorter; 3, parameters; 4, block; 5, identifier:generated; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, comment:"""Return a list of paths sorted by dirname & basename."""; 11, assignment; 12, call; 13, list_comprehension; 14, identifier:pairs; 15, list_comprehension; 16, attribute; 17, argument_list; 18, call; 19, for_in_clause; 20, tuple; 21, for_in_clause; 22, identifier:pairs; 23, identifier:sort; 24, attribute; 25, argument_list; 26, identifier:pair; 27, identifier:pairs; 28, call; 29, call; 30, identifier:f; 31, call; 32, attribute; 33, identifier:join; 34, subscript; 35, subscript; 36, attribute; 37, argument_list; 38, attribute; 39, argument_list; 40, identifier:set; 41, argument_list; 42, identifier:os; 43, identifier:path; 44, identifier:pair; 45, integer:0; 46, identifier:pair; 47, integer:1; 48, attribute; 49, identifier:dirname; 50, identifier:f; 51, attribute; 52, identifier:basename; 53, identifier:f; 54, call; 55, identifier:os; 56, identifier:path; 57, identifier:os; 58, identifier:path; 59, identifier:list; 60, argument_list; 61, identifier:generated | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 9, 13; 11, 14; 11, 15; 12, 16; 12, 17; 13, 18; 13, 19; 15, 20; 15, 21; 16, 22; 16, 23; 18, 24; 18, 25; 19, 26; 19, 27; 20, 28; 20, 29; 21, 30; 21, 31; 24, 32; 24, 33; 25, 34; 25, 35; 28, 36; 28, 37; 29, 38; 29, 39; 31, 40; 31, 41; 32, 42; 32, 43; 34, 44; 34, 45; 35, 46; 35, 47; 36, 48; 36, 49; 37, 50; 38, 51; 38, 52; 39, 53; 41, 54; 48, 55; 48, 56; 51, 57; 51, 58; 54, 59; 54, 60; 60, 61 | def _sorter(generated):
"""Return a list of paths sorted by dirname & basename."""
pairs = [(os.path.dirname(f), os.path.basename(f))
for f in set(list(generated))]
pairs.sort()
return [os.path.join(pair[0], pair[1]) for pair in pairs] |
0, module; 1, function_definition; 2, function_name:regionsIntersection; 3, parameters; 4, block; 5, identifier:s1; 6, identifier:s2; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, comment:# we don't need to explicitly check for sorting because sorted order is; 11, comment:# a post-condition of the collapsing function; 12, expression_statement; 13, expression_statement; 14, if_statement; 15, expression_statement; 16, expression_statement; 17, for_statement; 18, return_statement; 19, identifier:collapse; 20, True; 21, comment:"""
given two lists of genomic regions with chromosome, start and end
coordinates, return a new list of regions which is the intersection of those
two sets. Lists must be sorted by chromosome and start index
:return: new list that represents the intersection of the two input lists.
output regions will all have name "X", be on strand "+" and have
score 0
:param s1: first list of genomic regions
:param s2: second list of genomic regions
:raise GenomicIntervalError: if the input regions are not sorted correctly
(by chromosome and start index)
:note: O(n) time, O(n) space; informally, might use up to 3x space of input
"""; 22, assignment; 23, assignment; 24, assignment; 25, boolean_operator; 26, block; 27, assignment; 28, assignment; 29, identifier:i; 30, call; 31, block; 32, identifier:res; 33, identifier:debug; 34, False; 35, identifier:s1_c; 36, call; 37, identifier:s2_c; 38, call; 39, comparison_operator:len(s1_c) == 0; 40, comparison_operator:len(s2_c) == 0; 41, return_statement; 42, identifier:res; 43, list; 44, identifier:j; 45, integer:0; 46, identifier:range; 47, argument_list; 48, if_statement; 49, comment:# find first thing in s2_c with end in or after s1_c[i]; 50, if_statement; 51, while_statement; 52, comment:# nothing intersects if we hit the end of s2, or the end of the chrom,; 53, comment:# or we're still on the same chrom but start after the end of s2_c[i]; 54, if_statement; 55, comment:# now everything at or after j in s2_c that starts before; 56, comment:# the end of s1_c must overlap with it; 57, while_statement; 58, comment:# it's possible the last intersecting element runs on to the; 59, comment:# next element from s1_c, so...; 60, expression_statement; 61, if_statement; 62, identifier:collapseRegions; 63, argument_list; 64, identifier:collapseRegions; 65, argument_list; 66, call; 67, integer:0; 68, call; 69, integer:0; 70, list; 71, integer:0; 72, call; 73, identifier:debug; 74, block; 75, identifier:debug; 76, block; 77, parenthesized_expression; 78, block; 79, boolean_operator; 80, block; 81, comparison_operator:s2_c[j].start < s1_c[i].end; 82, block; 83, augmented_assignment; 84, identifier:debug; 85, block; 86, identifier:s1; 87, identifier:s2; 88, identifier:len; 89, argument_list; 90, identifier:len; 91, argument_list; 92, identifier:len; 93, argument_list; 94, expression_statement; 95, expression_statement; 96, boolean_operator; 97, expression_statement; 98, boolean_operator; 99, line_continuation:\; 100, parenthesized_expression; 101, continue_statement; 102, attribute; 103, attribute; 104, expression_statement; 105, expression_statement; 106, expression_statement; 107, if_statement; 108, expression_statement; 109, expression_statement; 110, if_statement; 111, identifier:j; 112, integer:1; 113, expression_statement; 114, identifier:s1_c; 115, identifier:s2_c; 116, identifier:s1_c; 117, call; 118, call; 119, comparison_operator:j < len(s2_c); 120, parenthesized_expression; 121, augmented_assignment; 122, comparison_operator:j >= len(s2_c); 123, comparison_operator:s2_c[j].chrom > s1_c[i].chrom; 124, boolean_operator; 125, subscript; 126, identifier:start; 127, subscript; 128, identifier:end; 129, assignment; 130, assignment; 131, assignment; 132, identifier:debug; 133, block; 134, call; 135, augmented_assignment; 136, boolean_operator; 137, block; 138, call; 139, attribute; 140, argument_list; 141, attribute; 142, argument_list; 143, identifier:j; 144, call; 145, boolean_operator; 146, identifier:j; 147, integer:1; 148, identifier:j; 149, call; 150, attribute; 151, attribute; 152, comparison_operator:s2_c[j].chrom == s1_c[i].chrom; 153, comparison_operator:s2_c[j].start >= s1_c[i].end; 154, identifier:s2_c; 155, identifier:j; 156, identifier:s1_c; 157, identifier:i; 158, identifier:s; 159, call; 160, identifier:e; 161, call; 162, identifier:overlap; 163, call; 164, expression_statement; 165, attribute; 166, argument_list; 167, identifier:j; 168, integer:1; 169, comparison_operator:j >= len(s2_c); 170, comparison_operator:s2_c[j].chrom != s1_c[i].chrom; 171, break_statement; 172, attribute; 173, argument_list; 174, attribute; 175, identifier:write; 176, binary_operator:"processing from s1_c : " + str(s1_c[i]) + "\n"; 177, attribute; 178, identifier:write; 179, binary_operator:"i = " + str(i) + " and j = " + str(j) + "\n"; 180, identifier:len; 181, argument_list; 182, comparison_operator:s2_c[j].chrom < s1_c[i].chrom; 183, parenthesized_expression; 184, identifier:len; 185, argument_list; 186, subscript; 187, identifier:chrom; 188, subscript; 189, identifier:chrom; 190, attribute; 191, attribute; 192, attribute; 193, attribute; 194, identifier:max; 195, argument_list; 196, identifier:min; 197, argument_list; 198, identifier:GenomicInterval; 199, argument_list; 200, call; 201, identifier:res; 202, identifier:append; 203, identifier:overlap; 204, identifier:j; 205, call; 206, attribute; 207, attribute; 208, attribute; 209, identifier:write; 210, binary_operator:"\tmoving s2_c index back to " + str(s2_c[j]) + "\n"; 211, identifier:sys; 212, identifier:stderr; 213, binary_operator:"processing from s1_c : " + str(s1_c[i]); 214, string:"\n"; 215, identifier:sys; 216, identifier:stderr; 217, binary_operator:"i = " + str(i) + " and j = " + str(j); 218, string:"\n"; 219, identifier:s2_c; 220, attribute; 221, attribute; 222, boolean_operator; 223, identifier:s2_c; 224, identifier:s2_c; 225, identifier:j; 226, identifier:s1_c; 227, identifier:i; 228, subscript; 229, identifier:chrom; 230, subscript; 231, identifier:chrom; 232, subscript; 233, identifier:start; 234, subscript; 235, identifier:end; 236, attribute; 237, attribute; 238, attribute; 239, attribute; 240, attribute; 241, identifier:s; 242, identifier:e; 243, string:"X"; 244, integer:0; 245, string:"+"; 246, attribute; 247, argument_list; 248, identifier:len; 249, argument_list; 250, subscript; 251, identifier:chrom; 252, subscript; 253, identifier:chrom; 254, identifier:sys; 255, identifier:stderr; 256, binary_operator:"\tmoving s2_c index back to " + str(s2_c[j]); 257, string:"\n"; 258, string:"processing from s1_c : "; 259, call; 260, binary_operator:"i = " + str(i) + " and j = "; 261, call; 262, subscript; 263, identifier:chrom; 264, subscript; 265, identifier:chrom; 266, comparison_operator:s2_c[j].chrom == s1_c[i].chrom; 267, comparison_operator:s2_c[j].end <= s1_c[i].start; 268, identifier:s2_c; 269, identifier:j; 270, identifier:s1_c; 271, identifier:i; 272, identifier:s2_c; 273, identifier:j; 274, identifier:s1_c; 275, identifier:i; 276, subscript; 277, identifier:start; 278, subscript; 279, identifier:start; 280, subscript; 281, identifier:end; 282, subscript; 283, identifier:end; 284, subscript; 285, identifier:chrom; 286, attribute; 287, identifier:write; 288, binary_operator:"\tadding to overlaps: " + str(overlap) + "\n"; 289, identifier:s2_c; 290, identifier:s2_c; 291, identifier:j; 292, identifier:s1_c; 293, identifier:i; 294, string:"\tmoving s2_c index back to "; 295, call; 296, identifier:str; 297, argument_list; 298, binary_operator:"i = " + str(i); 299, string:" and j = "; 300, identifier:str; 301, argument_list; 302, identifier:s2_c; 303, identifier:j; 304, identifier:s1_c; 305, identifier:i; 306, attribute; 307, attribute; 308, attribute; 309, attribute; 310, identifier:s1_c; 311, identifier:i; 312, identifier:s2_c; 313, identifier:j; 314, identifier:s1_c; 315, identifier:i; 316, identifier:s2_c; 317, identifier:j; 318, identifier:s1_c; 319, identifier:i; 320, identifier:sys; 321, identifier:stderr; 322, binary_operator:"\tadding to overlaps: " + str(overlap); 323, string:"\n"; 324, identifier:str; 325, argument_list; 326, subscript; 327, string:"i = "; 328, call; 329, identifier:j; 330, subscript; 331, identifier:chrom; 332, subscript; 333, identifier:chrom; 334, subscript; 335, identifier:end; 336, subscript; 337, identifier:start; 338, string:"\tadding to overlaps: "; 339, call; 340, subscript; 341, identifier:s1_c; 342, identifier:i; 343, identifier:str; 344, argument_list; 345, identifier:s2_c; 346, identifier:j; 347, identifier:s1_c; 348, identifier:i; 349, identifier:s2_c; 350, identifier:j; 351, identifier:s1_c; 352, identifier:i; 353, identifier:str; 354, argument_list; 355, identifier:s2_c; 356, identifier:j; 357, identifier:i; 358, identifier:overlap | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 7, 19; 7, 20; 8, 21; 9, 22; 12, 23; 13, 24; 14, 25; 14, 26; 15, 27; 16, 28; 17, 29; 17, 30; 17, 31; 18, 32; 22, 33; 22, 34; 23, 35; 23, 36; 24, 37; 24, 38; 25, 39; 25, 40; 26, 41; 27, 42; 27, 43; 28, 44; 28, 45; 30, 46; 30, 47; 31, 48; 31, 49; 31, 50; 31, 51; 31, 52; 31, 53; 31, 54; 31, 55; 31, 56; 31, 57; 31, 58; 31, 59; 31, 60; 31, 61; 36, 62; 36, 63; 38, 64; 38, 65; 39, 66; 39, 67; 40, 68; 40, 69; 41, 70; 47, 71; 47, 72; 48, 73; 48, 74; 50, 75; 50, 76; 51, 77; 51, 78; 54, 79; 54, 80; 57, 81; 57, 82; 60, 83; 61, 84; 61, 85; 63, 86; 65, 87; 66, 88; 66, 89; 68, 90; 68, 91; 72, 92; 72, 93; 74, 94; 76, 95; 77, 96; 78, 97; 79, 98; 79, 99; 79, 100; 80, 101; 81, 102; 81, 103; 82, 104; 82, 105; 82, 106; 82, 107; 82, 108; 82, 109; 82, 110; 83, 111; 83, 112; 85, 113; 89, 114; 91, 115; 93, 116; 94, 117; 95, 118; 96, 119; 96, 120; 97, 121; 98, 122; 98, 123; 100, 124; 102, 125; 102, 126; 103, 127; 103, 128; 104, 129; 105, 130; 106, 131; 107, 132; 107, 133; 108, 134; 109, 135; 110, 136; 110, 137; 113, 138; 117, 139; 117, 140; 118, 141; 118, 142; 119, 143; 119, 144; 120, 145; 121, 146; 121, 147; 122, 148; 122, 149; 123, 150; 123, 151; 124, 152; 124, 153; 125, 154; 125, 155; 127, 156; 127, 157; 129, 158; 129, 159; 130, 160; 130, 161; 131, 162; 131, 163; 133, 164; 134, 165; 134, 166; 135, 167; 135, 168; 136, 169; 136, 170; 137, 171; 138, 172; 138, 173; 139, 174; 139, 175; 140, 176; 141, 177; 141, 178; 142, 179; 144, 180; 144, 181; 145, 182; 145, 183; 149, 184; 149, 185; 150, 186; 150, 187; 151, 188; 151, 189; 152, 190; 152, 191; 153, 192; 153, 193; 159, 194; 159, 195; 161, 196; 161, 197; 163, 198; 163, 199; 164, 200; 165, 201; 165, 202; 166, 203; 169, 204; 169, 205; 170, 206; 170, 207; 172, 208; 172, 209; 173, 210; 174, 211; 174, 212; 176, 213; 176, 214; 177, 215; 177, 216; 179, 217; 179, 218; 181, 219; 182, 220; 182, 221; 183, 222; 185, 223; 186, 224; 186, 225; 188, 226; 188, 227; 190, 228; 190, 229; 191, 230; 191, 231; 192, 232; 192, 233; 193, 234; 193, 235; 195, 236; 195, 237; 197, 238; 197, 239; 199, 240; 199, 241; 199, 242; 199, 243; 199, 244; 199, 245; 200, 246; 200, 247; 205, 248; 205, 249; 206, 250; 206, 251; 207, 252; 207, 253; 208, 254; 208, 255; 210, 256; 210, 257; 213, 258; 213, 259; 217, 260; 217, 261; 220, 262; 220, 263; 221, 264; 221, 265; 222, 266; 222, 267; 228, 268; 228, 269; 230, 270; 230, 271; 232, 272; 232, 273; 234, 274; 234, 275; 236, 276; 236, 277; 237, 278; 237, 279; 238, 280; 238, 281; 239, 282; 239, 283; 240, 284; 240, 285; 246, 286; 246, 287; 247, 288; 249, 289; 250, 290; 250, 291; 252, 292; 252, 293; 256, 294; 256, 295; 259, 296; 259, 297; 260, 298; 260, 299; 261, 300; 261, 301; 262, 302; 262, 303; 264, 304; 264, 305; 266, 306; 266, 307; 267, 308; 267, 309; 276, 310; 276, 311; 278, 312; 278, 313; 280, 314; 280, 315; 282, 316; 282, 317; 284, 318; 284, 319; 286, 320; 286, 321; 288, 322; 288, 323; 295, 324; 295, 325; 297, 326; 298, 327; 298, 328; 301, 329; 306, 330; 306, 331; 307, 332; 307, 333; 308, 334; 308, 335; 309, 336; 309, 337; 322, 338; 322, 339; 325, 340; 326, 341; 326, 342; 328, 343; 328, 344; 330, 345; 330, 346; 332, 347; 332, 348; 334, 349; 334, 350; 336, 351; 336, 352; 339, 353; 339, 354; 340, 355; 340, 356; 344, 357; 354, 358 | def regionsIntersection(s1, s2, collapse=True):
"""
given two lists of genomic regions with chromosome, start and end
coordinates, return a new list of regions which is the intersection of those
two sets. Lists must be sorted by chromosome and start index
:return: new list that represents the intersection of the two input lists.
output regions will all have name "X", be on strand "+" and have
score 0
:param s1: first list of genomic regions
:param s2: second list of genomic regions
:raise GenomicIntervalError: if the input regions are not sorted correctly
(by chromosome and start index)
:note: O(n) time, O(n) space; informally, might use up to 3x space of input
"""
debug = False
# we don't need to explicitly check for sorting because sorted order is
# a post-condition of the collapsing function
s1_c = collapseRegions(s1)
s2_c = collapseRegions(s2)
if len(s1_c) == 0 or len(s2_c) == 0:
return []
res = []
j = 0
for i in range(0, len(s1_c)):
if debug:
sys.stderr.write("processing from s1_c : " + str(s1_c[i]) + "\n")
# find first thing in s2_c with end in or after s1_c[i]
if debug:
sys.stderr.write("i = " + str(i) + " and j = " + str(j) + "\n")
while (j < len(s2_c) and
(s2_c[j].chrom < s1_c[i].chrom or
(s2_c[j].chrom == s1_c[i].chrom and s2_c[j].end <= s1_c[i].start))):
j += 1
# nothing intersects if we hit the end of s2, or the end of the chrom,
# or we're still on the same chrom but start after the end of s2_c[i]
if j >= len(s2_c) or s2_c[j].chrom > s1_c[i].chrom or \
(s2_c[j].chrom == s1_c[i].chrom and s2_c[j].start >= s1_c[i].end):
continue
# now everything at or after j in s2_c that starts before
# the end of s1_c must overlap with it
while s2_c[j].start < s1_c[i].end:
s = max(s1_c[i].start, s2_c[j].start)
e = min(s1_c[i].end, s2_c[j].end)
overlap = GenomicInterval(s1_c[i].chrom, s, e, "X", 0, "+")
if debug:
sys.stderr.write("\tadding to overlaps: " + str(overlap) + "\n")
res.append(overlap)
j += 1
if j >= len(s2_c) or s2_c[j].chrom != s1_c[i].chrom:
break
# it's possible the last intersecting element runs on to the
# next element from s1_c, so...
j -= 1
if debug:
sys.stderr.write("\tmoving s2_c index back to " + str(s2_c[j]) + "\n")
return res |
0, module; 1, function_definition; 2, function_name:bucketIterator; 3, parameters; 4, block; 5, identifier:elements; 6, identifier:buckets; 7, expression_statement; 8, function_definition; 9, function_definition; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, for_statement; 14, comment:"""
For each bucket in buckets, yield it and any elements that overlap it.
:param elements: the genomic intervals to place into the buckets. Must be
sorted by chromosome and start index. This could be a
list, or an iterator.
:param buckets: the buckets into which genomic intervals should be binned.
Must be sorted by chromosome and start index. This could be
a list, or an iterator
:return: iterator that will yeild a tuple of 1 bucket and 1 list of elements
in the bucket for each call to __next__().
"""; 15, function_name:check_sorted; 16, parameters; 17, block; 18, function_name:updateOpen; 19, parameters; 20, block; 21, assignment; 22, assignment; 23, assignment; 24, identifier:bucket; 25, identifier:buckets; 26, comment:# make sure the buckets are sorted by start index; 27, block; 28, identifier:current; 29, identifier:previous; 30, if_statement; 31, identifier:openHeap; 32, identifier:elementIterator; 33, identifier:bucketChrom; 34, identifier:bucketStart; 35, identifier:bucketEnd; 36, expression_statement; 37, comment:# first, we're going to pop elements from the heap which can no longer; 38, comment:# overalp this or any future buckets. Buckets are sorted by start, so; 39, comment:# we'll never see another bucket that starts earlier than this one --; 40, comment:# hence any elements that end before the start of this bucket will never be; 41, comment:# used again and can be dropped. Elements in the heap are ordered by end; 42, comment:# index, so once we reach an element in the heap that does not end before; 43, comment:# the start of this bucket, we are sure that no others will come after it; 44, comment:# which do end before the start of this bucket. So we can stop dropping.; 45, while_statement; 46, comment:# now we're going to add new elements from the iterator to the heap. As; 47, comment:# we know that elements in the iterator are sorted by start index, we know; 48, comment:# that once we see an element that has a start index greater than the end; 49, comment:# of this bucket, we can stop -- everything else after it will also start; 50, comment:# after the end of this bucket.; 51, while_statement; 52, identifier:openElems; 53, list; 54, identifier:prevBucket; 55, None; 56, identifier:elementIter; 57, call; 58, if_statement; 59, expression_statement; 60, comment:# be careful here not to leak a reference to the heap; if the caller; 61, comment:# decides to mess with that list, it'll screw us up. Anyway, we need a; 62, comment:# final check here to make sure we trim off any elements that exceed the; 63, comment:# end of this bucket.; 64, expression_statement; 65, expression_statement; 66, boolean_operator; 67, block; 68, comment:"""
Drop elements from heap which start earlier than current bucket.
Update the open heap so that it contains only elements that end after the
start of the current bucket. Note that the heap may already contain some
elements that start after the end of the current bucket, if a previous
bucket ended after the end of this one and brought them into the set.
:param openHeap: a min heap of elements; uses the default sorting order
for the genomic intervals, which is by end index. This
is what we're updating.
:param elementIterator: an iterator from which we will pull new elements.
Elements yielded by this iterator must be sorted
by start index. Must be 'peakable'
:param bucketChrom: the chromosome of the current bucket.
:param bucketStart: the start index of the current bucket.
:param bucketEnd: the end index of the current bucket.
"""; 69, boolean_operator; 70, block; 71, boolean_operator; 72, block; 73, identifier:AutoApplyIterator; 74, argument_list; 75, boolean_operator; 76, block; 77, call; 78, yield; 79, assignment; 80, parenthesized_expression; 81, line_continuation:\; 82, parenthesized_expression; 83, raise_statement; 84, comparison_operator:len(openHeap) > 0; 85, parenthesized_expression; 86, expression_statement; 87, parenthesized_expression; 88, line_continuation:\; 89, parenthesized_expression; 90, expression_statement; 91, comment:# if e falls before this bucket, we can skip it; buckets are sorted by; 92, comment:# start, so no other buckets start earlier than this one and so it; 93, comment:# cannot intersect any others.; 94, if_statement; 95, comment:# now we know e intersects this bucket..; 96, expression_statement; 97, identifier:elements; 98, identifier:check_sorted; 99, comparison_operator:prevBucket is not None; 100, parenthesized_expression; 101, raise_statement; 102, identifier:updateOpen; 103, argument_list; 104, expression_list; 105, identifier:prevBucket; 106, identifier:bucket; 107, comparison_operator:previous is not None; 108, boolean_operator; 109, call; 110, call; 111, integer:0; 112, boolean_operator; 113, call; 114, comparison_operator:elementIterator.peek() is not None; 115, boolean_operator; 116, assignment; 117, boolean_operator; 118, block; 119, call; 120, identifier:prevBucket; 121, None; 122, boolean_operator; 123, call; 124, identifier:openElems; 125, identifier:elementIter; 126, attribute; 127, attribute; 128, attribute; 129, identifier:bucket; 130, list_comprehension; 131, identifier:previous; 132, None; 133, parenthesized_expression; 134, parenthesized_expression; 135, identifier:GenomicIntervalError; 136, argument_list; 137, identifier:len; 138, argument_list; 139, parenthesized_expression; 140, parenthesized_expression; 141, identifier:heappop; 142, argument_list; 143, call; 144, None; 145, parenthesized_expression; 146, parenthesized_expression; 147, identifier:e; 148, call; 149, parenthesized_expression; 150, line_continuation:\; 151, parenthesized_expression; 152, continue_statement; 153, identifier:heappush; 154, argument_list; 155, parenthesized_expression; 156, parenthesized_expression; 157, identifier:GenomicIntervalError; 158, argument_list; 159, identifier:bucket; 160, identifier:chrom; 161, identifier:bucket; 162, identifier:start; 163, identifier:bucket; 164, identifier:end; 165, identifier:x; 166, for_in_clause; 167, if_clause; 168, comparison_operator:previous.chrom > current.chrom; 169, boolean_operator; 170, binary_operator:"elements not sorted. Saw " +
str(previous) + " before " + str(current); 171, identifier:openHeap; 172, comparison_operator:openHeap[0].chrom < bucketChrom; 173, boolean_operator; 174, identifier:openHeap; 175, attribute; 176, argument_list; 177, comparison_operator:elementIterator.peek().chrom < bucketChrom; 178, boolean_operator; 179, attribute; 180, argument_list; 181, comparison_operator:e.chrom < bucketChrom; 182, boolean_operator; 183, identifier:openHeap; 184, identifier:e; 185, comparison_operator:bucket.chrom < prevBucket.chrom; 186, boolean_operator; 187, binary_operator:"regions-of-interest are not sorted. Saw " +
str(prevBucket) + " before " + str(bucket); 188, identifier:x; 189, identifier:openElems; 190, comparison_operator:x.start < bucket.end; 191, attribute; 192, attribute; 193, parenthesized_expression; 194, parenthesized_expression; 195, binary_operator:"elements not sorted. Saw " +
str(previous) + " before "; 196, call; 197, attribute; 198, identifier:bucketChrom; 199, parenthesized_expression; 200, parenthesized_expression; 201, identifier:elementIterator; 202, identifier:peek; 203, attribute; 204, identifier:bucketChrom; 205, parenthesized_expression; 206, parenthesized_expression; 207, identifier:elementIterator; 208, identifier:__next__; 209, attribute; 210, identifier:bucketChrom; 211, comparison_operator:e.chrom == bucketChrom; 212, comparison_operator:e.end <= bucketStart; 213, attribute; 214, attribute; 215, comparison_operator:bucket.chrom == prevBucket.chrom; 216, comparison_operator:bucket.start < prevBucket.start; 217, binary_operator:"regions-of-interest are not sorted. Saw " +
str(prevBucket) + " before "; 218, call; 219, attribute; 220, attribute; 221, identifier:previous; 222, identifier:chrom; 223, identifier:current; 224, identifier:chrom; 225, comparison_operator:previous.chrom == current.chrom; 226, comparison_operator:previous.start > current.start; 227, binary_operator:"elements not sorted. Saw " +
str(previous); 228, string:" before "; 229, identifier:str; 230, argument_list; 231, subscript; 232, identifier:chrom; 233, comparison_operator:openHeap[0].chrom == bucketChrom; 234, comparison_operator:openHeap[0].end <= bucketStart; 235, call; 236, identifier:chrom; 237, comparison_operator:elementIterator.peek().chrom == bucketChrom; 238, comparison_operator:elementIterator.peek().start < bucketEnd; 239, identifier:e; 240, identifier:chrom; 241, attribute; 242, identifier:bucketChrom; 243, attribute; 244, identifier:bucketStart; 245, identifier:bucket; 246, identifier:chrom; 247, identifier:prevBucket; 248, identifier:chrom; 249, attribute; 250, attribute; 251, attribute; 252, attribute; 253, binary_operator:"regions-of-interest are not sorted. Saw " +
str(prevBucket); 254, string:" before "; 255, identifier:str; 256, argument_list; 257, identifier:x; 258, identifier:start; 259, identifier:bucket; 260, identifier:end; 261, attribute; 262, attribute; 263, attribute; 264, attribute; 265, string:"elements not sorted. Saw "; 266, call; 267, identifier:current; 268, identifier:openHeap; 269, integer:0; 270, attribute; 271, identifier:bucketChrom; 272, attribute; 273, identifier:bucketStart; 274, attribute; 275, argument_list; 276, attribute; 277, identifier:bucketChrom; 278, attribute; 279, identifier:bucketEnd; 280, identifier:e; 281, identifier:chrom; 282, identifier:e; 283, identifier:end; 284, identifier:bucket; 285, identifier:chrom; 286, identifier:prevBucket; 287, identifier:chrom; 288, identifier:bucket; 289, identifier:start; 290, identifier:prevBucket; 291, identifier:start; 292, string:"regions-of-interest are not sorted. Saw "; 293, call; 294, identifier:bucket; 295, identifier:previous; 296, identifier:chrom; 297, identifier:current; 298, identifier:chrom; 299, identifier:previous; 300, identifier:start; 301, identifier:current; 302, identifier:start; 303, identifier:str; 304, argument_list; 305, subscript; 306, identifier:chrom; 307, subscript; 308, identifier:end; 309, identifier:elementIterator; 310, identifier:peek; 311, call; 312, identifier:chrom; 313, call; 314, identifier:start; 315, identifier:str; 316, argument_list; 317, identifier:previous; 318, identifier:openHeap; 319, integer:0; 320, identifier:openHeap; 321, integer:0; 322, attribute; 323, argument_list; 324, attribute; 325, argument_list; 326, identifier:prevBucket; 327, identifier:elementIterator; 328, identifier:peek; 329, identifier:elementIterator; 330, identifier:peek | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 8, 15; 8, 16; 8, 17; 9, 18; 9, 19; 9, 20; 10, 21; 11, 22; 12, 23; 13, 24; 13, 25; 13, 26; 13, 27; 16, 28; 16, 29; 17, 30; 19, 31; 19, 32; 19, 33; 19, 34; 19, 35; 20, 36; 20, 37; 20, 38; 20, 39; 20, 40; 20, 41; 20, 42; 20, 43; 20, 44; 20, 45; 20, 46; 20, 47; 20, 48; 20, 49; 20, 50; 20, 51; 21, 52; 21, 53; 22, 54; 22, 55; 23, 56; 23, 57; 27, 58; 27, 59; 27, 60; 27, 61; 27, 62; 27, 63; 27, 64; 27, 65; 30, 66; 30, 67; 36, 68; 45, 69; 45, 70; 51, 71; 51, 72; 57, 73; 57, 74; 58, 75; 58, 76; 59, 77; 64, 78; 65, 79; 66, 80; 66, 81; 66, 82; 67, 83; 69, 84; 69, 85; 70, 86; 71, 87; 71, 88; 71, 89; 72, 90; 72, 91; 72, 92; 72, 93; 72, 94; 72, 95; 72, 96; 74, 97; 74, 98; 75, 99; 75, 100; 76, 101; 77, 102; 77, 103; 78, 104; 79, 105; 79, 106; 80, 107; 82, 108; 83, 109; 84, 110; 84, 111; 85, 112; 86, 113; 87, 114; 89, 115; 90, 116; 94, 117; 94, 118; 96, 119; 99, 120; 99, 121; 100, 122; 101, 123; 103, 124; 103, 125; 103, 126; 103, 127; 103, 128; 104, 129; 104, 130; 107, 131; 107, 132; 108, 133; 108, 134; 109, 135; 109, 136; 110, 137; 110, 138; 112, 139; 112, 140; 113, 141; 113, 142; 114, 143; 114, 144; 115, 145; 115, 146; 116, 147; 116, 148; 117, 149; 117, 150; 117, 151; 118, 152; 119, 153; 119, 154; 122, 155; 122, 156; 123, 157; 123, 158; 126, 159; 126, 160; 127, 161; 127, 162; 128, 163; 128, 164; 130, 165; 130, 166; 130, 167; 133, 168; 134, 169; 136, 170; 138, 171; 139, 172; 140, 173; 142, 174; 143, 175; 143, 176; 145, 177; 146, 178; 148, 179; 148, 180; 149, 181; 151, 182; 154, 183; 154, 184; 155, 185; 156, 186; 158, 187; 166, 188; 166, 189; 167, 190; 168, 191; 168, 192; 169, 193; 169, 194; 170, 195; 170, 196; 172, 197; 172, 198; 173, 199; 173, 200; 175, 201; 175, 202; 177, 203; 177, 204; 178, 205; 178, 206; 179, 207; 179, 208; 181, 209; 181, 210; 182, 211; 182, 212; 185, 213; 185, 214; 186, 215; 186, 216; 187, 217; 187, 218; 190, 219; 190, 220; 191, 221; 191, 222; 192, 223; 192, 224; 193, 225; 194, 226; 195, 227; 195, 228; 196, 229; 196, 230; 197, 231; 197, 232; 199, 233; 200, 234; 203, 235; 203, 236; 205, 237; 206, 238; 209, 239; 209, 240; 211, 241; 211, 242; 212, 243; 212, 244; 213, 245; 213, 246; 214, 247; 214, 248; 215, 249; 215, 250; 216, 251; 216, 252; 217, 253; 217, 254; 218, 255; 218, 256; 219, 257; 219, 258; 220, 259; 220, 260; 225, 261; 225, 262; 226, 263; 226, 264; 227, 265; 227, 266; 230, 267; 231, 268; 231, 269; 233, 270; 233, 271; 234, 272; 234, 273; 235, 274; 235, 275; 237, 276; 237, 277; 238, 278; 238, 279; 241, 280; 241, 281; 243, 282; 243, 283; 249, 284; 249, 285; 250, 286; 250, 287; 251, 288; 251, 289; 252, 290; 252, 291; 253, 292; 253, 293; 256, 294; 261, 295; 261, 296; 262, 297; 262, 298; 263, 299; 263, 300; 264, 301; 264, 302; 266, 303; 266, 304; 270, 305; 270, 306; 272, 307; 272, 308; 274, 309; 274, 310; 276, 311; 276, 312; 278, 313; 278, 314; 293, 315; 293, 316; 304, 317; 305, 318; 305, 319; 307, 320; 307, 321; 311, 322; 311, 323; 313, 324; 313, 325; 316, 326; 322, 327; 322, 328; 324, 329; 324, 330 | def bucketIterator(elements, buckets):
"""
For each bucket in buckets, yield it and any elements that overlap it.
:param elements: the genomic intervals to place into the buckets. Must be
sorted by chromosome and start index. This could be a
list, or an iterator.
:param buckets: the buckets into which genomic intervals should be binned.
Must be sorted by chromosome and start index. This could be
a list, or an iterator
:return: iterator that will yeild a tuple of 1 bucket and 1 list of elements
in the bucket for each call to __next__().
"""
def check_sorted(current, previous):
if (previous is not None) and \
((previous.chrom > current.chrom) or
((previous.chrom == current.chrom) and
(previous.start > current.start))):
raise GenomicIntervalError("elements not sorted. Saw " +
str(previous) + " before " + str(current))
def updateOpen(openHeap, elementIterator, bucketChrom,
bucketStart, bucketEnd):
"""
Drop elements from heap which start earlier than current bucket.
Update the open heap so that it contains only elements that end after the
start of the current bucket. Note that the heap may already contain some
elements that start after the end of the current bucket, if a previous
bucket ended after the end of this one and brought them into the set.
:param openHeap: a min heap of elements; uses the default sorting order
for the genomic intervals, which is by end index. This
is what we're updating.
:param elementIterator: an iterator from which we will pull new elements.
Elements yielded by this iterator must be sorted
by start index. Must be 'peakable'
:param bucketChrom: the chromosome of the current bucket.
:param bucketStart: the start index of the current bucket.
:param bucketEnd: the end index of the current bucket.
"""
# first, we're going to pop elements from the heap which can no longer
# overalp this or any future buckets. Buckets are sorted by start, so
# we'll never see another bucket that starts earlier than this one --
# hence any elements that end before the start of this bucket will never be
# used again and can be dropped. Elements in the heap are ordered by end
# index, so once we reach an element in the heap that does not end before
# the start of this bucket, we are sure that no others will come after it
# which do end before the start of this bucket. So we can stop dropping.
while len(openHeap) > 0 and ((openHeap[0].chrom < bucketChrom) or
((openHeap[0].chrom == bucketChrom) and
(openHeap[0].end <= bucketStart))):
heappop(openHeap)
# now we're going to add new elements from the iterator to the heap. As
# we know that elements in the iterator are sorted by start index, we know
# that once we see an element that has a start index greater than the end
# of this bucket, we can stop -- everything else after it will also start
# after the end of this bucket.
while (elementIterator.peek() is not None) and \
((elementIterator.peek().chrom < bucketChrom) or
((elementIterator.peek().chrom == bucketChrom) and
(elementIterator.peek().start < bucketEnd))):
e = elementIterator.__next__()
# if e falls before this bucket, we can skip it; buckets are sorted by
# start, so no other buckets start earlier than this one and so it
# cannot intersect any others.
if (e.chrom < bucketChrom) or \
(e.chrom == bucketChrom and e.end <= bucketStart):
continue
# now we know e intersects this bucket..
heappush(openHeap, e)
openElems = []
prevBucket = None
elementIter = AutoApplyIterator(elements, check_sorted)
for bucket in buckets:
# make sure the buckets are sorted by start index
if prevBucket is not None and ((bucket.chrom < prevBucket.chrom) or
(bucket.chrom == prevBucket.chrom and
bucket.start < prevBucket.start)):
raise GenomicIntervalError("regions-of-interest are not sorted. Saw " +
str(prevBucket) + " before " + str(bucket))
updateOpen(openElems, elementIter, bucket.chrom, bucket. start, bucket.end)
# be careful here not to leak a reference to the heap; if the caller
# decides to mess with that list, it'll screw us up. Anyway, we need a
# final check here to make sure we trim off any elements that exceed the
# end of this bucket.
yield bucket, [x for x in openElems if x.start < bucket.end]
prevBucket = bucket |
0, module; 1, function_definition; 2, function_name:_ordered; 3, parameters; 4, block; 5, identifier:generator; 6, list_splat_pattern; 7, dictionary_splat_pattern; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, return_statement; 14, identifier:args; 15, identifier:kwargs; 16, comment:"""Sort keys of unordered_dict and store in OrderedDict."""; 17, assignment; 18, assignment; 19, assignment; 20, identifier:key; 21, identifier:keys; 22, block; 23, identifier:result; 24, identifier:unordered_dict; 25, dictionary_comprehension; 26, identifier:keys; 27, call; 28, identifier:result; 29, call; 30, expression_statement; 31, pair; 32, for_in_clause; 33, identifier:sorted; 34, argument_list; 35, identifier:OrderedDict; 36, argument_list; 37, assignment; 38, identifier:k; 39, identifier:v; 40, pattern_list; 41, call; 42, call; 43, subscript; 44, subscript; 45, identifier:k; 46, identifier:v; 47, identifier:generator; 48, argument_list; 49, identifier:list; 50, argument_list; 51, identifier:result; 52, identifier:key; 53, identifier:unordered_dict; 54, identifier:key; 55, list_splat; 56, dictionary_splat; 57, call; 58, identifier:args; 59, identifier:kwargs; 60, attribute; 61, argument_list; 62, call; 63, identifier:keys; 64, identifier:dict; 65, argument_list; 66, identifier:unordered_dict | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 6, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 12, 20; 12, 21; 12, 22; 13, 23; 17, 24; 17, 25; 18, 26; 18, 27; 19, 28; 19, 29; 22, 30; 25, 31; 25, 32; 27, 33; 27, 34; 29, 35; 29, 36; 30, 37; 31, 38; 31, 39; 32, 40; 32, 41; 34, 42; 37, 43; 37, 44; 40, 45; 40, 46; 41, 47; 41, 48; 42, 49; 42, 50; 43, 51; 43, 52; 44, 53; 44, 54; 48, 55; 48, 56; 50, 57; 55, 58; 56, 59; 57, 60; 57, 61; 60, 62; 60, 63; 62, 64; 62, 65; 65, 66 | def _ordered(generator, *args, **kwargs):
"""Sort keys of unordered_dict and store in OrderedDict."""
unordered_dict = {k: v for k, v in generator(*args, **kwargs)}
keys = sorted(list(dict(unordered_dict).keys()))
result = OrderedDict()
for key in keys:
result[key] = unordered_dict[key]
return result |
0, module; 1, function_definition; 2, function_name:str2dict_keys; 3, parameters; 4, block; 5, identifier:str_in; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, return_statement; 10, string; 11, assignment; 12, comparison_operator:tmp_dict is None; 13, block; 14, call; 15, string_content:Extracts the keys from a string that represents a dict and returns them
sorted by key.
Args:
str_in (string) that contains python dict
Returns:
(list) with keys or None if no valid dict was found
Raises:
-; 16, identifier:tmp_dict; 17, call; 18, identifier:tmp_dict; 19, None; 20, return_statement; 21, identifier:sorted; 22, argument_list; 23, identifier:str2dict; 24, argument_list; 25, None; 26, list_comprehension; 27, identifier:str_in; 28, identifier:k; 29, for_in_clause; 30, identifier:k; 31, identifier:tmp_dict | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 9, 14; 10, 15; 11, 16; 11, 17; 12, 18; 12, 19; 13, 20; 14, 21; 14, 22; 17, 23; 17, 24; 20, 25; 22, 26; 24, 27; 26, 28; 26, 29; 29, 30; 29, 31 | def str2dict_keys(str_in):
'''
Extracts the keys from a string that represents a dict and returns them
sorted by key.
Args:
str_in (string) that contains python dict
Returns:
(list) with keys or None if no valid dict was found
Raises:
-
'''
tmp_dict = str2dict(str_in)
if tmp_dict is None:
return None
return sorted([k for k in tmp_dict]) |
0, module; 1, function_definition; 2, function_name:str2dict_values; 3, parameters; 4, block; 5, identifier:str_in; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, return_statement; 10, string; 11, assignment; 12, comparison_operator:tmp_dict is None; 13, block; 14, list_comprehension; 15, string_content:Extracts the values from a string that represents a dict and returns them
sorted by key.
Args:
str_in (string) that contains python dict
Returns:
(list) with values or None if no valid dict was found
Raises:
-; 16, identifier:tmp_dict; 17, call; 18, identifier:tmp_dict; 19, None; 20, return_statement; 21, subscript; 22, for_in_clause; 23, identifier:str2dict; 24, argument_list; 25, None; 26, identifier:tmp_dict; 27, identifier:key; 28, identifier:key; 29, call; 30, identifier:str_in; 31, identifier:sorted; 32, generator_expression; 33, identifier:k; 34, for_in_clause; 35, identifier:k; 36, identifier:tmp_dict | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 9, 14; 10, 15; 11, 16; 11, 17; 12, 18; 12, 19; 13, 20; 14, 21; 14, 22; 17, 23; 17, 24; 20, 25; 21, 26; 21, 27; 22, 28; 22, 29; 24, 30; 29, 31; 29, 32; 32, 33; 32, 34; 34, 35; 34, 36 | def str2dict_values(str_in):
'''
Extracts the values from a string that represents a dict and returns them
sorted by key.
Args:
str_in (string) that contains python dict
Returns:
(list) with values or None if no valid dict was found
Raises:
-
'''
tmp_dict = str2dict(str_in)
if tmp_dict is None:
return None
return [tmp_dict[key] for key in sorted(k for k in tmp_dict)] |
0, module; 1, function_definition; 2, function_name:to_json; 3, parameters; 4, block; 5, identifier:self; 6, keyword_separator; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, return_statement; 13, identifier:include_keys; 14, None; 15, identifier:exclude_keys; 16, None; 17, identifier:use_default_excludes; 18, True; 19, identifier:pretty; 20, False; 21, comment:"""Converts the response from to_dict to a JSON string. If pretty is True then newlines,
indentation and key sorting are used.
"""; 22, call; 23, identifier:to_json; 24, argument_list; 25, call; 26, keyword_argument; 27, attribute; 28, argument_list; 29, identifier:pretty; 30, identifier:pretty; 31, identifier:self; 32, identifier:to_dict; 33, keyword_argument; 34, keyword_argument; 35, keyword_argument; 36, identifier:include_keys; 37, identifier:include_keys; 38, identifier:exclude_keys; 39, identifier:exclude_keys; 40, identifier:use_default_excludes; 41, identifier:use_default_excludes | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 7, 13; 7, 14; 8, 15; 8, 16; 9, 17; 9, 18; 10, 19; 10, 20; 11, 21; 12, 22; 22, 23; 22, 24; 24, 25; 24, 26; 25, 27; 25, 28; 26, 29; 26, 30; 27, 31; 27, 32; 28, 33; 28, 34; 28, 35; 33, 36; 33, 37; 34, 38; 34, 39; 35, 40; 35, 41 | def to_json(self, *, include_keys=None, exclude_keys=None, use_default_excludes=True,
pretty=False):
"""Converts the response from to_dict to a JSON string. If pretty is True then newlines,
indentation and key sorting are used.
"""
return to_json(
self.to_dict(
include_keys=include_keys,
exclude_keys=exclude_keys,
use_default_excludes=use_default_excludes),
pretty=pretty) |
0, module; 1, function_definition; 2, function_name:get_annotations; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:target; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, default_parameter; 15, expression_statement; 16, expression_statement; 17, if_statement; 18, if_statement; 19, return_statement; 20, identifier:exclude; 21, None; 22, identifier:ctx; 23, None; 24, identifier:select; 25, lambda; 26, identifier:mindepth; 27, integer:0; 28, identifier:maxdepth; 29, integer:0; 30, identifier:followannotated; 31, True; 32, identifier:public; 33, True; 34, identifier:_history; 35, None; 36, comment:"""Returns all input target annotations of cls type sorted
by definition order.
:param type cls: type of annotation to get from target.
:param target: target from where get annotations.
:param tuple/type exclude: annotation types to remove from selection.
:param ctx: target ctx.
:param select: bool function which select annotations after applying
previous type filters. Takes a target, a ctx and an annotation in
parameters. True by default.
:param int mindepth: minimal depth for searching annotations (default 0)
:param int maxdepth: maximal depth for searching annotations (default 0)
:param bool followannotated: if True (default) follow deeply only
annotated members.
:param bool public: if True (default) follow public members.
:param list _history: private parameter which save parsed elements.
:rtype: Annotation
"""; 37, assignment; 38, comparison_operator:mindepth <= 0; 39, block; 40, boolean_operator; 41, block; 42, identifier:result; 43, lambda_parameters; 44, True; 45, identifier:result; 46, list; 47, identifier:mindepth; 48, integer:0; 49, try_statement; 50, if_statement; 51, expression_statement; 52, for_statement; 53, comparison_operator:mindepth >= 0; 54, parenthesized_expression; 55, if_statement; 56, for_statement; 57, list_splat_pattern; 58, block; 59, except_clause; 60, not_operator; 61, block; 62, assignment; 63, pattern_list; 64, identifier:annotations_by_ctx; 65, block; 66, identifier:mindepth; 67, integer:0; 68, boolean_operator; 69, comparison_operator:_history is None; 70, block; 71, else_clause; 72, pattern_list; 73, call; 74, block; 75, identifier:p; 76, expression_statement; 77, identifier:TypeError; 78, block; 79, identifier:annotations_by_ctx; 80, if_statement; 81, identifier:exclude; 82, conditional_expression:() if exclude is None else exclude; 83, identifier:elt; 84, identifier:annotations; 85, for_statement; 86, comparison_operator:maxdepth > 0; 87, parenthesized_expression; 88, identifier:_history; 89, None; 90, expression_statement; 91, block; 92, identifier:name; 93, identifier:member; 94, identifier:getmembers; 95, argument_list; 96, if_statement; 97, assignment; 98, expression_statement; 99, call; 100, block; 101, elif_clause; 102, tuple; 103, comparison_operator:exclude is None; 104, identifier:exclude; 105, identifier:annotation; 106, identifier:annotations; 107, comment:# check if annotation is a StopPropagation rule; 108, block; 109, identifier:maxdepth; 110, integer:0; 111, boolean_operator; 112, assignment; 113, expression_statement; 114, identifier:target; 115, boolean_operator; 116, block; 117, identifier:annotations_by_ctx; 118, call; 119, assignment; 120, identifier:ismethod; 121, argument_list; 122, expression_statement; 123, expression_statement; 124, if_statement; 125, call; 126, block; 127, identifier:exclude; 128, None; 129, if_statement; 130, comment:# ensure propagation; 131, if_statement; 132, comment:# ensure overriding; 133, if_statement; 134, comment:# check for annotation; 135, if_statement; 136, identifier:result; 137, not_operator; 138, identifier:_history; 139, list; 140, call; 141, parenthesized_expression; 142, comparison_operator:member not in _history; 143, if_statement; 144, expression_statement; 145, identifier:get_property; 146, argument_list; 147, identifier:annotations_by_ctx; 148, dictionary; 149, identifier:target; 150, assignment; 151, assignment; 152, not_operator; 153, block; 154, identifier:isfunction; 155, argument_list; 156, expression_statement; 157, call; 158, block; 159, boolean_operator; 160, block; 161, attribute; 162, block; 163, parenthesized_expression; 164, block; 165, identifier:followannotated; 166, identifier:target; 167, attribute; 168, argument_list; 169, boolean_operator; 170, identifier:member; 171, identifier:_history; 172, boolean_operator; 173, block; 174, augmented_assignment; 175, keyword_argument; 176, keyword_argument; 177, keyword_argument; 178, identifier:func; 179, call; 180, identifier:annotations_by_ctx; 181, call; 182, identifier:annotations_by_ctx; 183, expression_statement; 184, identifier:target; 185, assignment; 186, identifier:isinstance; 187, argument_list; 188, expression_statement; 189, comparison_operator:elt is not target; 190, not_operator; 191, continue_statement; 192, identifier:annotation; 193, identifier:override; 194, expression_statement; 195, boolean_operator; 196, expression_statement; 197, identifier:_history; 198, identifier:append; 199, identifier:target; 200, comparison_operator:name[0] != '_'; 201, not_operator; 202, call; 203, call; 204, continue_statement; 205, identifier:result; 206, call; 207, identifier:elt; 208, identifier:target; 209, identifier:key; 210, attribute; 211, identifier:ctx; 212, identifier:ctx; 213, identifier:get_method_function; 214, argument_list; 215, identifier:get_property; 216, argument_list; 217, assignment; 218, identifier:annotations_by_ctx; 219, call; 220, identifier:annotation; 221, identifier:StopPropagation; 222, augmented_assignment; 223, identifier:elt; 224, identifier:target; 225, attribute; 226, augmented_assignment; 227, boolean_operator; 228, call; 229, call; 230, subscript; 231, string; 232, identifier:public; 233, identifier:ismethod; 234, argument_list; 235, attribute; 236, argument_list; 237, attribute; 238, argument_list; 239, identifier:Annotation; 240, identifier:__ANNOTATIONS_KEY__; 241, identifier:target; 242, keyword_argument; 243, keyword_argument; 244, keyword_argument; 245, identifier:annotations_by_ctx; 246, call; 247, identifier:get_property; 248, argument_list; 249, identifier:exclude; 250, attribute; 251, identifier:annotation; 252, identifier:propagate; 253, identifier:exclude; 254, tuple; 255, call; 256, not_operator; 257, identifier:select; 258, argument_list; 259, attribute; 260, argument_list; 261, identifier:name; 262, integer:0; 263, string_content:_; 264, identifier:target; 265, identifier:name; 266, identifier:startswith; 267, string; 268, identifier:cls; 269, identifier:get_annotations; 270, keyword_argument; 271, keyword_argument; 272, keyword_argument; 273, keyword_argument; 274, keyword_argument; 275, keyword_argument; 276, keyword_argument; 277, keyword_argument; 278, identifier:elt; 279, identifier:func; 280, identifier:key; 281, attribute; 282, identifier:ctx; 283, identifier:ctx; 284, identifier:get_property; 285, argument_list; 286, keyword_argument; 287, keyword_argument; 288, identifier:annotation; 289, identifier:annotation_types; 290, attribute; 291, identifier:isinstance; 292, argument_list; 293, call; 294, identifier:target; 295, identifier:ctx; 296, identifier:annotation; 297, identifier:result; 298, identifier:append; 299, identifier:annotation; 300, string_content:im_; 301, identifier:target; 302, identifier:member; 303, identifier:exclude; 304, identifier:exclude; 305, identifier:ctx; 306, identifier:ctx; 307, identifier:select; 308, identifier:select; 309, identifier:mindepth; 310, binary_operator:mindepth - 1; 311, identifier:maxdepth; 312, binary_operator:maxdepth - 1; 313, identifier:followannotated; 314, identifier:followannotated; 315, identifier:_history; 316, identifier:_history; 317, identifier:Annotation; 318, identifier:__ANNOTATIONS_KEY__; 319, keyword_argument; 320, keyword_argument; 321, identifier:elt; 322, identifier:target; 323, identifier:key; 324, attribute; 325, identifier:annotation; 326, identifier:__class__; 327, identifier:annotation; 328, identifier:cls; 329, identifier:isinstance; 330, argument_list; 331, identifier:mindepth; 332, integer:1; 333, identifier:maxdepth; 334, integer:1; 335, identifier:elt; 336, identifier:func; 337, identifier:key; 338, attribute; 339, identifier:Annotation; 340, identifier:__ANNOTATIONS_KEY__; 341, identifier:annotation; 342, identifier:exclude; 343, identifier:Annotation; 344, identifier:__ANNOTATIONS_KEY__ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 3, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 7, 20; 7, 21; 8, 22; 8, 23; 9, 24; 9, 25; 10, 26; 10, 27; 11, 28; 11, 29; 12, 30; 12, 31; 13, 32; 13, 33; 14, 34; 14, 35; 15, 36; 16, 37; 17, 38; 17, 39; 18, 40; 18, 41; 19, 42; 25, 43; 25, 44; 37, 45; 37, 46; 38, 47; 38, 48; 39, 49; 39, 50; 39, 51; 39, 52; 40, 53; 40, 54; 41, 55; 41, 56; 43, 57; 49, 58; 49, 59; 50, 60; 50, 61; 51, 62; 52, 63; 52, 64; 52, 65; 53, 66; 53, 67; 54, 68; 55, 69; 55, 70; 55, 71; 56, 72; 56, 73; 56, 74; 57, 75; 58, 76; 59, 77; 59, 78; 60, 79; 61, 80; 62, 81; 62, 82; 63, 83; 63, 84; 65, 85; 68, 86; 68, 87; 69, 88; 69, 89; 70, 90; 71, 91; 72, 92; 72, 93; 73, 94; 73, 95; 74, 96; 76, 97; 78, 98; 80, 99; 80, 100; 80, 101; 82, 102; 82, 103; 82, 104; 85, 105; 85, 106; 85, 107; 85, 108; 86, 109; 86, 110; 87, 111; 90, 112; 91, 113; 95, 114; 96, 115; 96, 116; 97, 117; 97, 118; 98, 119; 99, 120; 99, 121; 100, 122; 100, 123; 100, 124; 101, 125; 101, 126; 103, 127; 103, 128; 108, 129; 108, 130; 108, 131; 108, 132; 108, 133; 108, 134; 108, 135; 111, 136; 111, 137; 112, 138; 112, 139; 113, 140; 115, 141; 115, 142; 116, 143; 116, 144; 118, 145; 118, 146; 119, 147; 119, 148; 121, 149; 122, 150; 123, 151; 124, 152; 124, 153; 125, 154; 125, 155; 126, 156; 129, 157; 129, 158; 131, 159; 131, 160; 133, 161; 133, 162; 135, 163; 135, 164; 137, 165; 139, 166; 140, 167; 140, 168; 141, 169; 142, 170; 142, 171; 143, 172; 143, 173; 144, 174; 146, 175; 146, 176; 146, 177; 150, 178; 150, 179; 151, 180; 151, 181; 152, 182; 153, 183; 155, 184; 156, 185; 157, 186; 157, 187; 158, 188; 159, 189; 159, 190; 160, 191; 161, 192; 161, 193; 162, 194; 163, 195; 164, 196; 167, 197; 167, 198; 168, 199; 169, 200; 169, 201; 172, 202; 172, 203; 173, 204; 174, 205; 174, 206; 175, 207; 175, 208; 176, 209; 176, 210; 177, 211; 177, 212; 179, 213; 179, 214; 181, 215; 181, 216; 183, 217; 185, 218; 185, 219; 187, 220; 187, 221; 188, 222; 189, 223; 189, 224; 190, 225; 194, 226; 195, 227; 195, 228; 196, 229; 200, 230; 200, 231; 201, 232; 202, 233; 202, 234; 203, 235; 203, 236; 206, 237; 206, 238; 210, 239; 210, 240; 214, 241; 216, 242; 216, 243; 216, 244; 217, 245; 217, 246; 219, 247; 219, 248; 222, 249; 222, 250; 225, 251; 225, 252; 226, 253; 226, 254; 227, 255; 227, 256; 228, 257; 228, 258; 229, 259; 229, 260; 230, 261; 230, 262; 231, 263; 234, 264; 235, 265; 235, 266; 236, 267; 237, 268; 237, 269; 238, 270; 238, 271; 238, 272; 238, 273; 238, 274; 238, 275; 238, 276; 238, 277; 242, 278; 242, 279; 243, 280; 243, 281; 244, 282; 244, 283; 246, 284; 246, 285; 248, 286; 248, 287; 250, 288; 250, 289; 254, 290; 255, 291; 255, 292; 256, 293; 258, 294; 258, 295; 258, 296; 259, 297; 259, 298; 260, 299; 267, 300; 270, 301; 270, 302; 271, 303; 271, 304; 272, 305; 272, 306; 273, 307; 273, 308; 274, 309; 274, 310; 275, 311; 275, 312; 276, 313; 276, 314; 277, 315; 277, 316; 281, 317; 281, 318; 285, 319; 285, 320; 286, 321; 286, 322; 287, 323; 287, 324; 290, 325; 290, 326; 292, 327; 292, 328; 293, 329; 293, 330; 310, 331; 310, 332; 312, 333; 312, 334; 319, 335; 319, 336; 320, 337; 320, 338; 324, 339; 324, 340; 330, 341; 330, 342; 338, 343; 338, 344 | def get_annotations(
cls, target,
exclude=None, ctx=None, select=lambda *p: True,
mindepth=0, maxdepth=0, followannotated=True, public=True,
_history=None
):
"""Returns all input target annotations of cls type sorted
by definition order.
:param type cls: type of annotation to get from target.
:param target: target from where get annotations.
:param tuple/type exclude: annotation types to remove from selection.
:param ctx: target ctx.
:param select: bool function which select annotations after applying
previous type filters. Takes a target, a ctx and an annotation in
parameters. True by default.
:param int mindepth: minimal depth for searching annotations (default 0)
:param int maxdepth: maximal depth for searching annotations (default 0)
:param bool followannotated: if True (default) follow deeply only
annotated members.
:param bool public: if True (default) follow public members.
:param list _history: private parameter which save parsed elements.
:rtype: Annotation
"""
result = []
if mindepth <= 0:
try:
annotations_by_ctx = get_property(
elt=target, key=Annotation.__ANNOTATIONS_KEY__, ctx=ctx
)
except TypeError:
annotations_by_ctx = {}
if not annotations_by_ctx:
if ismethod(target):
func = get_method_function(target)
annotations_by_ctx = get_property(
elt=func,
key=Annotation.__ANNOTATIONS_KEY__,
ctx=ctx
)
if not annotations_by_ctx:
annotations_by_ctx = get_property(
elt=func, key=Annotation.__ANNOTATIONS_KEY__
)
elif isfunction(target):
annotations_by_ctx = get_property(
elt=target,
key=Annotation.__ANNOTATIONS_KEY__
)
exclude = () if exclude is None else exclude
for elt, annotations in annotations_by_ctx:
for annotation in annotations:
# check if annotation is a StopPropagation rule
if isinstance(annotation, StopPropagation):
exclude += annotation.annotation_types
# ensure propagation
if elt is not target and not annotation.propagate:
continue
# ensure overriding
if annotation.override:
exclude += (annotation.__class__, )
# check for annotation
if (isinstance(annotation, cls)
and not isinstance(annotation, exclude)
and select(target, ctx, annotation)):
result.append(annotation)
if mindepth >= 0 or (maxdepth > 0 and (result or not followannotated)):
if _history is None:
_history = [target]
else:
_history.append(target)
for name, member in getmembers(target):
if (name[0] != '_' or not public) and member not in _history:
if ismethod(target) and name.startswith('im_'):
continue
result += cls.get_annotations(
target=member, exclude=exclude, ctx=ctx, select=select,
mindepth=mindepth - 1, maxdepth=maxdepth - 1,
followannotated=followannotated, _history=_history
)
return result |
0, module; 1, function_definition; 2, function_name:get_filenames; 3, parameters; 4, block; 5, identifier:dirname; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""Return all model output filenames inside a model output directory,
sorted by iteration number.
Parameters
----------
dirname: str
A path to a directory.
Returns
-------
filenames: list[str]
Paths to all output files inside `dirname`, sorted in order of
increasing iteration number.
"""; 10, assignment; 11, call; 12, identifier:filenames; 13, call; 14, identifier:sorted; 15, argument_list; 16, attribute; 17, argument_list; 18, identifier:filenames; 19, keyword_argument; 20, identifier:glob; 21, identifier:glob; 22, call; 23, identifier:key; 24, identifier:_f_to_i; 25, attribute; 26, argument_list; 27, string; 28, identifier:format; 29, identifier:dirname; 30, string_content:{}/*.pkl | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 15, 19; 16, 20; 16, 21; 17, 22; 19, 23; 19, 24; 22, 25; 22, 26; 25, 27; 25, 28; 26, 29; 27, 30 | def get_filenames(dirname):
"""Return all model output filenames inside a model output directory,
sorted by iteration number.
Parameters
----------
dirname: str
A path to a directory.
Returns
-------
filenames: list[str]
Paths to all output files inside `dirname`, sorted in order of
increasing iteration number.
"""
filenames = glob.glob('{}/*.pkl'.format(dirname))
return sorted(filenames, key=_f_to_i) |
0, module; 1, function_definition; 2, function_name:sort_states; 3, parameters; 4, block; 5, identifier:states; 6, identifier:sort_list; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""
Returns a list of sorted states, original states list remains unsorted
The sort list is a list of state field: field key pairs
For example (as YAML):
- data: position
- meta: created_at
The field_key part can be a list to simplify input
- meta: created_at
- meta: updated_at
or
- meta:
- created_at
- updated_at
It is also possible to sort by grouping values
For example, with a grouping called student_id:
- groupings:
- student_id:
index: !!null (optional: when null or missing it uses the first group in the grouping
values:
- meta: student_id
A key which begins with a - inverts the sort, so
- -data: position
is the inverse of
- data: position
With groupings only values can have a - to invert the sort (always on the key)
- groupings:
- student_id:
index: !!null
values:
- -meta: student_id
NOT
- -groupings: ...
"""; 12, assignment; 13, identifier:sort_pair; 14, call; 15, block; 16, identifier:sorted_states; 17, identifier:sorted_states; 18, call; 19, identifier:reversed; 20, argument_list; 21, if_statement; 22, attribute; 23, argument_list; 24, call; 25, comparison_operator:sort_pair[0].lstrip('-') in ['data','measure','meta']; 26, block; 27, elif_clause; 28, identifier:states; 29, identifier:copy; 30, identifier:_convert_list_of_dict_to_tuple; 31, argument_list; 32, call; 33, list; 34, expression_statement; 35, comparison_operator:sort_pair[0] == 'groupings'; 36, block; 37, identifier:sort_list; 38, attribute; 39, argument_list; 40, string; 41, string; 42, string; 43, assignment; 44, subscript; 45, string; 46, for_statement; 47, subscript; 48, identifier:lstrip; 49, string; 50, string_content:data; 51, string_content:measure; 52, string_content:meta; 53, identifier:sorted_states; 54, call; 55, identifier:sort_pair; 56, integer:0; 57, string_content:groupings; 58, identifier:grouping; 59, call; 60, block; 61, identifier:sort_pair; 62, integer:0; 63, string_content:-; 64, identifier:_state_value_sort; 65, argument_list; 66, identifier:reversed; 67, argument_list; 68, expression_statement; 69, identifier:sorted_states; 70, identifier:sort_pair; 71, identifier:_state_key_function; 72, subscript; 73, assignment; 74, identifier:sort_pair; 75, integer:1; 76, identifier:sorted_states; 77, call; 78, identifier:_groupings_values_sort; 79, argument_list; 80, identifier:sorted_states; 81, identifier:grouping | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 9, 14; 9, 15; 10, 16; 12, 17; 12, 18; 14, 19; 14, 20; 15, 21; 18, 22; 18, 23; 20, 24; 21, 25; 21, 26; 21, 27; 22, 28; 22, 29; 24, 30; 24, 31; 25, 32; 25, 33; 26, 34; 27, 35; 27, 36; 31, 37; 32, 38; 32, 39; 33, 40; 33, 41; 33, 42; 34, 43; 35, 44; 35, 45; 36, 46; 38, 47; 38, 48; 39, 49; 40, 50; 41, 51; 42, 52; 43, 53; 43, 54; 44, 55; 44, 56; 45, 57; 46, 58; 46, 59; 46, 60; 47, 61; 47, 62; 49, 63; 54, 64; 54, 65; 59, 66; 59, 67; 60, 68; 65, 69; 65, 70; 65, 71; 67, 72; 68, 73; 72, 74; 72, 75; 73, 76; 73, 77; 77, 78; 77, 79; 79, 80; 79, 81 | def sort_states(states, sort_list):
"""
Returns a list of sorted states, original states list remains unsorted
The sort list is a list of state field: field key pairs
For example (as YAML):
- data: position
- meta: created_at
The field_key part can be a list to simplify input
- meta: created_at
- meta: updated_at
or
- meta:
- created_at
- updated_at
It is also possible to sort by grouping values
For example, with a grouping called student_id:
- groupings:
- student_id:
index: !!null (optional: when null or missing it uses the first group in the grouping
values:
- meta: student_id
A key which begins with a - inverts the sort, so
- -data: position
is the inverse of
- data: position
With groupings only values can have a - to invert the sort (always on the key)
- groupings:
- student_id:
index: !!null
values:
- -meta: student_id
NOT
- -groupings: ...
"""
sorted_states= states.copy()
for sort_pair in reversed( _convert_list_of_dict_to_tuple(sort_list) ):
if sort_pair[0].lstrip('-') in ['data','measure','meta']:
sorted_states= _state_value_sort(sorted_states, sort_pair, _state_key_function)
elif sort_pair[0] == 'groupings':
for grouping in reversed(sort_pair[1]):
sorted_states= _groupings_values_sort(sorted_states, grouping)
return sorted_states |
0, module; 1, function_definition; 2, function_name:search; 3, parameters; 4, block; 5, identifier:self; 6, identifier:terms; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, comment:# first, get the total number of pages returned. this findall returns; 16, comment:# two results (one from the top half of the page, one from the bottom),; 17, comment:# so only take the first element.; 18, expression_statement; 19, if_statement; 20, expression_statement; 21, expression_statement; 22, for_statement; 23, return_statement; 24, identifier:category; 25, attribute; 26, identifier:page; 27, integer:1; 28, identifier:sort_key; 29, attribute; 30, identifier:order_key; 31, attribute; 32, comment:"""Get a list of torrents that match the given search term
:param terms: the `str` needle
:param category: the desired :class:`Category` of the results
:param page: the 1-based page to return the result
:param sort_key: the :class:`SearchSortKey` of the results list
:param order_key: the :class:`SearchOrderkey` of the results list
:return: a :class:`SearchPage` of results
"""; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, not_operator; 38, block; 39, else_clause; 40, assignment; 41, assignment; 42, identifier:row; 43, identifier:rows; 44, block; 45, call; 46, identifier:Category; 47, identifier:all_categories; 48, identifier:SearchSortKey; 49, identifier:date; 50, identifier:SearchOrderKey; 51, identifier:descending; 52, identifier:params; 53, dictionary; 54, identifier:r; 55, call; 56, identifier:content; 57, call; 58, identifier:a_to_last_page; 59, call; 60, identifier:a_to_last_page; 61, expression_statement; 62, block; 63, identifier:torrent_stubs; 64, list; 65, identifier:rows; 66, generator_expression; 67, expression_statement; 68, expression_statement; 69, expression_statement; 70, expression_statement; 71, expression_statement; 72, expression_statement; 73, if_statement; 74, if_statement; 75, expression_statement; 76, expression_statement; 77, expression_statement; 78, identifier:SearchResultPage; 79, argument_list; 80, pair; 81, pair; 82, pair; 83, pair; 84, pair; 85, attribute; 86, argument_list; 87, attribute; 88, argument_list; 89, attribute; 90, argument_list; 91, assignment; 92, expression_statement; 93, expression_statement; 94, expression_statement; 95, identifier:x; 96, for_in_clause; 97, if_clause; 98, assignment; 99, assignment; 100, assignment; 101, assignment; 102, assignment; 103, assignment; 104, call; 105, block; 106, else_clause; 107, call; 108, block; 109, else_clause; 110, assignment; 111, assignment; 112, call; 113, identifier:terms; 114, identifier:category; 115, identifier:sort_key; 116, identifier:order_key; 117, identifier:page; 118, identifier:total_pages; 119, identifier:torrent_stubs; 120, string; 121, string; 122, string; 123, identifier:terms; 124, string; 125, attribute; 126, string; 127, attribute; 128, string; 129, attribute; 130, identifier:requests; 131, identifier:get; 132, attribute; 133, keyword_argument; 134, identifier:self; 135, identifier:_get_page_content; 136, identifier:r; 137, identifier:content; 138, identifier:findall; 139, string:'.//div[@class="rightpages"]/a[2]'; 140, identifier:total_pages; 141, integer:1; 142, assignment; 143, assignment; 144, assignment; 145, identifier:x; 146, call; 147, comparison_operator:'tlistrow' in x.attrib.get('class', ''); 148, identifier:cell_td_elems; 149, call; 150, identifier:category_value; 151, subscript; 152, identifier:category; 153, call; 154, identifier:torrent_id; 155, subscript; 156, identifier:name; 157, attribute; 158, identifier:file_size; 159, attribute; 160, attribute; 161, argument_list; 162, expression_statement; 163, block; 164, attribute; 165, argument_list; 166, expression_statement; 167, block; 168, identifier:downloads; 169, call; 170, identifier:stub; 171, call; 172, attribute; 173, argument_list; 174, string_content:page; 175, string_content:search; 176, string_content:term; 177, string_content:cats; 178, identifier:category; 179, identifier:value; 180, string_content:sort; 181, identifier:sort_key; 182, identifier:value; 183, string_content:order; 184, identifier:order_key; 185, identifier:value; 186, identifier:self; 187, identifier:base_url; 188, identifier:params; 189, identifier:params; 190, identifier:last_page_url; 191, subscript; 192, identifier:offset; 193, subscript; 194, identifier:total_pages; 195, call; 196, attribute; 197, argument_list; 198, string; 199, call; 200, attribute; 201, argument_list; 202, call; 203, integer:0; 204, attribute; 205, argument_list; 206, call; 207, integer:0; 208, call; 209, identifier:text; 210, subscript; 211, identifier:text; 212, attribute; 213, identifier:isdigit; 214, assignment; 215, expression_statement; 216, attribute; 217, identifier:isdigit; 218, assignment; 219, expression_statement; 220, identifier:int; 221, argument_list; 222, identifier:TorrentStub; 223, argument_list; 224, identifier:torrent_stubs; 225, identifier:append; 226, identifier:stub; 227, attribute; 228, string; 229, call; 230, integer:0; 231, identifier:int; 232, argument_list; 233, identifier:content; 234, identifier:findall; 235, string; 236, string_content:tlistrow; 237, attribute; 238, argument_list; 239, identifier:row; 240, identifier:findall; 241, string; 242, identifier:extract_url_query_parameter; 243, argument_list; 244, identifier:Category; 245, identifier:lookup_category; 246, identifier:category_value; 247, identifier:extract_url_query_parameter; 248, argument_list; 249, attribute; 250, argument_list; 251, identifier:cell_td_elems; 252, integer:3; 253, subscript; 254, identifier:text; 255, identifier:seeders; 256, call; 257, assignment; 258, subscript; 259, identifier:text; 260, identifier:leechers; 261, call; 262, assignment; 263, attribute; 264, identifier:torrent_id; 265, identifier:name; 266, identifier:category; 267, identifier:seeders; 268, identifier:leechers; 269, identifier:file_size; 270, identifier:downloads; 271, subscript; 272, identifier:attrib; 273, string_content:href; 274, identifier:extract_url_query_parameter; 275, argument_list; 276, identifier:offset; 277, string_content:.//table//tr; 278, attribute; 279, identifier:get; 280, string; 281, string; 282, string_content:td; 283, subscript; 284, string; 285, subscript; 286, string:"tid"; 287, subscript; 288, identifier:find; 289, string; 290, identifier:cell_td_elems; 291, integer:4; 292, identifier:int; 293, argument_list; 294, identifier:seeders; 295, None; 296, identifier:cell_td_elems; 297, integer:5; 298, identifier:int; 299, argument_list; 300, identifier:leechers; 301, None; 302, subscript; 303, identifier:text; 304, identifier:a_to_last_page; 305, integer:0; 306, identifier:last_page_url; 307, string:"offset"; 308, identifier:x; 309, identifier:attrib; 310, string_content:class; 311, attribute; 312, string; 313, string_content:cats; 314, attribute; 315, string; 316, identifier:cell_td_elems; 317, integer:1; 318, string_content:a; 319, attribute; 320, attribute; 321, identifier:cell_td_elems; 322, integer:6; 323, call; 324, identifier:attrib; 325, string_content:href; 326, call; 327, identifier:attrib; 328, string_content:href; 329, subscript; 330, identifier:text; 331, subscript; 332, identifier:text; 333, attribute; 334, argument_list; 335, attribute; 336, argument_list; 337, identifier:cell_td_elems; 338, integer:4; 339, identifier:cell_td_elems; 340, integer:5; 341, subscript; 342, identifier:find; 343, string; 344, subscript; 345, identifier:find; 346, string; 347, identifier:cell_td_elems; 348, integer:0; 349, string_content:a; 350, identifier:cell_td_elems; 351, integer:1; 352, string_content:a | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 7, 24; 7, 25; 8, 26; 8, 27; 9, 28; 9, 29; 10, 30; 10, 31; 11, 32; 12, 33; 13, 34; 14, 35; 18, 36; 19, 37; 19, 38; 19, 39; 20, 40; 21, 41; 22, 42; 22, 43; 22, 44; 23, 45; 25, 46; 25, 47; 29, 48; 29, 49; 31, 50; 31, 51; 33, 52; 33, 53; 34, 54; 34, 55; 35, 56; 35, 57; 36, 58; 36, 59; 37, 60; 38, 61; 39, 62; 40, 63; 40, 64; 41, 65; 41, 66; 44, 67; 44, 68; 44, 69; 44, 70; 44, 71; 44, 72; 44, 73; 44, 74; 44, 75; 44, 76; 44, 77; 45, 78; 45, 79; 53, 80; 53, 81; 53, 82; 53, 83; 53, 84; 55, 85; 55, 86; 57, 87; 57, 88; 59, 89; 59, 90; 61, 91; 62, 92; 62, 93; 62, 94; 66, 95; 66, 96; 66, 97; 67, 98; 68, 99; 69, 100; 70, 101; 71, 102; 72, 103; 73, 104; 73, 105; 73, 106; 74, 107; 74, 108; 74, 109; 75, 110; 76, 111; 77, 112; 79, 113; 79, 114; 79, 115; 79, 116; 79, 117; 79, 118; 79, 119; 80, 120; 80, 121; 81, 122; 81, 123; 82, 124; 82, 125; 83, 126; 83, 127; 84, 128; 84, 129; 85, 130; 85, 131; 86, 132; 86, 133; 87, 134; 87, 135; 88, 136; 89, 137; 89, 138; 90, 139; 91, 140; 91, 141; 92, 142; 93, 143; 94, 144; 96, 145; 96, 146; 97, 147; 98, 148; 98, 149; 99, 150; 99, 151; 100, 152; 100, 153; 101, 154; 101, 155; 102, 156; 102, 157; 103, 158; 103, 159; 104, 160; 104, 161; 105, 162; 106, 163; 107, 164; 107, 165; 108, 166; 109, 167; 110, 168; 110, 169; 111, 170; 111, 171; 112, 172; 112, 173; 120, 174; 121, 175; 122, 176; 124, 177; 125, 178; 125, 179; 126, 180; 127, 181; 127, 182; 128, 183; 129, 184; 129, 185; 132, 186; 132, 187; 133, 188; 133, 189; 142, 190; 142, 191; 143, 192; 143, 193; 144, 194; 144, 195; 146, 196; 146, 197; 147, 198; 147, 199; 149, 200; 149, 201; 151, 202; 151, 203; 153, 204; 153, 205; 155, 206; 155, 207; 157, 208; 157, 209; 159, 210; 159, 211; 160, 212; 160, 213; 162, 214; 163, 215; 164, 216; 164, 217; 166, 218; 167, 219; 169, 220; 169, 221; 171, 222; 171, 223; 172, 224; 172, 225; 173, 226; 191, 227; 191, 228; 193, 229; 193, 230; 195, 231; 195, 232; 196, 233; 196, 234; 197, 235; 198, 236; 199, 237; 199, 238; 200, 239; 200, 240; 201, 241; 202, 242; 202, 243; 204, 244; 204, 245; 205, 246; 206, 247; 206, 248; 208, 249; 208, 250; 210, 251; 210, 252; 212, 253; 212, 254; 214, 255; 214, 256; 215, 257; 216, 258; 216, 259; 218, 260; 218, 261; 219, 262; 221, 263; 223, 264; 223, 265; 223, 266; 223, 267; 223, 268; 223, 269; 223, 270; 227, 271; 227, 272; 228, 273; 229, 274; 229, 275; 232, 276; 235, 277; 237, 278; 237, 279; 238, 280; 238, 281; 241, 282; 243, 283; 243, 284; 248, 285; 248, 286; 249, 287; 249, 288; 250, 289; 253, 290; 253, 291; 256, 292; 256, 293; 257, 294; 257, 295; 258, 296; 258, 297; 261, 298; 261, 299; 262, 300; 262, 301; 263, 302; 263, 303; 271, 304; 271, 305; 275, 306; 275, 307; 278, 308; 278, 309; 280, 310; 283, 311; 283, 312; 284, 313; 285, 314; 285, 315; 287, 316; 287, 317; 289, 318; 293, 319; 299, 320; 302, 321; 302, 322; 311, 323; 311, 324; 312, 325; 314, 326; 314, 327; 315, 328; 319, 329; 319, 330; 320, 331; 320, 332; 323, 333; 323, 334; 326, 335; 326, 336; 329, 337; 329, 338; 331, 339; 331, 340; 333, 341; 333, 342; 334, 343; 335, 344; 335, 345; 336, 346; 341, 347; 341, 348; 343, 349; 344, 350; 344, 351; 346, 352 | def search(self, terms, category=Category.all_categories, page=1,
sort_key=SearchSortKey.date,
order_key=SearchOrderKey.descending):
"""Get a list of torrents that match the given search term
:param terms: the `str` needle
:param category: the desired :class:`Category` of the results
:param page: the 1-based page to return the result
:param sort_key: the :class:`SearchSortKey` of the results list
:param order_key: the :class:`SearchOrderkey` of the results list
:return: a :class:`SearchPage` of results
"""
params = {
'page': 'search',
'term': terms,
'cats': category.value,
'sort': sort_key.value,
'order': order_key.value,
}
r = requests.get(self.base_url, params=params)
content = self._get_page_content(r)
# first, get the total number of pages returned. this findall returns
# two results (one from the top half of the page, one from the bottom),
# so only take the first element.
a_to_last_page = content.findall('.//div[@class="rightpages"]/a[2]')
if not a_to_last_page:
total_pages = 1
else:
last_page_url = a_to_last_page[0].attrib['href']
offset = extract_url_query_parameter(last_page_url, "offset")[0]
total_pages = int(offset)
torrent_stubs = []
rows = (x for x in content.findall('.//table//tr')
if 'tlistrow' in x.attrib.get('class', ''))
for row in rows:
cell_td_elems = row.findall('td')
category_value = extract_url_query_parameter(
cell_td_elems[0].find('a').attrib['href'],
'cats')[0]
category = Category.lookup_category(category_value)
torrent_id = extract_url_query_parameter(
cell_td_elems[1].find('a').attrib['href'],
"tid")[0]
name = cell_td_elems[1].find('a').text
file_size = cell_td_elems[3].text
if cell_td_elems[4].text.isdigit():
seeders = int(cell_td_elems[4].text)
else:
seeders = None
if cell_td_elems[5].text.isdigit():
leechers = int(cell_td_elems[5].text)
else:
leechers = None
downloads = int(cell_td_elems[6].text)
stub = TorrentStub(torrent_id, name, category, seeders, leechers,
file_size, downloads)
torrent_stubs.append(stub)
return SearchResultPage(
terms, category, sort_key, order_key, page, total_pages,
torrent_stubs) |
0, module; 1, function_definition; 2, function_name:partition; 3, parameters; 4, block; 5, identifier:self; 6, identifier:mapped_values; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""Organize the mapped values by their key.
Returns an unsorted sequence of tuples with a key and a sequence of values.
"""; 12, assignment; 13, pattern_list; 14, identifier:mapped_values; 15, block; 16, call; 17, identifier:partitioned_data; 18, call; 19, identifier:key; 20, identifier:value; 21, expression_statement; 22, attribute; 23, argument_list; 24, attribute; 25, argument_list; 26, call; 27, identifier:partitioned_data; 28, identifier:items; 29, identifier:collections; 30, identifier:defaultdict; 31, identifier:list; 32, attribute; 33, argument_list; 34, subscript; 35, identifier:append; 36, identifier:value; 37, identifier:partitioned_data; 38, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 9, 14; 9, 15; 10, 16; 12, 17; 12, 18; 13, 19; 13, 20; 15, 21; 16, 22; 16, 23; 18, 24; 18, 25; 21, 26; 22, 27; 22, 28; 24, 29; 24, 30; 25, 31; 26, 32; 26, 33; 32, 34; 32, 35; 33, 36; 34, 37; 34, 38 | def partition(self, mapped_values):
"""Organize the mapped values by their key.
Returns an unsorted sequence of tuples with a key and a sequence of values.
"""
partitioned_data = collections.defaultdict(list)
for key, value in mapped_values:
partitioned_data[key].append(value)
return partitioned_data.items() |
0, module; 1, function_definition; 2, function_name:cond_int; 3, parameters; 4, block; 5, identifier:self; 6, identifier:conkey; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, return_statement; 11, comment:"""Return the trailing number from cond if any, as an int. If no
trailing number, return the string conkey as is.
This is used for sorting the conditions properly even when
passing the number 10. The name of this function could be
improved since it might return a string."""; 12, assignment; 13, not_operator; 14, block; 15, call; 16, identifier:m; 17, call; 18, identifier:m; 19, return_statement; 20, identifier:int; 21, argument_list; 22, attribute; 23, argument_list; 24, identifier:conkey; 25, call; 26, identifier:re; 27, identifier:match; 28, attribute; 29, identifier:conkey; 30, attribute; 31, argument_list; 32, identifier:self; 33, identifier:numrx; 34, identifier:m; 35, identifier:group; 36, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 9, 14; 10, 15; 12, 16; 12, 17; 13, 18; 14, 19; 15, 20; 15, 21; 17, 22; 17, 23; 19, 24; 21, 25; 22, 26; 22, 27; 23, 28; 23, 29; 25, 30; 25, 31; 28, 32; 28, 33; 30, 34; 30, 35; 31, 36 | def cond_int(self, conkey):
"""Return the trailing number from cond if any, as an int. If no
trailing number, return the string conkey as is.
This is used for sorting the conditions properly even when
passing the number 10. The name of this function could be
improved since it might return a string."""
m = re.match(self.numrx, conkey)
if not m:
return conkey
return int(m.group(1)) |
0, module; 1, function_definition; 2, function_name:sorted_conkeys; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, comment:# Make for defined and sorted output:; 9, expression_statement; 10, for_statement; 11, if_statement; 12, return_statement; 13, identifier:prefix; 14, None; 15, comment:"""Return all condition keys in self.conditions as a list sorted
suitable for print or write to a file. If prefix is given return
only the ones prefixed with prefix."""; 16, assignment; 17, identifier:cond; 18, identifier:_COND_PREFIXES; 19, block; 20, not_operator; 21, block; 22, list_comprehension; 23, identifier:conkeys; 24, list; 25, expression_statement; 26, identifier:prefix; 27, return_statement; 28, identifier:key; 29, for_in_clause; 30, if_clause; 31, augmented_assignment; 32, identifier:conkeys; 33, identifier:key; 34, identifier:conkeys; 35, call; 36, identifier:conkeys; 37, call; 38, attribute; 39, argument_list; 40, identifier:sorted; 41, argument_list; 42, identifier:key; 43, identifier:startswith; 44, identifier:prefix; 45, list_comprehension; 46, keyword_argument; 47, identifier:key; 48, for_in_clause; 49, if_clause; 50, identifier:key; 51, attribute; 52, identifier:key; 53, attribute; 54, call; 55, identifier:self; 56, identifier:cond_int; 57, identifier:self; 58, identifier:conditions; 59, attribute; 60, argument_list; 61, identifier:key; 62, identifier:startswith; 63, identifier:cond | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 6, 14; 7, 15; 9, 16; 10, 17; 10, 18; 10, 19; 11, 20; 11, 21; 12, 22; 16, 23; 16, 24; 19, 25; 20, 26; 21, 27; 22, 28; 22, 29; 22, 30; 25, 31; 27, 32; 29, 33; 29, 34; 30, 35; 31, 36; 31, 37; 35, 38; 35, 39; 37, 40; 37, 41; 38, 42; 38, 43; 39, 44; 41, 45; 41, 46; 45, 47; 45, 48; 45, 49; 46, 50; 46, 51; 48, 52; 48, 53; 49, 54; 51, 55; 51, 56; 53, 57; 53, 58; 54, 59; 54, 60; 59, 61; 59, 62; 60, 63 | def sorted_conkeys(self, prefix=None):
"""Return all condition keys in self.conditions as a list sorted
suitable for print or write to a file. If prefix is given return
only the ones prefixed with prefix."""
# Make for defined and sorted output:
conkeys = []
for cond in _COND_PREFIXES:
conkeys += sorted([key for key in self.conditions
if key.startswith(cond)], key=self.cond_int)
if not prefix:
return conkeys
return [key for key in conkeys if key.startswith(prefix)] |
0, module; 1, function_definition; 2, function_name:isordinal; 3, parameters; 4, block; 5, identifier:x; 6, expression_statement; 7, import_statement; 8, if_statement; 9, if_statement; 10, return_statement; 11, comment:"""Checks if a list or array contains ordinal data.
Warning:
--------
This is not a reliable check for a variable being
ordinal.
The following criteria are used
- There are more observations than unique values.
Why? Ordinal means discrete or countable and
I just assume that an ordinal sample should
have some recurring (countable) values.
- Values are integers or strings.
Why? Ordinal scale data are usually labels
(e.g. strings) or are encoded labels (e.g.
as integers).
- Ordinal scale data is sortable
Integers imply that the Analyst encoded the
labels according to the ordinal data's "natural
order". Strings would imply that the alphabetic
order would be the natual order (what is usually
not the case)
Usage:
------
obs = 10
np.random.seed(42)
x1 = np.random.randint(1,50, (obs,))
x2 = np.random.randint(0,3, (obs,))
x3 = np.random.uniform(0,3, (obs,))
flag, msg = isordinal(x1)
if not flag:
warnings.warn(msg)
"""; 12, aliased_import; 13, comparison_operator:len(x) == len(np.unique(x)); 14, block; 15, not_operator; 16, block; 17, expression_list; 18, dotted_name; 19, identifier:np; 20, call; 21, call; 22, return_statement; 23, call; 24, if_statement; 25, True; 26, string:"is ordinal"; 27, identifier:numpy; 28, identifier:len; 29, argument_list; 30, identifier:len; 31, argument_list; 32, expression_list; 33, identifier:isinstance; 34, argument_list; 35, not_operator; 36, block; 37, identifier:x; 38, call; 39, False; 40, parenthesized_expression; 41, subscript; 42, identifier:str; 43, call; 44, return_statement; 45, attribute; 46, argument_list; 47, concatenated_string; 48, identifier:x; 49, integer:0; 50, attribute; 51, argument_list; 52, expression_list; 53, identifier:np; 54, identifier:unique; 55, identifier:x; 56, string:"number of observations equals the "; 57, string:"number of unique values."; 58, identifier:np; 59, identifier:all; 60, call; 61, False; 62, string:"elements are not integer or strings."; 63, attribute; 64, argument_list; 65, identifier:np; 66, identifier:equal; 67, call; 68, integer:0; 69, attribute; 70, argument_list; 71, identifier:np; 72, identifier:mod; 73, identifier:x; 74, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 8, 14; 9, 15; 9, 16; 10, 17; 12, 18; 12, 19; 13, 20; 13, 21; 14, 22; 15, 23; 16, 24; 17, 25; 17, 26; 18, 27; 20, 28; 20, 29; 21, 30; 21, 31; 22, 32; 23, 33; 23, 34; 24, 35; 24, 36; 29, 37; 31, 38; 32, 39; 32, 40; 34, 41; 34, 42; 35, 43; 36, 44; 38, 45; 38, 46; 40, 47; 41, 48; 41, 49; 43, 50; 43, 51; 44, 52; 45, 53; 45, 54; 46, 55; 47, 56; 47, 57; 50, 58; 50, 59; 51, 60; 52, 61; 52, 62; 60, 63; 60, 64; 63, 65; 63, 66; 64, 67; 64, 68; 67, 69; 67, 70; 69, 71; 69, 72; 70, 73; 70, 74 | def isordinal(x):
"""Checks if a list or array contains ordinal data.
Warning:
--------
This is not a reliable check for a variable being
ordinal.
The following criteria are used
- There are more observations than unique values.
Why? Ordinal means discrete or countable and
I just assume that an ordinal sample should
have some recurring (countable) values.
- Values are integers or strings.
Why? Ordinal scale data are usually labels
(e.g. strings) or are encoded labels (e.g.
as integers).
- Ordinal scale data is sortable
Integers imply that the Analyst encoded the
labels according to the ordinal data's "natural
order". Strings would imply that the alphabetic
order would be the natual order (what is usually
not the case)
Usage:
------
obs = 10
np.random.seed(42)
x1 = np.random.randint(1,50, (obs,))
x2 = np.random.randint(0,3, (obs,))
x3 = np.random.uniform(0,3, (obs,))
flag, msg = isordinal(x1)
if not flag:
warnings.warn(msg)
"""
import numpy as np
if len(x) == len(np.unique(x)):
return False, ("number of observations equals the "
"number of unique values.")
if not isinstance(x[0], str):
if not np.all(np.equal(np.mod(x, 1), 0)):
return False, "elements are not integer or strings."
return True, "is ordinal" |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, list_splat_pattern; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, identifier:sort; 11, comment:""" Sort the results.
Define how the results should be sorted. The arguments should be tuples
of string defining the key and direction to sort by. For example
`('name', 'asc')` and `('version', 'desc')`. The first sorte rule is
considered first by the API. See also the API documentation on
`sorting`_.
Arguments:
`*sort` (`tuple`)
The rules to sort by
.. _sorting: https://github.com/XereoNet/SpaceGDN/wiki/API#sorting
"""; 12, call; 13, identifier:self; 14, attribute; 15, argument_list; 16, identifier:self; 17, identifier:add_get_param; 18, string; 19, call; 20, string_content:sort; 21, attribute; 22, argument_list; 23, identifier:FILTER_DELIMITER; 24, identifier:join; 25, list_comprehension; 26, call; 27, for_in_clause; 28, attribute; 29, argument_list; 30, identifier:elements; 31, identifier:sort; 32, identifier:ELEMENT_DELIMITER; 33, identifier:join; 34, identifier:elements | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 9, 13; 12, 14; 12, 15; 14, 16; 14, 17; 15, 18; 15, 19; 18, 20; 19, 21; 19, 22; 21, 23; 21, 24; 22, 25; 25, 26; 25, 27; 26, 28; 26, 29; 27, 30; 27, 31; 28, 32; 28, 33; 29, 34 | def sort(self, *sort):
""" Sort the results.
Define how the results should be sorted. The arguments should be tuples
of string defining the key and direction to sort by. For example
`('name', 'asc')` and `('version', 'desc')`. The first sorte rule is
considered first by the API. See also the API documentation on
`sorting`_.
Arguments:
`*sort` (`tuple`)
The rules to sort by
.. _sorting: https://github.com/XereoNet/SpaceGDN/wiki/API#sorting
"""
self.add_get_param('sort', FILTER_DELIMITER.join(
[ELEMENT_DELIMITER.join(elements) for elements in sort]))
return self |
0, module; 1, function_definition; 2, function_name:to_json; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, return_statement; 12, identifier:drop_null; 13, True; 14, identifier:camel; 15, False; 16, identifier:indent; 17, None; 18, identifier:sort_keys; 19, False; 20, comment:"""Serialize self as JSON
Args:
drop_null: bool, default True. Remove 'empty' attributes. See
to_dict.
camel: bool, default True. Convert keys to camelCase.
indent: int, default None. See json built-in.
sort_keys: bool, default False. See json built-in.
Return:
str: object params.
"""; 21, call; 22, attribute; 23, argument_list; 24, identifier:json; 25, identifier:dumps; 26, call; 27, keyword_argument; 28, keyword_argument; 29, attribute; 30, argument_list; 31, identifier:indent; 32, identifier:indent; 33, identifier:sort_keys; 34, identifier:sort_keys; 35, identifier:self; 36, identifier:to_dict; 37, identifier:drop_null; 38, identifier:camel | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 7, 15; 8, 16; 8, 17; 9, 18; 9, 19; 10, 20; 11, 21; 21, 22; 21, 23; 22, 24; 22, 25; 23, 26; 23, 27; 23, 28; 26, 29; 26, 30; 27, 31; 27, 32; 28, 33; 28, 34; 29, 35; 29, 36; 30, 37; 30, 38 | def to_json(self, drop_null=True, camel=False, indent=None, sort_keys=False):
"""Serialize self as JSON
Args:
drop_null: bool, default True. Remove 'empty' attributes. See
to_dict.
camel: bool, default True. Convert keys to camelCase.
indent: int, default None. See json built-in.
sort_keys: bool, default False. See json built-in.
Return:
str: object params.
"""
return json.dumps(self.to_dict(drop_null, camel), indent=indent,
sort_keys=sort_keys) |
0, module; 1, function_definition; 2, function_name:sort_by_name; 3, parameters; 4, block; 5, identifier:names; 6, expression_statement; 7, function_definition; 8, return_statement; 9, comment:"""Sort by last name, uniquely."""; 10, function_name:last_name_key; 11, parameters; 12, block; 13, call; 14, identifier:full_name; 15, expression_statement; 16, if_statement; 17, expression_statement; 18, return_statement; 19, identifier:sorted; 20, argument_list; 21, assignment; 22, comparison_operator:len(parts) == 1; 23, block; 24, assignment; 25, call; 26, call; 27, keyword_argument; 28, identifier:parts; 29, call; 30, call; 31, integer:1; 32, return_statement; 33, identifier:last_first; 34, binary_operator:parts[-1] + ' ' + ' '.join(parts[:-1]); 35, attribute; 36, argument_list; 37, identifier:set; 38, argument_list; 39, identifier:key; 40, identifier:last_name_key; 41, attribute; 42, argument_list; 43, identifier:len; 44, argument_list; 45, call; 46, binary_operator:parts[-1] + ' '; 47, call; 48, identifier:last_first; 49, identifier:upper; 50, identifier:names; 51, identifier:full_name; 52, identifier:split; 53, string; 54, identifier:parts; 55, attribute; 56, argument_list; 57, subscript; 58, string; 59, attribute; 60, argument_list; 61, string_content:; 62, identifier:full_name; 63, identifier:upper; 64, identifier:parts; 65, unary_operator; 66, string_content:; 67, string; 68, identifier:join; 69, subscript; 70, integer:1; 71, string_content:; 72, identifier:parts; 73, slice; 74, unary_operator; 75, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 7, 11; 7, 12; 8, 13; 11, 14; 12, 15; 12, 16; 12, 17; 12, 18; 13, 19; 13, 20; 15, 21; 16, 22; 16, 23; 17, 24; 18, 25; 20, 26; 20, 27; 21, 28; 21, 29; 22, 30; 22, 31; 23, 32; 24, 33; 24, 34; 25, 35; 25, 36; 26, 37; 26, 38; 27, 39; 27, 40; 29, 41; 29, 42; 30, 43; 30, 44; 32, 45; 34, 46; 34, 47; 35, 48; 35, 49; 38, 50; 41, 51; 41, 52; 42, 53; 44, 54; 45, 55; 45, 56; 46, 57; 46, 58; 47, 59; 47, 60; 53, 61; 55, 62; 55, 63; 57, 64; 57, 65; 58, 66; 59, 67; 59, 68; 60, 69; 65, 70; 67, 71; 69, 72; 69, 73; 73, 74; 74, 75 | def sort_by_name(names):
"""Sort by last name, uniquely."""
def last_name_key(full_name):
parts = full_name.split(' ')
if len(parts) == 1:
return full_name.upper()
last_first = parts[-1] + ' ' + ' '.join(parts[:-1])
return last_first.upper()
return sorted(set(names), key=last_name_key) |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, comment:# First sort commits by author email; 8, expression_statement; 9, comment:# Group commits by author email, so they can be merged; 10, for_statement; 11, comment:# Finally sort by the (aggregated) commits' line counts; 12, expression_statement; 13, return_statement; 14, comment:"""Sort by commit size, per author."""; 15, assignment; 16, pattern_list; 17, call; 18, block; 19, assignment; 20, attribute; 21, identifier:users; 22, list; 23, identifier:_; 24, identifier:group; 25, attribute; 26, argument_list; 27, if_statement; 28, attribute; 29, call; 30, identifier:self; 31, identifier:sorted_commits; 32, identifier:itertools; 33, identifier:groupby; 34, call; 35, call; 36, identifier:group; 37, block; 38, identifier:self; 39, identifier:sorted_commits; 40, identifier:sorted; 41, argument_list; 42, identifier:sorted; 43, argument_list; 44, attribute; 45, argument_list; 46, expression_statement; 47, identifier:users; 48, keyword_argument; 49, keyword_argument; 50, attribute; 51, identifier:operator; 52, identifier:attrgetter; 53, string; 54, call; 55, identifier:key; 56, call; 57, identifier:reverse; 58, True; 59, identifier:self; 60, identifier:commits; 61, string_content:author_mail; 62, attribute; 63, argument_list; 64, attribute; 65, argument_list; 66, identifier:users; 67, identifier:append; 68, call; 69, identifier:operator; 70, identifier:attrgetter; 71, string; 72, attribute; 73, argument_list; 74, string_content:line_count; 75, identifier:self; 76, identifier:merge_user_commits; 77, identifier:group | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 6, 14; 8, 15; 10, 16; 10, 17; 10, 18; 12, 19; 13, 20; 15, 21; 15, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 19, 28; 19, 29; 20, 30; 20, 31; 25, 32; 25, 33; 26, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 34, 42; 34, 43; 35, 44; 35, 45; 37, 46; 41, 47; 41, 48; 41, 49; 43, 50; 44, 51; 44, 52; 45, 53; 46, 54; 48, 55; 48, 56; 49, 57; 49, 58; 50, 59; 50, 60; 53, 61; 54, 62; 54, 63; 56, 64; 56, 65; 62, 66; 62, 67; 63, 68; 64, 69; 64, 70; 65, 71; 68, 72; 68, 73; 71, 74; 72, 75; 72, 76; 73, 77 | def sort(self):
"""Sort by commit size, per author."""
# First sort commits by author email
users = []
# Group commits by author email, so they can be merged
for _, group in itertools.groupby(sorted(self.commits),
operator.attrgetter('author_mail')):
if group:
users.append(self.merge_user_commits(group))
# Finally sort by the (aggregated) commits' line counts
self.sorted_commits = sorted(users,
key=operator.attrgetter('line_count'),
reverse=True)
return self.sorted_commits |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, comment:# Take care of last commit; 14, expression_statement; 15, expression_statement; 16, return_statement; 17, comment:"""Consolidate adjacent lines, if same commit ID.
Will modify line number to be a range, when two or more lines with the
same commit ID.
"""; 18, assignment; 19, not_operator; 20, block; 21, assignment; 22, assignment; 23, assignment; 24, identifier:commit; 25, attribute; 26, block; 27, assignment; 28, call; 29, attribute; 30, attribute; 31, list; 32, attribute; 33, return_statement; 34, identifier:prev_commit; 35, call; 36, identifier:prev_line; 37, attribute; 38, identifier:prev_uuid; 39, attribute; 40, identifier:self; 41, identifier:commits; 42, if_statement; 43, expression_statement; 44, expression_statement; 45, attribute; 46, call; 47, attribute; 48, argument_list; 49, identifier:self; 50, identifier:sorted_commits; 51, identifier:self; 52, identifier:sorted_commits; 53, identifier:self; 54, identifier:commits; 55, attribute; 56, attribute; 57, argument_list; 58, identifier:prev_commit; 59, identifier:line_number; 60, identifier:prev_commit; 61, identifier:uuid; 62, parenthesized_expression; 63, block; 64, assignment; 65, assignment; 66, identifier:prev_commit; 67, identifier:lines; 68, attribute; 69, argument_list; 70, attribute; 71, identifier:append; 72, identifier:prev_commit; 73, identifier:self; 74, identifier:sorted_commits; 75, attribute; 76, identifier:pop; 77, integer:0; 78, boolean_operator; 79, expression_statement; 80, expression_statement; 81, expression_statement; 82, identifier:prev_line; 83, attribute; 84, identifier:prev_uuid; 85, attribute; 86, identifier:self; 87, identifier:line_range; 88, attribute; 89, identifier:prev_line; 90, identifier:self; 91, identifier:sorted_commits; 92, identifier:self; 93, identifier:commits; 94, comparison_operator:commit.uuid != prev_uuid; 95, comparison_operator:commit.line_number != (prev_line + 1); 96, assignment; 97, call; 98, assignment; 99, identifier:commit; 100, identifier:line_number; 101, identifier:commit; 102, identifier:uuid; 103, identifier:prev_commit; 104, identifier:line_number; 105, attribute; 106, identifier:prev_uuid; 107, attribute; 108, parenthesized_expression; 109, attribute; 110, call; 111, attribute; 112, argument_list; 113, identifier:prev_commit; 114, identifier:commit; 115, identifier:commit; 116, identifier:uuid; 117, identifier:commit; 118, identifier:line_number; 119, binary_operator:prev_line + 1; 120, identifier:prev_commit; 121, identifier:lines; 122, attribute; 123, argument_list; 124, attribute; 125, identifier:append; 126, identifier:prev_commit; 127, identifier:prev_line; 128, integer:1; 129, identifier:self; 130, identifier:line_range; 131, attribute; 132, identifier:prev_line; 133, identifier:self; 134, identifier:sorted_commits; 135, identifier:prev_commit; 136, identifier:line_number | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 6, 17; 7, 18; 8, 19; 8, 20; 9, 21; 10, 22; 11, 23; 12, 24; 12, 25; 12, 26; 14, 27; 15, 28; 16, 29; 18, 30; 18, 31; 19, 32; 20, 33; 21, 34; 21, 35; 22, 36; 22, 37; 23, 38; 23, 39; 25, 40; 25, 41; 26, 42; 26, 43; 26, 44; 27, 45; 27, 46; 28, 47; 28, 48; 29, 49; 29, 50; 30, 51; 30, 52; 32, 53; 32, 54; 33, 55; 35, 56; 35, 57; 37, 58; 37, 59; 39, 60; 39, 61; 42, 62; 42, 63; 43, 64; 44, 65; 45, 66; 45, 67; 46, 68; 46, 69; 47, 70; 47, 71; 48, 72; 55, 73; 55, 74; 56, 75; 56, 76; 57, 77; 62, 78; 63, 79; 63, 80; 63, 81; 64, 82; 64, 83; 65, 84; 65, 85; 68, 86; 68, 87; 69, 88; 69, 89; 70, 90; 70, 91; 75, 92; 75, 93; 78, 94; 78, 95; 79, 96; 80, 97; 81, 98; 83, 99; 83, 100; 85, 101; 85, 102; 88, 103; 88, 104; 94, 105; 94, 106; 95, 107; 95, 108; 96, 109; 96, 110; 97, 111; 97, 112; 98, 113; 98, 114; 105, 115; 105, 116; 107, 117; 107, 118; 108, 119; 109, 120; 109, 121; 110, 122; 110, 123; 111, 124; 111, 125; 112, 126; 119, 127; 119, 128; 122, 129; 122, 130; 123, 131; 123, 132; 124, 133; 124, 134; 131, 135; 131, 136 | def sort(self):
"""Consolidate adjacent lines, if same commit ID.
Will modify line number to be a range, when two or more lines with the
same commit ID.
"""
self.sorted_commits = []
if not self.commits:
return self.sorted_commits
prev_commit = self.commits.pop(0)
prev_line = prev_commit.line_number
prev_uuid = prev_commit.uuid
for commit in self.commits:
if (commit.uuid != prev_uuid or
commit.line_number != (prev_line + 1)):
prev_commit.lines = self.line_range(prev_commit.line_number,
prev_line)
self.sorted_commits.append(prev_commit)
prev_commit = commit
prev_line = commit.line_number
prev_uuid = commit.uuid
# Take care of last commit
prev_commit.lines = self.line_range(prev_commit.line_number, prev_line)
self.sorted_commits.append(prev_commit)
return self.sorted_commits |
0, module; 1, function_definition; 2, function_name:truncate_most_common; 3, parameters; 4, block; 5, identifier:self; 6, identifier:truncation_length; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, string; 11, assignment; 12, identifier:key; 13, call; 14, block; 15, string_content:Sorts the counter and keeps only the most common items up to
``truncation_length`` in place.
:type truncation_length: int; 16, identifier:keep_keys; 17, call; 18, attribute; 19, argument_list; 20, if_statement; 21, identifier:set; 22, generator_expression; 23, identifier:self; 24, identifier:keys; 25, comparison_operator:key not in keep_keys; 26, block; 27, subscript; 28, for_in_clause; 29, identifier:key; 30, identifier:keep_keys; 31, expression_statement; 32, identifier:v; 33, integer:0; 34, identifier:v; 35, call; 36, call; 37, attribute; 38, argument_list; 39, attribute; 40, argument_list; 41, identifier:self; 42, identifier:most_common; 43, identifier:truncation_length; 44, identifier:self; 45, identifier:pop; 46, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 7, 10; 8, 11; 9, 12; 9, 13; 9, 14; 10, 15; 11, 16; 11, 17; 13, 18; 13, 19; 14, 20; 17, 21; 17, 22; 18, 23; 18, 24; 20, 25; 20, 26; 22, 27; 22, 28; 25, 29; 25, 30; 26, 31; 27, 32; 27, 33; 28, 34; 28, 35; 31, 36; 35, 37; 35, 38; 36, 39; 36, 40; 37, 41; 37, 42; 38, 43; 39, 44; 39, 45; 40, 46 | def truncate_most_common(self, truncation_length):
'''
Sorts the counter and keeps only the most common items up to
``truncation_length`` in place.
:type truncation_length: int
'''
keep_keys = set(v[0] for v in self.most_common(truncation_length))
for key in self.keys():
if key not in keep_keys:
self.pop(key) |
0, module; 1, function_definition; 2, function_name:get_ordered_values; 3, parameters; 4, block; 5, identifier:self; 6, identifier:keypath; 7, identifier:distance_from; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, for_statement; 13, if_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, if_statement; 18, if_statement; 19, expression_statement; 20, expression_statement; 21, expression_statement; 22, for_statement; 23, return_statement; 24, identifier:open_interval; 25, True; 26, comment:"""
Retrieves the referents's values sorted by their distance from the
min, max, or mid value.
"""; 27, assignment; 28, comparison_operator:keypath[0] == 'target'; 29, comment:# instances start with 'target' prefix, but; 30, comment:# don't contain it, so we remove it here.; 31, block; 32, pattern_list; 33, call; 34, block; 35, comparison_operator:len(values) == 0; 36, block; 37, assignment; 38, assignment; 39, assignment; 40, comparison_operator:distance_from == 'max'; 41, block; 42, comparison_operator:distance_from == 'mean'; 43, block; 44, assignment; 45, call; 46, assignment; 47, pattern_list; 48, call; 49, block; 50, identifier:results; 51, identifier:values; 52, list; 53, subscript; 54, string; 55, expression_statement; 56, identifier:_; 57, identifier:instance; 58, attribute; 59, argument_list; 60, expression_statement; 61, if_statement; 62, expression_statement; 63, call; 64, integer:0; 65, return_statement; 66, identifier:values; 67, call; 68, identifier:anchor; 69, call; 70, identifier:diffs; 71, binary_operator:values - anchor; 72, identifier:distance_from; 73, string; 74, expression_statement; 75, expression_statement; 76, identifier:distance_from; 77, string; 78, expression_statement; 79, expression_statement; 80, identifier:sdiffs; 81, call; 82, attribute; 83, argument_list; 84, identifier:results; 85, list; 86, identifier:ix; 87, identifier:el; 88, identifier:enumerate; 89, argument_list; 90, expression_statement; 91, expression_statement; 92, if_statement; 93, identifier:keypath; 94, integer:0; 95, string_content:target; 96, assignment; 97, identifier:self; 98, identifier:iter_singleton_referents; 99, assignment; 100, boolean_operator; 101, block; 102, call; 103, identifier:len; 104, argument_list; 105, list; 106, attribute; 107, argument_list; 108, attribute; 109, argument_list; 110, identifier:values; 111, identifier:anchor; 112, string_content:max; 113, assignment; 114, assignment; 115, string_content:mean; 116, assignment; 117, assignment; 118, attribute; 119, argument_list; 120, identifier:sdiffs; 121, identifier:sort; 122, identifier:sdiffs; 123, assignment; 124, assignment; 125, False; 126, comment:# when vagueness has been made precise through an ordinal; 127, block; 128, elif_clause; 129, elif_clause; 130, elif_clause; 131, identifier:keypath; 132, subscript; 133, identifier:value; 134, call; 135, call; 136, comparison_operator:value.low != value.high; 137, return_statement; 138, attribute; 139, argument_list; 140, identifier:values; 141, identifier:np; 142, identifier:array; 143, identifier:values; 144, identifier:values; 145, identifier:min; 146, identifier:anchor; 147, call; 148, identifier:diffs; 149, binary_operator:anchor - values; 150, identifier:anchor; 151, call; 152, identifier:diffs; 153, call; 154, identifier:np; 155, identifier:unique; 156, identifier:diffs; 157, identifier:mask; 158, comparison_operator:diffs <= el; 159, identifier:vals; 160, subscript; 161, expression_statement; 162, comparison_operator:distance_from == 'max'; 163, block; 164, comparison_operator:distance_from == 'min'; 165, block; 166, comparison_operator:distance_from == 'mean'; 167, block; 168, identifier:keypath; 169, slice; 170, attribute; 171, argument_list; 172, identifier:hasattr; 173, argument_list; 174, attribute; 175, attribute; 176, list; 177, identifier:values; 178, identifier:append; 179, call; 180, attribute; 181, argument_list; 182, identifier:anchor; 183, identifier:values; 184, attribute; 185, argument_list; 186, identifier:abs; 187, argument_list; 188, identifier:diffs; 189, identifier:el; 190, identifier:values; 191, identifier:mask; 192, call; 193, identifier:distance_from; 194, string; 195, if_statement; 196, identifier:distance_from; 197, string; 198, if_statement; 199, identifier:distance_from; 200, string; 201, if_statement; 202, expression_statement; 203, integer:1; 204, identifier:instance; 205, identifier:get_value_from_path; 206, identifier:keypath; 207, identifier:value; 208, string; 209, identifier:value; 210, identifier:low; 211, identifier:value; 212, identifier:high; 213, identifier:float; 214, argument_list; 215, identifier:values; 216, identifier:max; 217, identifier:values; 218, identifier:mean; 219, binary_operator:anchor - values; 220, attribute; 221, argument_list; 222, string_content:max; 223, identifier:open_interval; 224, block; 225, else_clause; 226, string_content:min; 227, identifier:open_interval; 228, block; 229, else_clause; 230, string_content:mean; 231, comparison_operator:ix+1 == len(sdiffs); 232, block; 233, call; 234, string_content:low; 235, identifier:value; 236, identifier:anchor; 237, identifier:values; 238, identifier:results; 239, identifier:append; 240, call; 241, expression_statement; 242, block; 243, expression_statement; 244, block; 245, binary_operator:ix+1; 246, call; 247, continue_statement; 248, comment:# skip last; 249, attribute; 250, argument_list; 251, identifier:IntervalCell; 252, argument_list; 253, call; 254, expression_statement; 255, call; 256, expression_statement; 257, identifier:ix; 258, integer:1; 259, identifier:len; 260, argument_list; 261, identifier:results; 262, identifier:append; 263, call; 264, call; 265, call; 266, attribute; 267, argument_list; 268, call; 269, attribute; 270, argument_list; 271, call; 272, identifier:sdiffs; 273, identifier:IntervalCell; 274, argument_list; 275, attribute; 276, argument_list; 277, attribute; 278, argument_list; 279, identifier:results; 280, identifier:append; 281, call; 282, attribute; 283, argument_list; 284, identifier:results; 285, identifier:append; 286, call; 287, attribute; 288, argument_list; 289, call; 290, call; 291, identifier:vals; 292, identifier:min; 293, identifier:vals; 294, identifier:max; 295, identifier:IntervalCell; 296, argument_list; 297, identifier:results; 298, identifier:append; 299, call; 300, identifier:IntervalCell; 301, argument_list; 302, identifier:results; 303, identifier:append; 304, call; 305, attribute; 306, argument_list; 307, attribute; 308, argument_list; 309, call; 310, attribute; 311, identifier:IntervalCell; 312, argument_list; 313, unary_operator; 314, call; 315, identifier:IntervalCell; 316, argument_list; 317, identifier:vals; 318, identifier:min; 319, identifier:vals; 320, identifier:max; 321, attribute; 322, argument_list; 323, identifier:np; 324, identifier:inf; 325, call; 326, call; 327, attribute; 328, attribute; 329, argument_list; 330, call; 331, call; 332, identifier:vals; 333, identifier:min; 334, attribute; 335, argument_list; 336, attribute; 337, argument_list; 338, identifier:np; 339, identifier:inf; 340, identifier:vals; 341, identifier:max; 342, attribute; 343, argument_list; 344, attribute; 345, argument_list; 346, identifier:vals; 347, identifier:min; 348, identifier:vals; 349, identifier:min; 350, identifier:vals; 351, identifier:max; 352, identifier:vals; 353, identifier:max | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 8, 24; 8, 25; 9, 26; 10, 27; 11, 28; 11, 29; 11, 30; 11, 31; 12, 32; 12, 33; 12, 34; 13, 35; 13, 36; 14, 37; 15, 38; 16, 39; 17, 40; 17, 41; 18, 42; 18, 43; 19, 44; 20, 45; 21, 46; 22, 47; 22, 48; 22, 49; 23, 50; 27, 51; 27, 52; 28, 53; 28, 54; 31, 55; 32, 56; 32, 57; 33, 58; 33, 59; 34, 60; 34, 61; 34, 62; 35, 63; 35, 64; 36, 65; 37, 66; 37, 67; 38, 68; 38, 69; 39, 70; 39, 71; 40, 72; 40, 73; 41, 74; 41, 75; 42, 76; 42, 77; 43, 78; 43, 79; 44, 80; 44, 81; 45, 82; 45, 83; 46, 84; 46, 85; 47, 86; 47, 87; 48, 88; 48, 89; 49, 90; 49, 91; 49, 92; 53, 93; 53, 94; 54, 95; 55, 96; 58, 97; 58, 98; 60, 99; 61, 100; 61, 101; 62, 102; 63, 103; 63, 104; 65, 105; 67, 106; 67, 107; 69, 108; 69, 109; 71, 110; 71, 111; 73, 112; 74, 113; 75, 114; 77, 115; 78, 116; 79, 117; 81, 118; 81, 119; 82, 120; 82, 121; 89, 122; 90, 123; 91, 124; 92, 125; 92, 126; 92, 127; 92, 128; 92, 129; 92, 130; 96, 131; 96, 132; 99, 133; 99, 134; 100, 135; 100, 136; 101, 137; 102, 138; 102, 139; 104, 140; 106, 141; 106, 142; 107, 143; 108, 144; 108, 145; 113, 146; 113, 147; 114, 148; 114, 149; 116, 150; 116, 151; 117, 152; 117, 153; 118, 154; 118, 155; 119, 156; 123, 157; 123, 158; 124, 159; 124, 160; 127, 161; 128, 162; 128, 163; 129, 164; 129, 165; 130, 166; 130, 167; 132, 168; 132, 169; 134, 170; 134, 171; 135, 172; 135, 173; 136, 174; 136, 175; 137, 176; 138, 177; 138, 178; 139, 179; 147, 180; 147, 181; 149, 182; 149, 183; 151, 184; 151, 185; 153, 186; 153, 187; 158, 188; 158, 189; 160, 190; 160, 191; 161, 192; 162, 193; 162, 194; 163, 195; 164, 196; 164, 197; 165, 198; 166, 199; 166, 200; 167, 201; 167, 202; 169, 203; 170, 204; 170, 205; 171, 206; 173, 207; 173, 208; 174, 209; 174, 210; 175, 211; 175, 212; 179, 213; 179, 214; 180, 215; 180, 216; 184, 217; 184, 218; 187, 219; 192, 220; 192, 221; 194, 222; 195, 223; 195, 224; 195, 225; 197, 226; 198, 227; 198, 228; 198, 229; 200, 230; 201, 231; 201, 232; 202, 233; 208, 234; 214, 235; 219, 236; 219, 237; 220, 238; 220, 239; 221, 240; 224, 241; 225, 242; 228, 243; 229, 244; 231, 245; 231, 246; 232, 247; 232, 248; 233, 249; 233, 250; 240, 251; 240, 252; 241, 253; 242, 254; 243, 255; 244, 256; 245, 257; 245, 258; 246, 259; 246, 260; 249, 261; 249, 262; 250, 263; 252, 264; 252, 265; 253, 266; 253, 267; 254, 268; 255, 269; 255, 270; 256, 271; 260, 272; 263, 273; 263, 274; 264, 275; 264, 276; 265, 277; 265, 278; 266, 279; 266, 280; 267, 281; 268, 282; 268, 283; 269, 284; 269, 285; 270, 286; 271, 287; 271, 288; 274, 289; 274, 290; 275, 291; 275, 292; 277, 293; 277, 294; 281, 295; 281, 296; 282, 297; 282, 298; 283, 299; 286, 300; 286, 301; 287, 302; 287, 303; 288, 304; 289, 305; 289, 306; 290, 307; 290, 308; 296, 309; 296, 310; 299, 311; 299, 312; 301, 313; 301, 314; 304, 315; 304, 316; 305, 317; 305, 318; 307, 319; 307, 320; 309, 321; 309, 322; 310, 323; 310, 324; 312, 325; 312, 326; 313, 327; 314, 328; 314, 329; 316, 330; 316, 331; 321, 332; 321, 333; 325, 334; 325, 335; 326, 336; 326, 337; 327, 338; 327, 339; 328, 340; 328, 341; 330, 342; 330, 343; 331, 344; 331, 345; 334, 346; 334, 347; 336, 348; 336, 349; 342, 350; 342, 351; 344, 352; 344, 353 | def get_ordered_values(self, keypath, distance_from, open_interval=True):
"""
Retrieves the referents's values sorted by their distance from the
min, max, or mid value.
"""
values = []
if keypath[0] == 'target':
# instances start with 'target' prefix, but
# don't contain it, so we remove it here.
keypath = keypath[1:]
for _, instance in self.iter_singleton_referents():
value = instance.get_value_from_path(keypath)
if hasattr(value, 'low') and value.low != value.high:
return []
values.append(float(value))
if len(values) == 0:
return []
values = np.array(values)
anchor = values.min()
diffs = values - anchor
if distance_from == 'max':
anchor = values.max()
diffs = anchor - values
if distance_from == 'mean':
anchor = values.mean()
diffs = abs(anchor - values)
sdiffs = np.unique(diffs)
sdiffs.sort()
results = []
for ix, el in enumerate(sdiffs):
mask = diffs <= el
vals = values[mask]
if False:
# when vagueness has been made precise through an ordinal
results.append(IntervalCell(vals.min(), vals.max()))
elif distance_from == 'max':
if open_interval:
results.append(IntervalCell(vals.min(), np.inf))
else:
results.append(IntervalCell(vals.min(), vals.min()))
elif distance_from == 'min':
if open_interval:
results.append(IntervalCell(-np.inf, vals.max()))
else:
results.append(IntervalCell(vals.max(), vals.max()))
elif distance_from == 'mean':
if ix+1 == len(sdiffs): continue # skip last
results.append(IntervalCell(vals.min(), vals.max()))
return results |
0, module; 1, function_definition; 2, function_name:gp_datdir; 3, parameters; 4, block; 5, identifier:initial; 6, identifier:topN; 7, expression_statement; 8, comment:# prepare input/output directories; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, if_statement; 13, comment:# prepare data; 14, expression_statement; 15, for_statement; 16, expression_statement; 17, comment:# shown if --log flag given on command line; 18, comment:# sort countries according to mean population (highest -> lowest); 19, expression_statement; 20, comment:# "pop" (select) N most populated countries; 21, expression_statement; 22, comment:# generate plot using ccsgp.make_plot; 23, expression_statement; 24, expression_statement; 25, return_statement; 26, comment:"""example for plotting from a text file via numpy.loadtxt
1. prepare input/output directories
2. load the data into an OrderedDict() [adjust axes units]
3. sort countries from highest to lowest population
4. select the <topN> most populated countries
5. call ccsgp.make_plot with data from 4
Below is an output image for country initial T and the 4 most populated
countries for this initial (click to enlarge). Also see::
$ python -m ccsgp_get_started.examples.gp_datdir -h
for help on the command line options.
.. image:: pics/T.png
:width: 450 px
.. image:: pics/U.png
:width: 450 px
:param initial: country initial
:type initial: str
:param topN: number of most populated countries to plot
:type topN: int
:ivar inDir: input directory according to package structure and initial
:ivar outDir: output directory according to package structure
:ivar data: OrderedDict with datasets to plot as separate keys
:ivar file: data input file for specific country, format: [x y] OR [x y dx dy]
:ivar country: country, filename stem of input file
:ivar file_url: absolute url to input file
:ivar nSets: number of datasets
"""; 27, assignment; 28, assignment; 29, assignment; 30, not_operator; 31, comment:# catch missing initial; 32, block; 33, assignment; 34, identifier:file; 35, call; 36, block; 37, call; 38, assignment; 39, assignment; 40, assignment; 41, call; 42, string; 43, pattern_list; 44, call; 45, identifier:initial; 46, call; 47, identifier:inDir; 48, call; 49, call; 50, return_statement; 51, identifier:data; 52, call; 53, attribute; 54, argument_list; 55, expression_statement; 56, expression_statement; 57, expression_statement; 58, comment:# load data; 59, comment:# set y-axis unit to 1M; 60, expression_statement; 61, if_statement; 62, attribute; 63, argument_list; 64, identifier:sorted_data; 65, call; 66, identifier:top_data; 67, call; 68, identifier:nSets; 69, call; 70, identifier:make_plot; 71, argument_list; 72, string_content:done; 73, identifier:inDir; 74, identifier:outDir; 75, identifier:getWorkDirs; 76, argument_list; 77, attribute; 78, argument_list; 79, attribute; 80, argument_list; 81, attribute; 82, argument_list; 83, binary_operator:"initial %s doesn't exist" % initial; 84, identifier:OrderedDict; 85, argument_list; 86, identifier:os; 87, identifier:listdir; 88, identifier:inDir; 89, assignment; 90, assignment; 91, assignment; 92, augmented_assignment; 93, comparison_operator:data[country].shape[1] > 2; 94, block; 95, identifier:logging; 96, identifier:debug; 97, identifier:data; 98, identifier:OrderedDict; 99, argument_list; 100, identifier:OrderedDict; 101, generator_expression; 102, identifier:len; 103, argument_list; 104, keyword_argument; 105, keyword_argument; 106, keyword_argument; 107, comment:# use data keys as legend titles; 108, keyword_argument; 109, keyword_argument; 110, keyword_argument; 111, keyword_argument; 112, keyword_argument; 113, keyword_argument; 114, keyword_argument; 115, identifier:initial; 116, identifier:capitalize; 117, attribute; 118, identifier:join; 119, identifier:inDir; 120, identifier:initial; 121, attribute; 122, identifier:exists; 123, identifier:inDir; 124, string:"initial %s doesn't exist"; 125, identifier:initial; 126, identifier:country; 127, subscript; 128, identifier:file_url; 129, call; 130, subscript; 131, call; 132, subscript; 133, float:1e6; 134, subscript; 135, integer:2; 136, expression_statement; 137, call; 138, call; 139, for_in_clause; 140, if_clause; 141, identifier:top_data; 142, identifier:data; 143, call; 144, identifier:properties; 145, list_comprehension; 146, identifier:titles; 147, call; 148, identifier:name; 149, call; 150, identifier:key; 151, list; 152, identifier:ylabel; 153, string; 154, identifier:xlabel; 155, string; 156, identifier:rmargin; 157, float:0.99; 158, identifier:tmargin; 159, float:0.85; 160, identifier:size; 161, string; 162, identifier:os; 163, identifier:path; 164, identifier:os; 165, identifier:path; 166, call; 167, integer:0; 168, attribute; 169, argument_list; 170, identifier:data; 171, identifier:country; 172, attribute; 173, argument_list; 174, subscript; 175, slice; 176, integer:1; 177, attribute; 178, integer:1; 179, augmented_assignment; 180, identifier:sorted; 181, argument_list; 182, attribute; 183, argument_list; 184, identifier:i; 185, call; 186, identifier:sorted_data; 187, attribute; 188, argument_list; 189, call; 190, for_in_clause; 191, attribute; 192, argument_list; 193, attribute; 194, argument_list; 195, string; 196, string; 197, string_content; 198, string_content:year; 199, string_content:8.5in,8in; 200, attribute; 201, argument_list; 202, attribute; 203, identifier:join; 204, identifier:inDir; 205, identifier:file; 206, identifier:np; 207, identifier:loadtxt; 208, call; 209, identifier:data; 210, identifier:country; 211, subscript; 212, identifier:shape; 213, subscript; 214, float:1e6; 215, call; 216, keyword_argument; 217, keyword_argument; 218, identifier:sorted_data; 219, identifier:popitem; 220, keyword_argument; 221, identifier:xrange; 222, argument_list; 223, identifier:top_data; 224, identifier:values; 225, identifier:getOpts; 226, argument_list; 227, identifier:i; 228, call; 229, identifier:top_data; 230, identifier:keys; 231, attribute; 232, identifier:join; 233, identifier:outDir; 234, identifier:initial; 235, string_content:at graph 1., 1.2; 236, string_content:maxrows 2; 237, escape_sequence:\664; 238, attribute; 239, identifier:splitext; 240, identifier:file; 241, identifier:os; 242, identifier:path; 243, identifier:open; 244, argument_list; 245, identifier:data; 246, identifier:country; 247, subscript; 248, slice; 249, slice; 250, attribute; 251, argument_list; 252, identifier:key; 253, lambda; 254, identifier:reverse; 255, True; 256, identifier:last; 257, False; 258, identifier:topN; 259, identifier:i; 260, identifier:xrange; 261, argument_list; 262, identifier:os; 263, identifier:path; 264, identifier:os; 265, identifier:path; 266, identifier:file_url; 267, string; 268, identifier:data; 269, identifier:country; 270, integer:3; 271, identifier:data; 272, identifier:items; 273, lambda_parameters; 274, call; 275, identifier:nSets; 276, string_content:rb; 277, identifier:t; 278, attribute; 279, argument_list; 280, identifier:np; 281, identifier:mean; 282, subscript; 283, subscript; 284, slice; 285, integer:1; 286, identifier:t; 287, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 7, 26; 9, 27; 10, 28; 11, 29; 12, 30; 12, 31; 12, 32; 14, 33; 15, 34; 15, 35; 15, 36; 16, 37; 19, 38; 21, 39; 23, 40; 24, 41; 25, 42; 27, 43; 27, 44; 28, 45; 28, 46; 29, 47; 29, 48; 30, 49; 32, 50; 33, 51; 33, 52; 35, 53; 35, 54; 36, 55; 36, 56; 36, 57; 36, 58; 36, 59; 36, 60; 36, 61; 37, 62; 37, 63; 38, 64; 38, 65; 39, 66; 39, 67; 40, 68; 40, 69; 41, 70; 41, 71; 42, 72; 43, 73; 43, 74; 44, 75; 44, 76; 46, 77; 46, 78; 48, 79; 48, 80; 49, 81; 49, 82; 50, 83; 52, 84; 52, 85; 53, 86; 53, 87; 54, 88; 55, 89; 56, 90; 57, 91; 60, 92; 61, 93; 61, 94; 62, 95; 62, 96; 63, 97; 65, 98; 65, 99; 67, 100; 67, 101; 69, 102; 69, 103; 71, 104; 71, 105; 71, 106; 71, 107; 71, 108; 71, 109; 71, 110; 71, 111; 71, 112; 71, 113; 71, 114; 77, 115; 77, 116; 79, 117; 79, 118; 80, 119; 80, 120; 81, 121; 81, 122; 82, 123; 83, 124; 83, 125; 89, 126; 89, 127; 90, 128; 90, 129; 91, 130; 91, 131; 92, 132; 92, 133; 93, 134; 93, 135; 94, 136; 99, 137; 101, 138; 101, 139; 101, 140; 103, 141; 104, 142; 104, 143; 105, 144; 105, 145; 106, 146; 106, 147; 108, 148; 108, 149; 109, 150; 109, 151; 110, 152; 110, 153; 111, 154; 111, 155; 112, 156; 112, 157; 113, 158; 113, 159; 114, 160; 114, 161; 117, 162; 117, 163; 121, 164; 121, 165; 127, 166; 127, 167; 129, 168; 129, 169; 130, 170; 130, 171; 131, 172; 131, 173; 132, 174; 132, 175; 132, 176; 134, 177; 134, 178; 136, 179; 137, 180; 137, 181; 138, 182; 138, 183; 139, 184; 139, 185; 140, 186; 143, 187; 143, 188; 145, 189; 145, 190; 147, 191; 147, 192; 149, 193; 149, 194; 151, 195; 151, 196; 153, 197; 155, 198; 161, 199; 166, 200; 166, 201; 168, 202; 168, 203; 169, 204; 169, 205; 172, 206; 172, 207; 173, 208; 174, 209; 174, 210; 177, 211; 177, 212; 179, 213; 179, 214; 181, 215; 181, 216; 181, 217; 182, 218; 182, 219; 183, 220; 185, 221; 185, 222; 187, 223; 187, 224; 189, 225; 189, 226; 190, 227; 190, 228; 191, 229; 191, 230; 193, 231; 193, 232; 194, 233; 194, 234; 195, 235; 196, 236; 197, 237; 200, 238; 200, 239; 201, 240; 202, 241; 202, 242; 208, 243; 208, 244; 211, 245; 211, 246; 213, 247; 213, 248; 213, 249; 215, 250; 215, 251; 216, 252; 216, 253; 217, 254; 217, 255; 220, 256; 220, 257; 222, 258; 226, 259; 228, 260; 228, 261; 231, 262; 231, 263; 238, 264; 238, 265; 244, 266; 244, 267; 247, 268; 247, 269; 249, 270; 250, 271; 250, 272; 253, 273; 253, 274; 261, 275; 267, 276; 273, 277; 274, 278; 274, 279; 278, 280; 278, 281; 279, 282; 282, 283; 282, 284; 282, 285; 283, 286; 283, 287 | def gp_datdir(initial, topN):
"""example for plotting from a text file via numpy.loadtxt
1. prepare input/output directories
2. load the data into an OrderedDict() [adjust axes units]
3. sort countries from highest to lowest population
4. select the <topN> most populated countries
5. call ccsgp.make_plot with data from 4
Below is an output image for country initial T and the 4 most populated
countries for this initial (click to enlarge). Also see::
$ python -m ccsgp_get_started.examples.gp_datdir -h
for help on the command line options.
.. image:: pics/T.png
:width: 450 px
.. image:: pics/U.png
:width: 450 px
:param initial: country initial
:type initial: str
:param topN: number of most populated countries to plot
:type topN: int
:ivar inDir: input directory according to package structure and initial
:ivar outDir: output directory according to package structure
:ivar data: OrderedDict with datasets to plot as separate keys
:ivar file: data input file for specific country, format: [x y] OR [x y dx dy]
:ivar country: country, filename stem of input file
:ivar file_url: absolute url to input file
:ivar nSets: number of datasets
"""
# prepare input/output directories
inDir, outDir = getWorkDirs()
initial = initial.capitalize()
inDir = os.path.join(inDir, initial)
if not os.path.exists(inDir): # catch missing initial
return "initial %s doesn't exist" % initial
# prepare data
data = OrderedDict()
for file in os.listdir(inDir):
country = os.path.splitext(file)[0]
file_url = os.path.join(inDir, file)
data[country] = np.loadtxt(open(file_url, 'rb')) # load data
# set y-axis unit to 1M
data[country][:, 1] /= 1e6
if data[country].shape[1] > 2: data[country][:, 3:] /= 1e6
logging.debug(data) # shown if --log flag given on command line
# sort countries according to mean population (highest -> lowest)
sorted_data = OrderedDict(sorted(
data.items(), key = lambda t: np.mean(t[1][:,1]), reverse = True
))
# "pop" (select) N most populated countries
top_data = OrderedDict(
sorted_data.popitem(last = False) for i in xrange(topN)
if sorted_data
)
# generate plot using ccsgp.make_plot
nSets = len(top_data)
make_plot(
data = top_data.values(),
properties = [ getOpts(i) for i in xrange(nSets) ],
titles = top_data.keys(), # use data keys as legend titles
name = os.path.join(outDir, initial),
key = [ 'at graph 1., 1.2', 'maxrows 2' ],
ylabel = 'total population ({/Symbol \664} 10^{6})',
xlabel = 'year', rmargin = 0.99, tmargin = 0.85, size='8.5in,8in'
)
return 'done' |
0, module; 1, function_definition; 2, function_name:rankingEval; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, comment:# Compute the selection probabilities of each individual; 14, expression_statement; 15, expression_statement; 16, for_statement; 17, expression_statement; 18, expression_statement; 19, return_statement; 20, string; 21, assignment; 22, assignment; 23, identifier:i; 24, call; 25, block; 26, assignment; 27, identifier:i; 28, call; 29, block; 30, assignment; 31, assignment; 32, assignment; 33, identifier:i; 34, call; 35, block; 36, assignment; 37, assignment; 38, list; 39, string_content:Sorting the pop. base on the fitnessEval result; 40, identifier:fitnessAll; 41, call; 42, identifier:fitnessNorm; 43, call; 44, identifier:range; 45, argument_list; 46, expression_statement; 47, expression_statement; 48, identifier:maxFitness; 49, call; 50, identifier:range; 51, argument_list; 52, expression_statement; 53, identifier:fitnessSorted; 54, call; 55, identifier:probability; 56, call; 57, identifier:S; 58, float:2.0; 59, identifier:range; 60, argument_list; 61, expression_statement; 62, attribute; 63, integer:1; 64, attribute; 65, identifier:fitnessAll; 66, identifier:fitnessAll; 67, subscript; 68, identifier:probability; 69, attribute; 70, argument_list; 71, attribute; 72, argument_list; 73, attribute; 74, call; 75, assignment; 76, attribute; 77, argument_list; 78, attribute; 79, assignment; 80, attribute; 81, argument_list; 82, attribute; 83, argument_list; 84, attribute; 85, assignment; 86, identifier:self; 87, identifier:rankingComputed; 88, identifier:self; 89, identifier:fitness; 90, identifier:fitnessSorted; 91, slice; 92, identifier:numpy; 93, identifier:zeros; 94, attribute; 95, identifier:numpy; 96, identifier:zeros; 97, attribute; 98, identifier:self; 99, identifier:length; 100, attribute; 101, argument_list; 102, subscript; 103, attribute; 104, identifier:fitnessAll; 105, identifier:max; 106, identifier:self; 107, identifier:length; 108, subscript; 109, binary_operator:(maxFitness - fitnessAll[i]) / maxFitness; 110, identifier:fitnessNorm; 111, identifier:argsort; 112, identifier:numpy; 113, identifier:zeros; 114, attribute; 115, identifier:self; 116, identifier:length; 117, subscript; 118, binary_operator:((2-S)/self.length) + (2*i*(S-1))/(self.length*(self.length-1)); 119, unary_operator; 120, identifier:self; 121, identifier:length; 122, identifier:self; 123, identifier:length; 124, subscript; 125, identifier:fitnessEval; 126, identifier:fitnessAll; 127, identifier:i; 128, subscript; 129, identifier:fitness; 130, identifier:fitnessNorm; 131, identifier:i; 132, parenthesized_expression; 133, identifier:maxFitness; 134, identifier:self; 135, identifier:length; 136, identifier:probability; 137, subscript; 138, parenthesized_expression; 139, binary_operator:(2*i*(S-1))/(self.length*(self.length-1)); 140, integer:1; 141, attribute; 142, identifier:i; 143, attribute; 144, identifier:i; 145, binary_operator:maxFitness - fitnessAll[i]; 146, identifier:fitnessSorted; 147, identifier:i; 148, binary_operator:(2-S)/self.length; 149, parenthesized_expression; 150, parenthesized_expression; 151, identifier:self; 152, identifier:Ind; 153, identifier:self; 154, identifier:Ind; 155, identifier:maxFitness; 156, subscript; 157, parenthesized_expression; 158, attribute; 159, binary_operator:2*i*(S-1); 160, binary_operator:self.length*(self.length-1); 161, identifier:fitnessAll; 162, identifier:i; 163, binary_operator:2-S; 164, identifier:self; 165, identifier:length; 166, binary_operator:2*i; 167, parenthesized_expression; 168, attribute; 169, parenthesized_expression; 170, integer:2; 171, identifier:S; 172, integer:2; 173, identifier:i; 174, binary_operator:S-1; 175, identifier:self; 176, identifier:length; 177, binary_operator:self.length-1; 178, identifier:S; 179, integer:1; 180, attribute; 181, integer:1; 182, identifier:self; 183, identifier:length | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 6, 20; 7, 21; 8, 22; 9, 23; 9, 24; 9, 25; 10, 26; 11, 27; 11, 28; 11, 29; 12, 30; 14, 31; 15, 32; 16, 33; 16, 34; 16, 35; 17, 36; 18, 37; 19, 38; 20, 39; 21, 40; 21, 41; 22, 42; 22, 43; 24, 44; 24, 45; 25, 46; 25, 47; 26, 48; 26, 49; 28, 50; 28, 51; 29, 52; 30, 53; 30, 54; 31, 55; 31, 56; 32, 57; 32, 58; 34, 59; 34, 60; 35, 61; 36, 62; 36, 63; 37, 64; 37, 65; 38, 66; 38, 67; 38, 68; 41, 69; 41, 70; 43, 71; 43, 72; 45, 73; 46, 74; 47, 75; 49, 76; 49, 77; 51, 78; 52, 79; 54, 80; 54, 81; 56, 82; 56, 83; 60, 84; 61, 85; 62, 86; 62, 87; 64, 88; 64, 89; 67, 90; 67, 91; 69, 92; 69, 93; 70, 94; 71, 95; 71, 96; 72, 97; 73, 98; 73, 99; 74, 100; 74, 101; 75, 102; 75, 103; 76, 104; 76, 105; 78, 106; 78, 107; 79, 108; 79, 109; 80, 110; 80, 111; 82, 112; 82, 113; 83, 114; 84, 115; 84, 116; 85, 117; 85, 118; 91, 119; 94, 120; 94, 121; 97, 122; 97, 123; 100, 124; 100, 125; 102, 126; 102, 127; 103, 128; 103, 129; 108, 130; 108, 131; 109, 132; 109, 133; 114, 134; 114, 135; 117, 136; 117, 137; 118, 138; 118, 139; 119, 140; 124, 141; 124, 142; 128, 143; 128, 144; 132, 145; 137, 146; 137, 147; 138, 148; 139, 149; 139, 150; 141, 151; 141, 152; 143, 153; 143, 154; 145, 155; 145, 156; 148, 157; 148, 158; 149, 159; 150, 160; 156, 161; 156, 162; 157, 163; 158, 164; 158, 165; 159, 166; 159, 167; 160, 168; 160, 169; 163, 170; 163, 171; 166, 172; 166, 173; 167, 174; 168, 175; 168, 176; 169, 177; 174, 178; 174, 179; 177, 180; 177, 181; 180, 182; 180, 183 | def rankingEval(self):
'''
Sorting the pop. base on the fitnessEval result
'''
fitnessAll = numpy.zeros(self.length)
fitnessNorm = numpy.zeros(self.length)
for i in range(self.length):
self.Ind[i].fitnessEval()
fitnessAll[i] = self.Ind[i].fitness
maxFitness = fitnessAll.max()
for i in range(self.length):
fitnessNorm[i] = (maxFitness - fitnessAll[i]) / maxFitness
fitnessSorted = fitnessNorm.argsort()
# Compute the selection probabilities of each individual
probability = numpy.zeros(self.length)
S = 2.0
for i in range(self.length):
probability[fitnessSorted[i]] = ((2-S)/self.length) + (2*i*(S-1))/(self.length*(self.length-1))
self.rankingComputed = 1
self.fitness = fitnessAll
return [fitnessAll, fitnessSorted[::-1], probability] |
0, module; 1, function_definition; 2, function_name:sortedbyAge; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, expression_statement; 10, return_statement; 11, string; 12, assignment; 13, identifier:i; 14, call; 15, block; 16, assignment; 17, subscript; 18, string_content:Sorting the pop. base of the age; 19, identifier:ageAll; 20, call; 21, identifier:range; 22, argument_list; 23, expression_statement; 24, identifier:ageSorted; 25, call; 26, identifier:ageSorted; 27, slice; 28, attribute; 29, argument_list; 30, attribute; 31, assignment; 32, attribute; 33, argument_list; 34, unary_operator; 35, identifier:numpy; 36, identifier:zeros; 37, attribute; 38, identifier:self; 39, identifier:length; 40, subscript; 41, attribute; 42, identifier:ageAll; 43, identifier:argsort; 44, integer:1; 45, identifier:self; 46, identifier:length; 47, identifier:ageAll; 48, identifier:i; 49, subscript; 50, identifier:age; 51, attribute; 52, identifier:i; 53, identifier:self; 54, identifier:Ind | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 8, 14; 8, 15; 9, 16; 10, 17; 11, 18; 12, 19; 12, 20; 14, 21; 14, 22; 15, 23; 16, 24; 16, 25; 17, 26; 17, 27; 20, 28; 20, 29; 22, 30; 23, 31; 25, 32; 25, 33; 27, 34; 28, 35; 28, 36; 29, 37; 30, 38; 30, 39; 31, 40; 31, 41; 32, 42; 32, 43; 34, 44; 37, 45; 37, 46; 40, 47; 40, 48; 41, 49; 41, 50; 49, 51; 49, 52; 51, 53; 51, 54 | def sortedbyAge(self):
'''
Sorting the pop. base of the age
'''
ageAll = numpy.zeros(self.length)
for i in range(self.length):
ageAll[i] = self.Ind[i].age
ageSorted = ageAll.argsort()
return ageSorted[::-1] |
0, module; 1, function_definition; 2, function_name:upcoming_releases; 3, parameters; 4, block; 5, identifier:self; 6, identifier:product; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, comment:"""
Get upcoming releases for this product.
Specifically we search for releases with a GA date greater-than or
equal to today's date.
:param product: str, eg. "ceph"
:returns: deferred that when fired returns a list of Munch (dict-like)
objects representing all releases, sorted by shortname.
"""; 16, assignment; 17, assignment; 18, assignment; 19, assignment; 20, assignment; 21, assignment; 22, call; 23, identifier:url; 24, string; 25, identifier:url; 26, binary_operator:url + '?product__shortname=' + product; 27, identifier:url; 28, binary_operator:url + '&ga_date__gte=' + date.today().strftime('%Y-%m-%d'); 29, identifier:url; 30, binary_operator:url + '&ordering=shortname_sort'; 31, identifier:releases; 32, yield; 33, identifier:result; 34, call; 35, attribute; 36, argument_list; 37, string_content:api/v6/releases/; 38, binary_operator:url + '?product__shortname='; 39, identifier:product; 40, binary_operator:url + '&ga_date__gte='; 41, call; 42, identifier:url; 43, string; 44, call; 45, identifier:munchify; 46, argument_list; 47, identifier:defer; 48, identifier:returnValue; 49, identifier:result; 50, identifier:url; 51, string; 52, identifier:url; 53, string; 54, attribute; 55, argument_list; 56, string_content:&ordering=shortname_sort; 57, attribute; 58, argument_list; 59, identifier:releases; 60, string_content:?product__shortname=; 61, string_content:&ga_date__gte=; 62, call; 63, identifier:strftime; 64, string; 65, identifier:self; 66, identifier:_get; 67, identifier:url; 68, attribute; 69, argument_list; 70, string_content:%Y-%m-%d; 71, identifier:date; 72, identifier:today | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 12, 20; 13, 21; 14, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 18, 28; 19, 29; 19, 30; 20, 31; 20, 32; 21, 33; 21, 34; 22, 35; 22, 36; 24, 37; 26, 38; 26, 39; 28, 40; 28, 41; 30, 42; 30, 43; 32, 44; 34, 45; 34, 46; 35, 47; 35, 48; 36, 49; 38, 50; 38, 51; 40, 52; 40, 53; 41, 54; 41, 55; 43, 56; 44, 57; 44, 58; 46, 59; 51, 60; 53, 61; 54, 62; 54, 63; 55, 64; 57, 65; 57, 66; 58, 67; 62, 68; 62, 69; 64, 70; 68, 71; 68, 72 | def upcoming_releases(self, product):
"""
Get upcoming releases for this product.
Specifically we search for releases with a GA date greater-than or
equal to today's date.
:param product: str, eg. "ceph"
:returns: deferred that when fired returns a list of Munch (dict-like)
objects representing all releases, sorted by shortname.
"""
url = 'api/v6/releases/'
url = url + '?product__shortname=' + product
url = url + '&ga_date__gte=' + date.today().strftime('%Y-%m-%d')
url = url + '&ordering=shortname_sort'
releases = yield self._get(url)
result = munchify(releases)
defer.returnValue(result) |
0, module; 1, function_definition; 2, function_name:es_field_sort; 3, parameters; 4, block; 5, identifier:fld_name; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, return_statement; 10, comment:""" Used with lambda to sort fields """; 11, assignment; 12, comparison_operator:"_" not in parts[-1]; 13, block; 14, call; 15, identifier:parts; 16, call; 17, string:"_"; 18, subscript; 19, expression_statement; 20, attribute; 21, argument_list; 22, attribute; 23, argument_list; 24, identifier:parts; 25, unary_operator; 26, assignment; 27, string:"."; 28, identifier:join; 29, identifier:parts; 30, identifier:fld_name; 31, identifier:split; 32, string:"."; 33, integer:1; 34, subscript; 35, binary_operator:"_" + parts[-1]; 36, identifier:parts; 37, unary_operator; 38, string:"_"; 39, subscript; 40, integer:1; 41, identifier:parts; 42, unary_operator; 43, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 9, 14; 11, 15; 11, 16; 12, 17; 12, 18; 13, 19; 14, 20; 14, 21; 16, 22; 16, 23; 18, 24; 18, 25; 19, 26; 20, 27; 20, 28; 21, 29; 22, 30; 22, 31; 23, 32; 25, 33; 26, 34; 26, 35; 34, 36; 34, 37; 35, 38; 35, 39; 37, 40; 39, 41; 39, 42; 42, 43 | def es_field_sort(fld_name):
""" Used with lambda to sort fields """
parts = fld_name.split(".")
if "_" not in parts[-1]:
parts[-1] = "_" + parts[-1]
return ".".join(parts) |
0, module; 1, function_definition; 2, function_name:_get_vars; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, if_statement; 8, if_statement; 9, expression_statement; 10, comment:# translate a list of vars into a dict; 11, if_statement; 12, if_statement; 13, if_statement; 14, expression_statement; 15, expression_statement; 16, return_statement; 17, string; 18, comparison_operator:self.vars is None; 19, block; 20, comparison_operator:type(self.vars) not in [dict, list]; 21, block; 22, assignment; 23, comparison_operator:type(self.vars) == list; 24, block; 25, else_clause; 26, comparison_operator:type(self.playbook.extra_vars) == dict; 27, block; 28, comparison_operator:type(self.vars_prompt) == list; 29, block; 30, elif_clause; 31, else_clause; 32, assignment; 33, call; 34, identifier:results; 35, string_content:load the vars section from a play, accounting for all sorts of variable features
including loading from yaml files, prompting, and conditional includes of the first
file found in a list.; 36, attribute; 37, None; 38, expression_statement; 39, call; 40, list; 41, raise_statement; 42, identifier:vars; 43, dictionary; 44, call; 45, identifier:list; 46, for_statement; 47, block; 48, call; 49, identifier:dict; 50, expression_statement; 51, call; 52, identifier:list; 53, for_statement; 54, comparison_operator:type(self.vars_prompt) == dict; 55, block; 56, block; 57, identifier:results; 58, call; 59, attribute; 60, argument_list; 61, identifier:self; 62, identifier:vars; 63, assignment; 64, identifier:type; 65, argument_list; 66, identifier:dict; 67, identifier:list; 68, call; 69, identifier:type; 70, argument_list; 71, identifier:item; 72, attribute; 73, block; 74, expression_statement; 75, identifier:type; 76, argument_list; 77, call; 78, identifier:type; 79, argument_list; 80, identifier:var; 81, attribute; 82, block; 83, call; 84, identifier:dict; 85, for_statement; 86, raise_statement; 87, attribute; 88, argument_list; 89, identifier:results; 90, identifier:update; 91, identifier:vars; 92, attribute; 93, dictionary; 94, attribute; 95, attribute; 96, argument_list; 97, attribute; 98, identifier:self; 99, identifier:vars; 100, if_statement; 101, expression_statement; 102, expression_statement; 103, call; 104, attribute; 105, attribute; 106, argument_list; 107, attribute; 108, identifier:self; 109, identifier:vars_prompt; 110, if_statement; 111, expression_statement; 112, expression_statement; 113, expression_statement; 114, expression_statement; 115, expression_statement; 116, expression_statement; 117, expression_statement; 118, expression_statement; 119, if_statement; 120, identifier:type; 121, argument_list; 122, tuple_pattern; 123, call; 124, block; 125, call; 126, attribute; 127, identifier:copy; 128, identifier:self; 129, identifier:vars; 130, identifier:self; 131, identifier:vars; 132, identifier:errors; 133, identifier:AnsibleError; 134, string:"'vars' section must contain only key/value pairs"; 135, identifier:self; 136, identifier:vars; 137, comparison_operator:getattr(item, 'items', None) is None; 138, block; 139, assignment; 140, assignment; 141, attribute; 142, argument_list; 143, attribute; 144, identifier:extra_vars; 145, identifier:vars; 146, identifier:update; 147, attribute; 148, identifier:self; 149, identifier:vars_prompt; 150, not_operator; 151, block; 152, assignment; 153, assignment; 154, assignment; 155, assignment; 156, assignment; 157, assignment; 158, assignment; 159, assignment; 160, comparison_operator:vname not in self.playbook.extra_vars; 161, block; 162, attribute; 163, identifier:vname; 164, identifier:prompt; 165, attribute; 166, argument_list; 167, expression_statement; 168, if_statement; 169, attribute; 170, argument_list; 171, attribute; 172, identifier:extra_vars; 173, call; 174, None; 175, raise_statement; 176, pattern_list; 177, subscript; 178, subscript; 179, identifier:v; 180, identifier:vars; 181, identifier:update; 182, attribute; 183, identifier:self; 184, identifier:playbook; 185, attribute; 186, identifier:extra_vars; 187, comparison_operator:'name' in var; 188, raise_statement; 189, identifier:vname; 190, subscript; 191, identifier:prompt; 192, call; 193, identifier:default; 194, call; 195, identifier:private; 196, call; 197, identifier:confirm; 198, call; 199, identifier:encrypt; 200, call; 201, identifier:salt_size; 202, call; 203, identifier:salt; 204, call; 205, identifier:vname; 206, attribute; 207, expression_statement; 208, identifier:self; 209, identifier:vars_prompt; 210, attribute; 211, identifier:iteritems; 212, assignment; 213, comparison_operator:vname not in self.playbook.extra_vars; 214, block; 215, identifier:errors; 216, identifier:AnsibleError; 217, string:"'vars_prompt' section is malformed, see docs"; 218, identifier:self; 219, identifier:playbook; 220, identifier:getattr; 221, argument_list; 222, call; 223, identifier:k; 224, identifier:v; 225, call; 226, integer:0; 227, identifier:vars; 228, identifier:k; 229, identifier:self; 230, identifier:vars; 231, identifier:self; 232, identifier:playbook; 233, string; 234, identifier:var; 235, call; 236, identifier:var; 237, string; 238, attribute; 239, argument_list; 240, attribute; 241, argument_list; 242, attribute; 243, argument_list; 244, attribute; 245, argument_list; 246, attribute; 247, argument_list; 248, attribute; 249, argument_list; 250, attribute; 251, argument_list; 252, attribute; 253, identifier:extra_vars; 254, assignment; 255, identifier:self; 256, identifier:vars_prompt; 257, identifier:prompt_msg; 258, binary_operator:"%s: " % prompt; 259, identifier:vname; 260, attribute; 261, expression_statement; 262, identifier:item; 263, string; 264, None; 265, attribute; 266, argument_list; 267, attribute; 268, argument_list; 269, string_content:name; 270, attribute; 271, argument_list; 272, string_content:name; 273, identifier:var; 274, identifier:get; 275, string:"prompt"; 276, identifier:vname; 277, identifier:var; 278, identifier:get; 279, string:"default"; 280, None; 281, identifier:var; 282, identifier:get; 283, string:"private"; 284, True; 285, identifier:var; 286, identifier:get; 287, string:"confirm"; 288, False; 289, identifier:var; 290, identifier:get; 291, string:"encrypt"; 292, None; 293, identifier:var; 294, identifier:get; 295, string:"salt_size"; 296, None; 297, identifier:var; 298, identifier:get; 299, string:"salt"; 300, None; 301, identifier:self; 302, identifier:playbook; 303, subscript; 304, call; 305, string:"%s: "; 306, identifier:prompt; 307, attribute; 308, identifier:extra_vars; 309, assignment; 310, string_content:items; 311, identifier:errors; 312, identifier:AnsibleError; 313, string:"expecting a key-value pair in 'vars' section"; 314, identifier:item; 315, identifier:items; 316, identifier:errors; 317, identifier:AnsibleError; 318, string:"'vars_prompt' item is missing 'name:'"; 319, identifier:vars; 320, identifier:vname; 321, attribute; 322, argument_list; 323, identifier:self; 324, identifier:playbook; 325, subscript; 326, call; 327, attribute; 328, identifier:on_vars_prompt; 329, identifier:vname; 330, identifier:private; 331, identifier:prompt; 332, identifier:encrypt; 333, identifier:confirm; 334, identifier:salt_size; 335, identifier:salt; 336, identifier:default; 337, identifier:vars; 338, identifier:vname; 339, attribute; 340, argument_list; 341, attribute; 342, identifier:callbacks; 343, attribute; 344, identifier:on_vars_prompt; 345, keyword_argument; 346, keyword_argument; 347, keyword_argument; 348, keyword_argument; 349, identifier:self; 350, identifier:playbook; 351, attribute; 352, identifier:callbacks; 353, identifier:varname; 354, identifier:vname; 355, identifier:private; 356, False; 357, identifier:prompt; 358, identifier:prompt_msg; 359, identifier:default; 360, None; 361, identifier:self; 362, identifier:playbook | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 6, 17; 7, 18; 7, 19; 8, 20; 8, 21; 9, 22; 11, 23; 11, 24; 11, 25; 12, 26; 12, 27; 13, 28; 13, 29; 13, 30; 13, 31; 14, 32; 15, 33; 16, 34; 17, 35; 18, 36; 18, 37; 19, 38; 20, 39; 20, 40; 21, 41; 22, 42; 22, 43; 23, 44; 23, 45; 24, 46; 25, 47; 26, 48; 26, 49; 27, 50; 28, 51; 28, 52; 29, 53; 30, 54; 30, 55; 31, 56; 32, 57; 32, 58; 33, 59; 33, 60; 36, 61; 36, 62; 38, 63; 39, 64; 39, 65; 40, 66; 40, 67; 41, 68; 44, 69; 44, 70; 46, 71; 46, 72; 46, 73; 47, 74; 48, 75; 48, 76; 50, 77; 51, 78; 51, 79; 53, 80; 53, 81; 53, 82; 54, 83; 54, 84; 55, 85; 56, 86; 58, 87; 58, 88; 59, 89; 59, 90; 60, 91; 63, 92; 63, 93; 65, 94; 68, 95; 68, 96; 70, 97; 72, 98; 72, 99; 73, 100; 73, 101; 73, 102; 74, 103; 76, 104; 77, 105; 77, 106; 79, 107; 81, 108; 81, 109; 82, 110; 82, 111; 82, 112; 82, 113; 82, 114; 82, 115; 82, 116; 82, 117; 82, 118; 82, 119; 83, 120; 83, 121; 85, 122; 85, 123; 85, 124; 86, 125; 87, 126; 87, 127; 92, 128; 92, 129; 94, 130; 94, 131; 95, 132; 95, 133; 96, 134; 97, 135; 97, 136; 100, 137; 100, 138; 101, 139; 102, 140; 103, 141; 103, 142; 104, 143; 104, 144; 105, 145; 105, 146; 106, 147; 107, 148; 107, 149; 110, 150; 110, 151; 111, 152; 112, 153; 113, 154; 114, 155; 115, 156; 116, 157; 117, 158; 118, 159; 119, 160; 119, 161; 121, 162; 122, 163; 122, 164; 123, 165; 123, 166; 124, 167; 124, 168; 125, 169; 125, 170; 126, 171; 126, 172; 137, 173; 137, 174; 138, 175; 139, 176; 139, 177; 140, 178; 140, 179; 141, 180; 141, 181; 142, 182; 143, 183; 143, 184; 147, 185; 147, 186; 150, 187; 151, 188; 152, 189; 152, 190; 153, 191; 153, 192; 154, 193; 154, 194; 155, 195; 155, 196; 156, 197; 156, 198; 157, 199; 157, 200; 158, 201; 158, 202; 159, 203; 159, 204; 160, 205; 160, 206; 161, 207; 162, 208; 162, 209; 165, 210; 165, 211; 167, 212; 168, 213; 168, 214; 169, 215; 169, 216; 170, 217; 171, 218; 171, 219; 173, 220; 173, 221; 175, 222; 176, 223; 176, 224; 177, 225; 177, 226; 178, 227; 178, 228; 182, 229; 182, 230; 185, 231; 185, 232; 187, 233; 187, 234; 188, 235; 190, 236; 190, 237; 192, 238; 192, 239; 194, 240; 194, 241; 196, 242; 196, 243; 198, 244; 198, 245; 200, 246; 200, 247; 202, 248; 202, 249; 204, 250; 204, 251; 206, 252; 206, 253; 207, 254; 210, 255; 210, 256; 212, 257; 212, 258; 213, 259; 213, 260; 214, 261; 221, 262; 221, 263; 221, 264; 222, 265; 222, 266; 225, 267; 225, 268; 233, 269; 235, 270; 235, 271; 237, 272; 238, 273; 238, 274; 239, 275; 239, 276; 240, 277; 240, 278; 241, 279; 241, 280; 242, 281; 242, 282; 243, 283; 243, 284; 244, 285; 244, 286; 245, 287; 245, 288; 246, 289; 246, 290; 247, 291; 247, 292; 248, 293; 248, 294; 249, 295; 249, 296; 250, 297; 250, 298; 251, 299; 251, 300; 252, 301; 252, 302; 254, 303; 254, 304; 258, 305; 258, 306; 260, 307; 260, 308; 261, 309; 263, 310; 265, 311; 265, 312; 266, 313; 267, 314; 267, 315; 270, 316; 270, 317; 271, 318; 303, 319; 303, 320; 304, 321; 304, 322; 307, 323; 307, 324; 309, 325; 309, 326; 321, 327; 321, 328; 322, 329; 322, 330; 322, 331; 322, 332; 322, 333; 322, 334; 322, 335; 322, 336; 325, 337; 325, 338; 326, 339; 326, 340; 327, 341; 327, 342; 339, 343; 339, 344; 340, 345; 340, 346; 340, 347; 340, 348; 341, 349; 341, 350; 343, 351; 343, 352; 345, 353; 345, 354; 346, 355; 346, 356; 347, 357; 347, 358; 348, 359; 348, 360; 351, 361; 351, 362 | def _get_vars(self):
''' load the vars section from a play, accounting for all sorts of variable features
including loading from yaml files, prompting, and conditional includes of the first
file found in a list. '''
if self.vars is None:
self.vars = {}
if type(self.vars) not in [dict, list]:
raise errors.AnsibleError("'vars' section must contain only key/value pairs")
vars = {}
# translate a list of vars into a dict
if type(self.vars) == list:
for item in self.vars:
if getattr(item, 'items', None) is None:
raise errors.AnsibleError("expecting a key-value pair in 'vars' section")
k, v = item.items()[0]
vars[k] = v
else:
vars.update(self.vars)
if type(self.playbook.extra_vars) == dict:
vars.update(self.playbook.extra_vars)
if type(self.vars_prompt) == list:
for var in self.vars_prompt:
if not 'name' in var:
raise errors.AnsibleError("'vars_prompt' item is missing 'name:'")
vname = var['name']
prompt = var.get("prompt", vname)
default = var.get("default", None)
private = var.get("private", True)
confirm = var.get("confirm", False)
encrypt = var.get("encrypt", None)
salt_size = var.get("salt_size", None)
salt = var.get("salt", None)
if vname not in self.playbook.extra_vars:
vars[vname] = self.playbook.callbacks.on_vars_prompt (
vname, private, prompt, encrypt, confirm, salt_size, salt, default
)
elif type(self.vars_prompt) == dict:
for (vname, prompt) in self.vars_prompt.iteritems():
prompt_msg = "%s: " % prompt
if vname not in self.playbook.extra_vars:
vars[vname] = self.playbook.callbacks.on_vars_prompt(
varname=vname, private=False, prompt=prompt_msg, default=None
)
else:
raise errors.AnsibleError("'vars_prompt' section is malformed, see docs")
results = self.playbook.extra_vars.copy()
results.update(vars)
return results |
0, module; 1, function_definition; 2, function_name:list_refs; 3, parameters; 4, block; 5, identifier:profile; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, expression_statement; 11, expression_statement; 12, return_statement; 13, identifier:ref_type; 14, None; 15, comment:"""List all refs.
Args:
profile
A profile generated from ``simplygithub.authentication.profile``.
Such profiles tell this module (i) the ``repo`` to connect to,
and (ii) the ``token`` to connect with.
ref_type
The type of ref you want. For heads, it's ``heads``. For tags,
it's ``tags``. That sort of thing. If you don't specify a type,
all refs are returned.
Returns:
A list of dicts with data about each ref.
"""; 16, assignment; 17, identifier:ref_type; 18, block; 19, assignment; 20, assignment; 21, identifier:result; 22, identifier:resource; 23, string:"/refs"; 24, expression_statement; 25, identifier:data; 26, call; 27, identifier:result; 28, list_comprehension; 29, augmented_assignment; 30, attribute; 31, argument_list; 32, call; 33, for_in_clause; 34, identifier:resource; 35, binary_operator:"/" + ref_type; 36, identifier:api; 37, identifier:get_request; 38, identifier:profile; 39, identifier:resource; 40, identifier:prepare; 41, argument_list; 42, identifier:x; 43, identifier:data; 44, string:"/"; 45, identifier:ref_type; 46, identifier:x | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 6, 14; 7, 15; 8, 16; 9, 17; 9, 18; 10, 19; 11, 20; 12, 21; 16, 22; 16, 23; 18, 24; 19, 25; 19, 26; 20, 27; 20, 28; 24, 29; 26, 30; 26, 31; 28, 32; 28, 33; 29, 34; 29, 35; 30, 36; 30, 37; 31, 38; 31, 39; 32, 40; 32, 41; 33, 42; 33, 43; 35, 44; 35, 45; 41, 46 | def list_refs(profile, ref_type=None):
"""List all refs.
Args:
profile
A profile generated from ``simplygithub.authentication.profile``.
Such profiles tell this module (i) the ``repo`` to connect to,
and (ii) the ``token`` to connect with.
ref_type
The type of ref you want. For heads, it's ``heads``. For tags,
it's ``tags``. That sort of thing. If you don't specify a type,
all refs are returned.
Returns:
A list of dicts with data about each ref.
"""
resource = "/refs"
if ref_type:
resource += "/" + ref_type
data = api.get_request(profile, resource)
result = [prepare(x) for x in data]
return result |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, identifier:fieldname; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, try_statement; 12, expression_statement; 13, expression_statement; 14, for_statement; 15, comment:# Note that sorting in-place still returns a reference; 16, comment:# to the table being sorted, for convenience.; 17, return_statement; 18, identifier:key; 19, lambda; 20, identifier:desc; 21, False; 22, identifier:inplace; 23, False; 24, comment:"""
This matches Python's built-in sorting signature closely.
By default, a new DataTable will be returned and the original will
not be mutated. If preferred, specify `inplace=True` in order to
mutate the original table. Either way, a reference to the relevant
table will be returned.
"""; 25, block; 26, except_clause; 27, assignment; 28, assignment; 29, pattern_list; 30, call; 31, block; 32, identifier:target_table; 33, lambda_parameters; 34, identifier:x; 35, expression_statement; 36, identifier:ValueError; 37, block; 38, identifier:data_cols; 39, call; 40, identifier:target_table; 41, conditional_expression:self if inplace else DataTable(); 42, identifier:field; 43, identifier:data_col; 44, identifier:izip; 45, argument_list; 46, expression_statement; 47, identifier:x; 48, assignment; 49, raise_statement; 50, identifier:izip; 51, argument_list; 52, identifier:self; 53, identifier:inplace; 54, call; 55, attribute; 56, identifier:data_cols; 57, assignment; 58, identifier:field_index; 59, call; 60, call; 61, list_splat; 62, identifier:DataTable; 63, argument_list; 64, identifier:self; 65, identifier:fields; 66, subscript; 67, call; 68, attribute; 69, argument_list; 70, identifier:ValueError; 71, argument_list; 72, call; 73, identifier:target_table; 74, identifier:field; 75, identifier:list; 76, argument_list; 77, call; 78, identifier:index; 79, identifier:fieldname; 80, binary_operator:"Sorting on a field that doesn't exist: `%s`" %
fieldname; 81, identifier:sorted; 82, argument_list; 83, identifier:data_col; 84, identifier:tuple; 85, argument_list; 86, string:"Sorting on a field that doesn't exist: `%s`"; 87, identifier:fieldname; 88, call; 89, keyword_argument; 90, keyword_argument; 91, attribute; 92, identifier:izip; 93, argument_list; 94, identifier:key; 95, lambda; 96, identifier:reverse; 97, identifier:desc; 98, identifier:self; 99, identifier:fields; 100, list_splat; 101, lambda_parameters; 102, call; 103, list_comprehension; 104, identifier:row; 105, identifier:key; 106, argument_list; 107, subscript; 108, for_in_clause; 109, subscript; 110, attribute; 111, identifier:field; 112, identifier:field; 113, attribute; 114, identifier:row; 115, identifier:field_index; 116, identifier:self; 117, identifier:__data; 118, identifier:self; 119, identifier:fields | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 7, 18; 7, 19; 8, 20; 8, 21; 9, 22; 9, 23; 10, 24; 11, 25; 11, 26; 12, 27; 13, 28; 14, 29; 14, 30; 14, 31; 17, 32; 19, 33; 19, 34; 25, 35; 26, 36; 26, 37; 27, 38; 27, 39; 28, 40; 28, 41; 29, 42; 29, 43; 30, 44; 30, 45; 31, 46; 33, 47; 35, 48; 37, 49; 39, 50; 39, 51; 41, 52; 41, 53; 41, 54; 45, 55; 45, 56; 46, 57; 48, 58; 48, 59; 49, 60; 51, 61; 54, 62; 54, 63; 55, 64; 55, 65; 57, 66; 57, 67; 59, 68; 59, 69; 60, 70; 60, 71; 61, 72; 66, 73; 66, 74; 67, 75; 67, 76; 68, 77; 68, 78; 69, 79; 71, 80; 72, 81; 72, 82; 76, 83; 77, 84; 77, 85; 80, 86; 80, 87; 82, 88; 82, 89; 82, 90; 85, 91; 88, 92; 88, 93; 89, 94; 89, 95; 90, 96; 90, 97; 91, 98; 91, 99; 93, 100; 95, 101; 95, 102; 100, 103; 101, 104; 102, 105; 102, 106; 103, 107; 103, 108; 106, 109; 107, 110; 107, 111; 108, 112; 108, 113; 109, 114; 109, 115; 110, 116; 110, 117; 113, 118; 113, 119 | def sort(self, fieldname, key=lambda x: x, desc=False, inplace=False):
"""
This matches Python's built-in sorting signature closely.
By default, a new DataTable will be returned and the original will
not be mutated. If preferred, specify `inplace=True` in order to
mutate the original table. Either way, a reference to the relevant
table will be returned.
"""
try:
field_index = tuple(self.fields).index(fieldname)
except ValueError:
raise ValueError("Sorting on a field that doesn't exist: `%s`" %
fieldname)
data_cols = izip(*sorted(izip(*[self.__data[field]
for field in self.fields]),
key=lambda row: key(row[field_index]),
reverse=desc))
target_table = self if inplace else DataTable()
for field, data_col in izip(self.fields, data_cols):
target_table[field] = list(data_col)
# Note that sorting in-place still returns a reference
# to the table being sorted, for convenience.
return target_table |
0, module; 1, function_definition; 2, function_name:intersectingIntervalIterator; 3, parameters; 4, block; 5, identifier:self; 6, identifier:start; 7, identifier:end; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, comment:"""
Get an iterator which will iterate over those objects in the tree which
intersect the given interval - sorted in order of start index
:param start: find intervals in the tree that intersect an interval with
with this start index (inclusive)
:param end: find intervals in the tree that intersect an interval with
with this end index (exclusive)
:return: an iterator that will yield intersected intervals
"""; 13, assignment; 14, call; 15, identifier:item; 16, identifier:items; 17, block; 18, identifier:items; 19, call; 20, attribute; 21, argument_list; 22, expression_statement; 23, attribute; 24, argument_list; 25, identifier:items; 26, identifier:sort; 27, keyword_argument; 28, yield; 29, identifier:self; 30, identifier:intersectingInterval; 31, identifier:start; 32, identifier:end; 33, identifier:key; 34, lambda; 35, identifier:item; 36, lambda_parameters; 37, attribute; 38, identifier:x; 39, identifier:x; 40, identifier:start | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 8, 12; 9, 13; 10, 14; 11, 15; 11, 16; 11, 17; 13, 18; 13, 19; 14, 20; 14, 21; 17, 22; 19, 23; 19, 24; 20, 25; 20, 26; 21, 27; 22, 28; 23, 29; 23, 30; 24, 31; 24, 32; 27, 33; 27, 34; 28, 35; 34, 36; 34, 37; 36, 38; 37, 39; 37, 40 | def intersectingIntervalIterator(self, start, end):
"""
Get an iterator which will iterate over those objects in the tree which
intersect the given interval - sorted in order of start index
:param start: find intervals in the tree that intersect an interval with
with this start index (inclusive)
:param end: find intervals in the tree that intersect an interval with
with this end index (exclusive)
:return: an iterator that will yield intersected intervals
"""
items = self.intersectingInterval(start, end)
items.sort(key=lambda x: x.start)
for item in items:
yield item |
0, module; 1, function_definition; 2, function_name:_sanitize_usecols; 3, parameters; 4, block; 5, identifier:usecols; 6, expression_statement; 7, if_statement; 8, try_statement; 9, expression_statement; 10, for_statement; 11, comment:# Remove duplicates:; 12, expression_statement; 13, expression_statement; 14, return_statement; 15, comment:"""Make a tuple of sorted integers and return it. Return None if
usecols is None"""; 16, comparison_operator:usecols is None; 17, block; 18, block; 19, except_clause; 20, assignment; 21, identifier:pat; 22, identifier:pats; 23, block; 24, assignment; 25, call; 26, call; 27, identifier:usecols; 28, None; 29, return_statement; 30, expression_statement; 31, expression_statement; 32, identifier:AttributeError; 33, block; 34, identifier:cols; 35, list; 36, if_statement; 37, identifier:cols; 38, call; 39, attribute; 40, argument_list; 41, identifier:tuple; 42, argument_list; 43, None; 44, assignment; 45, assignment; 46, expression_statement; 47, comment:# Make error if mix.; 48, expression_statement; 49, return_statement; 50, comment:# Assume sane sequence of integers.; 51, comparison_operator:':' in pat; 52, block; 53, else_clause; 54, identifier:list; 55, argument_list; 56, identifier:cols; 57, identifier:sort; 58, identifier:cols; 59, identifier:pats; 60, call; 61, identifier:pats; 62, list_comprehension; 63, assignment; 64, call; 65, call; 66, string; 67, identifier:pat; 68, expression_statement; 69, expression_statement; 70, expression_statement; 71, expression_statement; 72, block; 73, call; 74, attribute; 75, argument_list; 76, call; 77, for_in_clause; 78, if_clause; 79, identifier:usecols; 80, list_comprehension; 81, attribute; 82, argument_list; 83, identifier:tuple; 84, argument_list; 85, string_content::; 86, assignment; 87, assignment; 88, assignment; 89, augmented_assignment; 90, expression_statement; 91, identifier:set; 92, argument_list; 93, identifier:usecols; 94, identifier:split; 95, string; 96, attribute; 97, argument_list; 98, identifier:p; 99, identifier:pats; 100, identifier:p; 101, call; 102, for_in_clause; 103, identifier:usecols; 104, identifier:sort; 105, identifier:usecols; 106, pattern_list; 107, call; 108, identifier:n1; 109, call; 110, identifier:n2; 111, call; 112, identifier:cols; 113, call; 114, augmented_assignment; 115, identifier:cols; 116, string_content:,; 117, identifier:p; 118, identifier:strip; 119, identifier:int; 120, argument_list; 121, identifier:c; 122, identifier:usecols; 123, identifier:c1; 124, identifier:c2; 125, attribute; 126, argument_list; 127, identifier:letter2num; 128, argument_list; 129, identifier:letter2num; 130, argument_list; 131, identifier:range; 132, argument_list; 133, identifier:cols; 134, list; 135, identifier:c; 136, identifier:pat; 137, identifier:split; 138, string; 139, identifier:c1; 140, keyword_argument; 141, identifier:c2; 142, keyword_argument; 143, identifier:n1; 144, identifier:n2; 145, call; 146, string_content::; 147, identifier:zbase; 148, True; 149, identifier:zbase; 150, False; 151, identifier:letter2num; 152, argument_list; 153, identifier:pat; 154, keyword_argument; 155, identifier:zbase; 156, True | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 7, 16; 7, 17; 8, 18; 8, 19; 9, 20; 10, 21; 10, 22; 10, 23; 12, 24; 13, 25; 14, 26; 16, 27; 16, 28; 17, 29; 18, 30; 18, 31; 19, 32; 19, 33; 20, 34; 20, 35; 23, 36; 24, 37; 24, 38; 25, 39; 25, 40; 26, 41; 26, 42; 29, 43; 30, 44; 31, 45; 33, 46; 33, 47; 33, 48; 33, 49; 33, 50; 36, 51; 36, 52; 36, 53; 38, 54; 38, 55; 39, 56; 39, 57; 42, 58; 44, 59; 44, 60; 45, 61; 45, 62; 46, 63; 48, 64; 49, 65; 51, 66; 51, 67; 52, 68; 52, 69; 52, 70; 52, 71; 53, 72; 55, 73; 60, 74; 60, 75; 62, 76; 62, 77; 62, 78; 63, 79; 63, 80; 64, 81; 64, 82; 65, 83; 65, 84; 66, 85; 68, 86; 69, 87; 70, 88; 71, 89; 72, 90; 73, 91; 73, 92; 74, 93; 74, 94; 75, 95; 76, 96; 76, 97; 77, 98; 77, 99; 78, 100; 80, 101; 80, 102; 81, 103; 81, 104; 84, 105; 86, 106; 86, 107; 87, 108; 87, 109; 88, 110; 88, 111; 89, 112; 89, 113; 90, 114; 92, 115; 95, 116; 96, 117; 96, 118; 101, 119; 101, 120; 102, 121; 102, 122; 106, 123; 106, 124; 107, 125; 107, 126; 109, 127; 109, 128; 111, 129; 111, 130; 113, 131; 113, 132; 114, 133; 114, 134; 120, 135; 125, 136; 125, 137; 126, 138; 128, 139; 128, 140; 130, 141; 130, 142; 132, 143; 132, 144; 134, 145; 138, 146; 140, 147; 140, 148; 142, 149; 142, 150; 145, 151; 145, 152; 152, 153; 152, 154; 154, 155; 154, 156 | def _sanitize_usecols(usecols):
"""Make a tuple of sorted integers and return it. Return None if
usecols is None"""
if usecols is None:
return None
try:
pats = usecols.split(',')
pats = [p.strip() for p in pats if p]
except AttributeError:
usecols = [int(c) for c in usecols] # Make error if mix.
usecols.sort()
return tuple(usecols) # Assume sane sequence of integers.
cols = []
for pat in pats:
if ':' in pat:
c1, c2 = pat.split(':')
n1 = letter2num(c1, zbase=True)
n2 = letter2num(c2, zbase=False)
cols += range(n1, n2)
else:
cols += [letter2num(pat, zbase=True)]
# Remove duplicates:
cols = list(set(cols))
cols.sort()
return tuple(cols) |
0, module; 1, function_definition; 2, function_name:binary_search; 3, parameters; 4, block; 5, identifier:data; 6, identifier:target; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, if_statement; 13, if_statement; 14, identifier:lo; 15, integer:0; 16, identifier:hi; 17, None; 18, comment:"""
Perform binary search on sorted list data for target. Returns int
representing position of target in data.
"""; 19, assignment; 20, assignment; 21, boolean_operator; 22, block; 23, comparison_operator:data[mid] > target; 24, block; 25, elif_clause; 26, elif_clause; 27, identifier:hi; 28, conditional_expression:hi if hi is not None else len(data); 29, identifier:mid; 30, binary_operator:(lo + hi) // 2; 31, boolean_operator; 32, comparison_operator:target < data[0]; 33, return_statement; 34, subscript; 35, identifier:target; 36, return_statement; 37, comparison_operator:data[mid] < target; 38, block; 39, comparison_operator:data[mid] == target; 40, block; 41, identifier:hi; 42, comparison_operator:hi is not None; 43, call; 44, parenthesized_expression; 45, integer:2; 46, boolean_operator; 47, comparison_operator:target > data[-1]; 48, identifier:target; 49, subscript; 50, unary_operator; 51, identifier:data; 52, identifier:mid; 53, call; 54, subscript; 55, identifier:target; 56, return_statement; 57, subscript; 58, identifier:target; 59, return_statement; 60, identifier:hi; 61, None; 62, identifier:len; 63, argument_list; 64, binary_operator:lo + hi; 65, comparison_operator:hi < 2; 66, comparison_operator:hi > len(data); 67, identifier:target; 68, subscript; 69, identifier:data; 70, integer:0; 71, integer:1; 72, identifier:binary_search; 73, argument_list; 74, identifier:data; 75, identifier:mid; 76, call; 77, identifier:data; 78, identifier:mid; 79, identifier:mid; 80, identifier:data; 81, identifier:lo; 82, identifier:hi; 83, identifier:hi; 84, integer:2; 85, identifier:hi; 86, call; 87, identifier:data; 88, unary_operator; 89, identifier:data; 90, identifier:target; 91, keyword_argument; 92, keyword_argument; 93, identifier:binary_search; 94, argument_list; 95, identifier:len; 96, argument_list; 97, integer:1; 98, identifier:lo; 99, identifier:lo; 100, identifier:hi; 101, identifier:mid; 102, identifier:data; 103, identifier:target; 104, keyword_argument; 105, keyword_argument; 106, identifier:data; 107, identifier:lo; 108, parenthesized_expression; 109, identifier:hi; 110, identifier:hi; 111, binary_operator:mid + 1; 112, identifier:mid; 113, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 7, 15; 8, 16; 8, 17; 9, 18; 10, 19; 11, 20; 12, 21; 12, 22; 13, 23; 13, 24; 13, 25; 13, 26; 19, 27; 19, 28; 20, 29; 20, 30; 21, 31; 21, 32; 22, 33; 23, 34; 23, 35; 24, 36; 25, 37; 25, 38; 26, 39; 26, 40; 28, 41; 28, 42; 28, 43; 30, 44; 30, 45; 31, 46; 31, 47; 32, 48; 32, 49; 33, 50; 34, 51; 34, 52; 36, 53; 37, 54; 37, 55; 38, 56; 39, 57; 39, 58; 40, 59; 42, 60; 42, 61; 43, 62; 43, 63; 44, 64; 46, 65; 46, 66; 47, 67; 47, 68; 49, 69; 49, 70; 50, 71; 53, 72; 53, 73; 54, 74; 54, 75; 56, 76; 57, 77; 57, 78; 59, 79; 63, 80; 64, 81; 64, 82; 65, 83; 65, 84; 66, 85; 66, 86; 68, 87; 68, 88; 73, 89; 73, 90; 73, 91; 73, 92; 76, 93; 76, 94; 86, 95; 86, 96; 88, 97; 91, 98; 91, 99; 92, 100; 92, 101; 94, 102; 94, 103; 94, 104; 94, 105; 96, 106; 104, 107; 104, 108; 105, 109; 105, 110; 108, 111; 111, 112; 111, 113 | def binary_search(data, target, lo=0, hi=None):
"""
Perform binary search on sorted list data for target. Returns int
representing position of target in data.
"""
hi = hi if hi is not None else len(data)
mid = (lo + hi) // 2
if hi < 2 or hi > len(data) or target > data[-1] or target < data[0]:
return -1
if data[mid] > target:
return binary_search(data, target, lo=lo, hi=mid)
elif data[mid] < target:
return binary_search(data, target, lo=(mid + 1), hi=hi)
elif data[mid] == target:
return mid |
0, module; 1, function_definition; 2, function_name:repr_feature; 3, parameters; 4, block; 5, identifier:feature; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, if_statement; 11, if_statement; 12, assert_statement; 13, identifier:max_keys; 14, integer:100; 15, identifier:indent; 16, integer:8; 17, identifier:lexigraphic; 18, False; 19, string; 20, call; 21, block; 22, call; 23, block; 24, elif_clause; 25, else_clause; 26, False; 27, string; 28, string_content:generate a pretty-printed string for a feature
Currently implemented:
* StringCounter
@max_keys: truncate long counters
@indent: indent multi-line displays by this many spaces
@lexigraphic: instead of sorting counters by count (default), sort
keys lexigraphically; 29, identifier:isinstance; 30, argument_list; 31, try_statement; 32, identifier:isinstance; 33, argument_list; 34, return_statement; 35, call; 36, block; 37, block; 38, string_content:internal logic failure, no branch taken; 39, identifier:feature; 40, tuple; 41, block; 42, except_clause; 43, identifier:feature; 44, identifier:StringCounter; 45, call; 46, identifier:isinstance; 47, argument_list; 48, return_statement; 49, return_statement; 50, identifier:str; 51, identifier:bytes; 52, expression_statement; 53, return_statement; 54, comment:# failure to decode, not actually utf8, other binary data; 55, block; 56, identifier:repr_stringcounter; 57, argument_list; 58, identifier:feature; 59, identifier:unicode; 60, identifier:feature; 61, call; 62, assignment; 63, identifier:ustr; 64, return_statement; 65, identifier:feature; 66, identifier:max_keys; 67, identifier:indent; 68, identifier:lexigraphic; 69, identifier:repr; 70, argument_list; 71, identifier:ustr; 72, call; 73, call; 74, identifier:feature; 75, attribute; 76, argument_list; 77, identifier:repr; 78, argument_list; 79, identifier:feature; 80, identifier:decode; 81, string; 82, identifier:feature; 83, string_content:utf8 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 6, 14; 7, 15; 7, 16; 8, 17; 8, 18; 9, 19; 10, 20; 10, 21; 11, 22; 11, 23; 11, 24; 11, 25; 12, 26; 12, 27; 19, 28; 20, 29; 20, 30; 21, 31; 22, 32; 22, 33; 23, 34; 24, 35; 24, 36; 25, 37; 27, 38; 30, 39; 30, 40; 31, 41; 31, 42; 33, 43; 33, 44; 34, 45; 35, 46; 35, 47; 36, 48; 37, 49; 40, 50; 40, 51; 41, 52; 41, 53; 42, 54; 42, 55; 45, 56; 45, 57; 47, 58; 47, 59; 48, 60; 49, 61; 52, 62; 53, 63; 55, 64; 57, 65; 57, 66; 57, 67; 57, 68; 61, 69; 61, 70; 62, 71; 62, 72; 64, 73; 70, 74; 72, 75; 72, 76; 73, 77; 73, 78; 75, 79; 75, 80; 76, 81; 78, 82; 81, 83 | def repr_feature(feature, max_keys=100, indent=8, lexigraphic=False):
'''
generate a pretty-printed string for a feature
Currently implemented:
* StringCounter
@max_keys: truncate long counters
@indent: indent multi-line displays by this many spaces
@lexigraphic: instead of sorting counters by count (default), sort
keys lexigraphically
'''
if isinstance(feature, (str, bytes)):
try:
ustr = feature.decode('utf8')
return ustr
except:
# failure to decode, not actually utf8, other binary data
return repr(feature)
if isinstance(feature, StringCounter):
return repr_stringcounter(feature, max_keys, indent, lexigraphic)
elif isinstance(feature, unicode):
return feature
else:
return repr(feature)
assert False, 'internal logic failure, no branch taken' |
0, module; 1, function_definition; 2, function_name:_getkey; 3, parameters; 4, block; 5, identifier:self; 6, identifier:args; 7, identifier:kwargs; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, return_statement; 14, comment:"""Get hash key from args and kwargs.
args and kwargs must be hashable.
:param tuple args: called vargs.
:param dict kwargs: called keywords.
:return: hash(tuple(args) + tuple((key, val) for key in sorted(kwargs)).
:rtype: int."""; 15, assignment; 16, assignment; 17, identifier:key; 18, identifier:keys; 19, block; 20, assignment; 21, identifier:result; 22, identifier:values; 23, call; 24, identifier:keys; 25, call; 26, expression_statement; 27, identifier:result; 28, call; 29, identifier:list; 30, argument_list; 31, identifier:sorted; 32, argument_list; 33, call; 34, identifier:hash; 35, argument_list; 36, identifier:args; 37, call; 38, attribute; 39, argument_list; 40, call; 41, identifier:list; 42, argument_list; 43, identifier:values; 44, identifier:append; 45, tuple; 46, identifier:tuple; 47, argument_list; 48, identifier:kwargs; 49, identifier:key; 50, subscript; 51, identifier:values; 52, identifier:kwargs; 53, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 8, 14; 9, 15; 10, 16; 11, 17; 11, 18; 11, 19; 12, 20; 13, 21; 15, 22; 15, 23; 16, 24; 16, 25; 19, 26; 20, 27; 20, 28; 23, 29; 23, 30; 25, 31; 25, 32; 26, 33; 28, 34; 28, 35; 30, 36; 32, 37; 33, 38; 33, 39; 35, 40; 37, 41; 37, 42; 38, 43; 38, 44; 39, 45; 40, 46; 40, 47; 42, 48; 45, 49; 45, 50; 47, 51; 50, 52; 50, 53 | def _getkey(self, args, kwargs):
"""Get hash key from args and kwargs.
args and kwargs must be hashable.
:param tuple args: called vargs.
:param dict kwargs: called keywords.
:return: hash(tuple(args) + tuple((key, val) for key in sorted(kwargs)).
:rtype: int."""
values = list(args)
keys = sorted(list(kwargs))
for key in keys:
values.append((key, kwargs[key]))
result = hash(tuple(values))
return result |
0, module; 1, function_definition; 2, function_name:iterator; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, return_statement; 10, comment:"""
If search has occurred and no ordering has occurred, decorate
each result with the number of search terms so that it can be
sorted by the number of occurrence of terms.
In the case of search fields that span model relationships, we
cannot accurately match occurrences without some very
complicated traversal code, which we won't attempt. So in this
case, namely when there are no matches for a result (count=0),
and search fields contain relationships (double underscores),
we assume one match for one of the fields, and use the average
weight of all search fields with relationships.
"""; 11, assignment; 12, boolean_operator; 13, block; 14, identifier:results; 15, identifier:results; 16, call; 17, attribute; 18, not_operator; 19, expression_statement; 20, for_statement; 21, return_statement; 22, attribute; 23, argument_list; 24, identifier:self; 25, identifier:_search_terms; 26, attribute; 27, assignment; 28, pattern_list; 29, call; 30, block; 31, call; 32, call; 33, identifier:iterator; 34, identifier:self; 35, identifier:_search_ordered; 36, identifier:results; 37, call; 38, identifier:i; 39, identifier:result; 40, identifier:enumerate; 41, argument_list; 42, expression_statement; 43, expression_statement; 44, for_statement; 45, if_statement; 46, expression_statement; 47, identifier:iter; 48, argument_list; 49, identifier:super; 50, argument_list; 51, identifier:list; 52, argument_list; 53, identifier:results; 54, assignment; 55, assignment; 56, tuple_pattern; 57, call; 58, block; 59, boolean_operator; 60, block; 61, assignment; 62, identifier:results; 63, identifier:SearchableQuerySet; 64, identifier:self; 65, identifier:results; 66, identifier:count; 67, integer:0; 68, identifier:related_weights; 69, list; 70, identifier:field; 71, identifier:weight; 72, attribute; 73, argument_list; 74, if_statement; 75, for_statement; 76, not_operator; 77, identifier:related_weights; 78, expression_statement; 79, attribute; 80, identifier:count; 81, attribute; 82, identifier:items; 83, comparison_operator:"__" in field; 84, block; 85, identifier:term; 86, attribute; 87, block; 88, identifier:count; 89, assignment; 90, subscript; 91, identifier:result_count; 92, identifier:self; 93, identifier:_search_fields; 94, string:"__"; 95, identifier:field; 96, expression_statement; 97, identifier:self; 98, identifier:_search_terms; 99, expression_statement; 100, if_statement; 101, identifier:count; 102, call; 103, identifier:results; 104, identifier:i; 105, call; 106, assignment; 107, identifier:field_value; 108, block; 109, identifier:int; 110, argument_list; 111, attribute; 112, argument_list; 113, identifier:field_value; 114, call; 115, expression_statement; 116, binary_operator:sum(related_weights) / len(related_weights); 117, identifier:related_weights; 118, identifier:append; 119, identifier:weight; 120, identifier:getattr; 121, argument_list; 122, augmented_assignment; 123, call; 124, call; 125, identifier:result; 126, identifier:field; 127, None; 128, identifier:count; 129, binary_operator:field_value.lower().count(term) * weight; 130, identifier:sum; 131, argument_list; 132, identifier:len; 133, argument_list; 134, call; 135, identifier:weight; 136, identifier:related_weights; 137, identifier:related_weights; 138, attribute; 139, argument_list; 140, call; 141, identifier:count; 142, identifier:term; 143, attribute; 144, argument_list; 145, identifier:field_value; 146, identifier:lower | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 9, 14; 11, 15; 11, 16; 12, 17; 12, 18; 13, 19; 13, 20; 13, 21; 16, 22; 16, 23; 17, 24; 17, 25; 18, 26; 19, 27; 20, 28; 20, 29; 20, 30; 21, 31; 22, 32; 22, 33; 26, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 30, 42; 30, 43; 30, 44; 30, 45; 30, 46; 31, 47; 31, 48; 32, 49; 32, 50; 37, 51; 37, 52; 41, 53; 42, 54; 43, 55; 44, 56; 44, 57; 44, 58; 45, 59; 45, 60; 46, 61; 48, 62; 50, 63; 50, 64; 52, 65; 54, 66; 54, 67; 55, 68; 55, 69; 56, 70; 56, 71; 57, 72; 57, 73; 58, 74; 58, 75; 59, 76; 59, 77; 60, 78; 61, 79; 61, 80; 72, 81; 72, 82; 74, 83; 74, 84; 75, 85; 75, 86; 75, 87; 76, 88; 78, 89; 79, 90; 79, 91; 81, 92; 81, 93; 83, 94; 83, 95; 84, 96; 86, 97; 86, 98; 87, 99; 87, 100; 89, 101; 89, 102; 90, 103; 90, 104; 96, 105; 99, 106; 100, 107; 100, 108; 102, 109; 102, 110; 105, 111; 105, 112; 106, 113; 106, 114; 108, 115; 110, 116; 111, 117; 111, 118; 112, 119; 114, 120; 114, 121; 115, 122; 116, 123; 116, 124; 121, 125; 121, 126; 121, 127; 122, 128; 122, 129; 123, 130; 123, 131; 124, 132; 124, 133; 129, 134; 129, 135; 131, 136; 133, 137; 134, 138; 134, 139; 138, 140; 138, 141; 139, 142; 140, 143; 140, 144; 143, 145; 143, 146 | def iterator(self):
"""
If search has occurred and no ordering has occurred, decorate
each result with the number of search terms so that it can be
sorted by the number of occurrence of terms.
In the case of search fields that span model relationships, we
cannot accurately match occurrences without some very
complicated traversal code, which we won't attempt. So in this
case, namely when there are no matches for a result (count=0),
and search fields contain relationships (double underscores),
we assume one match for one of the fields, and use the average
weight of all search fields with relationships.
"""
results = super(SearchableQuerySet, self).iterator()
if self._search_terms and not self._search_ordered:
results = list(results)
for i, result in enumerate(results):
count = 0
related_weights = []
for (field, weight) in self._search_fields.items():
if "__" in field:
related_weights.append(weight)
for term in self._search_terms:
field_value = getattr(result, field, None)
if field_value:
count += field_value.lower().count(term) * weight
if not count and related_weights:
count = int(sum(related_weights) / len(related_weights))
results[i].result_count = count
return iter(results)
return results |
0, module; 1, function_definition; 2, function_name:save_as_json; 3, parameters; 4, block; 5, typed_parameter; 6, default_parameter; 7, typed_default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, if_statement; 12, if_statement; 13, expression_statement; 14, expression_statement; 15, identifier:total; 16, type; 17, identifier:name; 18, string; 19, identifier:sort_by; 20, type; 21, None; 22, identifier:no_duplicate; 23, False; 24, identifier:order; 25, string; 26, comment:"""Save what you crawled as a json file.
Args:
total (list): Total of data you crawled.
name (str, optional): Defaults to 'data.json'. The name of the file.
sort_by (str, optional): Defaults to None. Sort items by a specific key.
no_duplicate (bool, optional): Defaults to False. If True, it will remove duplicated data.
order (str, optional): Defaults to 'asc'. The opposite option is 'desc'.
"""; 27, identifier:sort_by; 28, block; 29, identifier:no_duplicate; 30, block; 31, assignment; 32, call; 33, identifier:list; 34, string_content:data.json; 35, identifier:str; 36, string_content:asc; 37, expression_statement; 38, expression_statement; 39, expression_statement; 40, identifier:data; 41, call; 42, attribute; 43, argument_list; 44, assignment; 45, assignment; 46, assignment; 47, attribute; 48, argument_list; 49, call; 50, identifier:write_text; 51, identifier:data; 52, keyword_argument; 53, identifier:reverse; 54, comparison_operator:order == 'desc'; 55, identifier:total; 56, call; 57, identifier:total; 58, list_comprehension; 59, identifier:json; 60, identifier:dumps; 61, identifier:total; 62, keyword_argument; 63, identifier:Path; 64, argument_list; 65, identifier:encoding; 66, string; 67, identifier:order; 68, string; 69, identifier:sorted; 70, argument_list; 71, identifier:key; 72, for_in_clause; 73, identifier:ensure_ascii; 74, False; 75, identifier:name; 76, string_content:utf-8; 77, string_content:desc; 78, identifier:total; 79, keyword_argument; 80, keyword_argument; 81, pattern_list; 82, call; 83, identifier:key; 84, call; 85, identifier:reverse; 86, identifier:reverse; 87, identifier:key; 88, identifier:_; 89, identifier:groupby; 90, argument_list; 91, identifier:itemgetter; 92, argument_list; 93, identifier:total; 94, identifier:sort_by | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 5, 15; 5, 16; 6, 17; 6, 18; 7, 19; 7, 20; 7, 21; 8, 22; 8, 23; 9, 24; 9, 25; 10, 26; 11, 27; 11, 28; 12, 29; 12, 30; 13, 31; 14, 32; 16, 33; 18, 34; 20, 35; 25, 36; 28, 37; 28, 38; 30, 39; 31, 40; 31, 41; 32, 42; 32, 43; 37, 44; 38, 45; 39, 46; 41, 47; 41, 48; 42, 49; 42, 50; 43, 51; 43, 52; 44, 53; 44, 54; 45, 55; 45, 56; 46, 57; 46, 58; 47, 59; 47, 60; 48, 61; 48, 62; 49, 63; 49, 64; 52, 65; 52, 66; 54, 67; 54, 68; 56, 69; 56, 70; 58, 71; 58, 72; 62, 73; 62, 74; 64, 75; 66, 76; 68, 77; 70, 78; 70, 79; 70, 80; 72, 81; 72, 82; 79, 83; 79, 84; 80, 85; 80, 86; 81, 87; 81, 88; 82, 89; 82, 90; 84, 91; 84, 92; 90, 93; 92, 94 | def save_as_json(total: list,
name='data.json',
sort_by: str = None,
no_duplicate=False,
order='asc'):
"""Save what you crawled as a json file.
Args:
total (list): Total of data you crawled.
name (str, optional): Defaults to 'data.json'. The name of the file.
sort_by (str, optional): Defaults to None. Sort items by a specific key.
no_duplicate (bool, optional): Defaults to False. If True, it will remove duplicated data.
order (str, optional): Defaults to 'asc'. The opposite option is 'desc'.
"""
if sort_by:
reverse = order == 'desc'
total = sorted(total, key=itemgetter(sort_by), reverse=reverse)
if no_duplicate:
total = [key for key, _ in groupby(total)]
data = json.dumps(total, ensure_ascii=False)
Path(name).write_text(data, encoding='utf-8') |
Subsets and Splits