sequence
stringlengths 546
16.2k
| code
stringlengths 108
19.3k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_serve_runs; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:request; 6, block; 6, 7; 6, 9; 6, 104; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 13; 9, 41; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_db_connection_provider; 13, block; 13, 14; 13, 22; 13, 31; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:db; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_db_connection_provider; 21, argument_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cursor; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:db; 28, identifier:execute; 29, argument_list; 29, 30; 30, string:'''
SELECT
run_name,
started_time IS NULL as started_time_nulls_last,
started_time
FROM Runs
ORDER BY started_time_nulls_last, started_time, run_name
'''; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:run_names; 34, list_comprehension; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:row; 37, integer:0; 38, for_in_clause; 38, 39; 38, 40; 39, identifier:row; 40, identifier:cursor; 41, else_clause; 41, 42; 41, 43; 41, 44; 42, comment; 43, comment; 44, block; 44, 45; 44, 58; 44, 95; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:run_names; 48, call; 48, 49; 48, 50; 49, identifier:sorted; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_multiplexer; 56, identifier:Runs; 57, argument_list; 58, function_definition; 58, 59; 58, 60; 58, 62; 59, function_name:get_first_event_timestamp; 60, parameters; 60, 61; 61, identifier:run_name; 62, block; 62, 63; 63, try_statement; 63, 64; 63, 74; 64, block; 64, 65; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_multiplexer; 71, identifier:FirstEventTimestamp; 72, argument_list; 72, 73; 73, identifier:run_name; 74, except_clause; 74, 75; 74, 79; 75, as_pattern; 75, 76; 75, 77; 76, identifier:ValueError; 77, as_pattern_target; 77, 78; 78, identifier:e; 79, block; 79, 80; 79, 89; 79, 90; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:logger; 84, identifier:warn; 85, argument_list; 85, 86; 85, 87; 85, 88; 86, string:'Unable to get first event timestamp for run %s: %s'; 87, identifier:run_name; 88, identifier:e; 89, comment; 90, return_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:float; 93, argument_list; 93, 94; 94, string:'inf'; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:run_names; 99, identifier:sort; 100, argument_list; 100, 101; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:key; 103, identifier:get_first_event_timestamp; 104, return_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:http_util; 108, identifier:Respond; 109, argument_list; 109, 110; 109, 111; 109, 112; 110, identifier:request; 111, identifier:run_names; 112, string:'application/json' | def _serve_runs(self, request):
"""Serve a JSON array of run names, ordered by run started time.
Sort order is by started time (aka first event time) with empty times sorted
last, and then ties are broken by sorting on the run name.
"""
if self._db_connection_provider:
db = self._db_connection_provider()
cursor = db.execute('''
SELECT
run_name,
started_time IS NULL as started_time_nulls_last,
started_time
FROM Runs
ORDER BY started_time_nulls_last, started_time, run_name
''')
run_names = [row[0] for row in cursor]
else:
# Python's list.sort is stable, so to order by started time and
# then by name, we can just do the sorts in the reverse order.
run_names = sorted(self._multiplexer.Runs())
def get_first_event_timestamp(run_name):
try:
return self._multiplexer.FirstEventTimestamp(run_name)
except ValueError as e:
logger.warn(
'Unable to get first event timestamp for run %s: %s', run_name, e)
# Put runs without a timestamp at the end.
return float('inf')
run_names.sort(key=get_first_event_timestamp)
return http_util.Respond(request, run_names, 'application/json') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_fetch_events_files_on_disk; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 23; 5, 38; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:all_files; 11, call; 11, 12; 11, 19; 12, attribute; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:tf; 16, identifier:io; 17, identifier:gfile; 18, identifier:listdir; 19, argument_list; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_events_directory; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:relevant_files; 26, list_comprehension; 26, 27; 26, 28; 26, 31; 27, identifier:file_name; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:file_name; 30, identifier:all_files; 31, if_clause; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:_DEBUGGER_EVENTS_FILE_NAME_REGEX; 35, identifier:match; 36, argument_list; 36, 37; 37, identifier:file_name; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:sorted; 41, argument_list; 41, 42; 41, 43; 42, identifier:relevant_files; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:key; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_obtain_file_index | def _fetch_events_files_on_disk(self):
"""Obtains the names of debugger-related events files within the directory.
Returns:
The names of the debugger-related events files written to disk. The names
are sorted in increasing events file index.
"""
all_files = tf.io.gfile.listdir(self._events_directory)
relevant_files = [
file_name for file_name in all_files
if _DEBUGGER_EVENTS_FILE_NAME_REGEX.match(file_name)
]
return sorted(relevant_files, key=self._obtain_file_index) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:Cleanse; 3, parameters; 3, 4; 3, 5; 4, identifier:obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:encoding; 7, string:'utf-8'; 8, block; 8, 9; 8, 11; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 17; 11, 20; 11, 55; 11, 72; 11, 91; 11, 111; 11, 140; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 16; 15, identifier:obj; 16, identifier:int; 17, block; 17, 18; 18, return_statement; 18, 19; 19, identifier:obj; 20, elif_clause; 20, 21; 20, 26; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:obj; 25, identifier:float; 26, block; 26, 27; 27, if_statement; 27, 28; 27, 31; 27, 34; 27, 41; 27, 51; 28, comparison_operator:==; 28, 29; 28, 30; 29, identifier:obj; 30, identifier:_INFINITY; 31, block; 31, 32; 32, return_statement; 32, 33; 33, string:'Infinity'; 34, elif_clause; 34, 35; 34, 38; 35, comparison_operator:==; 35, 36; 35, 37; 36, identifier:obj; 37, identifier:_NEGATIVE_INFINITY; 38, block; 38, 39; 39, return_statement; 39, 40; 40, string:'-Infinity'; 41, elif_clause; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:math; 45, identifier:isnan; 46, argument_list; 46, 47; 47, identifier:obj; 48, block; 48, 49; 49, return_statement; 49, 50; 50, string:'NaN'; 51, else_clause; 51, 52; 52, block; 52, 53; 53, return_statement; 53, 54; 54, identifier:obj; 55, elif_clause; 55, 56; 55, 61; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:obj; 60, identifier:bytes; 61, block; 61, 62; 62, return_statement; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:tf; 67, identifier:compat; 68, identifier:as_text; 69, argument_list; 69, 70; 69, 71; 70, identifier:obj; 71, identifier:encoding; 72, elif_clause; 72, 73; 72, 80; 73, call; 73, 74; 73, 75; 74, identifier:isinstance; 75, argument_list; 75, 76; 75, 77; 76, identifier:obj; 77, tuple; 77, 78; 77, 79; 78, identifier:list; 79, identifier:tuple; 80, block; 80, 81; 81, return_statement; 81, 82; 82, list_comprehension; 82, 83; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:Cleanse; 85, argument_list; 85, 86; 85, 87; 86, identifier:i; 87, identifier:encoding; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:i; 90, identifier:obj; 91, elif_clause; 91, 92; 91, 97; 92, call; 92, 93; 92, 94; 93, identifier:isinstance; 94, argument_list; 94, 95; 94, 96; 95, identifier:obj; 96, identifier:set; 97, block; 97, 98; 98, return_statement; 98, 99; 99, list_comprehension; 99, 100; 99, 105; 100, call; 100, 101; 100, 102; 101, identifier:Cleanse; 102, argument_list; 102, 103; 102, 104; 103, identifier:i; 104, identifier:encoding; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:i; 107, call; 107, 108; 107, 109; 108, identifier:sorted; 109, argument_list; 109, 110; 110, identifier:obj; 111, elif_clause; 111, 112; 111, 117; 112, call; 112, 113; 112, 114; 113, identifier:isinstance; 114, argument_list; 114, 115; 114, 116; 115, identifier:obj; 116, identifier:dict; 117, block; 117, 118; 118, return_statement; 118, 119; 119, dictionary_comprehension; 119, 120; 119, 131; 120, pair; 120, 121; 120, 126; 121, call; 121, 122; 121, 123; 122, identifier:Cleanse; 123, argument_list; 123, 124; 123, 125; 124, identifier:k; 125, identifier:encoding; 126, call; 126, 127; 126, 128; 127, identifier:Cleanse; 128, argument_list; 128, 129; 128, 130; 129, identifier:v; 130, identifier:encoding; 131, for_in_clause; 131, 132; 131, 135; 132, pattern_list; 132, 133; 132, 134; 133, identifier:k; 134, identifier:v; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:obj; 138, identifier:items; 139, argument_list; 140, else_clause; 140, 141; 141, block; 141, 142; 142, return_statement; 142, 143; 143, identifier:obj | def Cleanse(obj, encoding='utf-8'):
"""Makes Python object appropriate for JSON serialization.
- Replaces instances of Infinity/-Infinity/NaN with strings.
- Turns byte strings into unicode strings.
- Turns sets into sorted lists.
- Turns tuples into lists.
Args:
obj: Python data structure.
encoding: Charset used to decode byte strings.
Returns:
Unicode JSON data structure.
"""
if isinstance(obj, int):
return obj
elif isinstance(obj, float):
if obj == _INFINITY:
return 'Infinity'
elif obj == _NEGATIVE_INFINITY:
return '-Infinity'
elif math.isnan(obj):
return 'NaN'
else:
return obj
elif isinstance(obj, bytes):
return tf.compat.as_text(obj, encoding)
elif isinstance(obj, (list, tuple)):
return [Cleanse(i, encoding) for i in obj]
elif isinstance(obj, set):
return [Cleanse(i, encoding) for i in sorted(obj)]
elif isinstance(obj, dict):
return {Cleanse(k, encoding): Cleanse(v, encoding) for k, v in obj.items()}
else:
return obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:session_groups; 6, block; 6, 7; 6, 9; 6, 10; 6, 24; 6, 25; 6, 26; 6, 27; 6, 28; 6, 29; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:session_groups; 14, identifier:sort; 15, argument_list; 15, 16; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:key; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:operator; 21, identifier:attrgetter; 22, argument_list; 22, 23; 23, string:'name'; 24, comment; 25, comment; 26, comment; 27, comment; 28, comment; 29, for_statement; 29, 30; 29, 33; 29, 50; 30, pattern_list; 30, 31; 30, 32; 31, identifier:col_param; 32, identifier:extractor; 33, call; 33, 34; 33, 35; 34, identifier:reversed; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:list; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:zip; 41, argument_list; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_request; 46, identifier:col_params; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_extractors; 50, block; 50, 51; 50, 61; 51, if_statement; 51, 52; 51, 59; 52, comparison_operator:==; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:col_param; 55, identifier:order; 56, attribute; 56, 57; 56, 58; 57, identifier:api_pb2; 58, identifier:ORDER_UNSPECIFIED; 59, block; 59, 60; 60, continue_statement; 61, if_statement; 61, 62; 61, 69; 61, 88; 61, 117; 62, comparison_operator:==; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:col_param; 65, identifier:order; 66, attribute; 66, 67; 66, 68; 67, identifier:api_pb2; 68, identifier:ORDER_ASC; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:session_groups; 74, identifier:sort; 75, argument_list; 75, 76; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:key; 78, call; 78, 79; 78, 80; 79, identifier:_create_key_func; 80, argument_list; 80, 81; 80, 82; 81, identifier:extractor; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:none_is_largest; 84, not_operator; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:col_param; 87, identifier:missing_values_first; 88, elif_clause; 88, 89; 88, 96; 89, comparison_operator:==; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:col_param; 92, identifier:order; 93, attribute; 93, 94; 93, 95; 94, identifier:api_pb2; 95, identifier:ORDER_DESC; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:session_groups; 101, identifier:sort; 102, argument_list; 102, 103; 102, 114; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:key; 105, call; 105, 106; 105, 107; 106, identifier:_create_key_func; 107, argument_list; 107, 108; 107, 109; 108, identifier:extractor; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:none_is_largest; 111, attribute; 111, 112; 111, 113; 112, identifier:col_param; 113, identifier:missing_values_first; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:reverse; 116, True; 117, else_clause; 117, 118; 118, block; 118, 119; 119, raise_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:error; 123, identifier:HParamsError; 124, argument_list; 124, 125; 125, binary_operator:%; 125, 126; 125, 127; 126, string:'Unknown col_param.order given: %s'; 127, identifier:col_param | def _sort(self, session_groups):
"""Sorts 'session_groups' in place according to _request.col_params."""
# Sort by session_group name so we have a deterministic order.
session_groups.sort(key=operator.attrgetter('name'))
# Sort by lexicographical order of the _request.col_params whose order
# is not ORDER_UNSPECIFIED. The first such column is the primary sorting
# key, the second is the secondary sorting key, etc. To achieve that we
# need to iterate on these columns in reverse order (thus the primary key
# is the key used in the last sort).
for col_param, extractor in reversed(list(zip(self._request.col_params,
self._extractors))):
if col_param.order == api_pb2.ORDER_UNSPECIFIED:
continue
if col_param.order == api_pb2.ORDER_ASC:
session_groups.sort(
key=_create_key_func(
extractor,
none_is_largest=not col_param.missing_values_first))
elif col_param.order == api_pb2.ORDER_DESC:
session_groups.sort(
key=_create_key_func(
extractor,
none_is_largest=col_param.missing_values_first),
reverse=True)
else:
raise error.HParamsError('Unknown col_param.order given: %s' %
col_param) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:search; 6, block; 6, 7; 6, 9; 6, 26; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_sort; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:search; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:search; 20, identifier:sort; 21, argument_list; 21, 22; 22, list_splat; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_sort; 26, return_statement; 26, 27; 27, identifier:search | def sort(self, search):
"""
Add sorting information to the request.
"""
if self._sort:
search = search.sort(*self._sort)
return search |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:competitions_list; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:group; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:category; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_by; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:page; 16, integer:1; 17, default_parameter; 17, 18; 17, 19; 18, identifier:search; 19, None; 20, block; 20, 21; 20, 23; 20, 30; 20, 47; 20, 58; 20, 75; 20, 85; 20, 102; 20, 138; 21, expression_statement; 21, 22; 22, comment; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:valid_groups; 26, list:['general', 'entered', 'inClass']; 26, 27; 26, 28; 26, 29; 27, string:'general'; 28, string:'entered'; 29, string:'inClass'; 30, if_statement; 30, 31; 30, 36; 31, boolean_operator:and; 31, 32; 31, 33; 32, identifier:group; 33, comparison_operator:not; 33, 34; 33, 35; 34, identifier:group; 35, identifier:valid_groups; 36, block; 36, 37; 37, raise_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:ValueError; 40, argument_list; 40, 41; 41, binary_operator:+; 41, 42; 41, 43; 42, string:'Invalid group specified. Valid options are '; 43, call; 43, 44; 43, 45; 44, identifier:str; 45, argument_list; 45, 46; 46, identifier:valid_groups; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:valid_categories; 50, list:[
'all', 'featured', 'research', 'recruitment', 'gettingStarted',
'masters', 'playground'
]; 50, 51; 50, 52; 50, 53; 50, 54; 50, 55; 50, 56; 50, 57; 51, string:'all'; 52, string:'featured'; 53, string:'research'; 54, string:'recruitment'; 55, string:'gettingStarted'; 56, string:'masters'; 57, string:'playground'; 58, if_statement; 58, 59; 58, 64; 59, boolean_operator:and; 59, 60; 59, 61; 60, identifier:category; 61, comparison_operator:not; 61, 62; 61, 63; 62, identifier:category; 63, identifier:valid_categories; 64, block; 64, 65; 65, raise_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:ValueError; 68, argument_list; 68, 69; 69, binary_operator:+; 69, 70; 69, 71; 70, string:'Invalid category specified. Valid options are '; 71, call; 71, 72; 71, 73; 72, identifier:str; 73, argument_list; 73, 74; 74, identifier:valid_categories; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:valid_sort_by; 78, list:[
'grouped', 'prize', 'earliestDeadline', 'latestDeadline',
'numberOfTeams', 'recentlyCreated'
]; 78, 79; 78, 80; 78, 81; 78, 82; 78, 83; 78, 84; 79, string:'grouped'; 80, string:'prize'; 81, string:'earliestDeadline'; 82, string:'latestDeadline'; 83, string:'numberOfTeams'; 84, string:'recentlyCreated'; 85, if_statement; 85, 86; 85, 91; 86, boolean_operator:and; 86, 87; 86, 88; 87, identifier:sort_by; 88, comparison_operator:not; 88, 89; 88, 90; 89, identifier:sort_by; 90, identifier:valid_sort_by; 91, block; 91, 92; 92, raise_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:ValueError; 95, argument_list; 95, 96; 96, binary_operator:+; 96, 97; 96, 98; 97, string:'Invalid sort_by specified. Valid options are '; 98, call; 98, 99; 98, 100; 99, identifier:str; 100, argument_list; 100, 101; 101, identifier:valid_sort_by; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:competitions_list_result; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:process_response; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:competitions_list_with_http_info; 114, argument_list; 114, 115; 114, 120; 114, 125; 114, 130; 114, 133; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:group; 117, boolean_operator:or; 117, 118; 117, 119; 118, identifier:group; 119, string:''; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:category; 122, boolean_operator:or; 122, 123; 122, 124; 123, identifier:category; 124, string:''; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:sort_by; 127, boolean_operator:or; 127, 128; 127, 129; 128, identifier:sort_by; 129, string:''; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:page; 132, identifier:page; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:search; 135, boolean_operator:or; 135, 136; 135, 137; 136, identifier:search; 137, string:''; 138, return_statement; 138, 139; 139, list_comprehension; 139, 140; 139, 144; 140, call; 140, 141; 140, 142; 141, identifier:Competition; 142, argument_list; 142, 143; 143, identifier:c; 144, for_in_clause; 144, 145; 144, 146; 145, identifier:c; 146, identifier:competitions_list_result | def competitions_list(self,
group=None,
category=None,
sort_by=None,
page=1,
search=None):
""" make call to list competitions, format the response, and return
a list of Competition instances
Parameters
==========
page: the page to return (default is 1)
search: a search term to use (default is empty string)
sort_by: how to sort the result, see valid_sort_by for options
category: category to filter result to
group: group to filter result to
"""
valid_groups = ['general', 'entered', 'inClass']
if group and group not in valid_groups:
raise ValueError('Invalid group specified. Valid options are ' +
str(valid_groups))
valid_categories = [
'all', 'featured', 'research', 'recruitment', 'gettingStarted',
'masters', 'playground'
]
if category and category not in valid_categories:
raise ValueError('Invalid category specified. Valid options are ' +
str(valid_categories))
valid_sort_by = [
'grouped', 'prize', 'earliestDeadline', 'latestDeadline',
'numberOfTeams', 'recentlyCreated'
]
if sort_by and sort_by not in valid_sort_by:
raise ValueError('Invalid sort_by specified. Valid options are ' +
str(valid_sort_by))
competitions_list_result = self.process_response(
self.competitions_list_with_http_info(
group=group or '',
category=category or '',
sort_by=sort_by or '',
page=page,
search=search or ''))
return [Competition(c) for c in competitions_list_result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:competitions_list_cli; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:group; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:category; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort_by; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:page; 16, integer:1; 17, default_parameter; 17, 18; 17, 19; 18, identifier:search; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:csv_display; 22, False; 23, block; 23, 24; 23, 26; 23, 49; 23, 59; 24, expression_statement; 24, 25; 25, comment; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:competitions; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:competitions_list; 33, argument_list; 33, 34; 33, 37; 33, 40; 33, 43; 33, 46; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:group; 36, identifier:group; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:category; 39, identifier:category; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:sort_by; 42, identifier:sort_by; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:page; 45, identifier:page; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:search; 48, identifier:search; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:fields; 52, list:[
'ref', 'deadline', 'category', 'reward', 'teamCount',
'userHasEntered'
]; 52, 53; 52, 54; 52, 55; 52, 56; 52, 57; 52, 58; 53, string:'ref'; 54, string:'deadline'; 55, string:'category'; 56, string:'reward'; 57, string:'teamCount'; 58, string:'userHasEntered'; 59, if_statement; 59, 60; 59, 61; 59, 83; 60, identifier:competitions; 61, block; 61, 62; 62, if_statement; 62, 63; 62, 64; 62, 73; 63, identifier:csv_display; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:print_csv; 70, argument_list; 70, 71; 70, 72; 71, identifier:competitions; 72, identifier:fields; 73, else_clause; 73, 74; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:print_table; 80, argument_list; 80, 81; 80, 82; 81, identifier:competitions; 82, identifier:fields; 83, else_clause; 83, 84; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:print; 88, argument_list; 88, 89; 89, string:'No competitions found' | def competitions_list_cli(self,
group=None,
category=None,
sort_by=None,
page=1,
search=None,
csv_display=False):
""" a wrapper for competitions_list for the client.
Parameters
==========
group: group to filter result to
category: category to filter result to
sort_by: how to sort the result, see valid_sort_by for options
page: the page to return (default is 1)
search: a search term to use (default is empty string)
csv_display: if True, print comma separated values
"""
competitions = self.competitions_list(
group=group,
category=category,
sort_by=sort_by,
page=page,
search=search)
fields = [
'ref', 'deadline', 'category', 'reward', 'teamCount',
'userHasEntered'
]
if competitions:
if csv_display:
self.print_csv(competitions, fields)
else:
self.print_table(competitions, fields)
else:
print('No competitions found') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 32; 2, function_name:dataset_list; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:size; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:file_type; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:license_name; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:tag_ids; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:search; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:user; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:mine; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:page; 31, integer:1; 32, block; 32, 33; 32, 35; 32, 44; 32, 61; 32, 69; 32, 86; 32, 95; 32, 112; 32, 121; 32, 138; 32, 151; 32, 155; 32, 170; 32, 177; 32, 231; 33, expression_statement; 33, 34; 34, comment; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:valid_sort_bys; 38, list:['hottest', 'votes', 'updated', 'active', 'published']; 38, 39; 38, 40; 38, 41; 38, 42; 38, 43; 39, string:'hottest'; 40, string:'votes'; 41, string:'updated'; 42, string:'active'; 43, string:'published'; 44, if_statement; 44, 45; 44, 50; 45, boolean_operator:and; 45, 46; 45, 47; 46, identifier:sort_by; 47, comparison_operator:not; 47, 48; 47, 49; 48, identifier:sort_by; 49, identifier:valid_sort_bys; 50, block; 50, 51; 51, raise_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:ValueError; 54, argument_list; 54, 55; 55, binary_operator:+; 55, 56; 55, 57; 56, string:'Invalid sort by specified. Valid options are '; 57, call; 57, 58; 57, 59; 58, identifier:str; 59, argument_list; 59, 60; 60, identifier:valid_sort_bys; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:valid_sizes; 64, list:['all', 'small', 'medium', 'large']; 64, 65; 64, 66; 64, 67; 64, 68; 65, string:'all'; 66, string:'small'; 67, string:'medium'; 68, string:'large'; 69, if_statement; 69, 70; 69, 75; 70, boolean_operator:and; 70, 71; 70, 72; 71, identifier:size; 72, comparison_operator:not; 72, 73; 72, 74; 73, identifier:size; 74, identifier:valid_sizes; 75, block; 75, 76; 76, raise_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:ValueError; 79, argument_list; 79, 80; 80, binary_operator:+; 80, 81; 80, 82; 81, string:'Invalid size specified. Valid options are '; 82, call; 82, 83; 82, 84; 83, identifier:str; 84, argument_list; 84, 85; 85, identifier:valid_sizes; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:valid_file_types; 89, list:['all', 'csv', 'sqlite', 'json', 'bigQuery']; 89, 90; 89, 91; 89, 92; 89, 93; 89, 94; 90, string:'all'; 91, string:'csv'; 92, string:'sqlite'; 93, string:'json'; 94, string:'bigQuery'; 95, if_statement; 95, 96; 95, 101; 96, boolean_operator:and; 96, 97; 96, 98; 97, identifier:file_type; 98, comparison_operator:not; 98, 99; 98, 100; 99, identifier:file_type; 100, identifier:valid_file_types; 101, block; 101, 102; 102, raise_statement; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:ValueError; 105, argument_list; 105, 106; 106, binary_operator:+; 106, 107; 106, 108; 107, string:'Invalid file type specified. Valid options are '; 108, call; 108, 109; 108, 110; 109, identifier:str; 110, argument_list; 110, 111; 111, identifier:valid_file_types; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:valid_license_names; 115, list:['all', 'cc', 'gpl', 'odb', 'other']; 115, 116; 115, 117; 115, 118; 115, 119; 115, 120; 116, string:'all'; 117, string:'cc'; 118, string:'gpl'; 119, string:'odb'; 120, string:'other'; 121, if_statement; 121, 122; 121, 127; 122, boolean_operator:and; 122, 123; 122, 124; 123, identifier:license_name; 124, comparison_operator:not; 124, 125; 124, 126; 125, identifier:license_name; 126, identifier:valid_license_names; 127, block; 127, 128; 128, raise_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:ValueError; 131, argument_list; 131, 132; 132, binary_operator:+; 132, 133; 132, 134; 133, string:'Invalid license specified. Valid options are '; 134, call; 134, 135; 134, 136; 135, identifier:str; 136, argument_list; 136, 137; 137, identifier:valid_license_names; 138, if_statement; 138, 139; 138, 145; 139, comparison_operator:<=; 139, 140; 139, 144; 140, call; 140, 141; 140, 142; 141, identifier:int; 142, argument_list; 142, 143; 143, identifier:page; 144, integer:0; 145, block; 145, 146; 146, raise_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:ValueError; 149, argument_list; 149, 150; 150, string:'Page number must be >= 1'; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:group; 154, string:'public'; 155, if_statement; 155, 156; 155, 157; 156, identifier:mine; 157, block; 157, 158; 157, 162; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:group; 161, string:'my'; 162, if_statement; 162, 163; 162, 164; 163, identifier:user; 164, block; 164, 165; 165, raise_statement; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:ValueError; 168, argument_list; 168, 169; 169, string:'Cannot specify both mine and a user'; 170, if_statement; 170, 171; 170, 172; 171, identifier:user; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:group; 176, string:'user'; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:datasets_list_result; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:process_response; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:datasets_list_with_http_info; 189, argument_list; 189, 190; 189, 193; 189, 198; 189, 203; 189, 208; 189, 213; 189, 218; 189, 223; 189, 228; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:group; 192, identifier:group; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:sort_by; 195, boolean_operator:or; 195, 196; 195, 197; 196, identifier:sort_by; 197, string:'hottest'; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:size; 200, boolean_operator:or; 200, 201; 200, 202; 201, identifier:size; 202, string:'all'; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:filetype; 205, boolean_operator:or; 205, 206; 205, 207; 206, identifier:file_type; 207, string:'all'; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:license; 210, boolean_operator:or; 210, 211; 210, 212; 211, identifier:license_name; 212, string:'all'; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:tagids; 215, boolean_operator:or; 215, 216; 215, 217; 216, identifier:tag_ids; 217, string:''; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:search; 220, boolean_operator:or; 220, 221; 220, 222; 221, identifier:search; 222, string:''; 223, keyword_argument; 223, 224; 223, 225; 224, identifier:user; 225, boolean_operator:or; 225, 226; 225, 227; 226, identifier:user; 227, string:''; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:page; 230, identifier:page; 231, return_statement; 231, 232; 232, list_comprehension; 232, 233; 232, 237; 233, call; 233, 234; 233, 235; 234, identifier:Dataset; 235, argument_list; 235, 236; 236, identifier:d; 237, for_in_clause; 237, 238; 237, 239; 238, identifier:d; 239, identifier:datasets_list_result | def dataset_list(self,
sort_by=None,
size=None,
file_type=None,
license_name=None,
tag_ids=None,
search=None,
user=None,
mine=False,
page=1):
""" return a list of datasets!
Parameters
==========
sort_by: how to sort the result, see valid_sort_bys for options
size: the size of the dataset, see valid_sizes for string options
file_type: the format, see valid_file_types for string options
license_name: string descriptor for license, see valid_license_names
tag_ids: tag identifiers to filter the search
search: a search term to use (default is empty string)
user: username to filter the search to
mine: boolean if True, group is changed to "my" to return personal
page: the page to return (default is 1)
"""
valid_sort_bys = ['hottest', 'votes', 'updated', 'active', 'published']
if sort_by and sort_by not in valid_sort_bys:
raise ValueError('Invalid sort by specified. Valid options are ' +
str(valid_sort_bys))
valid_sizes = ['all', 'small', 'medium', 'large']
if size and size not in valid_sizes:
raise ValueError('Invalid size specified. Valid options are ' +
str(valid_sizes))
valid_file_types = ['all', 'csv', 'sqlite', 'json', 'bigQuery']
if file_type and file_type not in valid_file_types:
raise ValueError('Invalid file type specified. Valid options are '
+ str(valid_file_types))
valid_license_names = ['all', 'cc', 'gpl', 'odb', 'other']
if license_name and license_name not in valid_license_names:
raise ValueError('Invalid license specified. Valid options are ' +
str(valid_license_names))
if int(page) <= 0:
raise ValueError('Page number must be >= 1')
group = 'public'
if mine:
group = 'my'
if user:
raise ValueError('Cannot specify both mine and a user')
if user:
group = 'user'
datasets_list_result = self.process_response(
self.datasets_list_with_http_info(
group=group,
sort_by=sort_by or 'hottest',
size=size or 'all',
filetype=file_type or 'all',
license=license_name or 'all',
tagids=tag_ids or '',
search=search or '',
user=user or '',
page=page))
return [Dataset(d) for d in datasets_list_result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 35; 2, function_name:dataset_list_cli; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:size; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:file_type; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:license_name; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:tag_ids; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:search; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:user; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:mine; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:page; 31, integer:1; 32, default_parameter; 32, 33; 32, 34; 33, identifier:csv_display; 34, False; 35, block; 35, 36; 35, 38; 35, 55; 35, 64; 36, expression_statement; 36, 37; 37, comment; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:datasets; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:dataset_list; 45, argument_list; 45, 46; 45, 47; 45, 48; 45, 49; 45, 50; 45, 51; 45, 52; 45, 53; 45, 54; 46, identifier:sort_by; 47, identifier:size; 48, identifier:file_type; 49, identifier:license_name; 50, identifier:tag_ids; 51, identifier:search; 52, identifier:user; 53, identifier:mine; 54, identifier:page; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:fields; 58, list:['ref', 'title', 'size', 'lastUpdated', 'downloadCount']; 58, 59; 58, 60; 58, 61; 58, 62; 58, 63; 59, string:'ref'; 60, string:'title'; 61, string:'size'; 62, string:'lastUpdated'; 63, string:'downloadCount'; 64, if_statement; 64, 65; 64, 66; 64, 88; 65, identifier:datasets; 66, block; 66, 67; 67, if_statement; 67, 68; 67, 69; 67, 78; 68, identifier:csv_display; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:print_csv; 75, argument_list; 75, 76; 75, 77; 76, identifier:datasets; 77, identifier:fields; 78, else_clause; 78, 79; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:print_table; 85, argument_list; 85, 86; 85, 87; 86, identifier:datasets; 87, identifier:fields; 88, else_clause; 88, 89; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:print; 93, argument_list; 93, 94; 94, string:'No datasets found' | def dataset_list_cli(self,
sort_by=None,
size=None,
file_type=None,
license_name=None,
tag_ids=None,
search=None,
user=None,
mine=False,
page=1,
csv_display=False):
""" a wrapper to datasets_list for the client. Additional parameters
are described here, see dataset_list for others.
Parameters
==========
sort_by: how to sort the result, see valid_sort_bys for options
size: the size of the dataset, see valid_sizes for string options
file_type: the format, see valid_file_types for string options
license_name: string descriptor for license, see valid_license_names
tag_ids: tag identifiers to filter the search
search: a search term to use (default is empty string)
user: username to filter the search to
mine: boolean if True, group is changed to "my" to return personal
page: the page to return (default is 1)
csv_display: if True, print comma separated values instead of table
"""
datasets = self.dataset_list(sort_by, size, file_type, license_name,
tag_ids, search, user, mine, page)
fields = ['ref', 'title', 'size', 'lastUpdated', 'downloadCount']
if datasets:
if csv_display:
self.print_csv(datasets, fields)
else:
self.print_table(datasets, fields)
else:
print('No datasets found') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 41; 2, function_name:kernels_list; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 3, 38; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:page; 7, integer:1; 8, default_parameter; 8, 9; 8, 10; 9, identifier:page_size; 10, integer:20; 11, default_parameter; 11, 12; 11, 13; 12, identifier:dataset; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:competition; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:parent_kernel; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:search; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:mine; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:user; 28, None; 29, default_parameter; 29, 30; 29, 31; 30, identifier:language; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:kernel_type; 34, None; 35, default_parameter; 35, 36; 35, 37; 36, identifier:output_type; 37, None; 38, default_parameter; 38, 39; 38, 40; 39, identifier:sort_by; 40, None; 41, block; 41, 42; 41, 44; 41, 57; 41, 64; 41, 74; 41, 83; 41, 92; 41, 109; 41, 116; 41, 133; 41, 140; 41, 157; 41, 170; 41, 187; 41, 201; 41, 208; 41, 215; 41, 219; 41, 226; 41, 293; 42, expression_statement; 42, 43; 43, comment; 44, if_statement; 44, 45; 44, 51; 45, comparison_operator:<=; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:int; 48, argument_list; 48, 49; 49, identifier:page; 50, integer:0; 51, block; 51, 52; 52, raise_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:ValueError; 55, argument_list; 55, 56; 56, string:'Page number must be >= 1'; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:page_size; 60, call; 60, 61; 60, 62; 61, identifier:int; 62, argument_list; 62, 63; 63, identifier:page_size; 64, if_statement; 64, 65; 64, 68; 65, comparison_operator:<=; 65, 66; 65, 67; 66, identifier:page_size; 67, integer:0; 68, block; 68, 69; 69, raise_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:ValueError; 72, argument_list; 72, 73; 73, string:'Page size must be >= 1'; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:>; 75, 76; 75, 77; 76, identifier:page_size; 77, integer:100; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:page_size; 82, integer:100; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:valid_languages; 86, list:['all', 'python', 'r', 'sqlite', 'julia']; 86, 87; 86, 88; 86, 89; 86, 90; 86, 91; 87, string:'all'; 88, string:'python'; 89, string:'r'; 90, string:'sqlite'; 91, string:'julia'; 92, if_statement; 92, 93; 92, 98; 93, boolean_operator:and; 93, 94; 93, 95; 94, identifier:language; 95, comparison_operator:not; 95, 96; 95, 97; 96, identifier:language; 97, identifier:valid_languages; 98, block; 98, 99; 99, raise_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:ValueError; 102, argument_list; 102, 103; 103, binary_operator:+; 103, 104; 103, 105; 104, string:'Invalid language specified. Valid options are '; 105, call; 105, 106; 105, 107; 106, identifier:str; 107, argument_list; 107, 108; 108, identifier:valid_languages; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:valid_kernel_types; 112, list:['all', 'script', 'notebook']; 112, 113; 112, 114; 112, 115; 113, string:'all'; 114, string:'script'; 115, string:'notebook'; 116, if_statement; 116, 117; 116, 122; 117, boolean_operator:and; 117, 118; 117, 119; 118, identifier:kernel_type; 119, comparison_operator:not; 119, 120; 119, 121; 120, identifier:kernel_type; 121, identifier:valid_kernel_types; 122, block; 122, 123; 123, raise_statement; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:ValueError; 126, argument_list; 126, 127; 127, binary_operator:+; 127, 128; 127, 129; 128, string:'Invalid kernel type specified. Valid options are '; 129, call; 129, 130; 129, 131; 130, identifier:str; 131, argument_list; 131, 132; 132, identifier:valid_kernel_types; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:valid_output_types; 136, list:['all', 'visualization', 'data']; 136, 137; 136, 138; 136, 139; 137, string:'all'; 138, string:'visualization'; 139, string:'data'; 140, if_statement; 140, 141; 140, 146; 141, boolean_operator:and; 141, 142; 141, 143; 142, identifier:output_type; 143, comparison_operator:not; 143, 144; 143, 145; 144, identifier:output_type; 145, identifier:valid_output_types; 146, block; 146, 147; 147, raise_statement; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:ValueError; 150, argument_list; 150, 151; 151, binary_operator:+; 151, 152; 151, 153; 152, string:'Invalid output type specified. Valid options are '; 153, call; 153, 154; 153, 155; 154, identifier:str; 155, argument_list; 155, 156; 156, identifier:valid_output_types; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:valid_sort_by; 160, list:[
'hotness', 'commentCount', 'dateCreated', 'dateRun', 'relevance',
'scoreAscending', 'scoreDescending', 'viewCount', 'voteCount'
]; 160, 161; 160, 162; 160, 163; 160, 164; 160, 165; 160, 166; 160, 167; 160, 168; 160, 169; 161, string:'hotness'; 162, string:'commentCount'; 163, string:'dateCreated'; 164, string:'dateRun'; 165, string:'relevance'; 166, string:'scoreAscending'; 167, string:'scoreDescending'; 168, string:'viewCount'; 169, string:'voteCount'; 170, if_statement; 170, 171; 170, 176; 171, boolean_operator:and; 171, 172; 171, 173; 172, identifier:sort_by; 173, comparison_operator:not; 173, 174; 173, 175; 174, identifier:sort_by; 175, identifier:valid_sort_by; 176, block; 176, 177; 177, raise_statement; 177, 178; 178, call; 178, 179; 178, 180; 179, identifier:ValueError; 180, argument_list; 180, 181; 181, binary_operator:+; 181, 182; 181, 183; 182, string:'Invalid sort by type specified. Valid options are '; 183, call; 183, 184; 183, 185; 184, identifier:str; 185, argument_list; 185, 186; 186, identifier:valid_sort_by; 187, if_statement; 187, 188; 187, 195; 188, boolean_operator:and; 188, 189; 188, 192; 189, comparison_operator:==; 189, 190; 189, 191; 190, identifier:sort_by; 191, string:'relevance'; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:search; 194, string:''; 195, block; 195, 196; 196, raise_statement; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:ValueError; 199, argument_list; 199, 200; 200, string:'Cannot sort by relevance without a search term.'; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:validate_dataset_string; 206, argument_list; 206, 207; 207, identifier:dataset; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:self; 212, identifier:validate_kernel_string; 213, argument_list; 213, 214; 214, identifier:parent_kernel; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:group; 218, string:'everyone'; 219, if_statement; 219, 220; 219, 221; 220, identifier:mine; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:group; 225, string:'profile'; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:kernels_list_result; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:process_response; 233, argument_list; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:kernels_list_with_http_info; 238, argument_list; 238, 239; 238, 242; 238, 245; 238, 248; 238, 253; 238, 258; 238, 263; 238, 268; 238, 273; 238, 278; 238, 283; 238, 288; 239, keyword_argument; 239, 240; 239, 241; 240, identifier:page; 241, identifier:page; 242, keyword_argument; 242, 243; 242, 244; 243, identifier:page_size; 244, identifier:page_size; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:group; 247, identifier:group; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:user; 250, boolean_operator:or; 250, 251; 250, 252; 251, identifier:user; 252, string:''; 253, keyword_argument; 253, 254; 253, 255; 254, identifier:language; 255, boolean_operator:or; 255, 256; 255, 257; 256, identifier:language; 257, string:'all'; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:kernel_type; 260, boolean_operator:or; 260, 261; 260, 262; 261, identifier:kernel_type; 262, string:'all'; 263, keyword_argument; 263, 264; 263, 265; 264, identifier:output_type; 265, boolean_operator:or; 265, 266; 265, 267; 266, identifier:output_type; 267, string:'all'; 268, keyword_argument; 268, 269; 268, 270; 269, identifier:sort_by; 270, boolean_operator:or; 270, 271; 270, 272; 271, identifier:sort_by; 272, string:'hotness'; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:dataset; 275, boolean_operator:or; 275, 276; 275, 277; 276, identifier:dataset; 277, string:''; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:competition; 280, boolean_operator:or; 280, 281; 280, 282; 281, identifier:competition; 282, string:''; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:parent_kernel; 285, boolean_operator:or; 285, 286; 285, 287; 286, identifier:parent_kernel; 287, string:''; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:search; 290, boolean_operator:or; 290, 291; 290, 292; 291, identifier:search; 292, string:''; 293, return_statement; 293, 294; 294, list_comprehension; 294, 295; 294, 299; 295, call; 295, 296; 295, 297; 296, identifier:Kernel; 297, argument_list; 297, 298; 298, identifier:k; 299, for_in_clause; 299, 300; 299, 301; 300, identifier:k; 301, identifier:kernels_list_result | def kernels_list(self,
page=1,
page_size=20,
dataset=None,
competition=None,
parent_kernel=None,
search=None,
mine=False,
user=None,
language=None,
kernel_type=None,
output_type=None,
sort_by=None):
""" list kernels based on a set of search criteria
Parameters
==========
page: the page of results to return (default is 1)
page_size: results per page (default is 20)
dataset: if defined, filter to this dataset (default None)
competition: if defined, filter to this competition (default None)
parent_kernel: if defined, filter to those with specified parent
search: a custom search string to pass to the list query
mine: if true, group is specified as "my" to return personal kernels
user: filter results to a specific user
language: the programming language of the kernel
kernel_type: the type of kernel, one of valid_kernel_types (str)
output_type: the output type, one of valid_output_types (str)
sort_by: if defined, sort results by this string (valid_sort_by)
"""
if int(page) <= 0:
raise ValueError('Page number must be >= 1')
page_size = int(page_size)
if page_size <= 0:
raise ValueError('Page size must be >= 1')
if page_size > 100:
page_size = 100
valid_languages = ['all', 'python', 'r', 'sqlite', 'julia']
if language and language not in valid_languages:
raise ValueError('Invalid language specified. Valid options are ' +
str(valid_languages))
valid_kernel_types = ['all', 'script', 'notebook']
if kernel_type and kernel_type not in valid_kernel_types:
raise ValueError(
'Invalid kernel type specified. Valid options are ' +
str(valid_kernel_types))
valid_output_types = ['all', 'visualization', 'data']
if output_type and output_type not in valid_output_types:
raise ValueError(
'Invalid output type specified. Valid options are ' +
str(valid_output_types))
valid_sort_by = [
'hotness', 'commentCount', 'dateCreated', 'dateRun', 'relevance',
'scoreAscending', 'scoreDescending', 'viewCount', 'voteCount'
]
if sort_by and sort_by not in valid_sort_by:
raise ValueError(
'Invalid sort by type specified. Valid options are ' +
str(valid_sort_by))
if sort_by == 'relevance' and search == '':
raise ValueError('Cannot sort by relevance without a search term.')
self.validate_dataset_string(dataset)
self.validate_kernel_string(parent_kernel)
group = 'everyone'
if mine:
group = 'profile'
kernels_list_result = self.process_response(
self.kernels_list_with_http_info(
page=page,
page_size=page_size,
group=group,
user=user or '',
language=language or 'all',
kernel_type=kernel_type or 'all',
output_type=output_type or 'all',
sort_by=sort_by or 'hotness',
dataset=dataset or '',
competition=competition or '',
parent_kernel=parent_kernel or '',
search=search or ''))
return [Kernel(k) for k in kernels_list_result] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:_get_salt_params; 3, parameters; 4, block; 4, 5; 4, 7; 4, 15; 4, 23; 4, 27; 4, 189; 5, expression_statement; 5, 6; 6, string:'''
Try to get all sort of parameters for Server Density server info.
NOTE: Missing publicDNS and publicIPs parameters. There might be way of
getting them with salt-cloud.
'''; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:all_stats; 10, call; 10, 11; 10, 14; 11, subscript; 11, 12; 11, 13; 12, identifier:__salt__; 13, string:'status.all_status'; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:all_grains; 18, call; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:__salt__; 21, string:'grains.items'; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:params; 26, dictionary; 27, try_statement; 27, 28; 27, 185; 28, block; 28, 29; 28, 37; 28, 45; 28, 82; 28, 97; 28, 107; 28, 129; 28, 151; 28, 168; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:params; 33, string:'name'; 34, subscript; 34, 35; 34, 36; 35, identifier:all_grains; 36, string:'id'; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, subscript; 39, 40; 39, 41; 40, identifier:params; 41, string:'hostname'; 42, subscript; 42, 43; 42, 44; 43, identifier:all_grains; 44, string:'host'; 45, if_statement; 45, 46; 45, 51; 45, 62; 46, comparison_operator:==; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:all_grains; 49, string:'kernel'; 50, string:'Darwin'; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:sd_os; 55, dictionary; 55, 56; 55, 59; 56, pair; 56, 57; 56, 58; 57, string:'code'; 58, string:'mac'; 59, pair; 59, 60; 59, 61; 60, string:'name'; 61, string:'Mac'; 62, else_clause; 62, 63; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:sd_os; 67, dictionary; 67, 68; 67, 77; 68, pair; 68, 69; 68, 70; 69, string:'code'; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:all_grains; 74, string:'kernel'; 75, identifier:lower; 76, argument_list; 77, pair; 77, 78; 77, 79; 78, string:'name'; 79, subscript; 79, 80; 79, 81; 80, identifier:all_grains; 81, string:'kernel'; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:params; 86, string:'os'; 87, call; 87, 88; 87, 95; 88, attribute; 88, 89; 88, 94; 89, attribute; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:salt; 92, identifier:utils; 93, identifier:json; 94, identifier:dumps; 95, argument_list; 95, 96; 96, identifier:sd_os; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:params; 101, string:'cpuCores'; 102, subscript; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:all_stats; 105, string:'cpuinfo'; 106, string:'cpu cores'; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:params; 111, string:'installedRAM'; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:six; 115, identifier:text_type; 116, argument_list; 116, 117; 117, binary_operator:/; 117, 118; 117, 128; 118, call; 118, 119; 118, 120; 119, identifier:int; 120, argument_list; 120, 121; 121, subscript; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:all_stats; 125, string:'meminfo'; 126, string:'MemTotal'; 127, string:'value'; 128, integer:1024; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:params; 133, string:'swapSpace'; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:six; 137, identifier:text_type; 138, argument_list; 138, 139; 139, binary_operator:/; 139, 140; 139, 150; 140, call; 140, 141; 140, 142; 141, identifier:int; 142, argument_list; 142, 143; 143, subscript; 143, 144; 143, 149; 144, subscript; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:all_stats; 147, string:'meminfo'; 148, string:'SwapTotal'; 149, string:'value'; 150, integer:1024; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:params; 155, string:'privateIPs'; 156, call; 156, 157; 156, 164; 157, attribute; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:salt; 161, identifier:utils; 162, identifier:json; 163, identifier:dumps; 164, argument_list; 164, 165; 165, subscript; 165, 166; 165, 167; 166, identifier:all_grains; 167, string:'fqdn_ip4'; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 173; 170, subscript; 170, 171; 170, 172; 171, identifier:params; 172, string:'privateDNS'; 173, call; 173, 174; 173, 181; 174, attribute; 174, 175; 174, 180; 175, attribute; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:salt; 178, identifier:utils; 179, identifier:json; 180, identifier:dumps; 181, argument_list; 181, 182; 182, subscript; 182, 183; 182, 184; 183, identifier:all_grains; 184, string:'fqdn'; 185, except_clause; 185, 186; 185, 187; 186, identifier:KeyError; 187, block; 187, 188; 188, pass_statement; 189, return_statement; 189, 190; 190, identifier:params | def _get_salt_params():
'''
Try to get all sort of parameters for Server Density server info.
NOTE: Missing publicDNS and publicIPs parameters. There might be way of
getting them with salt-cloud.
'''
all_stats = __salt__['status.all_status']()
all_grains = __salt__['grains.items']()
params = {}
try:
params['name'] = all_grains['id']
params['hostname'] = all_grains['host']
if all_grains['kernel'] == 'Darwin':
sd_os = {'code': 'mac', 'name': 'Mac'}
else:
sd_os = {'code': all_grains['kernel'].lower(), 'name': all_grains['kernel']}
params['os'] = salt.utils.json.dumps(sd_os)
params['cpuCores'] = all_stats['cpuinfo']['cpu cores']
params['installedRAM'] = six.text_type(int(all_stats['meminfo']['MemTotal']['value']) / 1024)
params['swapSpace'] = six.text_type(int(all_stats['meminfo']['SwapTotal']['value']) / 1024)
params['privateIPs'] = salt.utils.json.dumps(all_grains['fqdn_ip4'])
params['privateDNS'] = salt.utils.json.dumps(all_grains['fqdn'])
except KeyError:
pass
return params |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:zcard; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:key; 5, default_parameter; 5, 6; 5, 7; 6, identifier:host; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:port; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:db; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:password; 16, None; 17, block; 17, 18; 17, 20; 17, 30; 18, expression_statement; 18, 19; 19, string:'''
Get the length of a sorted set in Redis
CLI Example:
.. code-block:: bash
salt '*' redis.zcard foo_sorted
'''; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:server; 23, call; 23, 24; 23, 25; 24, identifier:_connect; 25, argument_list; 25, 26; 25, 27; 25, 28; 25, 29; 26, identifier:host; 27, identifier:port; 28, identifier:db; 29, identifier:password; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:server; 34, identifier:zcard; 35, argument_list; 35, 36; 36, identifier:key | def zcard(key, host=None, port=None, db=None, password=None):
'''
Get the length of a sorted set in Redis
CLI Example:
.. code-block:: bash
salt '*' redis.zcard foo_sorted
'''
server = _connect(host, port, db, password)
return server.zcard(key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:zrange; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 4, identifier:key; 5, identifier:start; 6, identifier:stop; 7, default_parameter; 7, 8; 7, 9; 8, identifier:host; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:port; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:db; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:password; 18, None; 19, block; 19, 20; 19, 22; 19, 32; 20, expression_statement; 20, 21; 21, string:'''
Get a range of values from a sorted set in Redis by index
CLI Example:
.. code-block:: bash
salt '*' redis.zrange foo_sorted 0 10
'''; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:server; 25, call; 25, 26; 25, 27; 26, identifier:_connect; 27, argument_list; 27, 28; 27, 29; 27, 30; 27, 31; 28, identifier:host; 29, identifier:port; 30, identifier:db; 31, identifier:password; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:server; 36, identifier:zrange; 37, argument_list; 37, 38; 37, 39; 37, 40; 38, identifier:key; 39, identifier:start; 40, identifier:stop | def zrange(key, start, stop, host=None, port=None, db=None, password=None):
'''
Get a range of values from a sorted set in Redis by index
CLI Example:
.. code-block:: bash
salt '*' redis.zrange foo_sorted 0 10
'''
server = _connect(host, port, db, password)
return server.zrange(key, start, stop) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:get_list; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 4, default_parameter; 4, 5; 4, 6; 5, identifier:list_type; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:search_term; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:page; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:page_size; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:sort_by; 18, None; 19, block; 19, 20; 19, 22; 19, 35; 19, 66; 19, 101; 19, 112; 19, 144; 19, 178; 19, 191; 19, 198; 19, 209; 19, 213; 19, 238; 20, expression_statement; 20, 21; 21, string:'''
Returns a list of domains for the particular user as a list of objects
offset by ``page`` length of ``page_size``
list_type : ALL
One of ``ALL``, ``EXPIRING``, ``EXPIRED``
search_term
Keyword to look for on the domain list
page : 1
Number of result page to return
page_size : 20
Number of domains to be listed per page (minimum: ``10``, maximum:
``100``)
sort_by
One of ``NAME``, ``NAME_DESC``, ``EXPIREDATE``, ``EXPIREDATE_DESC``,
``CREATEDATE``, or ``CREATEDATE_DESC``
CLI Example:
.. code-block:: bash
salt 'my-minion' namecheap_domains.get_list
'''; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:opts; 25, call; 25, 26; 25, 33; 26, attribute; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:salt; 30, identifier:utils; 31, identifier:namecheap; 32, identifier:get_opts; 33, argument_list; 33, 34; 34, string:'namecheap.domains.getList'; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:list_type; 38, None; 39, block; 39, 40; 39, 60; 40, if_statement; 40, 41; 40, 47; 41, comparison_operator:not; 41, 42; 41, 43; 42, identifier:list_type; 43, list:['ALL', 'EXPIRING', 'EXPIRED']; 43, 44; 43, 45; 43, 46; 44, string:'ALL'; 45, string:'EXPIRING'; 46, string:'EXPIRED'; 47, block; 47, 48; 47, 55; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:log; 52, identifier:error; 53, argument_list; 53, 54; 54, string:'Invalid option for list_type'; 55, raise_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:Exception; 58, argument_list; 58, 59; 59, string:'Invalid option for list_type'; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:opts; 64, string:'ListType'; 65, identifier:list_type; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:search_term; 69, None; 70, block; 70, 71; 70, 95; 71, if_statement; 71, 72; 71, 78; 72, comparison_operator:>; 72, 73; 72, 77; 73, call; 73, 74; 73, 75; 74, identifier:len; 75, argument_list; 75, 76; 76, identifier:search_term; 77, integer:70; 78, block; 78, 79; 78, 86; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:log; 83, identifier:warning; 84, argument_list; 84, 85; 85, string:'search_term trimmed to first 70 characters'; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:search_term; 89, subscript; 89, 90; 89, 91; 90, identifier:search_term; 91, slice; 91, 92; 91, 93; 91, 94; 92, integer:0; 93, colon; 94, integer:70; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:opts; 99, string:'SearchTerm'; 100, identifier:search_term; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:page; 104, None; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:opts; 110, string:'Page'; 111, identifier:page; 112, if_statement; 112, 113; 112, 116; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:page_size; 115, None; 116, block; 116, 117; 116, 138; 117, if_statement; 117, 118; 117, 125; 118, boolean_operator:or; 118, 119; 118, 122; 119, comparison_operator:>; 119, 120; 119, 121; 120, identifier:page_size; 121, integer:100; 122, comparison_operator:<; 122, 123; 122, 124; 123, identifier:page_size; 124, integer:10; 125, block; 125, 126; 125, 133; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:log; 130, identifier:error; 131, argument_list; 131, 132; 132, string:'Invalid option for page'; 133, raise_statement; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:Exception; 136, argument_list; 136, 137; 137, string:'Invalid option for page'; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:opts; 142, string:'PageSize'; 143, identifier:page_size; 144, if_statement; 144, 145; 144, 148; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:sort_by; 147, None; 148, block; 148, 149; 148, 172; 149, if_statement; 149, 150; 149, 159; 150, comparison_operator:not; 150, 151; 150, 152; 151, identifier:sort_by; 152, list:['NAME', 'NAME_DESC', 'EXPIREDATE', 'EXPIREDATE_DESC', 'CREATEDATE', 'CREATEDATE_DESC']; 152, 153; 152, 154; 152, 155; 152, 156; 152, 157; 152, 158; 153, string:'NAME'; 154, string:'NAME_DESC'; 155, string:'EXPIREDATE'; 156, string:'EXPIREDATE_DESC'; 157, string:'CREATEDATE'; 158, string:'CREATEDATE_DESC'; 159, block; 159, 160; 159, 167; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:log; 164, identifier:error; 165, argument_list; 165, 166; 166, string:'Invalid option for sort_by'; 167, raise_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:Exception; 170, argument_list; 170, 171; 171, string:'Invalid option for sort_by'; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:opts; 176, string:'SortBy'; 177, identifier:sort_by; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:response_xml; 181, call; 181, 182; 181, 189; 182, attribute; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:salt; 186, identifier:utils; 187, identifier:namecheap; 188, identifier:get_request; 189, argument_list; 189, 190; 190, identifier:opts; 191, if_statement; 191, 192; 191, 195; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:response_xml; 194, None; 195, block; 195, 196; 196, return_statement; 196, 197; 197, list:[]; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:domainresult; 201, subscript; 201, 202; 201, 208; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:response_xml; 205, identifier:getElementsByTagName; 206, argument_list; 206, 207; 207, string:"DomainGetListResult"; 208, integer:0; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:domains; 212, list:[]; 213, for_statement; 213, 214; 213, 215; 213, 221; 214, identifier:d; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:domainresult; 218, identifier:getElementsByTagName; 219, argument_list; 219, 220; 220, string:"Domain"; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:domains; 226, identifier:append; 227, argument_list; 227, 228; 228, call; 228, 229; 228, 236; 229, attribute; 229, 230; 229, 235; 230, attribute; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:salt; 233, identifier:utils; 234, identifier:namecheap; 235, identifier:atts_to_dict; 236, argument_list; 236, 237; 237, identifier:d; 238, return_statement; 238, 239; 239, identifier:domains | def get_list(list_type=None,
search_term=None,
page=None,
page_size=None,
sort_by=None):
'''
Returns a list of domains for the particular user as a list of objects
offset by ``page`` length of ``page_size``
list_type : ALL
One of ``ALL``, ``EXPIRING``, ``EXPIRED``
search_term
Keyword to look for on the domain list
page : 1
Number of result page to return
page_size : 20
Number of domains to be listed per page (minimum: ``10``, maximum:
``100``)
sort_by
One of ``NAME``, ``NAME_DESC``, ``EXPIREDATE``, ``EXPIREDATE_DESC``,
``CREATEDATE``, or ``CREATEDATE_DESC``
CLI Example:
.. code-block:: bash
salt 'my-minion' namecheap_domains.get_list
'''
opts = salt.utils.namecheap.get_opts('namecheap.domains.getList')
if list_type is not None:
if list_type not in ['ALL', 'EXPIRING', 'EXPIRED']:
log.error('Invalid option for list_type')
raise Exception('Invalid option for list_type')
opts['ListType'] = list_type
if search_term is not None:
if len(search_term) > 70:
log.warning('search_term trimmed to first 70 characters')
search_term = search_term[0:70]
opts['SearchTerm'] = search_term
if page is not None:
opts['Page'] = page
if page_size is not None:
if page_size > 100 or page_size < 10:
log.error('Invalid option for page')
raise Exception('Invalid option for page')
opts['PageSize'] = page_size
if sort_by is not None:
if sort_by not in ['NAME', 'NAME_DESC', 'EXPIREDATE', 'EXPIREDATE_DESC', 'CREATEDATE', 'CREATEDATE_DESC']:
log.error('Invalid option for sort_by')
raise Exception('Invalid option for sort_by')
opts['SortBy'] = sort_by
response_xml = salt.utils.namecheap.get_request(opts)
if response_xml is None:
return []
domainresult = response_xml.getElementsByTagName("DomainGetListResult")[0]
domains = []
for d in domainresult.getElementsByTagName("Domain"):
domains.append(salt.utils.namecheap.atts_to_dict(d))
return domains |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort_policy; 3, parameters; 3, 4; 4, identifier:doc; 5, block; 5, 6; 5, 8; 5, 57; 6, expression_statement; 6, 7; 7, string:'''
List-type sub-items in policies don't happen to be order-sensitive, but
compare operations will render them unequal, leading to non-idempotent
state runs. We'll sort any list-type subitems before comparison to reduce
the likelihood of false negatives.
'''; 8, if_statement; 8, 9; 8, 14; 8, 27; 9, call; 9, 10; 9, 11; 10, identifier:isinstance; 11, argument_list; 11, 12; 11, 13; 12, identifier:doc; 13, identifier:list; 14, block; 14, 15; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 19, list_comprehension; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:_sort_policy; 22, argument_list; 22, 23; 23, identifier:i; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:i; 26, identifier:doc; 27, elif_clause; 27, 28; 27, 35; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:doc; 32, tuple; 32, 33; 32, 34; 33, identifier:dict; 34, identifier:OrderedDict; 35, block; 35, 36; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:dict; 39, argument_list; 39, 40; 40, list_comprehension; 40, 41; 40, 47; 41, tuple; 41, 42; 41, 43; 42, identifier:k; 43, call; 43, 44; 43, 45; 44, identifier:_sort_policy; 45, argument_list; 45, 46; 46, identifier:v; 47, for_in_clause; 47, 48; 47, 51; 48, pattern_list; 48, 49; 48, 50; 49, identifier:k; 50, identifier:v; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:six; 54, identifier:iteritems; 55, argument_list; 55, 56; 56, identifier:doc; 57, return_statement; 57, 58; 58, identifier:doc | def _sort_policy(doc):
'''
List-type sub-items in policies don't happen to be order-sensitive, but
compare operations will render them unequal, leading to non-idempotent
state runs. We'll sort any list-type subitems before comparison to reduce
the likelihood of false negatives.
'''
if isinstance(doc, list):
return sorted([_sort_policy(i) for i in doc])
elif isinstance(doc, (dict, OrderedDict)):
return dict([(k, _sort_policy(v)) for k, v in six.iteritems(doc)])
return doc |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_resolve_datacenter; 3, parameters; 3, 4; 3, 5; 4, identifier:dc; 5, identifier:pillarenv; 6, block; 6, 7; 6, 9; 6, 17; 6, 41; 6, 52; 6, 60; 6, 61; 6, 62; 6, 85; 6, 136; 7, expression_statement; 7, 8; 8, string:'''
If ``dc`` is a string - return it as is.
If it's a dict then sort it in descending order by key length and try
to use keys as RegEx patterns to match against ``pillarenv``.
The value for matched pattern should be a string (that can use
``str.format`` syntax togetehr with captured variables from pattern)
pointing to targe data center to use.
If none patterns matched return ``None`` which meanse us datacenter of
conencted Consul agent.
'''; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:log; 13, identifier:debug; 14, argument_list; 14, 15; 14, 16; 15, string:'Resolving Consul datacenter based on: %s'; 16, identifier:dc; 17, try_statement; 17, 18; 17, 28; 18, block; 18, 19; 18, 27; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:mappings; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:dc; 25, identifier:items; 26, argument_list; 27, comment; 28, except_clause; 28, 29; 28, 30; 29, identifier:AttributeError; 30, block; 30, 31; 30, 39; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:log; 35, identifier:debug; 36, argument_list; 36, 37; 36, 38; 37, string:'Using pre-defined DC: \'%s\''; 38, identifier:dc; 39, return_statement; 39, 40; 40, identifier:dc; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:log; 45, identifier:debug; 46, argument_list; 46, 47; 46, 48; 47, string:'Selecting DC based on pillarenv using %d pattern(s)'; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:mappings; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:log; 56, identifier:debug; 57, argument_list; 57, 58; 57, 59; 58, string:'Pillarenv set to \'%s\''; 59, identifier:pillarenv; 60, comment; 61, comment; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:sorted_mappings; 65, call; 65, 66; 65, 67; 66, identifier:sorted; 67, argument_list; 67, 68; 67, 69; 68, identifier:mappings; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:key; 71, lambda; 71, 72; 71, 74; 72, lambda_parameters; 72, 73; 73, identifier:m; 74, tuple; 74, 75; 74, 82; 75, unary_operator:-; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:m; 81, integer:0; 82, subscript; 82, 83; 82, 84; 83, identifier:m; 84, integer:0; 85, for_statement; 85, 86; 85, 89; 85, 90; 86, pattern_list; 86, 87; 86, 88; 87, identifier:pattern; 88, identifier:target; 89, identifier:sorted_mappings; 90, block; 90, 91; 90, 101; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:match; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:re; 97, identifier:match; 98, argument_list; 98, 99; 98, 100; 99, identifier:pattern; 100, identifier:pillarenv; 101, if_statement; 101, 102; 101, 103; 102, identifier:match; 103, block; 103, 104; 103, 112; 103, 126; 103, 134; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:log; 108, identifier:debug; 109, argument_list; 109, 110; 109, 111; 110, string:'Matched pattern: \'%s\''; 111, identifier:pattern; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:result; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:target; 118, identifier:format; 119, argument_list; 119, 120; 120, dictionary_splat; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:match; 124, identifier:groupdict; 125, argument_list; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:log; 130, identifier:debug; 131, argument_list; 131, 132; 131, 133; 132, string:'Resolved datacenter: \'%s\''; 133, identifier:result; 134, return_statement; 134, 135; 135, identifier:result; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:log; 140, identifier:debug; 141, argument_list; 141, 142; 141, 143; 141, 144; 142, string:'None of following patterns matched pillarenv=%s: %s'; 143, identifier:pillarenv; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, string:', '; 147, identifier:join; 148, generator_expression; 148, 149; 148, 153; 149, call; 149, 150; 149, 151; 150, identifier:repr; 151, argument_list; 151, 152; 152, identifier:x; 153, for_in_clause; 153, 154; 153, 155; 154, identifier:x; 155, identifier:mappings | def _resolve_datacenter(dc, pillarenv):
'''
If ``dc`` is a string - return it as is.
If it's a dict then sort it in descending order by key length and try
to use keys as RegEx patterns to match against ``pillarenv``.
The value for matched pattern should be a string (that can use
``str.format`` syntax togetehr with captured variables from pattern)
pointing to targe data center to use.
If none patterns matched return ``None`` which meanse us datacenter of
conencted Consul agent.
'''
log.debug('Resolving Consul datacenter based on: %s', dc)
try:
mappings = dc.items() # is it a dict?
except AttributeError:
log.debug('Using pre-defined DC: \'%s\'', dc)
return dc
log.debug('Selecting DC based on pillarenv using %d pattern(s)', len(mappings))
log.debug('Pillarenv set to \'%s\'', pillarenv)
# sort in reverse based on pattern length
# but use alphabetic order within groups of patterns of same length
sorted_mappings = sorted(mappings, key=lambda m: (-len(m[0]), m[0]))
for pattern, target in sorted_mappings:
match = re.match(pattern, pillarenv)
if match:
log.debug('Matched pattern: \'%s\'', pattern)
result = target.format(**match.groupdict())
log.debug('Resolved datacenter: \'%s\'', result)
return result
log.debug(
'None of following patterns matched pillarenv=%s: %s',
pillarenv, ', '.join(repr(x) for x in mappings)
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:read_conf; 3, parameters; 3, 4; 3, 5; 4, identifier:conf_file; 5, default_parameter; 5, 6; 5, 7; 6, identifier:out_format; 7, string:'simple'; 8, block; 8, 9; 8, 11; 8, 15; 8, 19; 8, 201; 8, 208; 9, expression_statement; 9, 10; 10, string:'''
Read in an LXC configuration file. By default returns a simple, unsorted
dict, but can also return a more detailed structure including blank lines
and comments.
out_format:
set to 'simple' if you need the old and unsupported behavior.
This won't support the multiple lxc values (eg: multiple network nics)
CLI Examples:
.. code-block:: bash
salt 'minion' lxc.read_conf /etc/lxc/mycontainer.conf
salt 'minion' lxc.read_conf /etc/lxc/mycontainer.conf out_format=commented
'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:ret_commented; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:ret_simple; 18, dictionary; 19, with_statement; 19, 20; 19, 36; 20, with_clause; 20, 21; 21, with_item; 21, 22; 22, as_pattern; 22, 23; 22, 34; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:salt; 28, identifier:utils; 29, identifier:files; 30, identifier:fopen; 31, argument_list; 31, 32; 31, 33; 32, identifier:conf_file; 33, string:'r'; 34, as_pattern_target; 34, 35; 35, identifier:fp_; 36, block; 36, 37; 37, for_statement; 37, 38; 37, 39; 37, 53; 38, identifier:line; 39, call; 39, 40; 39, 47; 40, attribute; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:salt; 44, identifier:utils; 45, identifier:data; 46, identifier:decode; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:fp_; 51, identifier:readlines; 52, argument_list; 53, block; 53, 54; 53, 67; 53, 76; 53, 93; 53, 97; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:not; 55, 56; 55, 57; 56, string:'='; 57, identifier:line; 58, block; 58, 59; 58, 66; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:ret_commented; 63, identifier:append; 64, argument_list; 64, 65; 65, identifier:line; 66, continue_statement; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:comps; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:line; 73, identifier:split; 74, argument_list; 74, 75; 75, string:'='; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:value; 79, call; 79, 80; 79, 92; 80, attribute; 80, 81; 80, 91; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, string:'='; 84, identifier:join; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 88; 87, identifier:comps; 88, slice; 88, 89; 88, 90; 89, integer:1; 90, colon; 91, identifier:strip; 92, argument_list; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:comment; 96, None; 97, if_statement; 97, 98; 97, 108; 97, 171; 98, call; 98, 99; 98, 106; 99, attribute; 99, 100; 99, 105; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:value; 103, identifier:strip; 104, argument_list; 105, identifier:startswith; 106, argument_list; 106, 107; 107, string:'#'; 108, block; 108, 109; 108, 122; 108, 132; 108, 149; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:vcomps; 112, call; 112, 113; 112, 120; 113, attribute; 113, 114; 113, 119; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:value; 117, identifier:strip; 118, argument_list; 119, identifier:split; 120, argument_list; 120, 121; 121, string:'#'; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:value; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:vcomps; 129, integer:1; 130, identifier:strip; 131, argument_list; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:comment; 135, call; 135, 136; 135, 148; 136, attribute; 136, 137; 136, 147; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, string:'#'; 140, identifier:join; 141, argument_list; 141, 142; 142, subscript; 142, 143; 142, 144; 143, identifier:vcomps; 144, slice; 144, 145; 144, 146; 145, integer:1; 146, colon; 147, identifier:strip; 148, argument_list; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:ret_commented; 153, identifier:append; 154, argument_list; 154, 155; 155, dictionary; 155, 156; 156, pair; 156, 157; 156, 164; 157, call; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, subscript; 159, 160; 159, 161; 160, identifier:comps; 161, integer:0; 162, identifier:strip; 163, argument_list; 164, dictionary; 164, 165; 164, 168; 165, pair; 165, 166; 165, 167; 166, string:'value'; 167, identifier:value; 168, pair; 168, 169; 168, 170; 169, string:'comment'; 170, identifier:comment; 171, else_clause; 171, 172; 172, block; 172, 173; 172, 189; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:ret_commented; 177, identifier:append; 178, argument_list; 178, 179; 179, dictionary; 179, 180; 180, pair; 180, 181; 180, 188; 181, call; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:comps; 185, integer:0; 186, identifier:strip; 187, argument_list; 188, identifier:value; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 200; 191, subscript; 191, 192; 191, 193; 192, identifier:ret_simple; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:comps; 197, integer:0; 198, identifier:strip; 199, argument_list; 200, identifier:value; 201, if_statement; 201, 202; 201, 205; 202, comparison_operator:==; 202, 203; 202, 204; 203, identifier:out_format; 204, string:'simple'; 205, block; 205, 206; 206, return_statement; 206, 207; 207, identifier:ret_simple; 208, return_statement; 208, 209; 209, identifier:ret_commented | def read_conf(conf_file, out_format='simple'):
'''
Read in an LXC configuration file. By default returns a simple, unsorted
dict, but can also return a more detailed structure including blank lines
and comments.
out_format:
set to 'simple' if you need the old and unsupported behavior.
This won't support the multiple lxc values (eg: multiple network nics)
CLI Examples:
.. code-block:: bash
salt 'minion' lxc.read_conf /etc/lxc/mycontainer.conf
salt 'minion' lxc.read_conf /etc/lxc/mycontainer.conf out_format=commented
'''
ret_commented = []
ret_simple = {}
with salt.utils.files.fopen(conf_file, 'r') as fp_:
for line in salt.utils.data.decode(fp_.readlines()):
if '=' not in line:
ret_commented.append(line)
continue
comps = line.split('=')
value = '='.join(comps[1:]).strip()
comment = None
if value.strip().startswith('#'):
vcomps = value.strip().split('#')
value = vcomps[1].strip()
comment = '#'.join(vcomps[1:]).strip()
ret_commented.append({comps[0].strip(): {
'value': value,
'comment': comment,
}})
else:
ret_commented.append({comps[0].strip(): value})
ret_simple[comps[0].strip()] = value
if out_format == 'simple':
return ret_simple
return ret_commented |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_top_targets; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:top; 6, identifier:orders; 7, block; 7, 8; 7, 10; 7, 19; 7, 20; 7, 62; 7, 63; 8, expression_statement; 8, 9; 9, string:'''
Returns the sorted high data from the merged top files
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sorted_top; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:collections; 16, identifier:defaultdict; 17, argument_list; 17, 18; 18, identifier:OrderedDict; 19, comment; 20, for_statement; 20, 21; 20, 24; 20, 30; 21, pattern_list; 21, 22; 21, 23; 22, identifier:saltenv; 23, identifier:targets; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:six; 27, identifier:iteritems; 28, argument_list; 28, 29; 29, identifier:top; 30, block; 30, 31; 30, 48; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:sorted_targets; 34, call; 34, 35; 34, 36; 35, identifier:sorted; 36, argument_list; 36, 37; 36, 38; 37, identifier:targets; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, lambda; 40, 41; 40, 43; 41, lambda_parameters; 41, 42; 42, identifier:target; 43, subscript; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:orders; 46, identifier:saltenv; 47, identifier:target; 48, for_statement; 48, 49; 48, 50; 48, 51; 49, identifier:target; 50, identifier:sorted_targets; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 59; 54, subscript; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:sorted_top; 57, identifier:saltenv; 58, identifier:target; 59, subscript; 59, 60; 59, 61; 60, identifier:targets; 61, identifier:target; 62, comment; 63, return_statement; 63, 64; 64, identifier:sorted_top | def sort_top_targets(self, top, orders):
'''
Returns the sorted high data from the merged top files
'''
sorted_top = collections.defaultdict(OrderedDict)
# pylint: disable=cell-var-from-loop
for saltenv, targets in six.iteritems(top):
sorted_targets = sorted(targets,
key=lambda target: orders[saltenv][target])
for target in sorted_targets:
sorted_top[saltenv][target] = targets[target]
# pylint: enable=cell-var-from-loop
return sorted_top |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 47; 2, function_name:subvolume_list; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 3, 38; 3, 41; 3, 44; 4, identifier:path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:parent_id; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:absolute; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ogeneration; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:generation; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:subvolumes; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:uuid; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:parent_uuid; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:sent_subvolume_uuid; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:snapshots; 31, False; 32, default_parameter; 32, 33; 32, 34; 33, identifier:readonly; 34, False; 35, default_parameter; 35, 36; 35, 37; 36, identifier:deleted; 37, False; 38, default_parameter; 38, 39; 38, 40; 39, identifier:generation_cmp; 40, None; 41, default_parameter; 41, 42; 41, 43; 42, identifier:ogeneration_cmp; 43, None; 44, default_parameter; 44, 45; 44, 46; 45, identifier:sort; 46, None; 47, block; 47, 48; 47, 50; 47, 65; 47, 95; 47, 114; 47, 121; 47, 158; 47, 174; 47, 186; 47, 198; 47, 199; 47, 219; 47, 226; 47, 235; 47, 246; 47, 247; 47, 248; 47, 249; 47, 250; 47, 251; 47, 252; 47, 253; 47, 254; 47, 268; 47, 272; 47, 328; 48, expression_statement; 48, 49; 49, string:'''
List the subvolumes present in the filesystem.
path
Mount point for the subvolume
parent_id
Print parent ID
absolute
Print all the subvolumes in the filesystem and distinguish
between absolute and relative path with respect to the given
<path>
ogeneration
Print the ogeneration of the subvolume
generation
Print the generation of the subvolume
subvolumes
Print only subvolumes below specified <path>
uuid
Print the UUID of the subvolume
parent_uuid
Print the parent uuid of subvolumes (and snapshots)
sent_subvolume_uuid
Print the UUID of the sent subvolume, where the subvolume is
the result of a receive operation
snapshots
Only snapshot subvolumes in the filesystem will be listed
readonly
Only readonly subvolumes in the filesystem will be listed
deleted
Only deleted subvolumens that are ye not cleaned
generation_cmp
List subvolumes in the filesystem that its generation is >=,
<= or = value. '+' means >= value, '-' means <= value, If
there is neither '+' nor '-', it means = value
ogeneration_cmp
List subvolumes in the filesystem that its ogeneration is >=,
<= or = value
sort
List subvolumes in order by specified items. Possible values:
* rootid
* gen
* ogen
* path
You can add '+' or '-' in front of each items, '+' means
ascending, '-' means descending. The default is ascending. You
can combite it in a list.
CLI Example:
.. code-block:: bash
salt '*' btrfs.subvolume_list /var/volumes/tmp
salt '*' btrfs.subvolume_list /var/volumes/tmp path=True
salt '*' btrfs.subvolume_list /var/volumes/tmp sort='[-rootid]'
'''; 50, if_statement; 50, 51; 50, 59; 51, boolean_operator:and; 51, 52; 51, 53; 52, identifier:sort; 53, comparison_operator:is; 53, 54; 53, 58; 54, call; 54, 55; 54, 56; 55, identifier:type; 56, argument_list; 56, 57; 57, identifier:sort; 58, identifier:list; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:CommandExecutionError; 63, argument_list; 63, 64; 64, string:'Sort parameter must be a list'; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:valid_sorts; 68, list_comprehension; 68, 69; 68, 77; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, string:''; 72, identifier:join; 73, argument_list; 73, 74; 74, tuple; 74, 75; 74, 76; 75, identifier:order; 76, identifier:attrib; 77, for_in_clause; 77, 78; 77, 81; 78, pattern_list; 78, 79; 78, 80; 79, identifier:order; 80, identifier:attrib; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:itertools; 84, identifier:product; 85, argument_list; 85, 86; 85, 90; 86, tuple; 86, 87; 86, 88; 86, 89; 87, string:'-'; 88, string:''; 89, string:'+'; 90, tuple; 90, 91; 90, 92; 90, 93; 90, 94; 91, string:'rootid'; 92, string:'gen'; 93, string:'ogen'; 94, string:'path'; 95, if_statement; 95, 96; 95, 108; 96, boolean_operator:and; 96, 97; 96, 98; 97, identifier:sort; 98, not_operator; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:all; 101, generator_expression; 101, 102; 101, 105; 102, comparison_operator:in; 102, 103; 102, 104; 103, identifier:s; 104, identifier:valid_sorts; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:s; 107, identifier:sort; 108, block; 108, 109; 109, raise_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:CommandExecutionError; 112, argument_list; 112, 113; 113, string:'Value for sort not recognized'; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:cmd; 117, list:['btrfs', 'subvolume', 'list']; 117, 118; 117, 119; 117, 120; 118, string:'btrfs'; 119, string:'subvolume'; 120, string:'list'; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:params; 124, tuple; 124, 125; 124, 128; 124, 131; 124, 134; 124, 137; 124, 140; 124, 143; 124, 146; 124, 149; 124, 152; 124, 155; 125, tuple; 125, 126; 125, 127; 126, identifier:parent_id; 127, string:'-p'; 128, tuple; 128, 129; 128, 130; 129, identifier:absolute; 130, string:'-a'; 131, tuple; 131, 132; 131, 133; 132, identifier:ogeneration; 133, string:'-c'; 134, tuple; 134, 135; 134, 136; 135, identifier:generation; 136, string:'-g'; 137, tuple; 137, 138; 137, 139; 138, identifier:subvolumes; 139, string:'-o'; 140, tuple; 140, 141; 140, 142; 141, identifier:uuid; 142, string:'-u'; 143, tuple; 143, 144; 143, 145; 144, identifier:parent_uuid; 145, string:'-q'; 146, tuple; 146, 147; 146, 148; 147, identifier:sent_subvolume_uuid; 148, string:'-R'; 149, tuple; 149, 150; 149, 151; 150, identifier:snapshots; 151, string:'-s'; 152, tuple; 152, 153; 152, 154; 153, identifier:readonly; 154, string:'-r'; 155, tuple; 155, 156; 155, 157; 156, identifier:deleted; 157, string:'-d'; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:cmd; 162, identifier:extend; 163, generator_expression; 163, 164; 163, 167; 163, 170; 164, subscript; 164, 165; 164, 166; 165, identifier:p; 166, integer:1; 167, for_in_clause; 167, 168; 167, 169; 168, identifier:p; 169, identifier:params; 170, if_clause; 170, 171; 171, subscript; 171, 172; 171, 173; 172, identifier:p; 173, integer:0; 174, if_statement; 174, 175; 174, 176; 175, identifier:generation_cmp; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:cmd; 181, identifier:extend; 182, argument_list; 182, 183; 183, list:['-G', generation_cmp]; 183, 184; 183, 185; 184, string:'-G'; 185, identifier:generation_cmp; 186, if_statement; 186, 187; 186, 188; 187, identifier:ogeneration_cmp; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:cmd; 193, identifier:extend; 194, argument_list; 194, 195; 195, list:['-C', ogeneration_cmp]; 195, 196; 195, 197; 196, string:'-C'; 197, identifier:ogeneration_cmp; 198, comment; 199, if_statement; 199, 200; 199, 201; 200, identifier:sort; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:cmd; 206, identifier:append; 207, argument_list; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, string:'--sort={}'; 211, identifier:format; 212, argument_list; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, string:','; 216, identifier:join; 217, argument_list; 217, 218; 218, identifier:sort; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:cmd; 223, identifier:append; 224, argument_list; 224, 225; 225, identifier:path; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:res; 229, call; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:__salt__; 232, string:'cmd.run_all'; 233, argument_list; 233, 234; 234, identifier:cmd; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 244; 237, attribute; 237, 238; 237, 243; 238, attribute; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:salt; 241, identifier:utils; 242, identifier:fsutils; 243, identifier:_verify_run; 244, argument_list; 244, 245; 245, identifier:res; 246, comment; 247, comment; 248, comment; 249, comment; 250, comment; 251, comment; 252, comment; 253, comment; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:columns; 257, tuple; 257, 258; 257, 259; 257, 260; 257, 261; 257, 262; 257, 263; 257, 264; 257, 265; 257, 266; 257, 267; 258, string:'ID'; 259, string:'gen'; 260, string:'cgen'; 261, string:'parent'; 262, string:'top level'; 263, string:'otime'; 264, string:'parent_uuid'; 265, string:'received_uuid'; 266, string:'uuid'; 267, string:'path'; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:result; 271, list:[]; 272, for_statement; 272, 273; 272, 274; 272, 281; 273, identifier:line; 274, call; 274, 275; 274, 280; 275, attribute; 275, 276; 275, 279; 276, subscript; 276, 277; 276, 278; 277, identifier:res; 278, string:'stdout'; 279, identifier:splitlines; 280, argument_list; 281, block; 281, 282; 281, 286; 281, 316; 281, 317; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:table; 285, dictionary; 286, for_statement; 286, 287; 286, 288; 286, 289; 287, identifier:key; 288, identifier:columns; 289, block; 289, 290; 289, 303; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 295; 292, pattern_list; 292, 293; 292, 294; 293, identifier:value; 294, identifier:line; 295, call; 295, 296; 295, 297; 296, identifier:_pop; 297, argument_list; 297, 298; 297, 299; 297, 300; 298, identifier:line; 299, identifier:key; 300, comparison_operator:==; 300, 301; 300, 302; 301, identifier:key; 302, string:'path'; 303, if_statement; 303, 304; 303, 305; 304, identifier:value; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 315; 308, subscript; 308, 309; 308, 310; 309, identifier:table; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:key; 313, identifier:lower; 314, argument_list; 315, identifier:value; 316, comment; 317, if_statement; 317, 318; 317, 320; 318, not_operator; 318, 319; 319, identifier:line; 320, block; 320, 321; 321, expression_statement; 321, 322; 322, call; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:result; 325, identifier:append; 326, argument_list; 326, 327; 327, identifier:table; 328, return_statement; 328, 329; 329, identifier:result | def subvolume_list(path, parent_id=False, absolute=False,
ogeneration=False, generation=False,
subvolumes=False, uuid=False, parent_uuid=False,
sent_subvolume_uuid=False, snapshots=False,
readonly=False, deleted=False, generation_cmp=None,
ogeneration_cmp=None, sort=None):
'''
List the subvolumes present in the filesystem.
path
Mount point for the subvolume
parent_id
Print parent ID
absolute
Print all the subvolumes in the filesystem and distinguish
between absolute and relative path with respect to the given
<path>
ogeneration
Print the ogeneration of the subvolume
generation
Print the generation of the subvolume
subvolumes
Print only subvolumes below specified <path>
uuid
Print the UUID of the subvolume
parent_uuid
Print the parent uuid of subvolumes (and snapshots)
sent_subvolume_uuid
Print the UUID of the sent subvolume, where the subvolume is
the result of a receive operation
snapshots
Only snapshot subvolumes in the filesystem will be listed
readonly
Only readonly subvolumes in the filesystem will be listed
deleted
Only deleted subvolumens that are ye not cleaned
generation_cmp
List subvolumes in the filesystem that its generation is >=,
<= or = value. '+' means >= value, '-' means <= value, If
there is neither '+' nor '-', it means = value
ogeneration_cmp
List subvolumes in the filesystem that its ogeneration is >=,
<= or = value
sort
List subvolumes in order by specified items. Possible values:
* rootid
* gen
* ogen
* path
You can add '+' or '-' in front of each items, '+' means
ascending, '-' means descending. The default is ascending. You
can combite it in a list.
CLI Example:
.. code-block:: bash
salt '*' btrfs.subvolume_list /var/volumes/tmp
salt '*' btrfs.subvolume_list /var/volumes/tmp path=True
salt '*' btrfs.subvolume_list /var/volumes/tmp sort='[-rootid]'
'''
if sort and type(sort) is not list:
raise CommandExecutionError('Sort parameter must be a list')
valid_sorts = [
''.join((order, attrib)) for order, attrib in itertools.product(
('-', '', '+'), ('rootid', 'gen', 'ogen', 'path'))
]
if sort and not all(s in valid_sorts for s in sort):
raise CommandExecutionError('Value for sort not recognized')
cmd = ['btrfs', 'subvolume', 'list']
params = ((parent_id, '-p'),
(absolute, '-a'),
(ogeneration, '-c'),
(generation, '-g'),
(subvolumes, '-o'),
(uuid, '-u'),
(parent_uuid, '-q'),
(sent_subvolume_uuid, '-R'),
(snapshots, '-s'),
(readonly, '-r'),
(deleted, '-d'))
cmd.extend(p[1] for p in params if p[0])
if generation_cmp:
cmd.extend(['-G', generation_cmp])
if ogeneration_cmp:
cmd.extend(['-C', ogeneration_cmp])
# We already validated the content of the list
if sort:
cmd.append('--sort={}'.format(','.join(sort)))
cmd.append(path)
res = __salt__['cmd.run_all'](cmd)
salt.utils.fsutils._verify_run(res)
# Parse the output. ID and gen are always at the begining, and
# path is always at the end. There is only one column that
# contains space (top level), and the path value can also have
# spaces. The issue is that we do not know how many spaces do we
# have in the path name, so any classic solution based on split
# will fail.
#
# This list is in order.
columns = ('ID', 'gen', 'cgen', 'parent', 'top level', 'otime',
'parent_uuid', 'received_uuid', 'uuid', 'path')
result = []
for line in res['stdout'].splitlines():
table = {}
for key in columns:
value, line = _pop(line, key, key == 'path')
if value:
table[key.lower()] = value
# If line is not empty here, we are not able to parse it
if not line:
result.append(table)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:diff; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 11; 8, 12; 8, 13; 8, 14; 8, 17; 8, 27; 8, 31; 8, 240; 9, expression_statement; 9, 10; 10, string:'''
Return the DIFFERENCE of the result sets returned by each matching minion
pool
.. versionadded:: 2014.7.0
These pools are determined from the aggregated and sorted results of
a salt command.
This command displays the "diffs" as a series of 2-way differences --
namely the difference between the FIRST displayed minion pool
(according to sort order) and EACH SUBSEQUENT minion pool result set.
Differences are displayed according to the Python ``difflib.unified_diff()``
as in the case of the salt execution module ``file.get_diff``.
This command is submitted via a salt runner using the general form::
salt-run survey.diff [survey_sort=up/down] <target>
<salt-execution-module> <salt-execution-module parameters>
Optionally accept a ``survey_sort=`` parameter. Default:
``survey_sort=down``
CLI Example #1: (Example to display the "differences of files")
.. code-block:: bash
salt-run survey.diff survey_sort=up "*" cp.get_file_str file:///etc/hosts
'''; 11, comment; 12, comment; 13, comment; 14, import_statement; 14, 15; 15, dotted_name; 15, 16; 16, identifier:difflib; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:bulk_ret; 20, call; 20, 21; 20, 22; 21, identifier:_get_pool_results; 22, argument_list; 22, 23; 22, 25; 23, list_splat; 23, 24; 24, identifier:args; 25, dictionary_splat; 25, 26; 26, identifier:kwargs; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:is_first_time; 30, True; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:k; 33, identifier:bulk_ret; 34, block; 34, 35; 34, 42; 34, 49; 34, 56; 34, 73; 34, 103; 34, 119; 34, 124; 34, 137; 34, 149; 34, 166; 34, 176; 34, 193; 34, 197; 34, 231; 34, 236; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:print; 38, argument_list; 38, 39; 39, concatenated_string; 39, 40; 39, 41; 40, string:'minion pool :\n'; 41, string:'------------'; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:print; 45, argument_list; 45, 46; 46, subscript; 46, 47; 46, 48; 47, identifier:k; 48, string:'pool'; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:print; 52, argument_list; 52, 53; 53, concatenated_string; 53, 54; 53, 55; 54, string:'pool size :\n'; 55, string:'----------'; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:print; 59, argument_list; 59, 60; 60, binary_operator:+; 60, 61; 60, 62; 61, string:' '; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:six; 65, identifier:text_type; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, subscript; 70, 71; 70, 72; 71, identifier:k; 72, string:'pool'; 73, if_statement; 73, 74; 73, 75; 74, identifier:is_first_time; 75, block; 75, 76; 75, 80; 75, 87; 75, 98; 75, 102; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:is_first_time; 79, False; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:print; 83, argument_list; 83, 84; 84, concatenated_string; 84, 85; 84, 86; 85, string:'pool result :\n'; 86, string:'------------'; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:print; 90, argument_list; 90, 91; 91, binary_operator:+; 91, 92; 91, 93; 92, string:' '; 93, subscript; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:bulk_ret; 96, integer:0; 97, string:'result'; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:print; 101, argument_list; 102, continue_statement; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:outs; 106, call; 106, 107; 106, 111; 107, attribute; 107, 108; 107, 110; 108, parenthesized_expression; 108, 109; 109, string:'differences from "{0}" results :'; 110, identifier:format; 111, argument_list; 111, 112; 112, subscript; 112, 113; 112, 118; 113, subscript; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:bulk_ret; 116, integer:0; 117, string:'pool'; 118, integer:0; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:print; 122, argument_list; 122, 123; 123, identifier:outs; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:print; 127, argument_list; 127, 128; 128, binary_operator:*; 128, 129; 128, 130; 129, string:'-'; 130, parenthesized_expression; 130, 131; 131, binary_operator:-; 131, 132; 131, 136; 132, call; 132, 133; 132, 134; 133, identifier:len; 134, argument_list; 134, 135; 135, identifier:outs; 136, integer:1; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:from_result; 140, call; 140, 141; 140, 148; 141, attribute; 141, 142; 141, 147; 142, subscript; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:bulk_ret; 145, integer:0; 146, string:'result'; 147, identifier:splitlines; 148, argument_list; 149, for_statement; 149, 150; 149, 151; 149, 159; 150, identifier:i; 151, call; 151, 152; 151, 153; 152, identifier:range; 153, argument_list; 153, 154; 153, 155; 154, integer:0; 155, call; 155, 156; 155, 157; 156, identifier:len; 157, argument_list; 157, 158; 158, identifier:from_result; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, augmented_assignment:+=; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:from_result; 164, identifier:i; 165, string:'\n'; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:to_result; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:k; 173, string:'result'; 174, identifier:splitlines; 175, argument_list; 176, for_statement; 176, 177; 176, 178; 176, 186; 177, identifier:i; 178, call; 178, 179; 178, 180; 179, identifier:range; 180, argument_list; 180, 181; 180, 182; 181, integer:0; 182, call; 182, 183; 182, 184; 183, identifier:len; 184, argument_list; 184, 185; 185, identifier:to_result; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, augmented_assignment:+=; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:to_result; 191, identifier:i; 192, string:'\n'; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:outs; 196, string:''; 197, expression_statement; 197, 198; 198, augmented_assignment:+=; 198, 199; 198, 200; 199, identifier:outs; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, string:''; 203, identifier:join; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:difflib; 208, identifier:unified_diff; 209, argument_list; 209, 210; 209, 211; 209, 212; 209, 221; 209, 228; 210, identifier:from_result; 211, identifier:to_result; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:fromfile; 214, subscript; 214, 215; 214, 220; 215, subscript; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:bulk_ret; 218, integer:0; 219, string:'pool'; 220, integer:0; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:tofile; 223, subscript; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:k; 226, string:'pool'; 227, integer:0; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:n; 230, integer:0; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:print; 234, argument_list; 234, 235; 235, identifier:outs; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:print; 239, argument_list; 240, return_statement; 240, 241; 241, identifier:bulk_ret | def diff(*args, **kwargs):
'''
Return the DIFFERENCE of the result sets returned by each matching minion
pool
.. versionadded:: 2014.7.0
These pools are determined from the aggregated and sorted results of
a salt command.
This command displays the "diffs" as a series of 2-way differences --
namely the difference between the FIRST displayed minion pool
(according to sort order) and EACH SUBSEQUENT minion pool result set.
Differences are displayed according to the Python ``difflib.unified_diff()``
as in the case of the salt execution module ``file.get_diff``.
This command is submitted via a salt runner using the general form::
salt-run survey.diff [survey_sort=up/down] <target>
<salt-execution-module> <salt-execution-module parameters>
Optionally accept a ``survey_sort=`` parameter. Default:
``survey_sort=down``
CLI Example #1: (Example to display the "differences of files")
.. code-block:: bash
salt-run survey.diff survey_sort=up "*" cp.get_file_str file:///etc/hosts
'''
# TODO: The salt execution module "cp.get_file_str file:///..." is a
# non-obvious way to display the differences between files using
# survey.diff . A more obvious method needs to be found or developed.
import difflib
bulk_ret = _get_pool_results(*args, **kwargs)
is_first_time = True
for k in bulk_ret:
print('minion pool :\n'
'------------')
print(k['pool'])
print('pool size :\n'
'----------')
print(' ' + six.text_type(len(k['pool'])))
if is_first_time:
is_first_time = False
print('pool result :\n'
'------------')
print(' ' + bulk_ret[0]['result'])
print()
continue
outs = ('differences from "{0}" results :').format(
bulk_ret[0]['pool'][0])
print(outs)
print('-' * (len(outs) - 1))
from_result = bulk_ret[0]['result'].splitlines()
for i in range(0, len(from_result)):
from_result[i] += '\n'
to_result = k['result'].splitlines()
for i in range(0, len(to_result)):
to_result[i] += '\n'
outs = ''
outs += ''.join(difflib.unified_diff(from_result,
to_result,
fromfile=bulk_ret[0]['pool'][0],
tofile=k['pool'][0],
n=0))
print(outs)
print()
return bulk_ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_get_pool_results; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 11; 8, 12; 8, 13; 8, 14; 8, 15; 8, 18; 8, 24; 8, 30; 8, 34; 8, 44; 8, 50; 8, 60; 8, 71; 8, 98; 8, 111; 8, 152; 8, 153; 8, 230; 8, 234; 8, 267; 9, expression_statement; 9, 10; 10, string:'''
A helper function which returns a dictionary of minion pools along with
their matching result sets.
Useful for developing other "survey style" functions.
Optionally accepts a "survey_sort=up" or "survey_sort=down" kwargs for
specifying sort order.
Because the kwargs namespace of the "salt" and "survey" command are shared,
the name "survey_sort" was chosen to help avoid option conflicts.
'''; 11, comment; 12, comment; 13, comment; 14, comment; 15, import_statement; 15, 16; 16, dotted_name; 16, 17; 17, identifier:hashlib; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:tgt; 21, subscript; 21, 22; 21, 23; 22, identifier:args; 23, integer:0; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:cmd; 27, subscript; 27, 28; 27, 29; 28, identifier:args; 29, integer:1; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:ret; 33, dictionary; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:sort; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:kwargs; 40, identifier:pop; 41, argument_list; 41, 42; 41, 43; 42, string:'survey_sort'; 43, string:'down'; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:direction; 47, comparison_operator:!=; 47, 48; 47, 49; 48, identifier:sort; 49, string:'up'; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:tgt_type; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:kwargs; 56, identifier:pop; 57, argument_list; 57, 58; 57, 59; 58, string:'tgt_type'; 59, string:'compound'; 60, if_statement; 60, 61; 60, 66; 61, comparison_operator:not; 61, 62; 61, 63; 62, identifier:tgt_type; 63, list:['compound', 'pcre']; 63, 64; 63, 65; 64, string:'compound'; 65, string:'pcre'; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:tgt_type; 70, string:'compound'; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:kwargs_passthru; 74, call; 74, 75; 74, 76; 75, identifier:dict; 76, generator_expression; 76, 77; 76, 82; 76, 90; 77, tuple; 77, 78; 77, 79; 78, identifier:k; 79, subscript; 79, 80; 79, 81; 80, identifier:kwargs; 81, identifier:k; 82, for_in_clause; 82, 83; 82, 84; 83, identifier:k; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:six; 87, identifier:iterkeys; 88, argument_list; 88, 89; 89, identifier:kwargs; 90, if_clause; 90, 91; 91, not_operator; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:k; 95, identifier:startswith; 96, argument_list; 96, 97; 97, string:'_'; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:client; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:salt; 105, identifier:client; 106, identifier:get_local_client; 107, argument_list; 107, 108; 108, subscript; 108, 109; 108, 110; 109, identifier:__opts__; 110, string:'conf_file'; 111, try_statement; 111, 112; 111, 139; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:minions; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:client; 119, identifier:cmd; 120, argument_list; 120, 121; 120, 122; 120, 123; 120, 128; 120, 133; 120, 136; 121, identifier:tgt; 122, identifier:cmd; 123, subscript; 123, 124; 123, 125; 124, identifier:args; 125, slice; 125, 126; 125, 127; 126, integer:2; 127, colon; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:timeout; 130, subscript; 130, 131; 130, 132; 131, identifier:__opts__; 132, string:'timeout'; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:tgt_type; 135, identifier:tgt_type; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:kwarg; 138, identifier:kwargs_passthru; 139, except_clause; 139, 140; 139, 144; 140, as_pattern; 140, 141; 140, 142; 141, identifier:SaltClientError; 142, as_pattern_target; 142, 143; 143, identifier:client_error; 144, block; 144, 145; 144, 150; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:print; 148, argument_list; 148, 149; 149, identifier:client_error; 150, return_statement; 150, 151; 151, identifier:ret; 152, comment; 153, for_statement; 153, 154; 153, 155; 153, 159; 154, identifier:minion; 155, call; 155, 156; 155, 157; 156, identifier:sorted; 157, argument_list; 157, 158; 158, identifier:minions; 159, block; 159, 160; 159, 185; 159, 219; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:digest; 163, call; 163, 164; 163, 184; 164, attribute; 164, 165; 164, 183; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:hashlib; 168, identifier:sha256; 169, argument_list; 169, 170; 170, call; 170, 171; 170, 181; 171, attribute; 171, 172; 171, 180; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:six; 175, identifier:text_type; 176, argument_list; 176, 177; 177, subscript; 177, 178; 177, 179; 178, identifier:minions; 179, identifier:minion; 180, identifier:encode; 181, argument_list; 181, 182; 182, identifier:__salt_system_encoding__; 183, identifier:hexdigest; 184, argument_list; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:not; 186, 187; 186, 188; 187, identifier:digest; 188, identifier:ret; 189, block; 189, 190; 189, 196; 189, 204; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:ret; 194, identifier:digest; 195, dictionary; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 203; 198, subscript; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:ret; 201, identifier:digest; 202, string:'pool'; 203, list:[]; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 211; 206, subscript; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:ret; 209, identifier:digest; 210, string:'result'; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:six; 214, identifier:text_type; 215, argument_list; 215, 216; 216, subscript; 216, 217; 216, 218; 217, identifier:minions; 218, identifier:minion; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 228; 221, attribute; 221, 222; 221, 227; 222, subscript; 222, 223; 222, 226; 223, subscript; 223, 224; 223, 225; 224, identifier:ret; 225, identifier:digest; 226, string:'pool'; 227, identifier:append; 228, argument_list; 228, 229; 229, identifier:minion; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:sorted_ret; 233, list:[]; 234, for_statement; 234, 235; 234, 236; 234, 256; 234, 257; 235, identifier:k; 236, call; 236, 237; 236, 238; 237, identifier:sorted; 238, argument_list; 238, 239; 238, 240; 238, 253; 239, identifier:ret; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:key; 242, lambda; 242, 243; 242, 245; 243, lambda_parameters; 243, 244; 244, identifier:k; 245, call; 245, 246; 245, 247; 246, identifier:len; 247, argument_list; 247, 248; 248, subscript; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:ret; 251, identifier:k; 252, string:'pool'; 253, keyword_argument; 253, 254; 253, 255; 254, identifier:reverse; 255, identifier:direction; 256, comment; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:sorted_ret; 262, identifier:append; 263, argument_list; 263, 264; 264, subscript; 264, 265; 264, 266; 265, identifier:ret; 266, identifier:k; 267, return_statement; 267, 268; 268, identifier:sorted_ret | def _get_pool_results(*args, **kwargs):
'''
A helper function which returns a dictionary of minion pools along with
their matching result sets.
Useful for developing other "survey style" functions.
Optionally accepts a "survey_sort=up" or "survey_sort=down" kwargs for
specifying sort order.
Because the kwargs namespace of the "salt" and "survey" command are shared,
the name "survey_sort" was chosen to help avoid option conflicts.
'''
# TODO: the option "survey.sort=" would be preferred for namespace
# separation but the kwargs parser for the salt-run command seems to
# improperly pass the options containing a "." in them for later modules to
# process. The "_" is used here instead.
import hashlib
tgt = args[0]
cmd = args[1]
ret = {}
sort = kwargs.pop('survey_sort', 'down')
direction = sort != 'up'
tgt_type = kwargs.pop('tgt_type', 'compound')
if tgt_type not in ['compound', 'pcre']:
tgt_type = 'compound'
kwargs_passthru = dict((k, kwargs[k]) for k in six.iterkeys(kwargs) if not k.startswith('_'))
client = salt.client.get_local_client(__opts__['conf_file'])
try:
minions = client.cmd(tgt, cmd, args[2:], timeout=__opts__['timeout'], tgt_type=tgt_type, kwarg=kwargs_passthru)
except SaltClientError as client_error:
print(client_error)
return ret
# hash minion return values as a string
for minion in sorted(minions):
digest = hashlib.sha256(six.text_type(minions[minion]).encode(__salt_system_encoding__)).hexdigest()
if digest not in ret:
ret[digest] = {}
ret[digest]['pool'] = []
ret[digest]['result'] = six.text_type(minions[minion])
ret[digest]['pool'].append(minion)
sorted_ret = []
for k in sorted(ret, key=lambda k: len(ret[k]['pool']), reverse=direction):
# return aggregated results, sorted by size of the hash pool
sorted_ret.append(ret[k])
return sorted_ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:list_; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:name; 6, None; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 12; 9, 18; 9, 19; 9, 20; 9, 30; 9, 47; 9, 48; 9, 49; 9, 50; 9, 62; 9, 70; 9, 71; 9, 72; 9, 77; 9, 81; 9, 82; 9, 98; 9, 126; 9, 146; 9, 156; 9, 191; 9, 218; 9, 219; 9, 247; 9, 351; 10, expression_statement; 10, 11; 11, string:'''
Return a list of all datasets or a specified dataset on the system and the
values of their used, available, referenced, and mountpoint properties.
name : string
name of dataset, volume, or snapshot
recursive : boolean
recursively list children
depth : int
limit recursion to depth
properties : string
comma-separated list of properties to list, the name property will always be added
type : string
comma-separated list of types to display, where type is one of
filesystem, snapshot, volume, bookmark, or all.
sort : string
property to sort on (default = name)
order : string [ascending|descending]
sort order (default = ascending)
parsable : boolean
display numbers in parsable (exact) values
.. versionadded:: 2018.3.0
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' zfs.list
salt '*' zfs.list myzpool/mydataset [recursive=True|False]
salt '*' zfs.list myzpool/mydataset properties="sharenfs,mountpoint"
'''; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:ret; 15, call; 15, 16; 15, 17; 16, identifier:OrderedDict; 17, argument_list; 18, comment; 19, comment; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:properties; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:kwargs; 26, identifier:get; 27, argument_list; 27, 28; 27, 29; 28, string:'properties'; 29, string:'used,avail,refer,mountpoint'; 30, if_statement; 30, 31; 30, 37; 31, not_operator; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:properties; 36, identifier:list; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:properties; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:properties; 44, identifier:split; 45, argument_list; 45, 46; 46, string:','; 47, comment; 48, comment; 49, comment; 50, while_statement; 50, 51; 50, 54; 51, comparison_operator:in; 51, 52; 51, 53; 52, string:'name'; 53, identifier:properties; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:properties; 59, identifier:remove; 60, argument_list; 60, 61; 61, string:'name'; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:properties; 66, identifier:insert; 67, argument_list; 67, 68; 67, 69; 68, integer:0; 69, string:'name'; 70, comment; 71, comment; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:flags; 75, list:['-H']; 75, 76; 76, string:'-H'; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:opts; 80, dictionary; 81, comment; 82, if_statement; 82, 83; 82, 90; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:kwargs; 86, identifier:get; 87, argument_list; 87, 88; 87, 89; 88, string:'recursive'; 89, False; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:flags; 95, identifier:append; 96, argument_list; 96, 97; 97, string:'-r'; 98, if_statement; 98, 99; 98, 114; 99, boolean_operator:and; 99, 100; 99, 107; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:kwargs; 103, identifier:get; 104, argument_list; 104, 105; 104, 106; 105, string:'recursive'; 106, False; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:kwargs; 110, identifier:get; 111, argument_list; 111, 112; 111, 113; 112, string:'depth'; 113, False; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:opts; 119, string:'-d'; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:kwargs; 123, identifier:get; 124, argument_list; 124, 125; 125, string:'depth'; 126, if_statement; 126, 127; 126, 134; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:kwargs; 130, identifier:get; 131, argument_list; 131, 132; 131, 133; 132, string:'type'; 133, False; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:opts; 139, string:'-t'; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:kwargs; 143, identifier:get; 144, argument_list; 144, 145; 145, string:'type'; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:kwargs_sort; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:kwargs; 152, identifier:get; 153, argument_list; 153, 154; 153, 155; 154, string:'sort'; 155, False; 156, if_statement; 156, 157; 156, 162; 157, boolean_operator:and; 157, 158; 157, 159; 158, identifier:kwargs_sort; 159, comparison_operator:in; 159, 160; 159, 161; 160, identifier:kwargs_sort; 161, identifier:properties; 162, block; 162, 163; 163, if_statement; 163, 164; 163, 176; 163, 183; 164, call; 164, 165; 164, 174; 165, attribute; 165, 166; 165, 173; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:kwargs; 169, identifier:get; 170, argument_list; 170, 171; 170, 172; 171, string:'order'; 172, string:'ascending'; 173, identifier:startswith; 174, argument_list; 174, 175; 175, string:'a'; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:opts; 181, string:'-s'; 182, identifier:kwargs_sort; 183, else_clause; 183, 184; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:opts; 189, string:'-S'; 190, identifier:kwargs_sort; 191, if_statement; 191, 192; 191, 197; 191, 198; 191, 210; 192, call; 192, 193; 192, 194; 193, identifier:isinstance; 194, argument_list; 194, 195; 194, 196; 195, identifier:properties; 196, identifier:list; 197, comment; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:opts; 203, string:'-o'; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, string:','; 207, identifier:join; 208, argument_list; 208, 209; 209, identifier:properties; 210, else_clause; 210, 211; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:opts; 216, string:'-o'; 217, identifier:properties; 218, comment; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:res; 222, call; 222, 223; 222, 226; 223, subscript; 223, 224; 223, 225; 224, identifier:__salt__; 225, string:'cmd.run_all'; 226, argument_list; 226, 227; 226, 244; 227, call; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:__utils__; 230, string:'zfs.zfs_command'; 231, argument_list; 231, 232; 231, 235; 231, 238; 231, 241; 232, keyword_argument; 232, 233; 232, 234; 233, identifier:command; 234, string:'list'; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:flags; 237, identifier:flags; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:opts; 240, identifier:opts; 241, keyword_argument; 241, 242; 241, 243; 242, identifier:target; 243, identifier:name; 244, keyword_argument; 244, 245; 244, 246; 245, identifier:python_shell; 246, False; 247, if_statement; 247, 248; 247, 253; 247, 342; 248, comparison_operator:==; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:res; 251, string:'retcode'; 252, integer:0; 253, block; 253, 254; 254, for_statement; 254, 255; 254, 256; 254, 263; 255, identifier:ds; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, subscript; 258, 259; 258, 260; 259, identifier:res; 260, string:'stdout'; 261, identifier:splitlines; 262, argument_list; 263, block; 263, 264; 263, 326; 263, 334; 264, if_statement; 264, 265; 264, 272; 264, 297; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:kwargs; 268, identifier:get; 269, argument_list; 269, 270; 269, 271; 270, string:'parsable'; 271, True; 272, block; 272, 273; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:ds_data; 276, call; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:__utils__; 279, string:'zfs.from_auto_dict'; 280, argument_list; 280, 281; 281, call; 281, 282; 281, 283; 282, identifier:OrderedDict; 283, argument_list; 283, 284; 284, call; 284, 285; 284, 286; 285, identifier:list; 286, argument_list; 286, 287; 287, call; 287, 288; 287, 289; 288, identifier:zip; 289, argument_list; 289, 290; 289, 291; 290, identifier:properties; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:ds; 294, identifier:split; 295, argument_list; 295, 296; 296, string:"\t"; 297, else_clause; 297, 298; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:ds_data; 302, call; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:__utils__; 305, string:'zfs.to_auto_dict'; 306, argument_list; 306, 307; 306, 323; 307, call; 307, 308; 307, 309; 308, identifier:OrderedDict; 309, argument_list; 309, 310; 310, call; 310, 311; 310, 312; 311, identifier:list; 312, argument_list; 312, 313; 313, call; 313, 314; 313, 315; 314, identifier:zip; 315, argument_list; 315, 316; 315, 317; 316, identifier:properties; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:ds; 320, identifier:split; 321, argument_list; 321, 322; 322, string:"\t"; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:convert_to_human; 325, True; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 333; 328, subscript; 328, 329; 328, 330; 329, identifier:ret; 330, subscript; 330, 331; 330, 332; 331, identifier:ds_data; 332, string:'name'; 333, identifier:ds_data; 334, delete_statement; 334, 335; 335, subscript; 335, 336; 335, 341; 336, subscript; 336, 337; 336, 338; 337, identifier:ret; 338, subscript; 338, 339; 338, 340; 339, identifier:ds_data; 340, string:'name'; 341, string:'name'; 342, else_clause; 342, 343; 343, block; 343, 344; 344, return_statement; 344, 345; 345, call; 345, 346; 345, 349; 346, subscript; 346, 347; 346, 348; 347, identifier:__utils__; 348, string:'zfs.parse_command_result'; 349, argument_list; 349, 350; 350, identifier:res; 351, return_statement; 351, 352; 352, identifier:ret | def list_(name=None, **kwargs):
'''
Return a list of all datasets or a specified dataset on the system and the
values of their used, available, referenced, and mountpoint properties.
name : string
name of dataset, volume, or snapshot
recursive : boolean
recursively list children
depth : int
limit recursion to depth
properties : string
comma-separated list of properties to list, the name property will always be added
type : string
comma-separated list of types to display, where type is one of
filesystem, snapshot, volume, bookmark, or all.
sort : string
property to sort on (default = name)
order : string [ascending|descending]
sort order (default = ascending)
parsable : boolean
display numbers in parsable (exact) values
.. versionadded:: 2018.3.0
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' zfs.list
salt '*' zfs.list myzpool/mydataset [recursive=True|False]
salt '*' zfs.list myzpool/mydataset properties="sharenfs,mountpoint"
'''
ret = OrderedDict()
## update properties
# NOTE: properties should be a list
properties = kwargs.get('properties', 'used,avail,refer,mountpoint')
if not isinstance(properties, list):
properties = properties.split(',')
# NOTE: name should be first property
# we loop here because there 'name' can be in the list
# multiple times.
while 'name' in properties:
properties.remove('name')
properties.insert(0, 'name')
## Configure command
# NOTE: initialize the defaults
flags = ['-H']
opts = {}
# NOTE: set extra config from kwargs
if kwargs.get('recursive', False):
flags.append('-r')
if kwargs.get('recursive', False) and kwargs.get('depth', False):
opts['-d'] = kwargs.get('depth')
if kwargs.get('type', False):
opts['-t'] = kwargs.get('type')
kwargs_sort = kwargs.get('sort', False)
if kwargs_sort and kwargs_sort in properties:
if kwargs.get('order', 'ascending').startswith('a'):
opts['-s'] = kwargs_sort
else:
opts['-S'] = kwargs_sort
if isinstance(properties, list):
# NOTE: There can be only one -o and it takes a comma-seperated list
opts['-o'] = ','.join(properties)
else:
opts['-o'] = properties
## parse zfs list
res = __salt__['cmd.run_all'](
__utils__['zfs.zfs_command'](
command='list',
flags=flags,
opts=opts,
target=name,
),
python_shell=False,
)
if res['retcode'] == 0:
for ds in res['stdout'].splitlines():
if kwargs.get('parsable', True):
ds_data = __utils__['zfs.from_auto_dict'](
OrderedDict(list(zip(properties, ds.split("\t")))),
)
else:
ds_data = __utils__['zfs.to_auto_dict'](
OrderedDict(list(zip(properties, ds.split("\t")))),
convert_to_human=True,
)
ret[ds_data['name']] = ds_data
del ret[ds_data['name']]['name']
else:
return __utils__['zfs.parse_command_result'](res)
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:list_users; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:order_by; 6, string:'id'; 7, block; 7, 8; 7, 10; 7, 14; 7, 28; 7, 37; 7, 45; 7, 114; 8, expression_statement; 8, 9; 9, string:'''
Show all users for this company.
CLI Example:
salt myminion bamboohr.list_users
By default, the return data will be keyed by ID. However, it can be ordered
by any other field. Keep in mind that if the field that is chosen contains
duplicate values (i.e., location is used, for a company which only has one
location), then each duplicate value will be overwritten by the previous.
Therefore, it is advisable to only sort by fields that are guaranteed to be
unique.
CLI Examples:
salt myminion bamboohr.list_users order_by=id
salt myminion bamboohr.list_users order_by=email
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:ret; 13, dictionary; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 19; 16, pattern_list; 16, 17; 16, 18; 17, identifier:status; 18, identifier:result; 19, call; 19, 20; 19, 21; 20, identifier:_query; 21, argument_list; 21, 22; 21, 25; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:action; 24, string:'meta'; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:command; 27, string:'users'; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:root; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:ET; 34, identifier:fromstring; 35, argument_list; 35, 36; 36, identifier:result; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:users; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:root; 43, identifier:getchildren; 44, argument_list; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:user; 47, identifier:users; 48, block; 48, 49; 48, 53; 48, 57; 48, 88; 48, 106; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:user_id; 52, None; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:user_ret; 56, dictionary; 57, for_statement; 57, 58; 57, 59; 57, 64; 58, identifier:item; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:user; 62, identifier:items; 63, argument_list; 64, block; 64, 65; 64, 75; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 72; 67, subscript; 67, 68; 67, 69; 68, identifier:user_ret; 69, subscript; 69, 70; 69, 71; 70, identifier:item; 71, integer:0; 72, subscript; 72, 73; 72, 74; 73, identifier:item; 74, integer:1; 75, if_statement; 75, 76; 75, 81; 76, comparison_operator:==; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:item; 79, integer:0; 80, string:'id'; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:user_id; 85, subscript; 85, 86; 85, 87; 86, identifier:item; 87, integer:1; 88, for_statement; 88, 89; 88, 90; 88, 95; 89, identifier:item; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:user; 93, identifier:getchildren; 94, argument_list; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 103; 98, subscript; 98, 99; 98, 100; 99, identifier:user_ret; 100, attribute; 100, 101; 100, 102; 101, identifier:item; 102, identifier:tag; 103, attribute; 103, 104; 103, 105; 104, identifier:item; 105, identifier:text; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 113; 108, subscript; 108, 109; 108, 110; 109, identifier:ret; 110, subscript; 110, 111; 110, 112; 111, identifier:user_ret; 112, identifier:order_by; 113, identifier:user_ret; 114, return_statement; 114, 115; 115, identifier:ret | def list_users(order_by='id'):
'''
Show all users for this company.
CLI Example:
salt myminion bamboohr.list_users
By default, the return data will be keyed by ID. However, it can be ordered
by any other field. Keep in mind that if the field that is chosen contains
duplicate values (i.e., location is used, for a company which only has one
location), then each duplicate value will be overwritten by the previous.
Therefore, it is advisable to only sort by fields that are guaranteed to be
unique.
CLI Examples:
salt myminion bamboohr.list_users order_by=id
salt myminion bamboohr.list_users order_by=email
'''
ret = {}
status, result = _query(action='meta', command='users')
root = ET.fromstring(result)
users = root.getchildren()
for user in users:
user_id = None
user_ret = {}
for item in user.items():
user_ret[item[0]] = item[1]
if item[0] == 'id':
user_id = item[1]
for item in user.getchildren():
user_ret[item.tag] = item.text
ret[user_ret[order_by]] = user_ret
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:key_value; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:minion_id; 5, identifier:pillar; 6, comment; 7, default_parameter; 7, 8; 7, 9; 8, identifier:pillar_key; 9, string:'redis_pillar'; 10, block; 10, 11; 10, 13; 10, 14; 10, 23; 10, 136; 10, 137; 11, expression_statement; 11, 12; 12, string:'''
Looks for key in redis matching minion_id, returns a structure based on the
data type of the redis key. String for string type, dict for hash type and
lists for lists, sets and sorted sets.
pillar_key
Pillar key to return data into
'''; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:key_type; 17, call; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:__salt__; 20, string:'redis.key_type'; 21, argument_list; 21, 22; 22, identifier:minion_id; 23, if_statement; 23, 24; 23, 27; 23, 38; 23, 53; 23, 87; 23, 102; 24, comparison_operator:==; 24, 25; 24, 26; 25, identifier:key_type; 26, string:'string'; 27, block; 27, 28; 28, return_statement; 28, 29; 29, dictionary; 29, 30; 30, pair; 30, 31; 30, 32; 31, identifier:pillar_key; 32, call; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:__salt__; 35, string:'redis.get_key'; 36, argument_list; 36, 37; 37, identifier:minion_id; 38, elif_clause; 38, 39; 38, 42; 39, comparison_operator:==; 39, 40; 39, 41; 40, identifier:key_type; 41, string:'hash'; 42, block; 42, 43; 43, return_statement; 43, 44; 44, dictionary; 44, 45; 45, pair; 45, 46; 45, 47; 46, identifier:pillar_key; 47, call; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:__salt__; 50, string:'redis.hgetall'; 51, argument_list; 51, 52; 52, identifier:minion_id; 53, elif_clause; 53, 54; 53, 57; 54, comparison_operator:==; 54, 55; 54, 56; 55, identifier:key_type; 56, string:'list'; 57, block; 57, 58; 57, 67; 57, 73; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:list_size; 61, call; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:__salt__; 64, string:'redis.llen'; 65, argument_list; 65, 66; 66, identifier:minion_id; 67, if_statement; 67, 68; 67, 70; 68, not_operator; 68, 69; 69, identifier:list_size; 70, block; 70, 71; 71, return_statement; 71, 72; 72, dictionary; 73, return_statement; 73, 74; 74, dictionary; 74, 75; 75, pair; 75, 76; 75, 77; 76, identifier:pillar_key; 77, call; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:__salt__; 80, string:'redis.lrange'; 81, argument_list; 81, 82; 81, 83; 81, 84; 82, identifier:minion_id; 83, integer:0; 84, binary_operator:-; 84, 85; 84, 86; 85, identifier:list_size; 86, integer:1; 87, elif_clause; 87, 88; 87, 91; 88, comparison_operator:==; 88, 89; 88, 90; 89, identifier:key_type; 90, string:'set'; 91, block; 91, 92; 92, return_statement; 92, 93; 93, dictionary; 93, 94; 94, pair; 94, 95; 94, 96; 95, identifier:pillar_key; 96, call; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:__salt__; 99, string:'redis.smembers'; 100, argument_list; 100, 101; 101, identifier:minion_id; 102, elif_clause; 102, 103; 102, 106; 103, comparison_operator:==; 103, 104; 103, 105; 104, identifier:key_type; 105, string:'zset'; 106, block; 106, 107; 106, 116; 106, 122; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:set_size; 110, call; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:__salt__; 113, string:'redis.zcard'; 114, argument_list; 114, 115; 115, identifier:minion_id; 116, if_statement; 116, 117; 116, 119; 117, not_operator; 117, 118; 118, identifier:set_size; 119, block; 119, 120; 120, return_statement; 120, 121; 121, dictionary; 122, return_statement; 122, 123; 123, dictionary; 123, 124; 124, pair; 124, 125; 124, 126; 125, identifier:pillar_key; 126, call; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:__salt__; 129, string:'redis.zrange'; 130, argument_list; 130, 131; 130, 132; 130, 133; 131, identifier:minion_id; 132, integer:0; 133, binary_operator:-; 133, 134; 133, 135; 134, identifier:set_size; 135, integer:1; 136, comment; 137, return_statement; 137, 138; 138, dictionary | def key_value(minion_id,
pillar, # pylint: disable=W0613
pillar_key='redis_pillar'):
'''
Looks for key in redis matching minion_id, returns a structure based on the
data type of the redis key. String for string type, dict for hash type and
lists for lists, sets and sorted sets.
pillar_key
Pillar key to return data into
'''
# Identify key type and process as needed based on that type
key_type = __salt__['redis.key_type'](minion_id)
if key_type == 'string':
return {pillar_key: __salt__['redis.get_key'](minion_id)}
elif key_type == 'hash':
return {pillar_key: __salt__['redis.hgetall'](minion_id)}
elif key_type == 'list':
list_size = __salt__['redis.llen'](minion_id)
if not list_size:
return {}
return {pillar_key: __salt__['redis.lrange'](minion_id, 0,
list_size - 1)}
elif key_type == 'set':
return {pillar_key: __salt__['redis.smembers'](minion_id)}
elif key_type == 'zset':
set_size = __salt__['redis.zcard'](minion_id)
if not set_size:
return {}
return {pillar_key: __salt__['redis.zrange'](minion_id, 0,
set_size - 1)}
# Return nothing for unhandled types
return {} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_cmp_version; 3, parameters; 3, 4; 3, 5; 4, identifier:item1; 5, identifier:item2; 6, block; 6, 7; 6, 9; 6, 16; 6, 23; 6, 31; 6, 38; 7, expression_statement; 7, 8; 8, string:'''
Compare function for package version sorting
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:vers1; 12, call; 12, 13; 12, 14; 13, identifier:_LooseVersion; 14, argument_list; 14, 15; 15, identifier:item1; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:vers2; 19, call; 19, 20; 19, 21; 20, identifier:_LooseVersion; 21, argument_list; 21, 22; 22, identifier:item2; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:<; 24, 25; 24, 26; 25, identifier:vers1; 26, identifier:vers2; 27, block; 27, 28; 28, return_statement; 28, 29; 29, unary_operator:-; 29, 30; 30, integer:1; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:>; 32, 33; 32, 34; 33, identifier:vers1; 34, identifier:vers2; 35, block; 35, 36; 36, return_statement; 36, 37; 37, integer:1; 38, return_statement; 38, 39; 39, integer:0 | def _cmp_version(item1, item2):
'''
Compare function for package version sorting
'''
vers1 = _LooseVersion(item1)
vers2 = _LooseVersion(item2)
if vers1 < vers2:
return -1
if vers1 > vers2:
return 1
return 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:list_snapshots; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:config_path; 6, identifier:_DEFAULT_CONFIG_PATH; 7, default_parameter; 7, 8; 7, 9; 8, identifier:sort_by_time; 9, False; 10, block; 10, 11; 10, 13; 10, 18; 10, 31; 10, 50; 10, 57; 10, 73; 10, 84; 11, expression_statement; 11, 12; 12, string:'''
Get a list of all the existing snapshots.
:param str config_path: The path to the configuration file for the aptly instance.
:param bool sort_by_time: Whether to sort by creation time instead of by name.
:return: A list of the snapshot names.
:rtype: list
CLI Example:
.. code-block:: bash
salt '*' aptly.list_snapshots
'''; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:_validate_config; 16, argument_list; 16, 17; 17, identifier:config_path; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:cmd; 21, list:['snapshot', 'list', '-config={}'.format(config_path), '-raw=true']; 21, 22; 21, 23; 21, 24; 21, 30; 22, string:'snapshot'; 23, string:'list'; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, string:'-config={}'; 27, identifier:format; 28, argument_list; 28, 29; 29, identifier:config_path; 30, string:'-raw=true'; 31, if_statement; 31, 32; 31, 33; 31, 41; 32, identifier:sort_by_time; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:cmd; 38, identifier:append; 39, argument_list; 39, 40; 40, string:'-sort=time'; 41, else_clause; 41, 42; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:cmd; 47, identifier:append; 48, argument_list; 48, 49; 49, string:'-sort=name'; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:cmd_ret; 53, call; 53, 54; 53, 55; 54, identifier:_cmd_run; 55, argument_list; 55, 56; 56, identifier:cmd; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:ret; 60, list_comprehension; 60, 61; 60, 66; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:line; 64, identifier:strip; 65, argument_list; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:line; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:cmd_ret; 71, identifier:splitlines; 72, argument_list; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:log; 77, identifier:debug; 78, argument_list; 78, 79; 78, 80; 79, string:'Found snapshots: %s'; 80, call; 80, 81; 80, 82; 81, identifier:len; 82, argument_list; 82, 83; 83, identifier:ret; 84, return_statement; 84, 85; 85, identifier:ret | def list_snapshots(config_path=_DEFAULT_CONFIG_PATH, sort_by_time=False):
'''
Get a list of all the existing snapshots.
:param str config_path: The path to the configuration file for the aptly instance.
:param bool sort_by_time: Whether to sort by creation time instead of by name.
:return: A list of the snapshot names.
:rtype: list
CLI Example:
.. code-block:: bash
salt '*' aptly.list_snapshots
'''
_validate_config(config_path)
cmd = ['snapshot', 'list', '-config={}'.format(config_path), '-raw=true']
if sort_by_time:
cmd.append('-sort=time')
else:
cmd.append('-sort=name')
cmd_ret = _cmd_run(cmd)
ret = [line.strip() for line in cmd_ret.splitlines()]
log.debug('Found snapshots: %s', len(ret))
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:render_value; 3, parameters; 3, 4; 4, identifier:value; 5, block; 5, 6; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 14; 8, 32; 8, 76; 9, call; 9, 10; 9, 11; 10, identifier:isinstance; 11, argument_list; 11, 12; 11, 13; 12, identifier:value; 13, identifier:list; 14, block; 14, 15; 15, return_statement; 15, 16; 16, binary_operator:+; 16, 17; 16, 31; 17, binary_operator:+; 17, 18; 17, 19; 18, string:'['; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, string:', '; 22, identifier:join; 23, generator_expression; 23, 24; 23, 28; 24, call; 24, 25; 24, 26; 25, identifier:render_value; 26, argument_list; 26, 27; 27, identifier:v; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:v; 30, identifier:value; 31, string:']'; 32, elif_clause; 32, 33; 32, 38; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:value; 37, identifier:dict; 38, block; 38, 39; 39, return_statement; 39, 40; 40, parenthesized_expression; 40, 41; 41, binary_operator:+; 41, 42; 41, 75; 42, binary_operator:+; 42, 43; 42, 44; 43, string:'{'; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, string:', '; 47, identifier:join; 48, generator_expression; 48, 49; 48, 63; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, string:'{k!r}: {v}'; 52, identifier:format; 53, argument_list; 53, 54; 53, 57; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:k; 56, identifier:k; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:v; 59, call; 59, 60; 59, 61; 60, identifier:render_value; 61, argument_list; 61, 62; 62, identifier:v; 63, for_in_clause; 63, 64; 63, 67; 64, pattern_list; 64, 65; 64, 66; 65, identifier:k; 66, identifier:v; 67, call; 67, 68; 67, 69; 68, identifier:sorted; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:value; 73, identifier:items; 74, argument_list; 75, string:'}'; 76, else_clause; 76, 77; 77, block; 77, 78; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:repr; 81, argument_list; 81, 82; 82, identifier:value | def render_value(value):
"""Render a value, ensuring that any nested dicts are sorted by key."""
if isinstance(value, list):
return '[' + ', '.join(render_value(v) for v in value) + ']'
elif isinstance(value, dict):
return (
'{' +
', '.join('{k!r}: {v}'.format(
k=k, v=render_value(v)) for k, v in sorted(value.items())) +
'}')
else:
return repr(value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort_schema; 3, parameters; 3, 4; 4, identifier:schema; 5, block; 5, 6; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 14; 8, 71; 8, 119; 9, call; 9, 10; 9, 11; 10, identifier:isinstance; 11, argument_list; 11, 12; 11, 13; 12, identifier:schema; 13, identifier:dict; 14, block; 14, 15; 15, for_statement; 15, 16; 15, 19; 15, 27; 16, pattern_list; 16, 17; 16, 18; 17, identifier:k; 18, identifier:v; 19, call; 19, 20; 19, 21; 20, identifier:sorted; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:schema; 25, identifier:items; 26, argument_list; 27, block; 27, 28; 28, if_statement; 28, 29; 28, 34; 28, 46; 28, 64; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:v; 33, identifier:dict; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, yield; 36, 37; 37, expression_list; 37, 38; 37, 39; 38, identifier:k; 39, call; 39, 40; 39, 41; 40, identifier:OrderedDict; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:_sort_schema; 44, argument_list; 44, 45; 45, identifier:v; 46, elif_clause; 46, 47; 46, 52; 47, call; 47, 48; 47, 49; 48, identifier:isinstance; 49, argument_list; 49, 50; 49, 51; 50, identifier:v; 51, identifier:list; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, yield; 54, 55; 55, expression_list; 55, 56; 55, 57; 56, identifier:k; 57, call; 57, 58; 57, 59; 58, identifier:list; 59, argument_list; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:_sort_schema; 62, argument_list; 62, 63; 63, identifier:v; 64, else_clause; 64, 65; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, yield; 67, 68; 68, expression_list; 68, 69; 68, 70; 69, identifier:k; 70, identifier:v; 71, elif_clause; 71, 72; 71, 77; 72, call; 72, 73; 72, 74; 73, identifier:isinstance; 74, argument_list; 74, 75; 74, 76; 75, identifier:schema; 76, identifier:list; 77, block; 77, 78; 78, for_statement; 78, 79; 78, 80; 78, 81; 79, identifier:v; 80, identifier:schema; 81, block; 81, 82; 82, if_statement; 82, 83; 82, 88; 82, 98; 82, 114; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 87; 86, identifier:v; 87, identifier:dict; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, yield; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:OrderedDict; 93, argument_list; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:_sort_schema; 96, argument_list; 96, 97; 97, identifier:v; 98, elif_clause; 98, 99; 98, 104; 99, call; 99, 100; 99, 101; 100, identifier:isinstance; 101, argument_list; 101, 102; 101, 103; 102, identifier:v; 103, identifier:list; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, yield; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:list; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:_sort_schema; 112, argument_list; 112, 113; 113, identifier:v; 114, else_clause; 114, 115; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, yield; 117, 118; 118, identifier:v; 119, else_clause; 119, 120; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, yield; 122, 123; 123, identifier:d | def _sort_schema(schema):
"""Recursively sorts a JSON schema by dict key."""
if isinstance(schema, dict):
for k, v in sorted(schema.items()):
if isinstance(v, dict):
yield k, OrderedDict(_sort_schema(v))
elif isinstance(v, list):
yield k, list(_sort_schema(v))
else:
yield k, v
elif isinstance(schema, list):
for v in schema:
if isinstance(v, dict):
yield OrderedDict(_sort_schema(v))
elif isinstance(v, list):
yield list(_sort_schema(v))
else:
yield v
else:
yield d |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_sort_handlers; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:signals; 6, identifier:handlers; 7, identifier:configs; 8, block; 8, 9; 8, 11; 8, 82; 8, 91; 8, 98; 8, 148; 8, 185; 9, expression_statement; 9, 10; 10, comment; 11, function_definition; 11, 12; 11, 13; 11, 16; 12, function_name:macro_precedence_sorter; 13, parameters; 13, 14; 13, 15; 14, identifier:flags; 15, identifier:hname; 16, block; 16, 17; 16, 19; 16, 25; 16, 33; 16, 54; 17, expression_statement; 17, 18; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:data; 22, subscript; 22, 23; 22, 24; 23, identifier:configs; 24, identifier:hname; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:topdown_sort; 28, comparison_operator:in; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:SignalOptions; 31, identifier:SORT_TOPDOWN; 32, identifier:flags; 33, if_statement; 33, 34; 33, 35; 33, 46; 34, identifier:topdown_sort; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:level; 39, binary_operator:-; 39, 40; 39, 43; 40, binary_operator:-; 40, 41; 40, 42; 41, identifier:levels_count; 42, integer:1; 43, subscript; 43, 44; 43, 45; 44, identifier:data; 45, string:'level'; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:level; 51, subscript; 51, 52; 51, 53; 52, identifier:data; 53, string:'level'; 54, if_statement; 54, 55; 54, 58; 54, 65; 54, 75; 55, comparison_operator:in; 55, 56; 55, 57; 56, string:'begin'; 57, identifier:data; 58, block; 58, 59; 59, return_statement; 59, 60; 60, tuple; 60, 61; 60, 63; 60, 64; 61, unary_operator:-; 61, 62; 62, integer:1; 63, identifier:level; 64, identifier:hname; 65, elif_clause; 65, 66; 65, 69; 66, comparison_operator:in; 66, 67; 66, 68; 67, string:'end'; 68, identifier:data; 69, block; 69, 70; 70, return_statement; 70, 71; 71, tuple; 71, 72; 71, 73; 71, 74; 72, integer:1; 73, identifier:level; 74, identifier:hname; 75, else_clause; 75, 76; 76, block; 76, 77; 77, return_statement; 77, 78; 78, tuple; 78, 79; 78, 80; 78, 81; 79, integer:0; 80, identifier:level; 81, identifier:hname; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:levels_count; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, attribute; 88, 89; 88, 90; 89, identifier:handlers; 90, identifier:maps; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:per_signal; 94, call; 94, 95; 94, 96; 95, identifier:defaultdict; 96, argument_list; 96, 97; 97, identifier:list; 98, for_statement; 98, 99; 98, 102; 98, 111; 99, pattern_list; 99, 100; 99, 101; 100, identifier:level; 101, identifier:m; 102, call; 102, 103; 102, 104; 103, identifier:enumerate; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:reversed; 107, argument_list; 107, 108; 108, attribute; 108, 109; 108, 110; 109, identifier:handlers; 110, identifier:maps; 111, block; 111, 112; 112, for_statement; 112, 113; 112, 116; 112, 121; 113, pattern_list; 113, 114; 113, 115; 114, identifier:hname; 115, identifier:sig_name; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:m; 119, identifier:items; 120, argument_list; 121, block; 121, 122; 121, 128; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:sig_handlers; 125, subscript; 125, 126; 125, 127; 126, identifier:per_signal; 127, identifier:sig_name; 128, if_statement; 128, 129; 128, 132; 129, comparison_operator:not; 129, 130; 129, 131; 130, identifier:hname; 131, identifier:sig_handlers; 132, block; 132, 133; 132, 141; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 140; 135, subscript; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:configs; 138, identifier:hname; 139, string:'level'; 140, identifier:level; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:sig_handlers; 145, identifier:append; 146, argument_list; 146, 147; 147, identifier:hname; 148, for_statement; 148, 149; 148, 152; 148, 157; 149, pattern_list; 149, 150; 149, 151; 150, identifier:sig_name; 151, identifier:sig_handlers; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:per_signal; 155, identifier:items; 156, argument_list; 157, block; 157, 158; 158, if_statement; 158, 159; 158, 162; 158, 163; 159, comparison_operator:in; 159, 160; 159, 161; 160, identifier:sig_name; 161, identifier:signals; 162, comment; 163, block; 163, 164; 163, 172; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:flags; 167, attribute; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:signals; 170, identifier:sig_name; 171, identifier:flags; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:sig_handlers; 176, identifier:sort; 177, argument_list; 177, 178; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:key; 180, call; 180, 181; 180, 182; 181, identifier:partial; 182, argument_list; 182, 183; 182, 184; 183, identifier:macro_precedence_sorter; 184, identifier:flags; 185, return_statement; 185, 186; 186, identifier:per_signal | def _sort_handlers(cls, signals, handlers, configs):
"""Sort class defined handlers to give precedence to those declared at
lower level. ``config`` can contain two keys ``begin`` or ``end`` that
will further reposition the handler at the two extremes.
"""
def macro_precedence_sorter(flags, hname):
"""The default is to sort 'bottom_up', with lower level getting
executed first, but sometimes you need them reversed."""
data = configs[hname]
topdown_sort = SignalOptions.SORT_TOPDOWN in flags
if topdown_sort:
level = levels_count - 1 - data['level']
else:
level = data['level']
if 'begin' in data:
return (-1, level, hname)
elif 'end' in data:
return (1, level, hname)
else:
return (0, level, hname)
levels_count = len(handlers.maps)
per_signal = defaultdict(list)
for level, m in enumerate(reversed(handlers.maps)):
for hname, sig_name in m.items():
sig_handlers = per_signal[sig_name]
if hname not in sig_handlers:
configs[hname]['level'] = level
sig_handlers.append(hname)
for sig_name, sig_handlers in per_signal.items():
if sig_name in signals: # it may be on a mixin
flags = signals[sig_name].flags
sig_handlers.sort(key=partial(macro_precedence_sorter,
flags))
return per_signal |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_radixPass; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:a; 5, identifier:b; 6, identifier:r; 7, identifier:n; 8, identifier:K; 9, block; 9, 10; 9, 12; 9, 26; 9, 27; 9, 45; 9, 49; 9, 75; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:c; 15, call; 15, 16; 15, 17; 16, identifier:_array; 17, argument_list; 17, 18; 17, 19; 18, string:"i"; 19, binary_operator:*; 19, 20; 19, 22; 20, list:[0]; 20, 21; 21, integer:0; 22, parenthesized_expression; 22, 23; 23, binary_operator:+; 23, 24; 23, 25; 24, identifier:K; 25, integer:1; 26, comment; 27, for_statement; 27, 28; 27, 29; 27, 33; 27, 34; 28, identifier:i; 29, call; 29, 30; 29, 31; 30, identifier:range; 31, argument_list; 31, 32; 32, identifier:n; 33, comment; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, augmented_assignment:+=; 36, 37; 36, 44; 37, subscript; 37, 38; 37, 39; 38, identifier:c; 39, subscript; 39, 40; 39, 41; 40, identifier:r; 41, subscript; 41, 42; 41, 43; 42, identifier:a; 43, identifier:i; 44, integer:1; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:sum; 48, integer:0; 49, for_statement; 49, 50; 49, 51; 49, 57; 49, 58; 50, identifier:i; 51, call; 51, 52; 51, 53; 52, identifier:range; 53, argument_list; 53, 54; 54, binary_operator:+; 54, 55; 54, 56; 55, identifier:K; 56, integer:1; 57, comment; 58, block; 58, 59; 58, 65; 58, 71; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:t; 62, subscript; 62, 63; 62, 64; 63, identifier:c; 64, identifier:i; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:c; 69, identifier:i; 70, identifier:sum; 71, expression_statement; 71, 72; 72, augmented_assignment:+=; 72, 73; 72, 74; 73, identifier:sum; 74, identifier:t; 75, for_statement; 75, 76; 75, 77; 75, 82; 75, 83; 76, identifier:a_i; 77, subscript; 77, 78; 77, 79; 78, identifier:a; 79, slice; 79, 80; 79, 81; 80, colon; 81, identifier:n; 82, comment; 83, block; 83, 84; 83, 94; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 93; 86, subscript; 86, 87; 86, 88; 87, identifier:b; 88, subscript; 88, 89; 88, 90; 89, identifier:c; 90, subscript; 90, 91; 90, 92; 91, identifier:r; 92, identifier:a_i; 93, identifier:a_i; 94, expression_statement; 94, 95; 95, augmented_assignment:+=; 95, 96; 95, 101; 96, subscript; 96, 97; 96, 98; 97, identifier:c; 98, subscript; 98, 99; 98, 100; 99, identifier:r; 100, identifier:a_i; 101, integer:1 | def _radixPass(a, b, r, n, K):
"""
Stable sort of the sequence a according to the keys given in r.
>>> a=range(5)
>>> b=[0]*5
>>> r=[2,1,3,0,4]
>>> _radixPass(a, b, r, 5, 5)
>>> b
[3, 1, 0, 2, 4]
When n is less than the length of a, the end of b must be left unaltered.
>>> b=[5]*5
>>> _radixPass(a, b, r, 2, 2)
>>> b
[1, 0, 5, 5, 5]
>>> _a=a=[1, 0]
>>> b= [0]*2
>>> r=[0, 1]
>>> _radixPass(a, b, r, 2, 2)
>>> a=_a
>>> b
[0, 1]
>>> a=[1, 1]
>>> _radixPass(a, b, r, 2, 2)
>>> b
[1, 1]
>>> a=[0, 1, 1, 0]
>>> b= [0]*4
>>> r=[0, 1]
>>> _radixPass(a, b, r, 4, 2)
>>> a=_a
>>> b
[0, 0, 1, 1]
"""
c = _array("i", [0] * (K + 1)) # counter array
for i in range(n): # count occurrences
c[r[a[i]]] += 1
sum = 0
for i in range(K + 1): # exclusive prefix sums
t = c[i]
c[i] = sum
sum += t
for a_i in a[:n]: # sort
b[c[r[a_i]]] = a_i
c[r[a_i]] += 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 13; 2, function_name:save_yaml; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:dictionary; 5, identifier:path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:pretty; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sortkeys; 11, False; 12, comment; 13, block; 13, 14; 13, 16; 13, 26; 14, expression_statement; 14, 15; 15, comment; 16, if_statement; 16, 17; 16, 18; 17, identifier:sortkeys; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:dictionary; 22, call; 22, 23; 22, 24; 23, identifier:dict; 24, argument_list; 24, 25; 25, identifier:dictionary; 26, with_statement; 26, 27; 26, 37; 27, with_clause; 27, 28; 28, with_item; 28, 29; 29, as_pattern; 29, 30; 29, 35; 30, call; 30, 31; 30, 32; 31, identifier:open; 32, argument_list; 32, 33; 32, 34; 33, identifier:path; 34, string:'w'; 35, as_pattern_target; 35, 36; 36, identifier:f; 37, block; 37, 38; 38, if_statement; 38, 39; 38, 40; 38, 49; 39, identifier:pretty; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:pyaml; 45, identifier:dump; 46, argument_list; 46, 47; 46, 48; 47, identifier:dictionary; 48, identifier:f; 49, else_clause; 49, 50; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:yaml; 55, identifier:dump; 56, argument_list; 56, 57; 56, 58; 56, 59; 56, 62; 57, identifier:dictionary; 58, identifier:f; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:default_flow_style; 61, None; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:Dumper; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:yamlloader; 67, identifier:ordereddict; 68, identifier:CDumper | def save_yaml(dictionary, path, pretty=False, sortkeys=False):
# type: (Dict, str, bool, bool) -> None
"""Save dictionary to YAML file preserving order if it is an OrderedDict
Args:
dictionary (Dict): Python dictionary to save
path (str): Path to YAML file
pretty (bool): Whether to pretty print. Defaults to False.
sortkeys (bool): Whether to sort dictionary keys. Defaults to False.
Returns:
None
"""
if sortkeys:
dictionary = dict(dictionary)
with open(path, 'w') as f:
if pretty:
pyaml.dump(dictionary, f)
else:
yaml.dump(dictionary, f, default_flow_style=None, Dumper=yamlloader.ordereddict.CDumper) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 13; 2, function_name:save_json; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:dictionary; 5, identifier:path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:pretty; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sortkeys; 11, False; 12, comment; 13, block; 13, 14; 13, 16; 14, expression_statement; 14, 15; 15, comment; 16, with_statement; 16, 17; 16, 27; 17, with_clause; 17, 18; 18, with_item; 18, 19; 19, as_pattern; 19, 20; 19, 25; 20, call; 20, 21; 20, 22; 21, identifier:open; 22, argument_list; 22, 23; 22, 24; 23, identifier:path; 24, string:'w'; 25, as_pattern_target; 25, 26; 26, identifier:f; 27, block; 27, 28; 27, 53; 28, if_statement; 28, 29; 28, 30; 28, 41; 29, identifier:pretty; 30, block; 30, 31; 30, 35; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:indent; 34, integer:2; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:separators; 38, tuple; 38, 39; 38, 40; 39, string:','; 40, string:': '; 41, else_clause; 41, 42; 42, block; 42, 43; 42, 47; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:indent; 46, None; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:separators; 50, tuple; 50, 51; 50, 52; 51, string:', '; 52, string:': '; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:json; 57, identifier:dump; 58, argument_list; 58, 59; 58, 60; 58, 61; 58, 64; 58, 67; 59, identifier:dictionary; 60, identifier:f; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:indent; 63, identifier:indent; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:sort_keys; 66, identifier:sortkeys; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:separators; 69, identifier:separators | def save_json(dictionary, path, pretty=False, sortkeys=False):
# type: (Dict, str, bool, bool) -> None
"""Save dictionary to JSON file preserving order if it is an OrderedDict
Args:
dictionary (Dict): Python dictionary to save
path (str): Path to JSON file
pretty (bool): Whether to pretty print. Defaults to False.
sortkeys (bool): Whether to sort dictionary keys. Defaults to False.
Returns:
None
"""
with open(path, 'w') as f:
if pretty:
indent = 2
separators = (',', ': ')
else:
indent = None
separators = (', ', ': ')
json.dump(dictionary, f, indent=indent, sort_keys=sortkeys, separators=separators) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:save_json; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:val; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pretty; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:encoder; 13, None; 14, block; 14, 15; 14, 17; 14, 26; 14, 74; 14, 99; 15, expression_statement; 15, 16; 16, comment; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:encoder; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:encoder; 25, identifier:DateTimeEncoder; 26, if_statement; 26, 27; 26, 28; 26, 52; 27, identifier:pretty; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:data; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:json; 35, identifier:dumps; 36, argument_list; 36, 37; 36, 38; 36, 41; 36, 46; 36, 49; 37, identifier:val; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:indent; 40, integer:4; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:separators; 43, tuple; 43, 44; 43, 45; 44, string:','; 45, string:': '; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:sort_keys; 48, identifier:sort; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:cls; 51, identifier:encoder; 52, else_clause; 52, 53; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:data; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:json; 60, identifier:dumps; 61, argument_list; 61, 62; 61, 63; 61, 68; 61, 71; 62, identifier:val; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:separators; 65, tuple; 65, 66; 65, 67; 66, string:','; 67, string:':'; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:sort_keys; 70, identifier:sort; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:cls; 73, identifier:encoder; 74, if_statement; 74, 75; 74, 89; 75, boolean_operator:and; 75, 76; 75, 84; 76, not_operator; 76, 77; 77, comparison_operator:>; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:sys; 80, identifier:version_info; 81, tuple; 81, 82; 81, 83; 82, integer:3; 83, integer:0; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:data; 88, identifier:str; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:data; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:data; 96, identifier:decode; 97, argument_list; 97, 98; 98, string:"utf-8"; 99, return_statement; 99, 100; 100, identifier:data | def save_json(val, pretty=False, sort=True, encoder=None):
"""
Save data to json string
:param val: Value or struct to save
:type val: None | int | float | str | list | dict
:param pretty: Format data to be readable (default: False)
otherwise going to be compact
:type pretty: bool
:param sort: Sort keys (default: True)
:type sort: bool
:param encoder: Use custom json encoder
:type encoder: T <= DateTimeEncoder
:return: The jsonified string
:rtype: str | unicode
"""
if encoder is None:
encoder = DateTimeEncoder
if pretty:
data = json.dumps(
val,
indent=4,
separators=(',', ': '),
sort_keys=sort,
cls=encoder
)
else:
data = json.dumps(
val,
separators=(',', ':'),
sort_keys=sort,
cls=encoder
)
if not sys.version_info > (3, 0) and isinstance(data, str):
data = data.decode("utf-8")
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:revdocs2reverts; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 13; 3, 16; 4, identifier:rev_docs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:radius; 7, attribute; 7, 8; 7, 9; 8, identifier:defaults; 9, identifier:RADIUS; 10, default_parameter; 10, 11; 10, 12; 11, identifier:use_sha1; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:resort; 15, False; 16, default_parameter; 16, 17; 16, 18; 17, identifier:verbose; 18, False; 19, block; 19, 20; 19, 22; 19, 38; 20, expression_statement; 20, 21; 21, comment; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:page_rev_docs; 25, call; 25, 26; 25, 27; 26, identifier:groupby; 27, argument_list; 27, 28; 27, 29; 28, identifier:rev_docs; 29, lambda; 29, 30; 29, 32; 30, lambda_parameters; 30, 31; 31, identifier:rd; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:rd; 35, identifier:get; 36, argument_list; 36, 37; 37, string:'page'; 38, for_statement; 38, 39; 38, 42; 38, 43; 39, pattern_list; 39, 40; 39, 41; 40, identifier:page_doc; 41, identifier:rev_docs; 42, identifier:page_rev_docs; 43, block; 43, 44; 43, 71; 43, 119; 43, 128; 43, 263; 44, if_statement; 44, 45; 44, 46; 45, identifier:verbose; 46, block; 46, 47; 46, 63; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:sys; 52, identifier:stderr; 53, identifier:write; 54, argument_list; 54, 55; 55, binary_operator:+; 55, 56; 55, 62; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:page_doc; 59, identifier:get; 60, argument_list; 60, 61; 61, string:'title'; 62, string:": "; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:sys; 68, identifier:stderr; 69, identifier:flush; 70, argument_list; 71, if_statement; 71, 72; 71, 73; 72, identifier:resort; 73, block; 73, 74; 73, 94; 74, if_statement; 74, 75; 74, 76; 75, identifier:verbose; 76, block; 76, 77; 76, 86; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:sys; 82, identifier:stderr; 83, identifier:write; 84, argument_list; 84, 85; 85, string:"(sorting) "; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 93; 88, attribute; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:sys; 91, identifier:stderr; 92, identifier:flush; 93, argument_list; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:rev_docs; 97, call; 97, 98; 97, 99; 98, identifier:sorted; 99, argument_list; 99, 100; 99, 101; 100, identifier:rev_docs; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:key; 103, lambda; 103, 104; 103, 106; 104, lambda_parameters; 104, 105; 105, identifier:r; 106, tuple; 106, 107; 106, 113; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:r; 110, identifier:get; 111, argument_list; 111, 112; 112, string:'timestamp'; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:r; 116, identifier:get; 117, argument_list; 117, 118; 118, string:'id'; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:detector; 122, call; 122, 123; 122, 124; 123, identifier:Detector; 124, argument_list; 124, 125; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:radius; 127, identifier:radius; 128, for_statement; 128, 129; 128, 130; 128, 131; 129, identifier:rev_doc; 130, identifier:rev_docs; 131, block; 131, 132; 131, 156; 131, 201; 131, 211; 132, if_statement; 132, 133; 132, 139; 133, boolean_operator:and; 133, 134; 133, 136; 134, not_operator; 134, 135; 135, identifier:use_sha1; 136, comparison_operator:not; 136, 137; 136, 138; 137, string:'text'; 138, identifier:rev_doc; 139, block; 139, 140; 139, 155; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:logger; 144, identifier:warn; 145, argument_list; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, string:"Skipping {0}: 'text' field not found in {0}"; 149, identifier:format; 150, argument_list; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:rev_doc; 153, string:'id'; 154, identifier:rev_doc; 155, continue_statement; 156, if_statement; 156, 157; 156, 158; 156, 172; 157, identifier:use_sha1; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:checksum; 162, boolean_operator:or; 162, 163; 162, 169; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:rev_doc; 166, identifier:get; 167, argument_list; 167, 168; 168, string:'sha1'; 169, call; 169, 170; 169, 171; 170, identifier:DummyChecksum; 171, argument_list; 172, elif_clause; 172, 173; 172, 176; 173, comparison_operator:in; 173, 174; 173, 175; 174, string:'text'; 175, identifier:rev_doc; 176, block; 176, 177; 176, 188; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:text_bytes; 180, call; 180, 181; 180, 182; 181, identifier:bytes; 182, argument_list; 182, 183; 182, 186; 182, 187; 183, subscript; 183, 184; 183, 185; 184, identifier:rev_doc; 185, string:'text'; 186, string:'utf8'; 187, string:'replace'; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:checksum; 191, call; 191, 192; 191, 200; 192, attribute; 192, 193; 192, 199; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:hashlib; 196, identifier:sha1; 197, argument_list; 197, 198; 198, identifier:text_bytes; 199, identifier:digest; 200, argument_list; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:revert; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:detector; 207, identifier:process; 208, argument_list; 208, 209; 208, 210; 209, identifier:checksum; 210, identifier:rev_doc; 211, if_statement; 211, 212; 211, 213; 211, 241; 212, identifier:revert; 213, block; 213, 214; 213, 221; 214, expression_statement; 214, 215; 215, yield; 215, 216; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:revert; 219, identifier:to_json; 220, argument_list; 221, if_statement; 221, 222; 221, 223; 222, identifier:verbose; 223, block; 223, 224; 223, 233; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:sys; 229, identifier:stderr; 230, identifier:write; 231, argument_list; 231, 232; 232, string:"r"; 233, expression_statement; 233, 234; 234, call; 234, 235; 234, 240; 235, attribute; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:sys; 238, identifier:stderr; 239, identifier:flush; 240, argument_list; 241, else_clause; 241, 242; 242, block; 242, 243; 243, if_statement; 243, 244; 243, 245; 244, identifier:verbose; 245, block; 245, 246; 245, 255; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:sys; 251, identifier:stderr; 252, identifier:write; 253, argument_list; 253, 254; 254, string:"."; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:sys; 260, identifier:stderr; 261, identifier:flush; 262, argument_list; 263, if_statement; 263, 264; 263, 265; 264, identifier:verbose; 265, block; 265, 266; 265, 275; 266, expression_statement; 266, 267; 267, call; 267, 268; 267, 273; 268, attribute; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:sys; 271, identifier:stderr; 272, identifier:write; 273, argument_list; 273, 274; 274, string:"\n"; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:sys; 280, identifier:stderr; 281, identifier:flush; 282, argument_list | def revdocs2reverts(rev_docs, radius=defaults.RADIUS, use_sha1=False,
resort=False, verbose=False):
"""
Converts a sequence of page-partitioned revision documents into a sequence
of reverts.
:Params:
rev_docs : `iterable` ( `dict` )
a page-partitioned sequence of revision documents
radius : `int`
The maximum number of revisions that a revert can reference.
use_sha1 : `bool`
Use the sha1 field as the checksum for comparison.
resort : `bool`
If True, re-sort the revisions of each page.
verbose : `bool`
Print dots and stuff
"""
page_rev_docs = groupby(rev_docs, lambda rd: rd.get('page'))
for page_doc, rev_docs in page_rev_docs:
if verbose:
sys.stderr.write(page_doc.get('title') + ": ")
sys.stderr.flush()
if resort:
if verbose:
sys.stderr.write("(sorting) ")
sys.stderr.flush()
rev_docs = sorted(
rev_docs, key=lambda r: (r.get('timestamp'), r.get('id')))
detector = Detector(radius=radius)
for rev_doc in rev_docs:
if not use_sha1 and 'text' not in rev_doc:
logger.warn("Skipping {0}: 'text' field not found in {0}"
.format(rev_doc['id'], rev_doc))
continue
if use_sha1:
checksum = rev_doc.get('sha1') or DummyChecksum()
elif 'text' in rev_doc:
text_bytes = bytes(rev_doc['text'], 'utf8', 'replace')
checksum = hashlib.sha1(text_bytes).digest()
revert = detector.process(checksum, rev_doc)
if revert:
yield revert.to_json()
if verbose:
sys.stderr.write("r")
sys.stderr.flush()
else:
if verbose:
sys.stderr.write(".")
sys.stderr.flush()
if verbose:
sys.stderr.write("\n")
sys.stderr.flush() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:dsort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:fname; 5, identifier:order; 6, default_parameter; 6, 7; 6, 8; 7, identifier:has_header; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:frow; 11, integer:0; 12, default_parameter; 12, 13; 12, 14; 13, identifier:ofname; 14, None; 15, block; 15, 16; 15, 18; 15, 27; 15, 42; 15, 49; 16, expression_statement; 16, 17; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:ofname; 21, conditional_expression:if; 21, 22; 21, 23; 21, 26; 22, identifier:fname; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:ofname; 25, None; 26, identifier:ofname; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:obj; 30, call; 30, 31; 30, 32; 31, identifier:CsvFile; 32, argument_list; 32, 33; 32, 36; 32, 39; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:fname; 35, identifier:fname; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:has_header; 38, identifier:has_header; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:frow; 41, identifier:frow; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:obj; 46, identifier:dsort; 47, argument_list; 47, 48; 48, identifier:order; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:obj; 53, identifier:write; 54, argument_list; 54, 55; 54, 58; 54, 61; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:fname; 57, identifier:ofname; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:header; 60, identifier:has_header; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:append; 63, False | def dsort(fname, order, has_header=True, frow=0, ofname=None):
r"""
Sort file data.
:param fname: Name of the comma-separated values file to sort
:type fname: FileNameExists_
:param order: Sort order
:type order: :ref:`CsvColFilter`
:param has_header: Flag that indicates whether the comma-separated
values file to sort has column headers in its first line
(True) or not (False)
:type has_header: boolean
:param frow: First data row (starting from 1). If 0 the row where data
starts is auto-detected as the first row that has a number
(integer of float) in at least one of its columns
:type frow: NonNegativeInteger_
:param ofname: Name of the output comma-separated values file, the file
that will contain the sorted data. If None the sorting is
done "in place"
:type ofname: FileName_ or None
.. [[[cog cog.out(exobj.get_sphinx_autodoc(raised=True)) ]]]
.. Auto-generated exceptions documentation for pcsv.dsort.dsort
:raises:
* OSError (File *[fname]* could not be found)
* RuntimeError (Argument \`fname\` is not valid)
* RuntimeError (Argument \`frow\` is not valid)
* RuntimeError (Argument \`has_header\` is not valid)
* RuntimeError (Argument \`ofname\` is not valid)
* RuntimeError (Argument \`order\` is not valid)
* RuntimeError (Column headers are not unique in file *[fname]*)
* RuntimeError (File *[fname]* has no valid data)
* RuntimeError (File *[fname]* is empty)
* RuntimeError (Invalid column specification)
* ValueError (Column *[column_identifier]* not found)
.. [[[end]]]
"""
ofname = fname if ofname is None else ofname
obj = CsvFile(fname=fname, has_header=has_header, frow=frow)
obj.dsort(order)
obj.write(fname=ofname, header=has_header, append=False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:dsort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:order; 6, block; 6, 7; 6, 9; 6, 10; 6, 22; 6, 41; 6, 42; 6, 62; 6, 63; 6, 67; 6, 114; 6, 115; 6, 116; 6, 117; 6, 118; 6, 119; 6, 120; 6, 121; 6, 122; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:order; 13, conditional_expression:if; 13, 14; 13, 15; 13, 20; 14, identifier:order; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:order; 19, identifier:list; 20, list:[order]; 20, 21; 21, identifier:order; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:norder; 25, list_comprehension; 25, 26; 25, 38; 26, conditional_expression:if; 26, 27; 26, 31; 26, 37; 27, dictionary; 27, 28; 28, pair; 28, 29; 28, 30; 29, identifier:item; 30, string:"A"; 31, not_operator; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:item; 36, identifier:dict; 37, identifier:item; 38, for_in_clause; 38, 39; 38, 40; 39, identifier:item; 40, identifier:order; 41, comment; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_in_header; 47, argument_list; 47, 48; 48, list_comprehension; 48, 49; 48, 59; 49, subscript; 49, 50; 49, 58; 50, call; 50, 51; 50, 52; 51, identifier:list; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:item; 56, identifier:keys; 57, argument_list; 58, integer:0; 59, for_in_clause; 59, 60; 59, 61; 60, identifier:item; 61, identifier:norder; 62, comment; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:clist; 66, list:[]; 67, for_statement; 67, 68; 67, 69; 67, 70; 68, identifier:nitem; 69, identifier:norder; 70, block; 70, 71; 71, for_statement; 71, 72; 71, 75; 71, 80; 72, pattern_list; 72, 73; 72, 74; 73, identifier:key; 74, identifier:value; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:nitem; 78, identifier:items; 79, argument_list; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:clist; 85, identifier:append; 86, argument_list; 86, 87; 87, tuple; 87, 88; 87, 107; 88, conditional_expression:if; 88, 89; 88, 90; 88, 95; 89, identifier:key; 90, call; 90, 91; 90, 92; 91, identifier:isinstance; 92, argument_list; 92, 93; 92, 94; 93, identifier:key; 94, identifier:int; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_header_upper; 100, identifier:index; 101, argument_list; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:key; 105, identifier:upper; 106, argument_list; 107, comparison_operator:==; 107, 108; 107, 113; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:value; 111, identifier:upper; 112, argument_list; 113, string:"D"; 114, comment; 115, comment; 116, comment; 117, comment; 118, comment; 119, comment; 120, comment; 121, comment; 122, for_statement; 122, 123; 122, 126; 122, 130; 123, tuple_pattern; 123, 124; 123, 125; 124, identifier:cindex; 125, identifier:rvalue; 126, call; 126, 127; 126, 128; 127, identifier:reversed; 128, argument_list; 128, 129; 129, identifier:clist; 130, block; 130, 131; 130, 140; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:fpointer; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:operator; 137, identifier:itemgetter; 138, argument_list; 138, 139; 139, identifier:cindex; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_data; 146, identifier:sort; 147, argument_list; 147, 148; 147, 151; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:key; 150, identifier:fpointer; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:reverse; 153, identifier:rvalue | def dsort(self, order):
r"""
Sort rows.
:param order: Sort order
:type order: :ref:`CsvColFilter`
.. [[[cog cog.out(exobj.get_sphinx_autodoc()) ]]]
.. Auto-generated exceptions documentation for
.. pcsv.csv_file.CsvFile.dsort
:raises:
* RuntimeError (Argument \`order\` is not valid)
* RuntimeError (Invalid column specification)
* ValueError (Column *[column_identifier]* not found)
.. [[[end]]]
"""
# Make order conforming to a list of dictionaries
order = order if isinstance(order, list) else [order]
norder = [{item: "A"} if not isinstance(item, dict) else item for item in order]
# Verify that all columns exist in file
self._in_header([list(item.keys())[0] for item in norder])
# Get column indexes
clist = []
for nitem in norder:
for key, value in nitem.items():
clist.append(
(
key
if isinstance(key, int)
else self._header_upper.index(key.upper()),
value.upper() == "D",
)
)
# From the Python documentation:
# "Starting with Python 2.3, the sort() method is guaranteed to be
# stable. A sort is stable if it guarantees not to change the
# relative order of elements that compare equal - this is helpful
# for sorting in multiple passes (for example, sort by department,
# then by salary grade)."
# This means that the sorts have to be done from "minor" column to
# "major" column
for (cindex, rvalue) in reversed(clist):
fpointer = operator.itemgetter(cindex)
self._data.sort(key=fpointer, reverse=rvalue) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:get_points_and_weights; 3, parameters; 3, 4; 3, 17; 3, 21; 3, 24; 3, 27; 4, default_parameter; 4, 5; 4, 6; 5, identifier:w_func; 6, lambda; 6, 7; 6, 9; 7, lambda_parameters; 7, 8; 8, identifier:x; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:np; 12, identifier:ones; 13, argument_list; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:x; 16, identifier:shape; 17, default_parameter; 17, 18; 17, 19; 18, identifier:left; 19, unary_operator:-; 19, 20; 20, float:1.0; 21, default_parameter; 21, 22; 21, 23; 22, identifier:right; 23, float:1.0; 24, default_parameter; 24, 25; 24, 26; 25, identifier:num_points; 26, integer:5; 27, default_parameter; 27, 28; 27, 29; 28, identifier:n; 29, integer:4096; 30, block; 30, 31; 30, 33; 30, 45; 30, 69; 30, 78; 30, 89; 30, 93; 30, 102; 30, 111; 30, 124; 30, 136; 30, 149; 30, 157; 30, 163; 30, 179; 30, 185; 31, expression_statement; 31, 32; 32, comment; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:dx; 36, binary_operator:/; 36, 37; 36, 44; 37, parenthesized_expression; 37, 38; 38, binary_operator:-; 38, 39; 38, 43; 39, call; 39, 40; 39, 41; 40, identifier:float; 41, argument_list; 41, 42; 42, identifier:right; 43, identifier:left; 44, identifier:n; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:z; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:hstack; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:np; 56, identifier:linspace; 57, argument_list; 57, 58; 57, 63; 57, 68; 58, binary_operator:+; 58, 59; 58, 60; 59, identifier:left; 60, binary_operator:*; 60, 61; 60, 62; 61, float:0.5; 62, identifier:dx; 63, binary_operator:-; 63, 64; 63, 65; 64, identifier:right; 65, binary_operator:*; 65, 66; 65, 67; 66, float:0.5; 67, identifier:dx; 68, identifier:n; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:w; 72, binary_operator:*; 72, 73; 72, 74; 73, identifier:dx; 74, call; 74, 75; 74, 76; 75, identifier:w_func; 76, argument_list; 76, 77; 77, identifier:z; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, tuple_pattern; 80, 81; 80, 82; 81, identifier:a; 82, identifier:b; 83, call; 83, 84; 83, 85; 84, identifier:discrete_gautschi; 85, argument_list; 85, 86; 85, 87; 85, 88; 86, identifier:z; 87, identifier:w; 88, identifier:num_points; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:alpha; 92, identifier:a; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:beta; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:sqrt; 100, argument_list; 100, 101; 101, identifier:b; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:J; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:np; 108, identifier:diag; 109, argument_list; 109, 110; 110, identifier:alpha; 111, expression_statement; 111, 112; 112, augmented_assignment:+=; 112, 113; 112, 114; 113, identifier:J; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:np; 117, identifier:diag; 118, argument_list; 118, 119; 118, 120; 119, identifier:beta; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:k; 122, unary_operator:-; 122, 123; 123, integer:1; 124, expression_statement; 124, 125; 125, augmented_assignment:+=; 125, 126; 125, 127; 126, identifier:J; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:np; 130, identifier:diag; 131, argument_list; 131, 132; 131, 133; 132, identifier:beta; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:k; 135, integer:1; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, tuple_pattern; 138, 139; 138, 140; 139, identifier:points; 140, identifier:v; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:np; 145, identifier:linalg; 146, identifier:eigh; 147, argument_list; 147, 148; 148, identifier:J; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:ind; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:points; 155, identifier:argsort; 156, argument_list; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:points; 160, subscript; 160, 161; 160, 162; 161, identifier:points; 162, identifier:ind; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:weights; 166, binary_operator:*; 166, 167; 166, 174; 167, binary_operator:**; 167, 168; 167, 173; 168, subscript; 168, 169; 168, 170; 168, 171; 169, identifier:v; 170, integer:0; 171, slice; 171, 172; 172, colon; 173, integer:2; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:w; 177, identifier:sum; 178, argument_list; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:weights; 182, subscript; 182, 183; 182, 184; 183, identifier:weights; 184, identifier:ind; 185, return_statement; 185, 186; 186, tuple; 186, 187; 186, 188; 187, identifier:points; 188, identifier:weights | def get_points_and_weights(w_func=lambda x : np.ones(x.shape),
left=-1.0, right=1.0, num_points=5, n=4096):
"""Quadratude points and weights for a weighting function.
Points and weights for approximating the integral
I = \int_left^right f(x) w(x) dx
given the weighting function w(x) using the approximation
I ~ w_i f(x_i)
Args:
w_func: The weighting function w(x). Must be a function that takes
one argument and is valid over the open interval (left, right).
left: The left boundary of the interval
right: The left boundary of the interval
num_points: number of integration points to return
n: the number of points to evaluate w_func at.
Returns:
A tuple (points, weights) where points is a sorted array of the
points x_i and weights gives the corresponding weights w_i.
"""
dx = (float(right)-left)/n
z = np.hstack(np.linspace(left+0.5*dx, right-0.5*dx, n))
w = dx*w_func(z)
(a, b) = discrete_gautschi(z, w, num_points)
alpha = a
beta = np.sqrt(b)
J = np.diag(alpha)
J += np.diag(beta, k=-1)
J += np.diag(beta, k=1)
(points,v) = np.linalg.eigh(J)
ind = points.argsort()
points = points[ind]
weights = v[0,:]**2 * w.sum()
weights = weights[ind]
return (points, weights) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:apply_to; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:x; 6, default_parameter; 6, 7; 6, 8; 7, identifier:columns; 8, False; 9, block; 9, 10; 9, 12; 9, 53; 10, expression_statement; 10, 11; 11, comment; 12, if_statement; 12, 13; 12, 39; 13, boolean_operator:and; 13, 14; 13, 38; 14, boolean_operator:and; 14, 15; 14, 31; 15, boolean_operator:and; 15, 16; 15, 23; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:x; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:ndarray; 23, comparison_operator:==; 23, 24; 23, 30; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:x; 29, identifier:shape; 30, integer:2; 31, comparison_operator:==; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:x; 35, identifier:shape; 36, integer:0; 37, integer:3; 38, identifier:columns; 39, block; 39, 40; 40, return_statement; 40, 41; 41, binary_operator:+; 41, 42; 41, 43; 42, identifier:x; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:t; 48, identifier:reshape; 49, argument_list; 49, 50; 50, tuple; 50, 51; 50, 52; 51, integer:3; 52, integer:1; 53, if_statement; 53, 54; 53, 90; 53, 97; 53, 118; 53, 136; 53, 153; 53, 162; 54, boolean_operator:and; 54, 55; 54, 88; 55, boolean_operator:and; 55, 56; 55, 63; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:x; 60, attribute; 60, 61; 60, 62; 61, identifier:np; 62, identifier:ndarray; 63, parenthesized_expression; 63, 64; 64, boolean_operator:or; 64, 65; 64, 71; 65, comparison_operator:==; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:x; 68, identifier:shape; 69, tuple; 69, 70; 70, integer:3; 71, parenthesized_expression; 71, 72; 72, boolean_operator:and; 72, 73; 72, 81; 73, comparison_operator:==; 73, 74; 73, 80; 74, call; 74, 75; 74, 76; 75, identifier:len; 76, argument_list; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:x; 79, identifier:shape; 80, integer:2; 81, comparison_operator:==; 81, 82; 81, 87; 82, subscript; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:x; 85, identifier:shape; 86, integer:1; 87, integer:3; 88, not_operator; 88, 89; 89, identifier:columns; 90, block; 90, 91; 91, return_statement; 91, 92; 92, binary_operator:+; 92, 93; 92, 94; 93, identifier:x; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:t; 97, elif_clause; 97, 98; 97, 103; 98, call; 98, 99; 98, 100; 99, identifier:isinstance; 100, argument_list; 100, 101; 100, 102; 101, identifier:x; 102, identifier:Complete; 103, block; 103, 104; 104, return_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:Complete; 107, argument_list; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:x; 110, identifier:r; 111, binary_operator:+; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:x; 114, identifier:t; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:t; 118, elif_clause; 118, 119; 118, 124; 119, call; 119, 120; 119, 121; 120, identifier:isinstance; 121, argument_list; 121, 122; 121, 123; 122, identifier:x; 123, identifier:Translation; 124, block; 124, 125; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:Translation; 128, argument_list; 128, 129; 129, binary_operator:+; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:x; 132, identifier:t; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:t; 136, elif_clause; 136, 137; 136, 142; 137, call; 137, 138; 137, 139; 138, identifier:isinstance; 139, argument_list; 139, 140; 139, 141; 140, identifier:x; 141, identifier:Rotation; 142, block; 142, 143; 143, return_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:Complete; 146, argument_list; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:x; 149, identifier:r; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:t; 153, elif_clause; 153, 154; 153, 159; 154, call; 154, 155; 154, 156; 155, identifier:isinstance; 156, argument_list; 156, 157; 156, 158; 157, identifier:x; 158, identifier:UnitCell; 159, block; 159, 160; 160, return_statement; 160, 161; 161, identifier:x; 162, else_clause; 162, 163; 163, block; 163, 164; 164, raise_statement; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:ValueError; 167, argument_list; 167, 168; 168, binary_operator:%; 168, 169; 168, 170; 169, string:"Can not apply this translation to %s"; 170, identifier:x | def apply_to(self, x, columns=False):
"""Apply this translation to the given object
The argument can be several sorts of objects:
* ``np.array`` with shape (3, )
* ``np.array`` with shape (N, 3)
* ``np.array`` with shape (3, N), use ``columns=True``
* ``Translation``
* ``Rotation``
* ``Complete``
* ``UnitCell``
In case of arrays, the 3D vectors are translated. In case of trans-
formations, a new transformation is returned that consists of this
translation applied AFTER the given translation. In case of a unit
cell, the original object is returned.
This method is equivalent to ``self*x``.
"""
if isinstance(x, np.ndarray) and len(x.shape) == 2 and x.shape[0] == 3 and columns:
return x + self.t.reshape((3,1))
if isinstance(x, np.ndarray) and (x.shape == (3, ) or (len(x.shape) == 2 and x.shape[1] == 3)) and not columns:
return x + self.t
elif isinstance(x, Complete):
return Complete(x.r, x.t + self.t)
elif isinstance(x, Translation):
return Translation(x.t + self.t)
elif isinstance(x, Rotation):
return Complete(x.r, self.t)
elif isinstance(x, UnitCell):
return x
else:
raise ValueError("Can not apply this translation to %s" % x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:apply_to; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:x; 6, default_parameter; 6, 7; 6, 8; 7, identifier:columns; 8, False; 9, block; 9, 10; 9, 12; 9, 50; 10, expression_statement; 10, 11; 11, comment; 12, if_statement; 12, 13; 12, 39; 13, boolean_operator:and; 13, 14; 13, 38; 14, boolean_operator:and; 14, 15; 14, 31; 15, boolean_operator:and; 15, 16; 15, 23; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:x; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:ndarray; 23, comparison_operator:==; 23, 24; 23, 30; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:x; 29, identifier:shape; 30, integer:2; 31, comparison_operator:==; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:x; 35, identifier:shape; 36, integer:0; 37, integer:3; 38, identifier:columns; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:np; 44, identifier:dot; 45, argument_list; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:r; 49, identifier:x; 50, if_statement; 50, 51; 50, 87; 50, 102; 50, 135; 50, 160; 50, 182; 50, 207; 51, boolean_operator:and; 51, 52; 51, 85; 52, boolean_operator:and; 52, 53; 52, 60; 53, call; 53, 54; 53, 55; 54, identifier:isinstance; 55, argument_list; 55, 56; 55, 57; 56, identifier:x; 57, attribute; 57, 58; 57, 59; 58, identifier:np; 59, identifier:ndarray; 60, parenthesized_expression; 60, 61; 61, boolean_operator:or; 61, 62; 61, 68; 62, comparison_operator:==; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:x; 65, identifier:shape; 66, tuple; 66, 67; 67, integer:3; 68, parenthesized_expression; 68, 69; 69, boolean_operator:and; 69, 70; 69, 78; 70, comparison_operator:==; 70, 71; 70, 77; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, attribute; 74, 75; 74, 76; 75, identifier:x; 76, identifier:shape; 77, integer:2; 78, comparison_operator:==; 78, 79; 78, 84; 79, subscript; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:x; 82, identifier:shape; 83, integer:1; 84, integer:3; 85, not_operator; 85, 86; 86, identifier:columns; 87, block; 87, 88; 88, return_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:np; 92, identifier:dot; 93, argument_list; 93, 94; 93, 95; 94, identifier:x; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:r; 100, identifier:transpose; 101, argument_list; 102, elif_clause; 102, 103; 102, 108; 103, call; 103, 104; 103, 105; 104, identifier:isinstance; 105, argument_list; 105, 106; 105, 107; 106, identifier:x; 107, identifier:Complete; 108, block; 108, 109; 109, return_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:Complete; 112, argument_list; 112, 113; 112, 124; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:dot; 117, argument_list; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:r; 121, attribute; 121, 122; 121, 123; 122, identifier:x; 123, identifier:r; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:np; 127, identifier:dot; 128, argument_list; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:r; 132, attribute; 132, 133; 132, 134; 133, identifier:x; 134, identifier:t; 135, elif_clause; 135, 136; 135, 141; 136, call; 136, 137; 136, 138; 137, identifier:isinstance; 138, argument_list; 138, 139; 138, 140; 139, identifier:x; 140, identifier:Translation; 141, block; 141, 142; 142, return_statement; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:Complete; 145, argument_list; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:r; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:np; 152, identifier:dot; 153, argument_list; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:r; 157, attribute; 157, 158; 157, 159; 158, identifier:x; 159, identifier:t; 160, elif_clause; 160, 161; 160, 166; 161, call; 161, 162; 161, 163; 162, identifier:isinstance; 163, argument_list; 163, 164; 163, 165; 164, identifier:x; 165, identifier:Rotation; 166, block; 166, 167; 167, return_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:Rotation; 170, argument_list; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:np; 174, identifier:dot; 175, argument_list; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:r; 179, attribute; 179, 180; 179, 181; 180, identifier:x; 181, identifier:r; 182, elif_clause; 182, 183; 182, 188; 183, call; 183, 184; 183, 185; 184, identifier:isinstance; 185, argument_list; 185, 186; 185, 187; 186, identifier:x; 187, identifier:UnitCell; 188, block; 188, 189; 189, return_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:UnitCell; 192, argument_list; 192, 193; 192, 204; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:np; 196, identifier:dot; 197, argument_list; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:r; 201, attribute; 201, 202; 201, 203; 202, identifier:x; 203, identifier:matrix; 204, attribute; 204, 205; 204, 206; 205, identifier:x; 206, identifier:active; 207, else_clause; 207, 208; 208, block; 208, 209; 209, raise_statement; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:ValueError; 212, argument_list; 212, 213; 213, binary_operator:%; 213, 214; 213, 215; 214, string:"Can not apply this rotation to %s"; 215, identifier:x | def apply_to(self, x, columns=False):
"""Apply this rotation to the given object
The argument can be several sorts of objects:
* ``np.array`` with shape (3, )
* ``np.array`` with shape (N, 3)
* ``np.array`` with shape (3, N), use ``columns=True``
* ``Translation``
* ``Rotation``
* ``Complete``
* ``UnitCell``
In case of arrays, the 3D vectors are rotated. In case of trans-
formations, a transformation is returned that consists of this
rotation applied AFTER the given translation. In case of a unit cell,
a unit cell with rotated cell vectors is returned.
This method is equivalent to ``self*x``.
"""
if isinstance(x, np.ndarray) and len(x.shape) == 2 and x.shape[0] == 3 and columns:
return np.dot(self.r, x)
if isinstance(x, np.ndarray) and (x.shape == (3, ) or (len(x.shape) == 2 and x.shape[1] == 3)) and not columns:
return np.dot(x, self.r.transpose())
elif isinstance(x, Complete):
return Complete(np.dot(self.r, x.r), np.dot(self.r, x.t))
elif isinstance(x, Translation):
return Complete(self.r, np.dot(self.r, x.t))
elif isinstance(x, Rotation):
return Rotation(np.dot(self.r, x.r))
elif isinstance(x, UnitCell):
return UnitCell(np.dot(self.r, x.matrix), x.active)
else:
raise ValueError("Can not apply this rotation to %s" % x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:canonical_order; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 53; 5, 54; 5, 55; 5, 56; 5, 57; 5, 58; 5, 59; 5, 60; 5, 61; 5, 62; 5, 115; 5, 124; 5, 125; 5, 126; 5, 127; 5, 128; 5, 129; 5, 130; 5, 131; 5, 132; 5, 133; 5, 134; 5, 135; 5, 136; 5, 137; 5, 138; 5, 139; 5, 140; 5, 141; 5, 175; 5, 176; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, comment; 10, comment; 11, comment; 12, comment; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:starting_vertex; 16, subscript; 16, 17; 16, 51; 17, call; 17, 18; 17, 19; 18, identifier:max; 19, generator_expression; 19, 20; 19, 46; 20, tuple; 20, 21; 20, 30; 20, 36; 20, 45; 21, unary_operator:-; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:len; 24, argument_list; 24, 25; 25, subscript; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:equivalent_vertices; 29, identifier:vertex; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:get_vertex_string; 34, argument_list; 34, 35; 35, identifier:vertex; 36, call; 36, 37; 36, 44; 37, attribute; 37, 38; 37, 43; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:vertex_fingerprints; 42, identifier:vertex; 43, identifier:tobytes; 44, argument_list; 45, identifier:vertex; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:vertex; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:central_vertices; 51, unary_operator:-; 51, 52; 52, integer:1; 53, comment; 54, comment; 55, comment; 56, comment; 57, comment; 58, comment; 59, comment; 60, comment; 61, comment; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:l; 65, list_comprehension; 65, 66; 65, 94; 65, 104; 66, list:[
-distance,
-len(self.equivalent_vertices[vertex]),
self.get_vertex_string(vertex),
self.vertex_fingerprints[vertex].tobytes(),
vertex
]; 66, 67; 66, 69; 66, 78; 66, 84; 66, 93; 67, unary_operator:-; 67, 68; 68, identifier:distance; 69, unary_operator:-; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:len; 72, argument_list; 72, 73; 73, subscript; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:equivalent_vertices; 77, identifier:vertex; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:get_vertex_string; 82, argument_list; 82, 83; 83, identifier:vertex; 84, call; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:vertex_fingerprints; 90, identifier:vertex; 91, identifier:tobytes; 92, argument_list; 93, identifier:vertex; 94, for_in_clause; 94, 95; 94, 98; 95, pattern_list; 95, 96; 95, 97; 96, identifier:vertex; 97, identifier:distance; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:iter_breadth_first; 102, argument_list; 102, 103; 103, identifier:starting_vertex; 104, if_clause; 104, 105; 105, comparison_operator:>; 105, 106; 105, 114; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, subscript; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:neighbors; 113, identifier:vertex; 114, integer:0; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:l; 119, identifier:sort; 120, argument_list; 120, 121; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:reverse; 123, True; 124, comment; 125, comment; 126, comment; 127, comment; 128, comment; 129, comment; 130, comment; 131, comment; 132, comment; 133, comment; 134, comment; 135, comment; 136, comment; 137, comment; 138, comment; 139, comment; 140, comment; 141, for_statement; 141, 142; 141, 143; 141, 151; 142, identifier:i; 143, call; 143, 144; 143, 145; 144, identifier:range; 145, argument_list; 145, 146; 145, 147; 146, integer:1; 147, call; 147, 148; 147, 149; 148, identifier:len; 149, argument_list; 149, 150; 150, identifier:l; 151, block; 151, 152; 152, if_statement; 152, 153; 152, 172; 153, comparison_operator:==; 153, 154; 153, 162; 154, subscript; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:l; 157, identifier:i; 158, slice; 158, 159; 158, 160; 159, colon; 160, unary_operator:-; 160, 161; 161, integer:1; 162, subscript; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 165; 164, identifier:l; 165, binary_operator:-; 165, 166; 165, 167; 166, identifier:i; 167, integer:1; 168, slice; 168, 169; 168, 170; 169, colon; 170, unary_operator:-; 170, 171; 171, integer:1; 172, block; 172, 173; 173, raise_statement; 173, 174; 174, identifier:NotImplementedError; 175, comment; 176, return_statement; 176, 177; 177, list_comprehension; 177, 178; 177, 182; 178, subscript; 178, 179; 178, 180; 179, identifier:record; 180, unary_operator:-; 180, 181; 181, integer:1; 182, for_in_clause; 182, 183; 182, 184; 183, identifier:record; 184, identifier:l | def canonical_order(self):
"""The vertices in a canonical or normalized order.
This routine will return a list of vertices in an order that does not
depend on the initial order, but only depends on the connectivity and
the return values of the function self.get_vertex_string.
Only the vertices that are involved in edges will be included. The
result can be given as first argument to self.get_subgraph, with
reduce=True as second argument. This will return a complete canonical
graph.
The routine is designed not to use symmetry relations that are
obtained with the GraphSearch routine. We also tried to create an
ordering that feels like natural, i.e. starting in the center and
pushing vertices with few equivalents to the front. If necessary, the
nature of the vertices and their bonds to atoms closer to the center
will also play a role, but only as a last resort.
"""
# A) find an appropriate starting vertex.
# Here we take a central vertex that has a minimal number of symmetrical
# equivalents, 'the highest atom number', and the highest fingerprint.
# Note that the symmetrical equivalents are computed from the vertex
# fingerprints, i.e. without the GraphSearch.
starting_vertex = max(
(
-len(self.equivalent_vertices[vertex]),
self.get_vertex_string(vertex),
self.vertex_fingerprints[vertex].tobytes(),
vertex
) for vertex in self.central_vertices
)[-1]
# B) sort all vertices based on
# 1) distance from central vertex
# 2) number of equivalent vertices
# 3) vertex string, (higher atom numbers come first)
# 4) fingerprint
# 5) vertex index
# The last field is only included to collect the result of the sort.
# The fingerprint on itself would be sufficient, but the three first are
# there to have a naturally appealing result.
l = [
[
-distance,
-len(self.equivalent_vertices[vertex]),
self.get_vertex_string(vertex),
self.vertex_fingerprints[vertex].tobytes(),
vertex
] for vertex, distance in self.iter_breadth_first(starting_vertex)
if len(self.neighbors[vertex]) > 0
]
l.sort(reverse=True)
# C) The order of some vertices is still not completely set. e.g.
# consider the case of allene. The four hydrogen atoms are equivalent,
# but one can have two different orders: make geminiles consecutive or
# don't. It is more trikcy than one would think at first sight. In the
# case of allene, geminility could easily solve the problem. Consider a
# big flat rotationally symmetric molecule (order 2). The first five
# shells are order 4 and one would just give a random order to four
# segemnts in the first shell. Only when one reaches the outer part that
# has order two, it turns out that the arbitrary choices in the inner
# shell play a role. So it does not help to look at relations with
# vertices at inner or current shells only. One has to consider the
# whole picture. (unit testing reveals troubles like these)
# I need some sleep now. The code below checks for potential fuzz and
# will raise an error if the ordering is not fully determined yet. One
# day, I'll need this code more than I do now, and I'll fix things up.
# I know how to do this, but I don't care enough right now.
# -- Toon
for i in range(1, len(l)):
if l[i][:-1] == l[i-1][:-1]:
raise NotImplementedError
# D) Return only the vertex indexes.
return [record[-1] for record in l] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_subgraph; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:subvertices; 6, default_parameter; 6, 7; 6, 8; 7, identifier:normalize; 8, False; 9, block; 9, 10; 9, 12; 9, 268; 10, expression_statement; 10, 11; 11, comment; 12, if_statement; 12, 13; 12, 14; 12, 197; 13, identifier:normalize; 14, block; 14, 15; 14, 32; 14, 36; 14, 40; 14, 99; 14, 100; 14, 113; 14, 114; 14, 135; 14, 145; 14, 155; 14, 168; 14, 182; 14, 183; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:revorder; 18, call; 18, 19; 18, 20; 19, identifier:dict; 20, generator_expression; 20, 21; 20, 24; 21, tuple; 21, 22; 21, 23; 22, identifier:j; 23, identifier:i; 24, for_in_clause; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:i; 27, identifier:j; 28, call; 28, 29; 28, 30; 29, identifier:enumerate; 30, argument_list; 30, 31; 31, identifier:subvertices; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:new_edges; 35, list:[]; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:old_edge_indexes; 39, list:[]; 40, for_statement; 40, 41; 40, 46; 40, 52; 41, pattern_list; 41, 42; 41, 43; 42, identifier:counter; 43, tuple_pattern; 43, 44; 43, 45; 44, identifier:i; 45, identifier:j; 46, call; 46, 47; 46, 48; 47, identifier:enumerate; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:edges; 52, block; 52, 53; 52, 62; 52, 68; 52, 77; 52, 83; 52, 92; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:new_i; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:revorder; 59, identifier:get; 60, argument_list; 60, 61; 61, identifier:i; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:new_i; 65, None; 66, block; 66, 67; 67, continue_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:new_j; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:revorder; 74, identifier:get; 75, argument_list; 75, 76; 76, identifier:j; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:is; 78, 79; 78, 80; 79, identifier:new_j; 80, None; 81, block; 81, 82; 82, continue_statement; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:new_edges; 87, identifier:append; 88, argument_list; 88, 89; 89, tuple; 89, 90; 89, 91; 90, identifier:new_i; 91, identifier:new_j; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:old_edge_indexes; 96, identifier:append; 97, argument_list; 97, 98; 98, identifier:counter; 99, comment; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:order; 103, call; 103, 104; 103, 105; 104, identifier:list; 105, argument_list; 105, 106; 106, call; 106, 107; 106, 108; 107, identifier:range; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:len; 111, argument_list; 111, 112; 112, identifier:new_edges; 113, comment; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:order; 118, identifier:sort; 119, argument_list; 119, 120; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:key; 122, parenthesized_expression; 122, 123; 123, lambda; 123, 124; 123, 126; 124, lambda_parameters; 124, 125; 125, identifier:i; 126, call; 126, 127; 126, 128; 127, identifier:tuple; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:sorted; 131, argument_list; 131, 132; 132, subscript; 132, 133; 132, 134; 133, identifier:new_edges; 134, identifier:i; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:new_edges; 138, list_comprehension; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:new_edges; 141, identifier:i; 142, for_in_clause; 142, 143; 142, 144; 143, identifier:i; 144, identifier:order; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:old_edge_indexes; 148, list_comprehension; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:old_edge_indexes; 151, identifier:i; 152, for_in_clause; 152, 153; 152, 154; 153, identifier:i; 154, identifier:order; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:result; 158, call; 158, 159; 158, 160; 159, identifier:Graph; 160, argument_list; 160, 161; 160, 162; 161, identifier:new_edges; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:num_vertices; 164, call; 164, 165; 164, 166; 165, identifier:len; 166, argument_list; 166, 167; 167, identifier:subvertices; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:result; 172, identifier:_old_vertex_indexes; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:np; 176, identifier:array; 177, argument_list; 177, 178; 177, 179; 178, identifier:subvertices; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:dtype; 181, identifier:int; 182, comment; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:result; 187, identifier:_old_edge_indexes; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:np; 191, identifier:array; 192, argument_list; 192, 193; 192, 194; 193, identifier:old_edge_indexes; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:dtype; 196, identifier:int; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 206; 198, 236; 198, 250; 198, 260; 198, 266; 198, 267; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:subvertices; 202, call; 202, 203; 202, 204; 203, identifier:set; 204, argument_list; 204, 205; 205, identifier:subvertices; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:old_edge_indexes; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:np; 212, identifier:array; 213, argument_list; 213, 214; 213, 233; 214, list_comprehension; 214, 215; 214, 216; 214, 226; 215, identifier:i; 216, for_in_clause; 216, 217; 216, 220; 217, pattern_list; 217, 218; 217, 219; 218, identifier:i; 219, identifier:edge; 220, call; 220, 221; 220, 222; 221, identifier:enumerate; 222, argument_list; 222, 223; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:edges; 226, if_clause; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:edge; 230, identifier:issubset; 231, argument_list; 231, 232; 232, identifier:subvertices; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:dtype; 235, identifier:int; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:new_edges; 239, call; 239, 240; 239, 241; 240, identifier:tuple; 241, generator_expression; 241, 242; 241, 247; 242, subscript; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:edges; 246, identifier:i; 247, for_in_clause; 247, 248; 247, 249; 248, identifier:i; 249, identifier:old_edge_indexes; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:result; 253, call; 253, 254; 253, 255; 254, identifier:Graph; 255, argument_list; 255, 256; 255, 257; 256, identifier:new_edges; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:num_vertices; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:result; 264, identifier:_old_edge_indexes; 265, identifier:old_edge_indexes; 266, comment; 267, comment; 268, return_statement; 268, 269; 269, identifier:result | def get_subgraph(self, subvertices, normalize=False):
"""Constructs a subgraph of the current graph
Arguments:
| ``subvertices`` -- The vertices that should be retained.
| ``normalize`` -- Whether or not the vertices should renumbered and
reduced to the given set of subvertices. When True, also the
edges are sorted. It the end, this means that new order of the
edges does not depend on the original order, but only on the
order of the argument subvertices.
This option is False by default. When False, only edges will be
discarded, but the retained data remain unchanged. Also the
parameter num_vertices is not affected.
The returned graph will have an attribute ``old_edge_indexes`` that
relates the positions of the new and the old edges as follows::
>>> self.edges[result._old_edge_indexes[i]] = result.edges[i]
In derived classes, the following should be supported::
>>> self.edge_property[result._old_edge_indexes[i]] = result.edge_property[i]
When ``normalize==True``, also the vertices are affected and the
derived classes should make sure that the following works::
>>> self.vertex_property[result._old_vertex_indexes[i]] = result.vertex_property[i]
The attribute ``old_vertex_indexes`` is only constructed when
``normalize==True``.
"""
if normalize:
revorder = dict((j, i) for i, j in enumerate(subvertices))
new_edges = []
old_edge_indexes = []
for counter, (i, j) in enumerate(self.edges):
new_i = revorder.get(i)
if new_i is None:
continue
new_j = revorder.get(j)
if new_j is None:
continue
new_edges.append((new_i, new_j))
old_edge_indexes.append(counter)
# sort the edges
order = list(range(len(new_edges)))
# argsort in pure python
order.sort( key=(lambda i: tuple(sorted(new_edges[i]))) )
new_edges = [new_edges[i] for i in order]
old_edge_indexes = [old_edge_indexes[i] for i in order]
result = Graph(new_edges, num_vertices=len(subvertices))
result._old_vertex_indexes = np.array(subvertices, dtype=int)
#result.new_vertex_indexes = revorder
result._old_edge_indexes = np.array(old_edge_indexes, dtype=int)
else:
subvertices = set(subvertices)
old_edge_indexes = np.array([
i for i, edge in enumerate(self.edges)
if edge.issubset(subvertices)
], dtype=int)
new_edges = tuple(self.edges[i] for i in old_edge_indexes)
result = Graph(new_edges, self.num_vertices)
result._old_edge_indexes = old_edge_indexes
# no need for old and new vertex_indexes because they remain the
# same.
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_closed_cycles; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 9; 5, 13; 5, 26; 5, 47; 5, 51; 5, 158; 5, 159; 5, 165; 5, 166; 5, 167; 5, 168; 5, 181; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:closed_cycles; 12, list:[]; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:todo; 16, call; 16, 17; 16, 18; 17, identifier:set; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:forward; 24, identifier:keys; 25, argument_list; 26, if_statement; 26, 27; 26, 39; 27, comparison_operator:!=; 27, 28; 27, 29; 28, identifier:todo; 29, call; 29, 30; 29, 31; 30, identifier:set; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:forward; 37, identifier:values; 38, argument_list; 39, block; 39, 40; 40, raise_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:GraphError; 43, argument_list; 43, 44; 44, concatenated_string; 44, 45; 44, 46; 45, string:"The subject and pattern graph must have the same "; 46, string:"numbering."; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:current_vertex; 50, None; 51, while_statement; 51, 52; 51, 58; 52, comparison_operator:>; 52, 53; 52, 57; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:todo; 57, integer:0; 58, block; 58, 59; 58, 85; 58, 92; 58, 101; 59, if_statement; 59, 60; 59, 63; 59, 76; 60, comparison_operator:==; 60, 61; 60, 62; 61, identifier:current_vertex; 62, None; 63, block; 63, 64; 63, 72; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:current_vertex; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:todo; 70, identifier:pop; 71, argument_list; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:current_cycle; 75, list:[]; 76, else_clause; 76, 77; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:todo; 82, identifier:discard; 83, argument_list; 83, 84; 84, identifier:current_vertex; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:current_cycle; 89, identifier:append; 90, argument_list; 90, 91; 91, identifier:current_vertex; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:next_vertex; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:get_destination; 99, argument_list; 99, 100; 100, identifier:current_vertex; 101, if_statement; 101, 102; 101, 107; 101, 152; 102, comparison_operator:==; 102, 103; 102, 104; 103, identifier:next_vertex; 104, subscript; 104, 105; 104, 106; 105, identifier:current_cycle; 106, integer:0; 107, block; 107, 108; 107, 148; 108, if_statement; 108, 109; 108, 115; 108, 116; 109, comparison_operator:>; 109, 110; 109, 114; 110, call; 110, 111; 110, 112; 111, identifier:len; 112, argument_list; 112, 113; 113, identifier:current_cycle; 114, integer:1; 115, comment; 116, block; 116, 117; 116, 126; 116, 141; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:pivot; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:np; 123, identifier:argmin; 124, argument_list; 124, 125; 125, identifier:current_cycle; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:current_cycle; 129, binary_operator:+; 129, 130; 129, 135; 129, 136; 130, subscript; 130, 131; 130, 132; 131, identifier:current_cycle; 132, slice; 132, 133; 132, 134; 133, identifier:pivot; 134, colon; 135, line_continuation:\; 136, subscript; 136, 137; 136, 138; 137, identifier:current_cycle; 138, slice; 138, 139; 138, 140; 139, colon; 140, identifier:pivot; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:closed_cycles; 145, identifier:append; 146, argument_list; 146, 147; 147, identifier:current_cycle; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:current_vertex; 151, None; 152, else_clause; 152, 153; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:current_vertex; 157, identifier:next_vertex; 158, comment; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:closed_cycles; 163, identifier:sort; 164, argument_list; 165, comment; 166, comment; 167, comment; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:closed_cycles; 171, call; 171, 172; 171, 173; 172, identifier:tuple; 173, generator_expression; 173, 174; 173, 178; 174, call; 174, 175; 174, 176; 175, identifier:tuple; 176, argument_list; 176, 177; 177, identifier:cycle; 178, for_in_clause; 178, 179; 178, 180; 179, identifier:cycle; 180, identifier:closed_cycles; 181, return_statement; 181, 182; 182, identifier:closed_cycles | def get_closed_cycles(self):
"""Return the closed cycles corresponding to this permutation
The cycle will be normalized to facilitate the elimination of
duplicates. The following is guaranteed:
1) If this permutation is represented by disconnected cycles, the
cycles will be sorted by the lowest index they contain.
2) Each cycle starts with its lowest index. (unique starting point)
3) Singletons are discarded. (because they are boring)
"""
# A) construct all the cycles
closed_cycles = []
todo = set(self.forward.keys())
if todo != set(self.forward.values()):
raise GraphError("The subject and pattern graph must have the same "
"numbering.")
current_vertex = None
while len(todo) > 0:
if current_vertex == None:
current_vertex = todo.pop()
current_cycle = []
else:
todo.discard(current_vertex)
current_cycle.append(current_vertex)
next_vertex = self.get_destination(current_vertex)
if next_vertex == current_cycle[0]:
if len(current_cycle) > 1:
# bring the lowest element in front
pivot = np.argmin(current_cycle)
current_cycle = current_cycle[pivot:] + \
current_cycle[:pivot]
closed_cycles.append(current_cycle)
current_vertex = None
else:
current_vertex = next_vertex
# B) normalize the cycle representation
closed_cycles.sort() # a normal sort is sufficient because only the
# first item of each cycle is considered
# transform the structure into a tuple of tuples
closed_cycles = tuple(tuple(cycle) for cycle in closed_cycles)
return closed_cycles |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sorted_exists; 3, parameters; 3, 4; 3, 5; 4, identifier:values; 5, identifier:x; 6, block; 6, 7; 6, 9; 6, 17; 6, 25; 6, 36; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:i; 12, call; 12, 13; 12, 14; 13, identifier:bisect_left; 14, argument_list; 14, 15; 14, 16; 15, identifier:values; 16, identifier:x; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:j; 20, call; 20, 21; 20, 22; 21, identifier:bisect_right; 22, argument_list; 22, 23; 22, 24; 23, identifier:values; 24, identifier:x; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:exists; 28, comparison_operator:in; 28, 29; 28, 30; 29, identifier:x; 30, subscript; 30, 31; 30, 32; 31, identifier:values; 32, slice; 32, 33; 32, 34; 32, 35; 33, identifier:i; 34, colon; 35, identifier:j; 36, return_statement; 36, 37; 37, expression_list; 37, 38; 37, 39; 38, identifier:exists; 39, identifier:i | def sorted_exists(values, x):
"""
For list, values, returns the insert position for item x and whether the item already exists in the list. This
allows one function call to return either the index to overwrite an existing value in the list, or the index to
insert a new item in the list and keep the list in sorted order.
:param values: list
:param x: item
:return: (exists, index) tuple
"""
i = bisect_left(values, x)
j = bisect_right(values, x)
exists = x in values[i:j]
return exists, i |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sorted_index; 3, parameters; 3, 4; 3, 5; 4, identifier:values; 5, identifier:x; 6, block; 6, 7; 6, 9; 6, 17; 6, 25; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:i; 12, call; 12, 13; 12, 14; 13, identifier:bisect_left; 14, argument_list; 14, 15; 14, 16; 15, identifier:values; 16, identifier:x; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:j; 20, call; 20, 21; 20, 22; 21, identifier:bisect_right; 22, argument_list; 22, 23; 22, 24; 23, identifier:values; 24, identifier:x; 25, return_statement; 25, 26; 26, binary_operator:+; 26, 27; 26, 38; 27, call; 27, 28; 27, 36; 28, attribute; 28, 29; 28, 35; 29, subscript; 29, 30; 29, 31; 30, identifier:values; 31, slice; 31, 32; 31, 33; 31, 34; 32, identifier:i; 33, colon; 34, identifier:j; 35, identifier:index; 36, argument_list; 36, 37; 37, identifier:x; 38, identifier:i | def sorted_index(values, x):
"""
For list, values, returns the index location of element x. If x does not exist will raise an error.
:param values: list
:param x: item
:return: integer index
"""
i = bisect_left(values, x)
j = bisect_right(values, x)
return values[i:j].index(x) + i |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_index; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 17; 5, 18; 5, 48; 5, 49; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:sort; 11, call; 11, 12; 11, 13; 12, identifier:sorted_list_indexes; 13, argument_list; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_index; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_index; 23, conditional_expression:if; 23, 24; 23, 36; 23, 39; 24, call; 24, 25; 24, 26; 25, identifier:blist; 26, argument_list; 26, 27; 27, list_comprehension; 27, 28; 27, 33; 28, subscript; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_index; 32, identifier:x; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:x; 35, identifier:sort; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_blist; 39, list_comprehension; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_index; 44, identifier:x; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:x; 47, identifier:sort; 48, comment; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_data; 54, conditional_expression:if; 54, 55; 54, 67; 54, 70; 55, call; 55, 56; 55, 57; 56, identifier:blist; 57, argument_list; 57, 58; 58, list_comprehension; 58, 59; 58, 64; 59, subscript; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_data; 63, identifier:x; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:x; 66, identifier:sort; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:_blist; 70, list_comprehension; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_data; 75, identifier:x; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:x; 78, identifier:sort | def sort_index(self):
"""
Sort the Series by the index. The sort modifies the Series inplace
:return: nothing
"""
sort = sorted_list_indexes(self._index)
# sort index
self._index = blist([self._index[x] for x in sort]) if self._blist else [self._index[x] for x in sort]
# sort data
self._data = blist([self._data[x] for x in sort]) if self._blist else [self._data[x] for x in sort] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_add_missing_rows; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:indexes; 6, block; 6, 7; 6, 9; 6, 23; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:new_indexes; 12, list_comprehension; 12, 13; 12, 14; 12, 17; 13, identifier:x; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:x; 16, identifier:indexes; 17, if_clause; 17, 18; 18, comparison_operator:not; 18, 19; 18, 20; 19, identifier:x; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_index; 23, for_statement; 23, 24; 23, 25; 23, 26; 24, identifier:x; 25, identifier:new_indexes; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_add_row; 32, argument_list; 32, 33; 33, identifier:x | def _add_missing_rows(self, indexes):
"""
Given a list of indexes, find all the indexes that are not currently in the Series and make a new row for
that index by appending to the Series. This does not maintain sorted order for the index.
:param indexes: list of indexes
:return: nothing
"""
new_indexes = [x for x in indexes if x not in self._index]
for x in new_indexes:
self._add_row(x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_insert_missing_rows; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:indexes; 6, block; 6, 7; 6, 9; 6, 23; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:new_indexes; 12, list_comprehension; 12, 13; 12, 14; 12, 17; 13, identifier:x; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:x; 16, identifier:indexes; 17, if_clause; 17, 18; 18, comparison_operator:not; 18, 19; 18, 20; 19, identifier:x; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_index; 23, for_statement; 23, 24; 23, 25; 23, 26; 24, identifier:x; 25, identifier:new_indexes; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_insert_row; 32, argument_list; 32, 33; 32, 40; 33, call; 33, 34; 33, 35; 34, identifier:bisect_left; 35, argument_list; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_index; 39, identifier:x; 40, identifier:x | def _insert_missing_rows(self, indexes):
"""
Given a list of indexes, find all the indexes that are not currently in the Series and make a new row for
that index, inserting into the index. This requires the Series to be sorted=True
:param indexes: list of indexes
:return: nothing
"""
new_indexes = [x for x in indexes if x not in self._index]
for x in new_indexes:
self._insert_row(bisect_left(self._index, x), x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:append_row; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:index; 6, identifier:value; 7, block; 7, 8; 7, 10; 7, 22; 7, 31; 8, expression_statement; 8, 9; 9, comment; 10, if_statement; 10, 11; 10, 16; 11, comparison_operator:in; 11, 12; 11, 13; 12, identifier:index; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_index; 16, block; 16, 17; 17, raise_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:IndexError; 20, argument_list; 20, 21; 21, string:'index already in Series'; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_index; 28, identifier:append; 29, argument_list; 29, 30; 30, identifier:index; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_data; 37, identifier:append; 38, argument_list; 38, 39; 39, identifier:value | def append_row(self, index, value):
"""
Appends a row of value to the end of the data. Be very careful with this function as for sorted Series it will
not enforce sort order. Use this only for speed when needed, be careful.
:param index: index
:param value: value
:return: nothing
"""
if index in self._index:
raise IndexError('index already in Series')
self._index.append(index)
self._data.append(value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:append_rows; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:indexes; 6, identifier:values; 7, block; 7, 8; 7, 10; 7, 11; 7, 27; 7, 28; 7, 36; 7, 55; 7, 56; 7, 65; 8, expression_statement; 8, 9; 9, comment; 10, comment; 11, if_statement; 11, 12; 11, 21; 12, comparison_operator:!=; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:len; 15, argument_list; 15, 16; 16, identifier:values; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, identifier:indexes; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, string:'length of values is not equal to length of indexes'; 27, comment; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:combined_index; 31, binary_operator:+; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_index; 35, identifier:indexes; 36, if_statement; 36, 37; 36, 49; 37, comparison_operator:!=; 37, 38; 37, 45; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:set; 43, argument_list; 43, 44; 44, identifier:combined_index; 45, call; 45, 46; 45, 47; 46, identifier:len; 47, argument_list; 47, 48; 48, identifier:combined_index; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:IndexError; 53, argument_list; 53, 54; 54, string:'duplicate indexes in Series'; 55, comment; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:_index; 62, identifier:extend; 63, argument_list; 63, 64; 64, identifier:indexes; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_data; 71, identifier:extend; 72, argument_list; 72, 73; 73, identifier:values | def append_rows(self, indexes, values):
"""
Appends values to the end of the data. Be very careful with this function as for sort DataFrames it will not
enforce sort order. Use this only for speed when needed, be careful.
:param indexes: list of indexes to append
:param values: list of values to append
:return: nothing
"""
# check that the values data is less than or equal to the length of the indexes
if len(values) != len(indexes):
raise ValueError('length of values is not equal to length of indexes')
# check the indexes are not duplicates
combined_index = self._index + indexes
if len(set(combined_index)) != len(combined_index):
raise IndexError('duplicate indexes in Series')
# append index value
self._index.extend(indexes)
self._data.extend(values) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sort_columns; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:columns_list; 6, block; 6, 7; 6, 9; 6, 43; 6, 58; 6, 88; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 37; 10, not_operator; 10, 11; 11, parenthesized_expression; 11, 12; 12, boolean_operator:and; 12, 13; 12, 25; 13, call; 13, 14; 13, 15; 14, identifier:all; 15, argument_list; 15, 16; 16, list_comprehension; 16, 17; 16, 20; 17, comparison_operator:in; 17, 18; 17, 19; 18, identifier:x; 19, identifier:columns_list; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:x; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_columns; 25, call; 25, 26; 25, 27; 26, identifier:all; 27, argument_list; 27, 28; 28, list_comprehension; 28, 29; 28, 34; 29, comparison_operator:in; 29, 30; 29, 31; 30, identifier:x; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_columns; 34, for_in_clause; 34, 35; 34, 36; 35, identifier:x; 36, identifier:columns_list; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:ValueError; 41, argument_list; 41, 42; 42, string:'columns_list must be all in current columns, and all current columns must be in columns_list'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:new_sort; 46, list_comprehension; 46, 47; 46, 55; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:_columns; 52, identifier:index; 53, argument_list; 53, 54; 54, identifier:x; 55, for_in_clause; 55, 56; 55, 57; 56, identifier:x; 57, identifier:columns_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_data; 63, conditional_expression:if; 63, 64; 63, 76; 63, 79; 64, call; 64, 65; 64, 66; 65, identifier:blist; 66, argument_list; 66, 67; 67, list_comprehension; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_data; 72, identifier:x; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:x; 75, identifier:new_sort; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_blist; 79, list_comprehension; 79, 80; 79, 85; 80, subscript; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_data; 84, identifier:x; 85, for_in_clause; 85, 86; 85, 87; 86, identifier:x; 87, identifier:new_sort; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_columns; 93, conditional_expression:if; 93, 94; 93, 106; 93, 109; 93, 110; 94, call; 94, 95; 94, 96; 95, identifier:blist; 96, argument_list; 96, 97; 97, list_comprehension; 97, 98; 97, 103; 98, subscript; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_columns; 102, identifier:x; 103, for_in_clause; 103, 104; 103, 105; 104, identifier:x; 105, identifier:new_sort; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:_blist; 109, line_continuation:\; 110, list_comprehension; 110, 111; 110, 116; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_columns; 115, identifier:x; 116, for_in_clause; 116, 117; 116, 118; 117, identifier:x; 118, identifier:new_sort | def _sort_columns(self, columns_list):
"""
Given a list of column names will sort the DataFrame columns to match the given order
:param columns_list: list of column names. Must include all column names
:return: nothing
"""
if not (all([x in columns_list for x in self._columns]) and all([x in self._columns for x in columns_list])):
raise ValueError(
'columns_list must be all in current columns, and all current columns must be in columns_list')
new_sort = [self._columns.index(x) for x in columns_list]
self._data = blist([self._data[x] for x in new_sort]) if self._blist else [self._data[x] for x in new_sort]
self._columns = blist([self._columns[x] for x in new_sort]) if self._blist \
else [self._columns[x] for x in new_sort] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:append_row; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:index; 6, identifier:values; 7, default_parameter; 7, 8; 7, 9; 8, identifier:new_cols; 9, True; 10, block; 10, 11; 10, 13; 10, 25; 10, 46; 10, 47; 10, 56; 10, 57; 11, expression_statement; 11, 12; 12, comment; 13, if_statement; 13, 14; 13, 19; 14, comparison_operator:in; 14, 15; 14, 16; 15, identifier:index; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_index; 19, block; 19, 20; 20, raise_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:IndexError; 23, argument_list; 23, 24; 24, string:'index already in DataFrame'; 25, if_statement; 25, 26; 25, 27; 26, identifier:new_cols; 27, block; 27, 28; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:col; 30, identifier:values; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 38; 33, comparison_operator:not; 33, 34; 33, 35; 34, identifier:col; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_columns; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_add_column; 44, argument_list; 44, 45; 45, identifier:col; 46, comment; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_index; 53, identifier:append; 54, argument_list; 54, 55; 55, identifier:index; 56, comment; 57, for_statement; 57, 58; 57, 61; 57, 67; 58, pattern_list; 58, 59; 58, 60; 59, identifier:c; 60, identifier:col; 61, call; 61, 62; 61, 63; 62, identifier:enumerate; 63, argument_list; 63, 64; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_columns; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 77; 70, attribute; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_data; 75, identifier:c; 76, identifier:append; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:values; 81, identifier:get; 82, argument_list; 82, 83; 82, 84; 83, identifier:col; 84, None | def append_row(self, index, values, new_cols=True):
"""
Appends a row of values to the end of the data. If there are new columns in the values and new_cols is True
they will be added. Be very careful with this function as for sort DataFrames it will not enforce sort order.
Use this only for speed when needed, be careful.
:param index: value of the index
:param values: dictionary of values
:param new_cols: if True add new columns in values, if False ignore
:return: nothing
"""
if index in self._index:
raise IndexError('index already in DataFrame')
if new_cols:
for col in values:
if col not in self._columns:
self._add_column(col)
# append index value
self._index.append(index)
# add data values, if not in values then use None
for c, col in enumerate(self._columns):
self._data[c].append(values.get(col, None)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:append_rows; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:indexes; 6, identifier:values; 7, default_parameter; 7, 8; 7, 9; 8, identifier:new_cols; 9, True; 10, block; 10, 11; 10, 13; 10, 14; 10, 38; 10, 39; 10, 47; 10, 66; 10, 87; 10, 88; 10, 97; 10, 98; 10, 132; 11, expression_statement; 11, 12; 12, comment; 13, comment; 14, for_statement; 14, 15; 14, 16; 14, 17; 15, identifier:column; 16, identifier:values; 17, block; 17, 18; 18, if_statement; 18, 19; 18, 30; 19, comparison_operator:>; 19, 20; 19, 26; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, subscript; 23, 24; 23, 25; 24, identifier:values; 25, identifier:column; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:indexes; 30, block; 30, 31; 31, raise_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:ValueError; 34, argument_list; 34, 35; 35, binary_operator:%; 35, 36; 35, 37; 36, string:'length of %s column in values is longer than indexes'; 37, identifier:column; 38, comment; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:combined_index; 42, binary_operator:+; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_index; 46, identifier:indexes; 47, if_statement; 47, 48; 47, 60; 48, comparison_operator:!=; 48, 49; 48, 56; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:set; 54, argument_list; 54, 55; 55, identifier:combined_index; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:combined_index; 60, block; 60, 61; 61, raise_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:IndexError; 64, argument_list; 64, 65; 65, string:'duplicate indexes in DataFrames'; 66, if_statement; 66, 67; 66, 68; 67, identifier:new_cols; 68, block; 68, 69; 69, for_statement; 69, 70; 69, 71; 69, 72; 70, identifier:col; 71, identifier:values; 72, block; 72, 73; 73, if_statement; 73, 74; 73, 79; 74, comparison_operator:not; 74, 75; 74, 76; 75, identifier:col; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_columns; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_add_column; 85, argument_list; 85, 86; 86, identifier:col; 87, comment; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:_index; 94, identifier:extend; 95, argument_list; 95, 96; 96, identifier:indexes; 97, comment; 98, for_statement; 98, 99; 98, 102; 98, 108; 99, pattern_list; 99, 100; 99, 101; 100, identifier:c; 101, identifier:col; 102, call; 102, 103; 102, 104; 103, identifier:enumerate; 104, argument_list; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:_columns; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 118; 111, attribute; 111, 112; 111, 117; 112, subscript; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:_data; 116, identifier:c; 117, identifier:extend; 118, argument_list; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:values; 122, identifier:get; 123, argument_list; 123, 124; 123, 125; 124, identifier:col; 125, binary_operator:*; 125, 126; 125, 128; 126, list:[None]; 126, 127; 127, None; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:indexes; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:_pad_data; 137, argument_list | def append_rows(self, indexes, values, new_cols=True):
"""
Appends rows of values to the end of the data. If there are new columns in the values and new_cols is True
they will be added. Be very careful with this function as for sort DataFrames it will not enforce sort order.
Use this only for speed when needed, be careful.
:param indexes: list of indexes
:param values: dictionary of values where the key is the column name and the value is a list
:param new_cols: if True add new columns in values, if False ignore
:return: nothing
"""
# check that the values data is less than or equal to the length of the indexes
for column in values:
if len(values[column]) > len(indexes):
raise ValueError('length of %s column in values is longer than indexes' % column)
# check the indexes are not duplicates
combined_index = self._index + indexes
if len(set(combined_index)) != len(combined_index):
raise IndexError('duplicate indexes in DataFrames')
if new_cols:
for col in values:
if col not in self._columns:
self._add_column(col)
# append index value
self._index.extend(indexes)
# add data values, if not in values then use None
for c, col in enumerate(self._columns):
self._data[c].extend(values.get(col, [None] * len(indexes)))
self._pad_data() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_index; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 17; 5, 18; 5, 48; 5, 49; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:sort; 11, call; 11, 12; 11, 13; 12, identifier:sorted_list_indexes; 13, argument_list; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_index; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_index; 23, conditional_expression:if; 23, 24; 23, 36; 23, 39; 24, call; 24, 25; 24, 26; 25, identifier:blist; 26, argument_list; 26, 27; 27, list_comprehension; 27, 28; 27, 33; 28, subscript; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_index; 32, identifier:x; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:x; 35, identifier:sort; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_blist; 39, list_comprehension; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_index; 44, identifier:x; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:x; 47, identifier:sort; 48, comment; 49, for_statement; 49, 50; 49, 51; 49, 60; 50, identifier:c; 51, call; 51, 52; 51, 53; 52, identifier:range; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:len; 56, argument_list; 56, 57; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_data; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_data; 67, identifier:c; 68, conditional_expression:if; 68, 69; 68, 83; 68, 86; 69, call; 69, 70; 69, 71; 70, identifier:blist; 71, argument_list; 71, 72; 72, list_comprehension; 72, 73; 72, 80; 73, subscript; 73, 74; 73, 79; 74, subscript; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:_data; 78, identifier:c; 79, identifier:i; 80, for_in_clause; 80, 81; 80, 82; 81, identifier:i; 82, identifier:sort; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_blist; 86, list_comprehension; 86, 87; 86, 94; 87, subscript; 87, 88; 87, 93; 88, subscript; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_data; 92, identifier:c; 93, identifier:i; 94, for_in_clause; 94, 95; 94, 96; 95, identifier:i; 96, identifier:sort | def sort_index(self):
"""
Sort the DataFrame by the index. The sort modifies the DataFrame inplace
:return: nothing
"""
sort = sorted_list_indexes(self._index)
# sort index
self._index = blist([self._index[x] for x in sort]) if self._blist else [self._index[x] for x in sort]
# each column
for c in range(len(self._data)):
self._data[c] = blist([self._data[c][i] for i in sort]) if self._blist else [self._data[c][i] for i in sort] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 1, 5; 2, function_name:tags; 3, parameters; 4, comment; 5, block; 5, 6; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 30; 10, attribute; 10, 11; 10, 29; 11, call; 11, 12; 11, 28; 12, attribute; 12, 13; 12, 27; 13, attribute; 13, 14; 13, 26; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:shell; 17, identifier:run; 18, argument_list; 18, 19; 18, 20; 18, 23; 19, string:'git tag --sort=v:refname'; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:capture; 22, True; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:never_pretend; 25, True; 26, identifier:stdout; 27, identifier:strip; 28, argument_list; 29, identifier:splitlines; 30, argument_list | def tags():
# type: () -> List[str]
""" Returns all tags in the repo.
Returns:
list[str]: List of all tags in the repo, sorted as versions.
All tags returned by this function will be parsed as if the contained
versions (using ``v:refname`` sorting).
"""
return shell.run(
'git tag --sort=v:refname',
capture=True,
never_pretend=True
).stdout.strip().splitlines() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 90; 1, 92; 2, function_name:search; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 15; 3, 20; 3, 25; 3, 30; 3, 35; 3, 40; 3, 45; 3, 50; 3, 55; 3, 60; 3, 65; 3, 70; 3, 75; 3, 80; 3, 85; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:token; 7, type; 7, 8; 8, identifier:dict; 9, None; 10, typed_default_parameter; 10, 11; 10, 12; 10, 14; 11, identifier:query; 12, type; 12, 13; 13, identifier:str; 14, string:""; 15, typed_default_parameter; 15, 16; 15, 17; 15, 19; 16, identifier:bbox; 17, type; 17, 18; 18, identifier:list; 19, None; 20, typed_default_parameter; 20, 21; 20, 22; 20, 24; 21, identifier:poly; 22, type; 22, 23; 23, identifier:str; 24, None; 25, typed_default_parameter; 25, 26; 25, 27; 25, 29; 26, identifier:georel; 27, type; 27, 28; 28, identifier:str; 29, None; 30, typed_default_parameter; 30, 31; 30, 32; 30, 34; 31, identifier:order_by; 32, type; 32, 33; 33, identifier:str; 34, string:"_created"; 35, typed_default_parameter; 35, 36; 35, 37; 35, 39; 36, identifier:order_dir; 37, type; 37, 38; 38, identifier:str; 39, string:"desc"; 40, typed_default_parameter; 40, 41; 40, 42; 40, 44; 41, identifier:page_size; 42, type; 42, 43; 43, identifier:int; 44, integer:100; 45, typed_default_parameter; 45, 46; 45, 47; 45, 49; 46, identifier:offset; 47, type; 47, 48; 48, identifier:int; 49, integer:0; 50, typed_default_parameter; 50, 51; 50, 52; 50, 54; 51, identifier:share; 52, type; 52, 53; 53, identifier:str; 54, None; 55, typed_default_parameter; 55, 56; 55, 57; 55, 59; 56, identifier:specific_md; 57, type; 57, 58; 58, identifier:list; 59, list:[]; 60, typed_default_parameter; 60, 61; 60, 62; 60, 64; 61, identifier:include; 62, type; 62, 63; 63, identifier:list; 64, list:[]; 65, typed_default_parameter; 65, 66; 65, 67; 65, 69; 66, identifier:whole_share; 67, type; 67, 68; 68, identifier:bool; 69, True; 70, typed_default_parameter; 70, 71; 70, 72; 70, 74; 71, identifier:check; 72, type; 72, 73; 73, identifier:bool; 74, True; 75, typed_default_parameter; 75, 76; 75, 77; 75, 79; 76, identifier:augment; 77, type; 77, 78; 78, identifier:bool; 79, False; 80, typed_default_parameter; 80, 81; 80, 82; 80, 84; 81, identifier:tags_as_dicts; 82, type; 82, 83; 83, identifier:bool; 84, False; 85, typed_default_parameter; 85, 86; 85, 87; 85, 89; 86, identifier:prot; 87, type; 87, 88; 88, identifier:str; 89, string:"https"; 90, type; 90, 91; 91, identifier:dict; 92, block; 92, 93; 92, 95; 92, 96; 92, 105; 92, 106; 92, 115; 92, 116; 92, 158; 92, 171; 92, 172; 92, 184; 92, 228; 92, 229; 92, 236; 92, 237; 92, 245; 92, 254; 92, 255; 92, 256; 92, 257; 92, 357; 92, 358; 92, 404; 92, 405; 92, 487; 92, 488; 93, expression_statement; 93, 94; 94, comment; 95, comment; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:specific_md; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:checker; 102, identifier:_check_filter_specific_md; 103, argument_list; 103, 104; 104, identifier:specific_md; 105, comment; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:include; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:checker; 112, identifier:_check_filter_includes; 113, argument_list; 113, 114; 114, identifier:include; 115, comment; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:payload; 119, dictionary; 119, 120; 119, 123; 119, 126; 119, 131; 119, 134; 119, 137; 119, 140; 119, 143; 119, 146; 119, 149; 119, 152; 119, 155; 120, pair; 120, 121; 120, 122; 121, string:"_id"; 122, identifier:specific_md; 123, pair; 123, 124; 123, 125; 124, string:"_include"; 125, identifier:include; 126, pair; 126, 127; 126, 128; 127, string:"_lang"; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:lang; 131, pair; 131, 132; 131, 133; 132, string:"_limit"; 133, identifier:page_size; 134, pair; 134, 135; 134, 136; 135, string:"_offset"; 136, identifier:offset; 137, pair; 137, 138; 137, 139; 138, string:"box"; 139, identifier:bbox; 140, pair; 140, 141; 140, 142; 141, string:"geo"; 142, identifier:poly; 143, pair; 143, 144; 143, 145; 144, string:"rel"; 145, identifier:georel; 146, pair; 146, 147; 146, 148; 147, string:"ob"; 148, identifier:order_by; 149, pair; 149, 150; 149, 151; 150, string:"od"; 151, identifier:order_dir; 152, pair; 152, 153; 152, 154; 153, string:"q"; 154, identifier:query; 155, pair; 155, 156; 155, 157; 156, string:"s"; 157, identifier:share; 158, if_statement; 158, 159; 158, 160; 158, 168; 159, identifier:check; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:checker; 165, identifier:check_request_parameters; 166, argument_list; 166, 167; 167, identifier:payload; 168, else_clause; 168, 169; 169, block; 169, 170; 170, pass_statement; 171, comment; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:search_url; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, string:"{}://v1.{}.isogeo.com/resources/search"; 178, identifier:format; 179, argument_list; 179, 180; 179, 181; 180, identifier:prot; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:api_url; 184, try_statement; 184, 185; 184, 213; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:search_req; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:get; 193, argument_list; 193, 194; 193, 195; 193, 200; 193, 203; 193, 208; 194, identifier:search_url; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:headers; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:header; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:params; 202, identifier:payload; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:proxies; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:proxies; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:verify; 210, attribute; 210, 211; 210, 212; 211, identifier:self; 212, identifier:ssl; 213, except_clause; 213, 214; 213, 218; 214, as_pattern; 214, 215; 214, 216; 215, identifier:Exception; 216, as_pattern_target; 216, 217; 217, identifier:e; 218, block; 218, 219; 218, 226; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:logging; 223, identifier:error; 224, argument_list; 224, 225; 225, identifier:e; 226, raise_statement; 226, 227; 227, identifier:Exception; 228, comment; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:checker; 233, identifier:check_api_response; 234, argument_list; 234, 235; 235, identifier:search_req; 236, comment; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:search_rez; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:search_req; 243, identifier:json; 244, argument_list; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:resources_count; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:search_rez; 251, identifier:get; 252, argument_list; 252, 253; 253, string:"total"; 254, comment; 255, comment; 256, comment; 257, if_statement; 257, 258; 257, 263; 257, 264; 257, 354; 258, boolean_operator:and; 258, 259; 258, 262; 259, comparison_operator:>; 259, 260; 259, 261; 260, identifier:resources_count; 261, identifier:page_size; 262, identifier:whole_share; 263, comment; 264, block; 264, 265; 264, 269; 264, 270; 264, 276; 264, 277; 264, 278; 264, 348; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:metadatas; 268, list:[]; 269, comment; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:payload; 274, string:"_limit"; 275, integer:100; 276, comment; 277, comment; 278, for_statement; 278, 279; 278, 280; 278, 295; 279, identifier:idx; 280, call; 280, 281; 280, 282; 281, identifier:range; 282, argument_list; 282, 283; 282, 284; 283, integer:0; 284, binary_operator:+; 284, 285; 284, 294; 285, call; 285, 286; 285, 287; 286, identifier:int; 287, argument_list; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:ceil; 290, argument_list; 290, 291; 291, binary_operator:/; 291, 292; 291, 293; 292, identifier:resources_count; 293, integer:100; 294, integer:1; 295, block; 295, 296; 295, 304; 295, 331; 295, 332; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 301; 298, subscript; 298, 299; 298, 300; 299, identifier:payload; 300, string:"_offset"; 301, binary_operator:*; 301, 302; 301, 303; 302, identifier:idx; 303, integer:100; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:search_req; 307, call; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, identifier:self; 310, identifier:get; 311, argument_list; 311, 312; 311, 313; 311, 318; 311, 321; 311, 326; 312, identifier:search_url; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:headers; 315, attribute; 315, 316; 315, 317; 316, identifier:self; 317, identifier:header; 318, keyword_argument; 318, 319; 318, 320; 319, identifier:params; 320, identifier:payload; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:proxies; 323, attribute; 323, 324; 323, 325; 324, identifier:self; 325, identifier:proxies; 326, keyword_argument; 326, 327; 326, 328; 327, identifier:verify; 328, attribute; 328, 329; 328, 330; 329, identifier:self; 330, identifier:ssl; 331, comment; 332, expression_statement; 332, 333; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:metadatas; 336, identifier:extend; 337, argument_list; 337, 338; 338, call; 338, 339; 338, 346; 339, attribute; 339, 340; 339, 345; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:search_req; 343, identifier:json; 344, argument_list; 345, identifier:get; 346, argument_list; 346, 347; 347, string:"results"; 348, expression_statement; 348, 349; 349, assignment; 349, 350; 349, 353; 350, subscript; 350, 351; 350, 352; 351, identifier:search_rez; 352, string:"results"; 353, identifier:metadatas; 354, else_clause; 354, 355; 355, block; 355, 356; 356, pass_statement; 357, comment; 358, if_statement; 358, 359; 358, 360; 358, 401; 359, identifier:augment; 360, block; 360, 361; 360, 373; 361, expression_statement; 361, 362; 362, call; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:self; 365, identifier:add_tags_shares; 366, argument_list; 366, 367; 367, call; 367, 368; 367, 371; 368, attribute; 368, 369; 368, 370; 369, identifier:search_rez; 370, identifier:get; 371, argument_list; 371, 372; 372, string:"tags"; 373, if_statement; 373, 374; 373, 375; 373, 388; 374, identifier:share; 375, block; 375, 376; 376, expression_statement; 376, 377; 377, assignment; 377, 378; 377, 386; 378, subscript; 378, 379; 378, 385; 379, call; 379, 380; 379, 383; 380, attribute; 380, 381; 380, 382; 381, identifier:search_rez; 382, identifier:get; 383, argument_list; 383, 384; 384, string:"query"; 385, string:"_shares"; 386, list:[share]; 386, 387; 387, identifier:share; 388, else_clause; 388, 389; 389, block; 389, 390; 390, expression_statement; 390, 391; 391, assignment; 391, 392; 391, 400; 392, subscript; 392, 393; 392, 399; 393, call; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:search_rez; 396, identifier:get; 397, argument_list; 397, 398; 398, string:"query"; 399, string:"_shares"; 400, list:[]; 401, else_clause; 401, 402; 402, block; 402, 403; 403, pass_statement; 404, comment; 405, if_statement; 405, 406; 405, 407; 405, 484; 406, identifier:tags_as_dicts; 407, block; 407, 408; 407, 432; 407, 433; 407, 444; 407, 455; 407, 456; 407, 470; 408, expression_statement; 408, 409; 409, assignment; 409, 410; 409, 411; 410, identifier:new_tags; 411, call; 411, 412; 411, 415; 412, attribute; 412, 413; 412, 414; 413, identifier:utils; 414, identifier:tags_to_dict; 415, argument_list; 415, 416; 415, 424; 416, keyword_argument; 416, 417; 416, 418; 417, identifier:tags; 418, call; 418, 419; 418, 422; 419, attribute; 419, 420; 419, 421; 420, identifier:search_rez; 421, identifier:get; 422, argument_list; 422, 423; 423, string:"tags"; 424, keyword_argument; 424, 425; 424, 426; 425, identifier:prev_query; 426, call; 426, 427; 426, 430; 427, attribute; 427, 428; 427, 429; 428, identifier:search_rez; 429, identifier:get; 430, argument_list; 430, 431; 431, string:"query"; 432, comment; 433, expression_statement; 433, 434; 434, call; 434, 435; 434, 443; 435, attribute; 435, 436; 435, 442; 436, call; 436, 437; 436, 440; 437, attribute; 437, 438; 437, 439; 438, identifier:search_rez; 439, identifier:get; 440, argument_list; 440, 441; 441, string:"tags"; 442, identifier:clear; 443, argument_list; 444, expression_statement; 444, 445; 445, call; 445, 446; 445, 454; 446, attribute; 446, 447; 446, 453; 447, call; 447, 448; 447, 451; 448, attribute; 448, 449; 448, 450; 449, identifier:search_rez; 450, identifier:get; 451, argument_list; 451, 452; 452, string:"query"; 453, identifier:clear; 454, argument_list; 455, comment; 456, expression_statement; 456, 457; 457, call; 457, 458; 457, 466; 458, attribute; 458, 459; 458, 465; 459, call; 459, 460; 459, 463; 460, attribute; 460, 461; 460, 462; 461, identifier:search_rez; 462, identifier:get; 463, argument_list; 463, 464; 464, string:"tags"; 465, identifier:update; 466, argument_list; 466, 467; 467, subscript; 467, 468; 467, 469; 468, identifier:new_tags; 469, integer:0; 470, expression_statement; 470, 471; 471, call; 471, 472; 471, 480; 472, attribute; 472, 473; 472, 479; 473, call; 473, 474; 473, 477; 474, attribute; 474, 475; 474, 476; 475, identifier:search_rez; 476, identifier:get; 477, argument_list; 477, 478; 478, string:"query"; 479, identifier:update; 480, argument_list; 480, 481; 481, subscript; 481, 482; 481, 483; 482, identifier:new_tags; 483, integer:1; 484, else_clause; 484, 485; 485, block; 485, 486; 486, pass_statement; 487, comment; 488, return_statement; 488, 489; 489, identifier:search_rez | def search(
self,
token: dict = None,
query: str = "",
bbox: list = None,
poly: str = None,
georel: str = None,
order_by: str = "_created",
order_dir: str = "desc",
page_size: int = 100,
offset: int = 0,
share: str = None,
specific_md: list = [],
include: list = [],
whole_share: bool = True,
check: bool = True,
augment: bool = False,
tags_as_dicts: bool = False,
prot: str = "https",
) -> dict:
"""Search within the resources shared to the application.
It's the main method to use.
:param str token: API auth token - DEPRECATED: token is now automatically included
:param str query: search terms and semantic filters. Equivalent of
**q** parameter in Isogeo API. It could be a simple
string like *oil* or a tag like *keyword:isogeo:formations*
or *keyword:inspire-theme:landcover*. The *AND* operator
is applied when various tags are passed.
:param list bbox: Bounding box to limit the search.
Must be a 4 list of coordinates in WGS84 (EPSG 4326).
Could be associated with *georel*.
:param str poly: Geographic criteria for the search, in WKT format.
Could be associated with *georel*.
:param str georel: geometric operator to apply to the bbox or poly
parameters.
Available values (see: *isogeo.GEORELATIONS*):
* 'contains',
* 'disjoint',
* 'equals',
* 'intersects' - [APPLIED BY API if NOT SPECIFIED]
* 'overlaps',
* 'within'.
:param str order_by: sorting results.
Available values:
* '_created': metadata creation date [DEFAULT if relevance is null]
* '_modified': metadata last update
* 'title': metadata title
* 'created': data creation date (possibly None)
* 'modified': data last update date
* 'relevance': relevance score calculated by API [DEFAULT].
:param str order_dir: sorting direction.
Available values:
* 'desc': descending
* 'asc': ascending
:param int page_size: limits the number of results.
Useful to paginate results display. Default value: 100.
:param int offset: offset to start page size
from a specific results index
:param str share: share UUID to filter on
:param list specific_md: list of metadata UUIDs to filter on
:param list include: subresources that should be returned.
Must be a list of strings. Available values: *isogeo.SUBRESOURCES*
:param bool whole_share: option to return all results or only the
page size. *True* by DEFAULT.
:param bool check: option to check query parameters and avoid erros.
*True* by DEFAULT.
:param bool augment: option to improve API response by adding
some tags on the fly (like shares_id)
:param bool tags_as_dicts: option to store tags as key/values by filter.
:param str prot: https [DEFAULT] or http
(use it only for dev and tracking needs).
"""
# specific resources specific parsing
specific_md = checker._check_filter_specific_md(specific_md)
# sub resources specific parsing
include = checker._check_filter_includes(include)
# handling request parameters
payload = {
"_id": specific_md,
"_include": include,
"_lang": self.lang,
"_limit": page_size,
"_offset": offset,
"box": bbox,
"geo": poly,
"rel": georel,
"ob": order_by,
"od": order_dir,
"q": query,
"s": share,
}
if check:
checker.check_request_parameters(payload)
else:
pass
# search request
search_url = "{}://v1.{}.isogeo.com/resources/search".format(prot, self.api_url)
try:
search_req = self.get(
search_url,
headers=self.header,
params=payload,
proxies=self.proxies,
verify=self.ssl,
)
except Exception as e:
logging.error(e)
raise Exception
# fast response check
checker.check_api_response(search_req)
# serializing result into dict and storing resources in variables
search_rez = search_req.json()
resources_count = search_rez.get("total") # total of metadatas shared
# handling Isogeo API pagination
# see: http://help.isogeo.com/api/fr/methods/pagination.html
if resources_count > page_size and whole_share:
# if API returned more than one page of results, let's get the rest!
metadatas = [] # a recipient list
payload["_limit"] = 100 # now it'll get pages of 100 resources
# let's parse pages
for idx in range(0, int(ceil(resources_count / 100)) + 1):
payload["_offset"] = idx * 100
search_req = self.get(
search_url,
headers=self.header,
params=payload,
proxies=self.proxies,
verify=self.ssl,
)
# storing results by addition
metadatas.extend(search_req.json().get("results"))
search_rez["results"] = metadatas
else:
pass
# add shares to tags and query
if augment:
self.add_tags_shares(search_rez.get("tags"))
if share:
search_rez.get("query")["_shares"] = [share]
else:
search_rez.get("query")["_shares"] = []
else:
pass
# store tags in dicts
if tags_as_dicts:
new_tags = utils.tags_to_dict(
tags=search_rez.get("tags"), prev_query=search_rez.get("query")
)
# clear
search_rez.get("tags").clear()
search_rez.get("query").clear()
# update
search_rez.get("tags").update(new_tags[0])
search_rez.get("query").update(new_tags[1])
else:
pass
# end of method
return search_rez |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 60; 1, 62; 2, function_name:keywords; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 15; 3, 20; 3, 25; 3, 30; 3, 35; 3, 40; 3, 45; 3, 50; 3, 55; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:token; 7, type; 7, 8; 8, identifier:dict; 9, None; 10, typed_default_parameter; 10, 11; 10, 12; 10, 14; 11, identifier:thez_id; 12, type; 12, 13; 13, identifier:str; 14, string:"1616597fbc4348c8b11ef9d59cf594c8"; 15, typed_default_parameter; 15, 16; 15, 17; 15, 19; 16, identifier:query; 17, type; 17, 18; 18, identifier:str; 19, string:""; 20, typed_default_parameter; 20, 21; 20, 22; 20, 24; 21, identifier:offset; 22, type; 22, 23; 23, identifier:int; 24, integer:0; 25, typed_default_parameter; 25, 26; 25, 27; 25, 29; 26, identifier:order_by; 27, type; 27, 28; 28, identifier:str; 29, string:"text"; 30, typed_default_parameter; 30, 31; 30, 32; 30, 34; 31, identifier:order_dir; 32, type; 32, 33; 33, identifier:str; 34, string:"desc"; 35, typed_default_parameter; 35, 36; 35, 37; 35, 39; 36, identifier:page_size; 37, type; 37, 38; 38, identifier:int; 39, integer:20; 40, typed_default_parameter; 40, 41; 40, 42; 40, 44; 41, identifier:specific_md; 42, type; 42, 43; 43, identifier:list; 44, list:[]; 45, typed_default_parameter; 45, 46; 45, 47; 45, 49; 46, identifier:specific_tag; 47, type; 47, 48; 48, identifier:list; 49, list:[]; 50, typed_default_parameter; 50, 51; 50, 52; 50, 54; 51, identifier:include; 52, type; 52, 53; 53, identifier:list; 54, list:[]; 55, typed_default_parameter; 55, 56; 55, 57; 55, 59; 56, identifier:prot; 57, type; 57, 58; 58, identifier:str; 59, string:"https"; 60, type; 60, 61; 61, identifier:dict; 62, block; 62, 63; 62, 65; 62, 66; 62, 75; 62, 76; 62, 86; 62, 87; 62, 96; 62, 97; 62, 128; 62, 129; 62, 142; 62, 169; 62, 170; 62, 177; 62, 178; 63, expression_statement; 63, 64; 64, comment; 65, comment; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:specific_md; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:checker; 72, identifier:_check_filter_specific_md; 73, argument_list; 73, 74; 74, identifier:specific_md; 75, comment; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:include; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:checker; 82, identifier:_check_filter_includes; 83, argument_list; 83, 84; 83, 85; 84, identifier:include; 85, string:"keyword"; 86, comment; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:specific_tag; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:checker; 93, identifier:_check_filter_specific_tag; 94, argument_list; 94, 95; 95, identifier:specific_tag; 96, comment; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:payload; 100, dictionary; 100, 101; 100, 104; 100, 107; 100, 110; 100, 113; 100, 116; 100, 119; 100, 122; 100, 125; 101, pair; 101, 102; 101, 103; 102, string:"_id"; 103, identifier:specific_md; 104, pair; 104, 105; 104, 106; 105, string:"_include"; 106, identifier:include; 107, pair; 107, 108; 107, 109; 108, string:"_limit"; 109, identifier:page_size; 110, pair; 110, 111; 110, 112; 111, string:"_offset"; 112, identifier:offset; 113, pair; 113, 114; 113, 115; 114, string:"_tag"; 115, identifier:specific_tag; 116, pair; 116, 117; 116, 118; 117, string:"tid"; 118, identifier:thez_id; 119, pair; 119, 120; 119, 121; 120, string:"ob"; 121, identifier:order_by; 122, pair; 122, 123; 122, 124; 123, string:"od"; 124, identifier:order_dir; 125, pair; 125, 126; 125, 127; 126, string:"q"; 127, identifier:query; 128, comment; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:keywords_url; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, string:"{}://v1.{}.isogeo.com/thesauri/{}/keywords/search"; 135, identifier:format; 136, argument_list; 136, 137; 136, 138; 136, 141; 137, identifier:prot; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:api_url; 141, identifier:thez_id; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:kwds_req; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:get; 149, argument_list; 149, 150; 149, 151; 149, 156; 149, 159; 149, 164; 150, identifier:keywords_url; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:headers; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:header; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:params; 158, identifier:payload; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:proxies; 161, attribute; 161, 162; 161, 163; 162, identifier:self; 163, identifier:proxies; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:verify; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:ssl; 169, comment; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:checker; 174, identifier:check_api_response; 175, argument_list; 175, 176; 176, identifier:kwds_req; 177, comment; 178, return_statement; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:kwds_req; 182, identifier:json; 183, argument_list | def keywords(
self,
token: dict = None,
thez_id: str = "1616597fbc4348c8b11ef9d59cf594c8",
query: str = "",
offset: int = 0,
order_by: str = "text",
order_dir: str = "desc",
page_size: int = 20,
specific_md: list = [],
specific_tag: list = [],
include: list = [],
prot: str = "https",
) -> dict:
"""Search for keywords within a specific thesaurus.
:param str token: API auth token
:param str thez_id: thesaurus UUID
:param str query: search terms
:param int offset: pagination start
:param str order_by: sort criteria. Available values :
- count.group,
- count.isogeo,
- text
:param str prot: https [DEFAULT] or http
(use it only for dev and tracking needs).
"""
# specific resources specific parsing
specific_md = checker._check_filter_specific_md(specific_md)
# sub resources specific parsing
include = checker._check_filter_includes(include, "keyword")
# specific tag specific parsing
specific_tag = checker._check_filter_specific_tag(specific_tag)
# handling request parameters
payload = {
"_id": specific_md,
"_include": include,
"_limit": page_size,
"_offset": offset,
"_tag": specific_tag,
"tid": thez_id,
"ob": order_by,
"od": order_dir,
"q": query,
}
# search request
keywords_url = "{}://v1.{}.isogeo.com/thesauri/{}/keywords/search".format(
prot, self.api_url, thez_id
)
kwds_req = self.get(
keywords_url,
headers=self.header,
params=payload,
proxies=self.proxies,
verify=self.ssl,
)
# checking response
checker.check_api_response(kwds_req)
# end of method
return kwds_req.json() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_field_sort_name; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:name; 6, block; 6, 7; 6, 9; 6, 53; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 19; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 18; 13, subscript; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:cls; 16, identifier:__dict__; 17, identifier:name; 18, identifier:DateItemField; 19, block; 19, 20; 19, 31; 19, 42; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:name; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:re; 26, identifier:sub; 27, argument_list; 27, 28; 27, 29; 27, 30; 28, string:'year'; 29, string:'date0'; 30, identifier:name; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:name; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:re; 37, identifier:sub; 38, argument_list; 38, 39; 38, 40; 38, 41; 39, string:'month'; 40, string:'date1'; 41, identifier:name; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:name; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:re; 48, identifier:sub; 49, argument_list; 49, 50; 49, 51; 49, 52; 50, string:'day'; 51, string:'date2'; 52, identifier:name; 53, return_statement; 53, 54; 54, identifier:name | def _field_sort_name(cls, name):
"""Get a sort key for a field name that determines the order
fields should be written in.
Fields names are kept unchanged, unless they are instances of
:class:`DateItemField`, in which case `year`, `month`, and `day`
are replaced by `date0`, `date1`, and `date2`, respectively, to
make them appear in that order.
"""
if isinstance(cls.__dict__[name], DateItemField):
name = re.sub('year', 'date0', name)
name = re.sub('month', 'date1', name)
name = re.sub('day', 'date2', name)
return name |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_fields; 3, parameters; 3, 4; 4, identifier:cls; 5, block; 5, 6; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, for_statement; 8, 9; 8, 10; 8, 23; 9, identifier:property; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 18; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:cls; 16, identifier:fields; 17, argument_list; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:key; 20, attribute; 20, 21; 20, 22; 21, identifier:cls; 22, identifier:_field_sort_name; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, yield; 25, 26; 26, identifier:property | def sorted_fields(cls):
"""Get the names of all writable metadata fields, sorted in the
order that they should be written.
This is a lexicographic order, except for instances of
:class:`DateItemField`, which are sorted in year-month-day
order.
"""
for property in sorted(cls.fields(), key=cls._field_sort_name):
yield property |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:set_vassals_wrapper_params; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:wrapper; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:overrides; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:fallbacks; 13, None; 14, block; 14, 15; 14, 17; 14, 25; 14, 36; 14, 47; 15, expression_statement; 15, 16; 16, comment; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_set; 22, argument_list; 22, 23; 22, 24; 23, string:'emperor-wrapper'; 24, identifier:wrapper; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_set; 30, argument_list; 30, 31; 30, 32; 30, 33; 31, string:'emperor-wrapper-override'; 32, identifier:overrides; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:multi; 35, True; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_set; 41, argument_list; 41, 42; 41, 43; 41, 44; 42, string:'emperor-wrapper-fallback'; 43, identifier:fallbacks; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:multi; 46, True; 47, return_statement; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_section | def set_vassals_wrapper_params(self, wrapper=None, overrides=None, fallbacks=None):
"""Binary wrapper for vassals parameters.
:param str|unicode wrapper: Set a binary wrapper for vassals.
:param str|unicode|list[str|unicode] overrides: Set a binary wrapper for vassals to try before the default one
:param str|unicode|list[str|unicode] fallbacks: Set a binary wrapper for vassals to try as a last resort.
Allows you to specify an alternative binary to execute when running a vassal
and the default binary_path is not found (or returns an error).
"""
self._set('emperor-wrapper', wrapper)
self._set('emperor-wrapper-override', overrides, multi=True)
self._set('emperor-wrapper-fallback', fallbacks, multi=True)
return self._section |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:add_query_parameters_to_url; 3, parameters; 3, 4; 3, 5; 4, identifier:url; 5, identifier:query_parameters; 6, block; 6, 7; 6, 9; 6, 10; 6, 21; 6, 22; 6, 35; 6, 42; 6, 43; 6, 49; 6, 68; 6, 69; 6, 81; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:url_parts; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:urllib; 17, identifier:parse; 18, identifier:urlparse; 19, argument_list; 19, 20; 20, identifier:url; 21, comment; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:qs_args; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:urllib; 29, identifier:parse; 30, identifier:parse_qs; 31, argument_list; 31, 32; 32, subscript; 32, 33; 32, 34; 33, identifier:url_parts; 34, integer:4; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:qs_args; 39, identifier:update; 40, argument_list; 40, 41; 41, identifier:query_parameters; 42, comment; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:sorted_qs_args; 46, call; 46, 47; 46, 48; 47, identifier:OrderedDict; 48, argument_list; 49, for_statement; 49, 50; 49, 51; 49, 59; 50, identifier:k; 51, call; 51, 52; 51, 53; 52, identifier:sorted; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:qs_args; 57, identifier:keys; 58, argument_list; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:sorted_qs_args; 64, identifier:k; 65, subscript; 65, 66; 65, 67; 66, identifier:qs_args; 67, identifier:k; 68, comment; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:new_qs; 72, call; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:urllib; 76, identifier:parse; 77, identifier:urlencode; 78, argument_list; 78, 79; 78, 80; 79, identifier:sorted_qs_args; 80, True; 81, return_statement; 81, 82; 82, call; 82, 83; 82, 88; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:urllib; 86, identifier:parse; 87, identifier:urlunparse; 88, argument_list; 88, 89; 89, binary_operator:+; 89, 90; 89, 102; 90, binary_operator:+; 90, 91; 90, 100; 91, call; 91, 92; 91, 93; 92, identifier:list; 93, argument_list; 93, 94; 94, subscript; 94, 95; 94, 96; 95, identifier:url_parts; 96, slice; 96, 97; 96, 98; 96, 99; 97, integer:0; 98, colon; 99, integer:4; 100, list:[new_qs]; 100, 101; 101, identifier:new_qs; 102, call; 102, 103; 102, 104; 103, identifier:list; 104, argument_list; 104, 105; 105, subscript; 105, 106; 105, 107; 106, identifier:url_parts; 107, slice; 107, 108; 107, 109; 108, integer:5; 109, colon | def add_query_parameters_to_url(url, query_parameters):
"""
Merge a dictionary of query parameters into the given URL.
Ensures all parameters are sorted in dictionary order when returning the URL.
"""
# Parse the given URL into parts.
url_parts = urllib.parse.urlparse(url)
# Parse existing parameters and add new parameters.
qs_args = urllib.parse.parse_qs(url_parts[4])
qs_args.update(query_parameters)
# Sort parameters to ensure consistent order.
sorted_qs_args = OrderedDict()
for k in sorted(qs_args.keys()):
sorted_qs_args[k] = qs_args[k]
# Encode the new parameters and return the updated URL.
new_qs = urllib.parse.urlencode(sorted_qs_args, True)
return urllib.parse.urlunparse(list(url_parts[0:4]) + [new_qs] + list(url_parts[5:])) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:elements; 6, block; 6, 7; 6, 9; 6, 14; 6, 22; 6, 23; 6, 49; 7, expression_statement; 7, 8; 8, string:''' Merges all scraping results to a list sorted by frequency of occurrence. '''; 9, import_from_statement; 9, 10; 9, 12; 10, dotted_name; 10, 11; 11, identifier:collections; 12, dotted_name; 12, 13; 13, identifier:Counter; 14, import_from_statement; 14, 15; 14, 18; 14, 20; 15, dotted_name; 15, 16; 15, 17; 16, identifier:lltk; 17, identifier:utils; 18, dotted_name; 18, 19; 19, identifier:list2tuple; 20, dotted_name; 20, 21; 21, identifier:tuple2list; 22, comment; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:merged; 26, call; 26, 27; 26, 28; 27, identifier:tuple2list; 28, argument_list; 28, 29; 29, list_comprehension; 29, 30; 29, 31; 30, identifier:value; 31, for_in_clause; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:value; 34, identifier:count; 35, call; 35, 36; 35, 48; 36, attribute; 36, 37; 36, 47; 37, call; 37, 38; 37, 39; 38, identifier:Counter; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:list2tuple; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:list; 45, argument_list; 45, 46; 46, identifier:elements; 47, identifier:most_common; 48, argument_list; 49, return_statement; 49, 50; 50, identifier:merged | def merge(self, elements):
''' Merges all scraping results to a list sorted by frequency of occurrence. '''
from collections import Counter
from lltk.utils import list2tuple, tuple2list
# The list2tuple conversion is necessary because mutable objects (e.g. lists) are not hashable
merged = tuple2list([value for value, count in Counter(list2tuple(list(elements))).most_common()])
return merged |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:in1d_sorted; 3, parameters; 3, 4; 3, 5; 4, identifier:ar1; 5, identifier:ar2; 6, block; 6, 7; 6, 9; 6, 29; 6, 38; 6, 49; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 25; 9, 26; 10, boolean_operator:or; 10, 11; 10, 18; 11, comparison_operator:==; 11, 12; 11, 17; 12, subscript; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:ar1; 15, identifier:shape; 16, integer:0; 17, integer:0; 18, comparison_operator:==; 18, 19; 18, 24; 19, subscript; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:ar2; 22, identifier:shape; 23, integer:0; 24, integer:0; 25, comment; 26, block; 26, 27; 27, return_statement; 27, 28; 28, list:[]; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:inds; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:ar2; 35, identifier:searchsorted; 36, argument_list; 36, 37; 37, identifier:ar1; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 48; 40, subscript; 40, 41; 40, 42; 41, identifier:inds; 42, comparison_operator:==; 42, 43; 42, 44; 43, identifier:inds; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:ar2; 48, integer:0; 49, return_statement; 49, 50; 50, comparison_operator:==; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:ar2; 53, identifier:inds; 54, identifier:ar1 | def in1d_sorted(ar1, ar2):
"""
Does the same than np.in1d but uses the fact that ar1 and ar2 are sorted. Is therefore much faster.
"""
if ar1.shape[0] == 0 or ar2.shape[0] == 0: # check for empty arrays to avoid crash
return []
inds = ar2.searchsorted(ar1)
inds[inds == len(ar2)] = 0
return ar2[inds] == ar1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_parameter_value_from_file_names; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:files; 5, default_parameter; 5, 6; 5, 7; 6, identifier:parameters; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:unique; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, True; 14, block; 14, 15; 14, 17; 14, 18; 14, 42; 14, 50; 14, 58; 14, 70; 14, 79; 14, 87; 14, 91; 14, 199; 15, expression_statement; 15, 16; 16, comment; 17, comment; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:logging; 22, identifier:debug; 23, argument_list; 23, 24; 24, binary_operator:+; 24, 25; 24, 41; 25, binary_operator:+; 25, 26; 25, 34; 26, binary_operator:+; 26, 27; 26, 33; 27, binary_operator:+; 27, 28; 27, 29; 28, string:'Get the parameter: '; 29, call; 29, 30; 29, 31; 30, identifier:str; 31, argument_list; 31, 32; 32, identifier:parameters; 33, string:' values from the file names of '; 34, call; 34, 35; 34, 36; 35, identifier:str; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:files; 41, string:' files'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:files_dict; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:collections; 48, identifier:OrderedDict; 49, argument_list; 50, if_statement; 50, 51; 50, 54; 50, 55; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:parameters; 53, None; 54, comment; 55, block; 55, 56; 56, return_statement; 56, 57; 57, identifier:files_dict; 58, if_statement; 58, 59; 58, 64; 59, call; 59, 60; 59, 61; 60, identifier:isinstance; 61, argument_list; 61, 62; 61, 63; 62, identifier:parameters; 63, identifier:basestring; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:parameters; 68, tuple; 68, 69; 69, identifier:parameters; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:search_string; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, string:'_'; 76, identifier:join; 77, argument_list; 77, 78; 78, identifier:parameters; 79, for_statement; 79, 80; 79, 81; 79, 82; 80, identifier:_; 81, identifier:parameters; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, augmented_assignment:+=; 84, 85; 84, 86; 85, identifier:search_string; 86, string:r'_(-?\d+)'; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:result; 90, dictionary; 91, for_statement; 91, 92; 91, 93; 91, 94; 92, identifier:one_file; 93, identifier:files; 94, block; 94, 95; 94, 105; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:parameter_values; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:re; 101, identifier:findall; 102, argument_list; 102, 103; 102, 104; 103, identifier:search_string; 104, identifier:one_file; 105, if_statement; 105, 106; 105, 107; 106, identifier:parameter_values; 107, block; 107, 108; 107, 134; 107, 146; 107, 147; 107, 160; 108, if_statement; 108, 109; 108, 116; 109, call; 109, 110; 109, 111; 110, identifier:isinstance; 111, argument_list; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:parameter_values; 114, integer:0; 115, identifier:tuple; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:parameter_values; 120, call; 120, 121; 120, 122; 121, identifier:list; 122, argument_list; 122, 123; 123, call; 123, 124; 123, 125; 124, identifier:reduce; 125, argument_list; 125, 126; 125, 133; 126, lambda; 126, 127; 126, 130; 127, lambda_parameters; 127, 128; 127, 129; 128, identifier:t1; 129, identifier:t2; 130, binary_operator:+; 130, 131; 130, 132; 131, identifier:t1; 132, identifier:t2; 133, identifier:parameter_values; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:parameter_values; 137, list_comprehension; 137, 138; 137, 143; 138, list:[int(i), ]; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:int; 141, argument_list; 141, 142; 142, identifier:i; 143, for_in_clause; 143, 144; 143, 145; 144, identifier:i; 145, identifier:parameter_values; 146, comment; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:files_dict; 151, identifier:one_file; 152, call; 152, 153; 152, 154; 153, identifier:dict; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:zip; 157, argument_list; 157, 158; 157, 159; 158, identifier:parameters; 159, identifier:parameter_values; 160, if_statement; 160, 161; 160, 162; 160, 163; 160, 189; 161, identifier:unique; 162, comment; 163, block; 163, 164; 164, for_statement; 164, 165; 164, 168; 164, 173; 165, pattern_list; 165, 166; 165, 167; 166, identifier:key; 167, identifier:value; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:files_dict; 171, identifier:items; 172, argument_list; 173, block; 173, 174; 174, if_statement; 174, 175; 174, 182; 175, comparison_operator:not; 175, 176; 175, 177; 176, identifier:value; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:result; 180, identifier:values; 181, argument_list; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:result; 187, identifier:key; 188, identifier:value; 189, else_clause; 189, 190; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:result; 195, identifier:one_file; 196, subscript; 196, 197; 196, 198; 197, identifier:files_dict; 198, identifier:one_file; 199, return_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:collections; 203, identifier:OrderedDict; 204, argument_list; 204, 205; 205, conditional_expression:if; 205, 206; 205, 220; 205, 221; 206, call; 206, 207; 206, 208; 207, identifier:sorted; 208, argument_list; 208, 209; 208, 214; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:result; 212, identifier:iteritems; 213, argument_list; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:key; 216, call; 216, 217; 216, 218; 217, identifier:itemgetter; 218, argument_list; 218, 219; 219, integer:1; 220, identifier:sort; 221, identifier:files_dict | def get_parameter_value_from_file_names(files, parameters=None, unique=False, sort=True):
"""
Takes a list of files, searches for the parameter name in the file name and returns a ordered dict with the file name
in the first dimension and the corresponding parameter value in the second.
The file names can be sorted by the parameter value, otherwise the order is kept. If unique is true every parameter is unique and
mapped to the file name that occurred last in the files list.
Parameters
----------
files : list of strings
parameter : string or list of strings
unique : bool
sort : bool
Returns
-------
collections.OrderedDict
"""
# unique=False
logging.debug('Get the parameter: ' + str(parameters) + ' values from the file names of ' + str(len(files)) + ' files')
files_dict = collections.OrderedDict()
if parameters is None: # special case, no parameter defined
return files_dict
if isinstance(parameters, basestring):
parameters = (parameters, )
search_string = '_'.join(parameters)
for _ in parameters:
search_string += r'_(-?\d+)'
result = {}
for one_file in files:
parameter_values = re.findall(search_string, one_file)
if parameter_values:
if isinstance(parameter_values[0], tuple):
parameter_values = list(reduce(lambda t1, t2: t1 + t2, parameter_values))
parameter_values = [[int(i), ] for i in parameter_values] # convert string value to list with int
files_dict[one_file] = dict(zip(parameters, parameter_values))
if unique: # reduce to the files with different scan parameters
for key, value in files_dict.items():
if value not in result.values():
result[key] = value
else:
result[one_file] = files_dict[one_file]
return collections.OrderedDict(sorted(result.iteritems(), key=itemgetter(1)) if sort else files_dict) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:get_data_file_names_from_scan_base; 3, parameters; 3, 4; 3, 5; 3, 13; 3, 16; 4, identifier:scan_base; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter_str; 7, list:['_analyzed.h5', '_interpreted.h5', '_cut.h5', '_result.h5', '_hists.h5']; 7, 8; 7, 9; 7, 10; 7, 11; 7, 12; 8, string:'_analyzed.h5'; 9, string:'_interpreted.h5'; 10, string:'_cut.h5'; 11, string:'_result.h5'; 12, string:'_hists.h5'; 13, default_parameter; 13, 14; 13, 15; 14, identifier:sort_by_time; 15, True; 16, default_parameter; 16, 17; 16, 18; 17, identifier:meta_data_v2; 18, True; 19, block; 19, 20; 19, 22; 19, 26; 19, 33; 19, 45; 19, 86; 19, 126; 19, 251; 20, expression_statement; 20, 21; 21, comment; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:data_files; 25, list:[]; 26, if_statement; 26, 27; 26, 30; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:scan_base; 29, None; 30, block; 30, 31; 31, return_statement; 31, 32; 32, identifier:data_files; 33, if_statement; 33, 34; 33, 39; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:scan_base; 38, identifier:basestring; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:scan_base; 43, list:[scan_base]; 43, 44; 44, identifier:scan_base; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:scan_base_str; 47, identifier:scan_base; 48, block; 48, 49; 49, if_statement; 49, 50; 49, 62; 49, 70; 50, comparison_operator:==; 50, 51; 50, 52; 51, string:'.h5'; 52, subscript; 52, 53; 52, 61; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:os; 57, identifier:path; 58, identifier:splitext; 59, argument_list; 59, 60; 60, identifier:scan_base_str; 61, integer:1; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:data_files; 67, identifier:append; 68, argument_list; 68, 69; 69, identifier:scan_base_str; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:data_files; 76, identifier:extend; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:glob; 81, identifier:glob; 82, argument_list; 82, 83; 83, binary_operator:+; 83, 84; 83, 85; 84, identifier:scan_base_str; 85, string:'*.h5'; 86, if_statement; 86, 87; 86, 88; 87, identifier:filter_str; 88, block; 88, 89; 88, 101; 89, if_statement; 89, 90; 89, 95; 90, call; 90, 91; 90, 92; 91, identifier:isinstance; 92, argument_list; 92, 93; 92, 94; 93, identifier:filter_str; 94, identifier:basestring; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:filter_str; 99, list:[filter_str]; 99, 100; 100, identifier:filter_str; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:data_files; 104, call; 104, 105; 104, 106; 105, identifier:filter; 106, argument_list; 106, 107; 106, 125; 107, lambda; 107, 108; 107, 110; 108, lambda_parameters; 108, 109; 109, identifier:data_file; 110, not_operator; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:any; 113, argument_list; 113, 114; 114, list_comprehension; 114, 115; 114, 122; 115, parenthesized_expression; 115, 116; 116, conditional_expression:if; 116, 117; 116, 118; 116, 121; 117, True; 118, comparison_operator:in; 118, 119; 118, 120; 119, identifier:x; 120, identifier:data_file; 121, False; 122, for_in_clause; 122, 123; 122, 124; 123, identifier:x; 124, identifier:filter_str; 125, identifier:data_files; 126, if_statement; 126, 127; 126, 135; 127, boolean_operator:and; 127, 128; 127, 129; 128, identifier:sort_by_time; 129, comparison_operator:>; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:len; 132, argument_list; 132, 133; 133, identifier:data_files; 134, integer:1; 135, block; 135, 136; 135, 140; 135, 233; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:f_list; 139, dictionary; 140, for_statement; 140, 141; 140, 142; 140, 143; 141, identifier:data_file; 142, identifier:data_files; 143, block; 143, 144; 144, with_statement; 144, 145; 144, 159; 145, with_clause; 145, 146; 146, with_item; 146, 147; 147, as_pattern; 147, 148; 147, 157; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:tb; 151, identifier:open_file; 152, argument_list; 152, 153; 152, 154; 153, identifier:data_file; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:mode; 156, string:"r"; 157, as_pattern_target; 157, 158; 158, identifier:h5_file; 159, block; 159, 160; 160, try_statement; 160, 161; 160, 170; 160, 186; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:meta_data; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:h5_file; 168, identifier:root; 169, identifier:meta_data; 170, except_clause; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:tb; 173, identifier:NoSuchNodeError; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:logging; 179, identifier:warning; 180, argument_list; 180, 181; 181, binary_operator:%; 181, 182; 181, 183; 182, string:"File %s is missing meta_data"; 183, attribute; 183, 184; 183, 185; 184, identifier:h5_file; 185, identifier:filename; 186, else_clause; 186, 187; 187, block; 187, 188; 188, try_statement; 188, 189; 188, 211; 188, 225; 189, block; 189, 190; 190, if_statement; 190, 191; 190, 192; 190, 201; 191, identifier:meta_data_v2; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:timestamp; 196, subscript; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:meta_data; 199, integer:0; 200, string:"timestamp_start"; 201, else_clause; 201, 202; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:timestamp; 206, subscript; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:meta_data; 209, integer:0; 210, string:"timestamp"; 211, except_clause; 211, 212; 211, 213; 212, identifier:IndexError; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:logging; 218, identifier:info; 219, argument_list; 219, 220; 220, binary_operator:%; 220, 221; 220, 222; 221, string:"File %s has empty meta_data"; 222, attribute; 222, 223; 222, 224; 223, identifier:h5_file; 224, identifier:filename; 225, else_clause; 225, 226; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 232; 229, subscript; 229, 230; 229, 231; 230, identifier:f_list; 231, identifier:data_file; 232, identifier:timestamp; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:data_files; 236, call; 236, 237; 236, 238; 237, identifier:list; 238, argument_list; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:sorted; 241, argument_list; 241, 242; 241, 243; 241, 248; 242, identifier:f_list; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:key; 245, attribute; 245, 246; 245, 247; 246, identifier:f_list; 247, identifier:__getitem__; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:reverse; 250, False; 251, return_statement; 251, 252; 252, identifier:data_files | def get_data_file_names_from_scan_base(scan_base, filter_str=['_analyzed.h5', '_interpreted.h5', '_cut.h5', '_result.h5', '_hists.h5'], sort_by_time=True, meta_data_v2=True):
"""
Generate a list of .h5 files which have a similar file name.
Parameters
----------
scan_base : list, string
List of string or string of the scan base names. The scan_base will be used to search for files containing the string. The .h5 file extension will be added automatically.
filter : list, string
List of string or string which are used to filter the returned filenames. File names containing filter_str in the file name will not be returned. Use None to disable filter.
sort_by_time : bool
If True, return file name list sorted from oldest to newest. The time from meta table will be used to sort the files.
meta_data_v2 : bool
True for new (v2) meta data format, False for the old (v1) format.
Returns
-------
data_files : list
List of file names matching the obove conditions.
"""
data_files = []
if scan_base is None:
return data_files
if isinstance(scan_base, basestring):
scan_base = [scan_base]
for scan_base_str in scan_base:
if '.h5' == os.path.splitext(scan_base_str)[1]:
data_files.append(scan_base_str)
else:
data_files.extend(glob.glob(scan_base_str + '*.h5'))
if filter_str:
if isinstance(filter_str, basestring):
filter_str = [filter_str]
data_files = filter(lambda data_file: not any([(True if x in data_file else False) for x in filter_str]), data_files)
if sort_by_time and len(data_files) > 1:
f_list = {}
for data_file in data_files:
with tb.open_file(data_file, mode="r") as h5_file:
try:
meta_data = h5_file.root.meta_data
except tb.NoSuchNodeError:
logging.warning("File %s is missing meta_data" % h5_file.filename)
else:
try:
if meta_data_v2:
timestamp = meta_data[0]["timestamp_start"]
else:
timestamp = meta_data[0]["timestamp"]
except IndexError:
logging.info("File %s has empty meta_data" % h5_file.filename)
else:
f_list[data_file] = timestamp
data_files = list(sorted(f_list, key=f_list.__getitem__, reverse=False))
return data_files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_parameter_from_files; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:files; 5, default_parameter; 5, 6; 5, 7; 6, identifier:parameters; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:unique; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, True; 14, block; 14, 15; 14, 17; 14, 41; 14, 49; 14, 61; 14, 73; 14, 87; 14, 88; 14, 392; 15, expression_statement; 15, 16; 16, string:''' Takes a list of files, searches for the parameter name in the file name and in the file.
Returns a ordered dict with the file name in the first dimension and the corresponding parameter values in the second.
If a scan parameter appears in the file name and in the file the first parameter setting has to be in the file name, otherwise a warning is shown.
The file names can be sorted by the first parameter value of each file.
Parameters
----------
files : string, list of strings
parameters : string, list of strings
unique : boolean
If set only one file per scan parameter value is used.
sort : boolean
Returns
-------
collections.OrderedDict
'''; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:logging; 21, identifier:debug; 22, argument_list; 22, 23; 23, binary_operator:+; 23, 24; 23, 40; 24, binary_operator:+; 24, 25; 24, 33; 25, binary_operator:+; 25, 26; 25, 32; 26, binary_operator:+; 26, 27; 26, 28; 27, string:'Get the parameter '; 28, call; 28, 29; 28, 30; 29, identifier:str; 30, argument_list; 30, 31; 31, identifier:parameters; 32, string:' values from '; 33, call; 33, 34; 33, 35; 34, identifier:str; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:files; 40, string:' files'; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:files_dict; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:collections; 47, identifier:OrderedDict; 48, argument_list; 49, if_statement; 49, 50; 49, 55; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:files; 54, identifier:basestring; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:files; 59, tuple; 59, 60; 60, identifier:files; 61, if_statement; 61, 62; 61, 67; 62, call; 62, 63; 62, 64; 63, identifier:isinstance; 64, argument_list; 64, 65; 64, 66; 65, identifier:parameters; 66, identifier:basestring; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:parameters; 71, tuple; 71, 72; 72, identifier:parameters; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:parameter_values_from_file_names_dict; 76, call; 76, 77; 76, 78; 77, identifier:get_parameter_value_from_file_names; 78, argument_list; 78, 79; 78, 80; 78, 81; 78, 84; 79, identifier:files; 80, identifier:parameters; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:unique; 83, identifier:unique; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:sort; 86, identifier:sort; 87, comment; 88, for_statement; 88, 89; 88, 90; 88, 91; 89, identifier:file_name; 90, identifier:files; 91, block; 91, 92; 92, with_statement; 92, 93; 92, 107; 92, 108; 93, with_clause; 93, 94; 94, with_item; 94, 95; 95, as_pattern; 95, 96; 95, 105; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:tb; 99, identifier:open_file; 100, argument_list; 100, 101; 100, 102; 101, identifier:file_name; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:mode; 104, string:"r"; 105, as_pattern_target; 105, 106; 106, identifier:in_file_h5; 107, comment; 108, block; 108, 109; 108, 117; 108, 228; 108, 315; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:scan_parameter_values; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:collections; 115, identifier:OrderedDict; 116, argument_list; 117, try_statement; 117, 118; 117, 172; 118, block; 118, 119; 118, 130; 118, 131; 118, 143; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:scan_parameters; 122, subscript; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:in_file_h5; 126, identifier:root; 127, identifier:scan_parameters; 128, slice; 128, 129; 129, colon; 130, comment; 131, if_statement; 131, 132; 131, 135; 132, comparison_operator:is; 132, 133; 132, 134; 133, identifier:parameters; 134, None; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:parameters; 139, call; 139, 140; 139, 141; 140, identifier:get_scan_parameter_names; 141, argument_list; 141, 142; 142, identifier:scan_parameters; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:parameter; 145, identifier:parameters; 146, block; 146, 147; 147, try_statement; 147, 148; 147, 167; 148, block; 148, 149; 148, 166; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:scan_parameter_values; 153, identifier:parameter; 154, call; 154, 155; 154, 165; 155, attribute; 155, 156; 155, 164; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:np; 159, identifier:unique; 160, argument_list; 160, 161; 161, subscript; 161, 162; 161, 163; 162, identifier:scan_parameters; 163, identifier:parameter; 164, identifier:tolist; 165, argument_list; 166, comment; 167, except_clause; 167, 168; 167, 169; 167, 170; 168, identifier:ValueError; 169, comment; 170, block; 170, 171; 171, pass_statement; 172, except_clause; 172, 173; 172, 176; 172, 177; 173, attribute; 173, 174; 173, 175; 174, identifier:tb; 175, identifier:NoSuchNodeError; 176, comment; 177, block; 177, 178; 178, try_statement; 178, 179; 178, 221; 179, block; 179, 180; 179, 194; 179, 195; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:scan_parameters; 183, call; 183, 184; 183, 185; 184, identifier:get_scan_parameter; 185, argument_list; 185, 186; 186, subscript; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:in_file_h5; 190, identifier:root; 191, identifier:meta_data; 192, slice; 192, 193; 193, colon; 194, comment; 195, if_statement; 195, 196; 195, 197; 196, identifier:scan_parameters; 197, block; 197, 198; 198, try_statement; 198, 199; 198, 216; 199, block; 199, 200; 199, 215; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:scan_parameter_values; 203, call; 203, 204; 203, 214; 204, attribute; 204, 205; 204, 213; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:np; 208, identifier:unique; 209, argument_list; 209, 210; 210, subscript; 210, 211; 210, 212; 211, identifier:scan_parameters; 212, identifier:parameters; 213, identifier:tolist; 214, argument_list; 215, comment; 216, except_clause; 216, 217; 216, 218; 216, 219; 217, identifier:ValueError; 218, comment; 219, block; 219, 220; 220, pass_statement; 221, except_clause; 221, 222; 221, 225; 221, 226; 222, attribute; 222, 223; 222, 224; 223, identifier:tb; 224, identifier:NoSuchNodeError; 225, comment; 226, block; 226, 227; 227, pass_statement; 228, if_statement; 228, 229; 228, 231; 228, 232; 228, 249; 229, not_operator; 229, 230; 230, identifier:scan_parameter_values; 231, comment; 232, block; 232, 233; 233, try_statement; 233, 234; 233, 241; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:scan_parameter_values; 238, subscript; 238, 239; 238, 240; 239, identifier:parameter_values_from_file_names_dict; 240, identifier:file_name; 241, except_clause; 241, 242; 241, 243; 241, 244; 242, identifier:KeyError; 243, comment; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:scan_parameter_values; 248, None; 249, else_clause; 249, 250; 249, 251; 250, comment; 251, block; 251, 252; 252, try_statement; 252, 253; 252, 302; 252, 307; 253, block; 253, 254; 254, for_statement; 254, 255; 254, 258; 254, 263; 255, pattern_list; 255, 256; 255, 257; 256, identifier:key; 257, identifier:value; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:scan_parameter_values; 261, identifier:items; 262, argument_list; 263, block; 263, 264; 264, if_statement; 264, 265; 264, 278; 264, 279; 265, boolean_operator:and; 265, 266; 265, 267; 266, identifier:value; 267, comparison_operator:!=; 267, 268; 267, 271; 268, subscript; 268, 269; 268, 270; 269, identifier:value; 270, integer:0; 271, subscript; 271, 272; 271, 277; 272, subscript; 272, 273; 272, 276; 273, subscript; 273, 274; 273, 275; 274, identifier:parameter_values_from_file_names_dict; 275, identifier:file_name; 276, identifier:key; 277, integer:0; 278, comment; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:logging; 284, identifier:warning; 285, argument_list; 285, 286; 285, 301; 286, binary_operator:+; 286, 287; 286, 300; 287, binary_operator:+; 287, 288; 287, 296; 288, binary_operator:+; 288, 289; 288, 295; 289, binary_operator:+; 289, 290; 289, 291; 290, string:'Parameter values in the file name and in the file differ. Take '; 291, call; 291, 292; 291, 293; 292, identifier:str; 293, argument_list; 293, 294; 294, identifier:key; 295, string:' parameters '; 296, call; 296, 297; 296, 298; 297, identifier:str; 298, argument_list; 298, 299; 299, identifier:value; 300, string:' found in %s.'; 301, identifier:file_name; 302, except_clause; 302, 303; 302, 304; 302, 305; 303, identifier:KeyError; 304, comment; 305, block; 305, 306; 306, pass_statement; 307, except_clause; 307, 308; 307, 309; 308, identifier:IndexError; 309, block; 309, 310; 310, raise_statement; 310, 311; 311, call; 311, 312; 311, 313; 312, identifier:IncompleteInputError; 313, argument_list; 313, 314; 314, string:'Something wrong check!'; 315, if_statement; 315, 316; 315, 321; 315, 384; 316, boolean_operator:and; 316, 317; 316, 318; 317, identifier:unique; 318, comparison_operator:is; 318, 319; 318, 320; 319, identifier:scan_parameter_values; 320, None; 321, block; 321, 322; 321, 326; 321, 364; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 325; 324, identifier:existing; 325, False; 326, for_statement; 326, 327; 326, 328; 326, 329; 326, 330; 327, identifier:parameter; 328, identifier:scan_parameter_values; 329, comment; 330, block; 330, 331; 330, 345; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:all_par_values; 334, list_comprehension; 334, 335; 334, 338; 335, subscript; 335, 336; 335, 337; 336, identifier:values; 337, identifier:parameter; 338, for_in_clause; 338, 339; 338, 340; 339, identifier:values; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:files_dict; 343, identifier:values; 344, argument_list; 345, if_statement; 345, 346; 345, 358; 346, call; 346, 347; 346, 348; 347, identifier:any; 348, generator_expression; 348, 349; 348, 355; 349, comparison_operator:in; 349, 350; 349, 351; 350, identifier:x; 351, list:[scan_parameter_values[parameter]]; 351, 352; 352, subscript; 352, 353; 352, 354; 353, identifier:scan_parameter_values; 354, identifier:parameter; 355, for_in_clause; 355, 356; 355, 357; 356, identifier:x; 357, identifier:all_par_values; 358, block; 358, 359; 358, 363; 359, expression_statement; 359, 360; 360, assignment; 360, 361; 360, 362; 361, identifier:existing; 362, True; 363, break_statement; 364, if_statement; 364, 365; 364, 367; 364, 374; 365, not_operator; 365, 366; 366, identifier:existing; 367, block; 367, 368; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 373; 370, subscript; 370, 371; 370, 372; 371, identifier:files_dict; 372, identifier:file_name; 373, identifier:scan_parameter_values; 374, else_clause; 374, 375; 375, block; 375, 376; 376, expression_statement; 376, 377; 377, call; 377, 378; 377, 381; 378, attribute; 378, 379; 378, 380; 379, identifier:logging; 380, identifier:warning; 381, argument_list; 381, 382; 381, 383; 382, string:'Scan parameter value(s) from %s exists already, do not add to result'; 383, identifier:file_name; 384, else_clause; 384, 385; 385, block; 385, 386; 386, expression_statement; 386, 387; 387, assignment; 387, 388; 387, 391; 388, subscript; 388, 389; 388, 390; 389, identifier:files_dict; 390, identifier:file_name; 391, identifier:scan_parameter_values; 392, return_statement; 392, 393; 393, call; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:collections; 396, identifier:OrderedDict; 397, argument_list; 397, 398; 398, conditional_expression:if; 398, 399; 398, 413; 398, 414; 399, call; 399, 400; 399, 401; 400, identifier:sorted; 401, argument_list; 401, 402; 401, 407; 402, call; 402, 403; 402, 406; 403, attribute; 403, 404; 403, 405; 404, identifier:files_dict; 405, identifier:iteritems; 406, argument_list; 407, keyword_argument; 407, 408; 407, 409; 408, identifier:key; 409, call; 409, 410; 409, 411; 410, identifier:itemgetter; 411, argument_list; 411, 412; 412, integer:1; 413, identifier:sort; 414, identifier:files_dict | def get_parameter_from_files(files, parameters=None, unique=False, sort=True):
''' Takes a list of files, searches for the parameter name in the file name and in the file.
Returns a ordered dict with the file name in the first dimension and the corresponding parameter values in the second.
If a scan parameter appears in the file name and in the file the first parameter setting has to be in the file name, otherwise a warning is shown.
The file names can be sorted by the first parameter value of each file.
Parameters
----------
files : string, list of strings
parameters : string, list of strings
unique : boolean
If set only one file per scan parameter value is used.
sort : boolean
Returns
-------
collections.OrderedDict
'''
logging.debug('Get the parameter ' + str(parameters) + ' values from ' + str(len(files)) + ' files')
files_dict = collections.OrderedDict()
if isinstance(files, basestring):
files = (files, )
if isinstance(parameters, basestring):
parameters = (parameters, )
parameter_values_from_file_names_dict = get_parameter_value_from_file_names(files, parameters, unique=unique, sort=sort) # get the parameter from the file name
for file_name in files:
with tb.open_file(file_name, mode="r") as in_file_h5: # open the actual file
scan_parameter_values = collections.OrderedDict()
try:
scan_parameters = in_file_h5.root.scan_parameters[:] # get the scan parameters from the scan parameter table
if parameters is None:
parameters = get_scan_parameter_names(scan_parameters)
for parameter in parameters:
try:
scan_parameter_values[parameter] = np.unique(scan_parameters[parameter]).tolist() # different scan parameter values used
except ValueError: # the scan parameter does not exists
pass
except tb.NoSuchNodeError: # scan parameter table does not exist
try:
scan_parameters = get_scan_parameter(in_file_h5.root.meta_data[:]) # get the scan parameters from the meta data
if scan_parameters:
try:
scan_parameter_values = np.unique(scan_parameters[parameters]).tolist() # different scan parameter values used
except ValueError: # the scan parameter does not exists
pass
except tb.NoSuchNodeError: # meta data table does not exist
pass
if not scan_parameter_values: # if no scan parameter values could be set from file take the parameter found in the file name
try:
scan_parameter_values = parameter_values_from_file_names_dict[file_name]
except KeyError: # no scan parameter found at all, neither in the file name nor in the file
scan_parameter_values = None
else: # use the parameter given in the file and cross check if it matches the file name parameter if these is given
try:
for key, value in scan_parameter_values.items():
if value and value[0] != parameter_values_from_file_names_dict[file_name][key][0]: # parameter value exists: check if the first value is the file name value
logging.warning('Parameter values in the file name and in the file differ. Take ' + str(key) + ' parameters ' + str(value) + ' found in %s.', file_name)
except KeyError: # parameter does not exists in the file name
pass
except IndexError:
raise IncompleteInputError('Something wrong check!')
if unique and scan_parameter_values is not None:
existing = False
for parameter in scan_parameter_values: # loop to determine if any value of any scan parameter exists already
all_par_values = [values[parameter] for values in files_dict.values()]
if any(x in [scan_parameter_values[parameter]] for x in all_par_values):
existing = True
break
if not existing:
files_dict[file_name] = scan_parameter_values
else:
logging.warning('Scan parameter value(s) from %s exists already, do not add to result', file_name)
else:
files_dict[file_name] = scan_parameter_values
return collections.OrderedDict(sorted(files_dict.iteritems(), key=itemgetter(1)) if sort else files_dict) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:reduce_sorted_to_intersect; 3, parameters; 3, 4; 3, 5; 4, identifier:ar1; 5, identifier:ar2; 6, block; 6, 7; 6, 9; 6, 10; 6, 23; 6, 36; 6, 37; 6, 44; 6, 50; 6, 57; 6, 63; 6, 87; 6, 88; 6, 99; 6, 110; 6, 121; 6, 132; 6, 141; 6, 150; 6, 171; 6, 192; 6, 193; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:ar1; 13, call; 13, 14; 13, 22; 14, attribute; 14, 15; 14, 21; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:asarray; 19, argument_list; 19, 20; 20, identifier:ar1; 21, identifier:ravel; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:ar2; 26, call; 26, 27; 26, 35; 27, attribute; 27, 28; 27, 34; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:asarray; 32, argument_list; 32, 33; 33, identifier:ar2; 34, identifier:ravel; 35, argument_list; 36, comment; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:ar1_biggest_value; 40, subscript; 40, 41; 40, 42; 41, identifier:ar1; 42, unary_operator:-; 42, 43; 43, integer:1; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ar1_smallest_value; 47, subscript; 47, 48; 47, 49; 48, identifier:ar1; 49, integer:0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ar2_biggest_value; 53, subscript; 53, 54; 53, 55; 54, identifier:ar2; 55, unary_operator:-; 55, 56; 56, integer:1; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:ar2_smallest_value; 60, subscript; 60, 61; 60, 62; 61, identifier:ar2; 62, integer:0; 63, if_statement; 63, 64; 63, 71; 63, 72; 64, boolean_operator:or; 64, 65; 64, 68; 65, comparison_operator:<; 65, 66; 65, 67; 66, identifier:ar1_biggest_value; 67, identifier:ar2_smallest_value; 68, comparison_operator:>; 68, 69; 68, 70; 69, identifier:ar1_smallest_value; 70, identifier:ar2_biggest_value; 71, comment; 72, block; 72, 73; 73, return_statement; 73, 74; 74, expression_list; 74, 75; 74, 81; 75, subscript; 75, 76; 75, 77; 76, identifier:ar1; 77, slice; 77, 78; 77, 79; 77, 80; 78, integer:0; 79, colon; 80, integer:0; 81, subscript; 81, 82; 81, 83; 82, identifier:ar2; 83, slice; 83, 84; 83, 85; 83, 86; 84, integer:0; 85, colon; 86, integer:0; 87, comment; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:min_index_ar1; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:np; 94, identifier:argmin; 95, argument_list; 95, 96; 96, comparison_operator:<; 96, 97; 96, 98; 97, identifier:ar1; 98, identifier:ar2_smallest_value; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:max_index_ar1; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:np; 105, identifier:argmax; 106, argument_list; 106, 107; 107, comparison_operator:>; 107, 108; 107, 109; 108, identifier:ar1; 109, identifier:ar2_biggest_value; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:min_index_ar2; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:argmin; 117, argument_list; 117, 118; 118, comparison_operator:<; 118, 119; 118, 120; 119, identifier:ar2; 120, identifier:ar1_smallest_value; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:max_index_ar2; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:np; 127, identifier:argmax; 128, argument_list; 128, 129; 129, comparison_operator:>; 129, 130; 129, 131; 130, identifier:ar2; 131, identifier:ar1_biggest_value; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:<; 133, 134; 133, 135; 134, identifier:min_index_ar1; 135, integer:0; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:min_index_ar1; 140, integer:0; 141, if_statement; 141, 142; 141, 145; 142, comparison_operator:<; 142, 143; 142, 144; 143, identifier:min_index_ar2; 144, integer:0; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:min_index_ar2; 149, integer:0; 150, if_statement; 150, 151; 150, 162; 151, boolean_operator:or; 151, 152; 151, 155; 152, comparison_operator:==; 152, 153; 152, 154; 153, identifier:max_index_ar1; 154, integer:0; 155, comparison_operator:>; 155, 156; 155, 157; 156, identifier:max_index_ar1; 157, subscript; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:ar1; 160, identifier:shape; 161, integer:0; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:max_index_ar1; 166, subscript; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:ar1; 169, identifier:shape; 170, integer:0; 171, if_statement; 171, 172; 171, 183; 172, boolean_operator:or; 172, 173; 172, 176; 173, comparison_operator:==; 173, 174; 173, 175; 174, identifier:max_index_ar2; 175, integer:0; 176, comparison_operator:>; 176, 177; 176, 178; 177, identifier:max_index_ar2; 178, subscript; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:ar2; 181, identifier:shape; 182, integer:0; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:max_index_ar2; 187, subscript; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:ar2; 190, identifier:shape; 191, integer:0; 192, comment; 193, return_statement; 193, 194; 194, expression_list; 194, 195; 194, 201; 195, subscript; 195, 196; 195, 197; 196, identifier:ar1; 197, slice; 197, 198; 197, 199; 197, 200; 198, identifier:min_index_ar1; 199, colon; 200, identifier:max_index_ar1; 201, subscript; 201, 202; 201, 203; 202, identifier:ar2; 203, slice; 203, 204; 203, 205; 203, 206; 204, identifier:min_index_ar2; 205, colon; 206, identifier:max_index_ar2 | def reduce_sorted_to_intersect(ar1, ar2):
"""
Takes two sorted arrays and return the intersection ar1 in ar2, ar2 in ar1.
Parameters
----------
ar1 : (M,) array_like
Input array.
ar2 : array_like
Input array.
Returns
-------
ar1, ar1 : ndarray, ndarray
The intersection values.
"""
# Ravel both arrays, behavior for the first array could be different
ar1 = np.asarray(ar1).ravel()
ar2 = np.asarray(ar2).ravel()
# get min max values of the arrays
ar1_biggest_value = ar1[-1]
ar1_smallest_value = ar1[0]
ar2_biggest_value = ar2[-1]
ar2_smallest_value = ar2[0]
if ar1_biggest_value < ar2_smallest_value or ar1_smallest_value > ar2_biggest_value: # special case, no intersection at all
return ar1[0:0], ar2[0:0]
# get min/max indices with values that are also in the other array
min_index_ar1 = np.argmin(ar1 < ar2_smallest_value)
max_index_ar1 = np.argmax(ar1 > ar2_biggest_value)
min_index_ar2 = np.argmin(ar2 < ar1_smallest_value)
max_index_ar2 = np.argmax(ar2 > ar1_biggest_value)
if min_index_ar1 < 0:
min_index_ar1 = 0
if min_index_ar2 < 0:
min_index_ar2 = 0
if max_index_ar1 == 0 or max_index_ar1 > ar1.shape[0]:
max_index_ar1 = ar1.shape[0]
if max_index_ar2 == 0 or max_index_ar2 > ar2.shape[0]:
max_index_ar2 = ar2.shape[0]
# reduce the data
return ar1[min_index_ar1:max_index_ar1], ar2[min_index_ar2:max_index_ar2] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_hits_in_events; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:hits_array; 5, identifier:events; 6, default_parameter; 6, 7; 6, 8; 7, identifier:assume_sorted; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:condition; 11, None; 12, block; 12, 13; 12, 15; 12, 27; 12, 60; 12, 161; 13, expression_statement; 13, 14; 14, string:'''Selects the hits that occurred in events and optional selection criterion.
If a event range can be defined use the get_data_in_event_range function. It is much faster.
Parameters
----------
hits_array : numpy.array
events : array
assume_sorted : bool
Is true if the events to select are sorted from low to high value. Increases speed by 35%.
condition : string
A condition that is applied to the hits in numexpr. Only if the expression evaluates to True the hit is taken.
Returns
-------
numpy.array
hit array with the hits in events.
'''; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:logging; 19, identifier:debug; 20, argument_list; 20, 21; 21, binary_operator:%; 21, 22; 21, 23; 22, string:"Calculate hits that exists in the given %d events."; 23, call; 23, 24; 23, 25; 24, identifier:len; 25, argument_list; 25, 26; 26, identifier:events; 27, if_statement; 27, 28; 27, 29; 28, identifier:assume_sorted; 29, block; 29, 30; 29, 42; 29, 43; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:events; 34, identifier:_; 35, call; 35, 36; 35, 37; 36, identifier:reduce_sorted_to_intersect; 37, argument_list; 37, 38; 37, 39; 38, identifier:events; 39, subscript; 39, 40; 39, 41; 40, identifier:hits_array; 41, string:'event_number'; 42, comment; 43, if_statement; 43, 44; 43, 51; 43, 52; 44, comparison_operator:==; 44, 45; 44, 50; 45, subscript; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:events; 48, identifier:shape; 49, integer:0; 50, integer:0; 51, comment; 52, block; 52, 53; 53, return_statement; 53, 54; 54, subscript; 54, 55; 54, 56; 55, identifier:hits_array; 56, slice; 56, 57; 56, 58; 56, 59; 57, integer:0; 58, colon; 59, integer:0; 60, try_statement; 60, 61; 60, 149; 61, block; 61, 62; 61, 98; 62, if_statement; 62, 63; 62, 64; 62, 77; 63, identifier:assume_sorted; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:selection; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:analysis_utils; 71, identifier:in1d_events; 72, argument_list; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:hits_array; 75, string:'event_number'; 76, identifier:events; 77, else_clause; 77, 78; 78, block; 78, 79; 78, 86; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:logging; 83, identifier:warning; 84, argument_list; 84, 85; 85, string:'Events are usually sorted. Are you sure you want this?'; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:selection; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:np; 92, identifier:in1d; 93, argument_list; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:hits_array; 96, string:'event_number'; 97, identifier:events; 98, if_statement; 98, 99; 98, 102; 98, 109; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:condition; 101, None; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:hits_in_events; 106, subscript; 106, 107; 106, 108; 107, identifier:hits_array; 108, identifier:selection; 109, else_clause; 109, 110; 109, 111; 110, comment; 111, block; 111, 112; 111, 136; 112, for_statement; 112, 113; 112, 114; 112, 124; 113, identifier:variable; 114, call; 114, 115; 114, 116; 115, identifier:set; 116, argument_list; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:re; 120, identifier:findall; 121, argument_list; 121, 122; 121, 123; 122, string:r'[a-zA-Z_]+'; 123, identifier:condition; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:exec; 128, argument_list; 128, 129; 129, binary_operator:+; 129, 130; 129, 135; 130, binary_operator:+; 130, 131; 130, 134; 131, binary_operator:+; 131, 132; 131, 133; 132, identifier:variable; 133, string:' = hits_array[\''; 134, identifier:variable; 135, string:'\']'; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:hits_in_events; 139, subscript; 139, 140; 139, 141; 140, identifier:hits_array; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:ne; 144, identifier:evaluate; 145, argument_list; 145, 146; 146, binary_operator:+; 146, 147; 146, 148; 147, identifier:condition; 148, string:' & selection'; 149, except_clause; 149, 150; 149, 151; 150, identifier:MemoryError; 151, block; 151, 152; 151, 159; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:logging; 156, identifier:error; 157, argument_list; 157, 158; 158, string:'There are too many hits to do in RAM operations. Consider decreasing chunk size and use the write_hits_in_events function instead.'; 159, raise_statement; 159, 160; 160, identifier:MemoryError; 161, return_statement; 161, 162; 162, identifier:hits_in_events | def get_hits_in_events(hits_array, events, assume_sorted=True, condition=None):
'''Selects the hits that occurred in events and optional selection criterion.
If a event range can be defined use the get_data_in_event_range function. It is much faster.
Parameters
----------
hits_array : numpy.array
events : array
assume_sorted : bool
Is true if the events to select are sorted from low to high value. Increases speed by 35%.
condition : string
A condition that is applied to the hits in numexpr. Only if the expression evaluates to True the hit is taken.
Returns
-------
numpy.array
hit array with the hits in events.
'''
logging.debug("Calculate hits that exists in the given %d events." % len(events))
if assume_sorted:
events, _ = reduce_sorted_to_intersect(events, hits_array['event_number']) # reduce the event number range to the max min event number of the given hits to save time
if events.shape[0] == 0: # if there is not a single selected hit
return hits_array[0:0]
try:
if assume_sorted:
selection = analysis_utils.in1d_events(hits_array['event_number'], events)
else:
logging.warning('Events are usually sorted. Are you sure you want this?')
selection = np.in1d(hits_array['event_number'], events)
if condition is None:
hits_in_events = hits_array[selection]
else:
# bad hack to be able to use numexpr
for variable in set(re.findall(r'[a-zA-Z_]+', condition)):
exec(variable + ' = hits_array[\'' + variable + '\']')
hits_in_events = hits_array[ne.evaluate(condition + ' & selection')]
except MemoryError:
logging.error('There are too many hits to do in RAM operations. Consider decreasing chunk size and use the write_hits_in_events function instead.')
raise MemoryError
return hits_in_events |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:natsorted; 3, parameters; 3, 4; 3, 5; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:cmp; 7, identifier:natcmp; 8, block; 8, 9; 8, 11; 8, 14; 8, 23; 8, 29; 9, expression_statement; 9, 10; 10, string:"Returns a copy of seq, sorted by natural string sort."; 11, import_statement; 11, 12; 12, dotted_name; 12, 13; 13, identifier:copy; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:temp; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:copy; 20, identifier:copy; 21, argument_list; 21, 22; 22, identifier:seq; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:natsort; 26, argument_list; 26, 27; 26, 28; 27, identifier:temp; 28, identifier:cmp; 29, return_statement; 29, 30; 30, identifier:temp | def natsorted(seq, cmp=natcmp):
"Returns a copy of seq, sorted by natural string sort."
import copy
temp = copy.copy(seq)
natsort(temp, cmp)
return temp |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:sort2groups; 3, parameters; 3, 4; 3, 5; 4, identifier:array; 5, default_parameter; 5, 6; 5, 7; 6, identifier:gpat; 7, list:['_R1','_R2']; 7, 8; 7, 9; 8, string:'_R1'; 9, string:'_R2'; 10, block; 10, 11; 10, 13; 10, 24; 10, 28; 10, 64; 11, expression_statement; 11, 12; 12, comment; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:groups; 16, list_comprehension; 16, 17; 16, 21; 17, call; 17, 18; 17, 19; 18, identifier:REGroup; 19, argument_list; 19, 20; 20, identifier:gp; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:gp; 23, identifier:gpat; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:unmatched; 27, list:[]; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:item; 30, identifier:array; 31, block; 31, 32; 31, 36; 31, 53; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:matched; 35, False; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:m; 38, identifier:groups; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 47; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:m; 44, identifier:match; 45, argument_list; 45, 46; 46, identifier:item; 47, block; 47, 48; 47, 52; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:matched; 51, True; 52, break_statement; 53, if_statement; 53, 54; 53, 56; 54, not_operator; 54, 55; 55, identifier:matched; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:unmatched; 61, identifier:append; 62, argument_list; 62, 63; 63, identifier:item; 64, return_statement; 64, 65; 65, expression_list; 65, 66; 65, 76; 66, list_comprehension; 66, 67; 66, 73; 67, call; 67, 68; 67, 69; 68, identifier:sorted; 69, argument_list; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:m; 72, identifier:list; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:m; 75, identifier:groups; 76, call; 76, 77; 76, 78; 77, identifier:sorted; 78, argument_list; 78, 79; 79, identifier:unmatched | def sort2groups(array, gpat=['_R1','_R2']):
""" Sort an array of strings to groups by patterns """
groups = [REGroup(gp) for gp in gpat]
unmatched = []
for item in array:
matched = False
for m in groups:
if m.match(item):
matched = True
break
if not matched: unmatched.append(item)
return [sorted(m.list) for m in groups], sorted(unmatched) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_and_distribute; 3, parameters; 3, 4; 3, 5; 4, identifier:array; 5, default_parameter; 5, 6; 5, 7; 6, identifier:splits; 7, integer:2; 8, block; 8, 9; 8, 11; 8, 26; 8, 39; 8, 46; 8, 71; 8, 79; 8, 113; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 20; 12, not_operator; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:array; 17, tuple; 17, 18; 17, 19; 18, identifier:list; 19, identifier:tuple; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:TypeError; 24, argument_list; 24, 25; 25, string:"array must be a list"; 26, if_statement; 26, 27; 26, 33; 27, not_operator; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:splits; 32, identifier:int; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:TypeError; 37, argument_list; 37, 38; 38, string:"splits must be an integer"; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:remaining; 42, call; 42, 43; 42, 44; 43, identifier:sorted; 44, argument_list; 44, 45; 45, identifier:array; 46, if_statement; 46, 47; 46, 54; 46, 62; 47, comparison_operator:<; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:sys; 50, identifier:version_info; 51, tuple; 51, 52; 51, 53; 52, integer:3; 53, integer:0; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:myrange; 58, call; 58, 59; 58, 60; 59, identifier:xrange; 60, argument_list; 60, 61; 61, identifier:splits; 62, else_clause; 62, 63; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:myrange; 67, call; 67, 68; 67, 69; 68, identifier:range; 69, argument_list; 69, 70; 70, identifier:splits; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:groups; 74, list_comprehension; 74, 75; 74, 76; 75, list:[]; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:i; 78, identifier:myrange; 79, while_statement; 79, 80; 79, 86; 80, comparison_operator:>; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:remaining; 85, integer:0; 86, block; 86, 87; 87, for_statement; 87, 88; 87, 89; 87, 90; 88, identifier:i; 89, identifier:myrange; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 98; 92, comparison_operator:>; 92, 93; 92, 97; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:remaining; 97, integer:0; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:groups; 104, identifier:i; 105, identifier:append; 106, argument_list; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:remaining; 110, identifier:pop; 111, argument_list; 111, 112; 112, integer:0; 113, return_statement; 113, 114; 114, identifier:groups | def sort_and_distribute(array, splits=2):
""" Sort an array of strings to groups by alphabetically continuous
distribution
"""
if not isinstance(array, (list,tuple)): raise TypeError("array must be a list")
if not isinstance(splits, int): raise TypeError("splits must be an integer")
remaining = sorted(array)
if sys.version_info < (3, 0):
myrange = xrange(splits)
else:
myrange = range(splits)
groups = [[] for i in myrange]
while len(remaining) > 0:
for i in myrange:
if len(remaining) > 0: groups[i].append(remaining.pop(0))
return groups |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:section; 7, type; 7, 8; 8, identifier:int; 9, default_parameter; 9, 10; 9, 11; 10, identifier:order; 11, None; 12, block; 12, 13; 12, 15; 12, 23; 12, 31; 12, 37; 12, 82; 13, expression_statement; 13, 14; 14, comment; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:attr; 18, subscript; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:header; 22, identifier:section; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:old_i; 27, identifier:old_sort; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:sort_state; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:beginResetModel; 36, argument_list; 37, if_statement; 37, 38; 37, 41; 37, 62; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:section; 40, identifier:old_i; 41, block; 41, 42; 41, 53; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:collection; 48, identifier:sort; 49, argument_list; 49, 50; 49, 51; 50, identifier:attr; 51, not_operator; 51, 52; 52, identifier:old_sort; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:sort_state; 58, tuple; 58, 59; 58, 60; 59, identifier:section; 60, not_operator; 60, 61; 61, identifier:old_sort; 62, else_clause; 62, 63; 63, block; 63, 64; 63, 74; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:collection; 70, identifier:sort; 71, argument_list; 71, 72; 71, 73; 72, identifier:attr; 73, True; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:sort_state; 79, tuple; 79, 80; 79, 81; 80, identifier:section; 81, True; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:endResetModel; 87, argument_list | def sort(self, section: int, order=None):
"""Order is defined by the current state of sorting"""
attr = self.header[section]
old_i, old_sort = self.sort_state
self.beginResetModel()
if section == old_i:
self.collection.sort(attr, not old_sort)
self.sort_state = (section, not old_sort)
else:
self.collection.sort(attr, True)
self.sort_state = (section, True)
self.endResetModel() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:set_collection; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:collection; 6, block; 6, 7; 6, 9; 6, 15; 6, 21; 6, 30; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:beginResetModel; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:collection; 20, identifier:collection; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:sort_state; 26, tuple; 26, 27; 26, 29; 27, unary_operator:-; 27, 28; 28, integer:1; 29, False; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:endResetModel; 35, argument_list | def set_collection(self, collection):
"""Reset sort state, set collection and emit resetModel signal"""
self.beginResetModel()
self.collection = collection
self.sort_state = (-1, False)
self.endResetModel() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:copy; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:items; 7, None; 8, block; 8, 9; 8, 11; 9, expression_statement; 9, 10; 10, comment; 11, return_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:NGram; 14, argument_list; 14, 15; 14, 21; 14, 24; 14, 27; 14, 30; 14, 33; 14, 36; 15, conditional_expression:if; 15, 16; 15, 17; 15, 20; 16, identifier:items; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:items; 19, None; 20, identifier:self; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:threshold; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:warp; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_key; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:N; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_pad_len; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_pad_char | def copy(self, items=None):
"""Return a new NGram object with the same settings, and
referencing the same items. Copy is shallow in that
each item is not recursively copied. Optionally specify
alternate items to populate the copy.
>>> from ngram import NGram
>>> from copy import deepcopy
>>> n = NGram(['eggs', 'spam'])
>>> m = n.copy()
>>> m.add('ham')
>>> sorted(list(n))
['eggs', 'spam']
>>> sorted(list(m))
['eggs', 'ham', 'spam']
>>> p = n.copy(['foo', 'bar'])
>>> sorted(list(p))
['bar', 'foo']
"""
return NGram(items if items is not None else self,
self.threshold, self.warp, self._key,
self.N, self._pad_len, self._pad_char) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:items_sharing_ngrams; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:query; 6, block; 6, 7; 6, 9; 6, 10; 6, 14; 6, 15; 6, 16; 6, 20; 6, 95; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:shared; 13, dictionary; 14, comment; 15, comment; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:remaining; 19, dictionary; 20, for_statement; 20, 21; 20, 22; 20, 28; 21, identifier:ngram; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:split; 26, argument_list; 26, 27; 27, identifier:query; 28, block; 28, 29; 29, try_statement; 29, 30; 29, 91; 30, block; 30, 31; 31, for_statement; 31, 32; 31, 35; 31, 44; 32, pattern_list; 32, 33; 32, 34; 33, identifier:match; 34, identifier:count; 35, call; 35, 36; 35, 43; 36, attribute; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_grams; 41, identifier:ngram; 42, identifier:items; 43, argument_list; 44, block; 44, 45; 44, 59; 44, 60; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 56; 47, attribute; 47, 48; 47, 55; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:remaining; 51, identifier:setdefault; 52, argument_list; 52, 53; 52, 54; 53, identifier:ngram; 54, dictionary; 55, identifier:setdefault; 56, argument_list; 56, 57; 56, 58; 57, identifier:match; 58, identifier:count; 59, comment; 60, if_statement; 60, 61; 60, 68; 61, comparison_operator:>; 61, 62; 61, 67; 62, subscript; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:remaining; 65, identifier:ngram; 66, identifier:match; 67, integer:0; 68, block; 68, 69; 68, 77; 68, 85; 69, expression_statement; 69, 70; 70, augmented_assignment:-=; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:remaining; 74, identifier:ngram; 75, identifier:match; 76, integer:1; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:shared; 81, identifier:setdefault; 82, argument_list; 82, 83; 82, 84; 83, identifier:match; 84, integer:0; 85, expression_statement; 85, 86; 86, augmented_assignment:+=; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:shared; 89, identifier:match; 90, integer:1; 91, except_clause; 91, 92; 91, 93; 92, identifier:KeyError; 93, block; 93, 94; 94, pass_statement; 95, return_statement; 95, 96; 96, identifier:shared | def items_sharing_ngrams(self, query):
"""Retrieve the subset of items that share n-grams the query string.
:param query: look up items that share N-grams with this string.
:return: mapping from matched string to the number of shared N-grams.
>>> from ngram import NGram
>>> n = NGram(["ham","spam","eggs"])
>>> sorted(n.items_sharing_ngrams("mam").items())
[('ham', 2), ('spam', 2)]
"""
# From matched string to number of N-grams shared with query string
shared = {}
# Dictionary mapping n-gram to string to number of occurrences of that
# ngram in the string that remain to be matched.
remaining = {}
for ngram in self.split(query):
try:
for match, count in self._grams[ngram].items():
remaining.setdefault(ngram, {}).setdefault(match, count)
# match as many occurrences as exist in matched string
if remaining[ngram][match] > 0:
remaining[ngram][match] -= 1
shared.setdefault(match, 0)
shared[match] += 1
except KeyError:
pass
return shared |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:searchitem; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:item; 6, default_parameter; 6, 7; 6, 8; 7, identifier:threshold; 8, None; 9, block; 9, 10; 9, 12; 10, expression_statement; 10, 11; 11, comment; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:search; 17, argument_list; 17, 18; 17, 24; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:key; 22, argument_list; 22, 23; 23, identifier:item; 24, identifier:threshold | def searchitem(self, item, threshold=None):
"""Search the index for items whose key exceeds the threshold
similarity to the key of the given item.
:return: list of pairs of (item, similarity) by decreasing similarity.
>>> from ngram import NGram
>>> n = NGram([(0, "SPAM"), (1, "SPAN"), (2, "EG"),
... (3, "SPANN")], key=lambda x:x[1])
>>> sorted(n.searchitem((2, "SPA"), 0.35))
[((0, 'SPAM'), 0.375), ((1, 'SPAN'), 0.375)]
"""
return self.search(self.key(item), threshold) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:search; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:threshold; 8, None; 9, block; 9, 10; 9, 12; 9, 23; 9, 27; 9, 28; 9, 100; 9, 101; 9, 118; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:threshold; 15, conditional_expression:if; 15, 16; 15, 17; 15, 20; 16, identifier:threshold; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:threshold; 19, None; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:threshold; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:results; 26, list:[]; 27, comment; 28, for_statement; 28, 29; 28, 32; 28, 42; 29, pattern_list; 29, 30; 29, 31; 30, identifier:match; 31, identifier:samegrams; 32, call; 32, 33; 32, 41; 33, attribute; 33, 34; 33, 40; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:items_sharing_ngrams; 38, argument_list; 38, 39; 39, identifier:query; 40, identifier:items; 41, argument_list; 42, block; 42, 43; 42, 73; 42, 86; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:allgrams; 46, parenthesized_expression; 46, 47; 47, binary_operator:+; 47, 48; 47, 72; 48, binary_operator:-; 48, 49; 48, 71; 49, binary_operator:-; 49, 50; 49, 65; 50, binary_operator:+; 50, 51; 50, 60; 51, call; 51, 52; 51, 53; 52, identifier:len; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:pad; 58, argument_list; 58, 59; 59, identifier:query; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:length; 64, identifier:match; 65, parenthesized_expression; 65, 66; 66, binary_operator:*; 66, 67; 66, 68; 67, integer:2; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:N; 71, identifier:samegrams; 72, integer:2; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:similarity; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:ngram_similarity; 80, argument_list; 80, 81; 80, 82; 80, 83; 81, identifier:samegrams; 82, identifier:allgrams; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:warp; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:>=; 87, 88; 87, 89; 88, identifier:similarity; 89, identifier:threshold; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:results; 95, identifier:append; 96, argument_list; 96, 97; 97, tuple; 97, 98; 97, 99; 98, identifier:match; 99, identifier:similarity; 100, comment; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:results; 105, identifier:sort; 106, argument_list; 106, 107; 106, 115; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:key; 109, lambda; 109, 110; 109, 112; 110, lambda_parameters; 110, 111; 111, identifier:x; 112, subscript; 112, 113; 112, 114; 113, identifier:x; 114, integer:1; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:reverse; 117, True; 118, return_statement; 118, 119; 119, identifier:results | def search(self, query, threshold=None):
"""Search the index for items whose key exceeds threshold
similarity to the query string.
:param query: returned items will have at least `threshold` \
similarity to the query string.
:return: list of pairs of (item, similarity) by decreasing similarity.
>>> from ngram import NGram
>>> n = NGram([(0, "SPAM"), (1, "SPAN"), (2, "EG")], key=lambda x:x[1])
>>> sorted(n.search("SPA"))
[((0, 'SPAM'), 0.375), ((1, 'SPAN'), 0.375)]
>>> n.search("M")
[((0, 'SPAM'), 0.125)]
>>> n.search("EG")
[((2, 'EG'), 1.0)]
"""
threshold = threshold if threshold is not None else self.threshold
results = []
# Identify possible results
for match, samegrams in self.items_sharing_ngrams(query).items():
allgrams = (len(self.pad(query))
+ self.length[match] - (2 * self.N) - samegrams + 2)
similarity = self.ngram_similarity(samegrams, allgrams, self.warp)
if similarity >= threshold:
results.append((match, similarity))
# Sort results by decreasing similarity
results.sort(key=lambda x: x[1], reverse=True)
return results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:clear; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 18; 5, 24; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, call; 9, 10; 9, 17; 10, attribute; 10, 11; 10, 16; 11, call; 11, 12; 11, 13; 12, identifier:super; 13, argument_list; 13, 14; 13, 15; 14, identifier:NGram; 15, identifier:self; 16, identifier:clear; 17, argument_list; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_grams; 23, dictionary; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:length; 29, dictionary | def clear(self):
"""Remove all elements from this set.
>>> from ngram import NGram
>>> n = NGram(['spam', 'eggs'])
>>> sorted(list(n))
['eggs', 'spam']
>>> n.clear()
>>> list(n)
[]
"""
super(NGram, self).clear()
self._grams = {}
self.length = {} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:others; 7, block; 7, 8; 7, 10; 8, expression_statement; 8, 9; 9, comment; 10, return_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:copy; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, call; 18, 19; 18, 20; 19, identifier:super; 20, argument_list; 20, 21; 20, 22; 21, identifier:NGram; 22, identifier:self; 23, identifier:union; 24, argument_list; 24, 25; 25, list_splat; 25, 26; 26, identifier:others | def union(self, *others):
"""Return the union of two or more sets as a new set.
>>> from ngram import NGram
>>> a = NGram(['spam', 'eggs'])
>>> b = NGram(['spam', 'ham'])
>>> sorted(list(a.union(b)))
['eggs', 'ham', 'spam']
"""
return self.copy(super(NGram, self).union(*others)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:symmetric_difference; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:other; 6, block; 6, 7; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:copy; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 23; 16, attribute; 16, 17; 16, 22; 17, call; 17, 18; 17, 19; 18, identifier:super; 19, argument_list; 19, 20; 19, 21; 20, identifier:NGram; 21, identifier:self; 22, identifier:symmetric_difference; 23, argument_list; 23, 24; 24, identifier:other | def symmetric_difference(self, other):
"""Return the symmetric difference of two sets as a new set.
>>> from ngram import NGram
>>> a = NGram(['spam', 'eggs'])
>>> b = NGram(['spam', 'ham'])
>>> sorted(list(a.symmetric_difference(b)))
['eggs', 'ham']
"""
return self.copy(super(NGram, self).symmetric_difference(other)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:symmetric_difference_update; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:other; 6, block; 6, 7; 6, 9; 6, 22; 6, 29; 6, 30; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:intersection; 12, call; 12, 13; 12, 20; 13, attribute; 13, 14; 13, 19; 14, call; 14, 15; 14, 16; 15, identifier:super; 16, argument_list; 16, 17; 16, 18; 17, identifier:NGram; 18, identifier:self; 19, identifier:intersection; 20, argument_list; 20, 21; 21, identifier:other; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:update; 27, argument_list; 27, 28; 28, identifier:other; 29, comment; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:difference_update; 35, argument_list; 35, 36; 36, identifier:intersection | def symmetric_difference_update(self, other):
"""Update the set with the symmetric difference of itself and `other`.
>>> from ngram import NGram
>>> n = NGram(['spam', 'eggs'])
>>> other = set(['spam', 'ham'])
>>> n.symmetric_difference_update(other)
>>> sorted(list(n))
['eggs', 'ham']
"""
intersection = super(NGram, self).intersection(other)
self.update(other) # add items present in other
self.difference_update(intersection) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:download; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 4, identifier:directory; 5, default_parameter; 5, 6; 5, 7; 6, identifier:master_token; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:member; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:access_token; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:source; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:project_data; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:max_size; 22, string:'128m'; 23, default_parameter; 23, 24; 23, 25; 24, identifier:verbose; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:debug; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:memberlist; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:excludelist; 34, None; 35, default_parameter; 35, 36; 35, 37; 36, identifier:id_filename; 37, False; 38, block; 38, 39; 38, 41; 38, 47; 38, 65; 38, 72; 38, 79; 38, 98; 38, 111; 39, expression_statement; 39, 40; 40, comment; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:set_log_level; 44, argument_list; 44, 45; 44, 46; 45, identifier:debug; 46, identifier:verbose; 47, if_statement; 47, 48; 47, 57; 48, boolean_operator:and; 48, 49; 48, 53; 49, parenthesized_expression; 49, 50; 50, boolean_operator:or; 50, 51; 50, 52; 51, identifier:memberlist; 52, identifier:excludelist; 53, parenthesized_expression; 53, 54; 54, boolean_operator:or; 54, 55; 54, 56; 55, identifier:member; 56, identifier:access_token; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:UsageError; 61, argument_list; 61, 62; 62, concatenated_string; 62, 63; 62, 64; 63, string:'Please do not provide a memberlist or excludelist '; 64, string:'when retrieving data for a single member.'; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:memberlist; 68, call; 68, 69; 68, 70; 69, identifier:read_id_list; 70, argument_list; 70, 71; 71, identifier:memberlist; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:excludelist; 75, call; 75, 76; 75, 77; 76, identifier:read_id_list; 77, argument_list; 77, 78; 78, identifier:excludelist; 79, if_statement; 79, 80; 79, 90; 80, boolean_operator:or; 80, 81; 80, 86; 81, not_operator; 81, 82; 82, parenthesized_expression; 82, 83; 83, boolean_operator:or; 83, 84; 83, 85; 84, identifier:master_token; 85, identifier:access_token; 86, parenthesized_expression; 86, 87; 87, boolean_operator:and; 87, 88; 87, 89; 88, identifier:master_token; 89, identifier:access_token; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:UsageError; 94, argument_list; 94, 95; 95, concatenated_string; 95, 96; 95, 97; 96, string:'Please specify either a master access token (-T), '; 97, string:'or an OAuth2 user access token (-t).'; 98, if_statement; 98, 99; 98, 103; 99, parenthesized_expression; 99, 100; 100, boolean_operator:and; 100, 101; 100, 102; 101, identifier:source; 102, identifier:project_data; 103, block; 103, 104; 104, raise_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:UsageError; 107, argument_list; 107, 108; 108, concatenated_string; 108, 109; 108, 110; 109, string:"It doesn't make sense to use both 'source' and"; 110, string:"'project-data' options!"; 111, if_statement; 111, 112; 111, 113; 111, 207; 112, identifier:master_token; 113, block; 113, 114; 113, 123; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:project; 117, call; 117, 118; 117, 119; 118, identifier:OHProject; 119, argument_list; 119, 120; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:master_access_token; 122, identifier:master_token; 123, if_statement; 123, 124; 123, 125; 123, 178; 124, identifier:member; 125, block; 125, 126; 126, if_statement; 126, 127; 126, 128; 126, 151; 127, identifier:project_data; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:project; 133, identifier:download_member_project_data; 134, argument_list; 134, 135; 134, 142; 134, 145; 134, 148; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:member_data; 137, subscript; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:project; 140, identifier:project_data; 141, identifier:member; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:target_member_dir; 144, identifier:directory; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:max_size; 147, identifier:max_size; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:id_filename; 150, identifier:id_filename; 151, else_clause; 151, 152; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:project; 157, identifier:download_member_shared; 158, argument_list; 158, 159; 158, 166; 158, 169; 158, 172; 158, 175; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:member_data; 161, subscript; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:project; 164, identifier:project_data; 165, identifier:member; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:target_member_dir; 168, identifier:directory; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:source; 171, identifier:source; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:max_size; 174, identifier:max_size; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:id_filename; 177, identifier:id_filename; 178, else_clause; 178, 179; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:project; 184, identifier:download_all; 185, argument_list; 185, 186; 185, 189; 185, 192; 185, 195; 185, 198; 185, 201; 185, 204; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:target_dir; 188, identifier:directory; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:source; 191, identifier:source; 192, keyword_argument; 192, 193; 192, 194; 193, identifier:max_size; 194, identifier:max_size; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:memberlist; 197, identifier:memberlist; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:excludelist; 200, identifier:excludelist; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:project_data; 203, identifier:project_data; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:id_filename; 206, identifier:id_filename; 207, else_clause; 207, 208; 208, block; 208, 209; 208, 219; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:member_data; 212, call; 212, 213; 212, 214; 213, identifier:exchange_oauth2_member; 214, argument_list; 214, 215; 214, 216; 215, identifier:access_token; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:all_files; 218, True; 219, if_statement; 219, 220; 219, 221; 219, 240; 220, identifier:project_data; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:OHProject; 226, identifier:download_member_project_data; 227, argument_list; 227, 228; 227, 231; 227, 234; 227, 237; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:member_data; 230, identifier:member_data; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:target_member_dir; 233, identifier:directory; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:max_size; 236, identifier:max_size; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:id_filename; 239, identifier:id_filename; 240, else_clause; 240, 241; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:OHProject; 246, identifier:download_member_shared; 247, argument_list; 247, 248; 247, 251; 247, 254; 247, 257; 247, 260; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:member_data; 250, identifier:member_data; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:target_member_dir; 253, identifier:directory; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:source; 256, identifier:source; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:max_size; 259, identifier:max_size; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:id_filename; 262, identifier:id_filename | def download(directory, master_token=None, member=None, access_token=None,
source=None, project_data=False, max_size='128m', verbose=False,
debug=False, memberlist=None, excludelist=None,
id_filename=False):
"""
Download data from project members to the target directory.
Unless this is a member-specific download, directories will be
created for each project member ID. Also, unless a source is specified,
all shared sources are downloaded and data is sorted into subdirectories
according to source.
Projects can optionally return data to Open Humans member accounts.
If project_data is True (or the "--project-data" flag is used), this data
(the project's own data files, instead of data from other sources) will be
downloaded for each member.
:param directory: This field is the target directory to download data.
:param master_token: This field is the master access token for the project.
It's default value is None.
:param member: This field is specific member whose project data is
downloaded. It's default value is None.
:param access_token: This field is the user specific access token. It's
default value is None.
:param source: This field is the data source. It's default value is None.
:param project_data: This field is data related to particular project. It's
default value is False.
:param max_size: This field is the maximum file size. It's default value is
128m.
:param verbose: This boolean field is the logging level. It's default value
is False.
:param debug: This boolean field is the logging level. It's default value
is False.
:param memberlist: This field is list of members whose data will be
downloaded. It's default value is None.
:param excludelist: This field is list of members whose data will be
skipped. It's default value is None.
"""
set_log_level(debug, verbose)
if (memberlist or excludelist) and (member or access_token):
raise UsageError('Please do not provide a memberlist or excludelist '
'when retrieving data for a single member.')
memberlist = read_id_list(memberlist)
excludelist = read_id_list(excludelist)
if not (master_token or access_token) or (master_token and access_token):
raise UsageError('Please specify either a master access token (-T), '
'or an OAuth2 user access token (-t).')
if (source and project_data):
raise UsageError("It doesn't make sense to use both 'source' and"
"'project-data' options!")
if master_token:
project = OHProject(master_access_token=master_token)
if member:
if project_data:
project.download_member_project_data(
member_data=project.project_data[member],
target_member_dir=directory,
max_size=max_size,
id_filename=id_filename)
else:
project.download_member_shared(
member_data=project.project_data[member],
target_member_dir=directory,
source=source,
max_size=max_size,
id_filename=id_filename)
else:
project.download_all(target_dir=directory,
source=source,
max_size=max_size,
memberlist=memberlist,
excludelist=excludelist,
project_data=project_data,
id_filename=id_filename)
else:
member_data = exchange_oauth2_member(access_token, all_files=True)
if project_data:
OHProject.download_member_project_data(member_data=member_data,
target_member_dir=directory,
max_size=max_size,
id_filename=id_filename)
else:
OHProject.download_member_shared(member_data=member_data,
target_member_dir=directory,
source=source,
max_size=max_size,
id_filename=id_filename) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:columns; 7, dictionary_splat_pattern; 7, 8; 8, identifier:options; 9, block; 9, 10; 9, 12; 9, 24; 9, 118; 9, 131; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:sorts; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:meta; 20, identifier:setdefault; 21, argument_list; 21, 22; 21, 23; 22, string:'sort'; 23, list:[]; 24, for_statement; 24, 25; 24, 26; 24, 27; 25, identifier:column; 26, identifier:columns; 27, block; 27, 28; 27, 96; 27, 109; 28, if_statement; 28, 29; 28, 34; 28, 41; 28, 84; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:column; 33, identifier:Column; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:identifier; 38, attribute; 38, 39; 38, 40; 39, identifier:column; 40, identifier:id; 41, elif_clause; 41, 42; 41, 49; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:column; 46, attribute; 46, 47; 46, 48; 47, identifier:utils; 48, identifier:basestring; 49, block; 49, 50; 49, 67; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:descending; 53, boolean_operator:or; 53, 54; 53, 60; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:column; 57, identifier:startswith; 58, argument_list; 58, 59; 59, string:'-'; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:options; 63, identifier:get; 64, argument_list; 64, 65; 64, 66; 65, string:'descending'; 66, False; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:identifier; 70, attribute; 70, 71; 70, 83; 71, subscript; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:api; 76, identifier:columns; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:column; 80, identifier:lstrip; 81, argument_list; 81, 82; 82, string:'-'; 83, identifier:id; 84, else_clause; 84, 85; 85, block; 85, 86; 86, raise_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:ValueError; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, string:"Can only sort on columns or column strings. Received: {}"; 93, identifier:format; 94, argument_list; 94, 95; 95, identifier:column; 96, if_statement; 96, 97; 96, 98; 96, 103; 97, identifier:descending; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:sign; 102, string:'-'; 103, else_clause; 103, 104; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:sign; 108, string:''; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:sorts; 113, identifier:append; 114, argument_list; 114, 115; 115, binary_operator:+; 115, 116; 115, 117; 116, identifier:sign; 117, identifier:identifier; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 125; 120, subscript; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:raw; 124, string:'sort'; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, string:","; 128, identifier:join; 129, argument_list; 129, 130; 130, identifier:sorts; 131, return_statement; 131, 132; 132, identifier:self | def sort(self, *columns, **options):
"""
Return a new query which will produce results sorted by
one or more metrics or dimensions. You may use plain
strings for the columns, or actual `Column`, `Metric`
and `Dimension` objects.
Add a minus in front of the metric (either the string or
the object) to sort in descending order.
```python
# sort using strings
query.sort('pageviews', '-device type')
# alternatively, ask for a descending sort in a keyword argument
query.sort('pageviews', descending=True)
# sort using metric, dimension or column objects
pageviews = profile.core.metrics['pageviews']
query.sort(-pageviews)
```
"""
sorts = self.meta.setdefault('sort', [])
for column in columns:
if isinstance(column, Column):
identifier = column.id
elif isinstance(column, utils.basestring):
descending = column.startswith('-') or options.get('descending', False)
identifier = self.api.columns[column.lstrip('-')].id
else:
raise ValueError("Can only sort on columns or column strings. Received: {}".format(column))
if descending:
sign = '-'
else:
sign = ''
sorts.append(sign + identifier)
self.raw['sort'] = ",".join(sorts)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:getList; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:aspList; 6, block; 6, 7; 6, 9; 6, 10; 6, 26; 6, 42; 6, 58; 6, 66; 6, 67; 6, 82; 6, 90; 6, 106; 6, 122; 6, 132; 6, 133; 6, 137; 6, 209; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:objects; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_elements; 17, argument_list; 17, 18; 17, 21; 17, 24; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:SIG_OBJECTS; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:N; 24, list:[0]; 24, 25; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:houses; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_elements; 33, argument_list; 33, 34; 33, 37; 33, 40; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:SIG_HOUSES; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:N; 40, list:[0]; 40, 41; 41, integer:0; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:angles; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_elements; 49, argument_list; 49, 50; 49, 53; 49, 56; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:SIG_ANGLES; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:N; 56, list:[0]; 56, 57; 57, integer:0; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:significators; 61, binary_operator:+; 61, 62; 61, 65; 62, binary_operator:+; 62, 63; 62, 64; 63, identifier:objects; 64, identifier:houses; 65, identifier:angles; 66, comment; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:objects; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_elements; 74, argument_list; 74, 75; 74, 78; 74, 81; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:SIG_OBJECTS; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:N; 81, identifier:aspList; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:terms; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:_terms; 89, argument_list; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:antiscias; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_elements; 97, argument_list; 97, 98; 97, 101; 97, 104; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:SIG_OBJECTS; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:A; 104, list:[0]; 104, 105; 105, integer:0; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:cantiscias; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:_elements; 113, argument_list; 113, 114; 113, 117; 113, 120; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:SIG_OBJECTS; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:C; 120, list:[0]; 120, 121; 121, integer:0; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:promissors; 125, binary_operator:+; 125, 126; 125, 131; 126, binary_operator:+; 126, 127; 126, 130; 127, binary_operator:+; 127, 128; 127, 129; 128, identifier:objects; 129, identifier:terms; 130, identifier:antiscias; 131, identifier:cantiscias; 132, comment; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:res; 136, list:[]; 137, for_statement; 137, 138; 137, 139; 137, 140; 138, identifier:prom; 139, identifier:promissors; 140, block; 140, 141; 141, for_statement; 141, 142; 141, 143; 141, 144; 142, identifier:sig; 143, identifier:significators; 144, block; 144, 145; 144, 156; 144, 166; 145, if_statement; 145, 146; 145, 154; 146, parenthesized_expression; 146, 147; 147, comparison_operator:==; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:prom; 150, string:'id'; 151, subscript; 151, 152; 151, 153; 152, identifier:sig; 153, string:'id'; 154, block; 154, 155; 155, continue_statement; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:arcs; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:_arc; 163, argument_list; 163, 164; 163, 165; 164, identifier:prom; 165, identifier:sig; 166, for_statement; 166, 167; 166, 170; 166, 177; 167, tuple_pattern; 167, 168; 167, 169; 168, identifier:x; 169, identifier:y; 170, list:[('arcm', 'M'), ('arcz', 'Z')]; 170, 171; 170, 174; 171, tuple; 171, 172; 171, 173; 172, string:'arcm'; 173, string:'M'; 174, tuple; 174, 175; 174, 176; 175, string:'arcz'; 176, string:'Z'; 177, block; 177, 178; 177, 184; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:arc; 181, subscript; 181, 182; 181, 183; 182, identifier:arcs; 183, identifier:x; 184, if_statement; 184, 185; 184, 191; 185, comparison_operator:<; 185, 186; 185, 187; 185, 188; 186, integer:0; 187, identifier:arc; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:MAX_ARC; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:res; 196, identifier:append; 197, argument_list; 197, 198; 198, list:[
arcs[x],
prom['id'],
sig['id'],
y,
]; 198, 199; 198, 202; 198, 205; 198, 208; 199, subscript; 199, 200; 199, 201; 200, identifier:arcs; 201, identifier:x; 202, subscript; 202, 203; 202, 204; 203, identifier:prom; 204, string:'id'; 205, subscript; 205, 206; 205, 207; 206, identifier:sig; 207, string:'id'; 208, identifier:y; 209, return_statement; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:sorted; 212, argument_list; 212, 213; 213, identifier:res | def getList(self, aspList):
""" Returns a sorted list with all
primary directions.
"""
# Significators
objects = self._elements(self.SIG_OBJECTS, self.N, [0])
houses = self._elements(self.SIG_HOUSES, self.N, [0])
angles = self._elements(self.SIG_ANGLES, self.N, [0])
significators = objects + houses + angles
# Promissors
objects = self._elements(self.SIG_OBJECTS, self.N, aspList)
terms = self._terms()
antiscias = self._elements(self.SIG_OBJECTS, self.A, [0])
cantiscias = self._elements(self.SIG_OBJECTS, self.C, [0])
promissors = objects + terms + antiscias + cantiscias
# Compute all
res = []
for prom in promissors:
for sig in significators:
if (prom['id'] == sig['id']):
continue
arcs = self._arc(prom, sig)
for (x,y) in [('arcm', 'M'), ('arcz', 'Z')]:
arc = arcs[x]
if 0 < arc < self.MAX_ARC:
res.append([
arcs[x],
prom['id'],
sig['id'],
y,
])
return sorted(res) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:knt2mlt; 3, parameters; 3, 4; 4, identifier:t; 5, block; 5, 6; 5, 8; 5, 17; 5, 29; 5, 33; 5, 37; 5, 78; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:t; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:np; 14, identifier:atleast_1d; 15, argument_list; 15, 16; 16, identifier:t; 17, if_statement; 17, 18; 17, 23; 18, comparison_operator:>; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:t; 21, identifier:ndim; 22, integer:1; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:ValueError; 27, argument_list; 27, 28; 28, string:"t must be a list or a rank-1 array"; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:out; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:e; 36, None; 37, for_statement; 37, 38; 37, 39; 37, 47; 38, identifier:k; 39, call; 39, 40; 39, 41; 40, identifier:range; 41, argument_list; 41, 42; 42, subscript; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:t; 45, identifier:shape; 46, integer:0; 47, block; 47, 48; 47, 71; 48, if_statement; 48, 49; 48, 54; 48, 65; 49, comparison_operator:!=; 49, 50; 49, 53; 50, subscript; 50, 51; 50, 52; 51, identifier:t; 52, identifier:k; 53, identifier:e; 54, block; 54, 55; 54, 61; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:e; 58, subscript; 58, 59; 58, 60; 59, identifier:t; 60, identifier:k; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:count; 64, integer:0; 65, else_clause; 65, 66; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, augmented_assignment:+=; 68, 69; 68, 70; 69, identifier:count; 70, integer:1; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:out; 75, identifier:append; 76, argument_list; 76, 77; 77, identifier:count; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:array; 83, argument_list; 83, 84; 84, identifier:out | def knt2mlt(t):
"""Count multiplicities of elements in a sorted list or rank-1 array.
Minimal emulation of MATLAB's ``knt2mlt``.
Parameters:
t:
Python list or rank-1 array. Must be sorted!
Returns:
out
rank-1 array such that
out[k] = #{ t[i] == t[k] for i < k }
Example:
If ``t = [1, 1, 2, 3, 3, 3]``, then ``out = [0, 1, 0, 0, 1, 2]``.
Caveat:
Requires input to be already sorted (this is not checked).
"""
t = np.atleast_1d(t)
if t.ndim > 1:
raise ValueError("t must be a list or a rank-1 array")
out = []
e = None
for k in range(t.shape[0]):
if t[k] != e:
e = t[k]
count = 0
else:
count += 1
out.append(count)
return np.array( out ) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:get_gallery; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:section; 7, string:'hot'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, string:'viral'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:window; 13, string:'day'; 14, default_parameter; 14, 15; 14, 16; 15, identifier:show_viral; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:limit; 19, None; 20, block; 20, 21; 20, 23; 20, 43; 20, 55; 21, expression_statement; 21, 22; 22, comment; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:url; 26, parenthesized_expression; 26, 27; 27, binary_operator:+; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_base_url; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, concatenated_string; 33, 34; 33, 35; 34, string:"/3/gallery/{}/{}/{}/{}?showViral="; 35, string:"{}"; 36, identifier:format; 37, argument_list; 37, 38; 37, 39; 37, 40; 37, 41; 37, 42; 38, identifier:section; 39, identifier:sort; 40, identifier:window; 41, string:'{}'; 42, identifier:show_viral; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:resp; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_send_request; 50, argument_list; 50, 51; 50, 52; 51, identifier:url; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:limit; 54, identifier:limit; 55, return_statement; 55, 56; 56, list_comprehension; 56, 57; 56, 62; 57, call; 57, 58; 57, 59; 58, identifier:_get_album_or_image; 59, argument_list; 59, 60; 59, 61; 60, identifier:thing; 61, identifier:self; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:thing; 64, identifier:resp | def get_gallery(self, section='hot', sort='viral', window='day',
show_viral=True, limit=None):
"""
Return a list of gallery albums and gallery images.
:param section: hot | top | user - defaults to hot.
:param sort: viral | time - defaults to viral.
:param window: Change the date range of the request if the section is
"top", day | week | month | year | all, defaults to day.
:param show_viral: true | false - Show or hide viral images from the
'user' section. Defaults to true.
:param limit: The number of items to return.
"""
url = (self._base_url + "/3/gallery/{}/{}/{}/{}?showViral="
"{}".format(section, sort, window, '{}', show_viral))
resp = self._send_request(url, limit=limit)
return [_get_album_or_image(thing, self) for thing in resp] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:find_neighbors; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:neighbors; 5, identifier:coords; 6, identifier:I; 7, identifier:source_files; 8, identifier:f; 9, identifier:sides; 10, block; 10, 11; 10, 13; 10, 90; 11, expression_statement; 11, 12; 12, comment; 13, for_statement; 13, 14; 13, 17; 13, 21; 14, pattern_list; 14, 15; 14, 16; 15, identifier:i; 16, identifier:c1; 17, call; 17, 18; 17, 19; 18, identifier:enumerate; 19, argument_list; 19, 20; 20, identifier:coords; 21, block; 21, 22; 21, 30; 21, 31; 21, 43; 21, 44; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:me; 25, subscript; 25, 26; 25, 27; 26, identifier:source_files; 27, subscript; 27, 28; 27, 29; 28, identifier:I; 29, identifier:i; 30, comment; 31, if_statement; 31, 32; 31, 41; 32, comparison_operator:!=; 32, 33; 32, 40; 33, subscript; 33, 34; 33, 37; 34, subscript; 34, 35; 34, 36; 35, identifier:neighbors; 36, identifier:me; 37, subscript; 37, 38; 37, 39; 38, identifier:sides; 39, integer:0; 40, string:''; 41, block; 41, 42; 42, continue_statement; 43, comment; 44, for_statement; 44, 45; 44, 48; 44, 52; 45, pattern_list; 45, 46; 45, 47; 46, identifier:j; 47, identifier:c2; 48, call; 48, 49; 48, 50; 49, identifier:enumerate; 50, argument_list; 50, 51; 51, identifier:coords; 52, block; 52, 53; 53, if_statement; 53, 54; 53, 59; 53, 60; 54, call; 54, 55; 54, 56; 55, identifier:f; 56, argument_list; 56, 57; 56, 58; 57, identifier:c1; 58, identifier:c2; 59, comment; 60, block; 60, 61; 60, 69; 60, 79; 60, 89; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:neigh; 64, subscript; 64, 65; 64, 66; 65, identifier:source_files; 66, subscript; 66, 67; 66, 68; 67, identifier:I; 68, identifier:j; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 78; 71, subscript; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:neighbors; 74, identifier:me; 75, subscript; 75, 76; 75, 77; 76, identifier:sides; 77, integer:0; 78, identifier:neigh; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 88; 81, subscript; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:neighbors; 84, identifier:neigh; 85, subscript; 85, 86; 85, 87; 86, identifier:sides; 87, integer:1; 88, identifier:me; 89, break_statement; 90, return_statement; 90, 91; 91, identifier:neighbors | def find_neighbors(neighbors, coords, I, source_files, f, sides):
"""Find the tile neighbors based on filenames
Parameters
-----------
neighbors : dict
Dictionary that stores the neighbors. Format is
neighbors["source_file_name"]["side"] = "neighbor_source_file_name"
coords : list
List of coordinates determined from the filename.
See :py:func:`utils.parse_fn`
I : array
Sort index. Different sorting schemes will speed up when neighbors
are found
source_files : list
List of strings of source file names
f : callable
Function that determines if two tiles are neighbors based on their
coordinates. f(c1, c2) returns True if tiles are neighbors
sides : list
List of 2 strings that give the "side" where tiles are neighbors.
Returns
-------
neighbors : dict
Dictionary of neighbors
Notes
-------
For example, if Tile1 is to the left of Tile2, then
neighbors['Tile1']['right'] = 'Tile2'
neighbors['Tile2']['left'] = 'Tile1'
"""
for i, c1 in enumerate(coords):
me = source_files[I[i]]
# If the left neighbor has already been found...
if neighbors[me][sides[0]] != '':
continue
# could try coords[i:] (+ fixes) for speed if it becomes a problem
for j, c2 in enumerate(coords):
if f(c1, c2):
# then tiles are neighbors neighbors
neigh = source_files[I[j]]
neighbors[me][sides[0]] = neigh
neighbors[neigh][sides[1]] = me
break
return neighbors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sortrows; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:a; 5, default_parameter; 5, 6; 5, 7; 6, identifier:i; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:index_out; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:recurse; 13, True; 14, block; 14, 15; 14, 17; 14, 30; 14, 38; 14, 39; 14, 40; 14, 143; 15, expression_statement; 15, 16; 16, comment; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:I; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:np; 23, identifier:argsort; 24, argument_list; 24, 25; 25, subscript; 25, 26; 25, 27; 25, 29; 26, identifier:a; 27, slice; 27, 28; 28, colon; 29, identifier:i; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:a; 33, subscript; 33, 34; 33, 35; 33, 36; 34, identifier:a; 35, identifier:I; 36, slice; 36, 37; 37, colon; 38, comment; 39, comment; 40, if_statement; 40, 41; 40, 54; 41, binary_operator:&; 41, 42; 41, 43; 42, identifier:recurse; 43, parenthesized_expression; 43, 44; 44, comparison_operator:>; 44, 45; 44, 51; 45, call; 45, 46; 45, 47; 46, identifier:len; 47, argument_list; 47, 48; 48, subscript; 48, 49; 48, 50; 49, identifier:a; 50, integer:0; 51, binary_operator:+; 51, 52; 51, 53; 52, identifier:i; 53, integer:1; 54, block; 54, 55; 55, for_statement; 55, 56; 55, 57; 55, 67; 56, identifier:b; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:np; 60, identifier:unique; 61, argument_list; 61, 62; 62, subscript; 62, 63; 62, 64; 62, 66; 63, identifier:a; 64, slice; 64, 65; 65, colon; 66, identifier:i; 67, block; 67, 68; 67, 78; 67, 98; 67, 126; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:ids; 71, comparison_operator:==; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 74; 72, 76; 73, identifier:a; 74, slice; 74, 75; 75, colon; 76, identifier:i; 77, identifier:b; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:colids; 81, binary_operator:+; 81, 82; 81, 86; 82, call; 82, 83; 82, 84; 83, identifier:range; 84, argument_list; 84, 85; 85, identifier:i; 86, call; 86, 87; 86, 88; 87, identifier:range; 88, argument_list; 88, 89; 88, 92; 89, binary_operator:+; 89, 90; 89, 91; 90, identifier:i; 91, integer:1; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, subscript; 95, 96; 95, 97; 96, identifier:a; 97, integer:0; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 111; 100, pattern_list; 100, 101; 100, 110; 101, subscript; 101, 102; 101, 103; 102, identifier:a; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:np; 106, identifier:ix_; 107, argument_list; 107, 108; 107, 109; 108, identifier:ids; 109, identifier:colids; 110, identifier:I2; 111, call; 111, 112; 111, 113; 112, identifier:sortrows; 113, argument_list; 113, 114; 113, 123; 113, 124; 113, 125; 114, subscript; 114, 115; 114, 116; 115, identifier:a; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:np; 119, identifier:ix_; 120, argument_list; 120, 121; 120, 122; 121, identifier:ids; 122, identifier:colids; 123, integer:0; 124, True; 125, True; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:I; 130, identifier:ids; 131, subscript; 131, 132; 131, 133; 132, identifier:I; 133, subscript; 133, 134; 133, 142; 134, subscript; 134, 135; 134, 141; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:np; 138, identifier:nonzero; 139, argument_list; 139, 140; 140, identifier:ids; 141, integer:0; 142, identifier:I2; 143, if_statement; 143, 144; 143, 145; 143, 150; 144, identifier:index_out; 145, block; 145, 146; 146, return_statement; 146, 147; 147, expression_list; 147, 148; 147, 149; 148, identifier:a; 149, identifier:I; 150, else_clause; 150, 151; 151, block; 151, 152; 152, return_statement; 152, 153; 153, identifier:a | def sortrows(a, i=0, index_out=False, recurse=True):
""" Sorts array "a" by columns i
Parameters
------------
a : np.ndarray
array to be sorted
i : int (optional)
column to be sorted by, taken as 0 by default
index_out : bool (optional)
return the index I such that a(I) = sortrows(a,i). Default = False
recurse : bool (optional)
recursively sort by each of the columns. i.e.
once column i is sort, we sort the smallest column number
etc. True by default.
Returns
--------
a : np.ndarray
The array 'a' sorted in descending order by column i
I : np.ndarray (optional)
The index such that a[I, :] = sortrows(a, i). Only return if
index_out = True
Examples
---------
>>> a = array([[1,2],[3,1],[2,3]])
>>> b = sortrows(a,0)
>>> b
array([[1, 2],
[2, 3],
[3, 1]])
c, I = sortrows(a,1,True)
>>> c
array([[3, 1],
[1, 2],
[2, 3]])
>>> I
array([1, 0, 2])
>>> a[I,:] - c
array([[0, 0],
[0, 0],
[0, 0]])
"""
I = np.argsort(a[:, i])
a = a[I, :]
# We recursively call sortrows to make sure it is sorted best by every
# column
if recurse & (len(a[0]) > i + 1):
for b in np.unique(a[:, i]):
ids = a[:, i] == b
colids = range(i) + range(i+1, len(a[0]))
a[np.ix_(ids, colids)], I2 = sortrows(a[np.ix_(ids, colids)],
0, True, True)
I[ids] = I[np.nonzero(ids)[0][I2]]
if index_out:
return a, I
else:
return a |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:my_notes; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start_index; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:limit; 10, integer:100; 11, default_parameter; 11, 12; 11, 13; 12, identifier:get_all; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sort_by; 16, string:'loanId'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:sort_dir; 19, string:'asc'; 20, block; 20, 21; 20, 23; 20, 27; 20, 40; 20, 152; 21, expression_statement; 21, 22; 22, comment; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:index; 26, identifier:start_index; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:notes; 30, dictionary; 30, 31; 30, 34; 30, 37; 31, pair; 31, 32; 31, 33; 32, string:'loans'; 33, list:[]; 34, pair; 34, 35; 34, 36; 35, string:'total'; 36, integer:0; 37, pair; 37, 38; 37, 39; 38, string:'result'; 39, string:'success'; 40, while_statement; 40, 41; 40, 42; 41, True; 42, block; 42, 43; 42, 62; 42, 76; 42, 84; 42, 85; 42, 127; 42, 128; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:payload; 46, dictionary; 46, 47; 46, 50; 46, 53; 46, 56; 46, 59; 47, pair; 47, 48; 47, 49; 48, string:'sortBy'; 49, identifier:sort_by; 50, pair; 50, 51; 50, 52; 51, string:'dir'; 52, identifier:sort_dir; 53, pair; 53, 54; 53, 55; 54, string:'startindex'; 55, identifier:index; 56, pair; 56, 57; 56, 58; 57, string:'pagesize'; 58, identifier:limit; 59, pair; 59, 60; 59, 61; 60, string:'namespace'; 61, string:'/account'; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:response; 65, call; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:session; 70, identifier:post; 71, argument_list; 71, 72; 71, 73; 72, string:'/account/loansAj.action'; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:data; 75, identifier:payload; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:json_response; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:response; 82, identifier:json; 83, argument_list; 84, comment; 85, if_statement; 85, 86; 85, 94; 85, 115; 85, 116; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:session; 91, identifier:json_success; 92, argument_list; 92, 93; 93, identifier:json_response; 94, block; 94, 95; 94, 105; 95, expression_statement; 95, 96; 96, augmented_assignment:+=; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:notes; 99, string:'loans'; 100, subscript; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:json_response; 103, string:'searchresult'; 104, string:'loans'; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:notes; 109, string:'total'; 110, subscript; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:json_response; 113, string:'searchresult'; 114, string:'totalRecords'; 115, comment; 116, else_clause; 116, 117; 117, block; 117, 118; 117, 126; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:notes; 122, string:'result'; 123, subscript; 123, 124; 123, 125; 124, identifier:json_response; 125, string:'result'; 126, break_statement; 127, comment; 128, if_statement; 128, 129; 128, 143; 128, 148; 128, 149; 129, boolean_operator:and; 129, 130; 129, 133; 130, comparison_operator:is; 130, 131; 130, 132; 131, identifier:get_all; 132, True; 133, comparison_operator:<; 133, 134; 133, 140; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:notes; 139, string:'loans'; 140, subscript; 140, 141; 140, 142; 141, identifier:notes; 142, string:'total'; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, augmented_assignment:+=; 145, 146; 145, 147; 146, identifier:index; 147, identifier:limit; 148, comment; 149, else_clause; 149, 150; 150, block; 150, 151; 151, break_statement; 152, return_statement; 152, 153; 153, identifier:notes | def my_notes(self, start_index=0, limit=100, get_all=False, sort_by='loanId', sort_dir='asc'):
"""
Return all the loan notes you've already invested in. By default it'll return 100 results at a time.
Parameters
----------
start_index : int, optional
The result index to start on. By default only 100 records will be returned at a time, so use this
to start at a later index in the results. For example, to get results 200 - 300, set `start_index` to 200.
(default is 0)
limit : int, optional
The number of results to return per request. (default is 100)
get_all : boolean, optional
Return all results in one request, instead of 100 per request.
sort_by : string, optional
What key to sort on
sort_dir : {'asc', 'desc'}, optional
Which direction to sort
Returns
-------
dict
A dictionary with a list of matching notes on the `loans` key
"""
index = start_index
notes = {
'loans': [],
'total': 0,
'result': 'success'
}
while True:
payload = {
'sortBy': sort_by,
'dir': sort_dir,
'startindex': index,
'pagesize': limit,
'namespace': '/account'
}
response = self.session.post('/account/loansAj.action', data=payload)
json_response = response.json()
# Notes returned
if self.session.json_success(json_response):
notes['loans'] += json_response['searchresult']['loans']
notes['total'] = json_response['searchresult']['totalRecords']
# Error
else:
notes['result'] = json_response['result']
break
# Load more
if get_all is True and len(notes['loans']) < notes['total']:
index += limit
# End
else:
break
return notes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:blacken; 3, parameters; 3, 4; 4, identifier:c; 5, block; 5, 6; 5, 8; 5, 37; 5, 38; 5, 56; 5, 66; 5, 78; 5, 79; 5, 80; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 16; 9, not_operator; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:PYTHON; 13, identifier:startswith; 14, argument_list; 14, 15; 15, string:"3.6"; 16, block; 16, 17; 16, 26; 16, 36; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:msg; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, string:"Not blackening, since Python {} != Python 3.6"; 23, identifier:format; 24, argument_list; 24, 25; 25, identifier:PYTHON; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:print; 29, argument_list; 29, 30; 29, 31; 30, identifier:msg; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:file; 33, attribute; 33, 34; 33, 35; 34, identifier:sys; 35, identifier:stderr; 36, return_statement; 37, comment; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:config; 41, call; 41, 42; 41, 53; 42, attribute; 42, 43; 42, 52; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:c; 47, identifier:config; 48, identifier:get; 49, argument_list; 49, 50; 49, 51; 50, string:"travis"; 51, dictionary; 52, identifier:get; 53, argument_list; 53, 54; 53, 55; 54, string:"black"; 55, dictionary; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:version; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:config; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, string:"version"; 65, string:"18.5b0"; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:c; 70, identifier:run; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, string:"pip install black=={}"; 75, identifier:format; 76, argument_list; 76, 77; 77, identifier:version; 78, comment; 79, comment; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:checks; 84, identifier:blacken; 85, argument_list; 85, 86; 85, 87; 85, 90; 86, identifier:c; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:check; 89, True; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:diff; 92, True | def blacken(c):
"""
Install and execute ``black`` under appropriate circumstances, with diffs.
Installs and runs ``black`` under Python 3.6 (the first version it
supports). Since this sort of CI based task only needs to run once per
commit (formatting is not going to change between interpreters) this seems
like a worthwhile tradeoff.
This task uses black's ``--check`` and ``--fail`` flags, so not only will
the build fail if it does not conform, but contributors can see exactly
what they need to change. This is intended as a hedge against the fact that
not all contributors will be using Python 3.6+.
"""
if not PYTHON.startswith("3.6"):
msg = "Not blackening, since Python {} != Python 3.6".format(PYTHON)
print(msg, file=sys.stderr)
return
# Install, allowing config override of hardcoded default version
config = c.config.get("travis", {}).get("black", {})
version = config.get("version", "18.5b0")
c.run("pip install black=={}".format(version))
# Execute our blacken task, with diff + check, which will both error
# and emit diffs.
checks.blacken(c, check=True, diff=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_versions_from_changelog; 3, parameters; 3, 4; 4, identifier:changelog; 5, block; 5, 6; 5, 8; 5, 26; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:versions; 11, list_comprehension; 11, 12; 11, 16; 11, 19; 12, call; 12, 13; 12, 14; 13, identifier:Version; 14, argument_list; 14, 15; 15, identifier:x; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:x; 18, identifier:changelog; 19, if_clause; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:BUGFIX_RELEASE_RE; 23, identifier:match; 24, argument_list; 24, 25; 25, identifier:x; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:sorted; 29, argument_list; 29, 30; 30, identifier:versions | def _versions_from_changelog(changelog):
"""
Return all released versions from given ``changelog``, sorted.
:param dict changelog:
A changelog dict as returned by ``releases.util.parse_changelog``.
:returns: A sorted list of `semantic_version.Version` objects.
"""
versions = [Version(x) for x in changelog if BUGFIX_RELEASE_RE.match(x)]
return sorted(versions) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_tags; 3, parameters; 3, 4; 4, identifier:c; 5, block; 5, 6; 5, 8; 5, 12; 5, 55; 5, 56; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:tags_; 11, list:[]; 12, for_statement; 12, 13; 12, 14; 12, 34; 13, identifier:tagstr; 14, call; 14, 15; 14, 32; 15, attribute; 15, 16; 15, 31; 16, call; 16, 17; 16, 30; 17, attribute; 17, 18; 17, 29; 18, attribute; 18, 19; 18, 28; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:c; 22, identifier:run; 23, argument_list; 23, 24; 23, 25; 24, string:"git tag"; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:hide; 27, True; 28, identifier:stdout; 29, identifier:strip; 30, argument_list; 31, identifier:split; 32, argument_list; 32, 33; 33, string:"\n"; 34, block; 34, 35; 35, try_statement; 35, 36; 35, 47; 35, 48; 35, 49; 35, 50; 35, 51; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:tags_; 41, identifier:append; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:Version; 45, argument_list; 45, 46; 46, identifier:tagstr; 47, comment; 48, comment; 49, comment; 50, comment; 51, except_clause; 51, 52; 51, 53; 52, identifier:ValueError; 53, block; 53, 54; 54, pass_statement; 55, comment; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:sorted; 59, argument_list; 59, 60; 60, identifier:tags_ | def _get_tags(c):
"""
Return sorted list of release-style tags as semver objects.
"""
tags_ = []
for tagstr in c.run("git tag", hide=True).stdout.strip().split("\n"):
try:
tags_.append(Version(tagstr))
# Ignore anything non-semver; most of the time they'll be non-release
# tags, and even if they are, we can't reason about anything
# non-semver anyways.
# TODO: perhaps log these to DEBUG
except ValueError:
pass
# Version objects sort semantically
return sorted(tags_) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 1, 7; 2, function_name:sortForSameExpTime; 3, parameters; 3, 4; 3, 5; 4, identifier:expTimes; 5, identifier:img_paths; 6, comment; 7, block; 7, 8; 7, 10; 7, 14; 7, 44; 7, 45; 7, 46; 7, 47; 7, 48; 7, 49; 7, 63; 8, expression_statement; 8, 9; 9, string:'''
return image paths sorted for same exposure time
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:d; 13, dictionary; 14, for_statement; 14, 15; 14, 18; 14, 23; 15, pattern_list; 15, 16; 15, 17; 16, identifier:e; 17, identifier:i; 18, call; 18, 19; 18, 20; 19, identifier:zip; 20, argument_list; 20, 21; 20, 22; 21, identifier:expTimes; 22, identifier:img_paths; 23, block; 23, 24; 23, 35; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:not; 25, 26; 25, 27; 26, identifier:e; 27, identifier:d; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:d; 33, identifier:e; 34, list:[]; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:d; 40, identifier:e; 41, identifier:append; 42, argument_list; 42, 43; 43, identifier:i; 44, comment; 45, comment; 46, comment; 47, comment; 48, comment; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:d; 52, call; 52, 53; 52, 54; 53, identifier:OrderedDict; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:sorted; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:d; 61, identifier:items; 62, argument_list; 63, return_statement; 63, 64; 64, expression_list; 64, 65; 64, 73; 65, call; 65, 66; 65, 67; 66, identifier:list; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:d; 71, identifier:keys; 72, argument_list; 73, call; 73, 74; 73, 75; 74, identifier:list; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:d; 79, identifier:values; 80, argument_list | def sortForSameExpTime(expTimes, img_paths): # , excludeSingleImg=True):
'''
return image paths sorted for same exposure time
'''
d = {}
for e, i in zip(expTimes, img_paths):
if e not in d:
d[e] = []
d[e].append(i)
# for key in list(d.keys()):
# if len(d[key]) == 1:
# print('have only one image of exposure time [%s]' % key)
# print('--> exclude that one')
# d.pop(key)
d = OrderedDict(sorted(d.items()))
return list(d.keys()), list(d.values()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:actionnames; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 12; 5, 55; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:actions; 11, list:[]; 12, for_statement; 12, 13; 12, 14; 12, 24; 13, identifier:service_name; 14, call; 14, 15; 14, 16; 15, identifier:sorted; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:services; 22, identifier:keys; 23, argument_list; 24, block; 24, 25; 24, 39; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:action_names; 28, call; 28, 29; 28, 38; 29, attribute; 29, 30; 29, 37; 30, attribute; 30, 31; 30, 36; 31, subscript; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:services; 35, identifier:service_name; 36, identifier:actions; 37, identifier:keys; 38, argument_list; 39, for_statement; 39, 40; 39, 41; 39, 45; 40, identifier:action_name; 41, call; 41, 42; 41, 43; 42, identifier:sorted; 43, argument_list; 43, 44; 44, identifier:action_names; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:actions; 50, identifier:append; 51, argument_list; 51, 52; 52, tuple; 52, 53; 52, 54; 53, identifier:service_name; 54, identifier:action_name; 55, return_statement; 55, 56; 56, identifier:actions | def actionnames(self):
"""
Returns a alphabetical sorted list of tuples with all known
service- and action-names.
"""
actions = []
for service_name in sorted(self.services.keys()):
action_names = self.services[service_name].actions.keys()
for action_name in sorted(action_names):
actions.append((service_name, action_name))
return actions |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:lookup_field_orderable; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:field; 6, block; 6, 7; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, try_statement; 9, 10; 9, 24; 10, block; 10, 11; 10, 22; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 20; 13, attribute; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:model; 18, identifier:_meta; 19, identifier:get_field_by_name; 20, argument_list; 20, 21; 21, identifier:field; 22, return_statement; 22, 23; 23, True; 24, except_clause; 24, 25; 24, 26; 24, 27; 25, identifier:Exception; 26, comment; 27, block; 27, 28; 28, return_statement; 28, 29; 29, False | def lookup_field_orderable(self, field):
"""
Returns whether the passed in field is sortable or not, by default all 'raw' fields, that
is fields that are part of the model are sortable.
"""
try:
self.model._meta.get_field_by_name(field)
return True
except Exception:
# that field doesn't exist, so not sortable
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:run; 3, parameters; 3, 4; 3, 5; 4, identifier:files; 5, identifier:temp_folder; 6, block; 6, 7; 6, 9; 6, 20; 6, 27; 6, 28; 7, expression_statement; 7, 8; 8, comment; 9, try_statement; 9, 10; 9, 15; 10, block; 10, 11; 10, 14; 11, import_statement; 11, 12; 12, dotted_name; 12, 13; 13, identifier:isort; 14, comment; 15, except_clause; 15, 16; 15, 17; 16, identifier:ImportError; 17, block; 17, 18; 18, return_statement; 18, 19; 19, identifier:NO_ISORT_MSG; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:py_files; 23, call; 23, 24; 23, 25; 24, identifier:filter_python_files; 25, argument_list; 25, 26; 26, identifier:files; 27, comment; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 46; 30, attribute; 30, 31; 30, 45; 31, call; 31, 32; 31, 33; 32, identifier:bash; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, string:'isort -df --quiet {0}'; 37, identifier:format; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, string:' '; 42, identifier:join; 43, argument_list; 43, 44; 44, identifier:py_files; 45, identifier:value; 46, argument_list | def run(files, temp_folder):
"""Check isort errors in the code base.
For the --quiet option, at least isort >= 4.1.1 is required.
https://github.com/timothycrosley/isort/blob/develop/CHANGELOG.md#411
"""
try:
import isort # NOQA
except ImportError:
return NO_ISORT_MSG
py_files = filter_python_files(files)
# --quiet because isort >= 4.1 outputs its logo in the console by default.
return bash('isort -df --quiet {0}'.format(' '.join(py_files))).value() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:keys; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 14; 11, 35; 12, expression_statement; 12, 13; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:ks; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 19, 29; 19, 32; 20, call; 20, 21; 20, 22; 21, identifier:list; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:dict; 26, identifier:keys; 27, argument_list; 27, 28; 28, identifier:self; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:key; 31, identifier:key; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:reverse; 34, identifier:reverse; 35, return_statement; 35, 36; 36, identifier:ks | def keys(self, key=None, reverse=False):
"""sort the keys before returning them"""
ks = sorted(list(dict.keys(self)), key=key, reverse=reverse)
return ks |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:lazy_map; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:data_processor; 5, identifier:data_generator; 6, default_parameter; 6, 7; 6, 8; 7, identifier:n_cpus; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:stepsize; 11, None; 12, block; 12, 13; 12, 15; 12, 42; 12, 51; 12, 55; 12, 100; 13, expression_statement; 13, 14; 14, comment; 15, if_statement; 15, 16; 15, 18; 15, 27; 16, not_operator; 16, 17; 17, identifier:n_cpus; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:n_cpus; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:mp; 25, identifier:cpu_count; 26, argument_list; 27, elif_clause; 27, 28; 27, 31; 28, comparison_operator:<; 28, 29; 28, 30; 29, identifier:n_cpus; 30, integer:0; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:n_cpus; 35, binary_operator:-; 35, 36; 35, 41; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:mp; 39, identifier:cpu_count; 40, argument_list; 41, identifier:n_cpus; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:stepsize; 45, None; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:stepsize; 50, identifier:n_cpus; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:results; 54, list:[]; 55, with_statement; 55, 56; 55, 69; 56, with_clause; 56, 57; 57, with_item; 57, 58; 58, as_pattern; 58, 59; 58, 67; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:mp; 62, identifier:Pool; 63, argument_list; 63, 64; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:processes; 66, identifier:n_cpus; 67, as_pattern_target; 67, 68; 68, identifier:p; 69, block; 69, 70; 70, while_statement; 70, 71; 70, 72; 71, True; 72, block; 72, 73; 72, 87; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:r; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:p; 79, identifier:map; 80, argument_list; 80, 81; 80, 82; 81, identifier:data_processor; 82, call; 82, 83; 82, 84; 83, identifier:islice; 84, argument_list; 84, 85; 84, 86; 85, identifier:data_generator; 86, identifier:stepsize; 87, if_statement; 87, 88; 87, 89; 87, 97; 88, identifier:r; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:results; 94, identifier:extend; 95, argument_list; 95, 96; 96, identifier:r; 97, else_clause; 97, 98; 98, block; 98, 99; 99, break_statement; 100, return_statement; 100, 101; 101, identifier:results | def lazy_map(data_processor, data_generator, n_cpus=1, stepsize=None):
"""A variant of multiprocessing.Pool.map that supports lazy evaluation
As with the regular multiprocessing.Pool.map, the processes are spawned off
asynchronously while the results are returned in order. In contrast to
multiprocessing.Pool.map, the iterator (here: data_generator) is not
consumed at once but evaluated lazily which is useful if the iterator
(for example, a generator) contains objects with a large memory footprint.
Parameters
==========
data_processor : func
A processing function that is applied to objects in `data_generator`
data_generator : iterator or generator
A python iterator or generator that yields objects to be fed into the
`data_processor` function for processing.
n_cpus=1 : int (default: 1)
Number of processes to run in parallel.
- If `n_cpus` > 0, the specified number of CPUs will be used.
- If `n_cpus=0`, all available CPUs will be used.
- If `n_cpus` < 0, all available CPUs - `n_cpus` will be used.
stepsize : int or None (default: None)
The number of items to fetch from the iterator to pass on to the
workers at a time.
If `stepsize=None` (default), the stepsize size will
be set equal to `n_cpus`.
Returns
=========
list : A Python list containing the results returned
by the `data_processor` function when called on
all elements in yielded by the `data_generator` in
sorted order. Note that the last list may contain
fewer items if the number of elements in `data_generator`
is not evenly divisible by `stepsize`.
"""
if not n_cpus:
n_cpus = mp.cpu_count()
elif n_cpus < 0:
n_cpus = mp.cpu_count() - n_cpus
if stepsize is None:
stepsize = n_cpus
results = []
with mp.Pool(processes=n_cpus) as p:
while True:
r = p.map(data_processor, islice(data_generator, stepsize))
if r:
results.extend(r)
else:
break
return results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:lazy_imap; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:data_processor; 5, identifier:data_generator; 6, default_parameter; 6, 7; 6, 8; 7, identifier:n_cpus; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:stepsize; 11, None; 12, block; 12, 13; 12, 15; 12, 42; 12, 51; 13, expression_statement; 13, 14; 14, comment; 15, if_statement; 15, 16; 15, 18; 15, 27; 16, not_operator; 16, 17; 17, identifier:n_cpus; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:n_cpus; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:mp; 25, identifier:cpu_count; 26, argument_list; 27, elif_clause; 27, 28; 27, 31; 28, comparison_operator:<; 28, 29; 28, 30; 29, identifier:n_cpus; 30, integer:0; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:n_cpus; 35, binary_operator:-; 35, 36; 35, 41; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:mp; 39, identifier:cpu_count; 40, argument_list; 41, identifier:n_cpus; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:stepsize; 45, None; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:stepsize; 50, identifier:n_cpus; 51, with_statement; 51, 52; 51, 65; 52, with_clause; 52, 53; 53, with_item; 53, 54; 54, as_pattern; 54, 55; 54, 63; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:mp; 58, identifier:Pool; 59, argument_list; 59, 60; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:processes; 62, identifier:n_cpus; 63, as_pattern_target; 63, 64; 64, identifier:p; 65, block; 65, 66; 66, while_statement; 66, 67; 66, 68; 67, True; 68, block; 68, 69; 68, 83; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:r; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:p; 75, identifier:map; 76, argument_list; 76, 77; 76, 78; 77, identifier:data_processor; 78, call; 78, 79; 78, 80; 79, identifier:islice; 80, argument_list; 80, 81; 80, 82; 81, identifier:data_generator; 82, identifier:stepsize; 83, if_statement; 83, 84; 83, 85; 83, 89; 84, identifier:r; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, yield; 87, 88; 88, identifier:r; 89, else_clause; 89, 90; 90, block; 90, 91; 91, break_statement | def lazy_imap(data_processor, data_generator, n_cpus=1, stepsize=None):
"""A variant of multiprocessing.Pool.imap that supports lazy evaluation
As with the regular multiprocessing.Pool.imap, the processes are spawned
off asynchronously while the results are returned in order. In contrast to
multiprocessing.Pool.imap, the iterator (here: data_generator) is not
consumed at once but evaluated lazily which is useful if the iterator
(for example, a generator) contains objects with a large memory footprint.
Parameters
==========
data_processor : func
A processing function that is applied to objects in `data_generator`
data_generator : iterator or generator
A python iterator or generator that yields objects to be fed into the
`data_processor` function for processing.
n_cpus=1 : int (default: 1)
Number of processes to run in parallel.
- If `n_cpus` > 0, the specified number of CPUs will be used.
- If `n_cpus=0`, all available CPUs will be used.
- If `n_cpus` < 0, all available CPUs - `n_cpus` will be used.
stepsize : int or None (default: None)
The number of items to fetch from the iterator to pass on to the
workers at a time.
If `stepsize=None` (default), the stepsize size will
be set equal to `n_cpus`.
Returns
=========
list : A Python list containing the *n* results returned
by the `data_processor` function when called on
elements by the `data_generator` in
sorted order; *n* is equal to the size of `stepsize`. If `stepsize`
is None, *n* is equal to `n_cpus`.
"""
if not n_cpus:
n_cpus = mp.cpu_count()
elif n_cpus < 0:
n_cpus = mp.cpu_count() - n_cpus
if stepsize is None:
stepsize = n_cpus
with mp.Pool(processes=n_cpus) as p:
while True:
r = p.map(data_processor, islice(data_generator, stepsize))
if r:
yield r
else:
break |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_dummy_thread; 3, parameters; 3, 4; 3, 5; 4, identifier:nsamples; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 10; 7, 20; 7, 30; 7, 43; 7, 53; 7, 66; 7, 80; 7, 135; 7, 149; 7, 168; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:seed; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:kwargs; 16, identifier:pop; 17, argument_list; 17, 18; 17, 19; 18, string:'seed'; 19, False; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:ndim; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:kwargs; 26, identifier:pop; 27, argument_list; 27, 28; 27, 29; 28, string:'ndim'; 29, integer:2; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:logl_start; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:kwargs; 36, identifier:pop; 37, argument_list; 37, 38; 37, 39; 38, string:'logl_start'; 39, unary_operator:-; 39, 40; 40, attribute; 40, 41; 40, 42; 41, identifier:np; 42, identifier:inf; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:logl_range; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:kwargs; 49, identifier:pop; 50, argument_list; 50, 51; 50, 52; 51, string:'logl_range'; 52, integer:1; 53, if_statement; 53, 54; 53, 55; 54, identifier:kwargs; 55, block; 55, 56; 56, raise_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:TypeError; 59, argument_list; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, string:'Unexpected **kwargs: {0}'; 63, identifier:format; 64, argument_list; 64, 65; 65, identifier:kwargs; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:seed; 69, False; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:np; 76, identifier:random; 77, identifier:seed; 78, argument_list; 78, 79; 79, identifier:seed; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:thread; 83, dictionary; 83, 84; 83, 101; 83, 110; 83, 122; 84, pair; 84, 85; 84, 86; 85, string:'logl'; 86, binary_operator:*; 86, 87; 86, 100; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:sort; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:random; 97, identifier:random; 98, argument_list; 98, 99; 99, identifier:nsamples; 100, identifier:logl_range; 101, pair; 101, 102; 101, 103; 102, string:'nlive_array'; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:np; 106, identifier:full; 107, argument_list; 107, 108; 107, 109; 108, identifier:nsamples; 109, float:1.; 110, pair; 110, 111; 110, 112; 111, string:'theta'; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:random; 117, identifier:random; 118, argument_list; 118, 119; 119, tuple; 119, 120; 119, 121; 120, identifier:nsamples; 121, identifier:ndim; 122, pair; 122, 123; 122, 124; 123, string:'thread_labels'; 124, call; 124, 125; 124, 133; 125, attribute; 125, 126; 125, 132; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:np; 129, identifier:zeros; 130, argument_list; 130, 131; 131, identifier:nsamples; 132, identifier:astype; 133, argument_list; 133, 134; 134, identifier:int; 135, if_statement; 135, 136; 135, 142; 136, comparison_operator:!=; 136, 137; 136, 138; 137, identifier:logl_start; 138, unary_operator:-; 138, 139; 139, attribute; 139, 140; 139, 141; 140, identifier:np; 141, identifier:inf; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, augmented_assignment:+=; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:thread; 147, string:'logl'; 148, identifier:logl_start; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:thread; 153, string:'thread_min_max'; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:np; 157, identifier:asarray; 158, argument_list; 158, 159; 159, list:[[logl_start, thread['logl'][-1]]]; 159, 160; 160, list:[logl_start, thread['logl'][-1]]; 160, 161; 160, 162; 161, identifier:logl_start; 162, subscript; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:thread; 165, string:'logl'; 166, unary_operator:-; 166, 167; 167, integer:1; 168, return_statement; 168, 169; 169, identifier:thread | def get_dummy_thread(nsamples, **kwargs):
"""Generate dummy data for a single nested sampling thread.
Log-likelihood values of points are generated from a uniform distribution
in (0, 1), sorted, scaled by logl_range and shifted by logl_start (if it is
not -np.inf). Theta values of each point are each generated from a uniform
distribution in (0, 1).
Parameters
----------
nsamples: int
Number of samples in thread.
ndim: int, optional
Number of dimensions.
seed: int, optional
If not False, the seed is set with np.random.seed(seed).
logl_start: float, optional
logl at which thread starts.
logl_range: float, optional
Scale factor applied to logl values.
"""
seed = kwargs.pop('seed', False)
ndim = kwargs.pop('ndim', 2)
logl_start = kwargs.pop('logl_start', -np.inf)
logl_range = kwargs.pop('logl_range', 1)
if kwargs:
raise TypeError('Unexpected **kwargs: {0}'.format(kwargs))
if seed is not False:
np.random.seed(seed)
thread = {'logl': np.sort(np.random.random(nsamples)) * logl_range,
'nlive_array': np.full(nsamples, 1.),
'theta': np.random.random((nsamples, ndim)),
'thread_labels': np.zeros(nsamples).astype(int)}
if logl_start != -np.inf:
thread['logl'] += logl_start
thread['thread_min_max'] = np.asarray([[logl_start, thread['logl'][-1]]])
return thread |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_dummy_run; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:nthread; 5, identifier:nsamples; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 11; 8, 21; 8, 31; 8, 44; 8, 54; 8, 67; 8, 71; 8, 72; 8, 86; 8, 90; 8, 119; 8, 120; 8, 121; 8, 122; 8, 139; 8, 162; 8, 163; 8, 164; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:seed; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:kwargs; 17, identifier:pop; 18, argument_list; 18, 19; 18, 20; 19, string:'seed'; 20, False; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:ndim; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:kwargs; 27, identifier:pop; 28, argument_list; 28, 29; 28, 30; 29, string:'ndim'; 30, integer:2; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:logl_start; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:kwargs; 37, identifier:pop; 38, argument_list; 38, 39; 38, 40; 39, string:'logl_start'; 40, unary_operator:-; 40, 41; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:inf; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:logl_range; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:kwargs; 50, identifier:pop; 51, argument_list; 51, 52; 51, 53; 52, string:'logl_range'; 53, integer:1; 54, if_statement; 54, 55; 54, 56; 55, identifier:kwargs; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:TypeError; 60, argument_list; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, string:'Unexpected **kwargs: {0}'; 64, identifier:format; 65, argument_list; 65, 66; 66, identifier:kwargs; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:threads; 70, list:[]; 71, comment; 72, if_statement; 72, 73; 72, 76; 73, comparison_operator:is; 73, 74; 73, 75; 74, identifier:seed; 75, False; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:random; 83, identifier:seed; 84, argument_list; 84, 85; 85, identifier:seed; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:threads; 89, list:[]; 90, for_statement; 90, 91; 90, 92; 90, 96; 91, identifier:_; 92, call; 92, 93; 92, 94; 93, identifier:range; 94, argument_list; 94, 95; 95, identifier:nthread; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:threads; 101, identifier:append; 102, argument_list; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:get_dummy_thread; 105, argument_list; 105, 106; 105, 107; 105, 110; 105, 113; 105, 116; 106, identifier:nsamples; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:ndim; 109, identifier:ndim; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:seed; 112, False; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:logl_start; 115, identifier:logl_start; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:logl_range; 118, identifier:logl_range; 119, comment; 120, comment; 121, comment; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:threads; 125, call; 125, 126; 125, 127; 126, identifier:sorted; 127, argument_list; 127, 128; 127, 129; 128, identifier:threads; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:key; 131, lambda; 131, 132; 131, 134; 132, lambda_parameters; 132, 133; 133, identifier:th; 134, subscript; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:th; 137, string:'logl'; 138, integer:0; 139, for_statement; 139, 140; 139, 143; 139, 147; 140, pattern_list; 140, 141; 140, 142; 141, identifier:i; 142, identifier:_; 143, call; 143, 144; 143, 145; 144, identifier:enumerate; 145, argument_list; 145, 146; 146, identifier:threads; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 155; 150, subscript; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:threads; 153, identifier:i; 154, string:'thread_labels'; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:np; 158, identifier:full; 159, argument_list; 159, 160; 159, 161; 160, identifier:nsamples; 161, identifier:i; 162, comment; 163, comment; 164, return_statement; 164, 165; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:nestcheck; 169, identifier:ns_run_utils; 170, identifier:combine_threads; 171, argument_list; 171, 172; 172, identifier:threads | def get_dummy_run(nthread, nsamples, **kwargs):
"""Generate dummy data for a nested sampling run.
Log-likelihood values of points are generated from a uniform distribution
in (0, 1), sorted, scaled by logl_range and shifted by logl_start (if it is
not -np.inf). Theta values of each point are each generated from a uniform
distribution in (0, 1).
Parameters
----------
nthreads: int
Number of threads in the run.
nsamples: int
Number of samples in thread.
ndim: int, optional
Number of dimensions.
seed: int, optional
If not False, the seed is set with np.random.seed(seed).
logl_start: float, optional
logl at which thread starts.
logl_range: float, optional
Scale factor applied to logl values.
"""
seed = kwargs.pop('seed', False)
ndim = kwargs.pop('ndim', 2)
logl_start = kwargs.pop('logl_start', -np.inf)
logl_range = kwargs.pop('logl_range', 1)
if kwargs:
raise TypeError('Unexpected **kwargs: {0}'.format(kwargs))
threads = []
# set seed before generating any threads and do not reset for each thread
if seed is not False:
np.random.seed(seed)
threads = []
for _ in range(nthread):
threads.append(get_dummy_thread(
nsamples, ndim=ndim, seed=False, logl_start=logl_start,
logl_range=logl_range))
# Sort threads in order of starting logl so labels match labels that would
# have been given processing a dead points array. N.B. this only works when
# all threads have same start_logl
threads = sorted(threads, key=lambda th: th['logl'][0])
for i, _ in enumerate(threads):
threads[i]['thread_labels'] = np.full(nsamples, i)
# Use combine_ns_runs rather than combine threads as this relabels the
# threads according to their order
return nestcheck.ns_run_utils.combine_threads(threads) |
Subsets and Splits