nodes
stringlengths 501
22.4k
| edges
stringlengths 138
5.07k
| code
stringlengths 108
19.3k
|
|---|---|---|
0, module; 1, function_definition; 2, function_name:register; 3, parameters; 4, block; 5, identifier:self; 6, identifier:func; 7, identifier:order; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, return_statement; 13, comment:"""
Add a function to the filter chain.
:param func: A callable which is to be added to the filter chain.
:param order: An object indicating the ordering of the function
relative to the others.
:return: Token representing the registration.
Register the function `func` as a filter into the chain. `order` must
be a value which is used as a sorting key to order the functions
registered in the chain.
The type of `order` depends on the use of the filter, as does the
number of arguments and keyword arguments which `func` must accept.
This will generally be documented at the place where the
:class:`Filter` is used.
Functions with the same order are sorted in the order of their
addition, with the function which was added earliest first.
Remember that all values passed to `order` which are registered at the
same time in the same :class:`Filter` need to be totally orderable with
respect to each other.
The returned token can be used to :meth:`unregister` a filter.
"""; 14, assignment; 15, call; 16, call; 17, identifier:token; 18, identifier:token; 19, call; 20, attribute; 21, argument_list; 22, attribute; 23, argument_list; 24, attribute; 25, argument_list; 26, attribute; 27, identifier:append; 28, tuple; 29, attribute; 30, identifier:sort; 31, keyword_argument; 32, identifier:self; 33, identifier:Token; 34, identifier:self; 35, identifier:_filter_order; 36, identifier:order; 37, identifier:token; 38, identifier:func; 39, identifier:self; 40, identifier:_filter_order; 41, identifier:key; 42, lambda; 43, lambda_parameters; 44, subscript; 45, identifier:x; 46, identifier:x; 47, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 8, 13; 9, 14; 10, 15; 11, 16; 12, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 16, 23; 19, 24; 19, 25; 20, 26; 20, 27; 21, 28; 22, 29; 22, 30; 23, 31; 24, 32; 24, 33; 26, 34; 26, 35; 28, 36; 28, 37; 28, 38; 29, 39; 29, 40; 31, 41; 31, 42; 42, 43; 42, 44; 43, 45; 44, 46; 44, 47 | def register(self, func, order):
"""
Add a function to the filter chain.
:param func: A callable which is to be added to the filter chain.
:param order: An object indicating the ordering of the function
relative to the others.
:return: Token representing the registration.
Register the function `func` as a filter into the chain. `order` must
be a value which is used as a sorting key to order the functions
registered in the chain.
The type of `order` depends on the use of the filter, as does the
number of arguments and keyword arguments which `func` must accept.
This will generally be documented at the place where the
:class:`Filter` is used.
Functions with the same order are sorted in the order of their
addition, with the function which was added earliest first.
Remember that all values passed to `order` which are registered at the
same time in the same :class:`Filter` need to be totally orderable with
respect to each other.
The returned token can be used to :meth:`unregister` a filter.
"""
token = self.Token()
self._filter_order.append((order, token, func))
self._filter_order.sort(key=lambda x: x[0])
return token |
0, module; 1, function_definition; 2, function_name:get_features; 3, parameters; 4, block; 5, identifier:self; 6, identifier:jid; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, for_statement; 11, return_statement; 12, comment:"""
Return the features supported by a service.
:param jid: Address of the PubSub service to query.
:type jid: :class:`aioxmpp.JID`
:return: Set of supported features
:rtype: set containing :class:`~.pubsub.xso.Feature` enumeration
members.
This simply uses service discovery to obtain the set of features and
converts the features to :class:`~.pubsub.xso.Feature` enumeration
members. To get the full feature information, resort to using
:meth:`.DiscoClient.query_info` directly on `jid`.
Features returned by the peer which are not valid pubsub features are
not returned.
"""; 13, assignment; 14, assignment; 15, identifier:feature; 16, attribute; 17, block; 18, identifier:result; 19, identifier:response; 20, yield; 21, identifier:result; 22, call; 23, identifier:response; 24, identifier:features; 25, try_statement; 26, call; 27, identifier:set; 28, argument_list; 29, block; 30, except_clause; 31, attribute; 32, argument_list; 33, expression_statement; 34, identifier:ValueError; 35, block; 36, attribute; 37, identifier:query_info; 38, identifier:jid; 39, call; 40, continue_statement; 41, identifier:self; 42, identifier:_disco; 43, attribute; 44, argument_list; 45, identifier:result; 46, identifier:add; 47, call; 48, attribute; 49, argument_list; 50, identifier:pubsub_xso; 51, identifier:Feature; 52, identifier:feature | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 9, 14; 10, 15; 10, 16; 10, 17; 11, 18; 13, 19; 13, 20; 14, 21; 14, 22; 16, 23; 16, 24; 17, 25; 20, 26; 22, 27; 22, 28; 25, 29; 25, 30; 26, 31; 26, 32; 29, 33; 30, 34; 30, 35; 31, 36; 31, 37; 32, 38; 33, 39; 35, 40; 36, 41; 36, 42; 39, 43; 39, 44; 43, 45; 43, 46; 44, 47; 47, 48; 47, 49; 48, 50; 48, 51; 49, 52 | def get_features(self, jid):
"""
Return the features supported by a service.
:param jid: Address of the PubSub service to query.
:type jid: :class:`aioxmpp.JID`
:return: Set of supported features
:rtype: set containing :class:`~.pubsub.xso.Feature` enumeration
members.
This simply uses service discovery to obtain the set of features and
converts the features to :class:`~.pubsub.xso.Feature` enumeration
members. To get the full feature information, resort to using
:meth:`.DiscoClient.query_info` directly on `jid`.
Features returned by the peer which are not valid pubsub features are
not returned.
"""
response = yield from self._disco.query_info(jid)
result = set()
for feature in response.features:
try:
result.add(pubsub_xso.Feature(feature))
except ValueError:
continue
return result |
0, module; 1, function_definition; 2, function_name:intersect; 3, parameters; 4, block; 5, identifier:self; 6, identifier:other; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, comment:"""Intersect with `other` sorted index.
Parameters
----------
other : array_like, int
Array of values to intersect with.
Returns
-------
out : SortedIndex
Values in common.
Examples
--------
>>> import allel
>>> idx1 = allel.SortedIndex([3, 6, 11, 20, 35])
>>> idx2 = allel.SortedIndex([4, 6, 20, 39])
>>> idx1.intersect(idx2)
<SortedIndex shape=(2,) dtype=int64>
[6, 20]
"""; 11, assignment; 12, call; 13, identifier:loc; 14, call; 15, attribute; 16, argument_list; 17, attribute; 18, argument_list; 19, identifier:self; 20, identifier:compress; 21, identifier:loc; 22, keyword_argument; 23, identifier:self; 24, identifier:locate_keys; 25, identifier:other; 26, keyword_argument; 27, identifier:axis; 28, integer:0; 29, identifier:strict; 30, False | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 7, 10; 8, 11; 9, 12; 11, 13; 11, 14; 12, 15; 12, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 17, 23; 17, 24; 18, 25; 18, 26; 22, 27; 22, 28; 26, 29; 26, 30 | def intersect(self, other):
"""Intersect with `other` sorted index.
Parameters
----------
other : array_like, int
Array of values to intersect with.
Returns
-------
out : SortedIndex
Values in common.
Examples
--------
>>> import allel
>>> idx1 = allel.SortedIndex([3, 6, 11, 20, 35])
>>> idx2 = allel.SortedIndex([4, 6, 20, 39])
>>> idx1.intersect(idx2)
<SortedIndex shape=(2,) dtype=int64>
[6, 20]
"""
loc = self.locate_keys(other, strict=False)
return self.compress(loc, axis=0) |
0, module; 1, function_definition; 2, function_name:locate_intersection_ranges; 3, parameters; 4, block; 5, identifier:self; 6, identifier:starts; 7, identifier:stops; 8, expression_statement; 9, comment:# check inputs; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, comment:# find indices of start and stop values in idx; 14, expression_statement; 15, expression_statement; 16, comment:# find intervals overlapping at least one value; 17, expression_statement; 18, comment:# find values within at least one interval; 19, expression_statement; 20, for_statement; 21, return_statement; 22, comment:"""Locate the intersection with a set of ranges.
Parameters
----------
starts : array_like, int
Range start values.
stops : array_like, int
Range stop values.
Returns
-------
loc : ndarray, bool
Boolean array with location of entries found.
loc_ranges : ndarray, bool
Boolean array with location of ranges containing one or more
entries.
Examples
--------
>>> import allel
>>> import numpy as np
>>> idx = allel.SortedIndex([3, 6, 11, 20, 35])
>>> ranges = np.array([[0, 2], [6, 17], [12, 15], [31, 35],
... [100, 120]])
>>> starts = ranges[:, 0]
>>> stops = ranges[:, 1]
>>> loc, loc_ranges = idx.locate_intersection_ranges(starts, stops)
>>> loc
array([False, True, True, False, True])
>>> loc_ranges
array([False, True, False, True, False])
>>> idx[loc]
<SortedIndex shape=(3,) dtype=int64>
[6, 11, 35]
>>> ranges[loc_ranges]
array([[ 6, 17],
[31, 35]])
"""; 23, assignment; 24, assignment; 25, call; 26, assignment; 27, assignment; 28, assignment; 29, assignment; 30, pattern_list; 31, call; 32, block; 33, expression_list; 34, identifier:starts; 35, call; 36, identifier:stops; 37, call; 38, identifier:check_dim0_aligned; 39, argument_list; 40, identifier:start_indices; 41, call; 42, identifier:stop_indices; 43, call; 44, identifier:loc_ranges; 45, comparison_operator:start_indices < stop_indices; 46, identifier:loc; 47, call; 48, identifier:i; 49, identifier:j; 50, identifier:zip; 51, argument_list; 52, expression_statement; 53, identifier:loc; 54, identifier:loc_ranges; 55, identifier:asarray_ndim; 56, argument_list; 57, identifier:asarray_ndim; 58, argument_list; 59, identifier:starts; 60, identifier:stops; 61, attribute; 62, argument_list; 63, attribute; 64, argument_list; 65, identifier:start_indices; 66, identifier:stop_indices; 67, attribute; 68, argument_list; 69, subscript; 70, subscript; 71, assignment; 72, identifier:starts; 73, integer:1; 74, identifier:stops; 75, integer:1; 76, identifier:np; 77, identifier:searchsorted; 78, identifier:self; 79, identifier:starts; 80, identifier:np; 81, identifier:searchsorted; 82, identifier:self; 83, identifier:stops; 84, keyword_argument; 85, identifier:np; 86, identifier:zeros; 87, attribute; 88, keyword_argument; 89, identifier:start_indices; 90, identifier:loc_ranges; 91, identifier:stop_indices; 92, identifier:loc_ranges; 93, subscript; 94, True; 95, identifier:side; 96, string; 97, identifier:self; 98, identifier:shape; 99, identifier:dtype; 100, attribute; 101, identifier:loc; 102, slice; 103, string_content:right; 104, identifier:np; 105, identifier:bool; 106, identifier:i; 107, identifier:j | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 8, 22; 10, 23; 11, 24; 12, 25; 14, 26; 15, 27; 17, 28; 19, 29; 20, 30; 20, 31; 20, 32; 21, 33; 23, 34; 23, 35; 24, 36; 24, 37; 25, 38; 25, 39; 26, 40; 26, 41; 27, 42; 27, 43; 28, 44; 28, 45; 29, 46; 29, 47; 30, 48; 30, 49; 31, 50; 31, 51; 32, 52; 33, 53; 33, 54; 35, 55; 35, 56; 37, 57; 37, 58; 39, 59; 39, 60; 41, 61; 41, 62; 43, 63; 43, 64; 45, 65; 45, 66; 47, 67; 47, 68; 51, 69; 51, 70; 52, 71; 56, 72; 56, 73; 58, 74; 58, 75; 61, 76; 61, 77; 62, 78; 62, 79; 63, 80; 63, 81; 64, 82; 64, 83; 64, 84; 67, 85; 67, 86; 68, 87; 68, 88; 69, 89; 69, 90; 70, 91; 70, 92; 71, 93; 71, 94; 84, 95; 84, 96; 87, 97; 87, 98; 88, 99; 88, 100; 93, 101; 93, 102; 96, 103; 100, 104; 100, 105; 102, 106; 102, 107 | def locate_intersection_ranges(self, starts, stops):
"""Locate the intersection with a set of ranges.
Parameters
----------
starts : array_like, int
Range start values.
stops : array_like, int
Range stop values.
Returns
-------
loc : ndarray, bool
Boolean array with location of entries found.
loc_ranges : ndarray, bool
Boolean array with location of ranges containing one or more
entries.
Examples
--------
>>> import allel
>>> import numpy as np
>>> idx = allel.SortedIndex([3, 6, 11, 20, 35])
>>> ranges = np.array([[0, 2], [6, 17], [12, 15], [31, 35],
... [100, 120]])
>>> starts = ranges[:, 0]
>>> stops = ranges[:, 1]
>>> loc, loc_ranges = idx.locate_intersection_ranges(starts, stops)
>>> loc
array([False, True, True, False, True])
>>> loc_ranges
array([False, True, False, True, False])
>>> idx[loc]
<SortedIndex shape=(3,) dtype=int64>
[6, 11, 35]
>>> ranges[loc_ranges]
array([[ 6, 17],
[31, 35]])
"""
# check inputs
starts = asarray_ndim(starts, 1)
stops = asarray_ndim(stops, 1)
check_dim0_aligned(starts, stops)
# find indices of start and stop values in idx
start_indices = np.searchsorted(self, starts)
stop_indices = np.searchsorted(self, stops, side='right')
# find intervals overlapping at least one value
loc_ranges = start_indices < stop_indices
# find values within at least one interval
loc = np.zeros(self.shape, dtype=np.bool)
for i, j in zip(start_indices[loc_ranges], stop_indices[loc_ranges]):
loc[i:j] = True
return loc, loc_ranges |
0, module; 1, function_definition; 2, function_name:locate_ranges; 3, parameters; 4, block; 5, identifier:self; 6, identifier:starts; 7, identifier:stops; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, return_statement; 13, identifier:strict; 14, True; 15, comment:"""Locate items within the given ranges.
Parameters
----------
starts : array_like, int
Range start values.
stops : array_like, int
Range stop values.
strict : bool, optional
If True, raise KeyError if any ranges contain no entries.
Returns
-------
loc : ndarray, bool
Boolean array with location of entries found.
Examples
--------
>>> import allel
>>> import numpy as np
>>> idx = allel.SortedIndex([3, 6, 11, 20, 35])
>>> ranges = np.array([[0, 2], [6, 17], [12, 15], [31, 35],
... [100, 120]])
>>> starts = ranges[:, 0]
>>> stops = ranges[:, 1]
>>> loc = idx.locate_ranges(starts, stops, strict=False)
>>> loc
array([False, True, True, False, True])
>>> idx[loc]
<SortedIndex shape=(3,) dtype=int64>
[6, 11, 35]
"""; 16, assignment; 17, boolean_operator; 18, block; 19, identifier:loc; 20, pattern_list; 21, call; 22, identifier:strict; 23, call; 24, raise_statement; 25, identifier:loc; 26, identifier:found; 27, attribute; 28, argument_list; 29, attribute; 30, argument_list; 31, call; 32, identifier:self; 33, identifier:locate_intersection_ranges; 34, identifier:starts; 35, identifier:stops; 36, identifier:np; 37, identifier:any; 38, unary_operator; 39, identifier:KeyError; 40, argument_list; 41, identifier:found; 42, subscript; 43, subscript; 44, identifier:starts; 45, unary_operator; 46, identifier:stops; 47, unary_operator; 48, identifier:found; 49, identifier:found | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 8, 13; 8, 14; 9, 15; 10, 16; 11, 17; 11, 18; 12, 19; 16, 20; 16, 21; 17, 22; 17, 23; 18, 24; 20, 25; 20, 26; 21, 27; 21, 28; 23, 29; 23, 30; 24, 31; 27, 32; 27, 33; 28, 34; 28, 35; 29, 36; 29, 37; 30, 38; 31, 39; 31, 40; 38, 41; 40, 42; 40, 43; 42, 44; 42, 45; 43, 46; 43, 47; 45, 48; 47, 49 | def locate_ranges(self, starts, stops, strict=True):
"""Locate items within the given ranges.
Parameters
----------
starts : array_like, int
Range start values.
stops : array_like, int
Range stop values.
strict : bool, optional
If True, raise KeyError if any ranges contain no entries.
Returns
-------
loc : ndarray, bool
Boolean array with location of entries found.
Examples
--------
>>> import allel
>>> import numpy as np
>>> idx = allel.SortedIndex([3, 6, 11, 20, 35])
>>> ranges = np.array([[0, 2], [6, 17], [12, 15], [31, 35],
... [100, 120]])
>>> starts = ranges[:, 0]
>>> stops = ranges[:, 1]
>>> loc = idx.locate_ranges(starts, stops, strict=False)
>>> loc
array([False, True, True, False, True])
>>> idx[loc]
<SortedIndex shape=(3,) dtype=int64>
[6, 11, 35]
"""
loc, found = self.locate_intersection_ranges(starts, stops)
if strict and np.any(~found):
raise KeyError(starts[~found], stops[~found])
return loc |
0, module; 1, function_definition; 2, function_name:intersect_ranges; 3, parameters; 4, block; 5, identifier:self; 6, identifier:starts; 7, identifier:stops; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, comment:"""Intersect with a set of ranges.
Parameters
----------
starts : array_like, int
Range start values.
stops : array_like, int
Range stop values.
Returns
-------
idx : SortedIndex
Examples
--------
>>> import allel
>>> import numpy as np
>>> idx = allel.SortedIndex([3, 6, 11, 20, 35])
>>> ranges = np.array([[0, 2], [6, 17], [12, 15], [31, 35],
... [100, 120]])
>>> starts = ranges[:, 0]
>>> stops = ranges[:, 1]
>>> idx.intersect_ranges(starts, stops)
<SortedIndex shape=(3,) dtype=int64>
[6, 11, 35]
"""; 12, assignment; 13, call; 14, identifier:loc; 15, call; 16, attribute; 17, argument_list; 18, attribute; 19, argument_list; 20, identifier:self; 21, identifier:compress; 22, identifier:loc; 23, keyword_argument; 24, identifier:self; 25, identifier:locate_ranges; 26, identifier:starts; 27, identifier:stops; 28, keyword_argument; 29, identifier:axis; 30, integer:0; 31, identifier:strict; 32, False | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 8, 11; 9, 12; 10, 13; 12, 14; 12, 15; 13, 16; 13, 17; 15, 18; 15, 19; 16, 20; 16, 21; 17, 22; 17, 23; 18, 24; 18, 25; 19, 26; 19, 27; 19, 28; 23, 29; 23, 30; 28, 31; 28, 32 | def intersect_ranges(self, starts, stops):
"""Intersect with a set of ranges.
Parameters
----------
starts : array_like, int
Range start values.
stops : array_like, int
Range stop values.
Returns
-------
idx : SortedIndex
Examples
--------
>>> import allel
>>> import numpy as np
>>> idx = allel.SortedIndex([3, 6, 11, 20, 35])
>>> ranges = np.array([[0, 2], [6, 17], [12, 15], [31, 35],
... [100, 120]])
>>> starts = ranges[:, 0]
>>> stops = ranges[:, 1]
>>> idx.intersect_ranges(starts, stops)
<SortedIndex shape=(3,) dtype=int64>
[6, 11, 35]
"""
loc = self.locate_ranges(starts, stops, strict=False)
return self.compress(loc, axis=0) |
0, module; 1, function_definition; 2, function_name:from_gff3; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, expression_statement; 13, expression_statement; 14, if_statement; 15, identifier:attributes; 16, None; 17, identifier:region; 18, None; 19, identifier:score_fill; 20, unary_operator; 21, identifier:phase_fill; 22, unary_operator; 23, identifier:attributes_fill; 24, string; 25, identifier:dtype; 26, None; 27, comment:"""Read a feature table from a GFF3 format file.
Parameters
----------
path : string
File path.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
dtype : numpy dtype, optional
Manually specify a dtype.
Returns
-------
ft : FeatureTable
"""; 28, assignment; 29, comparison_operator:a is None; 30, block; 31, else_clause; 32, integer:1; 33, integer:1; 34, string_content:.; 35, identifier:a; 36, call; 37, identifier:a; 38, None; 39, return_statement; 40, block; 41, identifier:gff3_to_recarray; 42, argument_list; 43, None; 44, return_statement; 45, identifier:path; 46, keyword_argument; 47, keyword_argument; 48, keyword_argument; 49, keyword_argument; 50, keyword_argument; 51, keyword_argument; 52, call; 53, identifier:attributes; 54, identifier:attributes; 55, identifier:region; 56, identifier:region; 57, identifier:score_fill; 58, identifier:score_fill; 59, identifier:phase_fill; 60, identifier:phase_fill; 61, identifier:attributes_fill; 62, identifier:attributes_fill; 63, identifier:dtype; 64, identifier:dtype; 65, identifier:FeatureTable; 66, argument_list; 67, identifier:a; 68, keyword_argument; 69, identifier:copy; 70, False | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 4, 12; 4, 13; 4, 14; 6, 15; 6, 16; 7, 17; 7, 18; 8, 19; 8, 20; 9, 21; 9, 22; 10, 23; 10, 24; 11, 25; 11, 26; 12, 27; 13, 28; 14, 29; 14, 30; 14, 31; 20, 32; 22, 33; 24, 34; 28, 35; 28, 36; 29, 37; 29, 38; 30, 39; 31, 40; 36, 41; 36, 42; 39, 43; 40, 44; 42, 45; 42, 46; 42, 47; 42, 48; 42, 49; 42, 50; 42, 51; 44, 52; 46, 53; 46, 54; 47, 55; 47, 56; 48, 57; 48, 58; 49, 59; 49, 60; 50, 61; 50, 62; 51, 63; 51, 64; 52, 65; 52, 66; 66, 67; 66, 68; 68, 69; 68, 70 | def from_gff3(path, attributes=None, region=None, score_fill=-1, phase_fill=-1,
attributes_fill='.', dtype=None):
"""Read a feature table from a GFF3 format file.
Parameters
----------
path : string
File path.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
dtype : numpy dtype, optional
Manually specify a dtype.
Returns
-------
ft : FeatureTable
"""
a = gff3_to_recarray(path, attributes=attributes, region=region,
score_fill=score_fill, phase_fill=phase_fill,
attributes_fill=attributes_fill, dtype=dtype)
if a is None:
return None
else:
return FeatureTable(a, copy=False) |
0, module; 1, function_definition; 2, function_name:iter_gff3; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, expression_statement; 13, comment:# prepare fill values for attributes; 14, if_statement; 15, comment:# open input stream; 16, if_statement; 17, try_statement; 18, identifier:attributes; 19, None; 20, identifier:region; 21, None; 22, identifier:score_fill; 23, unary_operator; 24, identifier:phase_fill; 25, unary_operator; 26, identifier:attributes_fill; 27, string; 28, identifier:tabix; 29, string; 30, comment:"""Iterate over records in a GFF3 file.
Parameters
----------
path : string
Path to input file.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
tabix : string
Tabix command.
Returns
-------
Iterator
"""; 31, comparison_operator:attributes is not None; 32, block; 33, comparison_operator:region is not None; 34, block; 35, elif_clause; 36, else_clause; 37, block; 38, finally_clause; 39, integer:1; 40, integer:1; 41, string_content:.; 42, string_content:tabix; 43, identifier:attributes; 44, None; 45, expression_statement; 46, if_statement; 47, identifier:region; 48, None; 49, expression_statement; 50, expression_statement; 51, boolean_operator; 52, block; 53, block; 54, for_statement; 55, block; 56, assignment; 57, call; 58, block; 59, else_clause; 60, assignment; 61, assignment; 62, call; 63, call; 64, expression_statement; 65, expression_statement; 66, identifier:line; 67, identifier:buffer; 68, block; 69, expression_statement; 70, identifier:attributes; 71, call; 72, identifier:isinstance; 73, argument_list; 74, if_statement; 75, block; 76, identifier:cmd; 77, list; 78, identifier:buffer; 79, attribute; 80, attribute; 81, argument_list; 82, attribute; 83, argument_list; 84, assignment; 85, assignment; 86, if_statement; 87, if_statement; 88, expression_statement; 89, if_statement; 90, call; 91, identifier:list; 92, argument_list; 93, identifier:attributes_fill; 94, tuple; 95, comparison_operator:len(attributes) != len(attributes_fill); 96, block; 97, expression_statement; 98, identifier:tabix; 99, identifier:path; 100, identifier:region; 101, call; 102, identifier:stdout; 103, identifier:path; 104, identifier:endswith; 105, string; 106, identifier:path; 107, identifier:endswith; 108, string; 109, identifier:buffer; 110, call; 111, identifier:buffer; 112, call; 113, comparison_operator:line[0] == b'>'; 114, comment:# assume begin embedded FASTA; 115, block; 116, comparison_operator:line[0] == b'#'; 117, comment:# skip comment lines; 118, block; 119, assignment; 120, comparison_operator:len(vals) == 9; 121, comment:# unpack for processing; 122, block; 123, attribute; 124, argument_list; 125, identifier:attributes; 126, identifier:list; 127, identifier:tuple; 128, call; 129, call; 130, raise_statement; 131, assignment; 132, attribute; 133, argument_list; 134, string_content:.gz; 135, string_content:.bgz; 136, attribute; 137, argument_list; 138, identifier:open; 139, argument_list; 140, subscript; 141, string; 142, return_statement; 143, subscript; 144, string; 145, continue_statement; 146, identifier:vals; 147, call; 148, call; 149, integer:9; 150, expression_statement; 151, comment:# convert numerics; 152, expression_statement; 153, expression_statement; 154, if_statement; 155, if_statement; 156, if_statement; 157, expression_statement; 158, if_statement; 159, expression_statement; 160, identifier:buffer; 161, identifier:close; 162, identifier:len; 163, argument_list; 164, identifier:len; 165, argument_list; 166, call; 167, identifier:attributes_fill; 168, binary_operator:[attributes_fill] * len(attributes); 169, identifier:subprocess; 170, identifier:Popen; 171, identifier:cmd; 172, keyword_argument; 173, identifier:gzip; 174, identifier:open; 175, identifier:path; 176, keyword_argument; 177, identifier:path; 178, keyword_argument; 179, identifier:line; 180, integer:0; 181, string_content:>; 182, identifier:line; 183, integer:0; 184, string_content:#; 185, attribute; 186, argument_list; 187, identifier:len; 188, argument_list; 189, assignment; 190, assignment; 191, assignment; 192, comparison_operator:fscore == b'.'; 193, block; 194, else_clause; 195, comparison_operator:fphase == b'.'; 196, block; 197, else_clause; 198, not_operator; 199, block; 200, assignment; 201, comparison_operator:attributes is not None; 202, block; 203, yield; 204, identifier:attributes; 205, identifier:attributes_fill; 206, identifier:ValueError; 207, argument_list; 208, list; 209, call; 210, identifier:stdout; 211, attribute; 212, identifier:mode; 213, string; 214, identifier:mode; 215, string; 216, identifier:line; 217, identifier:split; 218, string; 219, identifier:vals; 220, pattern_list; 221, identifier:vals; 222, identifier:fstart; 223, call; 224, identifier:fend; 225, call; 226, identifier:fscore; 227, string; 228, expression_statement; 229, block; 230, identifier:fphase; 231, string; 232, expression_statement; 233, block; 234, identifier:PY2; 235, expression_statement; 236, expression_statement; 237, expression_statement; 238, expression_statement; 239, expression_statement; 240, identifier:rec; 241, tuple; 242, identifier:attributes; 243, None; 244, expression_statement; 245, expression_statement; 246, expression_statement; 247, identifier:rec; 248, string; 249, identifier:attributes_fill; 250, identifier:len; 251, argument_list; 252, identifier:subprocess; 253, identifier:PIPE; 254, string_content:rb; 255, string_content:rb; 256, string_content; 257, identifier:fseqid; 258, identifier:fsource; 259, identifier:ftype; 260, identifier:fstart; 261, identifier:fend; 262, identifier:fscore; 263, identifier:fstrand; 264, identifier:fphase; 265, identifier:fattrs; 266, identifier:int; 267, argument_list; 268, identifier:int; 269, argument_list; 270, string_content:.; 271, assignment; 272, expression_statement; 273, string_content:.; 274, assignment; 275, expression_statement; 276, assignment; 277, assignment; 278, assignment; 279, assignment; 280, assignment; 281, identifier:fseqid; 282, identifier:fsource; 283, identifier:ftype; 284, identifier:fstart; 285, identifier:fend; 286, identifier:fscore; 287, identifier:fstrand; 288, identifier:fphase; 289, assignment; 290, assignment; 291, augmented_assignment; 292, string_content:number of fills does not match attributes; 293, identifier:attributes; 294, escape_sequence:\t; 295, identifier:fstart; 296, identifier:fend; 297, identifier:fscore; 298, identifier:score_fill; 299, assignment; 300, identifier:fphase; 301, identifier:phase_fill; 302, assignment; 303, identifier:fseqid; 304, call; 305, identifier:fsource; 306, call; 307, identifier:ftype; 308, call; 309, identifier:fstrand; 310, call; 311, identifier:fattrs; 312, call; 313, identifier:dattrs; 314, call; 315, identifier:vattrs; 316, call; 317, identifier:rec; 318, identifier:vattrs; 319, identifier:fscore; 320, call; 321, identifier:fphase; 322, call; 323, identifier:str; 324, argument_list; 325, identifier:str; 326, argument_list; 327, identifier:str; 328, argument_list; 329, identifier:str; 330, argument_list; 331, identifier:str; 332, argument_list; 333, identifier:gff3_parse_attributes; 334, argument_list; 335, identifier:tuple; 336, generator_expression; 337, identifier:float; 338, argument_list; 339, identifier:int; 340, argument_list; 341, identifier:fseqid; 342, string; 343, identifier:fsource; 344, string; 345, identifier:ftype; 346, string; 347, identifier:fstrand; 348, string; 349, identifier:fattrs; 350, string; 351, identifier:fattrs; 352, call; 353, for_in_clause; 354, identifier:fscore; 355, identifier:fphase; 356, string_content:ascii; 357, string_content:ascii; 358, string_content:ascii; 359, string_content:ascii; 360, string_content:ascii; 361, attribute; 362, argument_list; 363, pattern_list; 364, call; 365, identifier:dattrs; 366, identifier:get; 367, identifier:k; 368, identifier:f; 369, identifier:k; 370, identifier:f; 371, identifier:zip; 372, argument_list; 373, identifier:attributes; 374, identifier:attributes_fill | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 6, 19; 7, 20; 7, 21; 8, 22; 8, 23; 9, 24; 9, 25; 10, 26; 10, 27; 11, 28; 11, 29; 12, 30; 14, 31; 14, 32; 16, 33; 16, 34; 16, 35; 16, 36; 17, 37; 17, 38; 23, 39; 25, 40; 27, 41; 29, 42; 31, 43; 31, 44; 32, 45; 32, 46; 33, 47; 33, 48; 34, 49; 34, 50; 35, 51; 35, 52; 36, 53; 37, 54; 38, 55; 45, 56; 46, 57; 46, 58; 46, 59; 49, 60; 50, 61; 51, 62; 51, 63; 52, 64; 53, 65; 54, 66; 54, 67; 54, 68; 55, 69; 56, 70; 56, 71; 57, 72; 57, 73; 58, 74; 59, 75; 60, 76; 60, 77; 61, 78; 61, 79; 62, 80; 62, 81; 63, 82; 63, 83; 64, 84; 65, 85; 68, 86; 68, 87; 68, 88; 68, 89; 69, 90; 71, 91; 71, 92; 73, 93; 73, 94; 74, 95; 74, 96; 75, 97; 77, 98; 77, 99; 77, 100; 79, 101; 79, 102; 80, 103; 80, 104; 81, 105; 82, 106; 82, 107; 83, 108; 84, 109; 84, 110; 85, 111; 85, 112; 86, 113; 86, 114; 86, 115; 87, 116; 87, 117; 87, 118; 88, 119; 89, 120; 89, 121; 89, 122; 90, 123; 90, 124; 92, 125; 94, 126; 94, 127; 95, 128; 95, 129; 96, 130; 97, 131; 101, 132; 101, 133; 105, 134; 108, 135; 110, 136; 110, 137; 112, 138; 112, 139; 113, 140; 113, 141; 115, 142; 116, 143; 116, 144; 118, 145; 119, 146; 119, 147; 120, 148; 120, 149; 122, 150; 122, 151; 122, 152; 122, 153; 122, 154; 122, 155; 122, 156; 122, 157; 122, 158; 122, 159; 123, 160; 123, 161; 128, 162; 128, 163; 129, 164; 129, 165; 130, 166; 131, 167; 131, 168; 132, 169; 132, 170; 133, 171; 133, 172; 136, 173; 136, 174; 137, 175; 137, 176; 139, 177; 139, 178; 140, 179; 140, 180; 141, 181; 143, 182; 143, 183; 144, 184; 147, 185; 147, 186; 148, 187; 148, 188; 150, 189; 152, 190; 153, 191; 154, 192; 154, 193; 154, 194; 155, 195; 155, 196; 155, 197; 156, 198; 156, 199; 157, 200; 158, 201; 158, 202; 159, 203; 163, 204; 165, 205; 166, 206; 166, 207; 168, 208; 168, 209; 172, 210; 172, 211; 176, 212; 176, 213; 178, 214; 178, 215; 185, 216; 185, 217; 186, 218; 188, 219; 189, 220; 189, 221; 190, 222; 190, 223; 191, 224; 191, 225; 192, 226; 192, 227; 193, 228; 194, 229; 195, 230; 195, 231; 196, 232; 197, 233; 198, 234; 199, 235; 199, 236; 199, 237; 199, 238; 199, 239; 200, 240; 200, 241; 201, 242; 201, 243; 202, 244; 202, 245; 202, 246; 203, 247; 207, 248; 208, 249; 209, 250; 209, 251; 211, 252; 211, 253; 213, 254; 215, 255; 218, 256; 220, 257; 220, 258; 220, 259; 220, 260; 220, 261; 220, 262; 220, 263; 220, 264; 220, 265; 223, 266; 223, 267; 225, 268; 225, 269; 227, 270; 228, 271; 229, 272; 231, 273; 232, 274; 233, 275; 235, 276; 236, 277; 237, 278; 238, 279; 239, 280; 241, 281; 241, 282; 241, 283; 241, 284; 241, 285; 241, 286; 241, 287; 241, 288; 244, 289; 245, 290; 246, 291; 248, 292; 251, 293; 256, 294; 267, 295; 269, 296; 271, 297; 271, 298; 272, 299; 274, 300; 274, 301; 275, 302; 276, 303; 276, 304; 277, 305; 277, 306; 278, 307; 278, 308; 279, 309; 279, 310; 280, 311; 280, 312; 289, 313; 289, 314; 290, 315; 290, 316; 291, 317; 291, 318; 299, 319; 299, 320; 302, 321; 302, 322; 304, 323; 304, 324; 306, 325; 306, 326; 308, 327; 308, 328; 310, 329; 310, 330; 312, 331; 312, 332; 314, 333; 314, 334; 316, 335; 316, 336; 320, 337; 320, 338; 322, 339; 322, 340; 324, 341; 324, 342; 326, 343; 326, 344; 328, 345; 328, 346; 330, 347; 330, 348; 332, 349; 332, 350; 334, 351; 336, 352; 336, 353; 338, 354; 340, 355; 342, 356; 344, 357; 346, 358; 348, 359; 350, 360; 352, 361; 352, 362; 353, 363; 353, 364; 361, 365; 361, 366; 362, 367; 362, 368; 363, 369; 363, 370; 364, 371; 364, 372; 372, 373; 372, 374 | def iter_gff3(path, attributes=None, region=None, score_fill=-1,
phase_fill=-1, attributes_fill='.', tabix='tabix'):
"""Iterate over records in a GFF3 file.
Parameters
----------
path : string
Path to input file.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
tabix : string
Tabix command.
Returns
-------
Iterator
"""
# prepare fill values for attributes
if attributes is not None:
attributes = list(attributes)
if isinstance(attributes_fill, (list, tuple)):
if len(attributes) != len(attributes_fill):
raise ValueError('number of fills does not match attributes')
else:
attributes_fill = [attributes_fill] * len(attributes)
# open input stream
if region is not None:
cmd = [tabix, path, region]
buffer = subprocess.Popen(cmd, stdout=subprocess.PIPE).stdout
elif path.endswith('.gz') or path.endswith('.bgz'):
buffer = gzip.open(path, mode='rb')
else:
buffer = open(path, mode='rb')
try:
for line in buffer:
if line[0] == b'>':
# assume begin embedded FASTA
return
if line[0] == b'#':
# skip comment lines
continue
vals = line.split(b'\t')
if len(vals) == 9:
# unpack for processing
fseqid, fsource, ftype, fstart, fend, fscore, fstrand, fphase, fattrs = vals
# convert numerics
fstart = int(fstart)
fend = int(fend)
if fscore == b'.':
fscore = score_fill
else:
fscore = float(fscore)
if fphase == b'.':
fphase = phase_fill
else:
fphase = int(fphase)
if not PY2:
fseqid = str(fseqid, 'ascii')
fsource = str(fsource, 'ascii')
ftype = str(ftype, 'ascii')
fstrand = str(fstrand, 'ascii')
fattrs = str(fattrs, 'ascii')
rec = (fseqid, fsource, ftype, fstart, fend, fscore, fstrand, fphase)
if attributes is not None:
dattrs = gff3_parse_attributes(fattrs)
vattrs = tuple(
dattrs.get(k, f)
for k, f in zip(attributes, attributes_fill)
)
rec += vattrs
yield rec
finally:
buffer.close() |
0, module; 1, function_definition; 2, function_name:gff3_to_recarray; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, expression_statement; 14, comment:# read records; 15, expression_statement; 16, if_statement; 17, comment:# determine dtype; 18, if_statement; 19, expression_statement; 20, return_statement; 21, identifier:attributes; 22, None; 23, identifier:region; 24, None; 25, identifier:score_fill; 26, unary_operator; 27, identifier:phase_fill; 28, unary_operator; 29, identifier:attributes_fill; 30, string; 31, identifier:tabix; 32, string; 33, identifier:dtype; 34, None; 35, comment:"""Load data from a GFF3 into a NumPy recarray.
Parameters
----------
path : string
Path to input file.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
tabix : string, optional
Tabix command.
dtype : dtype, optional
Override dtype.
Returns
-------
np.recarray
"""; 36, assignment; 37, not_operator; 38, block; 39, comparison_operator:dtype is None; 40, block; 41, assignment; 42, identifier:a; 43, integer:1; 44, integer:1; 45, string_content:.; 46, string_content:tabix; 47, identifier:recs; 48, call; 49, identifier:recs; 50, return_statement; 51, identifier:dtype; 52, None; 53, expression_statement; 54, if_statement; 55, identifier:a; 56, call; 57, identifier:list; 58, argument_list; 59, None; 60, assignment; 61, identifier:attributes; 62, block; 63, attribute; 64, argument_list; 65, call; 66, identifier:dtype; 67, list; 68, for_statement; 69, attribute; 70, identifier:fromrecords; 71, identifier:recs; 72, keyword_argument; 73, identifier:iter_gff3; 74, argument_list; 75, tuple; 76, tuple; 77, tuple; 78, tuple; 79, tuple; 80, tuple; 81, tuple; 82, tuple; 83, identifier:n; 84, identifier:attributes; 85, block; 86, identifier:np; 87, identifier:rec; 88, identifier:dtype; 89, identifier:dtype; 90, identifier:path; 91, keyword_argument; 92, keyword_argument; 93, keyword_argument; 94, keyword_argument; 95, keyword_argument; 96, keyword_argument; 97, string; 98, identifier:object; 99, string; 100, identifier:object; 101, string; 102, identifier:object; 103, string; 104, identifier:int; 105, string; 106, identifier:int; 107, string; 108, identifier:float; 109, string; 110, identifier:object; 111, string; 112, identifier:int; 113, expression_statement; 114, identifier:attributes; 115, identifier:attributes; 116, identifier:region; 117, identifier:region; 118, identifier:score_fill; 119, identifier:score_fill; 120, identifier:phase_fill; 121, identifier:phase_fill; 122, identifier:attributes_fill; 123, identifier:attributes_fill; 124, identifier:tabix; 125, identifier:tabix; 126, string_content:seqid; 127, string_content:source; 128, string_content:type; 129, string_content:start; 130, string_content:end; 131, string_content:score; 132, string_content:strand; 133, string_content:phase; 134, call; 135, attribute; 136, argument_list; 137, identifier:dtype; 138, identifier:append; 139, tuple; 140, identifier:n; 141, identifier:object | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 6, 21; 6, 22; 7, 23; 7, 24; 8, 25; 8, 26; 9, 27; 9, 28; 10, 29; 10, 30; 11, 31; 11, 32; 12, 33; 12, 34; 13, 35; 15, 36; 16, 37; 16, 38; 18, 39; 18, 40; 19, 41; 20, 42; 26, 43; 28, 44; 30, 45; 32, 46; 36, 47; 36, 48; 37, 49; 38, 50; 39, 51; 39, 52; 40, 53; 40, 54; 41, 55; 41, 56; 48, 57; 48, 58; 50, 59; 53, 60; 54, 61; 54, 62; 56, 63; 56, 64; 58, 65; 60, 66; 60, 67; 62, 68; 63, 69; 63, 70; 64, 71; 64, 72; 65, 73; 65, 74; 67, 75; 67, 76; 67, 77; 67, 78; 67, 79; 67, 80; 67, 81; 67, 82; 68, 83; 68, 84; 68, 85; 69, 86; 69, 87; 72, 88; 72, 89; 74, 90; 74, 91; 74, 92; 74, 93; 74, 94; 74, 95; 74, 96; 75, 97; 75, 98; 76, 99; 76, 100; 77, 101; 77, 102; 78, 103; 78, 104; 79, 105; 79, 106; 80, 107; 80, 108; 81, 109; 81, 110; 82, 111; 82, 112; 85, 113; 91, 114; 91, 115; 92, 116; 92, 117; 93, 118; 93, 119; 94, 120; 94, 121; 95, 122; 95, 123; 96, 124; 96, 125; 97, 126; 99, 127; 101, 128; 103, 129; 105, 130; 107, 131; 109, 132; 111, 133; 113, 134; 134, 135; 134, 136; 135, 137; 135, 138; 136, 139; 139, 140; 139, 141 | def gff3_to_recarray(path, attributes=None, region=None, score_fill=-1,
phase_fill=-1, attributes_fill='.', tabix='tabix', dtype=None):
"""Load data from a GFF3 into a NumPy recarray.
Parameters
----------
path : string
Path to input file.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
tabix : string, optional
Tabix command.
dtype : dtype, optional
Override dtype.
Returns
-------
np.recarray
"""
# read records
recs = list(iter_gff3(path, attributes=attributes, region=region,
score_fill=score_fill, phase_fill=phase_fill,
attributes_fill=attributes_fill, tabix=tabix))
if not recs:
return None
# determine dtype
if dtype is None:
dtype = [('seqid', object),
('source', object),
('type', object),
('start', int),
('end', int),
('score', float),
('strand', object),
('phase', int)]
if attributes:
for n in attributes:
dtype.append((n, object))
a = np.rec.fromrecords(recs, dtype=dtype)
return a |
0, module; 1, function_definition; 2, function_name:gff3_to_dataframe; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, dictionary_splat_pattern; 13, expression_statement; 14, import_statement; 15, comment:# read records; 16, expression_statement; 17, comment:# load into pandas; 18, expression_statement; 19, if_statement; 20, expression_statement; 21, return_statement; 22, identifier:attributes; 23, None; 24, identifier:region; 25, None; 26, identifier:score_fill; 27, unary_operator; 28, identifier:phase_fill; 29, unary_operator; 30, identifier:attributes_fill; 31, string; 32, identifier:tabix; 33, string; 34, identifier:kwargs; 35, comment:"""Load data from a GFF3 into a pandas DataFrame.
Parameters
----------
path : string
Path to input file.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
tabix : string, optional
Tabix command.
Returns
-------
pandas.DataFrame
"""; 36, dotted_name; 37, assignment; 38, assignment; 39, identifier:attributes; 40, block; 41, assignment; 42, identifier:df; 43, integer:1; 44, integer:1; 45, string_content:.; 46, string_content:tabix; 47, identifier:pandas; 48, identifier:recs; 49, call; 50, identifier:columns; 51, list; 52, expression_statement; 53, identifier:df; 54, call; 55, identifier:list; 56, argument_list; 57, string; 58, string; 59, string; 60, string; 61, string; 62, string; 63, string; 64, string; 65, augmented_assignment; 66, attribute; 67, argument_list; 68, call; 69, string_content:seqid; 70, string_content:source; 71, string_content:type; 72, string_content:start; 73, string_content:end; 74, string_content:score; 75, string_content:strand; 76, string_content:phase; 77, identifier:columns; 78, call; 79, attribute; 80, identifier:from_records; 81, identifier:recs; 82, keyword_argument; 83, dictionary_splat; 84, identifier:iter_gff3; 85, argument_list; 86, identifier:list; 87, argument_list; 88, identifier:pandas; 89, identifier:DataFrame; 90, identifier:columns; 91, identifier:columns; 92, identifier:kwargs; 93, identifier:path; 94, keyword_argument; 95, keyword_argument; 96, keyword_argument; 97, keyword_argument; 98, keyword_argument; 99, keyword_argument; 100, identifier:attributes; 101, identifier:attributes; 102, identifier:attributes; 103, identifier:region; 104, identifier:region; 105, identifier:score_fill; 106, identifier:score_fill; 107, identifier:phase_fill; 108, identifier:phase_fill; 109, identifier:attributes_fill; 110, identifier:attributes_fill; 111, identifier:tabix; 112, identifier:tabix | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 6, 22; 6, 23; 7, 24; 7, 25; 8, 26; 8, 27; 9, 28; 9, 29; 10, 30; 10, 31; 11, 32; 11, 33; 12, 34; 13, 35; 14, 36; 16, 37; 18, 38; 19, 39; 19, 40; 20, 41; 21, 42; 27, 43; 29, 44; 31, 45; 33, 46; 36, 47; 37, 48; 37, 49; 38, 50; 38, 51; 40, 52; 41, 53; 41, 54; 49, 55; 49, 56; 51, 57; 51, 58; 51, 59; 51, 60; 51, 61; 51, 62; 51, 63; 51, 64; 52, 65; 54, 66; 54, 67; 56, 68; 57, 69; 58, 70; 59, 71; 60, 72; 61, 73; 62, 74; 63, 75; 64, 76; 65, 77; 65, 78; 66, 79; 66, 80; 67, 81; 67, 82; 67, 83; 68, 84; 68, 85; 78, 86; 78, 87; 79, 88; 79, 89; 82, 90; 82, 91; 83, 92; 85, 93; 85, 94; 85, 95; 85, 96; 85, 97; 85, 98; 85, 99; 87, 100; 94, 101; 94, 102; 95, 103; 95, 104; 96, 105; 96, 106; 97, 107; 97, 108; 98, 109; 98, 110; 99, 111; 99, 112 | def gff3_to_dataframe(path, attributes=None, region=None, score_fill=-1,
phase_fill=-1, attributes_fill='.', tabix='tabix', **kwargs):
"""Load data from a GFF3 into a pandas DataFrame.
Parameters
----------
path : string
Path to input file.
attributes : list of strings, optional
List of columns to extract from the "attributes" field.
region : string, optional
Genome region to extract. If given, file must be position
sorted, bgzipped and tabix indexed. Tabix must also be installed
and on the system path.
score_fill : int, optional
Value to use where score field has a missing value.
phase_fill : int, optional
Value to use where phase field has a missing value.
attributes_fill : object or list of objects, optional
Value(s) to use where attribute field(s) have a missing value.
tabix : string, optional
Tabix command.
Returns
-------
pandas.DataFrame
"""
import pandas
# read records
recs = list(iter_gff3(path, attributes=attributes, region=region,
score_fill=score_fill, phase_fill=phase_fill,
attributes_fill=attributes_fill, tabix=tabix))
# load into pandas
columns = ['seqid', 'source', 'type', 'start', 'end', 'score', 'strand', 'phase']
if attributes:
columns += list(attributes)
df = pandas.DataFrame.from_records(recs, columns=columns, **kwargs)
return df |
0, module; 1, function_definition; 2, function_name:voight_painting; 3, parameters; 4, block; 5, identifier:h; 6, expression_statement; 7, comment:# check inputs; 8, comment:# N.B., ensure int8 so we can use cython optimisation; 9, expression_statement; 10, if_statement; 11, if_statement; 12, comment:# sort by prefix; 13, expression_statement; 14, expression_statement; 15, comment:# paint; 16, expression_statement; 17, return_statement; 18, comment:"""Paint haplotypes, assigning a unique integer to each shared haplotype
prefix.
Parameters
----------
h : array_like, int, shape (n_variants, n_haplotypes)
Haplotype array.
Returns
-------
painting : ndarray, int, shape (n_variants, n_haplotypes)
Painting array.
indices : ndarray, int, shape (n_hapotypes,)
Haplotype indices after sorting by prefix.
"""; 19, assignment; 20, comparison_operator:h.max() > 1; 21, block; 22, comparison_operator:h.min() < 0; 23, block; 24, assignment; 25, assignment; 26, assignment; 27, expression_list; 28, identifier:h; 29, call; 30, call; 31, integer:1; 32, raise_statement; 33, call; 34, integer:0; 35, raise_statement; 36, identifier:indices; 37, call; 38, identifier:h; 39, call; 40, identifier:painting; 41, call; 42, identifier:painting; 43, identifier:indices; 44, identifier:HaplotypeArray; 45, argument_list; 46, attribute; 47, argument_list; 48, call; 49, attribute; 50, argument_list; 51, call; 52, attribute; 53, argument_list; 54, attribute; 55, argument_list; 56, identifier:paint_shared_prefixes; 57, argument_list; 58, call; 59, keyword_argument; 60, identifier:h; 61, identifier:max; 62, identifier:NotImplementedError; 63, argument_list; 64, identifier:h; 65, identifier:min; 66, identifier:NotImplementedError; 67, argument_list; 68, identifier:h; 69, identifier:prefix_argsort; 70, identifier:np; 71, identifier:take; 72, identifier:h; 73, identifier:indices; 74, keyword_argument; 75, call; 76, attribute; 77, argument_list; 78, identifier:copy; 79, False; 80, string; 81, string; 82, identifier:axis; 83, integer:1; 84, identifier:memoryview_safe; 85, argument_list; 86, identifier:np; 87, identifier:asarray; 88, identifier:h; 89, string_content:only biallelic variants are supported; 90, string_content:missing calls are not supported; 91, call; 92, attribute; 93, argument_list; 94, identifier:np; 95, identifier:asarray; 96, identifier:h | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 9, 19; 10, 20; 10, 21; 11, 22; 11, 23; 13, 24; 14, 25; 16, 26; 17, 27; 19, 28; 19, 29; 20, 30; 20, 31; 21, 32; 22, 33; 22, 34; 23, 35; 24, 36; 24, 37; 25, 38; 25, 39; 26, 40; 26, 41; 27, 42; 27, 43; 29, 44; 29, 45; 30, 46; 30, 47; 32, 48; 33, 49; 33, 50; 35, 51; 37, 52; 37, 53; 39, 54; 39, 55; 41, 56; 41, 57; 45, 58; 45, 59; 46, 60; 46, 61; 48, 62; 48, 63; 49, 64; 49, 65; 51, 66; 51, 67; 52, 68; 52, 69; 54, 70; 54, 71; 55, 72; 55, 73; 55, 74; 57, 75; 58, 76; 58, 77; 59, 78; 59, 79; 63, 80; 67, 81; 74, 82; 74, 83; 75, 84; 75, 85; 76, 86; 76, 87; 77, 88; 80, 89; 81, 90; 85, 91; 91, 92; 91, 93; 92, 94; 92, 95; 93, 96 | def voight_painting(h):
"""Paint haplotypes, assigning a unique integer to each shared haplotype
prefix.
Parameters
----------
h : array_like, int, shape (n_variants, n_haplotypes)
Haplotype array.
Returns
-------
painting : ndarray, int, shape (n_variants, n_haplotypes)
Painting array.
indices : ndarray, int, shape (n_hapotypes,)
Haplotype indices after sorting by prefix.
"""
# check inputs
# N.B., ensure int8 so we can use cython optimisation
h = HaplotypeArray(np.asarray(h), copy=False)
if h.max() > 1:
raise NotImplementedError('only biallelic variants are supported')
if h.min() < 0:
raise NotImplementedError('missing calls are not supported')
# sort by prefix
indices = h.prefix_argsort()
h = np.take(h, indices, axis=1)
# paint
painting = paint_shared_prefixes(memoryview_safe(np.asarray(h)))
return painting, indices |
0, module; 1, function_definition; 2, function_name:get_model_perms; 3, parameters; 4, block; 5, identifier:model; 6, expression_statement; 7, import_from_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, return_statement; 13, comment:"""
Get permission-string list of a specified django model.
Parameters
----------
model : model class
A model class to specify the particular django model.
Returns
-------
set
A set of perms of the specified django model.
Examples
--------
>>> sorted(get_model_perms(Permission)) == [
... 'auth.add_permission',
... 'auth.change_permission',
... 'auth.delete_permission'
... ]
True
"""; 14, dotted_name; 15, dotted_name; 16, assignment; 17, assignment; 18, assignment; 19, assignment; 20, call; 21, identifier:django; 22, identifier:contrib; 23, identifier:auth; 24, identifier:models; 25, identifier:Permission; 26, identifier:app_label; 27, attribute; 28, identifier:model_name; 29, call; 30, identifier:qs; 31, call; 32, identifier:perms; 33, generator_expression; 34, identifier:set; 35, argument_list; 36, attribute; 37, identifier:app_label; 38, attribute; 39, argument_list; 40, attribute; 41, argument_list; 42, binary_operator:'%s.%s' % (app_label, p.codename); 43, for_in_clause; 44, identifier:perms; 45, identifier:model; 46, identifier:_meta; 47, attribute; 48, identifier:lower; 49, attribute; 50, identifier:filter; 51, keyword_argument; 52, keyword_argument; 53, string; 54, tuple; 55, identifier:p; 56, call; 57, attribute; 58, identifier:object_name; 59, identifier:Permission; 60, identifier:objects; 61, identifier:content_type__app_label; 62, identifier:app_label; 63, identifier:content_type__model; 64, identifier:model_name; 65, string_content:%s.%s; 66, identifier:app_label; 67, attribute; 68, attribute; 69, argument_list; 70, identifier:model; 71, identifier:_meta; 72, identifier:p; 73, identifier:codename; 74, identifier:qs; 75, identifier:iterator | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 7, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 12, 20; 14, 21; 14, 22; 14, 23; 14, 24; 15, 25; 16, 26; 16, 27; 17, 28; 17, 29; 18, 30; 18, 31; 19, 32; 19, 33; 20, 34; 20, 35; 27, 36; 27, 37; 29, 38; 29, 39; 31, 40; 31, 41; 33, 42; 33, 43; 35, 44; 36, 45; 36, 46; 38, 47; 38, 48; 40, 49; 40, 50; 41, 51; 41, 52; 42, 53; 42, 54; 43, 55; 43, 56; 47, 57; 47, 58; 49, 59; 49, 60; 51, 61; 51, 62; 52, 63; 52, 64; 53, 65; 54, 66; 54, 67; 56, 68; 56, 69; 57, 70; 57, 71; 67, 72; 67, 73; 68, 74; 68, 75 | def get_model_perms(model):
"""
Get permission-string list of a specified django model.
Parameters
----------
model : model class
A model class to specify the particular django model.
Returns
-------
set
A set of perms of the specified django model.
Examples
--------
>>> sorted(get_model_perms(Permission)) == [
... 'auth.add_permission',
... 'auth.change_permission',
... 'auth.delete_permission'
... ]
True
"""
from django.contrib.auth.models import Permission
app_label = model._meta.app_label
model_name = model._meta.object_name.lower()
qs = Permission.objects.filter(content_type__app_label=app_label,
content_type__model=model_name)
perms = ('%s.%s' % (app_label, p.codename) for p in qs.iterator())
return set(perms) |
0, module; 1, function_definition; 2, function_name:sort_trigger_set; 3, parameters; 4, block; 5, identifier:triggers; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, comment:# KEEP IN MIND: the `triggers` array is composed of array elements of the form; 11, comment:# ["trigger text", pointer to trigger data]; 12, comment:# So this code will use e.g. `trig[0]` when referring to the trigger text.; 13, comment:# Create a list of trigger objects map.; 14, expression_statement; 15, for_statement; 16, comment:# Priority order of sorting criteria:; 17, comment:# weight, inherit, is_empty, star, pound, under, option, wordcount, len, alphabet; 18, expression_statement; 19, return_statement; 20, identifier:exclude_previous; 21, True; 22, identifier:say; 23, None; 24, comment:"""Sort a group of triggers in optimal sorting order.
The optimal sorting order is, briefly:
* Atomic triggers (containing nothing but plain words and alternation
groups) are on top, with triggers containing the most words coming
first. Triggers with equal word counts are sorted by length, and then
alphabetically if they have the same length.
* Triggers containing optionals are sorted next, by word count like
atomic triggers.
* Triggers containing wildcards are next, with ``_`` (alphabetic)
wildcards on top, then ``#`` (numeric) and finally ``*``.
* At the bottom of the sorted list are triggers consisting of only a
single wildcard, in the order: ``_``, ``#``, ``*``.
Triggers that have ``{weight}`` tags are grouped together by weight
value and sorted amongst themselves. Higher weighted groups are then
ordered before lower weighted groups regardless of the normal sorting
algorithm.
Triggers that come from topics which inherit other topics are also
sorted with higher priority than triggers from the inherited topics.
Arguments:
triggers ([]str): Array of triggers to sort.
exclude_previous (bool): Create a sort buffer for 'previous' triggers.
say (function): A reference to ``RiveScript._say()`` or provide your
own function.
"""; 25, comparison_operator:say is None; 26, block; 27, assignment; 28, pattern_list; 29, call; 30, block; 31, assignment; 32, list_comprehension; 33, identifier:say; 34, None; 35, expression_statement; 36, identifier:trigger_object_list; 37, list; 38, identifier:index; 39, identifier:trig; 40, identifier:enumerate; 41, argument_list; 42, if_statement; 43, expression_statement; 44, comment:# Extract only the text of the trigger, with possible tag of inherit; 45, comment:# See if it has a weight tag; 46, expression_statement; 47, if_statement; 48, comment:# See if it has an inherits tag.; 49, expression_statement; 50, if_statement; 51, expression_statement; 52, identifier:sorted_list; 53, call; 54, subscript; 55, for_in_clause; 56, assignment; 57, identifier:triggers; 58, boolean_operator; 59, block; 60, assignment; 61, assignment; 62, identifier:match; 63, comment:# Value of math is not None if there is a match.; 64, block; 65, assignment; 66, identifier:match; 67, block; 68, else_clause; 69, call; 70, identifier:sorted; 71, argument_list; 72, identifier:triggers; 73, attribute; 74, identifier:item; 75, identifier:sorted_list; 76, identifier:say; 77, lambda; 78, identifier:exclude_previous; 79, subscript; 80, continue_statement; 81, identifier:pattern; 82, subscript; 83, pattern_list; 84, expression_list; 85, expression_statement; 86, comment:# Get the weight from the tag ``{weight}``; 87, identifier:match; 88, call; 89, expression_statement; 90, comment:# Get inherit value from the tag ``{inherit}``; 91, expression_statement; 92, expression_statement; 93, comment:# Remove the inherit tag if any; 94, block; 95, attribute; 96, argument_list; 97, identifier:trigger_object_list; 98, keyword_argument; 99, identifier:item; 100, identifier:index; 101, lambda_parameters; 102, identifier:x; 103, subscript; 104, string:"previous"; 105, identifier:trig; 106, integer:0; 107, identifier:match; 108, identifier:weight; 109, call; 110, integer:0; 111, assignment; 112, attribute; 113, argument_list; 114, assignment; 115, call; 116, assignment; 117, expression_statement; 118, comment:# If not found any inherit, set it to the maximum value, to place it last in the sort; 119, identifier:trigger_object_list; 120, identifier:append; 121, call; 122, identifier:key; 123, call; 124, identifier:x; 125, identifier:trig; 126, integer:1; 127, attribute; 128, argument_list; 129, identifier:weight; 130, call; 131, identifier:re; 132, identifier:search; 133, attribute; 134, identifier:pattern; 135, identifier:inherit; 136, call; 137, identifier:say; 138, argument_list; 139, subscript; 140, assignment; 141, assignment; 142, identifier:TriggerObj; 143, argument_list; 144, identifier:attrgetter; 145, argument_list; 146, identifier:re; 147, identifier:search; 148, attribute; 149, subscript; 150, identifier:int; 151, argument_list; 152, identifier:RE; 153, identifier:inherit; 154, identifier:int; 155, argument_list; 156, binary_operator:"\t\t\tTrigger belongs to a topic which inherits other topics: level=" + str(inherit); 157, subscript; 158, integer:0; 159, identifier:pattern; 160, call; 161, identifier:inherit; 162, attribute; 163, identifier:pattern; 164, identifier:index; 165, identifier:weight; 166, identifier:inherit; 167, string; 168, string; 169, string; 170, string; 171, string; 172, string; 173, string; 174, string; 175, string; 176, string; 177, identifier:RE; 178, identifier:weight; 179, identifier:trig; 180, integer:0; 181, call; 182, call; 183, string:"\t\t\tTrigger belongs to a topic which inherits other topics: level="; 184, call; 185, identifier:triggers; 186, identifier:index; 187, attribute; 188, argument_list; 189, identifier:sys; 190, identifier:maxsize; 191, string_content:weight; 192, string_content:inherit; 193, string_content:is_empty; 194, string_content:star; 195, string_content:pound; 196, string_content:under; 197, string_content:option; 198, string_content:wordcount; 199, string_content:len; 200, string_content:alphabet; 201, attribute; 202, argument_list; 203, attribute; 204, argument_list; 205, identifier:str; 206, argument_list; 207, identifier:re; 208, identifier:sub; 209, attribute; 210, string:""; 211, identifier:pattern; 212, identifier:match; 213, identifier:group; 214, integer:1; 215, identifier:match; 216, identifier:group; 217, integer:1; 218, identifier:inherit; 219, identifier:RE; 220, identifier:inherit | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 6, 20; 6, 21; 7, 22; 7, 23; 8, 24; 9, 25; 9, 26; 14, 27; 15, 28; 15, 29; 15, 30; 18, 31; 19, 32; 25, 33; 25, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 30, 42; 30, 43; 30, 44; 30, 45; 30, 46; 30, 47; 30, 48; 30, 49; 30, 50; 30, 51; 31, 52; 31, 53; 32, 54; 32, 55; 35, 56; 41, 57; 42, 58; 42, 59; 43, 60; 46, 61; 47, 62; 47, 63; 47, 64; 49, 65; 50, 66; 50, 67; 50, 68; 51, 69; 53, 70; 53, 71; 54, 72; 54, 73; 55, 74; 55, 75; 56, 76; 56, 77; 58, 78; 58, 79; 59, 80; 60, 81; 60, 82; 61, 83; 61, 84; 64, 85; 64, 86; 65, 87; 65, 88; 67, 89; 67, 90; 67, 91; 67, 92; 67, 93; 68, 94; 69, 95; 69, 96; 71, 97; 71, 98; 73, 99; 73, 100; 77, 101; 77, 102; 79, 103; 79, 104; 82, 105; 82, 106; 83, 107; 83, 108; 84, 109; 84, 110; 85, 111; 88, 112; 88, 113; 89, 114; 91, 115; 92, 116; 94, 117; 94, 118; 95, 119; 95, 120; 96, 121; 98, 122; 98, 123; 101, 124; 103, 125; 103, 126; 109, 127; 109, 128; 111, 129; 111, 130; 112, 131; 112, 132; 113, 133; 113, 134; 114, 135; 114, 136; 115, 137; 115, 138; 116, 139; 116, 140; 117, 141; 121, 142; 121, 143; 123, 144; 123, 145; 127, 146; 127, 147; 128, 148; 128, 149; 130, 150; 130, 151; 133, 152; 133, 153; 136, 154; 136, 155; 138, 156; 139, 157; 139, 158; 140, 159; 140, 160; 141, 161; 141, 162; 143, 163; 143, 164; 143, 165; 143, 166; 145, 167; 145, 168; 145, 169; 145, 170; 145, 171; 145, 172; 145, 173; 145, 174; 145, 175; 145, 176; 148, 177; 148, 178; 149, 179; 149, 180; 151, 181; 155, 182; 156, 183; 156, 184; 157, 185; 157, 186; 160, 187; 160, 188; 162, 189; 162, 190; 167, 191; 168, 192; 169, 193; 170, 194; 171, 195; 172, 196; 173, 197; 174, 198; 175, 199; 176, 200; 181, 201; 181, 202; 182, 203; 182, 204; 184, 205; 184, 206; 187, 207; 187, 208; 188, 209; 188, 210; 188, 211; 201, 212; 201, 213; 202, 214; 203, 215; 203, 216; 204, 217; 206, 218; 209, 219; 209, 220 | def sort_trigger_set(triggers, exclude_previous=True, say=None):
"""Sort a group of triggers in optimal sorting order.
The optimal sorting order is, briefly:
* Atomic triggers (containing nothing but plain words and alternation
groups) are on top, with triggers containing the most words coming
first. Triggers with equal word counts are sorted by length, and then
alphabetically if they have the same length.
* Triggers containing optionals are sorted next, by word count like
atomic triggers.
* Triggers containing wildcards are next, with ``_`` (alphabetic)
wildcards on top, then ``#`` (numeric) and finally ``*``.
* At the bottom of the sorted list are triggers consisting of only a
single wildcard, in the order: ``_``, ``#``, ``*``.
Triggers that have ``{weight}`` tags are grouped together by weight
value and sorted amongst themselves. Higher weighted groups are then
ordered before lower weighted groups regardless of the normal sorting
algorithm.
Triggers that come from topics which inherit other topics are also
sorted with higher priority than triggers from the inherited topics.
Arguments:
triggers ([]str): Array of triggers to sort.
exclude_previous (bool): Create a sort buffer for 'previous' triggers.
say (function): A reference to ``RiveScript._say()`` or provide your
own function.
"""
if say is None:
say = lambda x: x
# KEEP IN MIND: the `triggers` array is composed of array elements of the form
# ["trigger text", pointer to trigger data]
# So this code will use e.g. `trig[0]` when referring to the trigger text.
# Create a list of trigger objects map.
trigger_object_list = []
for index, trig in enumerate(triggers):
if exclude_previous and trig[1]["previous"]:
continue
pattern = trig[0] # Extract only the text of the trigger, with possible tag of inherit
# See if it has a weight tag
match, weight = re.search(RE.weight, trig[0]), 0
if match: # Value of math is not None if there is a match.
weight = int(match.group(1)) # Get the weight from the tag ``{weight}``
# See if it has an inherits tag.
match = re.search(RE.inherit, pattern)
if match:
inherit = int(match.group(1)) # Get inherit value from the tag ``{inherit}``
say("\t\t\tTrigger belongs to a topic which inherits other topics: level=" + str(inherit))
triggers[index][0] = pattern = re.sub(RE.inherit, "", pattern) # Remove the inherit tag if any
else:
inherit = sys.maxsize # If not found any inherit, set it to the maximum value, to place it last in the sort
trigger_object_list.append(TriggerObj(pattern, index, weight, inherit))
# Priority order of sorting criteria:
# weight, inherit, is_empty, star, pound, under, option, wordcount, len, alphabet
sorted_list = sorted(trigger_object_list,
key=attrgetter('weight', 'inherit', 'is_empty', 'star', 'pound',
'under', 'option', 'wordcount', 'len', 'alphabet'))
return [triggers[item.index] for item in sorted_list] |
0, module; 1, function_definition; 2, function_name:sort_list; 3, parameters; 4, block; 5, identifier:items; 6, expression_statement; 7, comment:# Track by number of words.; 8, expression_statement; 9, function_definition; 10, comment:# Loop through each item.; 11, for_statement; 12, comment:# Sort them.; 13, expression_statement; 14, for_statement; 15, return_statement; 16, comment:"""Sort a simple list by number of words and length."""; 17, assignment; 18, function_name:by_length; 19, parameters; 20, block; 21, identifier:item; 22, identifier:items; 23, comment:# Count the words.; 24, block; 25, assignment; 26, identifier:count; 27, call; 28, block; 29, identifier:output; 30, identifier:track; 31, dictionary; 32, identifier:word1; 33, identifier:word2; 34, return_statement; 35, expression_statement; 36, if_statement; 37, expression_statement; 38, identifier:output; 39, list; 40, identifier:sorted; 41, argument_list; 42, expression_statement; 43, expression_statement; 44, binary_operator:len(word2) - len(word1); 45, assignment; 46, comparison_operator:cword not in track; 47, block; 48, call; 49, call; 50, keyword_argument; 51, assignment; 52, call; 53, call; 54, call; 55, identifier:cword; 56, call; 57, identifier:cword; 58, identifier:track; 59, expression_statement; 60, attribute; 61, argument_list; 62, attribute; 63, argument_list; 64, identifier:reverse; 65, True; 66, identifier:sort; 67, call; 68, attribute; 69, argument_list; 70, identifier:len; 71, argument_list; 72, identifier:len; 73, argument_list; 74, attribute; 75, argument_list; 76, assignment; 77, subscript; 78, identifier:append; 79, identifier:item; 80, identifier:track; 81, identifier:keys; 82, identifier:sorted; 83, argument_list; 84, identifier:output; 85, identifier:extend; 86, identifier:sort; 87, identifier:word2; 88, identifier:word1; 89, identifier:utils; 90, identifier:word_count; 91, identifier:item; 92, keyword_argument; 93, subscript; 94, list; 95, identifier:track; 96, identifier:cword; 97, subscript; 98, keyword_argument; 99, keyword_argument; 100, identifier:all; 101, True; 102, identifier:track; 103, identifier:cword; 104, identifier:track; 105, identifier:count; 106, identifier:key; 107, identifier:len; 108, identifier:reverse; 109, True | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 6, 16; 8, 17; 9, 18; 9, 19; 9, 20; 11, 21; 11, 22; 11, 23; 11, 24; 13, 25; 14, 26; 14, 27; 14, 28; 15, 29; 17, 30; 17, 31; 19, 32; 19, 33; 20, 34; 24, 35; 24, 36; 24, 37; 25, 38; 25, 39; 27, 40; 27, 41; 28, 42; 28, 43; 34, 44; 35, 45; 36, 46; 36, 47; 37, 48; 41, 49; 41, 50; 42, 51; 43, 52; 44, 53; 44, 54; 45, 55; 45, 56; 46, 57; 46, 58; 47, 59; 48, 60; 48, 61; 49, 62; 49, 63; 50, 64; 50, 65; 51, 66; 51, 67; 52, 68; 52, 69; 53, 70; 53, 71; 54, 72; 54, 73; 56, 74; 56, 75; 59, 76; 60, 77; 60, 78; 61, 79; 62, 80; 62, 81; 67, 82; 67, 83; 68, 84; 68, 85; 69, 86; 71, 87; 73, 88; 74, 89; 74, 90; 75, 91; 75, 92; 76, 93; 76, 94; 77, 95; 77, 96; 83, 97; 83, 98; 83, 99; 92, 100; 92, 101; 93, 102; 93, 103; 97, 104; 97, 105; 98, 106; 98, 107; 99, 108; 99, 109 | def sort_list(items):
"""Sort a simple list by number of words and length."""
# Track by number of words.
track = {}
def by_length(word1, word2):
return len(word2) - len(word1)
# Loop through each item.
for item in items:
# Count the words.
cword = utils.word_count(item, all=True)
if cword not in track:
track[cword] = []
track[cword].append(item)
# Sort them.
output = []
for count in sorted(track.keys(), reverse=True):
sort = sorted(track[count], key=len, reverse=True)
output.extend(sort)
return output |
0, module; 1, function_definition; 2, function_name:sort_replies; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, comment:# (Re)initialize the sort cache.; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, comment:# Loop through all the topics.; 13, for_statement; 14, comment:# And sort the substitution lists.; 15, if_statement; 16, expression_statement; 17, expression_statement; 18, identifier:thats; 19, False; 20, comment:"""Sort the loaded triggers in memory.
After you have finished loading your RiveScript code, call this method
to populate the various internal sort buffers. This is absolutely
necessary for reply matching to work efficiently!
"""; 21, assignment; 22, assignment; 23, call; 24, identifier:topic; 25, call; 26, block; 27, not_operator; 28, block; 29, assignment; 30, assignment; 31, subscript; 32, dictionary; 33, subscript; 34, dictionary; 35, attribute; 36, argument_list; 37, attribute; 38, argument_list; 39, expression_statement; 40, comment:# Collect a list of all the triggers we're going to worry about.; 41, comment:# If this topic inherits another topic, we need to recursively add; 42, comment:# those to the list as well.; 43, expression_statement; 44, comment:# Sort them.; 45, expression_statement; 46, comment:# Get all of the %Previous triggers for this topic.; 47, expression_statement; 48, comment:# And sort them, too.; 49, expression_statement; 50, comparison_operator:"lists" in self._sorted; 51, expression_statement; 52, subscript; 53, call; 54, subscript; 55, call; 56, attribute; 57, string:"topics"; 58, attribute; 59, string:"thats"; 60, identifier:self; 61, identifier:_say; 62, string:"Sorting triggers..."; 63, attribute; 64, identifier:keys; 65, call; 66, assignment; 67, assignment; 68, assignment; 69, assignment; 70, string:"lists"; 71, attribute; 72, assignment; 73, subscript; 74, string:"sub"; 75, attribute; 76, argument_list; 77, subscript; 78, string:"person"; 79, attribute; 80, argument_list; 81, identifier:self; 82, identifier:_sorted; 83, identifier:self; 84, identifier:_sorted; 85, identifier:self; 86, identifier:_topics; 87, attribute; 88, argument_list; 89, identifier:alltrig; 90, call; 91, subscript; 92, call; 93, identifier:that_triggers; 94, call; 95, subscript; 96, call; 97, identifier:self; 98, identifier:_sorted; 99, subscript; 100, dictionary; 101, attribute; 102, string:"lists"; 103, identifier:sorting; 104, identifier:sort_list; 105, call; 106, attribute; 107, string:"lists"; 108, identifier:sorting; 109, identifier:sort_list; 110, call; 111, identifier:self; 112, identifier:_say; 113, binary_operator:"Analyzing topic " + topic; 114, attribute; 115, argument_list; 116, subscript; 117, identifier:topic; 118, attribute; 119, argument_list; 120, attribute; 121, argument_list; 122, subscript; 123, identifier:topic; 124, attribute; 125, argument_list; 126, attribute; 127, string:"lists"; 128, identifier:self; 129, identifier:_sorted; 130, attribute; 131, argument_list; 132, identifier:self; 133, identifier:_sorted; 134, attribute; 135, argument_list; 136, string:"Analyzing topic "; 137, identifier:topic; 138, identifier:inherit_utils; 139, identifier:get_topic_triggers; 140, identifier:self; 141, identifier:topic; 142, False; 143, attribute; 144, string:"topics"; 145, identifier:sorting; 146, identifier:sort_trigger_set; 147, identifier:alltrig; 148, True; 149, attribute; 150, identifier:inherit_utils; 151, identifier:get_topic_triggers; 152, identifier:self; 153, identifier:topic; 154, True; 155, attribute; 156, string:"thats"; 157, identifier:sorting; 158, identifier:sort_trigger_set; 159, identifier:that_triggers; 160, False; 161, attribute; 162, identifier:self; 163, identifier:_sorted; 164, attribute; 165, identifier:keys; 166, attribute; 167, identifier:keys; 168, identifier:self; 169, identifier:_sorted; 170, identifier:self; 171, identifier:_say; 172, identifier:self; 173, identifier:_sorted; 174, identifier:self; 175, identifier:_say; 176, identifier:self; 177, identifier:_sub; 178, identifier:self; 179, identifier:_person | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 6, 19; 7, 20; 9, 21; 10, 22; 11, 23; 13, 24; 13, 25; 13, 26; 15, 27; 15, 28; 16, 29; 17, 30; 21, 31; 21, 32; 22, 33; 22, 34; 23, 35; 23, 36; 25, 37; 25, 38; 26, 39; 26, 40; 26, 41; 26, 42; 26, 43; 26, 44; 26, 45; 26, 46; 26, 47; 26, 48; 26, 49; 27, 50; 28, 51; 29, 52; 29, 53; 30, 54; 30, 55; 31, 56; 31, 57; 33, 58; 33, 59; 35, 60; 35, 61; 36, 62; 37, 63; 37, 64; 39, 65; 43, 66; 45, 67; 47, 68; 49, 69; 50, 70; 50, 71; 51, 72; 52, 73; 52, 74; 53, 75; 53, 76; 54, 77; 54, 78; 55, 79; 55, 80; 56, 81; 56, 82; 58, 83; 58, 84; 63, 85; 63, 86; 65, 87; 65, 88; 66, 89; 66, 90; 67, 91; 67, 92; 68, 93; 68, 94; 69, 95; 69, 96; 71, 97; 71, 98; 72, 99; 72, 100; 73, 101; 73, 102; 75, 103; 75, 104; 76, 105; 77, 106; 77, 107; 79, 108; 79, 109; 80, 110; 87, 111; 87, 112; 88, 113; 90, 114; 90, 115; 91, 116; 91, 117; 92, 118; 92, 119; 94, 120; 94, 121; 95, 122; 95, 123; 96, 124; 96, 125; 99, 126; 99, 127; 101, 128; 101, 129; 105, 130; 105, 131; 106, 132; 106, 133; 110, 134; 110, 135; 113, 136; 113, 137; 114, 138; 114, 139; 115, 140; 115, 141; 115, 142; 116, 143; 116, 144; 118, 145; 118, 146; 119, 147; 119, 148; 119, 149; 120, 150; 120, 151; 121, 152; 121, 153; 121, 154; 122, 155; 122, 156; 124, 157; 124, 158; 125, 159; 125, 160; 125, 161; 126, 162; 126, 163; 130, 164; 130, 165; 134, 166; 134, 167; 143, 168; 143, 169; 149, 170; 149, 171; 155, 172; 155, 173; 161, 174; 161, 175; 164, 176; 164, 177; 166, 178; 166, 179 | def sort_replies(self, thats=False):
"""Sort the loaded triggers in memory.
After you have finished loading your RiveScript code, call this method
to populate the various internal sort buffers. This is absolutely
necessary for reply matching to work efficiently!
"""
# (Re)initialize the sort cache.
self._sorted["topics"] = {}
self._sorted["thats"] = {}
self._say("Sorting triggers...")
# Loop through all the topics.
for topic in self._topics.keys():
self._say("Analyzing topic " + topic)
# Collect a list of all the triggers we're going to worry about.
# If this topic inherits another topic, we need to recursively add
# those to the list as well.
alltrig = inherit_utils.get_topic_triggers(self, topic, False)
# Sort them.
self._sorted["topics"][topic] = sorting.sort_trigger_set(alltrig, True, self._say)
# Get all of the %Previous triggers for this topic.
that_triggers = inherit_utils.get_topic_triggers(self, topic, True)
# And sort them, too.
self._sorted["thats"][topic] = sorting.sort_trigger_set(that_triggers, False, self._say)
# And sort the substitution lists.
if not "lists" in self._sorted:
self._sorted["lists"] = {}
self._sorted["lists"]["sub"] = sorting.sort_list(self._sub.keys())
self._sorted["lists"]["person"] = sorting.sort_list(self._person.keys()) |
0, module; 1, function_definition; 2, function_name:all; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, return_statement; 11, identifier:page; 12, integer:1; 13, identifier:per_page; 14, integer:10; 15, identifier:order_by; 16, string:"latest"; 17, comment:"""
Get a single page from the list of all photos.
:param page [integer]: Page number to retrieve. (Optional; default: 1)
:param per_page [integer]: Number of items per page. (Optional; default: 10)
:param order_by [string]: How to sort the photos. Optional.
(Valid values: latest, oldest, popular; default: latest)
:return: [Array]: A single page of the Photo list.
"""; 18, call; 19, attribute; 20, argument_list; 21, identifier:self; 22, identifier:_all; 23, string:"/photos"; 24, keyword_argument; 25, keyword_argument; 26, keyword_argument; 27, identifier:page; 28, identifier:page; 29, identifier:per_page; 30, identifier:per_page; 31, identifier:order_by; 32, identifier:order_by | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 7, 14; 8, 15; 8, 16; 9, 17; 10, 18; 18, 19; 18, 20; 19, 21; 19, 22; 20, 23; 20, 24; 20, 25; 20, 26; 24, 27; 24, 28; 25, 29; 25, 30; 26, 31; 26, 32 | def all(self, page=1, per_page=10, order_by="latest"):
"""
Get a single page from the list of all photos.
:param page [integer]: Page number to retrieve. (Optional; default: 1)
:param per_page [integer]: Number of items per page. (Optional; default: 10)
:param order_by [string]: How to sort the photos. Optional.
(Valid values: latest, oldest, popular; default: latest)
:return: [Array]: A single page of the Photo list.
"""
return self._all("/photos", page=page, per_page=per_page, order_by=order_by) |
0, module; 1, function_definition; 2, function_name:photos; 3, parameters; 4, block; 5, identifier:self; 6, identifier:username; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, return_statement; 14, identifier:page; 15, integer:1; 16, identifier:per_page; 17, integer:10; 18, identifier:order_by; 19, string:"latest"; 20, comment:"""
Get a list of photos uploaded by a user.
:param username [string]: The user’s username. Required.
:param page [integer]: Page number to retrieve. (Optional; default: 1)
:param per_page [integer]: Number of items per page. (Optional; default: 10)
:param order_by [string]: How to sort the photos. Optional.
(Valid values: latest, oldest, popular; default: latest)
:return: [Array]: A single page of the Photo list.
"""; 21, assignment; 22, assignment; 23, call; 24, identifier:url; 25, call; 26, identifier:result; 27, call; 28, attribute; 29, argument_list; 30, attribute; 31, argument_list; 32, attribute; 33, argument_list; 34, identifier:PhotoModel; 35, identifier:parse_list; 36, identifier:result; 37, string:"/users/{username}/photos"; 38, identifier:format; 39, keyword_argument; 40, identifier:self; 41, identifier:_photos; 42, identifier:url; 43, identifier:username; 44, keyword_argument; 45, keyword_argument; 46, keyword_argument; 47, identifier:username; 48, identifier:username; 49, identifier:page; 50, identifier:page; 51, identifier:per_page; 52, identifier:per_page; 53, identifier:order_by; 54, identifier:order_by | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 7, 15; 8, 16; 8, 17; 9, 18; 9, 19; 10, 20; 11, 21; 12, 22; 13, 23; 21, 24; 21, 25; 22, 26; 22, 27; 23, 28; 23, 29; 25, 30; 25, 31; 27, 32; 27, 33; 28, 34; 28, 35; 29, 36; 30, 37; 30, 38; 31, 39; 32, 40; 32, 41; 33, 42; 33, 43; 33, 44; 33, 45; 33, 46; 39, 47; 39, 48; 44, 49; 44, 50; 45, 51; 45, 52; 46, 53; 46, 54 | def photos(self, username, page=1, per_page=10, order_by="latest"):
"""
Get a list of photos uploaded by a user.
:param username [string]: The user’s username. Required.
:param page [integer]: Page number to retrieve. (Optional; default: 1)
:param per_page [integer]: Number of items per page. (Optional; default: 10)
:param order_by [string]: How to sort the photos. Optional.
(Valid values: latest, oldest, popular; default: latest)
:return: [Array]: A single page of the Photo list.
"""
url = "/users/{username}/photos".format(username=username)
result = self._photos(url, username, page=page, per_page=per_page, order_by=order_by)
return PhotoModel.parse_list(result) |
0, module; 1, function_definition; 2, function_name:callable; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, function_definition; 10, return_statement; 11, identifier:nans; 12, False; 13, comment:"""Compile a jitted function and loop it over the sorted data."""; 14, assignment; 15, function_name:_loop; 16, parameters; 17, block; 18, call; 19, identifier:jitfunc; 20, call; 21, identifier:sortidx; 22, identifier:group_idx; 23, identifier:a; 24, identifier:ret; 25, expression_statement; 26, expression_statement; 27, expression_statement; 28, expression_statement; 29, for_statement; 30, attribute; 31, argument_list; 32, attribute; 33, argument_list; 34, assignment; 35, assignment; 36, assignment; 37, assignment; 38, identifier:i; 39, call; 40, block; 41, identifier:nb; 42, identifier:njit; 43, identifier:_loop; 44, keyword_argument; 45, identifier:nb; 46, identifier:njit; 47, attribute; 48, keyword_argument; 49, identifier:size; 50, call; 51, identifier:group_idx_srt; 52, subscript; 53, identifier:a_srt; 54, subscript; 55, identifier:indices; 56, call; 57, identifier:range; 58, argument_list; 59, expression_statement; 60, expression_statement; 61, if_statement; 62, if_statement; 63, expression_statement; 64, identifier:nogil; 65, True; 66, identifier:self; 67, identifier:func; 68, identifier:nogil; 69, True; 70, identifier:len; 71, argument_list; 72, identifier:group_idx; 73, identifier:sortidx; 74, identifier:a; 75, identifier:sortidx; 76, identifier:step_indices; 77, argument_list; 78, binary_operator:len(indices) - 1; 79, assignment; 80, assignment; 81, comparison_operator:ri < 0; 82, block; 83, comparison_operator:ri >= size; 84, block; 85, assignment; 86, identifier:ret; 87, identifier:group_idx_srt; 88, call; 89, integer:1; 90, pattern_list; 91, expression_list; 92, identifier:ri; 93, subscript; 94, identifier:ri; 95, integer:0; 96, raise_statement; 97, identifier:ri; 98, identifier:size; 99, raise_statement; 100, subscript; 101, call; 102, identifier:len; 103, argument_list; 104, identifier:start_idx; 105, identifier:stop_idx; 106, subscript; 107, subscript; 108, identifier:group_idx_srt; 109, identifier:start_idx; 110, call; 111, call; 112, identifier:ret; 113, identifier:ri; 114, identifier:jitfunc; 115, argument_list; 116, identifier:indices; 117, identifier:indices; 118, identifier:i; 119, identifier:indices; 120, binary_operator:i + 1; 121, identifier:ValueError; 122, argument_list; 123, identifier:ValueError; 124, argument_list; 125, subscript; 126, identifier:i; 127, integer:1; 128, string:"negative indices not supported"; 129, string:"one or more indices in group_idx are too large"; 130, identifier:a_srt; 131, slice; 132, identifier:start_idx; 133, identifier:stop_idx | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 8, 14; 9, 15; 9, 16; 9, 17; 10, 18; 14, 19; 14, 20; 16, 21; 16, 22; 16, 23; 16, 24; 17, 25; 17, 26; 17, 27; 17, 28; 17, 29; 18, 30; 18, 31; 20, 32; 20, 33; 25, 34; 26, 35; 27, 36; 28, 37; 29, 38; 29, 39; 29, 40; 30, 41; 30, 42; 31, 43; 31, 44; 32, 45; 32, 46; 33, 47; 33, 48; 34, 49; 34, 50; 35, 51; 35, 52; 36, 53; 36, 54; 37, 55; 37, 56; 39, 57; 39, 58; 40, 59; 40, 60; 40, 61; 40, 62; 40, 63; 44, 64; 44, 65; 47, 66; 47, 67; 48, 68; 48, 69; 50, 70; 50, 71; 52, 72; 52, 73; 54, 74; 54, 75; 56, 76; 56, 77; 58, 78; 59, 79; 60, 80; 61, 81; 61, 82; 62, 83; 62, 84; 63, 85; 71, 86; 77, 87; 78, 88; 78, 89; 79, 90; 79, 91; 80, 92; 80, 93; 81, 94; 81, 95; 82, 96; 83, 97; 83, 98; 84, 99; 85, 100; 85, 101; 88, 102; 88, 103; 90, 104; 90, 105; 91, 106; 91, 107; 93, 108; 93, 109; 96, 110; 99, 111; 100, 112; 100, 113; 101, 114; 101, 115; 103, 116; 106, 117; 106, 118; 107, 119; 107, 120; 110, 121; 110, 122; 111, 123; 111, 124; 115, 125; 120, 126; 120, 127; 122, 128; 124, 129; 125, 130; 125, 131; 131, 132; 131, 133 | def callable(self, nans=False):
"""Compile a jitted function and loop it over the sorted data."""
jitfunc = nb.njit(self.func, nogil=True)
def _loop(sortidx, group_idx, a, ret):
size = len(ret)
group_idx_srt = group_idx[sortidx]
a_srt = a[sortidx]
indices = step_indices(group_idx_srt)
for i in range(len(indices) - 1):
start_idx, stop_idx = indices[i], indices[i + 1]
ri = group_idx_srt[start_idx]
if ri < 0:
raise ValueError("negative indices not supported")
if ri >= size:
raise ValueError("one or more indices in group_idx are too large")
ret[ri] = jitfunc(a_srt[start_idx:stop_idx])
return nb.njit(_loop, nogil=True) |
0, module; 1, function_definition; 2, function_name:scores2recos; 3, parameters; 4, block; 5, identifier:self; 6, identifier:scores; 7, identifier:candidates; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, return_statement; 13, identifier:rev; 14, False; 15, comment:"""Get recommendation list for a user u_index based on scores.
Args:
scores (numpy array; (n_target_items,)):
Scores for the target items. Smaller score indicates a promising item.
candidates (numpy array; (# target items, )): Target items' indices. Only these items are considered as the recommendation candidates.
rev (bool): If true, return items in an descending order. A ascending order (i.e., smaller scores are more promising) is default.
Returns:
(numpy array, numpy array) : (Sorted list of items, Sorted scores).
"""; 16, assignment; 17, identifier:rev; 18, block; 19, expression_list; 20, identifier:sorted_indices; 21, call; 22, expression_statement; 23, subscript; 24, subscript; 25, attribute; 26, argument_list; 27, assignment; 28, identifier:candidates; 29, identifier:sorted_indices; 30, identifier:scores; 31, identifier:sorted_indices; 32, identifier:np; 33, identifier:argsort; 34, identifier:scores; 35, identifier:sorted_indices; 36, subscript; 37, identifier:sorted_indices; 38, slice; 39, unary_operator; 40, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 8, 13; 8, 14; 9, 15; 10, 16; 11, 17; 11, 18; 12, 19; 16, 20; 16, 21; 18, 22; 19, 23; 19, 24; 21, 25; 21, 26; 22, 27; 23, 28; 23, 29; 24, 30; 24, 31; 25, 32; 25, 33; 26, 34; 27, 35; 27, 36; 36, 37; 36, 38; 38, 39; 39, 40 | def scores2recos(self, scores, candidates, rev=False):
"""Get recommendation list for a user u_index based on scores.
Args:
scores (numpy array; (n_target_items,)):
Scores for the target items. Smaller score indicates a promising item.
candidates (numpy array; (# target items, )): Target items' indices. Only these items are considered as the recommendation candidates.
rev (bool): If true, return items in an descending order. A ascending order (i.e., smaller scores are more promising) is default.
Returns:
(numpy array, numpy array) : (Sorted list of items, Sorted scores).
"""
sorted_indices = np.argsort(scores)
if rev:
sorted_indices = sorted_indices[::-1]
return candidates[sorted_indices], scores[sorted_indices] |
0, module; 1, function_definition; 2, function_name:commutative_sequence_variable_partition_iter; 3, parameters; 4, type; 5, block; 6, typed_parameter; 7, typed_parameter; 8, generic_type; 9, expression_statement; 10, if_statement; 11, expression_statement; 12, for_statement; 13, expression_statement; 14, comment:# type: Dict[str, 'Multiset[T]']; 15, for_statement; 16, identifier:values; 17, type; 18, identifier:variables; 19, type; 20, identifier:Iterator; 21, type_parameter; 22, comment:"""Yield all possible variable substitutions for given values and variables.
.. note::
The results are not yielded in any particular order because the algorithm uses dictionaries. Dictionaries until
Python 3.6 do not keep track of the insertion order.
Example:
For a subject like ``fc(a, a, a, b, b, c)`` and a pattern like ``f(x__, y___, y___)`` one can define the
following input parameters for the partitioning:
>>> x = VariableWithCount(name='x', count=1, minimum=1, default=None)
>>> y = VariableWithCount(name='y', count=2, minimum=0, default=None)
>>> values = Multiset('aaabbc')
Then the solutions are found (and sorted to get a unique output):
>>> substitutions = commutative_sequence_variable_partition_iter(values, [x, y])
>>> as_strings = list(str(Substitution(substitution)) for substitution in substitutions)
>>> for substitution in sorted(as_strings):
... print(substitution)
{x ↦ {a, a, a, b, b, c}, y ↦ {}}
{x ↦ {a, a, a, c}, y ↦ {b}}
{x ↦ {a, b, b, c}, y ↦ {a}}
{x ↦ {a, c}, y ↦ {a, b}}
Args:
values:
The multiset of values which are partitioned and distributed among the variables.
variables:
A list of the variables to distribute the values among. Each variable has a name, a count of how many times
it occurs and a minimum number of values it needs.
Yields:
Each possible substitutions that is a valid partitioning of the values among the variables.
"""; 23, comparison_operator:len(variables) == 1; 24, block; 25, assignment; 26, pattern_list; 27, call; 28, block; 29, assignment; 30, identifier:subst; 31, call; 32, block; 33, identifier:Multiset; 34, generic_type; 35, type; 36, call; 37, integer:1; 38, expression_statement; 39, return_statement; 40, identifier:generators; 41, list; 42, identifier:value; 43, identifier:count; 44, attribute; 45, argument_list; 46, expression_statement; 47, identifier:initial; 48, call; 49, identifier:generator_chain; 50, argument_list; 51, expression_statement; 52, for_statement; 53, if_statement; 54, identifier:List; 55, type_parameter; 56, generic_type; 57, identifier:len; 58, argument_list; 59, yield; 60, identifier:values; 61, identifier:items; 62, call; 63, identifier:dict; 64, generator_expression; 65, identifier:initial; 66, list_splat; 67, assignment; 68, identifier:var; 69, identifier:variables; 70, block; 71, identifier:valid; 72, block; 73, type; 74, identifier:Dict; 75, type_parameter; 76, identifier:variables; 77, call; 78, attribute; 79, argument_list; 80, tuple; 81, for_in_clause; 82, identifier:generators; 83, identifier:valid; 84, True; 85, if_statement; 86, if_statement; 87, expression_statement; 88, identifier:VariableWithCount; 89, type; 90, type; 91, identifier:_commutative_single_variable_partiton_iter; 92, argument_list; 93, identifier:generators; 94, identifier:append; 95, call; 96, attribute; 97, call; 98, identifier:var; 99, identifier:variables; 100, boolean_operator; 101, block; 102, elif_clause; 103, comparison_operator:None in subst; 104, block; 105, yield; 106, identifier:str; 107, identifier:Multiset; 108, identifier:values; 109, subscript; 110, identifier:_make_variable_generator_factory; 111, argument_list; 112, identifier:var; 113, identifier:name; 114, identifier:Multiset; 115, argument_list; 116, comparison_operator:var.default is not None; 117, comparison_operator:len(subst[var.name]) == 0; 118, expression_statement; 119, comparison_operator:len(subst[var.name]) < var.minimum; 120, block; 121, None; 122, identifier:subst; 123, delete_statement; 124, identifier:subst; 125, identifier:variables; 126, integer:0; 127, identifier:value; 128, identifier:count; 129, identifier:variables; 130, attribute; 131, None; 132, call; 133, integer:0; 134, assignment; 135, call; 136, attribute; 137, expression_statement; 138, break_statement; 139, subscript; 140, identifier:var; 141, identifier:default; 142, identifier:len; 143, argument_list; 144, subscript; 145, attribute; 146, identifier:len; 147, argument_list; 148, identifier:var; 149, identifier:minimum; 150, assignment; 151, identifier:subst; 152, None; 153, subscript; 154, identifier:subst; 155, attribute; 156, identifier:var; 157, identifier:default; 158, subscript; 159, identifier:valid; 160, False; 161, identifier:subst; 162, attribute; 163, identifier:var; 164, identifier:name; 165, identifier:subst; 166, attribute; 167, identifier:var; 168, identifier:name; 169, identifier:var; 170, identifier:name | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 4, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 14; 5, 15; 6, 16; 6, 17; 7, 18; 7, 19; 8, 20; 8, 21; 9, 22; 10, 23; 10, 24; 11, 25; 12, 26; 12, 27; 12, 28; 13, 29; 15, 30; 15, 31; 15, 32; 17, 33; 19, 34; 21, 35; 23, 36; 23, 37; 24, 38; 24, 39; 25, 40; 25, 41; 26, 42; 26, 43; 27, 44; 27, 45; 28, 46; 29, 47; 29, 48; 31, 49; 31, 50; 32, 51; 32, 52; 32, 53; 34, 54; 34, 55; 35, 56; 36, 57; 36, 58; 38, 59; 44, 60; 44, 61; 46, 62; 48, 63; 48, 64; 50, 65; 50, 66; 51, 67; 52, 68; 52, 69; 52, 70; 53, 71; 53, 72; 55, 73; 56, 74; 56, 75; 58, 76; 59, 77; 62, 78; 62, 79; 64, 80; 64, 81; 66, 82; 67, 83; 67, 84; 70, 85; 72, 86; 72, 87; 73, 88; 75, 89; 75, 90; 77, 91; 77, 92; 78, 93; 78, 94; 79, 95; 80, 96; 80, 97; 81, 98; 81, 99; 85, 100; 85, 101; 85, 102; 86, 103; 86, 104; 87, 105; 89, 106; 90, 107; 92, 108; 92, 109; 95, 110; 95, 111; 96, 112; 96, 113; 97, 114; 97, 115; 100, 116; 100, 117; 101, 118; 102, 119; 102, 120; 103, 121; 103, 122; 104, 123; 105, 124; 109, 125; 109, 126; 111, 127; 111, 128; 111, 129; 116, 130; 116, 131; 117, 132; 117, 133; 118, 134; 119, 135; 119, 136; 120, 137; 120, 138; 123, 139; 130, 140; 130, 141; 132, 142; 132, 143; 134, 144; 134, 145; 135, 146; 135, 147; 136, 148; 136, 149; 137, 150; 139, 151; 139, 152; 143, 153; 144, 154; 144, 155; 145, 156; 145, 157; 147, 158; 150, 159; 150, 160; 153, 161; 153, 162; 155, 163; 155, 164; 158, 165; 158, 166; 162, 167; 162, 168; 166, 169; 166, 170 | def commutative_sequence_variable_partition_iter(values: Multiset, variables: List[VariableWithCount]
) -> Iterator[Dict[str, Multiset]]:
"""Yield all possible variable substitutions for given values and variables.
.. note::
The results are not yielded in any particular order because the algorithm uses dictionaries. Dictionaries until
Python 3.6 do not keep track of the insertion order.
Example:
For a subject like ``fc(a, a, a, b, b, c)`` and a pattern like ``f(x__, y___, y___)`` one can define the
following input parameters for the partitioning:
>>> x = VariableWithCount(name='x', count=1, minimum=1, default=None)
>>> y = VariableWithCount(name='y', count=2, minimum=0, default=None)
>>> values = Multiset('aaabbc')
Then the solutions are found (and sorted to get a unique output):
>>> substitutions = commutative_sequence_variable_partition_iter(values, [x, y])
>>> as_strings = list(str(Substitution(substitution)) for substitution in substitutions)
>>> for substitution in sorted(as_strings):
... print(substitution)
{x ↦ {a, a, a, b, b, c}, y ↦ {}}
{x ↦ {a, a, a, c}, y ↦ {b}}
{x ↦ {a, b, b, c}, y ↦ {a}}
{x ↦ {a, c}, y ↦ {a, b}}
Args:
values:
The multiset of values which are partitioned and distributed among the variables.
variables:
A list of the variables to distribute the values among. Each variable has a name, a count of how many times
it occurs and a minimum number of values it needs.
Yields:
Each possible substitutions that is a valid partitioning of the values among the variables.
"""
if len(variables) == 1:
yield from _commutative_single_variable_partiton_iter(values, variables[0])
return
generators = []
for value, count in values.items():
generators.append(_make_variable_generator_factory(value, count, variables))
initial = dict((var.name, Multiset()) for var in variables) # type: Dict[str, 'Multiset[T]']
for subst in generator_chain(initial, *generators):
valid = True
for var in variables:
if var.default is not None and len(subst[var.name]) == 0:
subst[var.name] = var.default
elif len(subst[var.name]) < var.minimum:
valid = False
break
if valid:
if None in subst:
del subst[None]
yield subst |
0, module; 1, function_definition; 2, function_name:iter_cookie_browse_sorting; 3, parameters; 4, block; 5, identifier:cookies; 6, expression_statement; 7, try_statement; 8, string; 9, block; 10, except_clause; 11, string_content:Get sorting-cookie from cookies dictionary.
:yields: tuple of path and sorting property
:ytype: 2-tuple of strings; 12, expression_statement; 13, for_statement; 14, as_pattern; 15, block; 16, assignment; 17, pattern_list; 18, call; 19, block; 20, tuple; 21, as_pattern_target; 22, expression_statement; 23, identifier:data; 24, call; 25, identifier:path; 26, identifier:prop; 27, attribute; 28, argument_list; 29, expression_statement; 30, identifier:ValueError; 31, identifier:TypeError; 32, identifier:KeyError; 33, identifier:e; 34, call; 35, attribute; 36, argument_list; 37, identifier:json; 38, identifier:loads; 39, call; 40, yield; 41, attribute; 42, argument_list; 43, call; 44, identifier:encode; 45, string; 46, attribute; 47, argument_list; 48, expression_list; 49, identifier:logger; 50, identifier:exception; 51, identifier:e; 52, attribute; 53, argument_list; 54, string_content:ascii; 55, call; 56, identifier:decode; 57, string; 58, identifier:path; 59, identifier:prop; 60, identifier:cookies; 61, identifier:get; 62, string; 63, string; 64, attribute; 65, argument_list; 66, string_content:utf-8; 67, string_content:browse-sorting; 68, string_content:e30=; 69, identifier:base64; 70, identifier:b64decode; 71, identifier:data | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 7, 10; 8, 11; 9, 12; 9, 13; 10, 14; 10, 15; 12, 16; 13, 17; 13, 18; 13, 19; 14, 20; 14, 21; 15, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 18, 28; 19, 29; 20, 30; 20, 31; 20, 32; 21, 33; 22, 34; 24, 35; 24, 36; 27, 37; 27, 38; 28, 39; 29, 40; 34, 41; 34, 42; 35, 43; 35, 44; 36, 45; 39, 46; 39, 47; 40, 48; 41, 49; 41, 50; 42, 51; 43, 52; 43, 53; 45, 54; 46, 55; 46, 56; 47, 57; 48, 58; 48, 59; 52, 60; 52, 61; 53, 62; 53, 63; 55, 64; 55, 65; 57, 66; 62, 67; 63, 68; 64, 69; 64, 70; 65, 71 | def iter_cookie_browse_sorting(cookies):
'''
Get sorting-cookie from cookies dictionary.
:yields: tuple of path and sorting property
:ytype: 2-tuple of strings
'''
try:
data = cookies.get('browse-sorting', 'e30=').encode('ascii')
for path, prop in json.loads(base64.b64decode(data).decode('utf-8')):
yield path, prop
except (ValueError, TypeError, KeyError) as e:
logger.exception(e) |
0, module; 1, function_definition; 2, function_name:get_cookie_browse_sorting; 3, parameters; 4, block; 5, identifier:path; 6, identifier:default; 7, expression_statement; 8, if_statement; 9, return_statement; 10, string; 11, identifier:request; 12, block; 13, identifier:default; 14, string_content:Get sorting-cookie data for path of current request.
:returns: sorting property
:rtype: string; 15, for_statement; 16, pattern_list; 17, call; 18, block; 19, identifier:cpath; 20, identifier:cprop; 21, identifier:iter_cookie_browse_sorting; 22, argument_list; 23, if_statement; 24, attribute; 25, comparison_operator:path == cpath; 26, block; 27, identifier:request; 28, identifier:cookies; 29, identifier:path; 30, identifier:cpath; 31, return_statement; 32, identifier:cprop | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 7, 10; 8, 11; 8, 12; 9, 13; 10, 14; 12, 15; 15, 16; 15, 17; 15, 18; 16, 19; 16, 20; 17, 21; 17, 22; 18, 23; 22, 24; 23, 25; 23, 26; 24, 27; 24, 28; 25, 29; 25, 30; 26, 31; 31, 32 | def get_cookie_browse_sorting(path, default):
'''
Get sorting-cookie data for path of current request.
:returns: sorting property
:rtype: string
'''
if request:
for cpath, cprop in iter_cookie_browse_sorting(request.cookies):
if path == cpath:
return cprop
return default |
0, module; 1, function_definition; 2, function_name:integral; 3, parameters; 4, block; 5, identifier:requestContext; 6, identifier:seriesList; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""
This will show the sum over time, sort of like a continuous addition
function. Useful for finding totals or trends in metrics that are
collected per minute.
Example::
&target=integral(company.sales.perMinute)
This would start at zero on the left side of the graph, adding the sales
each minute, and show the total sales for the time period selected at the
right side, (time now, or the time specified by '&until=').
"""; 12, assignment; 13, identifier:series; 14, identifier:seriesList; 15, block; 16, identifier:results; 17, identifier:results; 18, list; 19, expression_statement; 20, expression_statement; 21, for_statement; 22, expression_statement; 23, expression_statement; 24, expression_statement; 25, expression_statement; 26, assignment; 27, assignment; 28, identifier:val; 29, identifier:series; 30, block; 31, assignment; 32, assignment; 33, assignment; 34, call; 35, identifier:newValues; 36, list; 37, identifier:current; 38, float:0.0; 39, if_statement; 40, identifier:newName; 41, binary_operator:"integral(%s)" % series.name; 42, identifier:newSeries; 43, call; 44, attribute; 45, identifier:newName; 46, attribute; 47, argument_list; 48, comparison_operator:val is None; 49, block; 50, else_clause; 51, string:"integral(%s)"; 52, attribute; 53, identifier:TimeSeries; 54, argument_list; 55, identifier:newSeries; 56, identifier:pathExpression; 57, identifier:results; 58, identifier:append; 59, identifier:newSeries; 60, identifier:val; 61, None; 62, expression_statement; 63, block; 64, identifier:series; 65, identifier:name; 66, identifier:newName; 67, attribute; 68, attribute; 69, attribute; 70, identifier:newValues; 71, call; 72, expression_statement; 73, expression_statement; 74, identifier:series; 75, identifier:start; 76, identifier:series; 77, identifier:end; 78, identifier:series; 79, identifier:step; 80, attribute; 81, argument_list; 82, augmented_assignment; 83, call; 84, identifier:newValues; 85, identifier:append; 86, None; 87, identifier:current; 88, identifier:val; 89, attribute; 90, argument_list; 91, identifier:newValues; 92, identifier:append; 93, identifier:current | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 9, 14; 9, 15; 10, 16; 12, 17; 12, 18; 15, 19; 15, 20; 15, 21; 15, 22; 15, 23; 15, 24; 15, 25; 19, 26; 20, 27; 21, 28; 21, 29; 21, 30; 22, 31; 23, 32; 24, 33; 25, 34; 26, 35; 26, 36; 27, 37; 27, 38; 30, 39; 31, 40; 31, 41; 32, 42; 32, 43; 33, 44; 33, 45; 34, 46; 34, 47; 39, 48; 39, 49; 39, 50; 41, 51; 41, 52; 43, 53; 43, 54; 44, 55; 44, 56; 46, 57; 46, 58; 47, 59; 48, 60; 48, 61; 49, 62; 50, 63; 52, 64; 52, 65; 54, 66; 54, 67; 54, 68; 54, 69; 54, 70; 62, 71; 63, 72; 63, 73; 67, 74; 67, 75; 68, 76; 68, 77; 69, 78; 69, 79; 71, 80; 71, 81; 72, 82; 73, 83; 80, 84; 80, 85; 81, 86; 82, 87; 82, 88; 83, 89; 83, 90; 89, 91; 89, 92; 90, 93 | def integral(requestContext, seriesList):
"""
This will show the sum over time, sort of like a continuous addition
function. Useful for finding totals or trends in metrics that are
collected per minute.
Example::
&target=integral(company.sales.perMinute)
This would start at zero on the left side of the graph, adding the sales
each minute, and show the total sales for the time period selected at the
right side, (time now, or the time specified by '&until=').
"""
results = []
for series in seriesList:
newValues = []
current = 0.0
for val in series:
if val is None:
newValues.append(None)
else:
current += val
newValues.append(current)
newName = "integral(%s)" % series.name
newSeries = TimeSeries(newName, series.start, series.end, series.step,
newValues)
newSeries.pathExpression = newName
results.append(newSeries)
return results |
0, module; 1, function_definition; 2, function_name:map_metabolite2kegg; 3, parameters; 4, block; 5, identifier:metabolite; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, if_statement; 11, expression_statement; 12, return_statement; 13, comment:"""
Return a KEGG compound identifier for the metabolite if it exists.
First see if there is an unambiguous mapping to a single KEGG compound ID
provided with the model. If not, check if there is any KEGG compound ID in
a list of mappings. KEGG IDs may map to compounds, drugs and glycans. KEGG
compound IDs are sorted so we keep the lowest that is there. If none of
this works try mapping to KEGG via the CompoundMatcher by the name of the
metabolite. If the metabolite cannot be mapped at all we simply map it back
to its own ID.
Parameters
----------
metabolite : cobra.Metabolite
The metabolite to be mapped to its KEGG compound identifier.
Returns
-------
None
If the metabolite could not be mapped.
str
The smallest KEGG compound identifier that was found.
"""; 14, call; 15, assignment; 16, comparison_operator:kegg_annotation is None; 17, comment:# TODO (Moritz Beber): Currently name matching is very slow and; 18, comment:# inaccurate. We disable it until there is a better solution.; 19, comment:# if metabolite.name:; 20, comment:# # The compound matcher uses regular expression and chokes; 21, comment:# # with a low level error on `[` in the name, for example.; 22, comment:# df = compound_matcher.match(metabolite.name); 23, comment:# try:; 24, comment:# return df.loc[df["score"] > threshold, "CID"].iat[0]; 25, comment:# except (IndexError, AttributeError):; 26, comment:# logger.warning(; 27, comment:# "Could not match the name %r to any kegg.compound "; 28, comment:# "annotation for metabolite %s.",; 29, comment:# metabolite.name, metabolite.id; 30, comment:# ); 31, comment:# return; 32, comment:# else:; 33, block; 34, boolean_operator; 35, block; 36, elif_clause; 37, call; 38, attribute; 39, argument_list; 40, identifier:kegg_annotation; 41, call; 42, identifier:kegg_annotation; 43, None; 44, expression_statement; 45, return_statement; 46, call; 47, line_continuation:\; 48, call; 49, return_statement; 50, call; 51, block; 52, attribute; 53, argument_list; 54, identifier:logger; 55, identifier:debug; 56, string:"Looking for KEGG compound identifier for %s."; 57, attribute; 58, attribute; 59, argument_list; 60, call; 61, identifier:isinstance; 62, argument_list; 63, attribute; 64, argument_list; 65, identifier:kegg_annotation; 66, identifier:isinstance; 67, argument_list; 68, try_statement; 69, identifier:logger; 70, identifier:warning; 71, string:"No matching kegg.compound annotation for metabolite %s."; 72, attribute; 73, identifier:metabolite; 74, identifier:id; 75, attribute; 76, identifier:get; 77, string:"kegg.compound"; 78, attribute; 79, argument_list; 80, identifier:kegg_annotation; 81, identifier:string_types; 82, identifier:kegg_annotation; 83, identifier:startswith; 84, string:"C"; 85, identifier:kegg_annotation; 86, identifier:Iterable; 87, block; 88, except_clause; 89, identifier:metabolite; 90, identifier:id; 91, identifier:metabolite; 92, identifier:annotation; 93, identifier:logger; 94, identifier:warning; 95, string:"No kegg.compound annotation for metabolite %s."; 96, attribute; 97, return_statement; 98, identifier:ValueError; 99, block; 100, identifier:metabolite; 101, identifier:id; 102, call; 103, return_statement; 104, identifier:get_smallest_compound_id; 105, argument_list; 106, identifier:kegg_annotation | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 7, 14; 8, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 9, 21; 9, 22; 9, 23; 9, 24; 9, 25; 9, 26; 9, 27; 9, 28; 9, 29; 9, 30; 9, 31; 9, 32; 9, 33; 10, 34; 10, 35; 10, 36; 11, 37; 14, 38; 14, 39; 15, 40; 15, 41; 16, 42; 16, 43; 33, 44; 33, 45; 34, 46; 34, 47; 34, 48; 35, 49; 36, 50; 36, 51; 37, 52; 37, 53; 38, 54; 38, 55; 39, 56; 39, 57; 41, 58; 41, 59; 44, 60; 46, 61; 46, 62; 48, 63; 48, 64; 49, 65; 50, 66; 50, 67; 51, 68; 52, 69; 52, 70; 53, 71; 53, 72; 57, 73; 57, 74; 58, 75; 58, 76; 59, 77; 60, 78; 60, 79; 62, 80; 62, 81; 63, 82; 63, 83; 64, 84; 67, 85; 67, 86; 68, 87; 68, 88; 72, 89; 72, 90; 75, 91; 75, 92; 78, 93; 78, 94; 79, 95; 79, 96; 87, 97; 88, 98; 88, 99; 96, 100; 96, 101; 97, 102; 99, 103; 102, 104; 102, 105; 105, 106 | def map_metabolite2kegg(metabolite):
"""
Return a KEGG compound identifier for the metabolite if it exists.
First see if there is an unambiguous mapping to a single KEGG compound ID
provided with the model. If not, check if there is any KEGG compound ID in
a list of mappings. KEGG IDs may map to compounds, drugs and glycans. KEGG
compound IDs are sorted so we keep the lowest that is there. If none of
this works try mapping to KEGG via the CompoundMatcher by the name of the
metabolite. If the metabolite cannot be mapped at all we simply map it back
to its own ID.
Parameters
----------
metabolite : cobra.Metabolite
The metabolite to be mapped to its KEGG compound identifier.
Returns
-------
None
If the metabolite could not be mapped.
str
The smallest KEGG compound identifier that was found.
"""
logger.debug("Looking for KEGG compound identifier for %s.", metabolite.id)
kegg_annotation = metabolite.annotation.get("kegg.compound")
if kegg_annotation is None:
# TODO (Moritz Beber): Currently name matching is very slow and
# inaccurate. We disable it until there is a better solution.
# if metabolite.name:
# # The compound matcher uses regular expression and chokes
# # with a low level error on `[` in the name, for example.
# df = compound_matcher.match(metabolite.name)
# try:
# return df.loc[df["score"] > threshold, "CID"].iat[0]
# except (IndexError, AttributeError):
# logger.warning(
# "Could not match the name %r to any kegg.compound "
# "annotation for metabolite %s.",
# metabolite.name, metabolite.id
# )
# return
# else:
logger.warning("No kegg.compound annotation for metabolite %s.",
metabolite.id)
return
if isinstance(kegg_annotation, string_types) and \
kegg_annotation.startswith("C"):
return kegg_annotation
elif isinstance(kegg_annotation, Iterable):
try:
return get_smallest_compound_id(kegg_annotation)
except ValueError:
return
logger.warning(
"No matching kegg.compound annotation for metabolite %s.",
metabolite.id
)
return |
0, module; 1, function_definition; 2, function_name:preProcessForComparison; 3, parameters; 4, block; 5, identifier:results; 6, identifier:target_size; 7, identifier:size_tolerance_prct; 8, expression_statement; 9, comment:# find reference (=image most likely to match target cover ignoring factors like size and format); 10, expression_statement; 11, for_statement; 12, comment:# remove results that are only refs; 13, expression_statement; 14, comment:# remove duplicates; 15, expression_statement; 16, for_statement; 17, expression_statement; 18, if_statement; 19, if_statement; 20, return_statement; 21, comment:""" Process results to prepare them for future comparison and sorting. """; 22, assignment; 23, identifier:result; 24, identifier:results; 25, block; 26, assignment; 27, assignment; 28, identifier:result; 29, identifier:results; 30, block; 31, assignment; 32, comparison_operator:dup_count > 0; 33, block; 34, comparison_operator:reference is not None; 35, block; 36, else_clause; 37, identifier:results; 38, identifier:reference; 39, None; 40, if_statement; 41, identifier:results; 42, call; 43, identifier:no_dup_results; 44, list; 45, expression_statement; 46, for_statement; 47, if_statement; 48, identifier:dup_count; 49, binary_operator:len(results) - len(no_dup_results); 50, identifier:dup_count; 51, integer:0; 52, expression_statement; 53, expression_statement; 54, identifier:reference; 55, None; 56, expression_statement; 57, expression_statement; 58, comment:# calculate sigs; 59, expression_statement; 60, for_statement; 61, if_statement; 62, if_statement; 63, for_statement; 64, comment:# compare other results to reference; 65, for_statement; 66, block; 67, comparison_operator:result.source_quality is CoverSourceQuality.REFERENCE; 68, block; 69, identifier:list; 70, argument_list; 71, assignment; 72, identifier:result_comp; 73, identifier:results; 74, block; 75, not_operator; 76, block; 77, call; 78, call; 79, call; 80, assignment; 81, call; 82, assignment; 83, assignment; 84, identifier:result; 85, identifier:results; 86, block; 87, attribute; 88, block; 89, identifier:futures; 90, block; 91, identifier:future; 92, identifier:futures; 93, block; 94, identifier:result; 95, identifier:results; 96, block; 97, expression_statement; 98, attribute; 99, attribute; 100, if_statement; 101, call; 102, identifier:is_dup; 103, False; 104, if_statement; 105, identifier:is_dup; 106, expression_statement; 107, identifier:len; 108, argument_list; 109, identifier:len; 110, argument_list; 111, attribute; 112, argument_list; 113, identifier:results; 114, identifier:no_dup_results; 115, attribute; 116, argument_list; 117, attribute; 118, True; 119, identifier:futures; 120, list; 121, expression_statement; 122, expression_statement; 123, expression_statement; 124, identifier:reference; 125, identifier:is_only_reference; 126, assert_statement; 127, expression_statement; 128, expression_statement; 129, expression_statement; 130, expression_statement; 131, expression_statement; 132, comment:# raise pending exception if any; 133, if_statement; 134, call; 135, identifier:result; 136, identifier:source_quality; 137, identifier:CoverSourceQuality; 138, identifier:REFERENCE; 139, parenthesized_expression; 140, block; 141, attribute; 142, argument_list; 143, parenthesized_expression; 144, block; 145, call; 146, identifier:results; 147, identifier:no_dup_results; 148, call; 149, identifier:info; 150, binary_operator:"Removed %u duplicate results" % (dup_count); 151, call; 152, identifier:info; 153, binary_operator:"Reference is: %s" % (reference); 154, identifier:reference; 155, identifier:is_similar_to_reference; 156, assignment; 157, assignment; 158, call; 159, parenthesized_expression; 160, assignment; 161, assignment; 162, call; 163, await; 164, call; 165, parenthesized_expression; 166, block; 167, attribute; 168, argument_list; 169, boolean_operator; 170, expression_statement; 171, identifier:itertools; 172, identifier:filterfalse; 173, call; 174, identifier:results; 175, boolean_operator; 176, expression_statement; 177, break_statement; 178, attribute; 179, argument_list; 180, attribute; 181, argument_list; 182, string:"Removed %u duplicate results"; 183, parenthesized_expression; 184, attribute; 185, argument_list; 186, string:"Reference is: %s"; 187, parenthesized_expression; 188, identifier:coroutine; 189, call; 190, identifier:future; 191, call; 192, attribute; 193, argument_list; 194, comparison_operator:reference not in results; 195, identifier:coroutine; 196, call; 197, identifier:future; 198, call; 199, attribute; 200, argument_list; 201, call; 202, attribute; 203, argument_list; 204, boolean_operator; 205, expression_statement; 206, if_statement; 207, call; 208, identifier:warning; 209, string:"No reference result found"; 210, parenthesized_expression; 211, parenthesized_expression; 212, assignment; 213, attribute; 214, argument_list; 215, boolean_operator; 216, parenthesized_expression; 217, assignment; 218, identifier:no_dup_results; 219, identifier:append; 220, identifier:result; 221, identifier:logging; 222, identifier:getLogger; 223, string:"Cover"; 224, identifier:dup_count; 225, identifier:logging; 226, identifier:getLogger; 227, string:"Cover"; 228, identifier:reference; 229, attribute; 230, argument_list; 231, attribute; 232, argument_list; 233, identifier:futures; 234, identifier:append; 235, identifier:future; 236, identifier:reference; 237, identifier:results; 238, attribute; 239, argument_list; 240, attribute; 241, argument_list; 242, identifier:futures; 243, identifier:append; 244, identifier:future; 245, attribute; 246, argument_list; 247, identifier:future; 248, identifier:result; 249, boolean_operator; 250, parenthesized_expression; 251, assignment; 252, attribute; 253, block; 254, else_clause; 255, attribute; 256, argument_list; 257, comparison_operator:reference is None; 258, comparison_operator:CoverSourceResult.compare(result,
reference,
target_size=target_size,
size_tolerance_prct=size_tolerance_prct) > 0; 259, identifier:reference; 260, identifier:result; 261, identifier:operator; 262, identifier:attrgetter; 263, string:"is_only_reference"; 264, parenthesized_expression; 265, parenthesized_expression; 266, comparison_operator:__class__.compare(result,
result_comp,
target_size=target_size,
size_tolerance_prct=size_tolerance_prct) < 0; 267, identifier:is_dup; 268, True; 269, identifier:result; 270, identifier:updateSignature; 271, identifier:asyncio; 272, identifier:ensure_future; 273, identifier:coroutine; 274, identifier:reference; 275, identifier:updateSignature; 276, identifier:asyncio; 277, identifier:ensure_future; 278, identifier:coroutine; 279, identifier:asyncio; 280, identifier:wait; 281, identifier:futures; 282, parenthesized_expression; 283, parenthesized_expression; 284, comparison_operator:reference.thumbnail_sig is not None; 285, attribute; 286, call; 287, identifier:result; 288, identifier:is_similar_to_reference; 289, expression_statement; 290, block; 291, identifier:logging; 292, identifier:getLogger; 293, string:"Cover"; 294, identifier:reference; 295, None; 296, call; 297, integer:0; 298, comparison_operator:result_comp is not result; 299, comparison_operator:result_comp.urls == result.urls; 300, call; 301, integer:0; 302, comparison_operator:result is not reference; 303, comparison_operator:result.thumbnail_sig is not None; 304, attribute; 305, None; 306, identifier:result; 307, identifier:is_similar_to_reference; 308, attribute; 309, argument_list; 310, call; 311, expression_statement; 312, attribute; 313, argument_list; 314, identifier:result_comp; 315, identifier:result; 316, attribute; 317, attribute; 318, attribute; 319, argument_list; 320, identifier:result; 321, identifier:reference; 322, attribute; 323, None; 324, identifier:reference; 325, identifier:thumbnail_sig; 326, identifier:__class__; 327, identifier:areImageSigsSimilar; 328, attribute; 329, attribute; 330, attribute; 331, argument_list; 332, call; 333, identifier:CoverSourceResult; 334, identifier:compare; 335, identifier:result; 336, identifier:reference; 337, keyword_argument; 338, keyword_argument; 339, identifier:result_comp; 340, identifier:urls; 341, identifier:result; 342, identifier:urls; 343, identifier:__class__; 344, identifier:compare; 345, identifier:result; 346, identifier:result_comp; 347, keyword_argument; 348, keyword_argument; 349, identifier:result; 350, identifier:thumbnail_sig; 351, identifier:result; 352, identifier:thumbnail_sig; 353, identifier:reference; 354, identifier:thumbnail_sig; 355, call; 356, identifier:debug; 357, binary_operator:"%s is similar to reference" % (result); 358, attribute; 359, argument_list; 360, identifier:target_size; 361, identifier:target_size; 362, identifier:size_tolerance_prct; 363, identifier:size_tolerance_prct; 364, identifier:target_size; 365, identifier:target_size; 366, identifier:size_tolerance_prct; 367, identifier:size_tolerance_prct; 368, attribute; 369, argument_list; 370, string:"%s is similar to reference"; 371, parenthesized_expression; 372, call; 373, identifier:debug; 374, binary_operator:"%s is NOT similar to reference" % (result); 375, identifier:logging; 376, identifier:getLogger; 377, string:"Cover"; 378, identifier:result; 379, attribute; 380, argument_list; 381, string:"%s is NOT similar to reference"; 382, parenthesized_expression; 383, identifier:logging; 384, identifier:getLogger; 385, string:"Cover"; 386, identifier:result | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 8, 21; 10, 22; 11, 23; 11, 24; 11, 25; 13, 26; 15, 27; 16, 28; 16, 29; 16, 30; 17, 31; 18, 32; 18, 33; 19, 34; 19, 35; 19, 36; 20, 37; 22, 38; 22, 39; 25, 40; 26, 41; 26, 42; 27, 43; 27, 44; 30, 45; 30, 46; 30, 47; 31, 48; 31, 49; 32, 50; 32, 51; 33, 52; 33, 53; 34, 54; 34, 55; 35, 56; 35, 57; 35, 58; 35, 59; 35, 60; 35, 61; 35, 62; 35, 63; 35, 64; 35, 65; 36, 66; 40, 67; 40, 68; 42, 69; 42, 70; 45, 71; 46, 72; 46, 73; 46, 74; 47, 75; 47, 76; 49, 77; 49, 78; 52, 79; 53, 80; 56, 81; 57, 82; 59, 83; 60, 84; 60, 85; 60, 86; 61, 87; 61, 88; 62, 89; 62, 90; 63, 91; 63, 92; 63, 93; 65, 94; 65, 95; 65, 96; 66, 97; 67, 98; 67, 99; 68, 100; 70, 101; 71, 102; 71, 103; 74, 104; 75, 105; 76, 106; 77, 107; 77, 108; 78, 109; 78, 110; 79, 111; 79, 112; 80, 113; 80, 114; 81, 115; 81, 116; 82, 117; 82, 118; 83, 119; 83, 120; 86, 121; 86, 122; 86, 123; 87, 124; 87, 125; 88, 126; 88, 127; 88, 128; 88, 129; 90, 130; 93, 131; 93, 132; 96, 133; 97, 134; 98, 135; 98, 136; 99, 137; 99, 138; 100, 139; 100, 140; 101, 141; 101, 142; 104, 143; 104, 144; 106, 145; 108, 146; 110, 147; 111, 148; 111, 149; 112, 150; 115, 151; 115, 152; 116, 153; 117, 154; 117, 155; 121, 156; 122, 157; 123, 158; 126, 159; 127, 160; 128, 161; 129, 162; 130, 163; 131, 164; 133, 165; 133, 166; 134, 167; 134, 168; 139, 169; 140, 170; 141, 171; 141, 172; 142, 173; 142, 174; 143, 175; 144, 176; 144, 177; 145, 178; 145, 179; 148, 180; 148, 181; 150, 182; 150, 183; 151, 184; 151, 185; 153, 186; 153, 187; 156, 188; 156, 189; 157, 190; 157, 191; 158, 192; 158, 193; 159, 194; 160, 195; 160, 196; 161, 197; 161, 198; 162, 199; 162, 200; 163, 201; 164, 202; 164, 203; 165, 204; 166, 205; 166, 206; 167, 207; 167, 208; 168, 209; 169, 210; 169, 211; 170, 212; 173, 213; 173, 214; 175, 215; 175, 216; 176, 217; 178, 218; 178, 219; 179, 220; 180, 221; 180, 222; 181, 223; 183, 224; 184, 225; 184, 226; 185, 227; 187, 228; 189, 229; 189, 230; 191, 231; 191, 232; 192, 233; 192, 234; 193, 235; 194, 236; 194, 237; 196, 238; 196, 239; 198, 240; 198, 241; 199, 242; 199, 243; 200, 244; 201, 245; 201, 246; 202, 247; 202, 248; 204, 249; 204, 250; 205, 251; 206, 252; 206, 253; 206, 254; 207, 255; 207, 256; 210, 257; 211, 258; 212, 259; 212, 260; 213, 261; 213, 262; 214, 263; 215, 264; 215, 265; 216, 266; 217, 267; 217, 268; 229, 269; 229, 270; 231, 271; 231, 272; 232, 273; 238, 274; 238, 275; 240, 276; 240, 277; 241, 278; 245, 279; 245, 280; 246, 281; 249, 282; 249, 283; 250, 284; 251, 285; 251, 286; 252, 287; 252, 288; 253, 289; 254, 290; 255, 291; 255, 292; 256, 293; 257, 294; 257, 295; 258, 296; 258, 297; 264, 298; 265, 299; 266, 300; 266, 301; 282, 302; 283, 303; 284, 304; 284, 305; 285, 306; 285, 307; 286, 308; 286, 309; 289, 310; 290, 311; 296, 312; 296, 313; 298, 314; 298, 315; 299, 316; 299, 317; 300, 318; 300, 319; 302, 320; 302, 321; 303, 322; 303, 323; 304, 324; 304, 325; 308, 326; 308, 327; 309, 328; 309, 329; 310, 330; 310, 331; 311, 332; 312, 333; 312, 334; 313, 335; 313, 336; 313, 337; 313, 338; 316, 339; 316, 340; 317, 341; 317, 342; 318, 343; 318, 344; 319, 345; 319, 346; 319, 347; 319, 348; 322, 349; 322, 350; 328, 351; 328, 352; 329, 353; 329, 354; 330, 355; 330, 356; 331, 357; 332, 358; 332, 359; 337, 360; 337, 361; 338, 362; 338, 363; 347, 364; 347, 365; 348, 366; 348, 367; 355, 368; 355, 369; 357, 370; 357, 371; 358, 372; 358, 373; 359, 374; 368, 375; 368, 376; 369, 377; 371, 378; 372, 379; 372, 380; 374, 381; 374, 382; 379, 383; 379, 384; 380, 385; 382, 386 | async def preProcessForComparison(results, target_size, size_tolerance_prct):
""" Process results to prepare them for future comparison and sorting. """
# find reference (=image most likely to match target cover ignoring factors like size and format)
reference = None
for result in results:
if result.source_quality is CoverSourceQuality.REFERENCE:
if ((reference is None) or
(CoverSourceResult.compare(result,
reference,
target_size=target_size,
size_tolerance_prct=size_tolerance_prct) > 0)):
reference = result
# remove results that are only refs
results = list(itertools.filterfalse(operator.attrgetter("is_only_reference"), results))
# remove duplicates
no_dup_results = []
for result in results:
is_dup = False
for result_comp in results:
if ((result_comp is not result) and
(result_comp.urls == result.urls) and
(__class__.compare(result,
result_comp,
target_size=target_size,
size_tolerance_prct=size_tolerance_prct) < 0)):
is_dup = True
break
if not is_dup:
no_dup_results.append(result)
dup_count = len(results) - len(no_dup_results)
if dup_count > 0:
logging.getLogger("Cover").info("Removed %u duplicate results" % (dup_count))
results = no_dup_results
if reference is not None:
logging.getLogger("Cover").info("Reference is: %s" % (reference))
reference.is_similar_to_reference = True
# calculate sigs
futures = []
for result in results:
coroutine = result.updateSignature()
future = asyncio.ensure_future(coroutine)
futures.append(future)
if reference.is_only_reference:
assert(reference not in results)
coroutine = reference.updateSignature()
future = asyncio.ensure_future(coroutine)
futures.append(future)
if futures:
await asyncio.wait(futures)
for future in futures:
future.result() # raise pending exception if any
# compare other results to reference
for result in results:
if ((result is not reference) and
(result.thumbnail_sig is not None) and
(reference.thumbnail_sig is not None)):
result.is_similar_to_reference = __class__.areImageSigsSimilar(result.thumbnail_sig,
reference.thumbnail_sig)
if result.is_similar_to_reference:
logging.getLogger("Cover").debug("%s is similar to reference" % (result))
else:
logging.getLogger("Cover").debug("%s is NOT similar to reference" % (result))
else:
logging.getLogger("Cover").warning("No reference result found")
return results |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, return_statement; 11, identifier:order; 12, string:"asc"; 13, comment:"""Getting the sorted result of the given list
:@param order: "asc"
:@type order: string
:@return self
"""; 14, call; 15, call; 16, block; 17, identifier:self; 18, attribute; 19, argument_list; 20, identifier:isinstance; 21, argument_list; 22, if_statement; 23, identifier:self; 24, identifier:__prepare; 25, attribute; 26, identifier:list; 27, comparison_operator:order == "asc"; 28, block; 29, else_clause; 30, identifier:self; 31, identifier:_json_data; 32, identifier:order; 33, string:"asc"; 34, expression_statement; 35, block; 36, assignment; 37, expression_statement; 38, attribute; 39, call; 40, assignment; 41, identifier:self; 42, identifier:_json_data; 43, identifier:sorted; 44, argument_list; 45, attribute; 46, call; 47, attribute; 48, identifier:self; 49, identifier:_json_data; 50, identifier:sorted; 51, argument_list; 52, identifier:self; 53, identifier:_json_data; 54, attribute; 55, keyword_argument; 56, identifier:self; 57, identifier:_json_data; 58, identifier:reverse; 59, True | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 8, 14; 9, 15; 9, 16; 10, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 18, 23; 18, 24; 21, 25; 21, 26; 22, 27; 22, 28; 22, 29; 25, 30; 25, 31; 27, 32; 27, 33; 28, 34; 29, 35; 34, 36; 35, 37; 36, 38; 36, 39; 37, 40; 38, 41; 38, 42; 39, 43; 39, 44; 40, 45; 40, 46; 44, 47; 45, 48; 45, 49; 46, 50; 46, 51; 47, 52; 47, 53; 51, 54; 51, 55; 54, 56; 54, 57; 55, 58; 55, 59 | def sort(self, order="asc"):
"""Getting the sorted result of the given list
:@param order: "asc"
:@type order: string
:@return self
"""
self.__prepare()
if isinstance(self._json_data, list):
if order == "asc":
self._json_data = sorted(self._json_data)
else:
self._json_data = sorted(self._json_data, reverse=True)
return self |
0, module; 1, function_definition; 2, function_name:sort_by; 3, parameters; 4, block; 5, identifier:self; 6, identifier:property; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, return_statement; 12, identifier:order; 13, string:"asc"; 14, comment:"""Getting the sorted result by the given property
:@param property, order: "asc"
:@type property, order: string
:@return self
"""; 15, call; 16, call; 17, block; 18, identifier:self; 19, attribute; 20, argument_list; 21, identifier:isinstance; 22, argument_list; 23, if_statement; 24, identifier:self; 25, identifier:__prepare; 26, attribute; 27, identifier:list; 28, comparison_operator:order == "asc"; 29, block; 30, else_clause; 31, identifier:self; 32, identifier:_json_data; 33, identifier:order; 34, string:"asc"; 35, expression_statement; 36, block; 37, assignment; 38, expression_statement; 39, attribute; 40, call; 41, assignment; 42, identifier:self; 43, identifier:_json_data; 44, identifier:sorted; 45, argument_list; 46, attribute; 47, call; 48, attribute; 49, keyword_argument; 50, identifier:self; 51, identifier:_json_data; 52, identifier:sorted; 53, argument_list; 54, identifier:self; 55, identifier:_json_data; 56, identifier:key; 57, lambda; 58, attribute; 59, keyword_argument; 60, keyword_argument; 61, lambda_parameters; 62, call; 63, identifier:self; 64, identifier:_json_data; 65, identifier:key; 66, lambda; 67, identifier:reverse; 68, True; 69, identifier:x; 70, attribute; 71, argument_list; 72, lambda_parameters; 73, call; 74, identifier:x; 75, identifier:get; 76, identifier:property; 77, identifier:x; 78, attribute; 79, argument_list; 80, identifier:x; 81, identifier:get; 82, identifier:property | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 7, 13; 8, 14; 9, 15; 10, 16; 10, 17; 11, 18; 15, 19; 15, 20; 16, 21; 16, 22; 17, 23; 19, 24; 19, 25; 22, 26; 22, 27; 23, 28; 23, 29; 23, 30; 26, 31; 26, 32; 28, 33; 28, 34; 29, 35; 30, 36; 35, 37; 36, 38; 37, 39; 37, 40; 38, 41; 39, 42; 39, 43; 40, 44; 40, 45; 41, 46; 41, 47; 45, 48; 45, 49; 46, 50; 46, 51; 47, 52; 47, 53; 48, 54; 48, 55; 49, 56; 49, 57; 53, 58; 53, 59; 53, 60; 57, 61; 57, 62; 58, 63; 58, 64; 59, 65; 59, 66; 60, 67; 60, 68; 61, 69; 62, 70; 62, 71; 66, 72; 66, 73; 70, 74; 70, 75; 71, 76; 72, 77; 73, 78; 73, 79; 78, 80; 78, 81; 79, 82 | def sort_by(self, property, order="asc"):
"""Getting the sorted result by the given property
:@param property, order: "asc"
:@type property, order: string
:@return self
"""
self.__prepare()
if isinstance(self._json_data, list):
if order == "asc":
self._json_data = sorted(
self._json_data,
key=lambda x: x.get(property)
)
else:
self._json_data = sorted(
self._json_data,
key=lambda x: x.get(property),
reverse=True
)
return self |
0, module; 1, function_definition; 2, function_name:get; 3, parameters; 4, block; 5, identifier:dic; 6, identifier:path; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, try_statement; 13, identifier:seps; 14, identifier:PATH_SEPS; 15, identifier:idx_reg; 16, identifier:_JSNP_GET_ARRAY_IDX_REG; 17, comment:"""getter for nested dicts.
:param dic: a dict[-like] object
:param path: Path expression to point object wanted
:param seps: Separator char candidates
:return: A tuple of (result_object, error_message)
>>> d = {'a': {'b': {'c': 0, 'd': [1, 2]}}, '': 3}
>>> assert get(d, '/') == (3, '') # key becomes '' (empty string).
>>> assert get(d, "/a/b/c") == (0, '')
>>> sorted(get(d, "a.b")[0].items())
[('c', 0), ('d', [1, 2])]
>>> (get(d, "a.b.d"), get(d, "/a/b/d/1"))
(([1, 2], ''), (2, ''))
>>> get(d, "a.b.key_not_exist") # doctest: +ELLIPSIS
(None, "'...'")
>>> get(d, "/a/b/d/2")
(None, 'list index out of range')
>>> get(d, "/a/b/d/-") # doctest: +ELLIPSIS
(None, 'list indices must be integers...')
"""; 18, assignment; 19, not_operator; 20, block; 21, block; 22, except_clause; 23, identifier:items; 24, list_comprehension; 25, identifier:items; 26, return_statement; 27, if_statement; 28, expression_statement; 29, expression_statement; 30, return_statement; 31, as_pattern; 32, block; 33, call; 34, for_in_clause; 35, tuple; 36, comparison_operator:len(items) == 1; 37, block; 38, assignment; 39, assignment; 40, conditional_expression:(prnt[int(items[-1])], '') if arr else (prnt[items[-1]], ''); 41, tuple; 42, as_pattern_target; 43, return_statement; 44, identifier:_jsnp_unescape; 45, argument_list; 46, identifier:p; 47, call; 48, identifier:dic; 49, string; 50, call; 51, integer:1; 52, return_statement; 53, identifier:prnt; 54, call; 55, identifier:arr; 56, boolean_operator; 57, tuple; 58, identifier:arr; 59, tuple; 60, identifier:TypeError; 61, identifier:KeyError; 62, identifier:IndexError; 63, identifier:exc; 64, tuple; 65, identifier:p; 66, identifier:_split_path; 67, argument_list; 68, identifier:len; 69, argument_list; 70, tuple; 71, attribute; 72, argument_list; 73, call; 74, call; 75, subscript; 76, string; 77, subscript; 78, string; 79, None; 80, call; 81, identifier:path; 82, identifier:seps; 83, identifier:items; 84, subscript; 85, string; 86, identifier:functools; 87, identifier:reduce; 88, attribute; 89, subscript; 90, identifier:dic; 91, attribute; 92, argument_list; 93, attribute; 94, argument_list; 95, identifier:prnt; 96, call; 97, identifier:prnt; 98, subscript; 99, identifier:str; 100, argument_list; 101, identifier:dic; 102, subscript; 103, identifier:operator; 104, identifier:getitem; 105, identifier:items; 106, slice; 107, attribute; 108, identifier:is_list_like; 109, identifier:prnt; 110, identifier:idx_reg; 111, identifier:match; 112, subscript; 113, identifier:int; 114, argument_list; 115, identifier:items; 116, unary_operator; 117, identifier:exc; 118, identifier:items; 119, integer:0; 120, unary_operator; 121, identifier:anyconfig; 122, identifier:utils; 123, identifier:items; 124, unary_operator; 125, subscript; 126, integer:1; 127, integer:1; 128, integer:1; 129, identifier:items; 130, unary_operator; 131, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 7, 14; 8, 15; 8, 16; 9, 17; 10, 18; 11, 19; 11, 20; 12, 21; 12, 22; 18, 23; 18, 24; 19, 25; 20, 26; 21, 27; 21, 28; 21, 29; 21, 30; 22, 31; 22, 32; 24, 33; 24, 34; 26, 35; 27, 36; 27, 37; 28, 38; 29, 39; 30, 40; 31, 41; 31, 42; 32, 43; 33, 44; 33, 45; 34, 46; 34, 47; 35, 48; 35, 49; 36, 50; 36, 51; 37, 52; 38, 53; 38, 54; 39, 55; 39, 56; 40, 57; 40, 58; 40, 59; 41, 60; 41, 61; 41, 62; 42, 63; 43, 64; 45, 65; 47, 66; 47, 67; 50, 68; 50, 69; 52, 70; 54, 71; 54, 72; 56, 73; 56, 74; 57, 75; 57, 76; 59, 77; 59, 78; 64, 79; 64, 80; 67, 81; 67, 82; 69, 83; 70, 84; 70, 85; 71, 86; 71, 87; 72, 88; 72, 89; 72, 90; 73, 91; 73, 92; 74, 93; 74, 94; 75, 95; 75, 96; 77, 97; 77, 98; 80, 99; 80, 100; 84, 101; 84, 102; 88, 103; 88, 104; 89, 105; 89, 106; 91, 107; 91, 108; 92, 109; 93, 110; 93, 111; 94, 112; 96, 113; 96, 114; 98, 115; 98, 116; 100, 117; 102, 118; 102, 119; 106, 120; 107, 121; 107, 122; 112, 123; 112, 124; 114, 125; 116, 126; 120, 127; 124, 128; 125, 129; 125, 130; 130, 131 | def get(dic, path, seps=PATH_SEPS, idx_reg=_JSNP_GET_ARRAY_IDX_REG):
"""getter for nested dicts.
:param dic: a dict[-like] object
:param path: Path expression to point object wanted
:param seps: Separator char candidates
:return: A tuple of (result_object, error_message)
>>> d = {'a': {'b': {'c': 0, 'd': [1, 2]}}, '': 3}
>>> assert get(d, '/') == (3, '') # key becomes '' (empty string).
>>> assert get(d, "/a/b/c") == (0, '')
>>> sorted(get(d, "a.b")[0].items())
[('c', 0), ('d', [1, 2])]
>>> (get(d, "a.b.d"), get(d, "/a/b/d/1"))
(([1, 2], ''), (2, ''))
>>> get(d, "a.b.key_not_exist") # doctest: +ELLIPSIS
(None, "'...'")
>>> get(d, "/a/b/d/2")
(None, 'list index out of range')
>>> get(d, "/a/b/d/-") # doctest: +ELLIPSIS
(None, 'list indices must be integers...')
"""
items = [_jsnp_unescape(p) for p in _split_path(path, seps)]
if not items:
return (dic, '')
try:
if len(items) == 1:
return (dic[items[0]], '')
prnt = functools.reduce(operator.getitem, items[:-1], dic)
arr = anyconfig.utils.is_list_like(prnt) and idx_reg.match(items[-1])
return (prnt[int(items[-1])], '') if arr else (prnt[items[-1]], '')
except (TypeError, KeyError, IndexError) as exc:
return (None, str(exc)) |
0, module; 1, function_definition; 2, function_name:groupby; 3, parameters; 4, block; 5, identifier:itr; 6, default_parameter; 7, expression_statement; 8, return_statement; 9, identifier:key_fn; 10, None; 11, comment:"""
An wrapper function around itertools.groupby to sort each results.
:param itr: Iterable object, a list/tuple/genrator, etc.
:param key_fn: Key function to sort 'itr'.
>>> import operator
>>> itr = [("a", 1), ("b", -1), ("c", 1)]
>>> res = groupby(itr, operator.itemgetter(1))
>>> [(key, tuple(grp)) for key, grp in res]
[(-1, (('b', -1),)), (1, (('a', 1), ('c', 1)))]
"""; 12, call; 13, attribute; 14, argument_list; 15, identifier:itertools; 16, identifier:groupby; 17, call; 18, keyword_argument; 19, identifier:sorted; 20, argument_list; 21, identifier:key; 22, identifier:key_fn; 23, identifier:itr; 24, keyword_argument; 25, identifier:key; 26, identifier:key_fn | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 6, 9; 6, 10; 7, 11; 8, 12; 12, 13; 12, 14; 13, 15; 13, 16; 14, 17; 14, 18; 17, 19; 17, 20; 18, 21; 18, 22; 20, 23; 20, 24; 24, 25; 24, 26 | def groupby(itr, key_fn=None):
"""
An wrapper function around itertools.groupby to sort each results.
:param itr: Iterable object, a list/tuple/genrator, etc.
:param key_fn: Key function to sort 'itr'.
>>> import operator
>>> itr = [("a", 1), ("b", -1), ("c", 1)]
>>> res = groupby(itr, operator.itemgetter(1))
>>> [(key, tuple(grp)) for key, grp in res]
[(-1, (('b', -1),)), (1, (('a', 1), ('c', 1)))]
"""
return itertools.groupby(sorted(itr, key=key_fn), key=key_fn) |
0, module; 1, function_definition; 2, function_name:open; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, dictionary_splat_pattern; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, return_statement; 13, identifier:mode; 14, None; 15, identifier:ac_parser; 16, None; 17, identifier:options; 18, comment:"""
Open given configuration file with appropriate open flag.
:param path: Configuration file path
:param mode:
Can be 'r' and 'rb' for reading (default) or 'w', 'wb' for writing.
Please note that even if you specify 'r' or 'w', it will be changed to
'rb' or 'wb' if selected backend, xml and configobj for example, for
given config file prefer that.
:param options:
Optional keyword arguments passed to the internal file opening APIs of
each backends such like 'buffering' optional parameter passed to
builtin 'open' function.
:return: A file object or None on any errors
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""; 19, assignment; 20, boolean_operator; 21, block; 22, call; 23, identifier:psr; 24, call; 25, comparison_operator:mode is not None; 26, call; 27, return_statement; 28, attribute; 29, argument_list; 30, identifier:find; 31, argument_list; 32, identifier:mode; 33, None; 34, attribute; 35, argument_list; 36, call; 37, identifier:psr; 38, identifier:ropen; 39, identifier:path; 40, dictionary_splat; 41, identifier:path; 42, keyword_argument; 43, identifier:mode; 44, identifier:startswith; 45, string; 46, attribute; 47, argument_list; 48, identifier:options; 49, identifier:forced_type; 50, identifier:ac_parser; 51, string_content:w; 52, identifier:psr; 53, identifier:wopen; 54, identifier:path; 55, dictionary_splat; 56, identifier:options | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 6, 14; 7, 15; 7, 16; 8, 17; 9, 18; 10, 19; 11, 20; 11, 21; 12, 22; 19, 23; 19, 24; 20, 25; 20, 26; 21, 27; 22, 28; 22, 29; 24, 30; 24, 31; 25, 32; 25, 33; 26, 34; 26, 35; 27, 36; 28, 37; 28, 38; 29, 39; 29, 40; 31, 41; 31, 42; 34, 43; 34, 44; 35, 45; 36, 46; 36, 47; 40, 48; 42, 49; 42, 50; 45, 51; 46, 52; 46, 53; 47, 54; 47, 55; 55, 56 | def open(path, mode=None, ac_parser=None, **options):
"""
Open given configuration file with appropriate open flag.
:param path: Configuration file path
:param mode:
Can be 'r' and 'rb' for reading (default) or 'w', 'wb' for writing.
Please note that even if you specify 'r' or 'w', it will be changed to
'rb' or 'wb' if selected backend, xml and configobj for example, for
given config file prefer that.
:param options:
Optional keyword arguments passed to the internal file opening APIs of
each backends such like 'buffering' optional parameter passed to
builtin 'open' function.
:return: A file object or None on any errors
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""
psr = find(path, forced_type=ac_parser)
if mode is not None and mode.startswith('w'):
return psr.wopen(path, **options)
return psr.ropen(path, **options) |
0, module; 1, function_definition; 2, function_name:single_load; 3, parameters; 4, block; 5, identifier:input_; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, dictionary_splat_pattern; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, return_statement; 15, identifier:ac_parser; 16, None; 17, identifier:ac_template; 18, False; 19, identifier:ac_context; 20, None; 21, identifier:options; 22, comment:r"""
Load single configuration file.
.. note::
:func:`load` is a preferable alternative and this API should be used
only if there is a need to emphasize given input 'input\_' is single
one.
:param input\_:
File path or file or file-like object or pathlib.Path object represents
the file or a namedtuple 'anyconfig.globals.IOInfo' object represents
some input to load some data from
:param ac_parser: Forced parser type or parser object itself
:param ac_template:
Assume configuration file may be a template file and try to compile it
AAR if True
:param ac_context: A dict presents context to instantiate template
:param options: Optional keyword arguments such as:
- Options common in :func:`single_load`, :func:`multi_load`,
:func:`load` and :func:`loads`:
- ac_dict: callable (function or class) to make mapping objects from
loaded data if the selected backend can customize that such as JSON
which supports that with 'object_pairs_hook' option, or None. If
this option was not given or None, dict or
:class:`collections.OrderedDict` will be used to make result as
mapping object depends on if ac_ordered (see below) is True and
selected backend can keep the order of items loaded. See also
:meth:`_container_factory` of
:class:`anyconfig.backend.base.Parser` for more implementation
details.
- ac_ordered: True if you want to keep resuls ordered. Please note
that order of items may be lost depends on the selected backend.
- ac_schema: JSON schema file path to validate given config file
- ac_query: JMESPath expression to query data
- Common backend options:
- ac_ignore_missing:
Ignore and just return empty result if given file 'input\_' does
not exist actually.
- Backend specific options such as {"indent": 2} for JSON backend
:return: Mapping object
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""; 23, assignment; 24, assignment; 25, assignment; 26, call; 27, identifier:cnf; 28, call; 29, identifier:schema; 30, call; 31, identifier:cnf; 32, call; 33, attribute; 34, argument_list; 35, identifier:_single_load; 36, argument_list; 37, identifier:_maybe_schema; 38, argument_list; 39, identifier:_try_validate; 40, argument_list; 41, attribute; 42, identifier:query; 43, identifier:cnf; 44, dictionary_splat; 45, identifier:input_; 46, keyword_argument; 47, keyword_argument; 48, keyword_argument; 49, dictionary_splat; 50, keyword_argument; 51, keyword_argument; 52, dictionary_splat; 53, identifier:cnf; 54, identifier:schema; 55, dictionary_splat; 56, identifier:anyconfig; 57, identifier:query; 58, identifier:options; 59, identifier:ac_parser; 60, identifier:ac_parser; 61, identifier:ac_template; 62, identifier:ac_template; 63, identifier:ac_context; 64, identifier:ac_context; 65, identifier:options; 66, identifier:ac_template; 67, identifier:ac_template; 68, identifier:ac_context; 69, identifier:ac_context; 70, identifier:options; 71, identifier:options | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 6, 16; 7, 17; 7, 18; 8, 19; 8, 20; 9, 21; 10, 22; 11, 23; 12, 24; 13, 25; 14, 26; 23, 27; 23, 28; 24, 29; 24, 30; 25, 31; 25, 32; 26, 33; 26, 34; 28, 35; 28, 36; 30, 37; 30, 38; 32, 39; 32, 40; 33, 41; 33, 42; 34, 43; 34, 44; 36, 45; 36, 46; 36, 47; 36, 48; 36, 49; 38, 50; 38, 51; 38, 52; 40, 53; 40, 54; 40, 55; 41, 56; 41, 57; 44, 58; 46, 59; 46, 60; 47, 61; 47, 62; 48, 63; 48, 64; 49, 65; 50, 66; 50, 67; 51, 68; 51, 69; 52, 70; 55, 71 | def single_load(input_, ac_parser=None, ac_template=False,
ac_context=None, **options):
r"""
Load single configuration file.
.. note::
:func:`load` is a preferable alternative and this API should be used
only if there is a need to emphasize given input 'input\_' is single
one.
:param input\_:
File path or file or file-like object or pathlib.Path object represents
the file or a namedtuple 'anyconfig.globals.IOInfo' object represents
some input to load some data from
:param ac_parser: Forced parser type or parser object itself
:param ac_template:
Assume configuration file may be a template file and try to compile it
AAR if True
:param ac_context: A dict presents context to instantiate template
:param options: Optional keyword arguments such as:
- Options common in :func:`single_load`, :func:`multi_load`,
:func:`load` and :func:`loads`:
- ac_dict: callable (function or class) to make mapping objects from
loaded data if the selected backend can customize that such as JSON
which supports that with 'object_pairs_hook' option, or None. If
this option was not given or None, dict or
:class:`collections.OrderedDict` will be used to make result as
mapping object depends on if ac_ordered (see below) is True and
selected backend can keep the order of items loaded. See also
:meth:`_container_factory` of
:class:`anyconfig.backend.base.Parser` for more implementation
details.
- ac_ordered: True if you want to keep resuls ordered. Please note
that order of items may be lost depends on the selected backend.
- ac_schema: JSON schema file path to validate given config file
- ac_query: JMESPath expression to query data
- Common backend options:
- ac_ignore_missing:
Ignore and just return empty result if given file 'input\_' does
not exist actually.
- Backend specific options such as {"indent": 2} for JSON backend
:return: Mapping object
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""
cnf = _single_load(input_, ac_parser=ac_parser, ac_template=ac_template,
ac_context=ac_context, **options)
schema = _maybe_schema(ac_template=ac_template, ac_context=ac_context,
**options)
cnf = _try_validate(cnf, schema, **options)
return anyconfig.query.query(cnf, **options) |
0, module; 1, function_definition; 2, function_name:multi_load; 3, parameters; 4, block; 5, identifier:inputs; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, dictionary_splat_pattern; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, comment:# Avoid to load schema more than twice.; 15, expression_statement; 16, if_statement; 17, expression_statement; 18, for_statement; 19, if_statement; 20, expression_statement; 21, return_statement; 22, identifier:ac_parser; 23, None; 24, identifier:ac_template; 25, False; 26, identifier:ac_context; 27, None; 28, identifier:options; 29, comment:r"""
Load multiple config files.
.. note::
:func:`load` is a preferable alternative and this API should be used
only if there is a need to emphasize given inputs are multiple ones.
The first argument 'inputs' may be a list of a file paths or a glob pattern
specifying them or a pathlib.Path object represents file[s] or a namedtuple
'anyconfig.globals.IOInfo' object represents some inputs to load some data
from.
About glob patterns, for example, is, if a.yml, b.yml and c.yml are in the
dir /etc/foo/conf.d/, the followings give same results::
multi_load(["/etc/foo/conf.d/a.yml", "/etc/foo/conf.d/b.yml",
"/etc/foo/conf.d/c.yml", ])
multi_load("/etc/foo/conf.d/*.yml")
:param inputs:
A list of file path or a glob pattern such as r'/a/b/\*.json'to list of
files, file or file-like object or pathlib.Path object represents the
file or a namedtuple 'anyconfig.globals.IOInfo' object represents some
inputs to load some data from
:param ac_parser: Forced parser type or parser object
:param ac_template: Assume configuration file may be a template file and
try to compile it AAR if True
:param ac_context: Mapping object presents context to instantiate template
:param options: Optional keyword arguments:
- ac_dict, ac_ordered, ac_schema and ac_query are the options common in
:func:`single_load`, :func:`multi_load`, :func:`load`: and
:func:`loads`. See the descriptions of them in :func:`single_load`.
- Options specific to this function and :func:`load`:
- ac_merge (merge): Specify strategy of how to merge results loaded
from multiple configuration files. See the doc of
:mod:`anyconfig.dicts` for more details of strategies. The default
is anyconfig.dicts.MS_DICTS.
- ac_marker (marker): Globbing marker to detect paths patterns.
- Common backend options:
- ignore_missing: Ignore and just return empty result if given file
'path' does not exist.
- Backend specific options such as {"indent": 2} for JSON backend
:return: Mapping object or any query result might be primitive objects
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, call; 35, block; 36, assignment; 37, identifier:path; 38, identifier:paths; 39, block; 40, comparison_operator:cnf is None; 41, block; 42, assignment; 43, call; 44, identifier:marker; 45, call; 46, identifier:schema; 47, call; 48, subscript; 49, None; 50, identifier:paths; 51, call; 52, attribute; 53, argument_list; 54, expression_statement; 55, identifier:cnf; 56, identifier:ac_context; 57, expression_statement; 58, expression_statement; 59, if_statement; 60, identifier:cnf; 61, None; 62, return_statement; 63, identifier:cnf; 64, call; 65, attribute; 66, argument_list; 67, attribute; 68, argument_list; 69, identifier:_maybe_schema; 70, argument_list; 71, identifier:options; 72, string:"ac_schema"; 73, attribute; 74, argument_list; 75, attribute; 76, identifier:are_same_file_types; 77, identifier:paths; 78, assignment; 79, assignment; 80, assignment; 81, identifier:cups; 82, block; 83, call; 84, identifier:_try_validate; 85, argument_list; 86, attribute; 87, identifier:query; 88, identifier:cnf; 89, dictionary_splat; 90, identifier:options; 91, identifier:setdefault; 92, string:"ac_marker"; 93, call; 94, keyword_argument; 95, keyword_argument; 96, dictionary_splat; 97, attribute; 98, identifier:expand_paths; 99, identifier:inputs; 100, keyword_argument; 101, identifier:anyconfig; 102, identifier:utils; 103, identifier:ac_parser; 104, call; 105, identifier:opts; 106, call; 107, identifier:cups; 108, call; 109, if_statement; 110, attribute; 111, argument_list; 112, identifier:cnf; 113, identifier:schema; 114, dictionary_splat; 115, identifier:anyconfig; 116, identifier:query; 117, identifier:options; 118, attribute; 119, argument_list; 120, identifier:ac_template; 121, identifier:ac_template; 122, identifier:ac_context; 123, identifier:ac_context; 124, identifier:options; 125, identifier:anyconfig; 126, identifier:utils; 127, identifier:marker; 128, identifier:marker; 129, identifier:find; 130, argument_list; 131, attribute; 132, argument_list; 133, identifier:_single_load; 134, argument_list; 135, comparison_operator:cnf is None; 136, block; 137, else_clause; 138, attribute; 139, identifier:convert_to; 140, dictionary; 141, dictionary_splat; 142, identifier:options; 143, identifier:options; 144, identifier:get; 145, string:"marker"; 146, string; 147, subscript; 148, keyword_argument; 149, identifier:options; 150, identifier:copy; 151, identifier:path; 152, keyword_argument; 153, keyword_argument; 154, keyword_argument; 155, dictionary_splat; 156, identifier:cnf; 157, None; 158, expression_statement; 159, block; 160, identifier:anyconfig; 161, identifier:dicts; 162, identifier:options; 163, string_content:*; 164, identifier:paths; 165, integer:0; 166, identifier:forced_type; 167, identifier:ac_parser; 168, identifier:ac_parser; 169, identifier:ac_parser; 170, identifier:ac_template; 171, identifier:ac_template; 172, identifier:ac_context; 173, identifier:cnf; 174, identifier:opts; 175, assignment; 176, expression_statement; 177, identifier:cnf; 178, identifier:cups; 179, call; 180, identifier:merge; 181, argument_list; 182, identifier:cnf; 183, identifier:cups; 184, dictionary_splat; 185, identifier:options | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 6, 22; 6, 23; 7, 24; 7, 25; 8, 26; 8, 27; 9, 28; 10, 29; 11, 30; 12, 31; 13, 32; 15, 33; 16, 34; 16, 35; 17, 36; 18, 37; 18, 38; 18, 39; 19, 40; 19, 41; 20, 42; 21, 43; 30, 44; 30, 45; 31, 46; 31, 47; 32, 48; 32, 49; 33, 50; 33, 51; 34, 52; 34, 53; 35, 54; 36, 55; 36, 56; 39, 57; 39, 58; 39, 59; 40, 60; 40, 61; 41, 62; 42, 63; 42, 64; 43, 65; 43, 66; 45, 67; 45, 68; 47, 69; 47, 70; 48, 71; 48, 72; 51, 73; 51, 74; 52, 75; 52, 76; 53, 77; 54, 78; 57, 79; 58, 80; 59, 81; 59, 82; 62, 83; 64, 84; 64, 85; 65, 86; 65, 87; 66, 88; 66, 89; 67, 90; 67, 91; 68, 92; 68, 93; 70, 94; 70, 95; 70, 96; 73, 97; 73, 98; 74, 99; 74, 100; 75, 101; 75, 102; 78, 103; 78, 104; 79, 105; 79, 106; 80, 107; 80, 108; 82, 109; 83, 110; 83, 111; 85, 112; 85, 113; 85, 114; 86, 115; 86, 116; 89, 117; 93, 118; 93, 119; 94, 120; 94, 121; 95, 122; 95, 123; 96, 124; 97, 125; 97, 126; 100, 127; 100, 128; 104, 129; 104, 130; 106, 131; 106, 132; 108, 133; 108, 134; 109, 135; 109, 136; 109, 137; 110, 138; 110, 139; 111, 140; 111, 141; 114, 142; 118, 143; 118, 144; 119, 145; 119, 146; 130, 147; 130, 148; 131, 149; 131, 150; 134, 151; 134, 152; 134, 153; 134, 154; 134, 155; 135, 156; 135, 157; 136, 158; 137, 159; 138, 160; 138, 161; 141, 162; 146, 163; 147, 164; 147, 165; 148, 166; 148, 167; 152, 168; 152, 169; 153, 170; 153, 171; 154, 172; 154, 173; 155, 174; 158, 175; 159, 176; 175, 177; 175, 178; 176, 179; 179, 180; 179, 181; 181, 182; 181, 183; 181, 184; 184, 185 | def multi_load(inputs, ac_parser=None, ac_template=False, ac_context=None,
**options):
r"""
Load multiple config files.
.. note::
:func:`load` is a preferable alternative and this API should be used
only if there is a need to emphasize given inputs are multiple ones.
The first argument 'inputs' may be a list of a file paths or a glob pattern
specifying them or a pathlib.Path object represents file[s] or a namedtuple
'anyconfig.globals.IOInfo' object represents some inputs to load some data
from.
About glob patterns, for example, is, if a.yml, b.yml and c.yml are in the
dir /etc/foo/conf.d/, the followings give same results::
multi_load(["/etc/foo/conf.d/a.yml", "/etc/foo/conf.d/b.yml",
"/etc/foo/conf.d/c.yml", ])
multi_load("/etc/foo/conf.d/*.yml")
:param inputs:
A list of file path or a glob pattern such as r'/a/b/\*.json'to list of
files, file or file-like object or pathlib.Path object represents the
file or a namedtuple 'anyconfig.globals.IOInfo' object represents some
inputs to load some data from
:param ac_parser: Forced parser type or parser object
:param ac_template: Assume configuration file may be a template file and
try to compile it AAR if True
:param ac_context: Mapping object presents context to instantiate template
:param options: Optional keyword arguments:
- ac_dict, ac_ordered, ac_schema and ac_query are the options common in
:func:`single_load`, :func:`multi_load`, :func:`load`: and
:func:`loads`. See the descriptions of them in :func:`single_load`.
- Options specific to this function and :func:`load`:
- ac_merge (merge): Specify strategy of how to merge results loaded
from multiple configuration files. See the doc of
:mod:`anyconfig.dicts` for more details of strategies. The default
is anyconfig.dicts.MS_DICTS.
- ac_marker (marker): Globbing marker to detect paths patterns.
- Common backend options:
- ignore_missing: Ignore and just return empty result if given file
'path' does not exist.
- Backend specific options such as {"indent": 2} for JSON backend
:return: Mapping object or any query result might be primitive objects
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""
marker = options.setdefault("ac_marker", options.get("marker", '*'))
schema = _maybe_schema(ac_template=ac_template, ac_context=ac_context,
**options)
options["ac_schema"] = None # Avoid to load schema more than twice.
paths = anyconfig.utils.expand_paths(inputs, marker=marker)
if anyconfig.utils.are_same_file_types(paths):
ac_parser = find(paths[0], forced_type=ac_parser)
cnf = ac_context
for path in paths:
opts = options.copy()
cups = _single_load(path, ac_parser=ac_parser,
ac_template=ac_template, ac_context=cnf, **opts)
if cups:
if cnf is None:
cnf = cups
else:
merge(cnf, cups, **options)
if cnf is None:
return anyconfig.dicts.convert_to({}, **options)
cnf = _try_validate(cnf, schema, **options)
return anyconfig.query.query(cnf, **options) |
0, module; 1, function_definition; 2, function_name:load; 3, parameters; 4, block; 5, identifier:path_specs; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, dictionary_splat_pattern; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, if_statement; 15, return_statement; 16, identifier:ac_parser; 17, None; 18, identifier:ac_dict; 19, None; 20, identifier:ac_template; 21, False; 22, identifier:ac_context; 23, None; 24, identifier:options; 25, comment:r"""
Load single or multiple config files or multiple config files specified in
given paths pattern or pathlib.Path object represents config files or a
namedtuple 'anyconfig.globals.IOInfo' object represents some inputs.
:param path_specs:
A list of file path or a glob pattern such as r'/a/b/\*.json'to list of
files, file or file-like object or pathlib.Path object represents the
file or a namedtuple 'anyconfig.globals.IOInfo' object represents some
inputs to load some data from.
:param ac_parser: Forced parser type or parser object
:param ac_dict:
callable (function or class) to make mapping object will be returned as
a result or None. If not given or ac_dict is None, default mapping
object used to store resutls is dict or
:class:`collections.OrderedDict` if ac_ordered is True and selected
backend can keep the order of items in mapping objects.
:param ac_template: Assume configuration file may be a template file and
try to compile it AAR if True
:param ac_context: A dict presents context to instantiate template
:param options:
Optional keyword arguments. See also the description of 'options' in
:func:`single_load` and :func:`multi_load`
:return: Mapping object or any query result might be primitive objects
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""; 26, assignment; 27, call; 28, block; 29, not_operator; 30, block; 31, call; 32, identifier:marker; 33, call; 34, attribute; 35, argument_list; 36, return_statement; 37, call; 38, raise_statement; 39, identifier:multi_load; 40, argument_list; 41, attribute; 42, argument_list; 43, attribute; 44, identifier:is_path_like_object; 45, identifier:path_specs; 46, identifier:marker; 47, call; 48, attribute; 49, argument_list; 50, call; 51, identifier:path_specs; 52, keyword_argument; 53, keyword_argument; 54, keyword_argument; 55, keyword_argument; 56, dictionary_splat; 57, identifier:options; 58, identifier:setdefault; 59, string:"ac_marker"; 60, call; 61, identifier:anyconfig; 62, identifier:utils; 63, identifier:single_load; 64, argument_list; 65, attribute; 66, identifier:is_paths; 67, identifier:path_specs; 68, identifier:marker; 69, identifier:ValueError; 70, argument_list; 71, identifier:ac_parser; 72, identifier:ac_parser; 73, identifier:ac_dict; 74, identifier:ac_dict; 75, identifier:ac_template; 76, identifier:ac_template; 77, identifier:ac_context; 78, identifier:ac_context; 79, identifier:options; 80, attribute; 81, argument_list; 82, identifier:path_specs; 83, keyword_argument; 84, keyword_argument; 85, keyword_argument; 86, keyword_argument; 87, dictionary_splat; 88, identifier:anyconfig; 89, identifier:utils; 90, binary_operator:"Possible invalid input %r" % path_specs; 91, identifier:options; 92, identifier:get; 93, string:"marker"; 94, string; 95, identifier:ac_parser; 96, identifier:ac_parser; 97, identifier:ac_dict; 98, identifier:ac_dict; 99, identifier:ac_template; 100, identifier:ac_template; 101, identifier:ac_context; 102, identifier:ac_context; 103, identifier:options; 104, string:"Possible invalid input %r"; 105, identifier:path_specs; 106, string_content:* | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 6, 16; 6, 17; 7, 18; 7, 19; 8, 20; 8, 21; 9, 22; 9, 23; 10, 24; 11, 25; 12, 26; 13, 27; 13, 28; 14, 29; 14, 30; 15, 31; 26, 32; 26, 33; 27, 34; 27, 35; 28, 36; 29, 37; 30, 38; 31, 39; 31, 40; 33, 41; 33, 42; 34, 43; 34, 44; 35, 45; 35, 46; 36, 47; 37, 48; 37, 49; 38, 50; 40, 51; 40, 52; 40, 53; 40, 54; 40, 55; 40, 56; 41, 57; 41, 58; 42, 59; 42, 60; 43, 61; 43, 62; 47, 63; 47, 64; 48, 65; 48, 66; 49, 67; 49, 68; 50, 69; 50, 70; 52, 71; 52, 72; 53, 73; 53, 74; 54, 75; 54, 76; 55, 77; 55, 78; 56, 79; 60, 80; 60, 81; 64, 82; 64, 83; 64, 84; 64, 85; 64, 86; 64, 87; 65, 88; 65, 89; 70, 90; 80, 91; 80, 92; 81, 93; 81, 94; 83, 95; 83, 96; 84, 97; 84, 98; 85, 99; 85, 100; 86, 101; 86, 102; 87, 103; 90, 104; 90, 105; 94, 106 | def load(path_specs, ac_parser=None, ac_dict=None, ac_template=False,
ac_context=None, **options):
r"""
Load single or multiple config files or multiple config files specified in
given paths pattern or pathlib.Path object represents config files or a
namedtuple 'anyconfig.globals.IOInfo' object represents some inputs.
:param path_specs:
A list of file path or a glob pattern such as r'/a/b/\*.json'to list of
files, file or file-like object or pathlib.Path object represents the
file or a namedtuple 'anyconfig.globals.IOInfo' object represents some
inputs to load some data from.
:param ac_parser: Forced parser type or parser object
:param ac_dict:
callable (function or class) to make mapping object will be returned as
a result or None. If not given or ac_dict is None, default mapping
object used to store resutls is dict or
:class:`collections.OrderedDict` if ac_ordered is True and selected
backend can keep the order of items in mapping objects.
:param ac_template: Assume configuration file may be a template file and
try to compile it AAR if True
:param ac_context: A dict presents context to instantiate template
:param options:
Optional keyword arguments. See also the description of 'options' in
:func:`single_load` and :func:`multi_load`
:return: Mapping object or any query result might be primitive objects
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""
marker = options.setdefault("ac_marker", options.get("marker", '*'))
if anyconfig.utils.is_path_like_object(path_specs, marker):
return single_load(path_specs, ac_parser=ac_parser, ac_dict=ac_dict,
ac_template=ac_template, ac_context=ac_context,
**options)
if not anyconfig.utils.is_paths(path_specs, marker):
raise ValueError("Possible invalid input %r" % path_specs)
return multi_load(path_specs, ac_parser=ac_parser, ac_dict=ac_dict,
ac_template=ac_template, ac_context=ac_context,
**options) |
0, module; 1, function_definition; 2, function_name:dump; 3, parameters; 4, block; 5, identifier:data; 6, identifier:out; 7, default_parameter; 8, dictionary_splat_pattern; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, identifier:ac_parser; 15, None; 16, identifier:options; 17, comment:"""
Save 'data' to 'out'.
:param data: A mapping object may have configurations data to dump
:param out:
An output file path, a file, a file-like object, :class:`pathlib.Path`
object represents the file or a namedtuple 'anyconfig.globals.IOInfo'
object represents output to dump some data to.
:param ac_parser: Forced parser type or parser object
:param options:
Backend specific optional arguments, e.g. {"indent": 2} for JSON
loader/dumper backend
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""; 18, assignment; 19, assignment; 20, call; 21, call; 22, identifier:ioi; 23, call; 24, identifier:psr; 25, call; 26, attribute; 27, argument_list; 28, attribute; 29, argument_list; 30, attribute; 31, argument_list; 32, identifier:find; 33, argument_list; 34, identifier:LOGGER; 35, identifier:info; 36, string:"Dumping: %s"; 37, attribute; 38, identifier:psr; 39, identifier:dump; 40, identifier:data; 41, identifier:ioi; 42, dictionary_splat; 43, attribute; 44, identifier:make; 45, identifier:out; 46, identifier:ioi; 47, keyword_argument; 48, identifier:ioi; 49, identifier:path; 50, identifier:options; 51, identifier:anyconfig; 52, identifier:ioinfo; 53, identifier:forced_type; 54, identifier:ac_parser | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 12, 20; 13, 21; 18, 22; 18, 23; 19, 24; 19, 25; 20, 26; 20, 27; 21, 28; 21, 29; 23, 30; 23, 31; 25, 32; 25, 33; 26, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 29, 42; 30, 43; 30, 44; 31, 45; 33, 46; 33, 47; 37, 48; 37, 49; 42, 50; 43, 51; 43, 52; 47, 53; 47, 54 | def dump(data, out, ac_parser=None, **options):
"""
Save 'data' to 'out'.
:param data: A mapping object may have configurations data to dump
:param out:
An output file path, a file, a file-like object, :class:`pathlib.Path`
object represents the file or a namedtuple 'anyconfig.globals.IOInfo'
object represents output to dump some data to.
:param ac_parser: Forced parser type or parser object
:param options:
Backend specific optional arguments, e.g. {"indent": 2} for JSON
loader/dumper backend
:raises: ValueError, UnknownProcessorTypeError, UnknownFileTypeError
"""
ioi = anyconfig.ioinfo.make(out)
psr = find(ioi, forced_type=ac_parser)
LOGGER.info("Dumping: %s", ioi.path)
psr.dump(data, ioi, **options) |
0, module; 1, function_definition; 2, function_name:dumps; 3, parameters; 4, block; 5, identifier:data; 6, default_parameter; 7, dictionary_splat_pattern; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, identifier:ac_parser; 12, None; 13, identifier:options; 14, comment:"""
Return string representation of 'data' in forced type format.
:param data: Config data object to dump
:param ac_parser: Forced parser type or ID or parser object
:param options: see :func:`dump`
:return: Backend-specific string representation for the given data
:raises: ValueError, UnknownProcessorTypeError
"""; 15, assignment; 16, call; 17, identifier:psr; 18, call; 19, attribute; 20, argument_list; 21, identifier:find; 22, argument_list; 23, identifier:psr; 24, identifier:dumps; 25, identifier:data; 26, dictionary_splat; 27, None; 28, keyword_argument; 29, identifier:options; 30, identifier:forced_type; 31, identifier:ac_parser | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 15, 17; 15, 18; 16, 19; 16, 20; 18, 21; 18, 22; 19, 23; 19, 24; 20, 25; 20, 26; 22, 27; 22, 28; 26, 29; 28, 30; 28, 31 | def dumps(data, ac_parser=None, **options):
"""
Return string representation of 'data' in forced type format.
:param data: Config data object to dump
:param ac_parser: Forced parser type or ID or parser object
:param options: see :func:`dump`
:return: Backend-specific string representation for the given data
:raises: ValueError, UnknownProcessorTypeError
"""
psr = find(None, forced_type=ac_parser)
return psr.dumps(data, **options) |
0, module; 1, function_definition; 2, function_name:sort_response; 3, parameters; 4, type; 5, block; 6, typed_parameter; 7, identifier:OrderedDict; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, if_statement; 13, return_statement; 14, identifier:response; 15, type; 16, comment:"""
Sort the keys in a JSON-RPC response object.
This has no effect other than making it nicer to read. Useful in Python 3.5 only,
dictionaries are already sorted in newer Python versions.
Example::
>>> json.dumps(sort_response({'id': 2, 'result': 5, 'jsonrpc': '2.0'}))
{"jsonrpc": "2.0", "result": 5, "id": 1}
Args:
response: Deserialized JSON-RPC response.
Returns:
The same response, sorted in an OrderedDict.
"""; 17, assignment; 18, assignment; 19, assignment; 20, comparison_operator:"error" in response; 21, block; 22, identifier:req; 23, generic_type; 24, identifier:root_order; 25, list; 26, identifier:error_order; 27, list; 28, identifier:req; 29, call; 30, string:"error"; 31, identifier:response; 32, expression_statement; 33, identifier:Dict; 34, type_parameter; 35, string:"jsonrpc"; 36, string:"result"; 37, string:"error"; 38, string:"id"; 39, string:"code"; 40, string:"message"; 41, string:"data"; 42, identifier:OrderedDict; 43, argument_list; 44, assignment; 45, type; 46, type; 47, call; 48, subscript; 49, call; 50, identifier:str; 51, identifier:Any; 52, identifier:sorted; 53, argument_list; 54, identifier:req; 55, string:"error"; 56, identifier:OrderedDict; 57, argument_list; 58, call; 59, keyword_argument; 60, call; 61, attribute; 62, argument_list; 63, identifier:key; 64, lambda; 65, identifier:sorted; 66, argument_list; 67, identifier:response; 68, identifier:items; 69, lambda_parameters; 70, call; 71, call; 72, keyword_argument; 73, identifier:k; 74, attribute; 75, argument_list; 76, attribute; 77, argument_list; 78, identifier:key; 79, lambda; 80, identifier:root_order; 81, identifier:index; 82, subscript; 83, subscript; 84, identifier:items; 85, lambda_parameters; 86, call; 87, identifier:k; 88, integer:0; 89, identifier:response; 90, string:"error"; 91, identifier:k; 92, attribute; 93, argument_list; 94, identifier:error_order; 95, identifier:index; 96, subscript; 97, identifier:k; 98, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 4, 7; 5, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 6, 14; 6, 15; 8, 16; 9, 17; 10, 18; 11, 19; 12, 20; 12, 21; 13, 22; 15, 23; 17, 24; 17, 25; 18, 26; 18, 27; 19, 28; 19, 29; 20, 30; 20, 31; 21, 32; 23, 33; 23, 34; 25, 35; 25, 36; 25, 37; 25, 38; 27, 39; 27, 40; 27, 41; 29, 42; 29, 43; 32, 44; 34, 45; 34, 46; 43, 47; 44, 48; 44, 49; 45, 50; 46, 51; 47, 52; 47, 53; 48, 54; 48, 55; 49, 56; 49, 57; 53, 58; 53, 59; 57, 60; 58, 61; 58, 62; 59, 63; 59, 64; 60, 65; 60, 66; 61, 67; 61, 68; 64, 69; 64, 70; 66, 71; 66, 72; 69, 73; 70, 74; 70, 75; 71, 76; 71, 77; 72, 78; 72, 79; 74, 80; 74, 81; 75, 82; 76, 83; 76, 84; 79, 85; 79, 86; 82, 87; 82, 88; 83, 89; 83, 90; 85, 91; 86, 92; 86, 93; 92, 94; 92, 95; 93, 96; 96, 97; 96, 98 | def sort_response(response: Dict[str, Any]) -> OrderedDict:
"""
Sort the keys in a JSON-RPC response object.
This has no effect other than making it nicer to read. Useful in Python 3.5 only,
dictionaries are already sorted in newer Python versions.
Example::
>>> json.dumps(sort_response({'id': 2, 'result': 5, 'jsonrpc': '2.0'}))
{"jsonrpc": "2.0", "result": 5, "id": 1}
Args:
response: Deserialized JSON-RPC response.
Returns:
The same response, sorted in an OrderedDict.
"""
root_order = ["jsonrpc", "result", "error", "id"]
error_order = ["code", "message", "data"]
req = OrderedDict(sorted(response.items(), key=lambda k: root_order.index(k[0])))
if "error" in response:
req["error"] = OrderedDict(
sorted(response["error"].items(), key=lambda k: error_order.index(k[0]))
)
return req |
0, module; 1, function_definition; 2, function_name:sort_request; 3, parameters; 4, type; 5, block; 6, typed_parameter; 7, identifier:OrderedDict; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, identifier:request; 12, type; 13, comment:"""
Sort a JSON-RPC request dict.
This has no effect other than making the request nicer to read.
>>> json.dumps(sort_request(
... {'id': 2, 'params': [2, 3], 'method': 'add', 'jsonrpc': '2.0'}))
'{"jsonrpc": "2.0", "method": "add", "params": [2, 3], "id": 2}'
Args:
request: JSON-RPC request in dict format.
"""; 14, assignment; 15, call; 16, generic_type; 17, identifier:sort_order; 18, list; 19, identifier:OrderedDict; 20, argument_list; 21, identifier:Dict; 22, type_parameter; 23, string:"jsonrpc"; 24, string:"method"; 25, string:"params"; 26, string:"id"; 27, call; 28, type; 29, type; 30, identifier:sorted; 31, argument_list; 32, identifier:str; 33, identifier:Any; 34, call; 35, keyword_argument; 36, attribute; 37, argument_list; 38, identifier:key; 39, lambda; 40, identifier:request; 41, identifier:items; 42, lambda_parameters; 43, call; 44, identifier:k; 45, attribute; 46, argument_list; 47, identifier:sort_order; 48, identifier:index; 49, subscript; 50, identifier:k; 51, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 4, 7; 5, 8; 5, 9; 5, 10; 6, 11; 6, 12; 8, 13; 9, 14; 10, 15; 12, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 18, 23; 18, 24; 18, 25; 18, 26; 20, 27; 22, 28; 22, 29; 27, 30; 27, 31; 28, 32; 29, 33; 31, 34; 31, 35; 34, 36; 34, 37; 35, 38; 35, 39; 36, 40; 36, 41; 39, 42; 39, 43; 42, 44; 43, 45; 43, 46; 45, 47; 45, 48; 46, 49; 49, 50; 49, 51 | def sort_request(request: Dict[str, Any]) -> OrderedDict:
"""
Sort a JSON-RPC request dict.
This has no effect other than making the request nicer to read.
>>> json.dumps(sort_request(
... {'id': 2, 'params': [2, 3], 'method': 'add', 'jsonrpc': '2.0'}))
'{"jsonrpc": "2.0", "method": "add", "params": [2, 3], "id": 2}'
Args:
request: JSON-RPC request in dict format.
"""
sort_order = ["jsonrpc", "method", "params", "id"]
return OrderedDict(sorted(request.items(), key=lambda k: sort_order.index(k[0]))) |
0, module; 1, function_definition; 2, function_name:dump; 3, parameters; 4, block; 5, identifier:obj; 6, identifier:fp; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, if_statement; 13, expression_statement; 14, expression_statement; 15, identifier:container_count; 16, False; 17, identifier:sort_keys; 18, False; 19, identifier:no_float32; 20, True; 21, identifier:default; 22, None; 23, comment:"""Writes the given object as UBJSON to the provided file-like object
Args:
obj: The object to encode
fp: write([size])-able object
container_count (bool): Specify length for container types (including
for empty ones). This can aid decoding speed
depending on implementation but requires a bit
more space and encoding speed could be reduced
if getting length of any of the containers is
expensive.
sort_keys (bool): Sort keys of mappings
no_float32 (bool): Never use float32 to store float numbers (other than
for zero). Disabling this might save space at the
loss of precision.
default (callable): Called for objects which cannot be serialised.
Should return a UBJSON-encodable version of the
object or raise an EncoderException.
Raises:
EncoderException: If an encoding failure occured.
The following Python types and interfaces (ABCs) are supported (as are any
subclasses):
+------------------------------+-----------------------------------+
| Python | UBJSON |
+==============================+===================================+
| (3) str | string |
| (2) unicode | |
+------------------------------+-----------------------------------+
| None | null |
+------------------------------+-----------------------------------+
| bool | true, false |
+------------------------------+-----------------------------------+
| (3) int | uint8, int8, int16, int32, int64, |
| (2) int, long | high_precision |
+------------------------------+-----------------------------------+
| float | float32, float64, high_precision |
+------------------------------+-----------------------------------+
| Decimal | high_precision |
+------------------------------+-----------------------------------+
| (3) bytes, bytearray | array (type, uint8) |
| (2) str | array (type, uint8) |
+------------------------------+-----------------------------------+
| (3) collections.abc.Mapping | object |
| (2) collections.Mapping | |
+------------------------------+-----------------------------------+
| (3) collections.abc.Sequence | array |
| (2) collections.Sequence | |
+------------------------------+-----------------------------------+
Notes:
- Items are resolved in the order of this table, e.g. if the item implements
both Mapping and Sequence interfaces, it will be encoded as a mapping.
- None and bool do not use an isinstance check
- Numbers in brackets denote Python version.
- Only unicode strings in Python 2 are encoded as strings, i.e. for
compatibility with e.g. Python 3 one MUST NOT use str in Python 2 (as that
will be interpreted as a byte array).
- Mapping keys have to be strings: str for Python3 and unicode or str in
Python 2.
- float conversion rules (depending on no_float32 setting):
float32: 1.18e-38 <= abs(value) <= 3.4e38 or value == 0
float64: 2.23e-308 <= abs(value) < 1.8e308
For other values Decimal is used.
"""; 24, not_operator; 25, block; 26, assignment; 27, call; 28, call; 29, raise_statement; 30, identifier:fp_write; 31, attribute; 32, identifier:__encode_value; 33, argument_list; 34, identifier:callable; 35, argument_list; 36, call; 37, identifier:fp; 38, identifier:write; 39, identifier:fp_write; 40, identifier:obj; 41, dictionary; 42, identifier:container_count; 43, identifier:sort_keys; 44, identifier:no_float32; 45, identifier:default; 46, attribute; 47, identifier:TypeError; 48, argument_list; 49, identifier:fp; 50, identifier:write; 51, string; 52, string_content:fp.write not callable | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 7, 16; 8, 17; 8, 18; 9, 19; 9, 20; 10, 21; 10, 22; 11, 23; 12, 24; 12, 25; 13, 26; 14, 27; 24, 28; 25, 29; 26, 30; 26, 31; 27, 32; 27, 33; 28, 34; 28, 35; 29, 36; 31, 37; 31, 38; 33, 39; 33, 40; 33, 41; 33, 42; 33, 43; 33, 44; 33, 45; 35, 46; 36, 47; 36, 48; 46, 49; 46, 50; 48, 51; 51, 52 | def dump(obj, fp, container_count=False, sort_keys=False, no_float32=True, default=None):
"""Writes the given object as UBJSON to the provided file-like object
Args:
obj: The object to encode
fp: write([size])-able object
container_count (bool): Specify length for container types (including
for empty ones). This can aid decoding speed
depending on implementation but requires a bit
more space and encoding speed could be reduced
if getting length of any of the containers is
expensive.
sort_keys (bool): Sort keys of mappings
no_float32 (bool): Never use float32 to store float numbers (other than
for zero). Disabling this might save space at the
loss of precision.
default (callable): Called for objects which cannot be serialised.
Should return a UBJSON-encodable version of the
object or raise an EncoderException.
Raises:
EncoderException: If an encoding failure occured.
The following Python types and interfaces (ABCs) are supported (as are any
subclasses):
+------------------------------+-----------------------------------+
| Python | UBJSON |
+==============================+===================================+
| (3) str | string |
| (2) unicode | |
+------------------------------+-----------------------------------+
| None | null |
+------------------------------+-----------------------------------+
| bool | true, false |
+------------------------------+-----------------------------------+
| (3) int | uint8, int8, int16, int32, int64, |
| (2) int, long | high_precision |
+------------------------------+-----------------------------------+
| float | float32, float64, high_precision |
+------------------------------+-----------------------------------+
| Decimal | high_precision |
+------------------------------+-----------------------------------+
| (3) bytes, bytearray | array (type, uint8) |
| (2) str | array (type, uint8) |
+------------------------------+-----------------------------------+
| (3) collections.abc.Mapping | object |
| (2) collections.Mapping | |
+------------------------------+-----------------------------------+
| (3) collections.abc.Sequence | array |
| (2) collections.Sequence | |
+------------------------------+-----------------------------------+
Notes:
- Items are resolved in the order of this table, e.g. if the item implements
both Mapping and Sequence interfaces, it will be encoded as a mapping.
- None and bool do not use an isinstance check
- Numbers in brackets denote Python version.
- Only unicode strings in Python 2 are encoded as strings, i.e. for
compatibility with e.g. Python 3 one MUST NOT use str in Python 2 (as that
will be interpreted as a byte array).
- Mapping keys have to be strings: str for Python3 and unicode or str in
Python 2.
- float conversion rules (depending on no_float32 setting):
float32: 1.18e-38 <= abs(value) <= 3.4e38 or value == 0
float64: 2.23e-308 <= abs(value) < 1.8e308
For other values Decimal is used.
"""
if not callable(fp.write):
raise TypeError('fp.write not callable')
fp_write = fp.write
__encode_value(fp_write, obj, {}, container_count, sort_keys, no_float32, default) |
0, module; 1, function_definition; 2, function_name:torrents; 3, parameters; 4, block; 5, identifier:self; 6, dictionary_splat_pattern; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, identifier:filters; 12, comment:"""
Returns a list of torrents matching the supplied filters.
:param filter: Current status of the torrents.
:param category: Fetch all torrents with the supplied label.
:param sort: Sort torrents by.
:param reverse: Enable reverse sorting.
:param limit: Limit the number of torrents returned.
:param offset: Set offset (if less than 0, offset from end).
:return: list() of torrent with matching filter.
"""; 13, assignment; 14, pattern_list; 15, call; 16, comment:# make sure that old 'status' argument still works; 17, block; 18, call; 19, identifier:params; 20, dictionary; 21, identifier:name; 22, identifier:value; 23, attribute; 24, argument_list; 25, expression_statement; 26, expression_statement; 27, attribute; 28, argument_list; 29, identifier:filters; 30, identifier:items; 31, assignment; 32, assignment; 33, identifier:self; 34, identifier:_get; 35, string; 36, keyword_argument; 37, identifier:name; 38, conditional_expression:'filter' if name == 'status' else name; 39, subscript; 40, identifier:value; 41, string_content:query/torrents; 42, identifier:params; 43, identifier:params; 44, string; 45, comparison_operator:name == 'status'; 46, identifier:name; 47, identifier:params; 48, identifier:name; 49, string_content:filter; 50, identifier:name; 51, string; 52, string_content:status | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 9, 17; 10, 18; 13, 19; 13, 20; 14, 21; 14, 22; 15, 23; 15, 24; 17, 25; 17, 26; 18, 27; 18, 28; 23, 29; 23, 30; 25, 31; 26, 32; 27, 33; 27, 34; 28, 35; 28, 36; 31, 37; 31, 38; 32, 39; 32, 40; 35, 41; 36, 42; 36, 43; 38, 44; 38, 45; 38, 46; 39, 47; 39, 48; 44, 49; 45, 50; 45, 51; 51, 52 | def torrents(self, **filters):
"""
Returns a list of torrents matching the supplied filters.
:param filter: Current status of the torrents.
:param category: Fetch all torrents with the supplied label.
:param sort: Sort torrents by.
:param reverse: Enable reverse sorting.
:param limit: Limit the number of torrents returned.
:param offset: Set offset (if less than 0, offset from end).
:return: list() of torrent with matching filter.
"""
params = {}
for name, value in filters.items():
# make sure that old 'status' argument still works
name = 'filter' if name == 'status' else name
params[name] = value
return self._get('query/torrents', params=params) |
0, module; 1, function_definition; 2, function_name:_get_global_color_table; 3, parameters; 4, block; 5, identifier:colors; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, return_statement; 12, comment:"""Return a color table sorted in descending order of count.
"""; 13, assignment; 14, assignment; 15, assignment; 16, assignment; 17, binary_operator:global_color_table + zeros; 18, identifier:global_color_table; 19, call; 20, identifier:full_table_size; 21, binary_operator:2**(1+int(get_color_table_size(len(colors)), 2)); 22, identifier:repeats; 23, binary_operator:3 * (full_table_size - len(colors)); 24, identifier:zeros; 25, call; 26, identifier:global_color_table; 27, identifier:zeros; 28, attribute; 29, generator_expression; 30, integer:2; 31, parenthesized_expression; 32, integer:3; 33, parenthesized_expression; 34, attribute; 35, argument_list; 36, string; 37, identifier:join; 38, subscript; 39, for_in_clause; 40, binary_operator:1+int(get_color_table_size(len(colors)), 2); 41, binary_operator:full_table_size - len(colors); 42, identifier:struct; 43, identifier:pack; 44, call; 45, identifier:c; 46, integer:0; 47, identifier:c; 48, call; 49, integer:1; 50, call; 51, identifier:full_table_size; 52, call; 53, attribute; 54, argument_list; 55, attribute; 56, argument_list; 57, identifier:int; 58, argument_list; 59, identifier:len; 60, argument_list; 61, string; 62, identifier:format; 63, identifier:repeats; 64, identifier:colors; 65, identifier:most_common; 66, call; 67, integer:2; 68, identifier:colors; 69, string_content:<{}x; 70, identifier:get_color_table_size; 71, argument_list; 72, call; 73, identifier:len; 74, argument_list; 75, identifier:colors | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 11, 17; 13, 18; 13, 19; 14, 20; 14, 21; 15, 22; 15, 23; 16, 24; 16, 25; 17, 26; 17, 27; 19, 28; 19, 29; 21, 30; 21, 31; 23, 32; 23, 33; 25, 34; 25, 35; 28, 36; 28, 37; 29, 38; 29, 39; 31, 40; 33, 41; 34, 42; 34, 43; 35, 44; 38, 45; 38, 46; 39, 47; 39, 48; 40, 49; 40, 50; 41, 51; 41, 52; 44, 53; 44, 54; 48, 55; 48, 56; 50, 57; 50, 58; 52, 59; 52, 60; 53, 61; 53, 62; 54, 63; 55, 64; 55, 65; 58, 66; 58, 67; 60, 68; 61, 69; 66, 70; 66, 71; 71, 72; 72, 73; 72, 74; 74, 75 | def _get_global_color_table(colors):
"""Return a color table sorted in descending order of count.
"""
global_color_table = b''.join(c[0] for c in colors.most_common())
full_table_size = 2**(1+int(get_color_table_size(len(colors)), 2))
repeats = 3 * (full_table_size - len(colors))
zeros = struct.pack('<{}x'.format(repeats))
return global_color_table + zeros |
0, module; 1, function_definition; 2, function_name:good_sequences_to_track; 3, parameters; 4, block; 5, identifier:flow; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, for_statement; 11, function_definition; 12, function_definition; 13, function_definition; 14, expression_statement; 15, comment:# frames; 16, expression_statement; 17, for_statement; 18, return_statement; 19, identifier:motion_threshold; 20, float:1.0; 21, comment:"""Get list of good frames to do tracking in.
Looking at the optical flow, this function chooses a span of frames
that fulfill certain criteria.
These include
* not being too short or too long
* not too low or too high mean flow magnitude
* a low max value (avoids motion blur)
Currently, the cost function for a sequence is hard coded. Sorry about that.
Parameters
-------------
flow : ndarray
The optical flow magnitude
motion_threshold : float
The maximum amount of motion to consider for sequence endpoints.
Returns
------------
sequences : list
Sorted list of (a, b, score) elements (highest scpre first) of sequences
where a sequence is frames with frame indices in the span [a, b].
"""; 22, assignment; 23, assignment; 24, pattern_list; 25, call; 26, block; 27, function_name:mean_score_func; 28, parameters; 29, block; 30, function_name:max_score_func; 31, parameters; 32, block; 33, function_name:length_score_func; 34, parameters; 35, block; 36, assignment; 37, assignment; 38, pattern_list; 39, call; 40, block; 41, call; 42, identifier:endpoints; 43, list; 44, identifier:in_low; 45, False; 46, identifier:i; 47, identifier:val; 48, identifier:enumerate; 49, argument_list; 50, if_statement; 51, identifier:m; 52, expression_statement; 53, expression_statement; 54, expression_statement; 55, return_statement; 56, identifier:m; 57, expression_statement; 58, expression_statement; 59, if_statement; 60, identifier:l; 61, expression_statement; 62, expression_statement; 63, expression_statement; 64, return_statement; 65, identifier:min_length; 66, integer:5; 67, identifier:sequences; 68, list; 69, identifier:k; 70, identifier:i; 71, identifier:enumerate; 72, argument_list; 73, for_statement; 74, identifier:sorted; 75, argument_list; 76, identifier:flow; 77, comparison_operator:val < motion_threshold; 78, block; 79, else_clause; 80, assignment; 81, assignment; 82, assignment; 83, binary_operator:normpdf(m, mu, sigma) / top_val; 84, assignment; 85, assignment; 86, comparison_operator:m <= mu; 87, block; 88, else_clause; 89, assignment; 90, assignment; 91, assignment; 92, binary_operator:normpdf(l, mu, sigma) / top_val; 93, subscript; 94, identifier:j; 95, subscript; 96, block; 97, identifier:sequences; 98, keyword_argument; 99, keyword_argument; 100, identifier:val; 101, identifier:motion_threshold; 102, if_statement; 103, block; 104, identifier:mu; 105, integer:15; 106, identifier:sigma; 107, integer:8; 108, identifier:top_val; 109, call; 110, call; 111, identifier:top_val; 112, identifier:mu; 113, integer:40; 114, identifier:sigma; 115, integer:8; 116, identifier:m; 117, identifier:mu; 118, return_statement; 119, block; 120, identifier:mu; 121, integer:30; 122, identifier:sigma; 123, integer:10; 124, identifier:top_val; 125, call; 126, call; 127, identifier:top_val; 128, identifier:endpoints; 129, slice; 130, identifier:endpoints; 131, slice; 132, expression_statement; 133, if_statement; 134, expression_statement; 135, expression_statement; 136, expression_statement; 137, expression_statement; 138, expression_statement; 139, if_statement; 140, expression_statement; 141, expression_statement; 142, identifier:key; 143, lambda; 144, identifier:reverse; 145, True; 146, not_operator; 147, block; 148, if_statement; 149, expression_statement; 150, identifier:normpdf; 151, argument_list; 152, identifier:normpdf; 153, argument_list; 154, float:1.; 155, expression_statement; 156, return_statement; 157, identifier:normpdf; 158, argument_list; 159, identifier:normpdf; 160, argument_list; 161, unary_operator; 162, binary_operator:k+1; 163, assignment; 164, comparison_operator:length < min_length; 165, block; 166, assignment; 167, assignment; 168, assignment; 169, assignment; 170, call; 171, comparison_operator:min(m_score, mx_score, l_score) < 0.2; 172, block; 173, assignment; 174, call; 175, lambda_parameters; 176, subscript; 177, identifier:in_low; 178, expression_statement; 179, expression_statement; 180, identifier:in_low; 181, block; 182, assignment; 183, identifier:mu; 184, identifier:mu; 185, identifier:sigma; 186, identifier:m; 187, identifier:mu; 188, identifier:sigma; 189, assignment; 190, binary_operator:normpdf(m, mu, sigma) / top_val; 191, identifier:mu; 192, identifier:mu; 193, identifier:sigma; 194, identifier:l; 195, identifier:mu; 196, identifier:sigma; 197, integer:1; 198, identifier:k; 199, integer:1; 200, identifier:length; 201, binary_operator:j - i; 202, identifier:length; 203, identifier:min_length; 204, continue_statement; 205, identifier:seq; 206, subscript; 207, identifier:m_score; 208, call; 209, identifier:mx_score; 210, call; 211, identifier:l_score; 212, call; 213, attribute; 214, argument_list; 215, call; 216, float:0.2; 217, continue_statement; 218, identifier:score; 219, binary_operator:m_score + mx_score + l_score; 220, attribute; 221, argument_list; 222, identifier:x; 223, identifier:x; 224, integer:2; 225, call; 226, assignment; 227, expression_statement; 228, comment:# Previous was last in a low spot; 229, identifier:in_low; 230, False; 231, identifier:top_val; 232, call; 233, call; 234, identifier:top_val; 235, identifier:j; 236, identifier:i; 237, identifier:flow; 238, slice; 239, identifier:mean_score_func; 240, argument_list; 241, identifier:max_score_func; 242, argument_list; 243, identifier:length_score_func; 244, argument_list; 245, identifier:logger; 246, identifier:debug; 247, binary_operator:"%d, %d scores: (mean=%.5f, max=%.5f, length=%.5f)" % (i,j,m_score, mx_score, l_score); 248, identifier:min; 249, argument_list; 250, binary_operator:m_score + mx_score; 251, identifier:l_score; 252, identifier:sequences; 253, identifier:append; 254, tuple; 255, attribute; 256, argument_list; 257, identifier:in_low; 258, True; 259, call; 260, identifier:normpdf; 261, argument_list; 262, identifier:normpdf; 263, argument_list; 264, identifier:i; 265, binary_operator:j+1; 266, call; 267, call; 268, identifier:length; 269, string:"%d, %d scores: (mean=%.5f, max=%.5f, length=%.5f)"; 270, tuple; 271, identifier:m_score; 272, identifier:mx_score; 273, identifier:l_score; 274, identifier:m_score; 275, identifier:mx_score; 276, identifier:i; 277, identifier:j; 278, identifier:score; 279, identifier:endpoints; 280, identifier:append; 281, identifier:i; 282, attribute; 283, argument_list; 284, identifier:mu; 285, identifier:mu; 286, identifier:sigma; 287, identifier:m; 288, identifier:mu; 289, identifier:sigma; 290, identifier:j; 291, integer:1; 292, attribute; 293, argument_list; 294, attribute; 295, argument_list; 296, identifier:i; 297, identifier:j; 298, identifier:m_score; 299, identifier:mx_score; 300, identifier:l_score; 301, identifier:endpoints; 302, identifier:append; 303, binary_operator:i-1; 304, identifier:np; 305, identifier:mean; 306, identifier:seq; 307, identifier:np; 308, identifier:max; 309, identifier:seq; 310, identifier:i; 311, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 6, 19; 6, 20; 7, 21; 8, 22; 9, 23; 10, 24; 10, 25; 10, 26; 11, 27; 11, 28; 11, 29; 12, 30; 12, 31; 12, 32; 13, 33; 13, 34; 13, 35; 14, 36; 16, 37; 17, 38; 17, 39; 17, 40; 18, 41; 22, 42; 22, 43; 23, 44; 23, 45; 24, 46; 24, 47; 25, 48; 25, 49; 26, 50; 28, 51; 29, 52; 29, 53; 29, 54; 29, 55; 31, 56; 32, 57; 32, 58; 32, 59; 34, 60; 35, 61; 35, 62; 35, 63; 35, 64; 36, 65; 36, 66; 37, 67; 37, 68; 38, 69; 38, 70; 39, 71; 39, 72; 40, 73; 41, 74; 41, 75; 49, 76; 50, 77; 50, 78; 50, 79; 52, 80; 53, 81; 54, 82; 55, 83; 57, 84; 58, 85; 59, 86; 59, 87; 59, 88; 61, 89; 62, 90; 63, 91; 64, 92; 72, 93; 73, 94; 73, 95; 73, 96; 75, 97; 75, 98; 75, 99; 77, 100; 77, 101; 78, 102; 79, 103; 80, 104; 80, 105; 81, 106; 81, 107; 82, 108; 82, 109; 83, 110; 83, 111; 84, 112; 84, 113; 85, 114; 85, 115; 86, 116; 86, 117; 87, 118; 88, 119; 89, 120; 89, 121; 90, 122; 90, 123; 91, 124; 91, 125; 92, 126; 92, 127; 93, 128; 93, 129; 95, 130; 95, 131; 96, 132; 96, 133; 96, 134; 96, 135; 96, 136; 96, 137; 96, 138; 96, 139; 96, 140; 96, 141; 98, 142; 98, 143; 99, 144; 99, 145; 102, 146; 102, 147; 103, 148; 103, 149; 109, 150; 109, 151; 110, 152; 110, 153; 118, 154; 119, 155; 119, 156; 125, 157; 125, 158; 126, 159; 126, 160; 129, 161; 131, 162; 132, 163; 133, 164; 133, 165; 134, 166; 135, 167; 136, 168; 137, 169; 138, 170; 139, 171; 139, 172; 140, 173; 141, 174; 143, 175; 143, 176; 146, 177; 147, 178; 147, 179; 148, 180; 148, 181; 149, 182; 151, 183; 151, 184; 151, 185; 153, 186; 153, 187; 153, 188; 155, 189; 156, 190; 158, 191; 158, 192; 158, 193; 160, 194; 160, 195; 160, 196; 161, 197; 162, 198; 162, 199; 163, 200; 163, 201; 164, 202; 164, 203; 165, 204; 166, 205; 166, 206; 167, 207; 167, 208; 168, 209; 168, 210; 169, 211; 169, 212; 170, 213; 170, 214; 171, 215; 171, 216; 172, 217; 173, 218; 173, 219; 174, 220; 174, 221; 175, 222; 176, 223; 176, 224; 178, 225; 179, 226; 181, 227; 181, 228; 182, 229; 182, 230; 189, 231; 189, 232; 190, 233; 190, 234; 201, 235; 201, 236; 206, 237; 206, 238; 208, 239; 208, 240; 210, 241; 210, 242; 212, 243; 212, 244; 213, 245; 213, 246; 214, 247; 215, 248; 215, 249; 219, 250; 219, 251; 220, 252; 220, 253; 221, 254; 225, 255; 225, 256; 226, 257; 226, 258; 227, 259; 232, 260; 232, 261; 233, 262; 233, 263; 238, 264; 238, 265; 240, 266; 242, 267; 244, 268; 247, 269; 247, 270; 249, 271; 249, 272; 249, 273; 250, 274; 250, 275; 254, 276; 254, 277; 254, 278; 255, 279; 255, 280; 256, 281; 259, 282; 259, 283; 261, 284; 261, 285; 261, 286; 263, 287; 263, 288; 263, 289; 265, 290; 265, 291; 266, 292; 266, 293; 267, 294; 267, 295; 270, 296; 270, 297; 270, 298; 270, 299; 270, 300; 282, 301; 282, 302; 283, 303; 292, 304; 292, 305; 293, 306; 294, 307; 294, 308; 295, 309; 303, 310; 303, 311 | def good_sequences_to_track(flow, motion_threshold=1.0):
"""Get list of good frames to do tracking in.
Looking at the optical flow, this function chooses a span of frames
that fulfill certain criteria.
These include
* not being too short or too long
* not too low or too high mean flow magnitude
* a low max value (avoids motion blur)
Currently, the cost function for a sequence is hard coded. Sorry about that.
Parameters
-------------
flow : ndarray
The optical flow magnitude
motion_threshold : float
The maximum amount of motion to consider for sequence endpoints.
Returns
------------
sequences : list
Sorted list of (a, b, score) elements (highest scpre first) of sequences
where a sequence is frames with frame indices in the span [a, b].
"""
endpoints = []
in_low = False
for i, val in enumerate(flow):
if val < motion_threshold:
if not in_low:
endpoints.append(i)
in_low = True
else:
if in_low:
endpoints.append(i-1) # Previous was last in a low spot
in_low = False
def mean_score_func(m):
mu = 15
sigma = 8
top_val = normpdf(mu, mu, sigma)
return normpdf(m, mu, sigma) / top_val
def max_score_func(m):
mu = 40
sigma = 8
if m <= mu:
return 1.
else:
top_val = normpdf(mu, mu, sigma)
return normpdf(m, mu, sigma) / top_val
def length_score_func(l):
mu = 30
sigma = 10
top_val = normpdf(mu, mu, sigma)
return normpdf(l, mu, sigma) / top_val
min_length = 5 # frames
sequences = []
for k, i in enumerate(endpoints[:-1]):
for j in endpoints[k+1:]:
length = j - i
if length < min_length:
continue
seq = flow[i:j+1]
m_score = mean_score_func(np.mean(seq))
mx_score = max_score_func(np.max(seq))
l_score = length_score_func(length)
logger.debug("%d, %d scores: (mean=%.5f, max=%.5f, length=%.5f)" % (i,j,m_score, mx_score, l_score))
if min(m_score, mx_score, l_score) < 0.2:
continue
score = m_score + mx_score + l_score
sequences.append((i, j, score))
return sorted(sequences, key=lambda x: x[2], reverse=True) |
0, module; 1, function_definition; 2, function_name:_generate_comparator; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:field_names; 7, expression_statement; 8, comment:# Ensure that field names is a list and not a tuple.; 9, expression_statement; 10, comment:# For fields that start with a '-', reverse the ordering of the; 11, comment:# comparison.; 12, expression_statement; 13, for_statement; 14, expression_statement; 15, function_definition; 16, return_statement; 17, comment:"""
Construct a comparator function based on the field names. The comparator
returns the first non-zero comparison value.
Inputs:
field_names (iterable of strings): The field names to sort on.
Returns:
A comparator function.
"""; 18, assignment; 19, assignment; 20, pattern_list; 21, call; 22, block; 23, assignment; 24, function_name:comparator; 25, parameters; 26, comment:# Get a tuple of values for comparison.; 27, block; 28, identifier:comparator; 29, identifier:field_names; 30, call; 31, identifier:reverses; 32, binary_operator:[1] * len(field_names); 33, identifier:i; 34, identifier:field_name; 35, identifier:enumerate; 36, argument_list; 37, if_statement; 38, identifier:field_names; 39, list_comprehension; 40, identifier:i1; 41, identifier:i2; 42, expression_statement; 43, expression_statement; 44, comment:# If there's only one arg supplied, attrgetter returns a single; 45, comment:# item, directly return the result in this case.; 46, if_statement; 47, comment:# Compare each field for the two items, reversing if necessary.; 48, expression_statement; 49, try_statement; 50, identifier:list; 51, argument_list; 52, list; 53, call; 54, identifier:field_names; 55, comparison_operator:field_name[0] == '-'; 56, block; 57, call; 58, for_in_clause; 59, assignment; 60, assignment; 61, comparison_operator:len(field_names) == 1; 62, block; 63, assignment; 64, comment:# The first non-zero element.; 65, block; 66, except_clause; 67, identifier:field_names; 68, integer:1; 69, identifier:len; 70, argument_list; 71, subscript; 72, string; 73, expression_statement; 74, expression_statement; 75, attribute; 76, argument_list; 77, identifier:f; 78, identifier:field_names; 79, identifier:v1; 80, call; 81, identifier:v2; 82, call; 83, call; 84, integer:1; 85, return_statement; 86, identifier:order; 87, call; 88, return_statement; 89, identifier:StopIteration; 90, comment:# Everything was equivalent.; 91, block; 92, identifier:field_names; 93, identifier:field_name; 94, integer:0; 95, string_content:-; 96, assignment; 97, assignment; 98, identifier:f; 99, identifier:replace; 100, identifier:LOOKUP_SEP; 101, string; 102, call; 103, argument_list; 104, call; 105, argument_list; 106, identifier:len; 107, argument_list; 108, binary_operator:cls._cmp(v1, v2) * reverses[0]; 109, identifier:multiply_iterables; 110, argument_list; 111, call; 112, return_statement; 113, subscript; 114, unary_operator; 115, subscript; 116, subscript; 117, string_content:.; 118, identifier:attrgetter; 119, argument_list; 120, identifier:i1; 121, identifier:attrgetter; 122, argument_list; 123, identifier:i2; 124, identifier:field_names; 125, call; 126, subscript; 127, call; 128, identifier:reverses; 129, identifier:next; 130, argument_list; 131, integer:0; 132, identifier:reverses; 133, identifier:i; 134, integer:1; 135, identifier:field_names; 136, identifier:i; 137, identifier:field_name; 138, slice; 139, list_splat; 140, list_splat; 141, attribute; 142, argument_list; 143, identifier:reverses; 144, integer:0; 145, identifier:list; 146, argument_list; 147, call; 148, integer:1; 149, identifier:field_names; 150, identifier:field_names; 151, identifier:cls; 152, identifier:_cmp; 153, identifier:v1; 154, identifier:v2; 155, call; 156, identifier:dropwhile; 157, argument_list; 158, identifier:map; 159, argument_list; 160, identifier:__not__; 161, identifier:order; 162, attribute; 163, identifier:v1; 164, identifier:v2; 165, identifier:cls; 166, identifier:_cmp | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 7, 17; 9, 18; 12, 19; 13, 20; 13, 21; 13, 22; 14, 23; 15, 24; 15, 25; 15, 26; 15, 27; 16, 28; 18, 29; 18, 30; 19, 31; 19, 32; 20, 33; 20, 34; 21, 35; 21, 36; 22, 37; 23, 38; 23, 39; 25, 40; 25, 41; 27, 42; 27, 43; 27, 44; 27, 45; 27, 46; 27, 47; 27, 48; 27, 49; 30, 50; 30, 51; 32, 52; 32, 53; 36, 54; 37, 55; 37, 56; 39, 57; 39, 58; 42, 59; 43, 60; 46, 61; 46, 62; 48, 63; 49, 64; 49, 65; 49, 66; 51, 67; 52, 68; 53, 69; 53, 70; 55, 71; 55, 72; 56, 73; 56, 74; 57, 75; 57, 76; 58, 77; 58, 78; 59, 79; 59, 80; 60, 81; 60, 82; 61, 83; 61, 84; 62, 85; 63, 86; 63, 87; 65, 88; 66, 89; 66, 90; 66, 91; 70, 92; 71, 93; 71, 94; 72, 95; 73, 96; 74, 97; 75, 98; 75, 99; 76, 100; 76, 101; 80, 102; 80, 103; 82, 104; 82, 105; 83, 106; 83, 107; 85, 108; 87, 109; 87, 110; 88, 111; 91, 112; 96, 113; 96, 114; 97, 115; 97, 116; 101, 117; 102, 118; 102, 119; 103, 120; 104, 121; 104, 122; 105, 123; 107, 124; 108, 125; 108, 126; 110, 127; 110, 128; 111, 129; 111, 130; 112, 131; 113, 132; 113, 133; 114, 134; 115, 135; 115, 136; 116, 137; 116, 138; 119, 139; 122, 140; 125, 141; 125, 142; 126, 143; 126, 144; 127, 145; 127, 146; 130, 147; 138, 148; 139, 149; 140, 150; 141, 151; 141, 152; 142, 153; 142, 154; 146, 155; 147, 156; 147, 157; 155, 158; 155, 159; 157, 160; 157, 161; 159, 162; 159, 163; 159, 164; 162, 165; 162, 166 | def _generate_comparator(cls, field_names):
"""
Construct a comparator function based on the field names. The comparator
returns the first non-zero comparison value.
Inputs:
field_names (iterable of strings): The field names to sort on.
Returns:
A comparator function.
"""
# Ensure that field names is a list and not a tuple.
field_names = list(field_names)
# For fields that start with a '-', reverse the ordering of the
# comparison.
reverses = [1] * len(field_names)
for i, field_name in enumerate(field_names):
if field_name[0] == '-':
reverses[i] = -1
field_names[i] = field_name[1:]
field_names = [f.replace(LOOKUP_SEP, '.') for f in field_names]
def comparator(i1, i2):
# Get a tuple of values for comparison.
v1 = attrgetter(*field_names)(i1)
v2 = attrgetter(*field_names)(i2)
# If there's only one arg supplied, attrgetter returns a single
# item, directly return the result in this case.
if len(field_names) == 1:
return cls._cmp(v1, v2) * reverses[0]
# Compare each field for the two items, reversing if necessary.
order = multiply_iterables(list(map(cls._cmp, v1, v2)), reverses)
try:
# The first non-zero element.
return next(dropwhile(__not__, order))
except StopIteration:
# Everything was equivalent.
return 0
return comparator |
0, module; 1, function_definition; 2, function_name:sort_segment_points; 3, parameters; 4, block; 5, identifier:Aps; 6, identifier:Bps; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, for_statement; 13, return_statement; 14, comment:"""Takes two line segments and sorts all their points,
so that they form a continuous path
Args:
Aps: Array of tracktotrip.Point
Bps: Array of tracktotrip.Point
Returns:
Array with points ordered
"""; 15, assignment; 16, assignment; 17, call; 18, identifier:i; 19, call; 20, block; 21, identifier:m; 22, call; 23, block; 24, identifier:mid; 25, identifier:mid; 26, list; 27, identifier:j; 28, integer:0; 29, attribute; 30, argument_list; 31, identifier:range; 32, argument_list; 33, expression_statement; 34, for_statement; 35, expression_statement; 36, identifier:range; 37, argument_list; 38, expression_statement; 39, identifier:mid; 40, identifier:append; 41, subscript; 42, binary_operator:len(Aps)-1; 43, assignment; 44, identifier:m; 45, call; 46, block; 47, call; 48, identifier:j; 49, call; 50, call; 51, identifier:Aps; 52, integer:0; 53, call; 54, integer:1; 55, identifier:dist; 56, call; 57, identifier:range; 58, argument_list; 59, expression_statement; 60, if_statement; 61, attribute; 62, argument_list; 63, identifier:len; 64, argument_list; 65, attribute; 66, argument_list; 67, identifier:len; 68, argument_list; 69, identifier:distance_tt_point; 70, argument_list; 71, identifier:j; 72, call; 73, assignment; 74, comparison_operator:dist > distm; 75, block; 76, identifier:mid; 77, identifier:append; 78, subscript; 79, identifier:Bps; 80, identifier:mid; 81, identifier:append; 82, subscript; 83, identifier:Aps; 84, subscript; 85, subscript; 86, identifier:len; 87, argument_list; 88, identifier:distm; 89, call; 90, identifier:dist; 91, identifier:distm; 92, expression_statement; 93, if_statement; 94, identifier:Aps; 95, binary_operator:i+1; 96, identifier:Bps; 97, identifier:m; 98, identifier:Aps; 99, identifier:i; 100, identifier:Aps; 101, binary_operator:i+1; 102, identifier:Bps; 103, identifier:distance_tt_point; 104, argument_list; 105, assignment; 106, comparison_operator:direction > 0; 107, block; 108, identifier:i; 109, integer:1; 110, identifier:i; 111, integer:1; 112, subscript; 113, subscript; 114, identifier:direction; 115, call; 116, identifier:direction; 117, integer:0; 118, expression_statement; 119, expression_statement; 120, break_statement; 121, identifier:Aps; 122, identifier:i; 123, identifier:Bps; 124, identifier:m; 125, identifier:dot; 126, argument_list; 127, assignment; 128, call; 129, call; 130, call; 131, identifier:j; 132, binary_operator:m + 1; 133, attribute; 134, argument_list; 135, identifier:normalize; 136, argument_list; 137, identifier:normalize; 138, argument_list; 139, identifier:m; 140, integer:1; 141, identifier:mid; 142, identifier:append; 143, subscript; 144, call; 145, call; 146, identifier:Bps; 147, identifier:m; 148, identifier:line; 149, argument_list; 150, attribute; 151, argument_list; 152, call; 153, call; 154, subscript; 155, identifier:gen2arr; 156, attribute; 157, argument_list; 158, attribute; 159, argument_list; 160, identifier:Bps; 161, identifier:m; 162, subscript; 163, identifier:gen2arr; 164, subscript; 165, identifier:gen2arr; 166, identifier:Aps; 167, identifier:i; 168, identifier:Aps; 169, binary_operator:i+1; 170, identifier:i; 171, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 8, 15; 9, 16; 10, 17; 11, 18; 11, 19; 11, 20; 12, 21; 12, 22; 12, 23; 13, 24; 15, 25; 15, 26; 16, 27; 16, 28; 17, 29; 17, 30; 19, 31; 19, 32; 20, 33; 20, 34; 20, 35; 22, 36; 22, 37; 23, 38; 29, 39; 29, 40; 30, 41; 32, 42; 33, 43; 34, 44; 34, 45; 34, 46; 35, 47; 37, 48; 37, 49; 38, 50; 41, 51; 41, 52; 42, 53; 42, 54; 43, 55; 43, 56; 45, 57; 45, 58; 46, 59; 46, 60; 47, 61; 47, 62; 49, 63; 49, 64; 50, 65; 50, 66; 53, 67; 53, 68; 56, 69; 56, 70; 58, 71; 58, 72; 59, 73; 60, 74; 60, 75; 61, 76; 61, 77; 62, 78; 64, 79; 65, 80; 65, 81; 66, 82; 68, 83; 70, 84; 70, 85; 72, 86; 72, 87; 73, 88; 73, 89; 74, 90; 74, 91; 75, 92; 75, 93; 78, 94; 78, 95; 82, 96; 82, 97; 84, 98; 84, 99; 85, 100; 85, 101; 87, 102; 89, 103; 89, 104; 92, 105; 93, 106; 93, 107; 95, 108; 95, 109; 101, 110; 101, 111; 104, 112; 104, 113; 105, 114; 105, 115; 106, 116; 106, 117; 107, 118; 107, 119; 107, 120; 112, 121; 112, 122; 113, 123; 113, 124; 115, 125; 115, 126; 118, 127; 119, 128; 126, 129; 126, 130; 127, 131; 127, 132; 128, 133; 128, 134; 129, 135; 129, 136; 130, 137; 130, 138; 132, 139; 132, 140; 133, 141; 133, 142; 134, 143; 136, 144; 138, 145; 143, 146; 143, 147; 144, 148; 144, 149; 145, 150; 145, 151; 149, 152; 149, 153; 150, 154; 150, 155; 152, 156; 152, 157; 153, 158; 153, 159; 154, 160; 154, 161; 156, 162; 156, 163; 158, 164; 158, 165; 162, 166; 162, 167; 164, 168; 164, 169; 169, 170; 169, 171 | def sort_segment_points(Aps, Bps):
"""Takes two line segments and sorts all their points,
so that they form a continuous path
Args:
Aps: Array of tracktotrip.Point
Bps: Array of tracktotrip.Point
Returns:
Array with points ordered
"""
mid = []
j = 0
mid.append(Aps[0])
for i in range(len(Aps)-1):
dist = distance_tt_point(Aps[i], Aps[i+1])
for m in range(j, len(Bps)):
distm = distance_tt_point(Aps[i], Bps[m])
if dist > distm:
direction = dot(normalize(line(Aps[i].gen2arr(), Aps[i+1].gen2arr())), normalize(Bps[m].gen2arr()))
if direction > 0:
j = m + 1
mid.append(Bps[m])
break
mid.append(Aps[i+1])
for m in range(j, len(Bps)):
mid.append(Bps[m])
return mid |
0, module; 1, function_definition; 2, function_name:works; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, default_parameter; 15, default_parameter; 16, default_parameter; 17, default_parameter; 18, dictionary_splat_pattern; 19, expression_statement; 20, if_statement; 21, identifier:ids; 22, None; 23, identifier:query; 24, None; 25, identifier:filter; 26, None; 27, identifier:offset; 28, None; 29, identifier:limit; 30, None; 31, identifier:sample; 32, None; 33, identifier:sort; 34, None; 35, identifier:order; 36, None; 37, identifier:facet; 38, None; 39, identifier:select; 40, None; 41, identifier:cursor; 42, None; 43, identifier:cursor_max; 44, integer:5000; 45, identifier:kwargs; 46, string:'''
Search Crossref works
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois.
Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`.
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param cursor: [String] Cursor character string to do deep paging. Default is None.
Pass in '*' to start deep paging. Any combination of query, filters and facets may be
used with deep paging cursors. While rows may be specified along with cursor, offset
and sample cannot be used.
See https://github.com/CrossRef/rest-api-doc/blob/master/rest_api.md#deep-paging-with-cursors
:param cursor_max: [Fixnum] Max records to retrieve. Only used when cursor param used. Because
deep paging can result in continuous requests until all are retrieved, use this
parameter to set a maximum number of records. Of course, if there are less records
found than this value, you will get only those found.
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.works()
cr.works(ids = '10.1371/journal.pone.0033693')
dois = ['10.1371/journal.pone.0033693', ]
cr.works(ids = dois)
x = cr.works(query = "ecology")
x['status']
x['message-type']
x['message-version']
x['message']
x['message']['total-results']
x['message']['items-per-page']
x['message']['query']
x['message']['items']
# Get full text links
x = cr.works(filter = {'has_full_text': True})
x
# Parse output to various data pieces
x = cr.works(filter = {'has_full_text': True})
## get doi for each item
[ z['DOI'] for z in x['message']['items'] ]
## get doi and url for each item
[ {"doi": z['DOI'], "url": z['URL']} for z in x['message']['items'] ]
### print every doi
for i in x['message']['items']:
print i['DOI']
# filters - pass in as a dict
## see https://github.com/CrossRef/rest-api-doc#filter-names
cr.works(filter = {'has_full_text': True})
cr.works(filter = {'has_funder': True, 'has_full_text': True})
cr.works(filter = {'award_number': 'CBET-0756451', 'award_funder': '10.13039/100000001'})
## to repeat a filter name, pass in a list
x = cr.works(filter = {'award_funder': ['10.13039/100004440', '10.13039/100000861']}, limit = 100)
map(lambda z:z['funder'][0]['DOI'], x['message']['items'])
# Deep paging, using the cursor parameter
## this search should lead to only ~215 results
cr.works(query = "widget", cursor = "*", cursor_max = 100)
## this search should lead to only ~2500 results, in chunks of 500
res = cr.works(query = "octopus", cursor = "*", limit = 500)
sum([ len(z['message']['items']) for z in res ])
## about 167 results
res = cr.works(query = "extravagant", cursor = "*", limit = 50, cursor_max = 500)
sum([ len(z['message']['items']) for z in res ])
## cursor_max to get back only a maximum set of results
res = cr.works(query = "widget", cursor = "*", cursor_max = 100)
sum([ len(z['message']['items']) for z in res ])
## cursor_max - especially useful when a request could be very large
### e.g., "ecology" results in ~275K records, lets max at 10,000
### with 1000 at a time
res = cr.works(query = "ecology", cursor = "*", cursor_max = 10000, limit = 1000)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.works(query = "ecology", query_author = 'carl boettiger')
[ x['author'][0]['family'] for x in res['message']['items'] ]
# select certain fields to return
## as a comma separated string
cr.works(query = "ecology", select = "DOI,title")
## or as a list
cr.works(query = "ecology", select = ["DOI","title"])
'''; 47, comparison_operator:ids.__class__.__name__ != 'NoneType'; 48, block; 49, else_clause; 50, attribute; 51, string; 52, return_statement; 53, block; 54, attribute; 55, identifier:__name__; 56, string_content:NoneType; 57, call; 58, return_statement; 59, identifier:ids; 60, identifier:__class__; 61, identifier:request; 62, argument_list; 63, call; 64, attribute; 65, attribute; 66, string:"/works/"; 67, identifier:ids; 68, identifier:query; 69, identifier:filter; 70, identifier:offset; 71, identifier:limit; 72, identifier:sample; 73, identifier:sort; 74, identifier:order; 75, identifier:facet; 76, identifier:select; 77, None; 78, None; 79, None; 80, None; 81, dictionary_splat; 82, attribute; 83, argument_list; 84, identifier:self; 85, identifier:mailto; 86, identifier:self; 87, identifier:base_url; 88, identifier:kwargs; 89, call; 90, identifier:do_request; 91, identifier:Request; 92, argument_list; 93, attribute; 94, attribute; 95, string:"/works/"; 96, identifier:query; 97, identifier:filter; 98, identifier:offset; 99, identifier:limit; 100, identifier:sample; 101, identifier:sort; 102, identifier:order; 103, identifier:facet; 104, identifier:select; 105, identifier:cursor; 106, identifier:cursor_max; 107, None; 108, dictionary_splat; 109, identifier:self; 110, identifier:mailto; 111, identifier:self; 112, identifier:base_url; 113, identifier:kwargs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 3, 14; 3, 15; 3, 16; 3, 17; 3, 18; 4, 19; 4, 20; 6, 21; 6, 22; 7, 23; 7, 24; 8, 25; 8, 26; 9, 27; 9, 28; 10, 29; 10, 30; 11, 31; 11, 32; 12, 33; 12, 34; 13, 35; 13, 36; 14, 37; 14, 38; 15, 39; 15, 40; 16, 41; 16, 42; 17, 43; 17, 44; 18, 45; 19, 46; 20, 47; 20, 48; 20, 49; 47, 50; 47, 51; 48, 52; 49, 53; 50, 54; 50, 55; 51, 56; 52, 57; 53, 58; 54, 59; 54, 60; 57, 61; 57, 62; 58, 63; 62, 64; 62, 65; 62, 66; 62, 67; 62, 68; 62, 69; 62, 70; 62, 71; 62, 72; 62, 73; 62, 74; 62, 75; 62, 76; 62, 77; 62, 78; 62, 79; 62, 80; 62, 81; 63, 82; 63, 83; 64, 84; 64, 85; 65, 86; 65, 87; 81, 88; 82, 89; 82, 90; 89, 91; 89, 92; 92, 93; 92, 94; 92, 95; 92, 96; 92, 97; 92, 98; 92, 99; 92, 100; 92, 101; 92, 102; 92, 103; 92, 104; 92, 105; 92, 106; 92, 107; 92, 108; 93, 109; 93, 110; 94, 111; 94, 112; 108, 113 | def works(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, select = None, cursor = None,
cursor_max = 5000, **kwargs):
'''
Search Crossref works
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois.
Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`.
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param cursor: [String] Cursor character string to do deep paging. Default is None.
Pass in '*' to start deep paging. Any combination of query, filters and facets may be
used with deep paging cursors. While rows may be specified along with cursor, offset
and sample cannot be used.
See https://github.com/CrossRef/rest-api-doc/blob/master/rest_api.md#deep-paging-with-cursors
:param cursor_max: [Fixnum] Max records to retrieve. Only used when cursor param used. Because
deep paging can result in continuous requests until all are retrieved, use this
parameter to set a maximum number of records. Of course, if there are less records
found than this value, you will get only those found.
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.works()
cr.works(ids = '10.1371/journal.pone.0033693')
dois = ['10.1371/journal.pone.0033693', ]
cr.works(ids = dois)
x = cr.works(query = "ecology")
x['status']
x['message-type']
x['message-version']
x['message']
x['message']['total-results']
x['message']['items-per-page']
x['message']['query']
x['message']['items']
# Get full text links
x = cr.works(filter = {'has_full_text': True})
x
# Parse output to various data pieces
x = cr.works(filter = {'has_full_text': True})
## get doi for each item
[ z['DOI'] for z in x['message']['items'] ]
## get doi and url for each item
[ {"doi": z['DOI'], "url": z['URL']} for z in x['message']['items'] ]
### print every doi
for i in x['message']['items']:
print i['DOI']
# filters - pass in as a dict
## see https://github.com/CrossRef/rest-api-doc#filter-names
cr.works(filter = {'has_full_text': True})
cr.works(filter = {'has_funder': True, 'has_full_text': True})
cr.works(filter = {'award_number': 'CBET-0756451', 'award_funder': '10.13039/100000001'})
## to repeat a filter name, pass in a list
x = cr.works(filter = {'award_funder': ['10.13039/100004440', '10.13039/100000861']}, limit = 100)
map(lambda z:z['funder'][0]['DOI'], x['message']['items'])
# Deep paging, using the cursor parameter
## this search should lead to only ~215 results
cr.works(query = "widget", cursor = "*", cursor_max = 100)
## this search should lead to only ~2500 results, in chunks of 500
res = cr.works(query = "octopus", cursor = "*", limit = 500)
sum([ len(z['message']['items']) for z in res ])
## about 167 results
res = cr.works(query = "extravagant", cursor = "*", limit = 50, cursor_max = 500)
sum([ len(z['message']['items']) for z in res ])
## cursor_max to get back only a maximum set of results
res = cr.works(query = "widget", cursor = "*", cursor_max = 100)
sum([ len(z['message']['items']) for z in res ])
## cursor_max - especially useful when a request could be very large
### e.g., "ecology" results in ~275K records, lets max at 10,000
### with 1000 at a time
res = cr.works(query = "ecology", cursor = "*", cursor_max = 10000, limit = 1000)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.works(query = "ecology", query_author = 'carl boettiger')
[ x['author'][0]['family'] for x in res['message']['items'] ]
# select certain fields to return
## as a comma separated string
cr.works(query = "ecology", select = "DOI,title")
## or as a list
cr.works(query = "ecology", select = ["DOI","title"])
'''
if ids.__class__.__name__ != 'NoneType':
return request(self.mailto, self.base_url, "/works/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, None, None, None, None, **kwargs)
else:
return Request(self.mailto, self.base_url, "/works/",
query, filter, offset, limit, sample, sort,
order, facet, select, cursor, cursor_max, None, **kwargs).do_request() |
0, module; 1, function_definition; 2, function_name:prefixes; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, default_parameter; 15, default_parameter; 16, default_parameter; 17, default_parameter; 18, dictionary_splat_pattern; 19, expression_statement; 20, expression_statement; 21, return_statement; 22, identifier:ids; 23, None; 24, identifier:filter; 25, None; 26, identifier:offset; 27, None; 28, identifier:limit; 29, None; 30, identifier:sample; 31, None; 32, identifier:sort; 33, None; 34, identifier:order; 35, None; 36, identifier:facet; 37, None; 38, identifier:works; 39, False; 40, identifier:select; 41, None; 42, identifier:cursor; 43, None; 44, identifier:cursor_max; 45, integer:5000; 46, identifier:kwargs; 47, string:'''
Search Crossref prefixes
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relevant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.prefixes(ids = "10.1016")
cr.prefixes(ids = ['10.1016','10.1371','10.1023','10.4176','10.1093'])
# get works
cr.prefixes(ids = "10.1016", works = True)
# Limit number of results
cr.prefixes(ids = "10.1016", works = True, limit = 3)
# Sort and order
cr.prefixes(ids = "10.1016", works = True, sort = "relevance", order = "asc")
# cursor - deep paging
res = cr.prefixes(ids = "10.1016", works = True, cursor = "*", limit = 200)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.prefixes(ids = "10.1371", works = True, query_editor = 'cooper', filter = {'type': 'journal-article'})
eds = [ x.get('editor') for x in res['message']['items'] ]
[ z for z in eds if z is not None ]
'''; 48, call; 49, call; 50, identifier:check_kwargs; 51, argument_list; 52, identifier:request; 53, argument_list; 54, list; 55, identifier:kwargs; 56, attribute; 57, attribute; 58, string:"/prefixes/"; 59, identifier:ids; 60, keyword_argument; 61, keyword_argument; 62, keyword_argument; 63, keyword_argument; 64, keyword_argument; 65, keyword_argument; 66, keyword_argument; 67, keyword_argument; 68, keyword_argument; 69, keyword_argument; 70, keyword_argument; 71, keyword_argument; 72, dictionary_splat; 73, string:"query"; 74, identifier:self; 75, identifier:mailto; 76, identifier:self; 77, identifier:base_url; 78, identifier:query; 79, None; 80, identifier:filter; 81, identifier:filter; 82, identifier:offset; 83, identifier:offset; 84, identifier:limit; 85, identifier:limit; 86, identifier:sample; 87, identifier:sample; 88, identifier:sort; 89, identifier:sort; 90, identifier:order; 91, identifier:order; 92, identifier:facet; 93, identifier:facet; 94, identifier:select; 95, identifier:select; 96, identifier:works; 97, identifier:works; 98, identifier:cursor; 99, identifier:cursor; 100, identifier:cursor_max; 101, identifier:cursor_max; 102, identifier:kwargs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 3, 14; 3, 15; 3, 16; 3, 17; 3, 18; 4, 19; 4, 20; 4, 21; 6, 22; 6, 23; 7, 24; 7, 25; 8, 26; 8, 27; 9, 28; 9, 29; 10, 30; 10, 31; 11, 32; 11, 33; 12, 34; 12, 35; 13, 36; 13, 37; 14, 38; 14, 39; 15, 40; 15, 41; 16, 42; 16, 43; 17, 44; 17, 45; 18, 46; 19, 47; 20, 48; 21, 49; 48, 50; 48, 51; 49, 52; 49, 53; 51, 54; 51, 55; 53, 56; 53, 57; 53, 58; 53, 59; 53, 60; 53, 61; 53, 62; 53, 63; 53, 64; 53, 65; 53, 66; 53, 67; 53, 68; 53, 69; 53, 70; 53, 71; 53, 72; 54, 73; 56, 74; 56, 75; 57, 76; 57, 77; 60, 78; 60, 79; 61, 80; 61, 81; 62, 82; 62, 83; 63, 84; 63, 85; 64, 86; 64, 87; 65, 88; 65, 89; 66, 90; 66, 91; 67, 92; 67, 93; 68, 94; 68, 95; 69, 96; 69, 97; 70, 98; 70, 99; 71, 100; 71, 101; 72, 102 | def prefixes(self, ids = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref prefixes
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relevant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.prefixes(ids = "10.1016")
cr.prefixes(ids = ['10.1016','10.1371','10.1023','10.4176','10.1093'])
# get works
cr.prefixes(ids = "10.1016", works = True)
# Limit number of results
cr.prefixes(ids = "10.1016", works = True, limit = 3)
# Sort and order
cr.prefixes(ids = "10.1016", works = True, sort = "relevance", order = "asc")
# cursor - deep paging
res = cr.prefixes(ids = "10.1016", works = True, cursor = "*", limit = 200)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.prefixes(ids = "10.1371", works = True, query_editor = 'cooper', filter = {'type': 'journal-article'})
eds = [ x.get('editor') for x in res['message']['items'] ]
[ z for z in eds if z is not None ]
'''
check_kwargs(["query"], kwargs)
return request(self.mailto, self.base_url, "/prefixes/", ids,
query = None, filter = filter, offset = offset, limit = limit,
sample = sample, sort = sort, order = order, facet = facet,
select = select, works = works, cursor = cursor, cursor_max = cursor_max,
**kwargs) |
0, module; 1, function_definition; 2, function_name:types; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, default_parameter; 15, default_parameter; 16, default_parameter; 17, default_parameter; 18, default_parameter; 19, dictionary_splat_pattern; 20, expression_statement; 21, return_statement; 22, identifier:ids; 23, None; 24, identifier:query; 25, None; 26, identifier:filter; 27, None; 28, identifier:offset; 29, None; 30, identifier:limit; 31, None; 32, identifier:sample; 33, None; 34, identifier:sort; 35, None; 36, identifier:order; 37, None; 38, identifier:facet; 39, None; 40, identifier:works; 41, False; 42, identifier:select; 43, None; 44, identifier:cursor; 45, None; 46, identifier:cursor_max; 47, integer:5000; 48, identifier:kwargs; 49, string:'''
Search Crossref types
:param ids: [Array] Type identifier, e.g., journal
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relevant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.types()
cr.types(ids = "journal")
cr.types(ids = "journal-article")
cr.types(ids = "journal", works = True)
# field queries
res = cr.types(ids = "journal-article", works = True, query_title = 'gender', rows = 100)
[ x.get('title') for x in res['message']['items'] ]
'''; 50, call; 51, identifier:request; 52, argument_list; 53, attribute; 54, attribute; 55, string:"/types/"; 56, identifier:ids; 57, identifier:query; 58, identifier:filter; 59, identifier:offset; 60, identifier:limit; 61, identifier:sample; 62, identifier:sort; 63, identifier:order; 64, identifier:facet; 65, identifier:select; 66, identifier:works; 67, identifier:cursor; 68, identifier:cursor_max; 69, dictionary_splat; 70, identifier:self; 71, identifier:mailto; 72, identifier:self; 73, identifier:base_url; 74, identifier:kwargs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 3, 14; 3, 15; 3, 16; 3, 17; 3, 18; 3, 19; 4, 20; 4, 21; 6, 22; 6, 23; 7, 24; 7, 25; 8, 26; 8, 27; 9, 28; 9, 29; 10, 30; 10, 31; 11, 32; 11, 33; 12, 34; 12, 35; 13, 36; 13, 37; 14, 38; 14, 39; 15, 40; 15, 41; 16, 42; 16, 43; 17, 44; 17, 45; 18, 46; 18, 47; 19, 48; 20, 49; 21, 50; 50, 51; 50, 52; 52, 53; 52, 54; 52, 55; 52, 56; 52, 57; 52, 58; 52, 59; 52, 60; 52, 61; 52, 62; 52, 63; 52, 64; 52, 65; 52, 66; 52, 67; 52, 68; 52, 69; 53, 70; 53, 71; 54, 72; 54, 73; 69, 74 | def types(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref types
:param ids: [Array] Type identifier, e.g., journal
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relevant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.types()
cr.types(ids = "journal")
cr.types(ids = "journal-article")
cr.types(ids = "journal", works = True)
# field queries
res = cr.types(ids = "journal-article", works = True, query_title = 'gender', rows = 100)
[ x.get('title') for x in res['message']['items'] ]
'''
return request(self.mailto, self.base_url, "/types/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, works, cursor, cursor_max, **kwargs) |
0, module; 1, function_definition; 2, function_name:licenses; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, dictionary_splat_pattern; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, return_statement; 18, identifier:query; 19, None; 20, identifier:offset; 21, None; 22, identifier:limit; 23, None; 24, identifier:sample; 25, None; 26, identifier:sort; 27, None; 28, identifier:order; 29, None; 30, identifier:facet; 31, None; 32, identifier:kwargs; 33, string:'''
Search Crossref licenses
:param query: [String] A query string
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relevant when searching with specific dois. Default: 20. Max: 1000
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.licenses()
cr.licenses(query = "creative")
'''; 34, call; 35, assignment; 36, identifier:res; 37, identifier:check_kwargs; 38, argument_list; 39, identifier:res; 40, call; 41, list; 42, identifier:kwargs; 43, identifier:request; 44, argument_list; 45, string:"ids"; 46, string:"filter"; 47, string:"works"; 48, attribute; 49, attribute; 50, string:"/licenses/"; 51, None; 52, identifier:query; 53, None; 54, identifier:offset; 55, identifier:limit; 56, None; 57, identifier:sort; 58, identifier:order; 59, identifier:facet; 60, None; 61, None; 62, None; 63, None; 64, dictionary_splat; 65, identifier:self; 66, identifier:mailto; 67, identifier:self; 68, identifier:base_url; 69, identifier:kwargs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 6, 19; 7, 20; 7, 21; 8, 22; 8, 23; 9, 24; 9, 25; 10, 26; 10, 27; 11, 28; 11, 29; 12, 30; 12, 31; 13, 32; 14, 33; 15, 34; 16, 35; 17, 36; 34, 37; 34, 38; 35, 39; 35, 40; 38, 41; 38, 42; 40, 43; 40, 44; 41, 45; 41, 46; 41, 47; 44, 48; 44, 49; 44, 50; 44, 51; 44, 52; 44, 53; 44, 54; 44, 55; 44, 56; 44, 57; 44, 58; 44, 59; 44, 60; 44, 61; 44, 62; 44, 63; 44, 64; 48, 65; 48, 66; 49, 67; 49, 68; 64, 69 | def licenses(self, query = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, **kwargs):
'''
Search Crossref licenses
:param query: [String] A query string
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relevant when searching with specific dois. Default: 20. Max: 1000
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.licenses()
cr.licenses(query = "creative")
'''
check_kwargs(["ids", "filter", "works"], kwargs)
res = request(self.mailto, self.base_url, "/licenses/", None,
query, None, offset, limit, None, sort,
order, facet, None, None, None, None, **kwargs)
return res |
0, module; 1, function_definition; 2, function_name:get_graph_component; 3, parameters; 4, block; 5, identifier:graph; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, return_statement; 12, comment:""" Identify strongly connected components in a graph using
Tarjan's algorithm.
graph should be a dictionary mapping node names to
lists of successor nodes.
"""; 13, assignment; 14, assignment; 15, assignment; 16, call; 17, identifier:graph_component; 18, identifier:components; 19, call; 20, identifier:node_component; 21, call; 22, identifier:graph_component; 23, dictionary_comprehension; 24, attribute; 25, argument_list; 26, identifier:map; 27, argument_list; 28, identifier:dict; 29, argument_list; 30, pair; 31, for_in_clause; 32, identifier:graph_component; 33, identifier:update; 34, call; 35, call; 36, identifier:graph; 37, call; 38, identifier:component; 39, list; 40, identifier:component; 41, identifier:components; 42, identifier:dict; 43, argument_list; 44, identifier:partial; 45, argument_list; 46, identifier:_gen_node_component; 47, argument_list; 48, call; 49, identifier:_visit; 50, keyword_argument; 51, identifier:components; 52, identifier:_gen_graph_component; 53, argument_list; 54, identifier:graph; 55, identifier:graph; 56, identifier:graph; 57, identifier:node_component; 58, identifier:_gen_graph_value | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 11, 17; 13, 18; 13, 19; 14, 20; 14, 21; 15, 22; 15, 23; 16, 24; 16, 25; 19, 26; 19, 27; 21, 28; 21, 29; 23, 30; 23, 31; 24, 32; 24, 33; 25, 34; 27, 35; 27, 36; 29, 37; 30, 38; 30, 39; 31, 40; 31, 41; 34, 42; 34, 43; 35, 44; 35, 45; 37, 46; 37, 47; 43, 48; 45, 49; 45, 50; 47, 51; 48, 52; 48, 53; 50, 54; 50, 55; 53, 56; 53, 57; 53, 58 | def get_graph_component(graph):
""" Identify strongly connected components in a graph using
Tarjan's algorithm.
graph should be a dictionary mapping node names to
lists of successor nodes.
"""
components = map(partial(_visit, graph=graph), graph)
node_component = dict(_gen_node_component(components))
graph_component = {component: [] for component in components}
graph_component.update(
dict(_gen_graph_component(graph, node_component, _gen_graph_value)))
return graph_component |
0, module; 1, function_definition; 2, function_name:pipe_fetchdata; 3, parameters; 4, block; 5, default_parameter; 6, default_parameter; 7, default_parameter; 8, dictionary_splat_pattern; 9, expression_statement; 10, comment:# todo: iCal and KML; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, return_statement; 17, identifier:context; 18, None; 19, identifier:_INPUT; 20, None; 21, identifier:conf; 22, None; 23, identifier:kwargs; 24, comment:"""A source that fetches and parses an XML or JSON file. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items or fields
conf : {
'URL': {'value': <url>},
'path': {'value': <dot separated path to data list>}
}
Yields
------
_OUTPUT : items
Examples
--------
>>> from os import path as p
>>> from pipe2py.modules.pipeforever import pipe_forever
>>> parent = p.dirname(p.dirname(__file__))
>>> abspath = p.abspath(p.join(parent, 'data', 'gigs.json'))
>>> path = 'value.items'
>>> url = "file://%s" % abspath
>>> conf = {'URL': {'value': url}, 'path': {'value': path}}
>>> pipe_fetchdata(_INPUT=pipe_forever(), conf=conf).next().keys()[:5]
[u'y:repeatcount', u'description', u'pubDate', u'title', u'y:published']
>>> abspath = p.abspath(p.join(parent, 'data', 'places.xml'))
>>> path = 'appointment'
>>> url = "file://%s" % abspath
>>> conf = {'URL': {'value': url}, 'path': {'value': path}}
>>> sorted(pipe_fetchdata(_INPUT=pipe_forever(), conf=conf).next().keys())
['alarmTime', 'begin', 'duration', 'places', 'subject', 'uid']
>>> conf = {'URL': {'value': url}, 'path': {'value': ''}}
>>> sorted(pipe_fetchdata(_INPUT=pipe_forever(), conf=conf).next().keys())
['appointment', 'reminder']
"""; 25, assignment; 26, assignment; 27, assignment; 28, assignment; 29, assignment; 30, identifier:_OUTPUT; 31, identifier:funcs; 32, call; 33, identifier:parsed; 34, call; 35, identifier:results; 36, call; 37, identifier:items; 38, call; 39, identifier:_OUTPUT; 40, call; 41, identifier:get_splits; 42, argument_list; 43, identifier:get_parsed; 44, argument_list; 45, identifier:starmap; 46, argument_list; 47, identifier:imap; 48, argument_list; 49, attribute; 50, argument_list; 51, None; 52, identifier:conf; 53, dictionary_splat; 54, identifier:_INPUT; 55, subscript; 56, identifier:parse_result; 57, identifier:parsed; 58, attribute; 59, identifier:results; 60, identifier:utils; 61, identifier:multiplex; 62, identifier:items; 63, call; 64, identifier:funcs; 65, integer:0; 66, identifier:utils; 67, identifier:gen_items; 68, identifier:cdicts; 69, argument_list; 70, identifier:opts; 71, identifier:kwargs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 5, 17; 5, 18; 6, 19; 6, 20; 7, 21; 7, 22; 8, 23; 9, 24; 11, 25; 12, 26; 13, 27; 14, 28; 15, 29; 16, 30; 25, 31; 25, 32; 26, 33; 26, 34; 27, 35; 27, 36; 28, 37; 28, 38; 29, 39; 29, 40; 32, 41; 32, 42; 34, 43; 34, 44; 36, 45; 36, 46; 38, 47; 38, 48; 40, 49; 40, 50; 42, 51; 42, 52; 42, 53; 44, 54; 44, 55; 46, 56; 46, 57; 48, 58; 48, 59; 49, 60; 49, 61; 50, 62; 53, 63; 55, 64; 55, 65; 58, 66; 58, 67; 63, 68; 63, 69; 69, 70; 69, 71 | def pipe_fetchdata(context=None, _INPUT=None, conf=None, **kwargs):
"""A source that fetches and parses an XML or JSON file. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items or fields
conf : {
'URL': {'value': <url>},
'path': {'value': <dot separated path to data list>}
}
Yields
------
_OUTPUT : items
Examples
--------
>>> from os import path as p
>>> from pipe2py.modules.pipeforever import pipe_forever
>>> parent = p.dirname(p.dirname(__file__))
>>> abspath = p.abspath(p.join(parent, 'data', 'gigs.json'))
>>> path = 'value.items'
>>> url = "file://%s" % abspath
>>> conf = {'URL': {'value': url}, 'path': {'value': path}}
>>> pipe_fetchdata(_INPUT=pipe_forever(), conf=conf).next().keys()[:5]
[u'y:repeatcount', u'description', u'pubDate', u'title', u'y:published']
>>> abspath = p.abspath(p.join(parent, 'data', 'places.xml'))
>>> path = 'appointment'
>>> url = "file://%s" % abspath
>>> conf = {'URL': {'value': url}, 'path': {'value': path}}
>>> sorted(pipe_fetchdata(_INPUT=pipe_forever(), conf=conf).next().keys())
['alarmTime', 'begin', 'duration', 'places', 'subject', 'uid']
>>> conf = {'URL': {'value': url}, 'path': {'value': ''}}
>>> sorted(pipe_fetchdata(_INPUT=pipe_forever(), conf=conf).next().keys())
['appointment', 'reminder']
"""
# todo: iCal and KML
funcs = get_splits(None, conf, **cdicts(opts, kwargs))
parsed = get_parsed(_INPUT, funcs[0])
results = starmap(parse_result, parsed)
items = imap(utils.gen_items, results)
_OUTPUT = utils.multiplex(items)
return _OUTPUT |
0, module; 1, function_definition; 2, function_name:pipe_sort; 3, parameters; 4, block; 5, default_parameter; 6, default_parameter; 7, default_parameter; 8, dictionary_splat_pattern; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, return_statement; 21, identifier:context; 22, None; 23, identifier:_INPUT; 24, None; 25, identifier:conf; 26, None; 27, identifier:kwargs; 28, comment:"""An operator that sorts the input source according to the specified key.
Not loopable. Not lazy.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
kwargs -- other inputs, e.g. to feed terminals for rule values
conf : {
'KEY': [
{
'field': {'type': 'text', 'value': 'title'},
'dir': {'type': 'text', 'value': 'DESC'}
}
]
}
Returns
-------
_OUTPUT : generator of sorted items
"""; 29, assignment; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, assignment; 38, assignment; 39, identifier:_OUTPUT; 40, identifier:test; 41, call; 42, identifier:_pass; 43, call; 44, identifier:key_defs; 45, call; 46, identifier:get_value; 47, call; 48, identifier:parse_conf; 49, call; 50, identifier:keys; 51, call; 52, identifier:order; 53, generator_expression; 54, identifier:comparers; 55, call; 56, identifier:cmp_func; 57, call; 58, identifier:_OUTPUT; 59, conditional_expression:_INPUT if _pass else iter(sorted(_INPUT, cmp=cmp_func)); 60, attribute; 61, argument_list; 62, attribute; 63, argument_list; 64, identifier:imap; 65, argument_list; 66, identifier:partial; 67, argument_list; 68, identifier:partial; 69, argument_list; 70, identifier:imap; 71, argument_list; 72, binary_operator:'%s%s' % ('-' if k.dir == 'DESC' else '', k.field); 73, for_in_clause; 74, identifier:map; 75, argument_list; 76, identifier:partial; 77, argument_list; 78, identifier:_INPUT; 79, identifier:_pass; 80, call; 81, identifier:kwargs; 82, identifier:pop; 83, string; 84, None; 85, identifier:utils; 86, identifier:get_pass; 87, keyword_argument; 88, identifier:DotDict; 89, call; 90, attribute; 91, dictionary_splat; 92, attribute; 93, keyword_argument; 94, dictionary_splat; 95, identifier:parse_conf; 96, identifier:key_defs; 97, string; 98, tuple; 99, identifier:k; 100, identifier:keys; 101, identifier:get_comparer; 102, identifier:order; 103, identifier:multikeysort; 104, keyword_argument; 105, identifier:iter; 106, argument_list; 107, string_content:pass_if; 108, identifier:test; 109, identifier:test; 110, attribute; 111, argument_list; 112, identifier:utils; 113, identifier:get_value; 114, identifier:kwargs; 115, identifier:utils; 116, identifier:parse_conf; 117, identifier:parse_func; 118, identifier:get_value; 119, identifier:kwargs; 120, string_content:%s%s; 121, conditional_expression:'-' if k.dir == 'DESC' else ''; 122, attribute; 123, identifier:comparers; 124, identifier:comparers; 125, call; 126, identifier:utils; 127, identifier:listize; 128, subscript; 129, string; 130, comparison_operator:k.dir == 'DESC'; 131, string; 132, identifier:k; 133, identifier:field; 134, identifier:sorted; 135, argument_list; 136, identifier:conf; 137, string; 138, string_content:-; 139, attribute; 140, string; 141, identifier:_INPUT; 142, keyword_argument; 143, string_content:KEY; 144, identifier:k; 145, identifier:dir; 146, string_content:DESC; 147, identifier:cmp; 148, identifier:cmp_func | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 5, 21; 5, 22; 6, 23; 6, 24; 7, 25; 7, 26; 8, 27; 9, 28; 10, 29; 11, 30; 12, 31; 13, 32; 14, 33; 15, 34; 16, 35; 17, 36; 18, 37; 19, 38; 20, 39; 29, 40; 29, 41; 30, 42; 30, 43; 31, 44; 31, 45; 32, 46; 32, 47; 33, 48; 33, 49; 34, 50; 34, 51; 35, 52; 35, 53; 36, 54; 36, 55; 37, 56; 37, 57; 38, 58; 38, 59; 41, 60; 41, 61; 43, 62; 43, 63; 45, 64; 45, 65; 47, 66; 47, 67; 49, 68; 49, 69; 51, 70; 51, 71; 53, 72; 53, 73; 55, 74; 55, 75; 57, 76; 57, 77; 59, 78; 59, 79; 59, 80; 60, 81; 60, 82; 61, 83; 61, 84; 62, 85; 62, 86; 63, 87; 65, 88; 65, 89; 67, 90; 67, 91; 69, 92; 69, 93; 69, 94; 71, 95; 71, 96; 72, 97; 72, 98; 73, 99; 73, 100; 75, 101; 75, 102; 77, 103; 77, 104; 80, 105; 80, 106; 83, 107; 87, 108; 87, 109; 89, 110; 89, 111; 90, 112; 90, 113; 91, 114; 92, 115; 92, 116; 93, 117; 93, 118; 94, 119; 97, 120; 98, 121; 98, 122; 104, 123; 104, 124; 106, 125; 110, 126; 110, 127; 111, 128; 121, 129; 121, 130; 121, 131; 122, 132; 122, 133; 125, 134; 125, 135; 128, 136; 128, 137; 129, 138; 130, 139; 130, 140; 135, 141; 135, 142; 137, 143; 139, 144; 139, 145; 140, 146; 142, 147; 142, 148 | def pipe_sort(context=None, _INPUT=None, conf=None, **kwargs):
"""An operator that sorts the input source according to the specified key.
Not loopable. Not lazy.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
kwargs -- other inputs, e.g. to feed terminals for rule values
conf : {
'KEY': [
{
'field': {'type': 'text', 'value': 'title'},
'dir': {'type': 'text', 'value': 'DESC'}
}
]
}
Returns
-------
_OUTPUT : generator of sorted items
"""
test = kwargs.pop('pass_if', None)
_pass = utils.get_pass(test=test)
key_defs = imap(DotDict, utils.listize(conf['KEY']))
get_value = partial(utils.get_value, **kwargs)
parse_conf = partial(utils.parse_conf, parse_func=get_value, **kwargs)
keys = imap(parse_conf, key_defs)
order = ('%s%s' % ('-' if k.dir == 'DESC' else '', k.field) for k in keys)
comparers = map(get_comparer, order)
cmp_func = partial(multikeysort, comparers=comparers)
_OUTPUT = _INPUT if _pass else iter(sorted(_INPUT, cmp=cmp_func))
return _OUTPUT |
0, module; 1, function_definition; 2, function_name:asyncPipeStringtokenizer; 3, parameters; 4, block; 5, default_parameter; 6, default_parameter; 7, default_parameter; 8, dictionary_splat_pattern; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, identifier:context; 17, None; 18, identifier:_INPUT; 19, None; 20, identifier:conf; 21, None; 22, identifier:kwargs; 23, comment:"""A string module that asynchronously splits a string into tokens
delimited by separators. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : twisted Deferred iterable of items or strings
conf : {
'to-str': {'value': <delimiter>},
'dedupe': {'type': 'bool', value': <1>},
'sort': {'type': 'bool', value': <1>}
}
Returns
-------
_OUTPUT : twisted.internet.defer.Deferred generator of items
"""; 24, assignment; 25, assignment; 26, assignment; 27, assignment; 28, assignment; 29, call; 30, subscript; 31, call; 32, identifier:splits; 33, yield; 34, identifier:parsed; 35, yield; 36, identifier:items; 37, yield; 38, identifier:_OUTPUT; 39, call; 40, identifier:returnValue; 41, argument_list; 42, identifier:conf; 43, string; 44, attribute; 45, argument_list; 46, call; 47, call; 48, call; 49, attribute; 50, argument_list; 51, identifier:_OUTPUT; 52, string_content:delimiter; 53, identifier:conf; 54, identifier:pop; 55, string; 56, call; 57, identifier:asyncGetSplits; 58, argument_list; 59, identifier:asyncDispatch; 60, argument_list; 61, identifier:asyncStarMap; 62, argument_list; 63, identifier:utils; 64, identifier:multiplex; 65, identifier:items; 66, string_content:to-str; 67, attribute; 68, argument_list; 69, identifier:_INPUT; 70, identifier:conf; 71, dictionary_splat; 72, identifier:splits; 73, list_splat; 74, call; 75, identifier:parsed; 76, identifier:dict; 77, identifier:get; 78, identifier:conf; 79, string; 80, call; 81, call; 82, identifier:partial; 83, argument_list; 84, string_content:delimiter; 85, identifier:cdicts; 86, argument_list; 87, identifier:get_async_dispatch_funcs; 88, argument_list; 89, identifier:maybeDeferred; 90, identifier:parse_result; 91, identifier:opts; 92, identifier:kwargs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 5, 16; 5, 17; 6, 18; 6, 19; 7, 20; 7, 21; 8, 22; 9, 23; 10, 24; 11, 25; 12, 26; 13, 27; 14, 28; 15, 29; 24, 30; 24, 31; 25, 32; 25, 33; 26, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 30, 42; 30, 43; 31, 44; 31, 45; 33, 46; 35, 47; 37, 48; 39, 49; 39, 50; 41, 51; 43, 52; 44, 53; 44, 54; 45, 55; 45, 56; 46, 57; 46, 58; 47, 59; 47, 60; 48, 61; 48, 62; 49, 63; 49, 64; 50, 65; 55, 66; 56, 67; 56, 68; 58, 69; 58, 70; 58, 71; 60, 72; 60, 73; 62, 74; 62, 75; 67, 76; 67, 77; 68, 78; 68, 79; 71, 80; 73, 81; 74, 82; 74, 83; 79, 84; 80, 85; 80, 86; 81, 87; 81, 88; 83, 89; 83, 90; 86, 91; 86, 92 | def asyncPipeStringtokenizer(context=None, _INPUT=None, conf=None, **kwargs):
"""A string module that asynchronously splits a string into tokens
delimited by separators. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : twisted Deferred iterable of items or strings
conf : {
'to-str': {'value': <delimiter>},
'dedupe': {'type': 'bool', value': <1>},
'sort': {'type': 'bool', value': <1>}
}
Returns
-------
_OUTPUT : twisted.internet.defer.Deferred generator of items
"""
conf['delimiter'] = conf.pop('to-str', dict.get(conf, 'delimiter'))
splits = yield asyncGetSplits(_INPUT, conf, **cdicts(opts, kwargs))
parsed = yield asyncDispatch(splits, *get_async_dispatch_funcs())
items = yield asyncStarMap(partial(maybeDeferred, parse_result), parsed)
_OUTPUT = utils.multiplex(items)
returnValue(_OUTPUT) |
0, module; 1, function_definition; 2, function_name:alphabeta; 3, parameters; 4, block; 5, identifier:game; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, comment:# base case - game is over; 10, if_statement; 11, if_statement; 12, comment:# recursive case - game is not over; 13, for_statement; 14, return_statement; 15, identifier:alpha_beta; 16, tuple; 17, identifier:player; 18, attribute; 19, string; 20, comparison_operator:game.result is not None; 21, block; 22, binary_operator:game.turn % 2; 23, comment:# minimizing player; 24, block; 25, else_clause; 26, pattern_list; 27, call; 28, block; 29, expression_list; 30, unary_operator; 31, call; 32, attribute; 33, identifier:identity; 34, string_content:Runs minimax search with alpha-beta pruning on the provided game.
:param Game game: game to search
:param tuple alpha_beta: a tuple of two floats that indicate
the initial values of alpha and beta,
respectively. The default is (-inf, inf).
:param callable player: player used to sort moves to be explored.
Ordering better moves first may significantly
reduce the amount of moves that need to be
explored. The identity player is the default.; 35, attribute; 36, None; 37, return_statement; 38, attribute; 39, integer:2; 40, expression_statement; 41, expression_statement; 42, expression_statement; 43, comment:# maximizing player; 44, block; 45, identifier:move; 46, identifier:new_game; 47, identifier:make_moves; 48, argument_list; 49, expression_statement; 50, if_statement; 51, identifier:best_moves; 52, identifier:best_value; 53, call; 54, identifier:float; 55, argument_list; 56, identifier:dominoes; 57, identifier:players; 58, identifier:game; 59, identifier:result; 60, expression_list; 61, identifier:game; 62, identifier:turn; 63, assignment; 64, assignment; 65, assignment; 66, expression_statement; 67, expression_statement; 68, expression_statement; 69, identifier:game; 70, identifier:player; 71, assignment; 72, call; 73, block; 74, identifier:float; 75, argument_list; 76, string; 77, list; 78, attribute; 79, identifier:best_value; 80, call; 81, identifier:op; 82, attribute; 83, identifier:update; 84, lambda; 85, assignment; 86, assignment; 87, assignment; 88, pattern_list; 89, call; 90, identifier:op; 91, argument_list; 92, expression_statement; 93, expression_statement; 94, expression_statement; 95, expression_statement; 96, if_statement; 97, string; 98, string_content:inf; 99, attribute; 100, identifier:points; 101, identifier:float; 102, argument_list; 103, identifier:operator; 104, identifier:lt; 105, lambda_parameters; 106, tuple; 107, identifier:best_value; 108, unary_operator; 109, identifier:op; 110, attribute; 111, identifier:update; 112, lambda; 113, identifier:moves; 114, identifier:value; 115, identifier:alphabeta; 116, argument_list; 117, identifier:value; 118, identifier:best_value; 119, assignment; 120, assignment; 121, call; 122, assignment; 123, comparison_operator:alpha_beta[1] <= alpha_beta[0]; 124, comment:# alpha-beta cutoff; 125, block; 126, string_content:inf; 127, identifier:game; 128, identifier:result; 129, string; 130, identifier:ab; 131, identifier:v; 132, subscript; 133, call; 134, call; 135, identifier:operator; 136, identifier:gt; 137, lambda_parameters; 138, tuple; 139, identifier:new_game; 140, identifier:alpha_beta; 141, identifier:player; 142, identifier:best_value; 143, identifier:value; 144, identifier:best_moves; 145, identifier:moves; 146, attribute; 147, argument_list; 148, identifier:alpha_beta; 149, call; 150, subscript; 151, subscript; 152, break_statement; 153, string_content:inf; 154, identifier:ab; 155, integer:0; 156, identifier:min; 157, argument_list; 158, identifier:float; 159, argument_list; 160, identifier:ab; 161, identifier:v; 162, call; 163, subscript; 164, identifier:best_moves; 165, identifier:insert; 166, integer:0; 167, identifier:move; 168, identifier:update; 169, argument_list; 170, identifier:alpha_beta; 171, integer:1; 172, identifier:alpha_beta; 173, integer:0; 174, subscript; 175, identifier:v; 176, string; 177, identifier:max; 178, argument_list; 179, identifier:ab; 180, integer:1; 181, identifier:alpha_beta; 182, identifier:best_value; 183, identifier:ab; 184, integer:1; 185, string_content:inf; 186, subscript; 187, identifier:v; 188, identifier:ab; 189, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 6, 16; 7, 17; 7, 18; 8, 19; 10, 20; 10, 21; 11, 22; 11, 23; 11, 24; 11, 25; 13, 26; 13, 27; 13, 28; 14, 29; 16, 30; 16, 31; 18, 32; 18, 33; 19, 34; 20, 35; 20, 36; 21, 37; 22, 38; 22, 39; 24, 40; 24, 41; 24, 42; 25, 43; 25, 44; 26, 45; 26, 46; 27, 47; 27, 48; 28, 49; 28, 50; 29, 51; 29, 52; 30, 53; 31, 54; 31, 55; 32, 56; 32, 57; 35, 58; 35, 59; 37, 60; 38, 61; 38, 62; 40, 63; 41, 64; 42, 65; 44, 66; 44, 67; 44, 68; 48, 69; 48, 70; 49, 71; 50, 72; 50, 73; 53, 74; 53, 75; 55, 76; 60, 77; 60, 78; 63, 79; 63, 80; 64, 81; 64, 82; 65, 83; 65, 84; 66, 85; 67, 86; 68, 87; 71, 88; 71, 89; 72, 90; 72, 91; 73, 92; 73, 93; 73, 94; 73, 95; 73, 96; 75, 97; 76, 98; 78, 99; 78, 100; 80, 101; 80, 102; 82, 103; 82, 104; 84, 105; 84, 106; 85, 107; 85, 108; 86, 109; 86, 110; 87, 111; 87, 112; 88, 113; 88, 114; 89, 115; 89, 116; 91, 117; 91, 118; 92, 119; 93, 120; 94, 121; 95, 122; 96, 123; 96, 124; 96, 125; 97, 126; 99, 127; 99, 128; 102, 129; 105, 130; 105, 131; 106, 132; 106, 133; 108, 134; 110, 135; 110, 136; 112, 137; 112, 138; 116, 139; 116, 140; 116, 141; 119, 142; 119, 143; 120, 144; 120, 145; 121, 146; 121, 147; 122, 148; 122, 149; 123, 150; 123, 151; 125, 152; 129, 153; 132, 154; 132, 155; 133, 156; 133, 157; 134, 158; 134, 159; 137, 160; 137, 161; 138, 162; 138, 163; 146, 164; 146, 165; 147, 166; 147, 167; 149, 168; 149, 169; 150, 170; 150, 171; 151, 172; 151, 173; 157, 174; 157, 175; 159, 176; 162, 177; 162, 178; 163, 179; 163, 180; 169, 181; 169, 182; 174, 183; 174, 184; 176, 185; 178, 186; 178, 187; 186, 188; 186, 189 | def alphabeta(game, alpha_beta=(-float('inf'), float('inf')),
player=dominoes.players.identity):
'''
Runs minimax search with alpha-beta pruning on the provided game.
:param Game game: game to search
:param tuple alpha_beta: a tuple of two floats that indicate
the initial values of alpha and beta,
respectively. The default is (-inf, inf).
:param callable player: player used to sort moves to be explored.
Ordering better moves first may significantly
reduce the amount of moves that need to be
explored. The identity player is the default.
'''
# base case - game is over
if game.result is not None:
return [], game.result.points
if game.turn % 2:
# minimizing player
best_value = float('inf')
op = operator.lt
update = lambda ab, v: (ab[0], min(ab[1], v))
else:
# maximizing player
best_value = -float('inf')
op = operator.gt
update = lambda ab, v: (max(ab[0], v), ab[1])
# recursive case - game is not over
for move, new_game in make_moves(game, player):
moves, value = alphabeta(new_game, alpha_beta, player)
if op(value, best_value):
best_value = value
best_moves = moves
best_moves.insert(0, move)
alpha_beta = update(alpha_beta, best_value)
if alpha_beta[1] <= alpha_beta[0]:
# alpha-beta cutoff
break
return best_moves, best_value |
0, module; 1, function_definition; 2, function_name:csv; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:d; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, expression_statement; 12, function_definition; 13, comment:# noinspection PyBroadException; 14, function_definition; 15, if_statement; 16, if_statement; 17, if_statement; 18, expression_statement; 19, expression_statement; 20, for_statement; 21, expression_statement; 22, for_statement; 23, return_statement; 24, identifier:order; 25, None; 26, identifier:header; 27, None; 28, identifier:sort_keys; 29, True; 30, comment:"""
prints a table in csv format
:param d: A a dict with dicts of the same type.
:type d: dict
:param order:The order in which the columns are printed.
The order is specified by the key names of the dict.
:type order:
:param header: The Header of each of the columns
:type header: list or tuple of field names
:param sort_keys: TODO: not yet implemented
:type sort_keys: bool
:return: a string representing the table in csv format
"""; 31, assignment; 32, function_name:_keys; 33, parameters; 34, block; 35, function_name:_get; 36, parameters; 37, block; 38, boolean_operator; 39, block; 40, comparison_operator:order is None; 41, block; 42, boolean_operator; 43, block; 44, elif_clause; 45, assignment; 46, assignment; 47, identifier:attribute; 48, identifier:order; 49, block; 50, assignment; 51, identifier:job; 52, identifier:d; 53, block; 54, identifier:table; 55, identifier:first_element; 56, subscript; 57, return_statement; 58, identifier:element; 59, identifier:key; 60, try_statement; 61, return_statement; 62, comparison_operator:d is None; 63, comparison_operator:d == {}; 64, return_statement; 65, identifier:order; 66, None; 67, expression_statement; 68, comparison_operator:header is None; 69, comparison_operator:order is not None; 70, expression_statement; 71, comparison_operator:header is None; 72, block; 73, identifier:table; 74, string:""; 75, identifier:content; 76, list; 77, expression_statement; 78, identifier:table; 79, binary_operator:table + ",".join([str(e) for e in content]) + "\n"; 80, expression_statement; 81, for_statement; 82, expression_statement; 83, call; 84, integer:0; 85, call; 86, block; 87, except_clause; 88, identifier:tmp; 89, identifier:d; 90, None; 91, identifier:d; 92, dictionary; 93, None; 94, assignment; 95, identifier:header; 96, None; 97, identifier:order; 98, None; 99, assignment; 100, identifier:header; 101, None; 102, expression_statement; 103, call; 104, binary_operator:table + ",".join([str(e) for e in content]); 105, string:"\n"; 106, assignment; 107, identifier:attribute; 108, identifier:order; 109, block; 110, assignment; 111, identifier:list; 112, argument_list; 113, identifier:list; 114, argument_list; 115, expression_statement; 116, block; 117, identifier:order; 118, call; 119, identifier:header; 120, identifier:order; 121, assignment; 122, attribute; 123, argument_list; 124, identifier:table; 125, call; 126, identifier:content; 127, list; 128, try_statement; 129, identifier:table; 130, binary_operator:table + ",".join([str(e) for e in content]) + "\n"; 131, identifier:d; 132, subscript; 133, assignment; 134, expression_statement; 135, identifier:_keys; 136, argument_list; 137, identifier:header; 138, call; 139, identifier:content; 140, identifier:append; 141, identifier:attribute; 142, attribute; 143, argument_list; 144, block; 145, except_clause; 146, binary_operator:table + ",".join([str(e) for e in content]); 147, string:"\n"; 148, identifier:d; 149, identifier:first_element; 150, identifier:tmp; 151, call; 152, assignment; 153, identifier:_keys; 154, argument_list; 155, string:","; 156, identifier:join; 157, list_comprehension; 158, expression_statement; 159, block; 160, identifier:table; 161, call; 162, identifier:str; 163, argument_list; 164, identifier:tmp; 165, string; 166, call; 167, for_in_clause; 168, call; 169, expression_statement; 170, attribute; 171, argument_list; 172, subscript; 173, string_content:; 174, identifier:str; 175, argument_list; 176, identifier:e; 177, identifier:content; 178, attribute; 179, argument_list; 180, call; 181, string:","; 182, identifier:join; 183, list_comprehension; 184, subscript; 185, identifier:key; 186, identifier:e; 187, identifier:content; 188, identifier:append; 189, subscript; 190, attribute; 191, argument_list; 192, call; 193, for_in_clause; 194, identifier:d; 195, identifier:element; 196, subscript; 197, identifier:attribute; 198, identifier:content; 199, identifier:append; 200, string:"None"; 201, identifier:str; 202, argument_list; 203, identifier:e; 204, identifier:content; 205, identifier:d; 206, identifier:job; 207, identifier:e | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 7, 24; 7, 25; 8, 26; 8, 27; 9, 28; 9, 29; 10, 30; 11, 31; 12, 32; 12, 33; 12, 34; 14, 35; 14, 36; 14, 37; 15, 38; 15, 39; 16, 40; 16, 41; 17, 42; 17, 43; 17, 44; 18, 45; 19, 46; 20, 47; 20, 48; 20, 49; 21, 50; 22, 51; 22, 52; 22, 53; 23, 54; 31, 55; 31, 56; 34, 57; 36, 58; 36, 59; 37, 60; 37, 61; 38, 62; 38, 63; 39, 64; 40, 65; 40, 66; 41, 67; 42, 68; 42, 69; 43, 70; 44, 71; 44, 72; 45, 73; 45, 74; 46, 75; 46, 76; 49, 77; 50, 78; 50, 79; 53, 80; 53, 81; 53, 82; 56, 83; 56, 84; 57, 85; 60, 86; 60, 87; 61, 88; 62, 89; 62, 90; 63, 91; 63, 92; 64, 93; 67, 94; 68, 95; 68, 96; 69, 97; 69, 98; 70, 99; 71, 100; 71, 101; 72, 102; 77, 103; 79, 104; 79, 105; 80, 106; 81, 107; 81, 108; 81, 109; 82, 110; 83, 111; 83, 112; 85, 113; 85, 114; 86, 115; 87, 116; 94, 117; 94, 118; 99, 119; 99, 120; 102, 121; 103, 122; 103, 123; 104, 124; 104, 125; 106, 126; 106, 127; 109, 128; 110, 129; 110, 130; 112, 131; 114, 132; 115, 133; 116, 134; 118, 135; 118, 136; 121, 137; 121, 138; 122, 139; 122, 140; 123, 141; 125, 142; 125, 143; 128, 144; 128, 145; 130, 146; 130, 147; 132, 148; 132, 149; 133, 150; 133, 151; 134, 152; 138, 153; 138, 154; 142, 155; 142, 156; 143, 157; 144, 158; 145, 159; 146, 160; 146, 161; 151, 162; 151, 163; 152, 164; 152, 165; 157, 166; 157, 167; 158, 168; 159, 169; 161, 170; 161, 171; 163, 172; 165, 173; 166, 174; 166, 175; 167, 176; 167, 177; 168, 178; 168, 179; 169, 180; 170, 181; 170, 182; 171, 183; 172, 184; 172, 185; 175, 186; 178, 187; 178, 188; 179, 189; 180, 190; 180, 191; 183, 192; 183, 193; 184, 194; 184, 195; 189, 196; 189, 197; 190, 198; 190, 199; 191, 200; 192, 201; 192, 202; 193, 203; 193, 204; 196, 205; 196, 206; 202, 207 | def csv(cls,
d,
order=None,
header=None,
sort_keys=True):
"""
prints a table in csv format
:param d: A a dict with dicts of the same type.
:type d: dict
:param order:The order in which the columns are printed.
The order is specified by the key names of the dict.
:type order:
:param header: The Header of each of the columns
:type header: list or tuple of field names
:param sort_keys: TODO: not yet implemented
:type sort_keys: bool
:return: a string representing the table in csv format
"""
first_element = list(d)[0]
def _keys():
return list(d[first_element])
# noinspection PyBroadException
def _get(element, key):
try:
tmp = str(d[element][key])
except:
tmp = ' '
return tmp
if d is None or d == {}:
return None
if order is None:
order = _keys()
if header is None and order is not None:
header = order
elif header is None:
header = _keys()
table = ""
content = []
for attribute in order:
content.append(attribute)
table = table + ",".join([str(e) for e in content]) + "\n"
for job in d:
content = []
for attribute in order:
try:
content.append(d[job][attribute])
except:
content.append("None")
table = table + ",".join([str(e) for e in content]) + "\n"
return table |
0, module; 1, function_definition; 2, function_name:deauthorize_application; 3, parameters; 4, block; 5, identifier:request; 6, expression_statement; 7, if_statement; 8, comment:"""
When a user deauthorizes an application, Facebook sends a HTTP POST request to the application's
"deauthorization callback" URL. This view picks up on requests of this sort and marks the corresponding
users as unauthorized.
"""; 9, attribute; 10, block; 11, else_clause; 12, identifier:request; 13, identifier:facebook; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, return_statement; 18, block; 19, assignment; 20, assignment; 21, call; 22, call; 23, return_statement; 24, identifier:user; 25, call; 26, attribute; 27, False; 28, attribute; 29, argument_list; 30, identifier:HttpResponse; 31, argument_list; 32, call; 33, attribute; 34, argument_list; 35, identifier:user; 36, identifier:authorized; 37, identifier:user; 38, identifier:save; 39, identifier:HttpResponse; 40, argument_list; 41, attribute; 42, identifier:get; 43, keyword_argument; 44, keyword_argument; 45, identifier:User; 46, identifier:objects; 47, identifier:facebook_id; 48, attribute; 49, identifier:status; 50, integer:400; 51, attribute; 52, identifier:id; 53, attribute; 54, identifier:user; 55, attribute; 56, identifier:signed_request; 57, identifier:request; 58, identifier:facebook | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 7, 10; 7, 11; 9, 12; 9, 13; 10, 14; 10, 15; 10, 16; 10, 17; 11, 18; 14, 19; 15, 20; 16, 21; 17, 22; 18, 23; 19, 24; 19, 25; 20, 26; 20, 27; 21, 28; 21, 29; 22, 30; 22, 31; 23, 32; 25, 33; 25, 34; 26, 35; 26, 36; 28, 37; 28, 38; 32, 39; 32, 40; 33, 41; 33, 42; 34, 43; 40, 44; 41, 45; 41, 46; 43, 47; 43, 48; 44, 49; 44, 50; 48, 51; 48, 52; 51, 53; 51, 54; 53, 55; 53, 56; 55, 57; 55, 58 | def deauthorize_application(request):
"""
When a user deauthorizes an application, Facebook sends a HTTP POST request to the application's
"deauthorization callback" URL. This view picks up on requests of this sort and marks the corresponding
users as unauthorized.
"""
if request.facebook:
user = User.objects.get(
facebook_id = request.facebook.signed_request.user.id
)
user.authorized = False
user.save()
return HttpResponse()
else:
return HttpResponse(status=400) |
0, module; 1, function_definition; 2, function_name:_handle_send_response; 3, parameters; 4, block; 5, identifier:self; 6, identifier:result; 7, identifier:payloadsByTopicPart; 8, identifier:deferredsByTopicPart; 9, expression_statement; 10, function_definition; 11, function_definition; 12, function_definition; 13, function_definition; 14, comment:# The payloads we need to retry, if we still can..; 15, expression_statement; 16, comment:# In the case we are sending requests without requiring acks, the; 17, comment:# brokerclient will immediately callback() the deferred upon send with; 18, comment:# None. In that case, we just iterate over all the deferreds in; 19, comment:# deferredsByTopicPart and callback them with None; 20, comment:# If we are expecting responses/acks, and we get an empty result, we; 21, comment:# callback with a Failure of NoResponseError; 22, if_statement; 23, comment:# Do we have results? Iterate over them and if the response indicates; 24, comment:# success, then callback the associated deferred. If the response; 25, comment:# indicates an error, then setup that request for retry.; 26, comment:# NOTE: In this case, each failed_payload get it's own error...; 27, for_statement; 28, comment:# Were there any failed requests to possibly retry?; 29, if_statement; 30, return_statement; 31, comment:"""Handle the response from our client to our send_produce_request
This is a bit complex. Failures can happen in a few ways:
1. The client sent an empty list, False, None or some similar thing
as the result, but we were expecting real responses.
2. The client had a failure before it even tried sending any requests
to any brokers.
a. Kafka error: See if we can retry the whole request
b. Non-kafka: Figure it's a programming error, fail all deferreds
3. The client sent all the requests (it's all or none) to the brokers
but one or more request failed (timed out before receiving a
response, or the brokerclient threw some sort of exception on send
In this case, the client throws FailedPayloadsError, and attaches
the responses (NOTE: some can have errors!), and the payloads
where the send itself failed to the exception.
4. The client sent all the requests, all responses were received, but
the Kafka broker indicated an error with servicing the request on
some of the responses.
"""; 32, function_name:_deliver_result; 33, parameters; 34, block; 35, function_name:_do_retry; 36, parameters; 37, comment:# We use 'fail_on_error=False' because we want our client to; 38, comment:# process every response that comes back from the brokers so; 39, comment:# we can determine which requests were successful, and which; 40, comment:# failed for retry; 41, block; 42, function_name:_cancel_retry; 43, parameters; 44, comment:# Cancel the retry callLater and pass-thru the failure; 45, block; 46, function_name:_check_retry_payloads; 47, parameters; 48, block; 49, assignment; 50, not_operator; 51, comment:# Success, but no results, is that what we're expecting?; 52, block; 53, elif_clause; 54, identifier:res; 55, identifier:result; 56, block; 57, identifier:failed_payloads; 58, block; 59, identifier:d_list; 60, default_parameter; 61, expression_statement; 62, for_statement; 63, identifier:payloads; 64, expression_statement; 65, expression_statement; 66, comment:# add our handlers; 67, expression_statement; 68, return_statement; 69, identifier:failure; 70, identifier:dc; 71, expression_statement; 72, comment:# cancel all the top-level deferreds associated with the request; 73, expression_statement; 74, return_statement; 75, identifier:failed_payloads_with_errs; 76, expression_statement; 77, comment:# Do we have retries left?; 78, if_statement; 79, comment:# Retries remain! Schedule one...; 80, expression_statement; 81, expression_statement; 82, expression_statement; 83, comment:# Cancel the callLater when request is cancelled before it fires; 84, expression_statement; 85, comment:# Reset the topic metadata for all topics which had failed_requests; 86, comment:# where the failures were of the kind UnknownTopicOrPartitionError; 87, comment:# or NotLeaderForPartitionError, since those indicate our client's; 88, comment:# metadata is out of date.; 89, expression_statement; 90, for_statement; 91, if_statement; 92, expression_statement; 93, return_statement; 94, identifier:failed_payloads; 95, list; 96, identifier:result; 97, if_statement; 98, expression_statement; 99, return_statement; 100, call; 101, comment:# Failure! Was it total, or partial?; 102, block; 103, expression_statement; 104, expression_statement; 105, if_statement; 106, return_statement; 107, identifier:result; 108, None; 109, comment:"""Possibly callback each deferred in a list with single result"""; 110, identifier:d; 111, identifier:d_list; 112, block; 113, assignment; 114, augmented_assignment; 115, call; 116, identifier:d; 117, call; 118, call; 119, identifier:failure; 120, comment:"""Check our retry count and retry after a delay or errback
If we have more retries to try, create a deferred that will fire
with the result of delayed retry. If not, errback the remaining
deferreds with failure
Params:
failed_payloads - list of (payload, failure) tuples
"""; 121, comparison_operator:self._req_attempts >= self._max_attempts; 122, comment:# No, no retries left, fail each failed_payload with its; 123, comment:# associated failure; 124, block; 125, assignment; 126, assignment; 127, augmented_assignment; 128, call; 129, assignment; 130, pattern_list; 131, identifier:failed_payloads; 132, block; 133, identifier:reset_topics; 134, block; 135, call; 136, identifier:d; 137, comparison_operator:self.req_acks == PRODUCER_ACK_NOT_REQUIRED; 138, block; 139, else_clause; 140, call; 141, identifier:isinstance; 142, argument_list; 143, if_statement; 144, assignment; 145, assignment; 146, not_operator; 147, comment:# Success for this topic/partition; 148, block; 149, else_clause; 150, call; 151, if_statement; 152, identifier:d; 153, call; 154, attribute; 155, integer:1; 156, attribute; 157, argument_list; 158, attribute; 159, argument_list; 160, identifier:_deliver_result; 161, argument_list; 162, attribute; 163, attribute; 164, for_statement; 165, return_statement; 166, identifier:d; 167, call; 168, identifier:dc; 169, call; 170, attribute; 171, attribute; 172, attribute; 173, argument_list; 174, identifier:reset_topics; 175, call; 176, identifier:payload; 177, identifier:e; 178, if_statement; 179, expression_statement; 180, attribute; 181, argument_list; 182, attribute; 183, identifier:PRODUCER_ACK_NOT_REQUIRED; 184, expression_statement; 185, comment:# We got no result, but we were expecting one? Fail everything!; 186, block; 187, identifier:_deliver_result; 188, argument_list; 189, identifier:result; 190, identifier:Failure; 191, not_operator; 192, comment:# Total failure of some sort!; 193, comment:# The client was unable to send the request at all. If it's; 194, comment:# a KafkaError (probably Leader/Partition unavailable), retry; 195, block; 196, else_clause; 197, identifier:t_and_p; 198, call; 199, identifier:t_and_p_err; 200, call; 201, identifier:t_and_p_err; 202, expression_statement; 203, expression_statement; 204, block; 205, identifier:_check_retry_payloads; 206, argument_list; 207, not_operator; 208, comment:# nested list...; 209, block; 210, else_clause; 211, attribute; 212, argument_list; 213, identifier:self; 214, identifier:_req_attempts; 215, identifier:d; 216, identifier:addBoth; 217, attribute; 218, identifier:payloadsByTopicPart; 219, identifier:deferredsByTopicPart; 220, identifier:dc; 221, identifier:cancel; 222, call; 223, identifier:failure; 224, identifier:self; 225, identifier:_req_attempts; 226, identifier:self; 227, identifier:_max_attempts; 228, pattern_list; 229, identifier:failed_payloads_with_errs; 230, block; 231, identifier:Deferred; 232, argument_list; 233, attribute; 234, argument_list; 235, identifier:self; 236, identifier:_retry_interval; 237, identifier:self; 238, identifier:RETRY_INTERVAL_FACTOR; 239, identifier:d; 240, identifier:addErrback; 241, identifier:_cancel_retry; 242, identifier:dc; 243, identifier:set; 244, argument_list; 245, parenthesized_expression; 246, block; 247, call; 248, identifier:d; 249, identifier:addCallback; 250, identifier:_do_retry; 251, identifier:self; 252, identifier:req_acks; 253, assignment; 254, expression_statement; 255, call; 256, identifier:result; 257, call; 258, if_statement; 259, comment:# FailedPayloadsError: This means that some/all of the; 260, comment:# requests to a/some brokerclients failed to send.; 261, comment:# Pull the successful responses and the failed_payloads off; 262, comment:# the exception and handle them below. Preserve the; 263, comment:# FailedPayloadsError as 'failure'; 264, block; 265, identifier:TopicAndPartition; 266, argument_list; 267, identifier:_check_error; 268, argument_list; 269, assignment; 270, call; 271, expression_statement; 272, expression_statement; 273, identifier:failed_payloads; 274, call; 275, expression_statement; 276, comment:# We check d.called since the request could have been; 277, comment:# cancelled while we waited for the response; 278, block; 279, attribute; 280, identifier:send_produce_request; 281, identifier:payloads; 282, keyword_argument; 283, keyword_argument; 284, keyword_argument; 285, identifier:self; 286, identifier:_handle_send_response; 287, attribute; 288, argument_list; 289, identifier:p; 290, identifier:f; 291, expression_statement; 292, expression_statement; 293, attribute; 294, identifier:callLater; 295, attribute; 296, attribute; 297, list_comprehension; 298, boolean_operator; 299, expression_statement; 300, attribute; 301, argument_list; 302, identifier:result; 303, None; 304, assignment; 305, attribute; 306, argument_list; 307, attribute; 308, argument_list; 309, call; 310, comment:# Yep, a kafak error. Set failed_payloads, and we'll retry; 311, comment:# them all below. Set failure for errback to callers if we; 312, comment:# are all out of retries; 313, block; 314, else_clause; 315, expression_statement; 316, expression_statement; 317, expression_statement; 318, attribute; 319, attribute; 320, identifier:res; 321, keyword_argument; 322, identifier:d_list; 323, subscript; 324, identifier:_deliver_result; 325, argument_list; 326, assignment; 327, call; 328, identifier:isinstance; 329, argument_list; 330, call; 331, if_statement; 332, identifier:self; 333, identifier:client; 334, identifier:acks; 335, attribute; 336, identifier:timeout; 337, attribute; 338, identifier:fail_on_error; 339, False; 340, identifier:deferredsByTopicPart; 341, identifier:values; 342, assignment; 343, call; 344, attribute; 345, identifier:reactor; 346, identifier:self; 347, identifier:_retry_interval; 348, identifier:d; 349, identifier:callback; 350, identifier:p; 351, for_in_clause; 352, call; 353, call; 354, call; 355, attribute; 356, identifier:reset_topic_metadata; 357, list_splat; 358, identifier:result; 359, call; 360, identifier:deferredsByTopicPart; 361, identifier:values; 362, identifier:result; 363, identifier:check; 364, identifier:FailedPayloadsError; 365, attribute; 366, argument_list; 367, expression_statement; 368, comment:# no succesful results, retry; 369, expression_statement; 370, comment:# Was the request cancelled?; 371, block; 372, assignment; 373, assignment; 374, assignment; 375, identifier:res; 376, identifier:topic; 377, identifier:res; 378, identifier:partition; 379, identifier:raiseException; 380, False; 381, identifier:deferredsByTopicPart; 382, identifier:t_and_p; 383, identifier:d_list; 384, identifier:res; 385, identifier:p; 386, subscript; 387, attribute; 388, argument_list; 389, identifier:d; 390, identifier:Deferred; 391, identifier:_deliver_result; 392, argument_list; 393, not_operator; 394, block; 395, identifier:self; 396, identifier:req_acks; 397, identifier:self; 398, identifier:ack_timeout; 399, identifier:t_and_p; 400, call; 401, identifier:_deliver_result; 402, argument_list; 403, identifier:self; 404, identifier:client; 405, pattern_list; 406, identifier:failed_payloads; 407, identifier:isinstance; 408, argument_list; 409, identifier:isinstance; 410, argument_list; 411, attribute; 412, argument_list; 413, identifier:self; 414, identifier:client; 415, identifier:reset_topics; 416, identifier:Failure; 417, argument_list; 418, identifier:result; 419, identifier:check; 420, identifier:KafkaError; 421, assignment; 422, assignment; 423, if_statement; 424, comment:# Cancelled, or programming error, we fail the requests; 425, expression_statement; 426, return_statement; 427, identifier:failure; 428, identifier:result; 429, identifier:result; 430, subscript; 431, identifier:failed_payloads; 432, subscript; 433, identifier:payloadsByTopicPart; 434, identifier:t_and_p; 435, identifier:failed_payloads; 436, identifier:append; 437, tuple; 438, identifier:d; 439, identifier:result; 440, attribute; 441, expression_statement; 442, identifier:TopicAndPartition; 443, argument_list; 444, subscript; 445, identifier:f; 446, identifier:p; 447, identifier:f; 448, identifier:e; 449, identifier:NotLeaderForPartitionError; 450, identifier:e; 451, identifier:UnknownTopicOrPartitionError; 452, identifier:reset_topics; 453, identifier:add; 454, attribute; 455, call; 456, pattern_list; 457, expression_list; 458, identifier:failed_payloads; 459, list_comprehension; 460, not_operator; 461, comment:# Uh Oh, programming error? Log it!; 462, block; 463, call; 464, attribute; 465, integer:0; 466, attribute; 467, integer:1; 468, identifier:p; 469, identifier:t_and_p_err; 470, identifier:d; 471, identifier:called; 472, call; 473, attribute; 474, attribute; 475, identifier:deferredsByTopicPart; 476, identifier:t_and_p; 477, identifier:payload; 478, identifier:topic; 479, identifier:NoResponseError; 480, argument_list; 481, identifier:failure; 482, identifier:result; 483, identifier:result; 484, list; 485, tuple; 486, for_in_clause; 487, call; 488, expression_statement; 489, identifier:_deliver_result; 490, argument_list; 491, attribute; 492, identifier:args; 493, attribute; 494, identifier:args; 495, attribute; 496, argument_list; 497, identifier:p; 498, identifier:topic; 499, identifier:p; 500, identifier:partition; 501, identifier:p; 502, identifier:failure; 503, identifier:p; 504, call; 505, attribute; 506, argument_list; 507, call; 508, call; 509, identifier:result; 510, identifier:failure; 511, identifier:value; 512, identifier:failure; 513, identifier:value; 514, identifier:d; 515, identifier:callback; 516, identifier:result; 517, attribute; 518, argument_list; 519, identifier:result; 520, identifier:check; 521, identifier:tid_CancelledError; 522, attribute; 523, argument_list; 524, attribute; 525, argument_list; 526, identifier:payloadsByTopicPart; 527, identifier:values; 528, identifier:log; 529, identifier:error; 530, concatenated_string; 531, identifier:result; 532, identifier:deferredsByTopicPart; 533, identifier:values; 534, string:"Unexpected failure: %r in "; 535, string:"_handle_send_response" |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| def _handle_send_response(self, result, payloadsByTopicPart,
deferredsByTopicPart):
"""Handle the response from our client to our send_produce_request
This is a bit complex. Failures can happen in a few ways:
1. The client sent an empty list, False, None or some similar thing
as the result, but we were expecting real responses.
2. The client had a failure before it even tried sending any requests
to any brokers.
a. Kafka error: See if we can retry the whole request
b. Non-kafka: Figure it's a programming error, fail all deferreds
3. The client sent all the requests (it's all or none) to the brokers
but one or more request failed (timed out before receiving a
response, or the brokerclient threw some sort of exception on send
In this case, the client throws FailedPayloadsError, and attaches
the responses (NOTE: some can have errors!), and the payloads
where the send itself failed to the exception.
4. The client sent all the requests, all responses were received, but
the Kafka broker indicated an error with servicing the request on
some of the responses.
"""
def _deliver_result(d_list, result=None):
"""Possibly callback each deferred in a list with single result"""
for d in d_list:
if not isinstance(d, Deferred):
# nested list...
_deliver_result(d, result)
else:
# We check d.called since the request could have been
# cancelled while we waited for the response
if not d.called:
d.callback(result)
def _do_retry(payloads):
# We use 'fail_on_error=False' because we want our client to
# process every response that comes back from the brokers so
# we can determine which requests were successful, and which
# failed for retry
d = self.client.send_produce_request(
payloads, acks=self.req_acks, timeout=self.ack_timeout,
fail_on_error=False)
self._req_attempts += 1
# add our handlers
d.addBoth(self._handle_send_response, payloadsByTopicPart,
deferredsByTopicPart)
return d
def _cancel_retry(failure, dc):
# Cancel the retry callLater and pass-thru the failure
dc.cancel()
# cancel all the top-level deferreds associated with the request
_deliver_result(deferredsByTopicPart.values(), failure)
return failure
def _check_retry_payloads(failed_payloads_with_errs):
"""Check our retry count and retry after a delay or errback
If we have more retries to try, create a deferred that will fire
with the result of delayed retry. If not, errback the remaining
deferreds with failure
Params:
failed_payloads - list of (payload, failure) tuples
"""
# Do we have retries left?
if self._req_attempts >= self._max_attempts:
# No, no retries left, fail each failed_payload with its
# associated failure
for p, f in failed_payloads_with_errs:
t_and_p = TopicAndPartition(p.topic, p.partition)
_deliver_result(deferredsByTopicPart[t_and_p], f)
return
# Retries remain! Schedule one...
d = Deferred()
dc = self.client.reactor.callLater(
self._retry_interval, d.callback, [p for p, f in
failed_payloads])
self._retry_interval *= self.RETRY_INTERVAL_FACTOR
# Cancel the callLater when request is cancelled before it fires
d.addErrback(_cancel_retry, dc)
# Reset the topic metadata for all topics which had failed_requests
# where the failures were of the kind UnknownTopicOrPartitionError
# or NotLeaderForPartitionError, since those indicate our client's
# metadata is out of date.
reset_topics = set()
for payload, e in failed_payloads:
if (isinstance(e, NotLeaderForPartitionError) or
isinstance(e, UnknownTopicOrPartitionError)):
reset_topics.add(payload.topic)
if reset_topics:
self.client.reset_topic_metadata(*reset_topics)
d.addCallback(_do_retry)
return d
# The payloads we need to retry, if we still can..
failed_payloads = []
# In the case we are sending requests without requiring acks, the
# brokerclient will immediately callback() the deferred upon send with
# None. In that case, we just iterate over all the deferreds in
# deferredsByTopicPart and callback them with None
# If we are expecting responses/acks, and we get an empty result, we
# callback with a Failure of NoResponseError
if not result:
# Success, but no results, is that what we're expecting?
if self.req_acks == PRODUCER_ACK_NOT_REQUIRED:
result = None
else:
# We got no result, but we were expecting one? Fail everything!
result = Failure(NoResponseError())
_deliver_result(deferredsByTopicPart.values(), result)
return
elif isinstance(result, Failure):
# Failure! Was it total, or partial?
if not result.check(FailedPayloadsError):
# Total failure of some sort!
# The client was unable to send the request at all. If it's
# a KafkaError (probably Leader/Partition unavailable), retry
if result.check(KafkaError):
# Yep, a kafak error. Set failed_payloads, and we'll retry
# them all below. Set failure for errback to callers if we
# are all out of retries
failure, result = result, [] # no succesful results, retry
failed_payloads = [(p, failure) for p in
payloadsByTopicPart.values()]
else:
# Was the request cancelled?
if not result.check(tid_CancelledError):
# Uh Oh, programming error? Log it!
log.error("Unexpected failure: %r in "
"_handle_send_response", result)
# Cancelled, or programming error, we fail the requests
_deliver_result(deferredsByTopicPart.values(), result)
return
else:
# FailedPayloadsError: This means that some/all of the
# requests to a/some brokerclients failed to send.
# Pull the successful responses and the failed_payloads off
# the exception and handle them below. Preserve the
# FailedPayloadsError as 'failure'
failure = result
result = failure.value.args[0]
failed_payloads = failure.value.args[1]
# Do we have results? Iterate over them and if the response indicates
# success, then callback the associated deferred. If the response
# indicates an error, then setup that request for retry.
# NOTE: In this case, each failed_payload get it's own error...
for res in result:
t_and_p = TopicAndPartition(res.topic, res.partition)
t_and_p_err = _check_error(res, raiseException=False)
if not t_and_p_err:
# Success for this topic/partition
d_list = deferredsByTopicPart[t_and_p]
_deliver_result(d_list, res)
else:
p = payloadsByTopicPart[t_and_p]
failed_payloads.append((p, t_and_p_err))
# Were there any failed requests to possibly retry?
if failed_payloads:
return _check_retry_payloads(failed_payloads)
return |
0, module; 1, function_definition; 2, function_name:ordering_url; 3, parameters; 4, block; 5, identifier:self; 6, identifier:field_name; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, expression_statement; 15, comment:# copy the list; 16, for_statement; 17, expression_statement; 18, for_statement; 19, expression_statement; 20, return_statement; 21, comment:"""
Creates a url link for sorting the given field.
The direction of sorting will be either ascending, if the field is not
yet sorted, or the opposite of the current sorting if sorted.
"""; 22, assignment; 23, assignment; 24, assignment; 25, assignment; 26, assignment; 27, not_operator; 28, block; 29, assignment; 30, identifier:ordering_field; 31, call; 32, block; 33, assignment; 34, identifier:item; 35, identifier:merged_ordering; 36, block; 37, assignment; 38, tuple; 39, identifier:path; 40, attribute; 41, identifier:direction; 42, string:""; 43, identifier:query_params; 44, call; 45, identifier:ordering; 46, call; 47, identifier:field; 48, call; 49, identifier:ordering; 50, expression_statement; 51, identifier:merged_ordering; 52, call; 53, attribute; 54, argument_list; 55, if_statement; 56, identifier:new_ordering; 57, list; 58, if_statement; 59, subscript; 60, call; 61, binary_operator:path + "?" + query_params.urlencode(safe=","); 62, identifier:direction; 63, attribute; 64, identifier:path; 65, attribute; 66, argument_list; 67, attribute; 68, argument_list; 69, attribute; 70, argument_list; 71, assignment; 72, identifier:list; 73, argument_list; 74, identifier:self; 75, identifier:get_ordering_fields_lookups; 76, boolean_operator; 77, block; 78, comparison_operator:item.lstrip("-") == field.lstrip("-"); 79, block; 80, identifier:query_params; 81, string:"order"; 82, attribute; 83, argument_list; 84, binary_operator:path + "?"; 85, call; 86, identifier:self; 87, identifier:request; 88, attribute; 89, identifier:copy; 90, call; 91, identifier:split; 92, string:","; 93, identifier:self; 94, identifier:_get_ordering_field_lookup; 95, identifier:field_name; 96, identifier:ordering; 97, call; 98, identifier:ordering; 99, parenthesized_expression; 100, parenthesized_expression; 101, expression_statement; 102, call; 103, call; 104, if_statement; 105, string:","; 106, identifier:join; 107, identifier:new_ordering; 108, identifier:path; 109, string:"?"; 110, attribute; 111, argument_list; 112, attribute; 113, identifier:GET; 114, attribute; 115, argument_list; 116, attribute; 117, argument_list; 118, comparison_operator:ordering_field.lstrip("-") not in ordering; 119, comparison_operator:("-" + ordering_field.lstrip("-")) not in ordering; 120, call; 121, attribute; 122, argument_list; 123, attribute; 124, argument_list; 125, boolean_operator; 126, block; 127, else_clause; 128, identifier:query_params; 129, identifier:urlencode; 130, keyword_argument; 131, identifier:self; 132, identifier:request; 133, attribute; 134, identifier:get; 135, string:"order"; 136, string:""; 137, identifier:self; 138, identifier:get_default_ordering; 139, call; 140, identifier:ordering; 141, parenthesized_expression; 142, identifier:ordering; 143, attribute; 144, argument_list; 145, identifier:item; 146, identifier:lstrip; 147, string:"-"; 148, identifier:field; 149, identifier:lstrip; 150, string:"-"; 151, parenthesized_expression; 152, not_operator; 153, if_statement; 154, expression_statement; 155, block; 156, identifier:safe; 157, string:","; 158, attribute; 159, identifier:GET; 160, attribute; 161, argument_list; 162, binary_operator:"-" + ordering_field.lstrip("-"); 163, identifier:merged_ordering; 164, identifier:append; 165, identifier:ordering_field; 166, comparison_operator:item[0] == "-"; 167, parenthesized_expression; 168, comparison_operator:item in ordering; 169, block; 170, call; 171, expression_statement; 172, expression_statement; 173, identifier:self; 174, identifier:request; 175, identifier:ordering_field; 176, identifier:lstrip; 177, string:"-"; 178, string:"-"; 179, call; 180, subscript; 181, string:"-"; 182, comparison_operator:item in ordering; 183, identifier:item; 184, identifier:ordering; 185, expression_statement; 186, attribute; 187, argument_list; 188, assignment; 189, call; 190, attribute; 191, argument_list; 192, identifier:item; 193, integer:0; 194, identifier:item; 195, identifier:ordering; 196, assignment; 197, identifier:new_ordering; 198, identifier:insert; 199, integer:0; 200, call; 201, identifier:direction; 202, string:"asc"; 203, attribute; 204, argument_list; 205, identifier:ordering_field; 206, identifier:lstrip; 207, string:"-"; 208, identifier:direction; 209, string:"desc"; 210, attribute; 211, argument_list; 212, identifier:new_ordering; 213, identifier:insert; 214, integer:0; 215, binary_operator:"-" + item; 216, identifier:item; 217, identifier:lstrip; 218, string:"-"; 219, string:"-"; 220, identifier:item | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 7, 21; 8, 22; 9, 23; 10, 24; 11, 25; 12, 26; 13, 27; 13, 28; 14, 29; 16, 30; 16, 31; 16, 32; 17, 33; 18, 34; 18, 35; 18, 36; 19, 37; 20, 38; 22, 39; 22, 40; 23, 41; 23, 42; 24, 43; 24, 44; 25, 45; 25, 46; 26, 47; 26, 48; 27, 49; 28, 50; 29, 51; 29, 52; 31, 53; 31, 54; 32, 55; 33, 56; 33, 57; 36, 58; 37, 59; 37, 60; 38, 61; 38, 62; 40, 63; 40, 64; 44, 65; 44, 66; 46, 67; 46, 68; 48, 69; 48, 70; 50, 71; 52, 72; 52, 73; 53, 74; 53, 75; 55, 76; 55, 77; 58, 78; 58, 79; 59, 80; 59, 81; 60, 82; 60, 83; 61, 84; 61, 85; 63, 86; 63, 87; 65, 88; 65, 89; 67, 90; 67, 91; 68, 92; 69, 93; 69, 94; 70, 95; 71, 96; 71, 97; 73, 98; 76, 99; 76, 100; 77, 101; 78, 102; 78, 103; 79, 104; 82, 105; 82, 106; 83, 107; 84, 108; 84, 109; 85, 110; 85, 111; 88, 112; 88, 113; 90, 114; 90, 115; 97, 116; 97, 117; 99, 118; 100, 119; 101, 120; 102, 121; 102, 122; 103, 123; 103, 124; 104, 125; 104, 126; 104, 127; 110, 128; 110, 129; 111, 130; 112, 131; 112, 132; 114, 133; 114, 134; 115, 135; 115, 136; 116, 137; 116, 138; 118, 139; 118, 140; 119, 141; 119, 142; 120, 143; 120, 144; 121, 145; 121, 146; 122, 147; 123, 148; 123, 149; 124, 150; 125, 151; 125, 152; 126, 153; 126, 154; 127, 155; 130, 156; 130, 157; 133, 158; 133, 159; 139, 160; 139, 161; 141, 162; 143, 163; 143, 164; 144, 165; 151, 166; 152, 167; 153, 168; 153, 169; 154, 170; 155, 171; 155, 172; 158, 173; 158, 174; 160, 175; 160, 176; 161, 177; 162, 178; 162, 179; 166, 180; 166, 181; 167, 182; 168, 183; 168, 184; 169, 185; 170, 186; 170, 187; 171, 188; 172, 189; 179, 190; 179, 191; 180, 192; 180, 193; 182, 194; 182, 195; 185, 196; 186, 197; 186, 198; 187, 199; 187, 200; 188, 201; 188, 202; 189, 203; 189, 204; 190, 205; 190, 206; 191, 207; 196, 208; 196, 209; 200, 210; 200, 211; 203, 212; 203, 213; 204, 214; 204, 215; 210, 216; 210, 217; 211, 218; 215, 219; 215, 220 | def ordering_url(self, field_name):
"""
Creates a url link for sorting the given field.
The direction of sorting will be either ascending, if the field is not
yet sorted, or the opposite of the current sorting if sorted.
"""
path = self.request.path
direction = ""
query_params = self.request.GET.copy()
ordering = self.request.GET.get("order", "").split(",")
field = self._get_ordering_field_lookup(field_name)
if not ordering:
ordering = self.get_default_ordering()
merged_ordering = list(ordering) # copy the list
for ordering_field in self.get_ordering_fields_lookups():
if (ordering_field.lstrip("-") not in ordering) and (
("-" + ordering_field.lstrip("-")) not in ordering
):
merged_ordering.append(ordering_field)
new_ordering = []
for item in merged_ordering:
if item.lstrip("-") == field.lstrip("-"):
if (item[0] == "-") or not (item in ordering):
if item in ordering:
direction = "desc"
new_ordering.insert(0, item.lstrip("-"))
else:
direction = "asc"
new_ordering.insert(0, "-" + item)
query_params["order"] = ",".join(new_ordering)
return (path + "?" + query_params.urlencode(safe=","), direction) |
0, module; 1, function_definition; 2, function_name:load_maf; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, comment:# pylint: disable=no-member; 13, comment:# pylint gets confused by read_csv inside load_maf_dataframe; 14, expression_statement; 15, if_statement; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, for_statement; 20, return_statement; 21, identifier:optional_cols; 22, list; 23, identifier:sort_key; 24, identifier:variant_ascending_position_sort_key; 25, identifier:distinct; 26, True; 27, identifier:raise_on_error; 28, True; 29, identifier:encoding; 30, None; 31, comment:"""
Load reference name and Variant objects from MAF filename.
Parameters
----------
path : str
Path to MAF (*.maf).
optional_cols : list, optional
A list of MAF columns to include as metadata if they are present in the MAF.
Does not result in an error if those columns are not present.
sort_key : fn
Function which maps each element to a sorting criterion.
Set to None to not to sort the variants.
distinct : bool
Don't keep repeated variants
raise_on_error : bool
Raise an exception upon encountering an error or just log a warning.
encoding : str, optional
Encoding to use for UTF when reading MAF file.
"""; 32, assignment; 33, boolean_operator; 34, block; 35, assignment; 36, assignment; 37, assignment; 38, pattern_list; 39, call; 40, block; 41, call; 42, identifier:maf_df; 43, call; 44, comparison_operator:len(maf_df) == 0; 45, identifier:raise_on_error; 46, raise_statement; 47, identifier:ensembl_objects; 48, dictionary; 49, identifier:variants; 50, list; 51, identifier:metadata; 52, dictionary; 53, identifier:_; 54, identifier:x; 55, attribute; 56, argument_list; 57, expression_statement; 58, if_statement; 59, expression_statement; 60, expression_statement; 61, comment:# it's possible in a MAF file to have multiple Ensembl releases; 62, comment:# mixed in a single MAF file (the genome assembly is; 63, comment:# specified by the NCBI_Build column); 64, expression_statement; 65, if_statement; 66, comment:# have to try both Tumor_Seq_Allele1 and Tumor_Seq_Allele2; 67, comment:# to figure out which is different from the reference allele; 68, if_statement; 69, expression_statement; 70, comment:# keep metadata about the variant and its TCGA annotation; 71, expression_statement; 72, for_statement; 73, expression_statement; 74, identifier:VariantCollection; 75, argument_list; 76, identifier:load_maf_dataframe; 77, argument_list; 78, call; 79, integer:0; 80, call; 81, identifier:maf_df; 82, identifier:iterrows; 83, assignment; 84, call; 85, block; 86, assignment; 87, assignment; 88, assignment; 89, comparison_operator:ncbi_build in ensembl_objects; 90, block; 91, else_clause; 92, comparison_operator:x.Tumor_Seq_Allele1 != ref; 93, block; 94, else_clause; 95, assignment; 96, assignment; 97, identifier:optional_col; 98, identifier:optional_cols; 99, block; 100, call; 101, keyword_argument; 102, keyword_argument; 103, keyword_argument; 104, keyword_argument; 105, identifier:path; 106, keyword_argument; 107, keyword_argument; 108, identifier:len; 109, argument_list; 110, identifier:ValueError; 111, argument_list; 112, identifier:contig; 113, attribute; 114, identifier:isnull; 115, argument_list; 116, expression_statement; 117, if_statement; 118, identifier:start_pos; 119, attribute; 120, identifier:ref; 121, attribute; 122, identifier:ncbi_build; 123, attribute; 124, identifier:ncbi_build; 125, identifier:ensembl_objects; 126, expression_statement; 127, block; 128, attribute; 129, identifier:ref; 130, expression_statement; 131, block; 132, identifier:variant; 133, call; 134, subscript; 135, dictionary; 136, if_statement; 137, attribute; 138, argument_list; 139, identifier:variants; 140, identifier:variants; 141, identifier:source_to_metadata_dict; 142, dictionary; 143, identifier:sort_key; 144, identifier:sort_key; 145, identifier:distinct; 146, identifier:distinct; 147, identifier:raise_on_error; 148, identifier:raise_on_error; 149, identifier:encoding; 150, identifier:encoding; 151, identifier:maf_df; 152, binary_operator:"Empty MAF file %s" % path; 153, identifier:x; 154, identifier:Chromosome; 155, identifier:contig; 156, assignment; 157, identifier:raise_on_error; 158, block; 159, else_clause; 160, identifier:x; 161, identifier:Start_Position; 162, identifier:x; 163, identifier:Reference_Allele; 164, identifier:x; 165, identifier:NCBI_Build; 166, assignment; 167, if_statement; 168, expression_statement; 169, expression_statement; 170, identifier:x; 171, identifier:Tumor_Seq_Allele1; 172, assignment; 173, if_statement; 174, expression_statement; 175, identifier:Variant; 176, argument_list; 177, identifier:metadata; 178, identifier:variant; 179, pair; 180, pair; 181, pair; 182, pair; 183, pair; 184, pair; 185, pair; 186, pair; 187, pair; 188, comparison_operator:optional_col in x; 189, block; 190, identifier:variants; 191, identifier:append; 192, identifier:variant; 193, pair; 194, string:"Empty MAF file %s"; 195, identifier:path; 196, identifier:error_message; 197, binary_operator:"Invalid contig name: %s" % (contig,); 198, raise_statement; 199, block; 200, identifier:ensembl; 201, subscript; 202, call; 203, block; 204, else_clause; 205, assignment; 206, assignment; 207, identifier:alt; 208, attribute; 209, comparison_operator:x.Tumor_Seq_Allele2 == ref; 210, block; 211, assignment; 212, identifier:contig; 213, identifier:start_pos; 214, call; 215, call; 216, keyword_argument; 217, string; 218, attribute; 219, string; 220, attribute; 221, string; 222, attribute; 223, string; 224, attribute; 225, string; 226, attribute; 227, string; 228, attribute; 229, string; 230, attribute; 231, string; 232, attribute; 233, string; 234, attribute; 235, identifier:optional_col; 236, identifier:x; 237, expression_statement; 238, identifier:path; 239, identifier:metadata; 240, string:"Invalid contig name: %s"; 241, tuple; 242, call; 243, expression_statement; 244, continue_statement; 245, identifier:ensembl_objects; 246, identifier:ncbi_build; 247, identifier:isinstance; 248, argument_list; 249, expression_statement; 250, block; 251, identifier:ensembl; 252, call; 253, subscript; 254, identifier:ensembl; 255, identifier:x; 256, identifier:Tumor_Seq_Allele1; 257, attribute; 258, identifier:ref; 259, expression_statement; 260, if_statement; 261, identifier:alt; 262, attribute; 263, identifier:str; 264, argument_list; 265, identifier:str; 266, argument_list; 267, identifier:ensembl; 268, identifier:ensembl; 269, string_content:Hugo_Symbol; 270, identifier:x; 271, identifier:Hugo_Symbol; 272, string_content:Center; 273, identifier:x; 274, identifier:Center; 275, string_content:Strand; 276, identifier:x; 277, identifier:Strand; 278, string_content:Variant_Classification; 279, identifier:x; 280, identifier:Variant_Classification; 281, string_content:Variant_Type; 282, identifier:x; 283, identifier:Variant_Type; 284, string_content:dbSNP_RS; 285, identifier:x; 286, identifier:dbSNP_RS; 287, string_content:dbSNP_Val_Status; 288, identifier:x; 289, identifier:dbSNP_Val_Status; 290, string_content:Tumor_Sample_Barcode; 291, identifier:x; 292, identifier:Tumor_Sample_Barcode; 293, string_content:Matched_Norm_Sample_Barcode; 294, identifier:x; 295, identifier:Matched_Norm_Sample_Barcode; 296, assignment; 297, identifier:contig; 298, identifier:ValueError; 299, argument_list; 300, call; 301, identifier:ncbi_build; 302, identifier:int; 303, assignment; 304, expression_statement; 305, identifier:infer_genome; 306, argument_list; 307, identifier:ensembl_objects; 308, identifier:ncbi_build; 309, identifier:x; 310, identifier:Tumor_Seq_Allele2; 311, assignment; 312, identifier:raise_on_error; 313, block; 314, else_clause; 315, identifier:x; 316, identifier:Tumor_Seq_Allele2; 317, identifier:ref; 318, identifier:alt; 319, subscript; 320, subscript; 321, identifier:error_message; 322, attribute; 323, argument_list; 324, identifier:reference_name; 325, binary_operator:"B%d" % ncbi_build; 326, assignment; 327, identifier:reference_name; 328, identifier:error_message; 329, parenthesized_expression; 330, raise_statement; 331, block; 332, subscript; 333, identifier:optional_col; 334, identifier:x; 335, identifier:optional_col; 336, identifier:logging; 337, identifier:warn; 338, identifier:error_message; 339, string:"B%d"; 340, identifier:ncbi_build; 341, identifier:reference_name; 342, call; 343, binary_operator:"Both tumor alleles agree with reference %s: %s" % (
ref, x,); 344, call; 345, expression_statement; 346, continue_statement; 347, identifier:metadata; 348, identifier:variant; 349, identifier:str; 350, argument_list; 351, string:"Both tumor alleles agree with reference %s: %s"; 352, tuple; 353, identifier:ValueError; 354, argument_list; 355, call; 356, identifier:ncbi_build; 357, identifier:ref; 358, identifier:x; 359, identifier:error_message; 360, attribute; 361, argument_list; 362, identifier:logging; 363, identifier:warn; 364, identifier:error_message | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 6, 21; 6, 22; 7, 23; 7, 24; 8, 25; 8, 26; 9, 27; 9, 28; 10, 29; 10, 30; 11, 31; 14, 32; 15, 33; 15, 34; 16, 35; 17, 36; 18, 37; 19, 38; 19, 39; 19, 40; 20, 41; 32, 42; 32, 43; 33, 44; 33, 45; 34, 46; 35, 47; 35, 48; 36, 49; 36, 50; 37, 51; 37, 52; 38, 53; 38, 54; 39, 55; 39, 56; 40, 57; 40, 58; 40, 59; 40, 60; 40, 61; 40, 62; 40, 63; 40, 64; 40, 65; 40, 66; 40, 67; 40, 68; 40, 69; 40, 70; 40, 71; 40, 72; 40, 73; 41, 74; 41, 75; 43, 76; 43, 77; 44, 78; 44, 79; 46, 80; 55, 81; 55, 82; 57, 83; 58, 84; 58, 85; 59, 86; 60, 87; 64, 88; 65, 89; 65, 90; 65, 91; 68, 92; 68, 93; 68, 94; 69, 95; 71, 96; 72, 97; 72, 98; 72, 99; 73, 100; 75, 101; 75, 102; 75, 103; 75, 104; 77, 105; 77, 106; 77, 107; 78, 108; 78, 109; 80, 110; 80, 111; 83, 112; 83, 113; 84, 114; 84, 115; 85, 116; 85, 117; 86, 118; 86, 119; 87, 120; 87, 121; 88, 122; 88, 123; 89, 124; 89, 125; 90, 126; 91, 127; 92, 128; 92, 129; 93, 130; 94, 131; 95, 132; 95, 133; 96, 134; 96, 135; 99, 136; 100, 137; 100, 138; 101, 139; 101, 140; 102, 141; 102, 142; 103, 143; 103, 144; 104, 145; 104, 146; 106, 147; 106, 148; 107, 149; 107, 150; 109, 151; 111, 152; 113, 153; 113, 154; 115, 155; 116, 156; 117, 157; 117, 158; 117, 159; 119, 160; 119, 161; 121, 162; 121, 163; 123, 164; 123, 165; 126, 166; 127, 167; 127, 168; 127, 169; 128, 170; 128, 171; 130, 172; 131, 173; 131, 174; 133, 175; 133, 176; 134, 177; 134, 178; 135, 179; 135, 180; 135, 181; 135, 182; 135, 183; 135, 184; 135, 185; 135, 186; 135, 187; 136, 188; 136, 189; 137, 190; 137, 191; 138, 192; 142, 193; 152, 194; 152, 195; 156, 196; 156, 197; 158, 198; 159, 199; 166, 200; 166, 201; 167, 202; 167, 203; 167, 204; 168, 205; 169, 206; 172, 207; 172, 208; 173, 209; 173, 210; 174, 211; 176, 212; 176, 213; 176, 214; 176, 215; 176, 216; 179, 217; 179, 218; 180, 219; 180, 220; 181, 221; 181, 222; 182, 223; 182, 224; 183, 225; 183, 226; 184, 227; 184, 228; 185, 229; 185, 230; 186, 231; 186, 232; 187, 233; 187, 234; 188, 235; 188, 236; 189, 237; 193, 238; 193, 239; 197, 240; 197, 241; 198, 242; 199, 243; 199, 244; 201, 245; 201, 246; 202, 247; 202, 248; 203, 249; 204, 250; 205, 251; 205, 252; 206, 253; 206, 254; 208, 255; 208, 256; 209, 257; 209, 258; 210, 259; 210, 260; 211, 261; 211, 262; 214, 263; 214, 264; 215, 265; 215, 266; 216, 267; 216, 268; 217, 269; 218, 270; 218, 271; 219, 272; 220, 273; 220, 274; 221, 275; 222, 276; 222, 277; 223, 278; 224, 279; 224, 280; 225, 281; 226, 282; 226, 283; 227, 284; 228, 285; 228, 286; 229, 287; 230, 288; 230, 289; 231, 290; 232, 291; 232, 292; 233, 293; 234, 294; 234, 295; 237, 296; 241, 297; 242, 298; 242, 299; 243, 300; 248, 301; 248, 302; 249, 303; 250, 304; 252, 305; 252, 306; 253, 307; 253, 308; 257, 309; 257, 310; 259, 311; 260, 312; 260, 313; 260, 314; 262, 315; 262, 316; 264, 317; 266, 318; 296, 319; 296, 320; 299, 321; 300, 322; 300, 323; 303, 324; 303, 325; 304, 326; 306, 327; 311, 328; 311, 329; 313, 330; 314, 331; 319, 332; 319, 333; 320, 334; 320, 335; 322, 336; 322, 337; 323, 338; 325, 339; 325, 340; 326, 341; 326, 342; 329, 343; 330, 344; 331, 345; 331, 346; 332, 347; 332, 348; 342, 349; 342, 350; 343, 351; 343, 352; 344, 353; 344, 354; 345, 355; 350, 356; 352, 357; 352, 358; 354, 359; 355, 360; 355, 361; 360, 362; 360, 363; 361, 364 | def load_maf(
path,
optional_cols=[],
sort_key=variant_ascending_position_sort_key,
distinct=True,
raise_on_error=True,
encoding=None):
"""
Load reference name and Variant objects from MAF filename.
Parameters
----------
path : str
Path to MAF (*.maf).
optional_cols : list, optional
A list of MAF columns to include as metadata if they are present in the MAF.
Does not result in an error if those columns are not present.
sort_key : fn
Function which maps each element to a sorting criterion.
Set to None to not to sort the variants.
distinct : bool
Don't keep repeated variants
raise_on_error : bool
Raise an exception upon encountering an error or just log a warning.
encoding : str, optional
Encoding to use for UTF when reading MAF file.
"""
# pylint: disable=no-member
# pylint gets confused by read_csv inside load_maf_dataframe
maf_df = load_maf_dataframe(path, raise_on_error=raise_on_error, encoding=encoding)
if len(maf_df) == 0 and raise_on_error:
raise ValueError("Empty MAF file %s" % path)
ensembl_objects = {}
variants = []
metadata = {}
for _, x in maf_df.iterrows():
contig = x.Chromosome
if isnull(contig):
error_message = "Invalid contig name: %s" % (contig,)
if raise_on_error:
raise ValueError(error_message)
else:
logging.warn(error_message)
continue
start_pos = x.Start_Position
ref = x.Reference_Allele
# it's possible in a MAF file to have multiple Ensembl releases
# mixed in a single MAF file (the genome assembly is
# specified by the NCBI_Build column)
ncbi_build = x.NCBI_Build
if ncbi_build in ensembl_objects:
ensembl = ensembl_objects[ncbi_build]
else:
if isinstance(ncbi_build, int):
reference_name = "B%d" % ncbi_build
else:
reference_name = str(ncbi_build)
ensembl = infer_genome(reference_name)
ensembl_objects[ncbi_build] = ensembl
# have to try both Tumor_Seq_Allele1 and Tumor_Seq_Allele2
# to figure out which is different from the reference allele
if x.Tumor_Seq_Allele1 != ref:
alt = x.Tumor_Seq_Allele1
else:
if x.Tumor_Seq_Allele2 == ref:
error_message = (
"Both tumor alleles agree with reference %s: %s" % (
ref, x,))
if raise_on_error:
raise ValueError(error_message)
else:
logging.warn(error_message)
continue
alt = x.Tumor_Seq_Allele2
variant = Variant(
contig,
start_pos,
str(ref),
str(alt),
ensembl=ensembl)
# keep metadata about the variant and its TCGA annotation
metadata[variant] = {
'Hugo_Symbol': x.Hugo_Symbol,
'Center': x.Center,
'Strand': x.Strand,
'Variant_Classification': x.Variant_Classification,
'Variant_Type': x.Variant_Type,
'dbSNP_RS': x.dbSNP_RS,
'dbSNP_Val_Status': x.dbSNP_Val_Status,
'Tumor_Sample_Barcode': x.Tumor_Sample_Barcode,
'Matched_Norm_Sample_Barcode': x.Matched_Norm_Sample_Barcode,
}
for optional_col in optional_cols:
if optional_col in x:
metadata[variant][optional_col] = x[optional_col]
variants.append(variant)
return VariantCollection(
variants=variants,
source_to_metadata_dict={path: metadata},
sort_key=sort_key,
distinct=distinct) |
0, module; 1, function_definition; 2, function_name:load_vcf; 3, parameters; 4, block; 5, identifier:path; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, default_parameter; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, if_statement; 19, comment:# Loading a local file.; 20, comment:# The file will be opened twice: first to parse the header with pyvcf, then; 21, comment:# by pandas to read the data.; 22, comment:# PyVCF reads the metadata immediately and stops at the first line with; 23, comment:# data. We can close the file after that.; 24, expression_statement; 25, expression_statement; 26, expression_statement; 27, expression_statement; 28, if_statement; 29, return_statement; 30, identifier:genome; 31, None; 32, identifier:reference_vcf_key; 33, string:"reference"; 34, identifier:only_passing; 35, True; 36, identifier:allow_extended_nucleotides; 37, False; 38, identifier:include_info; 39, True; 40, identifier:chunk_size; 41, binary_operator:10 ** 5; 42, identifier:max_variants; 43, None; 44, identifier:sort_key; 45, identifier:variant_ascending_position_sort_key; 46, identifier:distinct; 47, True; 48, comment:"""
Load reference name and Variant objects from the given VCF filename.
Currently only local files are supported by this function (no http). If you
call this on an HTTP URL, it will fall back to `load_vcf`.
Parameters
----------
path : str
Path to VCF (*.vcf) or compressed VCF (*.vcf.gz).
genome : {pyensembl.Genome, reference name, Ensembl version int}, optional
Optionally pass in a PyEnsembl Genome object, name of reference, or
PyEnsembl release version to specify the reference associated with a
VCF (otherwise infer reference from VCF using reference_vcf_key)
reference_vcf_key : str, optional
Name of metadata field which contains path to reference FASTA
file (default = 'reference')
only_passing : boolean, optional
If true, any entries whose FILTER field is not one of "." or "PASS" is
dropped.
allow_extended_nucleotides : boolean, default False
Allow characters other that A,C,T,G in the ref and alt strings.
include_info : boolean, default True
Whether to parse the INFO and per-sample columns. If you don't need
these, set to False for faster parsing.
chunk_size: int, optional
Number of records to load in memory at once.
max_variants : int, optional
If specified, return only the first max_variants variants.
sort_key : fn
Function which maps each element to a sorting criterion.
Set to None to not to sort the variants.
distinct : boolean, default True
Don't keep repeated variants
"""; 49, call; 50, assignment; 51, boolean_operator; 52, comment:# pandas.read_table nominally supports HTTP, but it tends to crash on; 53, comment:# large files and does not support gzip. Switching to the python-based; 54, comment:# implementation of read_table (with engine="python") helps with some; 55, comment:# issues but introduces a new set of problems (e.g. the dtype parameter; 56, comment:# is not accepted). For these reasons, we're currently not attempting; 57, comment:# to load VCFs over HTTP with pandas directly, and instead download it; 58, comment:# to a temporary file and open that.; 59, block; 60, assignment; 61, call; 62, assignment; 63, assignment; 64, identifier:include_info; 65, block; 66, else_clause; 67, call; 68, integer:10; 69, integer:5; 70, identifier:require_string; 71, argument_list; 72, identifier:parsed_path; 73, call; 74, attribute; 75, comparison_operator:parsed_path.scheme.lower() != "file"; 76, expression_statement; 77, try_statement; 78, identifier:handle; 79, call; 80, attribute; 81, argument_list; 82, identifier:genome; 83, call; 84, identifier:df_iterator; 85, call; 86, function_definition; 87, block; 88, identifier:dataframes_to_variant_collection; 89, argument_list; 90, identifier:path; 91, string:"Path or URL to VCF"; 92, identifier:parse_url_or_path; 93, argument_list; 94, identifier:parsed_path; 95, identifier:scheme; 96, call; 97, string:"file"; 98, assignment; 99, comment:# The downloaded file has no file extension, which confuses pyvcf; 100, comment:# for gziped files in Python 3. We rename it to have the correct; 101, comment:# file extension.; 102, block; 103, finally_clause; 104, identifier:PyVCFReaderFromPathOrURL; 105, argument_list; 106, identifier:handle; 107, identifier:close; 108, identifier:infer_genome_from_vcf; 109, argument_list; 110, identifier:read_vcf_into_dataframe; 111, argument_list; 112, function_name:sample_info_parser; 113, parameters; 114, block; 115, expression_statement; 116, identifier:df_iterator; 117, keyword_argument; 118, keyword_argument; 119, keyword_argument; 120, keyword_argument; 121, keyword_argument; 122, keyword_argument; 123, keyword_argument; 124, keyword_argument; 125, identifier:path; 126, attribute; 127, argument_list; 128, tuple_pattern; 129, call; 130, expression_statement; 131, expression_statement; 132, expression_statement; 133, return_statement; 134, block; 135, identifier:path; 136, identifier:genome; 137, attribute; 138, identifier:reference_vcf_key; 139, identifier:path; 140, keyword_argument; 141, keyword_argument; 142, keyword_argument; 143, identifier:unparsed_sample_info_strings; 144, identifier:format_string; 145, expression_statement; 146, return_statement; 147, assignment; 148, identifier:source_path; 149, identifier:path; 150, identifier:info_parser; 151, conditional_expression:handle.vcf_reader._parse_info if include_info else None; 152, identifier:only_passing; 153, identifier:only_passing; 154, identifier:max_variants; 155, identifier:max_variants; 156, identifier:sample_names; 157, conditional_expression:handle.vcf_reader.samples if include_info else None; 158, identifier:sample_info_parser; 159, identifier:sample_info_parser; 160, identifier:variant_kwargs; 161, dictionary; 162, identifier:variant_collection_kwargs; 163, dictionary; 164, attribute; 165, identifier:lower; 166, identifier:filename; 167, identifier:headers; 168, attribute; 169, argument_list; 170, assignment; 171, call; 172, assignment; 173, call; 174, expression_statement; 175, expression_statement; 176, identifier:handle; 177, identifier:vcf_reader; 178, identifier:include_info; 179, identifier:include_info; 180, identifier:sample_names; 181, conditional_expression:handle.vcf_reader.samples if include_info else None; 182, identifier:chunk_size; 183, identifier:chunk_size; 184, comment:"""
Given a format string like "GT:AD:ADP:DP:FS"
and a list of sample info strings where each entry is like
"0/1:3,22:T=3,G=22:25:33", return a dict that maps:
sample name -> field name -> value. Uses pyvcf to parse the fields.
"""; 185, call; 186, identifier:sample_info_parser; 187, None; 188, attribute; 189, identifier:include_info; 190, None; 191, attribute; 192, identifier:include_info; 193, None; 194, pair; 195, pair; 196, pair; 197, pair; 198, identifier:parsed_path; 199, identifier:scheme; 200, attribute; 201, identifier:urlretrieve; 202, identifier:path; 203, identifier:new_filename; 204, binary_operator:"%s.%s" % (
filename, parsed_path.path.split(".")[-1]); 205, attribute; 206, argument_list; 207, identifier:filename; 208, identifier:new_filename; 209, identifier:load_vcf; 210, argument_list; 211, call; 212, call; 213, attribute; 214, identifier:include_info; 215, None; 216, identifier:pyvcf_calls_to_sample_info_list; 217, argument_list; 218, attribute; 219, identifier:_parse_info; 220, attribute; 221, identifier:samples; 222, string; 223, identifier:genome; 224, string; 225, identifier:allow_extended_nucleotides; 226, string; 227, identifier:sort_key; 228, string; 229, identifier:distinct; 230, identifier:urllib; 231, identifier:request; 232, string:"%s.%s"; 233, tuple; 234, identifier:os; 235, identifier:rename; 236, identifier:filename; 237, identifier:new_filename; 238, identifier:filename; 239, keyword_argument; 240, keyword_argument; 241, keyword_argument; 242, keyword_argument; 243, keyword_argument; 244, keyword_argument; 245, keyword_argument; 246, keyword_argument; 247, keyword_argument; 248, attribute; 249, argument_list; 250, attribute; 251, argument_list; 252, attribute; 253, identifier:samples; 254, call; 255, identifier:handle; 256, identifier:vcf_reader; 257, identifier:handle; 258, identifier:vcf_reader; 259, string_content:ensembl; 260, string_content:allow_extended_nucleotides; 261, string_content:sort_key; 262, string_content:distinct; 263, identifier:filename; 264, subscript; 265, identifier:genome; 266, identifier:genome; 267, identifier:reference_vcf_key; 268, identifier:reference_vcf_key; 269, identifier:only_passing; 270, identifier:only_passing; 271, identifier:allow_extended_nucleotides; 272, identifier:allow_extended_nucleotides; 273, identifier:include_info; 274, identifier:include_info; 275, identifier:chunk_size; 276, identifier:chunk_size; 277, identifier:max_variants; 278, identifier:max_variants; 279, identifier:sort_key; 280, identifier:sort_key; 281, identifier:distinct; 282, identifier:distinct; 283, identifier:logger; 284, identifier:info; 285, string:"Removing temporary file: %s"; 286, identifier:filename; 287, identifier:os; 288, identifier:unlink; 289, identifier:filename; 290, identifier:handle; 291, identifier:vcf_reader; 292, attribute; 293, argument_list; 294, call; 295, unary_operator; 296, attribute; 297, identifier:_parse_samples; 298, identifier:unparsed_sample_info_strings; 299, identifier:format_string; 300, None; 301, attribute; 302, argument_list; 303, integer:1; 304, identifier:handle; 305, identifier:vcf_reader; 306, attribute; 307, identifier:split; 308, string:"."; 309, identifier:parsed_path; 310, identifier:path | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 3, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 6, 30; 6, 31; 7, 32; 7, 33; 8, 34; 8, 35; 9, 36; 9, 37; 10, 38; 10, 39; 11, 40; 11, 41; 12, 42; 12, 43; 13, 44; 13, 45; 14, 46; 14, 47; 15, 48; 16, 49; 17, 50; 18, 51; 18, 52; 18, 53; 18, 54; 18, 55; 18, 56; 18, 57; 18, 58; 18, 59; 24, 60; 25, 61; 26, 62; 27, 63; 28, 64; 28, 65; 28, 66; 29, 67; 41, 68; 41, 69; 49, 70; 49, 71; 50, 72; 50, 73; 51, 74; 51, 75; 59, 76; 59, 77; 60, 78; 60, 79; 61, 80; 61, 81; 62, 82; 62, 83; 63, 84; 63, 85; 65, 86; 66, 87; 67, 88; 67, 89; 71, 90; 71, 91; 73, 92; 73, 93; 74, 94; 74, 95; 75, 96; 75, 97; 76, 98; 77, 99; 77, 100; 77, 101; 77, 102; 77, 103; 79, 104; 79, 105; 80, 106; 80, 107; 83, 108; 83, 109; 85, 110; 85, 111; 86, 112; 86, 113; 86, 114; 87, 115; 89, 116; 89, 117; 89, 118; 89, 119; 89, 120; 89, 121; 89, 122; 89, 123; 89, 124; 93, 125; 96, 126; 96, 127; 98, 128; 98, 129; 102, 130; 102, 131; 102, 132; 102, 133; 103, 134; 105, 135; 109, 136; 109, 137; 109, 138; 111, 139; 111, 140; 111, 141; 111, 142; 113, 143; 113, 144; 114, 145; 114, 146; 115, 147; 117, 148; 117, 149; 118, 150; 118, 151; 119, 152; 119, 153; 120, 154; 120, 155; 121, 156; 121, 157; 122, 158; 122, 159; 123, 160; 123, 161; 124, 162; 124, 163; 126, 164; 126, 165; 128, 166; 128, 167; 129, 168; 129, 169; 130, 170; 131, 171; 132, 172; 133, 173; 134, 174; 134, 175; 137, 176; 137, 177; 140, 178; 140, 179; 141, 180; 141, 181; 142, 182; 142, 183; 145, 184; 146, 185; 147, 186; 147, 187; 151, 188; 151, 189; 151, 190; 157, 191; 157, 192; 157, 193; 161, 194; 161, 195; 163, 196; 163, 197; 164, 198; 164, 199; 168, 200; 168, 201; 169, 202; 170, 203; 170, 204; 171, 205; 171, 206; 172, 207; 172, 208; 173, 209; 173, 210; 174, 211; 175, 212; 181, 213; 181, 214; 181, 215; 185, 216; 185, 217; 188, 218; 188, 219; 191, 220; 191, 221; 194, 222; 194, 223; 195, 224; 195, 225; 196, 226; 196, 227; 197, 228; 197, 229; 200, 230; 200, 231; 204, 232; 204, 233; 205, 234; 205, 235; 206, 236; 206, 237; 210, 238; 210, 239; 210, 240; 210, 241; 210, 242; 210, 243; 210, 244; 210, 245; 210, 246; 210, 247; 211, 248; 211, 249; 212, 250; 212, 251; 213, 252; 213, 253; 217, 254; 218, 255; 218, 256; 220, 257; 220, 258; 222, 259; 224, 260; 226, 261; 228, 262; 233, 263; 233, 264; 239, 265; 239, 266; 240, 267; 240, 268; 241, 269; 241, 270; 242, 271; 242, 272; 243, 273; 243, 274; 244, 275; 244, 276; 245, 277; 245, 278; 246, 279; 246, 280; 247, 281; 247, 282; 248, 283; 248, 284; 249, 285; 249, 286; 250, 287; 250, 288; 251, 289; 252, 290; 252, 291; 254, 292; 254, 293; 264, 294; 264, 295; 292, 296; 292, 297; 293, 298; 293, 299; 293, 300; 294, 301; 294, 302; 295, 303; 296, 304; 296, 305; 301, 306; 301, 307; 302, 308; 306, 309; 306, 310 | def load_vcf(
path,
genome=None,
reference_vcf_key="reference",
only_passing=True,
allow_extended_nucleotides=False,
include_info=True,
chunk_size=10 ** 5,
max_variants=None,
sort_key=variant_ascending_position_sort_key,
distinct=True):
"""
Load reference name and Variant objects from the given VCF filename.
Currently only local files are supported by this function (no http). If you
call this on an HTTP URL, it will fall back to `load_vcf`.
Parameters
----------
path : str
Path to VCF (*.vcf) or compressed VCF (*.vcf.gz).
genome : {pyensembl.Genome, reference name, Ensembl version int}, optional
Optionally pass in a PyEnsembl Genome object, name of reference, or
PyEnsembl release version to specify the reference associated with a
VCF (otherwise infer reference from VCF using reference_vcf_key)
reference_vcf_key : str, optional
Name of metadata field which contains path to reference FASTA
file (default = 'reference')
only_passing : boolean, optional
If true, any entries whose FILTER field is not one of "." or "PASS" is
dropped.
allow_extended_nucleotides : boolean, default False
Allow characters other that A,C,T,G in the ref and alt strings.
include_info : boolean, default True
Whether to parse the INFO and per-sample columns. If you don't need
these, set to False for faster parsing.
chunk_size: int, optional
Number of records to load in memory at once.
max_variants : int, optional
If specified, return only the first max_variants variants.
sort_key : fn
Function which maps each element to a sorting criterion.
Set to None to not to sort the variants.
distinct : boolean, default True
Don't keep repeated variants
"""
require_string(path, "Path or URL to VCF")
parsed_path = parse_url_or_path(path)
if parsed_path.scheme and parsed_path.scheme.lower() != "file":
# pandas.read_table nominally supports HTTP, but it tends to crash on
# large files and does not support gzip. Switching to the python-based
# implementation of read_table (with engine="python") helps with some
# issues but introduces a new set of problems (e.g. the dtype parameter
# is not accepted). For these reasons, we're currently not attempting
# to load VCFs over HTTP with pandas directly, and instead download it
# to a temporary file and open that.
(filename, headers) = urllib.request.urlretrieve(path)
try:
# The downloaded file has no file extension, which confuses pyvcf
# for gziped files in Python 3. We rename it to have the correct
# file extension.
new_filename = "%s.%s" % (
filename, parsed_path.path.split(".")[-1])
os.rename(filename, new_filename)
filename = new_filename
return load_vcf(
filename,
genome=genome,
reference_vcf_key=reference_vcf_key,
only_passing=only_passing,
allow_extended_nucleotides=allow_extended_nucleotides,
include_info=include_info,
chunk_size=chunk_size,
max_variants=max_variants,
sort_key=sort_key,
distinct=distinct)
finally:
logger.info("Removing temporary file: %s", filename)
os.unlink(filename)
# Loading a local file.
# The file will be opened twice: first to parse the header with pyvcf, then
# by pandas to read the data.
# PyVCF reads the metadata immediately and stops at the first line with
# data. We can close the file after that.
handle = PyVCFReaderFromPathOrURL(path)
handle.close()
genome = infer_genome_from_vcf(
genome,
handle.vcf_reader,
reference_vcf_key)
df_iterator = read_vcf_into_dataframe(
path,
include_info=include_info,
sample_names=handle.vcf_reader.samples if include_info else None,
chunk_size=chunk_size)
if include_info:
def sample_info_parser(unparsed_sample_info_strings, format_string):
"""
Given a format string like "GT:AD:ADP:DP:FS"
and a list of sample info strings where each entry is like
"0/1:3,22:T=3,G=22:25:33", return a dict that maps:
sample name -> field name -> value. Uses pyvcf to parse the fields.
"""
return pyvcf_calls_to_sample_info_list(
handle.vcf_reader._parse_samples(
unparsed_sample_info_strings, format_string, None))
else:
sample_info_parser = None
return dataframes_to_variant_collection(
df_iterator,
source_path=path,
info_parser=handle.vcf_reader._parse_info if include_info else None,
only_passing=only_passing,
max_variants=max_variants,
sample_names=handle.vcf_reader.samples if include_info else None,
sample_info_parser=sample_info_parser,
variant_kwargs={
'ensembl': genome,
'allow_extended_nucleotides': allow_extended_nucleotides},
variant_collection_kwargs={
'sort_key': sort_key,
'distinct': distinct}) |
0, module; 1, function_definition; 2, function_name:top_expression_effect; 3, parameters; 4, block; 5, identifier:self; 6, identifier:expression_levels; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, function_definition; 11, return_statement; 12, comment:"""
Return effect whose transcript has the highest expression level.
If none of the effects are expressed or have associated transcripts,
then return None. In case of ties, add lexicographical sorting by
effect priority and transcript length.
"""; 13, assignment; 14, comparison_operator:len(effect_expression_dict) == 0; 15, block; 16, function_name:key_fn; 17, parameters; 18, block; 19, subscript; 20, identifier:effect_expression_dict; 21, call; 22, call; 23, integer:0; 24, return_statement; 25, identifier:effect_fpkm_pair; 26, expression_statement; 27, expression_statement; 28, return_statement; 29, call; 30, integer:0; 31, attribute; 32, argument_list; 33, identifier:len; 34, argument_list; 35, None; 36, comment:"""
Sort effects primarily by their expression level
and secondarily by the priority logic used in
`top_priority_effect`.
"""; 37, assignment; 38, tuple; 39, identifier:max; 40, argument_list; 41, identifier:self; 42, identifier:effect_expression; 43, identifier:expression_levels; 44, identifier:effect_expression_dict; 45, tuple_pattern; 46, identifier:effect_fpkm_pair; 47, identifier:fpkm; 48, call; 49, call; 50, keyword_argument; 51, identifier:effect; 52, identifier:fpkm; 53, identifier:multi_gene_effect_sort_key; 54, argument_list; 55, attribute; 56, argument_list; 57, identifier:key; 58, identifier:key_fn; 59, identifier:effect; 60, identifier:effect_expression_dict; 61, identifier:items | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 9, 14; 9, 15; 10, 16; 10, 17; 10, 18; 11, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 17, 25; 18, 26; 18, 27; 18, 28; 19, 29; 19, 30; 21, 31; 21, 32; 22, 33; 22, 34; 24, 35; 26, 36; 27, 37; 28, 38; 29, 39; 29, 40; 31, 41; 31, 42; 32, 43; 34, 44; 37, 45; 37, 46; 38, 47; 38, 48; 40, 49; 40, 50; 45, 51; 45, 52; 48, 53; 48, 54; 49, 55; 49, 56; 50, 57; 50, 58; 54, 59; 55, 60; 55, 61 | def top_expression_effect(self, expression_levels):
"""
Return effect whose transcript has the highest expression level.
If none of the effects are expressed or have associated transcripts,
then return None. In case of ties, add lexicographical sorting by
effect priority and transcript length.
"""
effect_expression_dict = self.effect_expression(expression_levels)
if len(effect_expression_dict) == 0:
return None
def key_fn(effect_fpkm_pair):
"""
Sort effects primarily by their expression level
and secondarily by the priority logic used in
`top_priority_effect`.
"""
(effect, fpkm) = effect_fpkm_pair
return (fpkm, multi_gene_effect_sort_key(effect))
return max(effect_expression_dict.items(), key=key_fn)[0] |
0, module; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, identifier:callback; 11, None; 12, comment:"""
Sort through each item with a callback.
:param callback: The callback
:type callback: callable or None
:rtype: Collection
"""; 13, assignment; 14, identifier:callback; 15, block; 16, else_clause; 17, identifier:items; 18, attribute; 19, return_statement; 20, block; 21, identifier:self; 22, identifier:items; 23, call; 24, return_statement; 25, attribute; 26, argument_list; 27, call; 28, identifier:self; 29, identifier:__class__; 30, call; 31, attribute; 32, argument_list; 33, identifier:sorted; 34, argument_list; 35, identifier:self; 36, identifier:__class__; 37, call; 38, identifier:items; 39, keyword_argument; 40, identifier:sorted; 41, argument_list; 42, identifier:key; 43, identifier:callback; 44, identifier:items | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 6, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 13, 17; 13, 18; 15, 19; 16, 20; 18, 21; 18, 22; 19, 23; 20, 24; 23, 25; 23, 26; 24, 27; 25, 28; 25, 29; 26, 30; 27, 31; 27, 32; 30, 33; 30, 34; 31, 35; 31, 36; 32, 37; 34, 38; 34, 39; 37, 40; 37, 41; 39, 42; 39, 43; 41, 44 | def sort(self, callback=None):
"""
Sort through each item with a callback.
:param callback: The callback
:type callback: callable or None
:rtype: Collection
"""
items = self.items
if callback:
return self.__class__(sorted(items, key=callback))
else:
return self.__class__(sorted(items)) |
0, module; 1, function_definition; 2, function_name:scan_for_spec; 3, parameters; 4, block; 5, identifier:keyword; 6, expression_statement; 7, comment:# Both 'spec' formats are wrapped in parens, discard; 8, expression_statement; 9, comment:# First, test for intermediate '1.2+' style; 10, expression_statement; 11, if_statement; 12, comment:# Failing that, see if Spec can make sense of it; 13, try_statement; 14, comment:"""
Attempt to return some sort of Spec from given keyword value.
Returns None if one could not be derived.
"""; 15, assignment; 16, assignment; 17, identifier:matches; 18, block; 19, block; 20, comment:# I've only ever seen Spec fail with ValueError.; 21, except_clause; 22, identifier:keyword; 23, call; 24, identifier:matches; 25, call; 26, return_statement; 27, return_statement; 28, identifier:ValueError; 29, block; 30, attribute; 31, argument_list; 32, attribute; 33, argument_list; 34, call; 35, call; 36, return_statement; 37, call; 38, identifier:rstrip; 39, string; 40, identifier:release_line_re; 41, identifier:findall; 42, identifier:keyword; 43, identifier:Spec; 44, argument_list; 45, identifier:Spec; 46, argument_list; 47, None; 48, attribute; 49, argument_list; 50, string_content:); 51, call; 52, identifier:keyword; 53, identifier:keyword; 54, identifier:lstrip; 55, string; 56, attribute; 57, argument_list; 58, string_content:(; 59, string:">={}"; 60, identifier:format; 61, subscript; 62, identifier:matches; 63, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 6, 14; 8, 15; 10, 16; 11, 17; 11, 18; 13, 19; 13, 20; 13, 21; 15, 22; 15, 23; 16, 24; 16, 25; 18, 26; 19, 27; 21, 28; 21, 29; 23, 30; 23, 31; 25, 32; 25, 33; 26, 34; 27, 35; 29, 36; 30, 37; 30, 38; 31, 39; 32, 40; 32, 41; 33, 42; 34, 43; 34, 44; 35, 45; 35, 46; 36, 47; 37, 48; 37, 49; 39, 50; 44, 51; 46, 52; 48, 53; 48, 54; 49, 55; 51, 56; 51, 57; 55, 58; 56, 59; 56, 60; 57, 61; 61, 62; 61, 63 | def scan_for_spec(keyword):
"""
Attempt to return some sort of Spec from given keyword value.
Returns None if one could not be derived.
"""
# Both 'spec' formats are wrapped in parens, discard
keyword = keyword.lstrip('(').rstrip(')')
# First, test for intermediate '1.2+' style
matches = release_line_re.findall(keyword)
if matches:
return Spec(">={}".format(matches[0]))
# Failing that, see if Spec can make sense of it
try:
return Spec(keyword)
# I've only ever seen Spec fail with ValueError.
except ValueError:
return None |
0, module; 1, function_definition; 2, function_name:get_students; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, expression_statement; 14, comment:# These are parameters required for the remote API call, so; 15, comment:# there aren't too many arguments, or too many variables; 16, comment:# pylint: disable=too-many-arguments,too-many-locals; 17, comment:# Set params by arguments; 18, expression_statement; 19, expression_statement; 20, if_statement; 21, expression_statement; 22, if_statement; 23, return_statement; 24, identifier:gradebook_id; 25, string; 26, identifier:simple; 27, False; 28, identifier:section_name; 29, string; 30, identifier:include_photo; 31, False; 32, identifier:include_grade_info; 33, False; 34, identifier:include_grade_history; 35, False; 36, identifier:include_makeup_grades; 37, False; 38, comment:"""Get students for a gradebook.
Get a list of students for a given gradebook,
specified by a gradebook id. Does not include grade data.
Args:
gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
simple (bool):
if ``True``, just return dictionary with keys ``email``,
``name``, ``section``, default = ``False``
section_name (str): section name
include_photo (bool): include student photo, default= ``False``
include_grade_info (bool):
include student's grade info, default= ``False``
include_grade_history (bool):
include student's grade history, default= ``False``
include_makeup_grades (bool):
include student's makeup grades, default= ``False``
Raises:
requests.RequestException: Exception connection error
ValueError: Unable to decode response content
Returns:
list: list of student dictionaries
.. code-block:: python
[{
u'accountEmail': u'[email protected]',
u'displayName': u'Molly Parker',
u'photoUrl': None,
u'middleName': None,
u'section': u'Unassigned',
u'sectionId': 1293925,
u'editable': False,
u'overallGradeInformation': None,
u'studentId': 1145,
u'studentAssignmentInfo': None,
u'sortableName': u'Parker, Molly',
u'surname': u'Parker',
u'givenName': u'Molly',
u'nickName': u'Molly',
u'email': u'[email protected]'
},]
"""; 39, assignment; 40, assignment; 41, identifier:section_name; 42, block; 43, assignment; 44, identifier:simple; 45, comment:# just return dict with keys email, name, section; 46, block; 47, subscript; 48, identifier:params; 49, call; 50, identifier:url; 51, string; 52, expression_statement; 53, if_statement; 54, expression_statement; 55, identifier:student_data; 56, call; 57, expression_statement; 58, function_definition; 59, return_statement; 60, identifier:student_data; 61, string; 62, identifier:dict; 63, argument_list; 64, string_content:students/{gradebookId}; 65, assignment; 66, comparison_operator:group_id is None; 67, block; 68, augmented_assignment; 69, attribute; 70, argument_list; 71, assignment; 72, function_name:remap; 73, parameters; 74, block; 75, list_comprehension; 76, string_content:data; 77, keyword_argument; 78, keyword_argument; 79, keyword_argument; 80, keyword_argument; 81, pattern_list; 82, call; 83, identifier:group_id; 84, None; 85, expression_statement; 86, expression_statement; 87, raise_statement; 88, identifier:url; 89, call; 90, identifier:self; 91, identifier:get; 92, call; 93, keyword_argument; 94, identifier:student_map; 95, call; 96, identifier:students; 97, expression_statement; 98, expression_statement; 99, comment:# match certs; 100, expression_statement; 101, return_statement; 102, call; 103, for_in_clause; 104, identifier:includePhoto; 105, call; 106, identifier:includeGradeInfo; 107, call; 108, identifier:includeGradeHistory; 109, call; 110, identifier:includeMakeupGrades; 111, call; 112, identifier:group_id; 113, identifier:_; 114, attribute; 115, argument_list; 116, assignment; 117, call; 118, call; 119, attribute; 120, argument_list; 121, attribute; 122, argument_list; 123, identifier:params; 124, identifier:params; 125, identifier:dict; 126, argument_list; 127, comment:"""Convert mit.edu domain to upper-case for student emails.
The mit.edu domain for user email must be upper-case,
i.e. MIT.EDU.
Args:
students (list): list of students
Returns:
dict: dictionary of updated student email domains
"""; 128, assignment; 129, assignment; 130, identifier:newx; 131, identifier:remap; 132, argument_list; 133, identifier:x; 134, subscript; 135, attribute; 136, argument_list; 137, attribute; 138, argument_list; 139, attribute; 140, argument_list; 141, attribute; 142, argument_list; 143, identifier:self; 144, identifier:get_section_by_name; 145, identifier:section_name; 146, identifier:failure_message; 147, parenthesized_expression; 148, attribute; 149, argument_list; 150, identifier:PyLmodNoSuchSection; 151, argument_list; 152, string; 153, identifier:format; 154, identifier:group_id; 155, identifier:url; 156, identifier:format; 157, keyword_argument; 158, keyword_argument; 159, keyword_argument; 160, keyword_argument; 161, identifier:newx; 162, call; 163, subscript; 164, call; 165, identifier:x; 166, identifier:student_data; 167, string; 168, identifier:json; 169, identifier:dumps; 170, identifier:include_photo; 171, identifier:json; 172, identifier:dumps; 173, identifier:include_grade_info; 174, identifier:json; 175, identifier:dumps; 176, identifier:include_grade_history; 177, identifier:json; 178, identifier:dumps; 179, identifier:include_makeup_grades; 180, binary_operator:'in get_students -- Error: '
'No such section %s' % section_name; 181, identifier:log; 182, identifier:critical; 183, identifier:failure_message; 184, identifier:failure_message; 185, string_content:/section/{0}; 186, identifier:gradebookId; 187, boolean_operator; 188, identifier:accountEmail; 189, string; 190, identifier:displayName; 191, string; 192, identifier:section; 193, string; 194, identifier:dict; 195, generator_expression; 196, identifier:newx; 197, string; 198, attribute; 199, argument_list; 200, string_content:data; 201, concatenated_string; 202, identifier:section_name; 203, identifier:gradebook_id; 204, attribute; 205, string_content:email; 206, string_content:name; 207, string_content:section; 208, tuple; 209, for_in_clause; 210, string_content:email; 211, subscript; 212, identifier:replace; 213, string; 214, string; 215, string; 216, string; 217, identifier:self; 218, identifier:gradebook_id; 219, subscript; 220, subscript; 221, identifier:k; 222, identifier:student_map; 223, identifier:newx; 224, string; 225, string_content:@mit.edu; 226, string_content:@MIT.EDU; 227, string_content:in get_students -- Error:; 228, string_content:No such section %s; 229, identifier:student_map; 230, identifier:k; 231, identifier:students; 232, identifier:k; 233, string_content:email | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 6, 24; 6, 25; 7, 26; 7, 27; 8, 28; 8, 29; 9, 30; 9, 31; 10, 32; 10, 33; 11, 34; 11, 35; 12, 36; 12, 37; 13, 38; 18, 39; 19, 40; 20, 41; 20, 42; 21, 43; 22, 44; 22, 45; 22, 46; 23, 47; 39, 48; 39, 49; 40, 50; 40, 51; 42, 52; 42, 53; 42, 54; 43, 55; 43, 56; 46, 57; 46, 58; 46, 59; 47, 60; 47, 61; 49, 62; 49, 63; 51, 64; 52, 65; 53, 66; 53, 67; 54, 68; 56, 69; 56, 70; 57, 71; 58, 72; 58, 73; 58, 74; 59, 75; 61, 76; 63, 77; 63, 78; 63, 79; 63, 80; 65, 81; 65, 82; 66, 83; 66, 84; 67, 85; 67, 86; 67, 87; 68, 88; 68, 89; 69, 90; 69, 91; 70, 92; 70, 93; 71, 94; 71, 95; 73, 96; 74, 97; 74, 98; 74, 99; 74, 100; 74, 101; 75, 102; 75, 103; 77, 104; 77, 105; 78, 106; 78, 107; 79, 108; 79, 109; 80, 110; 80, 111; 81, 112; 81, 113; 82, 114; 82, 115; 85, 116; 86, 117; 87, 118; 89, 119; 89, 120; 92, 121; 92, 122; 93, 123; 93, 124; 95, 125; 95, 126; 97, 127; 98, 128; 100, 129; 101, 130; 102, 131; 102, 132; 103, 133; 103, 134; 105, 135; 105, 136; 107, 137; 107, 138; 109, 139; 109, 140; 111, 141; 111, 142; 114, 143; 114, 144; 115, 145; 116, 146; 116, 147; 117, 148; 117, 149; 118, 150; 118, 151; 119, 152; 119, 153; 120, 154; 121, 155; 121, 156; 122, 157; 126, 158; 126, 159; 126, 160; 128, 161; 128, 162; 129, 163; 129, 164; 132, 165; 134, 166; 134, 167; 135, 168; 135, 169; 136, 170; 137, 171; 137, 172; 138, 173; 139, 174; 139, 175; 140, 176; 141, 177; 141, 178; 142, 179; 147, 180; 148, 181; 148, 182; 149, 183; 151, 184; 152, 185; 157, 186; 157, 187; 158, 188; 158, 189; 159, 190; 159, 191; 160, 192; 160, 193; 162, 194; 162, 195; 163, 196; 163, 197; 164, 198; 164, 199; 167, 200; 180, 201; 180, 202; 187, 203; 187, 204; 189, 205; 191, 206; 193, 207; 195, 208; 195, 209; 197, 210; 198, 211; 198, 212; 199, 213; 199, 214; 201, 215; 201, 216; 204, 217; 204, 218; 208, 219; 208, 220; 209, 221; 209, 222; 211, 223; 211, 224; 213, 225; 214, 226; 215, 227; 216, 228; 219, 229; 219, 230; 220, 231; 220, 232; 224, 233 | def get_students(
self,
gradebook_id='',
simple=False,
section_name='',
include_photo=False,
include_grade_info=False,
include_grade_history=False,
include_makeup_grades=False
):
"""Get students for a gradebook.
Get a list of students for a given gradebook,
specified by a gradebook id. Does not include grade data.
Args:
gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
simple (bool):
if ``True``, just return dictionary with keys ``email``,
``name``, ``section``, default = ``False``
section_name (str): section name
include_photo (bool): include student photo, default= ``False``
include_grade_info (bool):
include student's grade info, default= ``False``
include_grade_history (bool):
include student's grade history, default= ``False``
include_makeup_grades (bool):
include student's makeup grades, default= ``False``
Raises:
requests.RequestException: Exception connection error
ValueError: Unable to decode response content
Returns:
list: list of student dictionaries
.. code-block:: python
[{
u'accountEmail': u'[email protected]',
u'displayName': u'Molly Parker',
u'photoUrl': None,
u'middleName': None,
u'section': u'Unassigned',
u'sectionId': 1293925,
u'editable': False,
u'overallGradeInformation': None,
u'studentId': 1145,
u'studentAssignmentInfo': None,
u'sortableName': u'Parker, Molly',
u'surname': u'Parker',
u'givenName': u'Molly',
u'nickName': u'Molly',
u'email': u'[email protected]'
},]
"""
# These are parameters required for the remote API call, so
# there aren't too many arguments, or too many variables
# pylint: disable=too-many-arguments,too-many-locals
# Set params by arguments
params = dict(
includePhoto=json.dumps(include_photo),
includeGradeInfo=json.dumps(include_grade_info),
includeGradeHistory=json.dumps(include_grade_history),
includeMakeupGrades=json.dumps(include_makeup_grades),
)
url = 'students/{gradebookId}'
if section_name:
group_id, _ = self.get_section_by_name(section_name)
if group_id is None:
failure_message = (
'in get_students -- Error: '
'No such section %s' % section_name
)
log.critical(failure_message)
raise PyLmodNoSuchSection(failure_message)
url += '/section/{0}'.format(group_id)
student_data = self.get(
url.format(
gradebookId=gradebook_id or self.gradebook_id
),
params=params,
)
if simple:
# just return dict with keys email, name, section
student_map = dict(
accountEmail='email',
displayName='name',
section='section'
)
def remap(students):
"""Convert mit.edu domain to upper-case for student emails.
The mit.edu domain for user email must be upper-case,
i.e. MIT.EDU.
Args:
students (list): list of students
Returns:
dict: dictionary of updated student email domains
"""
newx = dict((student_map[k], students[k]) for k in student_map)
# match certs
newx['email'] = newx['email'].replace('@mit.edu', '@MIT.EDU')
return newx
return [remap(x) for x in student_data['data']]
return student_data['data'] |
0, module; 1, function_definition; 2, function_name:get_staff; 3, parameters; 4, block; 5, identifier:self; 6, identifier:gradebook_id; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, return_statement; 12, identifier:simple; 13, False; 14, comment:"""Get staff list for gradebook.
Get staff list for the gradebook specified. Optionally, return
a less detailed list by specifying ``simple = True``.
If simple=True, return a list of dictionaries, one dictionary
for each member. The dictionary contains a member's ``email``,
``displayName``, and ``role``. Members with multiple roles will
appear in the list once for each role.
Args:
gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
simple (bool): Return a staff list with less detail. Default
is ``False``.
Returns:
An example return value is:
.. code-block:: python
{
u'data': {
u'COURSE_ADMIN': [
{
u'accountEmail': u'[email protected]',
u'displayName': u'Benjamin Franklin',
u'editable': False,
u'email': u'[email protected]',
u'givenName': u'Benjamin',
u'middleName': None,
u'mitId': u'921344431',
u'nickName': u'Benjamin',
u'personId': 10710616,
u'sortableName': u'Franklin, Benjamin',
u'surname': u'Franklin',
u'year': None
},
],
u'COURSE_PROF': [
{
u'accountEmail': u'[email protected]',
u'displayName': u'Donald Duck',
u'editable': False,
u'email': u'[email protected]',
u'givenName': u'Donald',
u'middleName': None,
u'mitId': u'916144889',
u'nickName': u'Donald',
u'personId': 8117160,
u'sortableName': u'Duck, Donald',
u'surname': u'Duck',
u'year': None
},
],
u'COURSE_TA': [
{
u'accountEmail': u'[email protected]',
u'displayName': u'Huey Duck',
u'editable': False,
u'email': u'[email protected]',
u'givenName': u'Huey',
u'middleName': None,
u'mitId': u'920445024',
u'nickName': u'Huey',
u'personId': 1299059,
u'sortableName': u'Duck, Huey',
u'surname': u'Duck',
u'year': None
},
]
},
}
"""; 15, assignment; 16, identifier:simple; 17, block; 18, subscript; 19, identifier:staff_data; 20, call; 21, expression_statement; 22, expression_statement; 23, for_statement; 24, return_statement; 25, identifier:staff_data; 26, string; 27, attribute; 28, argument_list; 29, assignment; 30, assignment; 31, identifier:member; 32, call; 33, block; 34, identifier:simple_list; 35, string_content:data; 36, identifier:self; 37, identifier:get; 38, call; 39, keyword_argument; 40, identifier:simple_list; 41, list; 42, identifier:unraveled_list; 43, call; 44, attribute; 45, argument_list; 46, expression_statement; 47, attribute; 48, argument_list; 49, identifier:params; 50, None; 51, attribute; 52, argument_list; 53, identifier:unraveled_list; 54, identifier:__iter__; 55, call; 56, string; 57, identifier:format; 58, keyword_argument; 59, identifier:self; 60, identifier:unravel_staff; 61, identifier:staff_data; 62, attribute; 63, argument_list; 64, string_content:staff/{gradebookId}; 65, identifier:gradebookId; 66, boolean_operator; 67, identifier:simple_list; 68, identifier:append; 69, dictionary; 70, identifier:gradebook_id; 71, attribute; 72, pair; 73, pair; 74, pair; 75, identifier:self; 76, identifier:gradebook_id; 77, string; 78, subscript; 79, string; 80, subscript; 81, string; 82, subscript; 83, string_content:accountEmail; 84, identifier:member; 85, string; 86, string_content:displayName; 87, identifier:member; 88, string; 89, string_content:role; 90, identifier:member; 91, string; 92, string_content:accountEmail; 93, string_content:displayName; 94, string_content:role | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 7, 13; 8, 14; 9, 15; 10, 16; 10, 17; 11, 18; 15, 19; 15, 20; 17, 21; 17, 22; 17, 23; 17, 24; 18, 25; 18, 26; 20, 27; 20, 28; 21, 29; 22, 30; 23, 31; 23, 32; 23, 33; 24, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 29, 40; 29, 41; 30, 42; 30, 43; 32, 44; 32, 45; 33, 46; 38, 47; 38, 48; 39, 49; 39, 50; 43, 51; 43, 52; 44, 53; 44, 54; 46, 55; 47, 56; 47, 57; 48, 58; 51, 59; 51, 60; 52, 61; 55, 62; 55, 63; 56, 64; 58, 65; 58, 66; 62, 67; 62, 68; 63, 69; 66, 70; 66, 71; 69, 72; 69, 73; 69, 74; 71, 75; 71, 76; 72, 77; 72, 78; 73, 79; 73, 80; 74, 81; 74, 82; 77, 83; 78, 84; 78, 85; 79, 86; 80, 87; 80, 88; 81, 89; 82, 90; 82, 91; 85, 92; 88, 93; 91, 94 | def get_staff(self, gradebook_id, simple=False):
"""Get staff list for gradebook.
Get staff list for the gradebook specified. Optionally, return
a less detailed list by specifying ``simple = True``.
If simple=True, return a list of dictionaries, one dictionary
for each member. The dictionary contains a member's ``email``,
``displayName``, and ``role``. Members with multiple roles will
appear in the list once for each role.
Args:
gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
simple (bool): Return a staff list with less detail. Default
is ``False``.
Returns:
An example return value is:
.. code-block:: python
{
u'data': {
u'COURSE_ADMIN': [
{
u'accountEmail': u'[email protected]',
u'displayName': u'Benjamin Franklin',
u'editable': False,
u'email': u'[email protected]',
u'givenName': u'Benjamin',
u'middleName': None,
u'mitId': u'921344431',
u'nickName': u'Benjamin',
u'personId': 10710616,
u'sortableName': u'Franklin, Benjamin',
u'surname': u'Franklin',
u'year': None
},
],
u'COURSE_PROF': [
{
u'accountEmail': u'[email protected]',
u'displayName': u'Donald Duck',
u'editable': False,
u'email': u'[email protected]',
u'givenName': u'Donald',
u'middleName': None,
u'mitId': u'916144889',
u'nickName': u'Donald',
u'personId': 8117160,
u'sortableName': u'Duck, Donald',
u'surname': u'Duck',
u'year': None
},
],
u'COURSE_TA': [
{
u'accountEmail': u'[email protected]',
u'displayName': u'Huey Duck',
u'editable': False,
u'email': u'[email protected]',
u'givenName': u'Huey',
u'middleName': None,
u'mitId': u'920445024',
u'nickName': u'Huey',
u'personId': 1299059,
u'sortableName': u'Duck, Huey',
u'surname': u'Duck',
u'year': None
},
]
},
}
"""
staff_data = self.get(
'staff/{gradebookId}'.format(
gradebookId=gradebook_id or self.gradebook_id
),
params=None,
)
if simple:
simple_list = []
unraveled_list = self.unravel_staff(staff_data)
for member in unraveled_list.__iter__():
simple_list.append({
'accountEmail': member['accountEmail'],
'displayName': member['displayName'],
'role': member['role'],
})
return simple_list
return staff_data['data'] |
0, module; 1, function_definition; 2, function_name:get_course_guide_staff; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, identifier:course_id; 11, string; 12, comment:"""Get the staff roster for a course.
Get a list of staff members for a given course,
specified by a course id.
Args:
course_id (int): unique identifier for course, i.e. ``2314``
Raises:
requests.RequestException: Exception connection error
ValueError: Unable to decode response content
Returns:
list: list of dictionaries containing staff data
An example return value is:
.. code-block:: python
[
{
u'displayName': u'Huey Duck',
u'role': u'TA',
u'sortableDisplayName': u'Duck, Huey'
},
{
u'displayName': u'Louie Duck',
u'role': u'CourseAdmin',
u'sortableDisplayName': u'Duck, Louie'
},
{
u'displayName': u'Benjamin Franklin',
u'role': u'CourseAdmin',
u'sortableDisplayName': u'Franklin, Benjamin'
},
{
u'displayName': u'George Washington',
u'role': u'Instructor',
u'sortableDisplayName': u'Washington, George'
},
]
"""; 13, assignment; 14, subscript; 15, identifier:staff_data; 16, call; 17, subscript; 18, string; 19, attribute; 20, argument_list; 21, identifier:staff_data; 22, string; 23, string_content:docs; 24, identifier:self; 25, identifier:get; 26, call; 27, keyword_argument; 28, string_content:response; 29, attribute; 30, argument_list; 31, identifier:params; 32, None; 33, string; 34, identifier:format; 35, keyword_argument; 36, string_content:courseguide/course/{courseId}/staff; 37, identifier:courseId; 38, boolean_operator; 39, identifier:course_id; 40, attribute; 41, identifier:self; 42, identifier:course_id | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 6, 10; 6, 11; 7, 12; 8, 13; 9, 14; 13, 15; 13, 16; 14, 17; 14, 18; 16, 19; 16, 20; 17, 21; 17, 22; 18, 23; 19, 24; 19, 25; 20, 26; 20, 27; 22, 28; 26, 29; 26, 30; 27, 31; 27, 32; 29, 33; 29, 34; 30, 35; 33, 36; 35, 37; 35, 38; 38, 39; 38, 40; 40, 41; 40, 42 | def get_course_guide_staff(self, course_id=''):
"""Get the staff roster for a course.
Get a list of staff members for a given course,
specified by a course id.
Args:
course_id (int): unique identifier for course, i.e. ``2314``
Raises:
requests.RequestException: Exception connection error
ValueError: Unable to decode response content
Returns:
list: list of dictionaries containing staff data
An example return value is:
.. code-block:: python
[
{
u'displayName': u'Huey Duck',
u'role': u'TA',
u'sortableDisplayName': u'Duck, Huey'
},
{
u'displayName': u'Louie Duck',
u'role': u'CourseAdmin',
u'sortableDisplayName': u'Duck, Louie'
},
{
u'displayName': u'Benjamin Franklin',
u'role': u'CourseAdmin',
u'sortableDisplayName': u'Franklin, Benjamin'
},
{
u'displayName': u'George Washington',
u'role': u'Instructor',
u'sortableDisplayName': u'Washington, George'
},
]
"""
staff_data = self.get(
'courseguide/course/{courseId}/staff'.format(
courseId=course_id or self.course_id
),
params=None
)
return staff_data['response']['docs'] |
0, module; 1, function_definition; 2, function_name:optimize; 3, parameters; 4, block; 5, identifier:self; 6, identifier:problem; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, expression_statement; 15, if_statement; 16, comment:# Prepare pool for multiprocessing; 17, if_statement; 18, comment:# Set first, incase optimizer uses _max_iterations in initialization; 19, expression_statement; 20, comment:# Initialize algorithm; 21, expression_statement; 22, expression_statement; 23, expression_statement; 24, try_statement; 25, return_statement; 26, identifier:max_iterations; 27, integer:100; 28, identifier:max_seconds; 29, call; 30, identifier:cache_encoded; 31, True; 32, identifier:cache_solution; 33, False; 34, identifier:clear_cache; 35, True; 36, identifier:logging_func; 37, identifier:_print_fitnesses; 38, identifier:n_processes; 39, integer:0; 40, comment:"""Find the optimal inputs for a given fitness function.
Args:
problem: An instance of Problem. The problem to solve.
max_iterations: The number of iterations to optimize before stopping.
max_seconds: Maximum number of seconds to optimize for, before stopping.
Note that condition is only checked one per iteration,
meaning optimization can take more than max_seconds,
especially if fitnesses take a long time to calculate.
cache_encoded: bool; Whether or not to cache fitness of encoded strings.
Encoded strings are produced directly by the optimizer.
If an encoded string is found in cache, it will not be decoded.
cache_solution: bool; Whether or not to cache fitness of decoded solutions.
Decoded solution is provided by problems decode function.
If problem does not provide a hash solution function,
Various naive hashing methods will be attempted, including:
tuple, tuple(sorted(dict.items)), str.
clear_cache: bool; Whether or not to reset cache after optimization.
Disable if you want to run optimize multiple times on the same problem.
logging_func: func/None; Function taking:
iteration, population, solutions, fitnesses, best_solution, best_fitness
Called after every iteration.
Use for custom logging, or set to None to disable logging.
Note that best_solution and best_fitness are the best of all iterations so far.
n_processes: int; Number of processes to use for multiprocessing.
If <= 0, do not use multiprocessing.
Returns:
object; The best solution, after decoding.
"""; 41, not_operator; 42, block; 43, comparison_operator:n_processes > 0; 44, block; 45, else_clause; 46, assignment; 47, call; 48, assignment; 49, assignment; 50, comment:# Begin optimization loop; 51, block; 52, finally_clause; 53, attribute; 54, identifier:float; 55, argument_list; 56, call; 57, raise_statement; 58, identifier:n_processes; 59, integer:0; 60, try_statement; 61, block; 62, attribute; 63, identifier:max_iterations; 64, attribute; 65, argument_list; 66, identifier:best_solution; 67, dictionary; 68, identifier:population; 69, call; 70, expression_statement; 71, for_statement; 72, comment:# Store best internally, before returning; 73, expression_statement; 74, expression_statement; 75, comment:# Clear caches; 76, block; 77, identifier:self; 78, identifier:best_solution; 79, string; 80, identifier:isinstance; 81, argument_list; 82, call; 83, block; 84, except_clause; 85, expression_statement; 86, identifier:self; 87, identifier:__max_iterations; 88, identifier:self; 89, identifier:_reset; 90, pair; 91, pair; 92, attribute; 93, argument_list; 94, assignment; 95, attribute; 96, call; 97, comment:# Infinite sequence of iterations; 98, comment:# Evaluate potential solutions; 99, block; 100, assignment; 101, assignment; 102, if_statement; 103, comment:# Clean up multiprocesses; 104, try_statement; 105, string_content:inf; 106, identifier:problem; 107, identifier:Problem; 108, identifier:TypeError; 109, argument_list; 110, expression_statement; 111, identifier:NameError; 112, block; 113, assignment; 114, string; 115, None; 116, string; 117, None; 118, identifier:self; 119, identifier:initial_population; 120, identifier:start; 121, call; 122, identifier:self; 123, identifier:iteration; 124, attribute; 125, argument_list; 126, expression_statement; 127, comment:# If the best fitness from this iteration is better than; 128, comment:# the global best; 129, expression_statement; 130, if_statement; 131, if_statement; 132, comment:# Break if solution found; 133, if_statement; 134, comment:# Break if out of time; 135, if_statement; 136, comment:# Break if out of iterations; 137, if_statement; 138, comment:# Continue optimizing; 139, expression_statement; 140, attribute; 141, subscript; 142, attribute; 143, subscript; 144, identifier:clear_cache; 145, comment:# Clear caches from memory; 146, block; 147, block; 148, except_clause; 149, string; 150, assignment; 151, raise_statement; 152, identifier:pool; 153, None; 154, string_content:solution; 155, string_content:fitness; 156, attribute; 157, argument_list; 158, identifier:itertools; 159, identifier:count; 160, integer:1; 161, assignment; 162, assignment; 163, comparison_operator:best_fitness > best_solution['fitness']; 164, comment:# Store the new best solution; 165, block; 166, identifier:logging_func; 167, block; 168, identifier:finished; 169, block; 170, comparison_operator:time.clock() - start >= max_seconds; 171, block; 172, comparison_operator:self.iteration >= max_iterations; 173, block; 174, assignment; 175, identifier:self; 176, identifier:best_solution; 177, identifier:best_solution; 178, string; 179, identifier:self; 180, identifier:best_fitness; 181, identifier:best_solution; 182, string; 183, expression_statement; 184, expression_statement; 185, comment:# Reset encoded, and decoded key functions; 186, expression_statement; 187, expression_statement; 188, expression_statement; 189, comment:# Kill outstanding work; 190, expression_statement; 191, comment:# Close child processes; 192, identifier:AttributeError; 193, comment:# No pool; 194, block; 195, string_content:problem must be an instance of Problem class; 196, identifier:pool; 197, call; 198, call; 199, identifier:time; 200, identifier:clock; 201, pattern_list; 202, call; 203, pattern_list; 204, call; 205, identifier:best_fitness; 206, subscript; 207, expression_statement; 208, expression_statement; 209, expression_statement; 210, expression_statement; 211, break_statement; 212, binary_operator:time.clock() - start; 213, identifier:max_seconds; 214, break_statement; 215, attribute; 216, identifier:max_iterations; 217, break_statement; 218, identifier:population; 219, call; 220, string_content:solution; 221, string_content:fitness; 222, assignment; 223, assignment; 224, assignment; 225, assignment; 226, call; 227, call; 228, assert_statement; 229, attribute; 230, argument_list; 231, identifier:ImportError; 232, argument_list; 233, identifier:solutions; 234, identifier:fitnesses; 235, identifier:finished; 236, attribute; 237, argument_list; 238, identifier:best_index; 239, identifier:best_fitness; 240, identifier:max; 241, argument_list; 242, identifier:best_solution; 243, string; 244, assignment; 245, assignment; 246, call; 247, assignment; 248, call; 249, identifier:start; 250, identifier:self; 251, identifier:iteration; 252, attribute; 253, argument_list; 254, attribute; 255, dictionary; 256, attribute; 257, dictionary; 258, attribute; 259, attribute; 260, attribute; 261, attribute; 262, attribute; 263, argument_list; 264, attribute; 265, argument_list; 266, comparison_operator:pool is None; 267, identifier:multiprocessing; 268, identifier:Pool; 269, keyword_argument; 270, string; 271, identifier:self; 272, identifier:_get_fitnesses; 273, identifier:problem; 274, identifier:population; 275, keyword_argument; 276, keyword_argument; 277, keyword_argument; 278, call; 279, keyword_argument; 280, string_content:fitness; 281, subscript; 282, identifier:best_fitness; 283, subscript; 284, subscript; 285, identifier:logging_func; 286, argument_list; 287, attribute; 288, True; 289, attribute; 290, argument_list; 291, identifier:self; 292, identifier:next_population; 293, identifier:population; 294, identifier:fitnesses; 295, identifier:self; 296, identifier:__encoded_cache; 297, identifier:self; 298, identifier:__solution_cache; 299, identifier:self; 300, identifier:_get_encoded_key; 301, identifier:self; 302, identifier:_get_encoded_key_type; 303, identifier:self; 304, identifier:_get_solution_key; 305, identifier:self; 306, identifier:_get_solution_key_type; 307, identifier:pool; 308, identifier:terminate; 309, identifier:pool; 310, identifier:close; 311, identifier:pool; 312, None; 313, identifier:processes; 314, identifier:n_processes; 315, string_content:pickle, dill, or multiprocessing library is not available.; 316, identifier:cache_encoded; 317, identifier:cache_encoded; 318, identifier:cache_solution; 319, identifier:cache_solution; 320, identifier:pool; 321, identifier:pool; 322, identifier:enumerate; 323, argument_list; 324, identifier:key; 325, call; 326, identifier:best_solution; 327, string; 328, identifier:best_solution; 329, string; 330, identifier:solutions; 331, identifier:best_index; 332, attribute; 333, identifier:population; 334, identifier:solutions; 335, identifier:fitnesses; 336, subscript; 337, subscript; 338, identifier:self; 339, identifier:solution_found; 340, identifier:time; 341, identifier:clock; 342, identifier:fitnesses; 343, attribute; 344, argument_list; 345, string_content:fitness; 346, string_content:solution; 347, identifier:self; 348, identifier:iteration; 349, identifier:best_solution; 350, string; 351, identifier:best_solution; 352, string; 353, identifier:operator; 354, identifier:itemgetter; 355, integer:1; 356, string_content:solution; 357, string_content:fitness | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 7, 26; 7, 27; 8, 28; 8, 29; 9, 30; 9, 31; 10, 32; 10, 33; 11, 34; 11, 35; 12, 36; 12, 37; 13, 38; 13, 39; 14, 40; 15, 41; 15, 42; 17, 43; 17, 44; 17, 45; 19, 46; 21, 47; 22, 48; 23, 49; 24, 50; 24, 51; 24, 52; 25, 53; 29, 54; 29, 55; 41, 56; 42, 57; 43, 58; 43, 59; 44, 60; 45, 61; 46, 62; 46, 63; 47, 64; 47, 65; 48, 66; 48, 67; 49, 68; 49, 69; 51, 70; 51, 71; 51, 72; 51, 73; 51, 74; 52, 75; 52, 76; 53, 77; 53, 78; 55, 79; 56, 80; 56, 81; 57, 82; 60, 83; 60, 84; 61, 85; 62, 86; 62, 87; 64, 88; 64, 89; 67, 90; 67, 91; 69, 92; 69, 93; 70, 94; 71, 95; 71, 96; 71, 97; 71, 98; 71, 99; 73, 100; 74, 101; 76, 102; 76, 103; 76, 104; 79, 105; 81, 106; 81, 107; 82, 108; 82, 109; 83, 110; 84, 111; 84, 112; 85, 113; 90, 114; 90, 115; 91, 116; 91, 117; 92, 118; 92, 119; 94, 120; 94, 121; 95, 122; 95, 123; 96, 124; 96, 125; 99, 126; 99, 127; 99, 128; 99, 129; 99, 130; 99, 131; 99, 132; 99, 133; 99, 134; 99, 135; 99, 136; 99, 137; 99, 138; 99, 139; 100, 140; 100, 141; 101, 142; 101, 143; 102, 144; 102, 145; 102, 146; 104, 147; 104, 148; 109, 149; 110, 150; 112, 151; 113, 152; 113, 153; 114, 154; 116, 155; 121, 156; 121, 157; 124, 158; 124, 159; 125, 160; 126, 161; 129, 162; 130, 163; 130, 164; 130, 165; 131, 166; 131, 167; 133, 168; 133, 169; 135, 170; 135, 171; 137, 172; 137, 173; 139, 174; 140, 175; 140, 176; 141, 177; 141, 178; 142, 179; 142, 180; 143, 181; 143, 182; 146, 183; 146, 184; 146, 185; 146, 186; 146, 187; 147, 188; 147, 189; 147, 190; 147, 191; 148, 192; 148, 193; 148, 194; 149, 195; 150, 196; 150, 197; 151, 198; 156, 199; 156, 200; 161, 201; 161, 202; 162, 203; 162, 204; 163, 205; 163, 206; 165, 207; 165, 208; 167, 209; 169, 210; 169, 211; 170, 212; 170, 213; 171, 214; 172, 215; 172, 216; 173, 217; 174, 218; 174, 219; 178, 220; 182, 221; 183, 222; 184, 223; 186, 224; 187, 225; 188, 226; 190, 227; 194, 228; 197, 229; 197, 230; 198, 231; 198, 232; 201, 233; 201, 234; 201, 235; 202, 236; 202, 237; 203, 238; 203, 239; 204, 240; 204, 241; 206, 242; 206, 243; 207, 244; 208, 245; 209, 246; 210, 247; 212, 248; 212, 249; 215, 250; 215, 251; 219, 252; 219, 253; 222, 254; 222, 255; 223, 256; 223, 257; 224, 258; 224, 259; 225, 260; 225, 261; 226, 262; 226, 263; 227, 264; 227, 265; 228, 266; 229, 267; 229, 268; 230, 269; 232, 270; 236, 271; 236, 272; 237, 273; 237, 274; 237, 275; 237, 276; 237, 277; 241, 278; 241, 279; 243, 280; 244, 281; 244, 282; 245, 283; 245, 284; 246, 285; 246, 286; 247, 287; 247, 288; 248, 289; 248, 290; 252, 291; 252, 292; 253, 293; 253, 294; 254, 295; 254, 296; 256, 297; 256, 298; 258, 299; 258, 300; 259, 301; 259, 302; 260, 303; 260, 304; 261, 305; 261, 306; 262, 307; 262, 308; 264, 309; 264, 310; 266, 311; 266, 312; 269, 313; 269, 314; 270, 315; 275, 316; 275, 317; 276, 318; 276, 319; 277, 320; 277, 321; 278, 322; 278, 323; 279, 324; 279, 325; 281, 326; 281, 327; 283, 328; 283, 329; 284, 330; 284, 331; 286, 332; 286, 333; 286, 334; 286, 335; 286, 336; 286, 337; 287, 338; 287, 339; 289, 340; 289, 341; 323, 342; 325, 343; 325, 344; 327, 345; 329, 346; 332, 347; 332, 348; 336, 349; 336, 350; 337, 351; 337, 352; 343, 353; 343, 354; 344, 355; 350, 356; 352, 357 | def optimize(self, problem, max_iterations=100, max_seconds=float('inf'),
cache_encoded=True, cache_solution=False, clear_cache=True,
logging_func=_print_fitnesses,
n_processes=0):
"""Find the optimal inputs for a given fitness function.
Args:
problem: An instance of Problem. The problem to solve.
max_iterations: The number of iterations to optimize before stopping.
max_seconds: Maximum number of seconds to optimize for, before stopping.
Note that condition is only checked one per iteration,
meaning optimization can take more than max_seconds,
especially if fitnesses take a long time to calculate.
cache_encoded: bool; Whether or not to cache fitness of encoded strings.
Encoded strings are produced directly by the optimizer.
If an encoded string is found in cache, it will not be decoded.
cache_solution: bool; Whether or not to cache fitness of decoded solutions.
Decoded solution is provided by problems decode function.
If problem does not provide a hash solution function,
Various naive hashing methods will be attempted, including:
tuple, tuple(sorted(dict.items)), str.
clear_cache: bool; Whether or not to reset cache after optimization.
Disable if you want to run optimize multiple times on the same problem.
logging_func: func/None; Function taking:
iteration, population, solutions, fitnesses, best_solution, best_fitness
Called after every iteration.
Use for custom logging, or set to None to disable logging.
Note that best_solution and best_fitness are the best of all iterations so far.
n_processes: int; Number of processes to use for multiprocessing.
If <= 0, do not use multiprocessing.
Returns:
object; The best solution, after decoding.
"""
if not isinstance(problem, Problem):
raise TypeError('problem must be an instance of Problem class')
# Prepare pool for multiprocessing
if n_processes > 0:
try:
pool = multiprocessing.Pool(processes=n_processes)
except NameError:
raise ImportError(
'pickle, dill, or multiprocessing library is not available.'
)
else:
pool = None
# Set first, incase optimizer uses _max_iterations in initialization
self.__max_iterations = max_iterations
# Initialize algorithm
self._reset()
best_solution = {'solution': None, 'fitness': None}
population = self.initial_population()
try:
# Begin optimization loop
start = time.clock()
for self.iteration in itertools.count(1): # Infinite sequence of iterations
# Evaluate potential solutions
solutions, fitnesses, finished = self._get_fitnesses(
problem,
population,
cache_encoded=cache_encoded,
cache_solution=cache_solution,
pool=pool)
# If the best fitness from this iteration is better than
# the global best
best_index, best_fitness = max(
enumerate(fitnesses), key=operator.itemgetter(1))
if best_fitness > best_solution['fitness']:
# Store the new best solution
best_solution['fitness'] = best_fitness
best_solution['solution'] = solutions[best_index]
if logging_func:
logging_func(self.iteration, population, solutions,
fitnesses, best_solution['solution'],
best_solution['fitness'])
# Break if solution found
if finished:
self.solution_found = True
break
# Break if out of time
if time.clock() - start >= max_seconds:
break
# Break if out of iterations
if self.iteration >= max_iterations:
break
# Continue optimizing
population = self.next_population(population, fitnesses)
# Store best internally, before returning
self.best_solution = best_solution['solution']
self.best_fitness = best_solution['fitness']
finally:
# Clear caches
if clear_cache:
# Clear caches from memory
self.__encoded_cache = {}
self.__solution_cache = {}
# Reset encoded, and decoded key functions
self._get_encoded_key = self._get_encoded_key_type
self._get_solution_key = self._get_solution_key_type
# Clean up multiprocesses
try:
pool.terminate() # Kill outstanding work
pool.close() # Close child processes
except AttributeError:
# No pool
assert pool is None
return self.best_solution |
0, module; 1, function_definition; 2, function_name:inspect; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, comment:"""
Inspect a pattern. This gives information regarding the sorts of
operations, content, etc in use in the pattern.
:return: Pattern information
"""; 11, assignment; 12, call; 13, call; 14, identifier:inspector; 15, call; 16, attribute; 17, argument_list; 18, attribute; 19, argument_list; 20, attribute; 21, argument_list; 22, identifier:self; 23, identifier:walk; 24, identifier:inspector; 25, identifier:inspector; 26, identifier:pattern_data; 27, attribute; 28, identifier:InspectionListener; 29, identifier:stix2patterns; 30, identifier:inspector | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 9, 13; 11, 14; 11, 15; 12, 16; 12, 17; 13, 18; 13, 19; 15, 20; 15, 21; 16, 22; 16, 23; 17, 24; 18, 25; 18, 26; 20, 27; 20, 28; 27, 29; 27, 30 | def inspect(self):
"""
Inspect a pattern. This gives information regarding the sorts of
operations, content, etc in use in the pattern.
:return: Pattern information
"""
inspector = stix2patterns.inspector.InspectionListener()
self.walk(inspector)
return inspector.pattern_data() |
0, module; 1, function_definition; 2, function_name:best_kmers; 3, parameters; 4, block; 5, identifier:dt; 6, identifier:response; 7, identifier:sequence; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, if_statement; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, comment:# which coefficients are nonzero?=; 22, expression_statement; 23, comment:# perform stepwise selection; 24, comment:#; 25, comment:# TODO - how do we deal with the intercept?; 26, comment:# largest number of motifs where they don't differ by more than 1 k-mer; 27, function_definition; 28, expression_statement; 29, return_statement; 30, identifier:k; 31, integer:6; 32, identifier:consider_shift; 33, True; 34, identifier:n_cores; 35, integer:1; 36, identifier:seq_align; 37, string:"start"; 38, identifier:trim_seq_len; 39, None; 40, comment:"""
Find best k-mers for CONCISE initialization.
Args:
dt (pd.DataFrame): Table containing response variable and sequence.
response (str): Name of the column used as the reponse variable.
sequence (str): Name of the column storing the DNA/RNA sequences.
k (int): Desired k-mer length.
n_cores (int): Number of cores to use for computation. It can use up to 3 cores.
consider_shift (boolean): When performing stepwise k-mer selection. Is TATTTA similar to ATTTAG?
seq_align (str): one of ``{"start", "end"}``. To which end should we align sequences?
trim_seq_len (int): Consider only first `trim_seq_len` bases of each sequence when generating the sequence design matrix. If :python:`None`, set :py:attr:`trim_seq_len` to the longest sequence length, hence whole sequences are considered.
Returns:
string list: Best set of motifs for this dataset sorted with respect to
confidence (best candidate occuring first).
Details:
First a lasso model gets fitted to get a set of initial motifs. Next, the best
subset of unrelated motifs is selected by stepwise selection.
"""; 41, assignment; 42, assignment; 43, comparison_operator:trim_seq_len is not None; 44, block; 45, assignment; 46, assignment; 47, assignment; 48, call; 49, assignment; 50, function_name:find_next_best; 51, parameters; 52, block; 53, assignment; 54, identifier:selected_kmers; 55, identifier:y; 56, subscript; 57, identifier:seq; 58, subscript; 59, identifier:trim_seq_len; 60, None; 61, expression_statement; 62, expression_statement; 63, identifier:dt_kmer; 64, call; 65, identifier:Xsp; 66, call; 67, identifier:en; 68, call; 69, attribute; 70, argument_list; 71, identifier:nonzero_kmers; 72, call; 73, identifier:dt_kmer; 74, identifier:y; 75, identifier:selected_kmers; 76, identifier:to_be_selected_kmers; 77, default_parameter; 78, expression_statement; 79, expression_statement; 80, expression_statement; 81, expression_statement; 82, function_definition; 83, expression_statement; 84, if_statement; 85, identifier:selected_kmers; 86, call; 87, identifier:dt; 88, identifier:response; 89, identifier:dt; 90, identifier:sequence; 91, assignment; 92, assignment; 93, identifier:kmer_count; 94, argument_list; 95, identifier:csc_matrix; 96, argument_list; 97, identifier:ElasticNet; 98, argument_list; 99, identifier:en; 100, identifier:fit; 101, identifier:Xsp; 102, identifier:y; 103, attribute; 104, argument_list; 105, identifier:consider_shift; 106, True; 107, comment:"""
perform stepwise model selection while preventing to add a motif similar to the
already selected motifs.
"""; 108, assignment; 109, assignment; 110, call; 111, function_name:select_criterion; 112, parameters; 113, block; 114, assignment; 115, comparison_operator:len(to_be_selected_kmers) == 0; 116, block; 117, else_clause; 118, identifier:find_next_best; 119, argument_list; 120, identifier:seq; 121, call; 122, identifier:seq; 123, list_comprehension; 124, identifier:seq; 125, identifier:k; 126, identifier:dt_kmer; 127, keyword_argument; 128, keyword_argument; 129, keyword_argument; 130, subscript; 131, identifier:tolist; 132, pattern_list; 133, call; 134, identifier:kmer; 135, call; 136, attribute; 137, argument_list; 138, identifier:s1; 139, identifier:s2; 140, default_parameter; 141, if_statement; 142, if_statement; 143, if_statement; 144, return_statement; 145, identifier:to_be_selected_kmers; 146, list_comprehension; 147, call; 148, integer:0; 149, return_statement; 150, comment:# regress out the new feature; 151, block; 152, identifier:dt_kmer; 153, identifier:y; 154, list; 155, identifier:nonzero_kmers; 156, identifier:consider_shift; 157, identifier:pad_sequences; 158, argument_list; 159, call; 160, for_in_clause; 161, identifier:alpha; 162, integer:1; 163, identifier:standardize; 164, False; 165, identifier:n_splits; 166, integer:3; 167, attribute; 168, comparison_operator:en.coef_ != 0; 169, identifier:F; 170, identifier:pval; 171, identifier:f_regression; 172, argument_list; 173, attribute; 174, argument_list; 175, identifier:selected_kmers; 176, identifier:append; 177, identifier:kmer; 178, identifier:consider_shift; 179, True; 180, comparison_operator:hamming_distance(s1, s2) <= 1; 181, block; 182, boolean_operator; 183, block; 184, boolean_operator; 185, block; 186, True; 187, identifier:ckmer; 188, for_in_clause; 189, if_clause; 190, identifier:len; 191, argument_list; 192, identifier:selected_kmers; 193, expression_statement; 194, expression_statement; 195, expression_statement; 196, return_statement; 197, identifier:seq; 198, keyword_argument; 199, keyword_argument; 200, attribute; 201, argument_list; 202, identifier:s; 203, identifier:seq; 204, attribute; 205, identifier:values; 206, attribute; 207, integer:0; 208, subscript; 209, identifier:y; 210, identifier:to_be_selected_kmers; 211, identifier:pop; 212, call; 213, call; 214, integer:1; 215, return_statement; 216, identifier:consider_shift; 217, comparison_operator:hamming_distance(s1[1:], s2[:-1]) == 0; 218, return_statement; 219, identifier:consider_shift; 220, comparison_operator:hamming_distance(s1[:-1], s2[1:]) == 0; 221, return_statement; 222, identifier:ckmer; 223, identifier:to_be_selected_kmers; 224, call; 225, identifier:to_be_selected_kmers; 226, assignment; 227, call; 228, assignment; 229, call; 230, identifier:align; 231, identifier:seq_align; 232, identifier:maxlen; 233, identifier:trim_seq_len; 234, identifier:s; 235, identifier:replace; 236, string:"N"; 237, string:""; 238, identifier:dt_kmer; 239, identifier:columns; 240, identifier:en; 241, identifier:coef_; 242, identifier:dt_kmer; 243, identifier:to_be_selected_kmers; 244, attribute; 245, argument_list; 246, identifier:hamming_distance; 247, argument_list; 248, False; 249, call; 250, integer:0; 251, False; 252, call; 253, integer:0; 254, False; 255, identifier:select_criterion; 256, argument_list; 257, identifier:lm; 258, call; 259, attribute; 260, argument_list; 261, identifier:y_new; 262, binary_operator:y - lm.predict(dt_kmer[selected_kmers]); 263, identifier:find_next_best; 264, argument_list; 265, identifier:pval; 266, identifier:argmin; 267, identifier:s1; 268, identifier:s2; 269, identifier:hamming_distance; 270, argument_list; 271, identifier:hamming_distance; 272, argument_list; 273, identifier:ckmer; 274, identifier:kmer; 275, identifier:consider_shift; 276, identifier:LinearRegression; 277, argument_list; 278, identifier:lm; 279, identifier:fit; 280, subscript; 281, identifier:y; 282, identifier:y; 283, call; 284, identifier:dt_kmer; 285, identifier:y_new; 286, identifier:selected_kmers; 287, identifier:to_be_selected_kmers; 288, identifier:consider_shift; 289, subscript; 290, subscript; 291, subscript; 292, subscript; 293, identifier:dt_kmer; 294, identifier:selected_kmers; 295, attribute; 296, argument_list; 297, identifier:s1; 298, slice; 299, identifier:s2; 300, slice; 301, identifier:s1; 302, slice; 303, identifier:s2; 304, slice; 305, identifier:lm; 306, identifier:predict; 307, subscript; 308, integer:1; 309, unary_operator; 310, unary_operator; 311, integer:1; 312, identifier:dt_kmer; 313, identifier:selected_kmers; 314, integer:1; 315, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 8, 30; 8, 31; 9, 32; 9, 33; 10, 34; 10, 35; 11, 36; 11, 37; 12, 38; 12, 39; 13, 40; 14, 41; 15, 42; 16, 43; 16, 44; 17, 45; 18, 46; 19, 47; 20, 48; 22, 49; 27, 50; 27, 51; 27, 52; 28, 53; 29, 54; 41, 55; 41, 56; 42, 57; 42, 58; 43, 59; 43, 60; 44, 61; 44, 62; 45, 63; 45, 64; 46, 65; 46, 66; 47, 67; 47, 68; 48, 69; 48, 70; 49, 71; 49, 72; 51, 73; 51, 74; 51, 75; 51, 76; 51, 77; 52, 78; 52, 79; 52, 80; 52, 81; 52, 82; 52, 83; 52, 84; 53, 85; 53, 86; 56, 87; 56, 88; 58, 89; 58, 90; 61, 91; 62, 92; 64, 93; 64, 94; 66, 95; 66, 96; 68, 97; 68, 98; 69, 99; 69, 100; 70, 101; 70, 102; 72, 103; 72, 104; 77, 105; 77, 106; 78, 107; 79, 108; 80, 109; 81, 110; 82, 111; 82, 112; 82, 113; 83, 114; 84, 115; 84, 116; 84, 117; 86, 118; 86, 119; 91, 120; 91, 121; 92, 122; 92, 123; 94, 124; 94, 125; 96, 126; 98, 127; 98, 128; 98, 129; 103, 130; 103, 131; 108, 132; 108, 133; 109, 134; 109, 135; 110, 136; 110, 137; 112, 138; 112, 139; 112, 140; 113, 141; 113, 142; 113, 143; 113, 144; 114, 145; 114, 146; 115, 147; 115, 148; 116, 149; 117, 150; 117, 151; 119, 152; 119, 153; 119, 154; 119, 155; 119, 156; 121, 157; 121, 158; 123, 159; 123, 160; 127, 161; 127, 162; 128, 163; 128, 164; 129, 165; 129, 166; 130, 167; 130, 168; 132, 169; 132, 170; 133, 171; 133, 172; 135, 173; 135, 174; 136, 175; 136, 176; 137, 177; 140, 178; 140, 179; 141, 180; 141, 181; 142, 182; 142, 183; 143, 184; 143, 185; 144, 186; 146, 187; 146, 188; 146, 189; 147, 190; 147, 191; 149, 192; 151, 193; 151, 194; 151, 195; 151, 196; 158, 197; 158, 198; 158, 199; 159, 200; 159, 201; 160, 202; 160, 203; 167, 204; 167, 205; 168, 206; 168, 207; 172, 208; 172, 209; 173, 210; 173, 211; 174, 212; 180, 213; 180, 214; 181, 215; 182, 216; 182, 217; 183, 218; 184, 219; 184, 220; 185, 221; 188, 222; 188, 223; 189, 224; 191, 225; 193, 226; 194, 227; 195, 228; 196, 229; 198, 230; 198, 231; 199, 232; 199, 233; 200, 234; 200, 235; 201, 236; 201, 237; 204, 238; 204, 239; 206, 240; 206, 241; 208, 242; 208, 243; 212, 244; 212, 245; 213, 246; 213, 247; 215, 248; 217, 249; 217, 250; 218, 251; 220, 252; 220, 253; 221, 254; 224, 255; 224, 256; 226, 257; 226, 258; 227, 259; 227, 260; 228, 261; 228, 262; 229, 263; 229, 264; 244, 265; 244, 266; 247, 267; 247, 268; 249, 269; 249, 270; 252, 271; 252, 272; 256, 273; 256, 274; 256, 275; 258, 276; 258, 277; 259, 278; 259, 279; 260, 280; 260, 281; 262, 282; 262, 283; 264, 284; 264, 285; 264, 286; 264, 287; 264, 288; 270, 289; 270, 290; 272, 291; 272, 292; 280, 293; 280, 294; 283, 295; 283, 296; 289, 297; 289, 298; 290, 299; 290, 300; 291, 301; 291, 302; 292, 303; 292, 304; 295, 305; 295, 306; 296, 307; 298, 308; 300, 309; 302, 310; 304, 311; 307, 312; 307, 313; 309, 314; 310, 315 | def best_kmers(dt, response, sequence, k=6, consider_shift=True, n_cores=1,
seq_align="start", trim_seq_len=None):
"""
Find best k-mers for CONCISE initialization.
Args:
dt (pd.DataFrame): Table containing response variable and sequence.
response (str): Name of the column used as the reponse variable.
sequence (str): Name of the column storing the DNA/RNA sequences.
k (int): Desired k-mer length.
n_cores (int): Number of cores to use for computation. It can use up to 3 cores.
consider_shift (boolean): When performing stepwise k-mer selection. Is TATTTA similar to ATTTAG?
seq_align (str): one of ``{"start", "end"}``. To which end should we align sequences?
trim_seq_len (int): Consider only first `trim_seq_len` bases of each sequence when generating the sequence design matrix. If :python:`None`, set :py:attr:`trim_seq_len` to the longest sequence length, hence whole sequences are considered.
Returns:
string list: Best set of motifs for this dataset sorted with respect to
confidence (best candidate occuring first).
Details:
First a lasso model gets fitted to get a set of initial motifs. Next, the best
subset of unrelated motifs is selected by stepwise selection.
"""
y = dt[response]
seq = dt[sequence]
if trim_seq_len is not None:
seq = pad_sequences(seq, align=seq_align, maxlen=trim_seq_len)
seq = [s.replace("N", "") for s in seq]
dt_kmer = kmer_count(seq, k)
Xsp = csc_matrix(dt_kmer)
en = ElasticNet(alpha=1, standardize=False, n_splits=3)
en.fit(Xsp, y)
# which coefficients are nonzero?=
nonzero_kmers = dt_kmer.columns.values[en.coef_ != 0].tolist()
# perform stepwise selection
#
# TODO - how do we deal with the intercept?
# largest number of motifs where they don't differ by more than 1 k-mer
def find_next_best(dt_kmer, y, selected_kmers, to_be_selected_kmers, consider_shift=True):
"""
perform stepwise model selection while preventing to add a motif similar to the
already selected motifs.
"""
F, pval = f_regression(dt_kmer[to_be_selected_kmers], y)
kmer = to_be_selected_kmers.pop(pval.argmin())
selected_kmers.append(kmer)
def select_criterion(s1, s2, consider_shift=True):
if hamming_distance(s1, s2) <= 1:
return False
if consider_shift and hamming_distance(s1[1:], s2[:-1]) == 0:
return False
if consider_shift and hamming_distance(s1[:-1], s2[1:]) == 0:
return False
return True
to_be_selected_kmers = [ckmer for ckmer in to_be_selected_kmers
if select_criterion(ckmer, kmer, consider_shift)]
if len(to_be_selected_kmers) == 0:
return selected_kmers
else:
# regress out the new feature
lm = LinearRegression()
lm.fit(dt_kmer[selected_kmers], y)
y_new = y - lm.predict(dt_kmer[selected_kmers])
return find_next_best(dt_kmer, y_new, selected_kmers, to_be_selected_kmers, consider_shift)
selected_kmers = find_next_best(dt_kmer, y, [], nonzero_kmers, consider_shift)
return selected_kmers |
0, module; 1, function_definition; 2, function_name:_custom_rdd_reduce; 3, parameters; 4, block; 5, identifier:self; 6, identifier:reduce_func; 7, expression_statement; 8, function_definition; 9, expression_statement; 10, return_statement; 11, comment:"""Provides a custom RDD reduce which preserves ordering if the RDD has
been sorted. This is useful for us because we need this functionality
as many pandas operations support sorting the results. The standard
reduce in PySpark does not have this property. Note that when PySpark
no longer does partition reduces locally this code will also need to
be updated."""; 12, function_name:accumulating_iter; 13, parameters; 14, block; 15, assignment; 16, call; 17, identifier:iterator; 18, expression_statement; 19, for_statement; 20, if_statement; 21, identifier:vals; 22, call; 23, identifier:reduce; 24, argument_list; 25, assignment; 26, identifier:obj; 27, identifier:iterator; 28, block; 29, comparison_operator:acc is not None; 30, block; 31, attribute; 32, argument_list; 33, identifier:accumulating_iter; 34, identifier:vals; 35, identifier:acc; 36, None; 37, if_statement; 38, identifier:acc; 39, None; 40, expression_statement; 41, call; 42, identifier:collect; 43, comparison_operator:acc is None; 44, block; 45, else_clause; 46, yield; 47, attribute; 48, argument_list; 49, identifier:acc; 50, None; 51, expression_statement; 52, block; 53, identifier:acc; 54, attribute; 55, identifier:mapPartitions; 56, identifier:accumulating_iter; 57, assignment; 58, expression_statement; 59, identifier:self; 60, identifier:_rdd; 61, identifier:acc; 62, identifier:obj; 63, assignment; 64, identifier:acc; 65, call; 66, identifier:reduce_func; 67, argument_list; 68, identifier:acc; 69, identifier:obj | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 8, 13; 8, 14; 9, 15; 10, 16; 13, 17; 14, 18; 14, 19; 14, 20; 15, 21; 15, 22; 16, 23; 16, 24; 18, 25; 19, 26; 19, 27; 19, 28; 20, 29; 20, 30; 22, 31; 22, 32; 24, 33; 24, 34; 25, 35; 25, 36; 28, 37; 29, 38; 29, 39; 30, 40; 31, 41; 31, 42; 37, 43; 37, 44; 37, 45; 40, 46; 41, 47; 41, 48; 43, 49; 43, 50; 44, 51; 45, 52; 46, 53; 47, 54; 47, 55; 48, 56; 51, 57; 52, 58; 54, 59; 54, 60; 57, 61; 57, 62; 58, 63; 63, 64; 63, 65; 65, 66; 65, 67; 67, 68; 67, 69 | def _custom_rdd_reduce(self, reduce_func):
"""Provides a custom RDD reduce which preserves ordering if the RDD has
been sorted. This is useful for us because we need this functionality
as many pandas operations support sorting the results. The standard
reduce in PySpark does not have this property. Note that when PySpark
no longer does partition reduces locally this code will also need to
be updated."""
def accumulating_iter(iterator):
acc = None
for obj in iterator:
if acc is None:
acc = obj
else:
acc = reduce_func(acc, obj)
if acc is not None:
yield acc
vals = self._rdd.mapPartitions(accumulating_iter).collect()
return reduce(accumulating_iter, vals) |
0, module; 1, function_definition; 2, function_name:__sort_analyses; 3, parameters; 4, block; 5, identifier:sentence; 6, expression_statement; 7, for_statement; 8, return_statement; 9, string; 10, identifier:word; 11, identifier:sentence; 12, block; 13, identifier:sentence; 14, string_content:Sorts analysis of all the words in the sentence.
This is required for consistency, because by default, analyses are
listed in arbitrary order;; 15, if_statement; 16, comparison_operator:ANALYSIS not in word; 17, block; 18, else_clause; 19, identifier:ANALYSIS; 20, identifier:word; 21, raise_statement; 22, block; 23, call; 24, expression_statement; 25, identifier:Exception; 26, argument_list; 27, assignment; 28, binary_operator:'(!) Error: no analysis found from word: '+str(word); 29, subscript; 30, call; 31, string; 32, call; 33, identifier:word; 34, identifier:ANALYSIS; 35, identifier:sorted; 36, argument_list; 37, string_content:(!) Error: no analysis found from word:; 38, identifier:str; 39, argument_list; 40, subscript; 41, line_continuation:\; 42, keyword_argument; 43, identifier:word; 44, identifier:word; 45, identifier:ANALYSIS; 46, identifier:key; 47, lambda; 48, lambda_parameters; 49, call; 50, identifier:x; 51, attribute; 52, argument_list; 53, string:"_"; 54, identifier:join; 55, list; 56, subscript; 57, subscript; 58, subscript; 59, subscript; 60, identifier:x; 61, identifier:ROOT; 62, identifier:x; 63, identifier:POSTAG; 64, identifier:x; 65, identifier:FORM; 66, identifier:x; 67, identifier:CLITIC | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 7, 11; 7, 12; 8, 13; 9, 14; 12, 15; 15, 16; 15, 17; 15, 18; 16, 19; 16, 20; 17, 21; 18, 22; 21, 23; 22, 24; 23, 25; 23, 26; 24, 27; 26, 28; 27, 29; 27, 30; 28, 31; 28, 32; 29, 33; 29, 34; 30, 35; 30, 36; 31, 37; 32, 38; 32, 39; 36, 40; 36, 41; 36, 42; 39, 43; 40, 44; 40, 45; 42, 46; 42, 47; 47, 48; 47, 49; 48, 50; 49, 51; 49, 52; 51, 53; 51, 54; 52, 55; 55, 56; 55, 57; 55, 58; 55, 59; 56, 60; 56, 61; 57, 62; 57, 63; 58, 64; 58, 65; 59, 66; 59, 67 | def __sort_analyses(sentence):
''' Sorts analysis of all the words in the sentence.
This is required for consistency, because by default, analyses are
listed in arbitrary order; '''
for word in sentence:
if ANALYSIS not in word:
raise Exception( '(!) Error: no analysis found from word: '+str(word) )
else:
word[ANALYSIS] = sorted(word[ANALYSIS], \
key=lambda x : "_".join( [x[ROOT],x[POSTAG],x[FORM],x[CLITIC]] ))
return sentence |
0, module; 1, function_definition; 2, function_name:tag; 3, parameters; 4, block; 5, identifier:self; 6, identifier:text; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, if_statement; 11, if_statement; 12, comment:"""Retrieves list of keywords in text.
Parameters
----------
text: Text
The text to search for events.
Returns
-------
list of vents sorted by start, end
"""; 13, comparison_operator:self.search_method == 'ahocorasick'; 14, block; 15, elif_clause; 16, assignment; 17, attribute; 18, block; 19, attribute; 20, block; 21, else_clause; 22, attribute; 23, string; 24, expression_statement; 25, comparison_operator:self.search_method == 'naive'; 26, block; 27, identifier:events; 28, call; 29, identifier:self; 30, identifier:mapping; 31, for_statement; 32, identifier:self; 33, identifier:return_layer; 34, return_statement; 35, block; 36, identifier:self; 37, identifier:search_method; 38, string_content:ahocorasick; 39, assignment; 40, attribute; 41, string; 42, expression_statement; 43, attribute; 44, argument_list; 45, identifier:item; 46, identifier:events; 47, block; 48, identifier:events; 49, expression_statement; 50, identifier:events; 51, call; 52, identifier:self; 53, identifier:search_method; 54, string_content:naive; 55, assignment; 56, identifier:self; 57, identifier:_resolve_conflicts; 58, identifier:events; 59, expression_statement; 60, assignment; 61, attribute; 62, argument_list; 63, identifier:events; 64, call; 65, assignment; 66, subscript; 67, identifier:events; 68, identifier:self; 69, identifier:_find_keywords_ahocorasick; 70, attribute; 71, attribute; 72, argument_list; 73, subscript; 74, subscript; 75, identifier:text; 76, attribute; 77, identifier:text; 78, identifier:text; 79, identifier:self; 80, identifier:_find_keywords_naive; 81, attribute; 82, identifier:item; 83, string; 84, attribute; 85, subscript; 86, identifier:self; 87, identifier:layer_name; 88, identifier:text; 89, identifier:text; 90, string_content:type; 91, identifier:self; 92, identifier:map; 93, attribute; 94, slice; 95, identifier:text; 96, identifier:text; 97, subscript; 98, subscript; 99, identifier:item; 100, string; 101, identifier:item; 102, string; 103, string_content:start; 104, string_content:end | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 8, 14; 8, 15; 9, 16; 10, 17; 10, 18; 11, 19; 11, 20; 11, 21; 13, 22; 13, 23; 14, 24; 15, 25; 15, 26; 16, 27; 16, 28; 17, 29; 17, 30; 18, 31; 19, 32; 19, 33; 20, 34; 21, 35; 22, 36; 22, 37; 23, 38; 24, 39; 25, 40; 25, 41; 26, 42; 28, 43; 28, 44; 31, 45; 31, 46; 31, 47; 34, 48; 35, 49; 39, 50; 39, 51; 40, 52; 40, 53; 41, 54; 42, 55; 43, 56; 43, 57; 44, 58; 47, 59; 49, 60; 51, 61; 51, 62; 55, 63; 55, 64; 59, 65; 60, 66; 60, 67; 61, 68; 61, 69; 62, 70; 64, 71; 64, 72; 65, 73; 65, 74; 66, 75; 66, 76; 70, 77; 70, 78; 71, 79; 71, 80; 72, 81; 73, 82; 73, 83; 74, 84; 74, 85; 76, 86; 76, 87; 81, 88; 81, 89; 83, 90; 84, 91; 84, 92; 85, 93; 85, 94; 93, 95; 93, 96; 94, 97; 94, 98; 97, 99; 97, 100; 98, 101; 98, 102; 100, 103; 102, 104 | def tag(self, text):
"""Retrieves list of keywords in text.
Parameters
----------
text: Text
The text to search for events.
Returns
-------
list of vents sorted by start, end
"""
if self.search_method == 'ahocorasick':
events = self._find_keywords_ahocorasick(text.text)
elif self.search_method == 'naive':
events = self._find_keywords_naive(text.text)
events = self._resolve_conflicts(events)
if self.mapping:
for item in events:
item['type'] = self.map[
text.text[item['start']:item['end']]
]
if self.return_layer:
return events
else:
text[self.layer_name] = events |
0, module; 1, function_definition; 2, function_name:search; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:term; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, comment:# If fields are provided, override the ones in the class; 11, if_statement; 12, expression_statement; 13, comment:# Cache the LIKE terms; 14, expression_statement; 15, expression_statement; 16, comment:# Cache the order by terms; 17, comment:# @TODO Peewee's order_by supports an `extend` kwarg will will allow; 18, comment:# for updating of the order by part of the query, but it's only; 19, comment:# supported in Peewee 2.8.5 and newer. Determine if we can support this; 20, comment:# before switching.; 21, comment:# http://docs.peewee-orm.com/en/stable/peewee/api.html#SelectQuery.order_by; 22, expression_statement; 23, comment:# Store the clauses seperately because it is needed to perform an OR on; 24, comment:# them and that's somehow impossible with their query builder in; 25, comment:# a loop.; 26, expression_statement; 27, for_statement; 28, comment:# Apply the clauses to the query; 29, expression_statement; 30, comment:# Apply the sort order so it's influenced by the search term relevance.; 31, expression_statement; 32, return_statement; 33, identifier:fields; 34, tuple; 35, comment:"""Generic SQL search function that uses SQL ``LIKE`` to search the
database for matching records. The records are sorted by their
relavancey to the search term.
The query searches and sorts on the folling criteria, in order, where
the target string is ``exactly``:
1. Straight equality (``x = 'exactly'``)
2. Right hand ``LIKE`` (``x LIKE 'exact%'``)
3. Substring ``LIKE`` (``x LIKE %act%``)
Args:
term (str): The search term to apply to the query.
Keyword Args:
fields (list|tuple|None): An optional list of fields to apply the
search to. If not provided, the class variable
``Meta.search_fields`` will be used by default.
Returns:
peewee.SelectQuery: An unexecuted query for the records.
Raises:
AttributeError: Raised if `search_fields` isn't defined in the
class and `fields` aren't provided for the function.
"""; 36, not_operator; 37, block; 38, not_operator; 39, block; 40, assignment; 41, assignment; 42, assignment; 43, assignment; 44, assignment; 45, identifier:field_name; 46, identifier:fields; 47, comment:# Cache the field, raising an exception if the field doesn't; 48, comment:# exist.; 49, block; 50, assignment; 51, assignment; 52, identifier:query; 53, call; 54, raise_statement; 55, identifier:fields; 56, expression_statement; 57, identifier:query; 58, call; 59, identifier:like_term; 60, call; 61, identifier:full_like_term; 62, call; 63, identifier:order_by; 64, list; 65, identifier:clauses; 66, list; 67, expression_statement; 68, comment:# Apply the search term case insensitively; 69, expression_statement; 70, expression_statement; 71, identifier:query; 72, call; 73, identifier:query; 74, call; 75, identifier:any; 76, argument_list; 77, call; 78, assignment; 79, attribute; 80, argument_list; 81, attribute; 82, argument_list; 83, attribute; 84, argument_list; 85, assignment; 86, call; 87, call; 88, attribute; 89, argument_list; 90, attribute; 91, argument_list; 92, tuple; 93, identifier:AttributeError; 94, argument_list; 95, identifier:fields; 96, attribute; 97, identifier:cls; 98, identifier:select; 99, string; 100, identifier:join; 101, tuple; 102, string; 103, identifier:join; 104, tuple; 105, identifier:field; 106, call; 107, attribute; 108, argument_list; 109, attribute; 110, argument_list; 111, identifier:query; 112, identifier:where; 113, call; 114, identifier:query; 115, identifier:order_by; 116, list_splat; 117, attribute; 118, identifier:fields; 119, concatenated_string; 120, attribute; 121, identifier:search_fields; 122, identifier:term; 123, string; 124, string; 125, identifier:term; 126, string; 127, identifier:getattr; 128, argument_list; 129, identifier:clauses; 130, identifier:append; 131, binary_operator:(field == term) |
(field ** like_term) |
(field ** full_like_term); 132, identifier:order_by; 133, identifier:append; 134, call; 135, identifier:reduce; 136, argument_list; 137, identifier:order_by; 138, attribute; 139, identifier:search_fields; 140, string:"A list of searchable fields must be provided in the class's "; 141, string:"search_fields or provided to this function in the `fields` "; 142, string:"kwarg."; 143, identifier:cls; 144, identifier:_meta; 145, string_content:%; 146, string_content:%; 147, string_content:%; 148, identifier:cls; 149, identifier:field_name; 150, binary_operator:(field == term) |
(field ** like_term); 151, parenthesized_expression; 152, attribute; 153, argument_list; 154, attribute; 155, identifier:clauses; 156, identifier:cls; 157, identifier:_meta; 158, parenthesized_expression; 159, parenthesized_expression; 160, binary_operator:field ** full_like_term; 161, call; 162, identifier:asc; 163, identifier:operator; 164, identifier:or_; 165, comparison_operator:field == term; 166, binary_operator:field ** like_term; 167, identifier:field; 168, identifier:full_like_term; 169, identifier:case; 170, argument_list; 171, identifier:field; 172, identifier:term; 173, identifier:field; 174, identifier:like_term; 175, None; 176, tuple; 177, keyword_argument; 178, comment:# Straight matches should show up first; 179, tuple; 180, comment:# Similar terms should show up second; 181, tuple; 182, comment:# Substring matches should show up third; 183, tuple; 184, identifier:default; 185, integer:3; 186, comparison_operator:field == term; 187, integer:0; 188, binary_operator:field ** like_term; 189, integer:1; 190, binary_operator:field ** full_like_term; 191, integer:2; 192, identifier:field; 193, identifier:term; 194, identifier:field; 195, identifier:like_term; 196, identifier:field; 197, identifier:full_like_term | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 4, 30; 4, 31; 4, 32; 7, 33; 7, 34; 8, 35; 9, 36; 9, 37; 11, 38; 11, 39; 12, 40; 14, 41; 15, 42; 22, 43; 26, 44; 27, 45; 27, 46; 27, 47; 27, 48; 27, 49; 29, 50; 31, 51; 32, 52; 36, 53; 37, 54; 38, 55; 39, 56; 40, 57; 40, 58; 41, 59; 41, 60; 42, 61; 42, 62; 43, 63; 43, 64; 44, 65; 44, 66; 49, 67; 49, 68; 49, 69; 49, 70; 50, 71; 50, 72; 51, 73; 51, 74; 53, 75; 53, 76; 54, 77; 56, 78; 58, 79; 58, 80; 60, 81; 60, 82; 62, 83; 62, 84; 67, 85; 69, 86; 70, 87; 72, 88; 72, 89; 74, 90; 74, 91; 76, 92; 77, 93; 77, 94; 78, 95; 78, 96; 79, 97; 79, 98; 81, 99; 81, 100; 82, 101; 83, 102; 83, 103; 84, 104; 85, 105; 85, 106; 86, 107; 86, 108; 87, 109; 87, 110; 88, 111; 88, 112; 89, 113; 90, 114; 90, 115; 91, 116; 92, 117; 92, 118; 94, 119; 96, 120; 96, 121; 101, 122; 101, 123; 104, 124; 104, 125; 104, 126; 106, 127; 106, 128; 107, 129; 107, 130; 108, 131; 109, 132; 109, 133; 110, 134; 113, 135; 113, 136; 116, 137; 117, 138; 117, 139; 119, 140; 119, 141; 119, 142; 120, 143; 120, 144; 123, 145; 124, 146; 126, 147; 128, 148; 128, 149; 131, 150; 131, 151; 134, 152; 134, 153; 136, 154; 136, 155; 138, 156; 138, 157; 150, 158; 150, 159; 151, 160; 152, 161; 152, 162; 154, 163; 154, 164; 158, 165; 159, 166; 160, 167; 160, 168; 161, 169; 161, 170; 165, 171; 165, 172; 166, 173; 166, 174; 170, 175; 170, 176; 170, 177; 176, 178; 176, 179; 176, 180; 176, 181; 176, 182; 176, 183; 177, 184; 177, 185; 179, 186; 179, 187; 181, 188; 181, 189; 183, 190; 183, 191; 186, 192; 186, 193; 188, 194; 188, 195; 190, 196; 190, 197 | def search(cls, term, fields=()):
"""Generic SQL search function that uses SQL ``LIKE`` to search the
database for matching records. The records are sorted by their
relavancey to the search term.
The query searches and sorts on the folling criteria, in order, where
the target string is ``exactly``:
1. Straight equality (``x = 'exactly'``)
2. Right hand ``LIKE`` (``x LIKE 'exact%'``)
3. Substring ``LIKE`` (``x LIKE %act%``)
Args:
term (str): The search term to apply to the query.
Keyword Args:
fields (list|tuple|None): An optional list of fields to apply the
search to. If not provided, the class variable
``Meta.search_fields`` will be used by default.
Returns:
peewee.SelectQuery: An unexecuted query for the records.
Raises:
AttributeError: Raised if `search_fields` isn't defined in the
class and `fields` aren't provided for the function.
"""
if not any((cls._meta.search_fields, fields)):
raise AttributeError(
"A list of searchable fields must be provided in the class's "
"search_fields or provided to this function in the `fields` "
"kwarg."
)
# If fields are provided, override the ones in the class
if not fields:
fields = cls._meta.search_fields
query = cls.select()
# Cache the LIKE terms
like_term = ''.join((term, '%'))
full_like_term = ''.join(('%', term, '%'))
# Cache the order by terms
# @TODO Peewee's order_by supports an `extend` kwarg will will allow
# for updating of the order by part of the query, but it's only
# supported in Peewee 2.8.5 and newer. Determine if we can support this
# before switching.
# http://docs.peewee-orm.com/en/stable/peewee/api.html#SelectQuery.order_by
order_by = []
# Store the clauses seperately because it is needed to perform an OR on
# them and that's somehow impossible with their query builder in
# a loop.
clauses = []
for field_name in fields:
# Cache the field, raising an exception if the field doesn't
# exist.
field = getattr(cls, field_name)
# Apply the search term case insensitively
clauses.append(
(field == term) |
(field ** like_term) |
(field ** full_like_term)
)
order_by.append(case(None, (
# Straight matches should show up first
(field == term, 0),
# Similar terms should show up second
(field ** like_term, 1),
# Substring matches should show up third
(field ** full_like_term, 2),
), default=3).asc())
# Apply the clauses to the query
query = query.where(reduce(operator.or_, clauses))
# Apply the sort order so it's influenced by the search term relevance.
query = query.order_by(*order_by)
return query |
0, module; 1, function_definition; 2, function_name:dependency_sort; 3, parameters; 4, block; 5, identifier:dependency_tree; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""
Sorts items 'dependencies first' in a given dependency tree.
A dependency tree is a dictionary mapping an object to a collection its
dependency objects.
Result is a properly sorted list of items, where each item is a 2-tuple
containing an object and its dependency list, as given in the input
dependency tree.
If B is directly or indirectly dependent on A and they are not both a part
of the same dependency cycle (i.e. then A is neither directly nor
indirectly dependent on B) then A needs to come before B.
If A and B are a part of the same dependency cycle, i.e. if they are both
directly or indirectly dependent on each other, then it does not matter
which comes first.
Any entries found listed as dependencies, but that do not have their own
dependencies listed as well, are logged & ignored.
@return: The sorted items.
@rtype: list
"""; 12, assignment; 13, assignment; 14, pattern_list; 15, call; 16, block; 17, identifier:sorted; 18, identifier:sorted; 19, list; 20, identifier:processed; 21, call; 22, identifier:key; 23, identifier:deps; 24, attribute; 25, argument_list; 26, expression_statement; 27, identifier:set; 28, argument_list; 29, identifier:dependency_tree; 30, identifier:iteritems; 31, call; 32, identifier:_sort_r; 33, argument_list; 34, identifier:sorted; 35, identifier:processed; 36, identifier:key; 37, identifier:deps; 38, identifier:dependency_tree | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 12, 18; 12, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 21, 27; 21, 28; 24, 29; 24, 30; 26, 31; 31, 32; 31, 33; 33, 34; 33, 35; 33, 36; 33, 37; 33, 38 | def dependency_sort(dependency_tree):
"""
Sorts items 'dependencies first' in a given dependency tree.
A dependency tree is a dictionary mapping an object to a collection its
dependency objects.
Result is a properly sorted list of items, where each item is a 2-tuple
containing an object and its dependency list, as given in the input
dependency tree.
If B is directly or indirectly dependent on A and they are not both a part
of the same dependency cycle (i.e. then A is neither directly nor
indirectly dependent on B) then A needs to come before B.
If A and B are a part of the same dependency cycle, i.e. if they are both
directly or indirectly dependent on each other, then it does not matter
which comes first.
Any entries found listed as dependencies, but that do not have their own
dependencies listed as well, are logged & ignored.
@return: The sorted items.
@rtype: list
"""
sorted = []
processed = set()
for key, deps in dependency_tree.iteritems():
_sort_r(sorted, processed, key, deps, dependency_tree)
return sorted |
0, module; 1, function_definition; 2, function_name:_sort_r; 3, parameters; 4, block; 5, identifier:sorted; 6, identifier:processed; 7, identifier:key; 8, identifier:deps; 9, identifier:dependency_tree; 10, expression_statement; 11, if_statement; 12, expression_statement; 13, for_statement; 14, expression_statement; 15, comment:"""Recursive topological sort implementation."""; 16, comparison_operator:key in processed; 17, block; 18, call; 19, identifier:dep_key; 20, identifier:deps; 21, block; 22, call; 23, identifier:key; 24, identifier:processed; 25, return_statement; 26, attribute; 27, argument_list; 28, expression_statement; 29, if_statement; 30, expression_statement; 31, attribute; 32, argument_list; 33, identifier:processed; 34, identifier:add; 35, identifier:key; 36, assignment; 37, comparison_operator:dep_deps is None; 38, block; 39, call; 40, identifier:sorted; 41, identifier:append; 42, tuple; 43, identifier:dep_deps; 44, call; 45, identifier:dep_deps; 46, None; 47, expression_statement; 48, continue_statement; 49, identifier:_sort_r; 50, argument_list; 51, identifier:key; 52, identifier:deps; 53, attribute; 54, argument_list; 55, call; 56, identifier:sorted; 57, identifier:processed; 58, identifier:dep_key; 59, identifier:dep_deps; 60, identifier:dependency_tree; 61, identifier:dependency_tree; 62, identifier:get; 63, identifier:dep_key; 64, attribute; 65, argument_list; 66, identifier:log; 67, identifier:debug; 68, string:'"%s" not found, skipped'; 69, call; 70, identifier:Repr; 71, argument_list; 72, identifier:dep_key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 10, 15; 11, 16; 11, 17; 12, 18; 13, 19; 13, 20; 13, 21; 14, 22; 16, 23; 16, 24; 17, 25; 18, 26; 18, 27; 21, 28; 21, 29; 21, 30; 22, 31; 22, 32; 26, 33; 26, 34; 27, 35; 28, 36; 29, 37; 29, 38; 30, 39; 31, 40; 31, 41; 32, 42; 36, 43; 36, 44; 37, 45; 37, 46; 38, 47; 38, 48; 39, 49; 39, 50; 42, 51; 42, 52; 44, 53; 44, 54; 47, 55; 50, 56; 50, 57; 50, 58; 50, 59; 50, 60; 53, 61; 53, 62; 54, 63; 55, 64; 55, 65; 64, 66; 64, 67; 65, 68; 65, 69; 69, 70; 69, 71; 71, 72 | def _sort_r(sorted, processed, key, deps, dependency_tree):
"""Recursive topological sort implementation."""
if key in processed:
return
processed.add(key)
for dep_key in deps:
dep_deps = dependency_tree.get(dep_key)
if dep_deps is None:
log.debug('"%s" not found, skipped', Repr(dep_key))
continue
_sort_r(sorted, processed, dep_key, dep_deps, dependency_tree)
sorted.append((key, deps)) |
0, module; 1, function_definition; 2, function_name:list; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, if_statement; 13, expression_statement; 14, expression_statement; 15, comment:# `cid` is the only required argument; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, comment:# When the downloads directory exists along with its parent directory,; 22, comment:# the receiver directory, its parent's count (receiver directory's; 23, comment:# count) does not include the downloads directory. This behavior is; 24, comment:# similar to its parent's parent (root), the count of which does not; 25, comment:# include the receiver directory.; 26, comment:# The following code fixed this behavior so that a directory's; 27, comment:# count correctly reflects the actual number of entries in it; 28, comment:# The side-effect that this code may ensure that downloads directory; 29, comment:# exists, causing the system to create the receiver directory and; 30, comment:# downloads directory, if they do not exist.; 31, if_statement; 32, if_statement; 33, try_statement; 34, expression_statement; 35, for_statement; 36, return_statement; 37, identifier:count; 38, integer:30; 39, identifier:order; 40, string; 41, identifier:asc; 42, False; 43, identifier:show_dir; 44, True; 45, identifier:natsort; 46, True; 47, comment:"""
List directory contents
:param int count: number of entries to be listed
:param str order: order of entries, originally named `o`. This value
may be one of `user_ptime` (default), `file_size` and `file_name`
:param bool asc: whether in ascending order
:param bool show_dir: whether to show directories
:param bool natsort: whether to use natural sort
Return a list of :class:`.File` or :class:`.Directory` objects
"""; 48, comparison_operator:self.cid is None; 49, block; 50, call; 51, assignment; 52, assignment; 53, assignment; 54, assignment; 55, assignment; 56, assignment; 57, boolean_operator; 58, block; 59, comparison_operator:self.count <= count; 60, comment:# count should never be greater than self.count; 61, block; 62, block; 63, comment:# When natsort=1 and order='file_name', API access will fail; 64, except_clause; 65, assignment; 66, identifier:entry; 67, identifier:entries; 68, block; 69, identifier:res; 70, string_content:user_ptime; 71, attribute; 72, None; 73, return_statement; 74, attribute; 75, argument_list; 76, identifier:kwargs; 77, dictionary; 78, subscript; 79, attribute; 80, subscript; 81, conditional_expression:1 if asc is True else 0; 82, subscript; 83, conditional_expression:1 if show_dir is True else 0; 84, subscript; 85, conditional_expression:1 if natsort is True else 0; 86, subscript; 87, identifier:order; 88, attribute; 89, comparison_operator:self == self.api.receiver_directory; 90, expression_statement; 91, attribute; 92, identifier:count; 93, expression_statement; 94, expression_statement; 95, as_pattern; 96, block; 97, identifier:res; 98, list; 99, if_statement; 100, identifier:self; 101, identifier:cid; 102, False; 103, identifier:self; 104, identifier:reload; 105, identifier:kwargs; 106, string; 107, identifier:self; 108, identifier:cid; 109, identifier:kwargs; 110, string; 111, integer:1; 112, comparison_operator:asc is True; 113, integer:0; 114, identifier:kwargs; 115, string; 116, integer:1; 117, comparison_operator:show_dir is True; 118, integer:0; 119, identifier:kwargs; 120, string; 121, integer:1; 122, comparison_operator:natsort is True; 123, integer:0; 124, identifier:kwargs; 125, string; 126, identifier:self; 127, identifier:is_root; 128, identifier:self; 129, attribute; 130, augmented_assignment; 131, identifier:self; 132, identifier:count; 133, assignment; 134, assignment; 135, identifier:RequestFailure; 136, as_pattern_target; 137, if_statement; 138, comparison_operator:'pid' in entry; 139, block; 140, else_clause; 141, string_content:cid; 142, string_content:asc; 143, identifier:asc; 144, True; 145, string_content:show_dir; 146, identifier:show_dir; 147, True; 148, string_content:natsort; 149, identifier:natsort; 150, True; 151, string_content:o; 152, attribute; 153, identifier:receiver_directory; 154, attribute; 155, integer:1; 156, identifier:count; 157, attribute; 158, identifier:entries; 159, call; 160, identifier:e; 161, boolean_operator; 162, block; 163, else_clause; 164, string; 165, identifier:entry; 166, expression_statement; 167, block; 168, identifier:self; 169, identifier:api; 170, identifier:self; 171, identifier:_count; 172, identifier:self; 173, identifier:count; 174, attribute; 175, argument_list; 176, comparison_operator:natsort is True; 177, comparison_operator:order == 'file_name'; 178, expression_statement; 179, block; 180, string_content:pid; 181, call; 182, expression_statement; 183, identifier:self; 184, identifier:_load_entries; 185, keyword_argument; 186, keyword_argument; 187, keyword_argument; 188, dictionary_splat; 189, identifier:natsort; 190, True; 191, identifier:order; 192, string; 193, assignment; 194, raise_statement; 195, attribute; 196, argument_list; 197, call; 198, identifier:func; 199, attribute; 200, identifier:count; 201, identifier:count; 202, identifier:page; 203, integer:1; 204, identifier:kwargs; 205, string_content:file_name; 206, identifier:entries; 207, line_continuation:\; 208, call; 209, identifier:e; 210, identifier:res; 211, identifier:append; 212, call; 213, attribute; 214, argument_list; 215, attribute; 216, identifier:_req_files; 217, attribute; 218, argument_list; 219, identifier:_instantiate_directory; 220, argument_list; 221, identifier:res; 222, identifier:append; 223, call; 224, identifier:self; 225, identifier:api; 226, identifier:self; 227, identifier:_load_entries; 228, keyword_argument; 229, keyword_argument; 230, keyword_argument; 231, dictionary_splat; 232, attribute; 233, identifier:entry; 234, identifier:_instantiate_file; 235, argument_list; 236, identifier:func; 237, attribute; 238, identifier:count; 239, identifier:count; 240, identifier:page; 241, integer:1; 242, identifier:kwargs; 243, identifier:self; 244, identifier:api; 245, attribute; 246, identifier:entry; 247, attribute; 248, identifier:_req_aps_natsort_files; 249, identifier:self; 250, identifier:api; 251, identifier:self; 252, identifier:api | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 4, 30; 4, 31; 4, 32; 4, 33; 4, 34; 4, 35; 4, 36; 6, 37; 6, 38; 7, 39; 7, 40; 8, 41; 8, 42; 9, 43; 9, 44; 10, 45; 10, 46; 11, 47; 12, 48; 12, 49; 13, 50; 14, 51; 16, 52; 17, 53; 18, 54; 19, 55; 20, 56; 31, 57; 31, 58; 32, 59; 32, 60; 32, 61; 33, 62; 33, 63; 33, 64; 34, 65; 35, 66; 35, 67; 35, 68; 36, 69; 40, 70; 48, 71; 48, 72; 49, 73; 50, 74; 50, 75; 51, 76; 51, 77; 52, 78; 52, 79; 53, 80; 53, 81; 54, 82; 54, 83; 55, 84; 55, 85; 56, 86; 56, 87; 57, 88; 57, 89; 58, 90; 59, 91; 59, 92; 61, 93; 62, 94; 64, 95; 64, 96; 65, 97; 65, 98; 68, 99; 71, 100; 71, 101; 73, 102; 74, 103; 74, 104; 78, 105; 78, 106; 79, 107; 79, 108; 80, 109; 80, 110; 81, 111; 81, 112; 81, 113; 82, 114; 82, 115; 83, 116; 83, 117; 83, 118; 84, 119; 84, 120; 85, 121; 85, 122; 85, 123; 86, 124; 86, 125; 88, 126; 88, 127; 89, 128; 89, 129; 90, 130; 91, 131; 91, 132; 93, 133; 94, 134; 95, 135; 95, 136; 96, 137; 99, 138; 99, 139; 99, 140; 106, 141; 110, 142; 112, 143; 112, 144; 115, 145; 117, 146; 117, 147; 120, 148; 122, 149; 122, 150; 125, 151; 129, 152; 129, 153; 130, 154; 130, 155; 133, 156; 133, 157; 134, 158; 134, 159; 136, 160; 137, 161; 137, 162; 137, 163; 138, 164; 138, 165; 139, 166; 140, 167; 152, 168; 152, 169; 154, 170; 154, 171; 157, 172; 157, 173; 159, 174; 159, 175; 161, 176; 161, 177; 162, 178; 163, 179; 164, 180; 166, 181; 167, 182; 174, 183; 174, 184; 175, 185; 175, 186; 175, 187; 175, 188; 176, 189; 176, 190; 177, 191; 177, 192; 178, 193; 179, 194; 181, 195; 181, 196; 182, 197; 185, 198; 185, 199; 186, 200; 186, 201; 187, 202; 187, 203; 188, 204; 192, 205; 193, 206; 193, 207; 193, 208; 194, 209; 195, 210; 195, 211; 196, 212; 197, 213; 197, 214; 199, 215; 199, 216; 208, 217; 208, 218; 212, 219; 212, 220; 213, 221; 213, 222; 214, 223; 215, 224; 215, 225; 217, 226; 217, 227; 218, 228; 218, 229; 218, 230; 218, 231; 220, 232; 220, 233; 223, 234; 223, 235; 228, 236; 228, 237; 229, 238; 229, 239; 230, 240; 230, 241; 231, 242; 232, 243; 232, 244; 235, 245; 235, 246; 237, 247; 237, 248; 245, 249; 245, 250; 247, 251; 247, 252 | def list(self, count=30, order='user_ptime', asc=False, show_dir=True,
natsort=True):
"""
List directory contents
:param int count: number of entries to be listed
:param str order: order of entries, originally named `o`. This value
may be one of `user_ptime` (default), `file_size` and `file_name`
:param bool asc: whether in ascending order
:param bool show_dir: whether to show directories
:param bool natsort: whether to use natural sort
Return a list of :class:`.File` or :class:`.Directory` objects
"""
if self.cid is None:
return False
self.reload()
kwargs = {}
# `cid` is the only required argument
kwargs['cid'] = self.cid
kwargs['asc'] = 1 if asc is True else 0
kwargs['show_dir'] = 1 if show_dir is True else 0
kwargs['natsort'] = 1 if natsort is True else 0
kwargs['o'] = order
# When the downloads directory exists along with its parent directory,
# the receiver directory, its parent's count (receiver directory's
# count) does not include the downloads directory. This behavior is
# similar to its parent's parent (root), the count of which does not
# include the receiver directory.
# The following code fixed this behavior so that a directory's
# count correctly reflects the actual number of entries in it
# The side-effect that this code may ensure that downloads directory
# exists, causing the system to create the receiver directory and
# downloads directory, if they do not exist.
if self.is_root or self == self.api.receiver_directory:
self._count += 1
if self.count <= count:
# count should never be greater than self.count
count = self.count
try:
entries = self._load_entries(func=self.api._req_files,
count=count, page=1, **kwargs)
# When natsort=1 and order='file_name', API access will fail
except RequestFailure as e:
if natsort is True and order == 'file_name':
entries = \
self._load_entries(func=self.api._req_aps_natsort_files,
count=count, page=1, **kwargs)
else:
raise e
res = []
for entry in entries:
if 'pid' in entry:
res.append(_instantiate_directory(self.api, entry))
else:
res.append(_instantiate_file(self.api, entry))
return res |
0, module; 1, function_definition; 2, function_name:list_items; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, return_statement; 12, identifier:sort_key; 13, None; 14, identifier:reverse; 15, False; 16, comment:"""Return a list of cart items.
Parameters
----------
sort_key : func
A function to customize the list order, same as the 'key'
argument to the built-in :func:`sorted`.
reverse: bool
If set to True, the sort order will be reversed.
Returns
-------
list
List of :attr:`item_class` instances.
Examples
--------
>>> cart = Cart(request)
>>> cart.list_items(lambda item: item.obj.name)
[<CartItem: obj=bar, quantity=3>,
<CartItem: obj=foo, quantity=1>,
<CartItem: obj=nox, quantity=5>]
>>> cart.list_items(lambda item: item.quantity, reverse=True)
[<CartItem: obj=nox, quantity=5>,
<CartItem: obj=bar, quantity=3>,
<CartItem: obj=foo, quantity=1>]
"""; 17, assignment; 18, identifier:sort_key; 19, block; 20, identifier:items; 21, identifier:items; 22, call; 23, expression_statement; 24, identifier:list; 25, argument_list; 26, call; 27, call; 28, attribute; 29, argument_list; 30, attribute; 31, argument_list; 32, identifier:items; 33, identifier:sort; 34, keyword_argument; 35, keyword_argument; 36, attribute; 37, identifier:values; 38, identifier:key; 39, identifier:sort_key; 40, identifier:reverse; 41, identifier:reverse; 42, identifier:self; 43, identifier:items | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 7, 15; 8, 16; 9, 17; 10, 18; 10, 19; 11, 20; 17, 21; 17, 22; 19, 23; 22, 24; 22, 25; 23, 26; 25, 27; 26, 28; 26, 29; 27, 30; 27, 31; 28, 32; 28, 33; 29, 34; 29, 35; 30, 36; 30, 37; 34, 38; 34, 39; 35, 40; 35, 41; 36, 42; 36, 43 | def list_items(self, sort_key=None, reverse=False):
"""Return a list of cart items.
Parameters
----------
sort_key : func
A function to customize the list order, same as the 'key'
argument to the built-in :func:`sorted`.
reverse: bool
If set to True, the sort order will be reversed.
Returns
-------
list
List of :attr:`item_class` instances.
Examples
--------
>>> cart = Cart(request)
>>> cart.list_items(lambda item: item.obj.name)
[<CartItem: obj=bar, quantity=3>,
<CartItem: obj=foo, quantity=1>,
<CartItem: obj=nox, quantity=5>]
>>> cart.list_items(lambda item: item.quantity, reverse=True)
[<CartItem: obj=nox, quantity=5>,
<CartItem: obj=bar, quantity=3>,
<CartItem: obj=foo, quantity=1>]
"""
items = list(self.items.values())
if sort_key:
items.sort(key=sort_key, reverse=reverse)
return items |
0, module; 1, function_definition; 2, function_name:_prepare_axes; 3, parameters; 4, block; 5, identifier:node; 6, identifier:sort_key; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, return_statement; 14, comment:"""
Sort axes and combine those that point to the same target and go
in the same direction.
"""; 15, assignment; 16, assignment; 17, assignment; 18, assignment; 19, identifier:axis; 20, call; 21, block; 22, identifier:axes; 23, identifier:links; 24, attribute; 25, identifier:o_links; 26, attribute; 27, identifier:overlap; 28, set_comprehension; 29, identifier:axes; 30, list; 31, identifier:sorted; 32, argument_list; 33, if_statement; 34, expression_statement; 35, if_statement; 36, expression_statement; 37, identifier:node; 38, identifier:links; 39, identifier:node; 40, identifier:_overlapping_links; 41, identifier:ax2; 42, for_in_clause; 43, for_in_clause; 44, call; 45, keyword_argument; 46, comparison_operator:axis in overlap; 47, block; 48, assignment; 49, comparison_operator:axis in o_links; 50, block; 51, call; 52, identifier:ax; 53, identifier:links; 54, identifier:ax2; 55, call; 56, attribute; 57, argument_list; 58, identifier:key; 59, identifier:sort_key; 60, identifier:axis; 61, identifier:overlap; 62, continue_statement; 63, identifier:tgt; 64, subscript; 65, identifier:axis; 66, identifier:o_links; 67, expression_statement; 68, expression_statement; 69, attribute; 70, argument_list; 71, attribute; 72, argument_list; 73, identifier:links; 74, identifier:keys; 75, identifier:links; 76, identifier:axis; 77, assignment; 78, assignment; 79, identifier:axes; 80, identifier:append; 81, tuple; 82, identifier:o_links; 83, identifier:get; 84, identifier:ax; 85, list; 86, pattern_list; 87, expression_list; 88, identifier:axis; 89, binary_operator:'%s%s%s' % (
s, '&'.join(a[1:-1] for a in [axis] + o_links[axis]), e
); 90, identifier:axis; 91, identifier:tgt; 92, identifier:s; 93, identifier:e; 94, subscript; 95, subscript; 96, string; 97, tuple; 98, identifier:axis; 99, integer:0; 100, identifier:axis; 101, unary_operator; 102, string_content:%s%s%s; 103, identifier:s; 104, call; 105, identifier:e; 106, integer:1; 107, attribute; 108, generator_expression; 109, string; 110, identifier:join; 111, subscript; 112, for_in_clause; 113, string_content:&; 114, identifier:a; 115, slice; 116, identifier:a; 117, binary_operator:[axis] + o_links[axis]; 118, integer:1; 119, unary_operator; 120, list; 121, subscript; 122, integer:1; 123, identifier:axis; 124, identifier:o_links; 125, identifier:axis | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 8, 15; 9, 16; 10, 17; 11, 18; 12, 19; 12, 20; 12, 21; 13, 22; 15, 23; 15, 24; 16, 25; 16, 26; 17, 27; 17, 28; 18, 29; 18, 30; 20, 31; 20, 32; 21, 33; 21, 34; 21, 35; 21, 36; 24, 37; 24, 38; 26, 39; 26, 40; 28, 41; 28, 42; 28, 43; 32, 44; 32, 45; 33, 46; 33, 47; 34, 48; 35, 49; 35, 50; 36, 51; 42, 52; 42, 53; 43, 54; 43, 55; 44, 56; 44, 57; 45, 58; 45, 59; 46, 60; 46, 61; 47, 62; 48, 63; 48, 64; 49, 65; 49, 66; 50, 67; 50, 68; 51, 69; 51, 70; 55, 71; 55, 72; 56, 73; 56, 74; 64, 75; 64, 76; 67, 77; 68, 78; 69, 79; 69, 80; 70, 81; 71, 82; 71, 83; 72, 84; 72, 85; 77, 86; 77, 87; 78, 88; 78, 89; 81, 90; 81, 91; 86, 92; 86, 93; 87, 94; 87, 95; 89, 96; 89, 97; 94, 98; 94, 99; 95, 100; 95, 101; 96, 102; 97, 103; 97, 104; 97, 105; 101, 106; 104, 107; 104, 108; 107, 109; 107, 110; 108, 111; 108, 112; 109, 113; 111, 114; 111, 115; 112, 116; 112, 117; 115, 118; 115, 119; 117, 120; 117, 121; 119, 122; 120, 123; 121, 124; 121, 125 | def _prepare_axes(node, sort_key):
"""
Sort axes and combine those that point to the same target and go
in the same direction.
"""
links = node.links
o_links = node._overlapping_links
overlap = {ax2 for ax in links for ax2 in o_links.get(ax, [])}
axes = []
for axis in sorted(links.keys(), key=sort_key):
if axis in overlap: continue
tgt = links[axis]
if axis in o_links:
s, e = axis[0], axis[-1]
axis = '%s%s%s' % (
s, '&'.join(a[1:-1] for a in [axis] + o_links[axis]), e
)
axes.append((axis, tgt))
return axes |
0, module; 1, function_definition; 2, function_name:sort_vid_split; 3, parameters; 4, block; 5, identifier:vs; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, comment:"""
Split a valid variable string into its variable sort and id.
Examples:
>>> sort_vid_split('h3')
('h', '3')
>>> sort_vid_split('ref-ind12')
('ref-ind', '12')
"""; 10, assignment; 11, comparison_operator:match is None; 12, block; 13, else_clause; 14, identifier:match; 15, call; 16, identifier:match; 17, None; 18, raise_statement; 19, block; 20, attribute; 21, argument_list; 22, call; 23, return_statement; 24, identifier:var_re; 25, identifier:match; 26, identifier:vs; 27, identifier:ValueError; 28, argument_list; 29, call; 30, call; 31, attribute; 32, argument_list; 33, attribute; 34, argument_list; 35, identifier:match; 36, identifier:groups; 37, string; 38, identifier:format; 39, call; 40, string_content:Invalid variable string: {}; 41, identifier:str; 42, argument_list; 43, identifier:vs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 8, 12; 8, 13; 10, 14; 10, 15; 11, 16; 11, 17; 12, 18; 13, 19; 15, 20; 15, 21; 18, 22; 19, 23; 20, 24; 20, 25; 21, 26; 22, 27; 22, 28; 23, 29; 28, 30; 29, 31; 29, 32; 30, 33; 30, 34; 31, 35; 31, 36; 33, 37; 33, 38; 34, 39; 37, 40; 39, 41; 39, 42; 42, 43 | def sort_vid_split(vs):
"""
Split a valid variable string into its variable sort and id.
Examples:
>>> sort_vid_split('h3')
('h', '3')
>>> sort_vid_split('ref-ind12')
('ref-ind', '12')
"""
match = var_re.match(vs)
if match is None:
raise ValueError('Invalid variable string: {}'.format(str(vs)))
else:
return match.groups() |
0, module; 1, function_definition; 2, function_name:properties; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, return_statement; 10, comment:"""
Morphosemantic property mapping.
Unlike :attr:`sortinfo`, this does not include `cvarsort`.
"""; 11, assignment; 12, comparison_operator:CVARSORT in d; 13, block; 14, identifier:d; 15, identifier:d; 16, call; 17, identifier:CVARSORT; 18, identifier:d; 19, delete_statement; 20, identifier:dict; 21, argument_list; 22, subscript; 23, attribute; 24, identifier:d; 25, identifier:CVARSORT; 26, identifier:self; 27, identifier:sortinfo | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 9, 14; 11, 15; 11, 16; 12, 17; 12, 18; 13, 19; 16, 20; 16, 21; 19, 22; 21, 23; 22, 24; 22, 25; 23, 26; 23, 27 | def properties(self):
"""
Morphosemantic property mapping.
Unlike :attr:`sortinfo`, this does not include `cvarsort`.
"""
d = dict(self.sortinfo)
if CVARSORT in d:
del d[CVARSORT]
return d |
0, module; 1, function_definition; 2, function_name:build_messages_modules; 3, parameters; 4, block; 5, identifier:messages; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, for_statement; 10, comment:"""Build and yield sorted list of messages per module.
:param list messages: List of dict of messages
:return: Tuple of 2 values: first is the module info, second is the list
of messages sorted by line number
"""; 11, assignment; 12, identifier:line; 13, identifier:messages; 14, block; 15, pattern_list; 16, call; 17, block; 18, identifier:data; 19, call; 20, expression_statement; 21, expression_statement; 22, expression_statement; 23, expression_statement; 24, identifier:module; 25, identifier:module_messages; 26, attribute; 27, argument_list; 28, expression_statement; 29, attribute; 30, argument_list; 31, assignment; 32, assignment; 33, assignment; 34, call; 35, identifier:data; 36, identifier:items; 37, yield; 38, identifier:collections; 39, identifier:defaultdict; 40, identifier:list; 41, identifier:module_name; 42, call; 43, identifier:module_path; 44, call; 45, identifier:module_info; 46, call; 47, attribute; 48, argument_list; 49, tuple; 50, attribute; 51, argument_list; 52, attribute; 53, argument_list; 54, identifier:ModuleInfo; 55, argument_list; 56, subscript; 57, identifier:append; 58, identifier:line; 59, identifier:module; 60, call; 61, identifier:line; 62, identifier:get; 63, string; 64, identifier:line; 65, identifier:get; 66, string; 67, identifier:module_name; 68, identifier:module_path; 69, identifier:data; 70, identifier:module_info; 71, identifier:sorted; 72, argument_list; 73, string_content:module; 74, string_content:path; 75, identifier:module_messages; 76, keyword_argument; 77, identifier:key; 78, lambda; 79, lambda_parameters; 80, call; 81, identifier:x; 82, attribute; 83, argument_list; 84, identifier:x; 85, identifier:get; 86, string; 87, string_content:line | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 8, 14; 9, 15; 9, 16; 9, 17; 11, 18; 11, 19; 14, 20; 14, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 16, 27; 17, 28; 19, 29; 19, 30; 20, 31; 21, 32; 22, 33; 23, 34; 26, 35; 26, 36; 28, 37; 29, 38; 29, 39; 30, 40; 31, 41; 31, 42; 32, 43; 32, 44; 33, 45; 33, 46; 34, 47; 34, 48; 37, 49; 42, 50; 42, 51; 44, 52; 44, 53; 46, 54; 46, 55; 47, 56; 47, 57; 48, 58; 49, 59; 49, 60; 50, 61; 50, 62; 51, 63; 52, 64; 52, 65; 53, 66; 55, 67; 55, 68; 56, 69; 56, 70; 60, 71; 60, 72; 63, 73; 66, 74; 72, 75; 72, 76; 76, 77; 76, 78; 78, 79; 78, 80; 79, 81; 80, 82; 80, 83; 82, 84; 82, 85; 83, 86; 86, 87 | def build_messages_modules(messages):
"""Build and yield sorted list of messages per module.
:param list messages: List of dict of messages
:return: Tuple of 2 values: first is the module info, second is the list
of messages sorted by line number
"""
data = collections.defaultdict(list)
for line in messages:
module_name = line.get('module')
module_path = line.get('path')
module_info = ModuleInfo(
module_name,
module_path,
)
data[module_info].append(line)
for module, module_messages in data.items():
yield (
module,
sorted(module_messages, key=lambda x: x.get('line'))) |
0, module; 1, function_definition; 2, function_name:write; 3, parameters; 4, block; 5, identifier:nml; 6, identifier:nml_path; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, comment:# Promote dicts to Namelists; 11, if_statement; 12, expression_statement; 13, identifier:force; 14, False; 15, identifier:sort; 16, False; 17, comment:"""Save a namelist to disk using either a file object or its file path.
File object usage:
>>> with open(nml_path, 'w') as nml_file:
>>> f90nml.write(nml, nml_file)
File path usage:
>>> f90nml.write(nml, 'data.nml')
This function is equivalent to the ``write`` function of the ``Namelist``
object ``nml``.
>>> nml.write('data.nml')
By default, ``write`` will not overwrite an existing file. To override
this, use the ``force`` flag.
>>> nml.write('data.nml', force=True)
To alphabetically sort the ``Namelist`` keys, use the ``sort`` flag.
>>> nml.write('data.nml', sort=True)
"""; 18, boolean_operator; 19, block; 20, else_clause; 21, call; 22, not_operator; 23, call; 24, expression_statement; 25, block; 26, attribute; 27, argument_list; 28, call; 29, identifier:isinstance; 30, argument_list; 31, assignment; 32, expression_statement; 33, identifier:nml_in; 34, identifier:write; 35, identifier:nml_path; 36, keyword_argument; 37, keyword_argument; 38, identifier:isinstance; 39, argument_list; 40, identifier:nml; 41, identifier:dict; 42, identifier:nml_in; 43, call; 44, assignment; 45, identifier:force; 46, identifier:force; 47, identifier:sort; 48, identifier:sort; 49, identifier:nml; 50, identifier:Namelist; 51, identifier:Namelist; 52, argument_list; 53, identifier:nml_in; 54, identifier:nml; 55, identifier:nml | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 7, 14; 8, 15; 8, 16; 9, 17; 11, 18; 11, 19; 11, 20; 12, 21; 18, 22; 18, 23; 19, 24; 20, 25; 21, 26; 21, 27; 22, 28; 23, 29; 23, 30; 24, 31; 25, 32; 26, 33; 26, 34; 27, 35; 27, 36; 27, 37; 28, 38; 28, 39; 30, 40; 30, 41; 31, 42; 31, 43; 32, 44; 36, 45; 36, 46; 37, 47; 37, 48; 39, 49; 39, 50; 43, 51; 43, 52; 44, 53; 44, 54; 52, 55 | def write(nml, nml_path, force=False, sort=False):
"""Save a namelist to disk using either a file object or its file path.
File object usage:
>>> with open(nml_path, 'w') as nml_file:
>>> f90nml.write(nml, nml_file)
File path usage:
>>> f90nml.write(nml, 'data.nml')
This function is equivalent to the ``write`` function of the ``Namelist``
object ``nml``.
>>> nml.write('data.nml')
By default, ``write`` will not overwrite an existing file. To override
this, use the ``force`` flag.
>>> nml.write('data.nml', force=True)
To alphabetically sort the ``Namelist`` keys, use the ``sort`` flag.
>>> nml.write('data.nml', sort=True)
"""
# Promote dicts to Namelists
if not isinstance(nml, Namelist) and isinstance(nml, dict):
nml_in = Namelist(nml)
else:
nml_in = nml
nml_in.write(nml_path, force=force, sort=sort) |
0, module; 1, function_definition; 2, function_name:date_key; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:month_string; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, comment:"""
Return a key suitable for sorting by month.
>>> k1 = ChannelPage.date_key('September, 2012')
>>> k2 = ChannelPage.date_key('August, 2013')
>>> k2 > k1
True
"""; 12, assignment; 13, assignment; 14, expression_list; 15, pattern_list; 16, call; 17, identifier:month_ord; 18, subscript; 19, identifier:year; 20, identifier:month_ord; 21, identifier:month; 22, identifier:year; 23, attribute; 24, argument_list; 25, attribute; 26, identifier:month; 27, identifier:month_string; 28, identifier:split; 29, string; 30, identifier:cls; 31, identifier:month_ordinal; 32, string_content:, | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 7, 11; 8, 12; 9, 13; 10, 14; 12, 15; 12, 16; 13, 17; 13, 18; 14, 19; 14, 20; 15, 21; 15, 22; 16, 23; 16, 24; 18, 25; 18, 26; 23, 27; 23, 28; 24, 29; 25, 30; 25, 31; 29, 32 | def date_key(cls, month_string):
"""
Return a key suitable for sorting by month.
>>> k1 = ChannelPage.date_key('September, 2012')
>>> k2 = ChannelPage.date_key('August, 2013')
>>> k2 > k1
True
"""
month, year = month_string.split(',')
month_ord = cls.month_ordinal[month]
return year, month_ord |
0, module; 1, function_definition; 2, function_name:SynchronizedClassMethod; 3, parameters; 4, comment:# pylint: disable=C1801; 5, block; 6, list_splat_pattern; 7, dictionary_splat_pattern; 8, expression_statement; 9, comment:# Filter the names (remove empty ones); 10, expression_statement; 11, if_statement; 12, if_statement; 13, function_definition; 14, comment:# Return the wrapped method; 15, return_statement; 16, identifier:locks_attr_names; 17, identifier:kwargs; 18, comment:"""
A synchronizer decorator for class methods. An AttributeError can be raised
at runtime if the given lock attribute doesn't exist or if it is None.
If a parameter ``sorted`` is found in ``kwargs`` and its value is True,
then the list of locks names will be sorted before locking.
:param locks_attr_names: A list of the lock(s) attribute(s) name(s) to be
used for synchronization
:return: The decorator method, surrounded with the lock
"""; 19, assignment; 20, not_operator; 21, block; 22, boolean_operator; 23, comment:# Sort the lock names if requested; 24, comment:# (locking always in the same order reduces the risk of dead lock); 25, block; 26, function_name:wrapped; 27, parameters; 28, block; 29, identifier:wrapped; 30, identifier:locks_attr_names; 31, list_comprehension; 32, identifier:locks_attr_names; 33, raise_statement; 34, comparison_operator:"sorted" not in kwargs; 35, subscript; 36, expression_statement; 37, expression_statement; 38, identifier:method; 39, expression_statement; 40, decorated_definition; 41, return_statement; 42, identifier:lock_name; 43, for_in_clause; 44, if_clause; 45, call; 46, string:"sorted"; 47, identifier:kwargs; 48, identifier:kwargs; 49, string:"sorted"; 50, assignment; 51, call; 52, comment:"""
The wrapping method
:param method: The wrapped method
:return: The wrapped method
:raise AttributeError: The given attribute name doesn't exist
"""; 53, decorator; 54, function_definition; 55, identifier:synchronized; 56, identifier:lock_name; 57, identifier:locks_attr_names; 58, identifier:lock_name; 59, identifier:ValueError; 60, argument_list; 61, identifier:locks_attr_names; 62, call; 63, attribute; 64, argument_list; 65, call; 66, function_name:synchronized; 67, parameters; 68, block; 69, string:"The lock names list can't be empty"; 70, identifier:list; 71, argument_list; 72, identifier:locks_attr_names; 73, identifier:sort; 74, attribute; 75, argument_list; 76, identifier:self; 77, list_splat_pattern; 78, dictionary_splat_pattern; 79, expression_statement; 80, comment:# Raises an AttributeError if needed; 81, expression_statement; 82, expression_statement; 83, expression_statement; 84, try_statement; 85, identifier:locks_attr_names; 86, identifier:functools; 87, identifier:wraps; 88, identifier:method; 89, identifier:args; 90, identifier:kwargs; 91, comment:"""
Calls the wrapped method with a lock
"""; 92, assignment; 93, assignment; 94, assignment; 95, comment:# Lock; 96, block; 97, finally_clause; 98, identifier:locks; 99, list_comprehension; 100, identifier:locked; 101, call; 102, identifier:i; 103, integer:0; 104, for_statement; 105, comment:# Use the method; 106, return_statement; 107, comment:# Unlock what has been locked in all cases; 108, block; 109, call; 110, for_in_clause; 111, attribute; 112, argument_list; 113, identifier:lock; 114, identifier:locks; 115, block; 116, call; 117, for_statement; 118, expression_statement; 119, delete_statement; 120, identifier:getattr; 121, argument_list; 122, identifier:attr_name; 123, identifier:locks_attr_names; 124, identifier:collections; 125, identifier:deque; 126, if_statement; 127, comment:# Get the lock; 128, expression_statement; 129, expression_statement; 130, expression_statement; 131, identifier:method; 132, argument_list; 133, identifier:lock; 134, identifier:locked; 135, block; 136, call; 137, subscript; 138, identifier:self; 139, identifier:attr_name; 140, comparison_operator:lock is None; 141, comment:# No lock...; 142, block; 143, augmented_assignment; 144, call; 145, call; 146, identifier:self; 147, list_splat; 148, dictionary_splat; 149, expression_statement; 150, attribute; 151, argument_list; 152, identifier:locks; 153, slice; 154, identifier:lock; 155, None; 156, raise_statement; 157, identifier:i; 158, integer:1; 159, attribute; 160, argument_list; 161, attribute; 162, argument_list; 163, identifier:args; 164, identifier:kwargs; 165, call; 166, identifier:locked; 167, identifier:clear; 168, call; 169, identifier:lock; 170, identifier:acquire; 171, identifier:locked; 172, identifier:appendleft; 173, identifier:lock; 174, attribute; 175, argument_list; 176, identifier:AttributeError; 177, argument_list; 178, identifier:lock; 179, identifier:release; 180, call; 181, attribute; 182, argument_list; 183, string:"Lock '{0}' can't be None in class {1}"; 184, identifier:format; 185, subscript; 186, attribute; 187, identifier:locks_attr_names; 188, identifier:i; 189, call; 190, identifier:__name__; 191, identifier:type; 192, argument_list; 193, identifier:self | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 5, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 14; 5, 15; 6, 16; 7, 17; 8, 18; 10, 19; 11, 20; 11, 21; 12, 22; 12, 23; 12, 24; 12, 25; 13, 26; 13, 27; 13, 28; 15, 29; 19, 30; 19, 31; 20, 32; 21, 33; 22, 34; 22, 35; 25, 36; 25, 37; 27, 38; 28, 39; 28, 40; 28, 41; 31, 42; 31, 43; 31, 44; 33, 45; 34, 46; 34, 47; 35, 48; 35, 49; 36, 50; 37, 51; 39, 52; 40, 53; 40, 54; 41, 55; 43, 56; 43, 57; 44, 58; 45, 59; 45, 60; 50, 61; 50, 62; 51, 63; 51, 64; 53, 65; 54, 66; 54, 67; 54, 68; 60, 69; 62, 70; 62, 71; 63, 72; 63, 73; 65, 74; 65, 75; 67, 76; 67, 77; 67, 78; 68, 79; 68, 80; 68, 81; 68, 82; 68, 83; 68, 84; 71, 85; 74, 86; 74, 87; 75, 88; 77, 89; 78, 90; 79, 91; 81, 92; 82, 93; 83, 94; 84, 95; 84, 96; 84, 97; 92, 98; 92, 99; 93, 100; 93, 101; 94, 102; 94, 103; 96, 104; 96, 105; 96, 106; 97, 107; 97, 108; 99, 109; 99, 110; 101, 111; 101, 112; 104, 113; 104, 114; 104, 115; 106, 116; 108, 117; 108, 118; 108, 119; 109, 120; 109, 121; 110, 122; 110, 123; 111, 124; 111, 125; 115, 126; 115, 127; 115, 128; 115, 129; 115, 130; 116, 131; 116, 132; 117, 133; 117, 134; 117, 135; 118, 136; 119, 137; 121, 138; 121, 139; 126, 140; 126, 141; 126, 142; 128, 143; 129, 144; 130, 145; 132, 146; 132, 147; 132, 148; 135, 149; 136, 150; 136, 151; 137, 152; 137, 153; 140, 154; 140, 155; 142, 156; 143, 157; 143, 158; 144, 159; 144, 160; 145, 161; 145, 162; 147, 163; 148, 164; 149, 165; 150, 166; 150, 167; 156, 168; 159, 169; 159, 170; 161, 171; 161, 172; 162, 173; 165, 174; 165, 175; 168, 176; 168, 177; 174, 178; 174, 179; 177, 180; 180, 181; 180, 182; 181, 183; 181, 184; 182, 185; 182, 186; 185, 187; 185, 188; 186, 189; 186, 190; 189, 191; 189, 192; 192, 193 | def SynchronizedClassMethod(*locks_attr_names, **kwargs):
# pylint: disable=C1801
"""
A synchronizer decorator for class methods. An AttributeError can be raised
at runtime if the given lock attribute doesn't exist or if it is None.
If a parameter ``sorted`` is found in ``kwargs`` and its value is True,
then the list of locks names will be sorted before locking.
:param locks_attr_names: A list of the lock(s) attribute(s) name(s) to be
used for synchronization
:return: The decorator method, surrounded with the lock
"""
# Filter the names (remove empty ones)
locks_attr_names = [
lock_name for lock_name in locks_attr_names if lock_name
]
if not locks_attr_names:
raise ValueError("The lock names list can't be empty")
if "sorted" not in kwargs or kwargs["sorted"]:
# Sort the lock names if requested
# (locking always in the same order reduces the risk of dead lock)
locks_attr_names = list(locks_attr_names)
locks_attr_names.sort()
def wrapped(method):
"""
The wrapping method
:param method: The wrapped method
:return: The wrapped method
:raise AttributeError: The given attribute name doesn't exist
"""
@functools.wraps(method)
def synchronized(self, *args, **kwargs):
"""
Calls the wrapped method with a lock
"""
# Raises an AttributeError if needed
locks = [getattr(self, attr_name) for attr_name in locks_attr_names]
locked = collections.deque()
i = 0
try:
# Lock
for lock in locks:
if lock is None:
# No lock...
raise AttributeError(
"Lock '{0}' can't be None in class {1}".format(
locks_attr_names[i], type(self).__name__
)
)
# Get the lock
i += 1
lock.acquire()
locked.appendleft(lock)
# Use the method
return method(self, *args, **kwargs)
finally:
# Unlock what has been locked in all cases
for lock in locked:
lock.release()
locked.clear()
del locks[:]
return synchronized
# Return the wrapped method
return wrapped |
0, module; 1, function_definition; 2, function_name:__sort_registry; 3, parameters; 4, comment:# type: (ServiceReference) -> None; 5, block; 6, identifier:self; 7, identifier:svc_ref; 8, expression_statement; 9, with_statement; 10, comment:"""
Sorts the registry, after the update of the sort key of given service
reference
:param svc_ref: A service reference with a modified sort key
"""; 11, with_clause; 12, block; 13, with_item; 14, if_statement; 15, comment:# Remove current references; 16, for_statement; 17, comment:# ... use the new sort key; 18, expression_statement; 19, for_statement; 20, attribute; 21, comparison_operator:svc_ref not in self.__svc_registry; 22, block; 23, identifier:spec; 24, call; 25, comment:# Use bisect to remove the reference (faster); 26, block; 27, call; 28, identifier:spec; 29, call; 30, comment:# ... and insert it again; 31, block; 32, identifier:self; 33, identifier:__svc_lock; 34, identifier:svc_ref; 35, attribute; 36, raise_statement; 37, attribute; 38, argument_list; 39, expression_statement; 40, expression_statement; 41, delete_statement; 42, attribute; 43, argument_list; 44, attribute; 45, argument_list; 46, expression_statement; 47, expression_statement; 48, identifier:self; 49, identifier:__svc_registry; 50, call; 51, identifier:svc_ref; 52, identifier:get_property; 53, identifier:OBJECTCLASS; 54, assignment; 55, assignment; 56, subscript; 57, identifier:svc_ref; 58, identifier:update_sort_key; 59, identifier:svc_ref; 60, identifier:get_property; 61, identifier:OBJECTCLASS; 62, assignment; 63, call; 64, identifier:BundleException; 65, argument_list; 66, identifier:spec_refs; 67, subscript; 68, identifier:idx; 69, call; 70, identifier:spec_refs; 71, identifier:idx; 72, identifier:spec_refs; 73, subscript; 74, attribute; 75, argument_list; 76, call; 77, attribute; 78, identifier:spec; 79, attribute; 80, argument_list; 81, attribute; 82, identifier:spec; 83, identifier:bisect; 84, identifier:insort_left; 85, identifier:spec_refs; 86, identifier:svc_ref; 87, attribute; 88, argument_list; 89, identifier:self; 90, identifier:__svc_specs; 91, identifier:bisect; 92, identifier:bisect_left; 93, identifier:spec_refs; 94, identifier:svc_ref; 95, identifier:self; 96, identifier:__svc_specs; 97, string:"Unknown service: {0}"; 98, identifier:format; 99, identifier:svc_ref | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 5, 8; 5, 9; 8, 10; 9, 11; 9, 12; 11, 13; 12, 14; 12, 15; 12, 16; 12, 17; 12, 18; 12, 19; 13, 20; 14, 21; 14, 22; 16, 23; 16, 24; 16, 25; 16, 26; 18, 27; 19, 28; 19, 29; 19, 30; 19, 31; 20, 32; 20, 33; 21, 34; 21, 35; 22, 36; 24, 37; 24, 38; 26, 39; 26, 40; 26, 41; 27, 42; 27, 43; 29, 44; 29, 45; 31, 46; 31, 47; 35, 48; 35, 49; 36, 50; 37, 51; 37, 52; 38, 53; 39, 54; 40, 55; 41, 56; 42, 57; 42, 58; 44, 59; 44, 60; 45, 61; 46, 62; 47, 63; 50, 64; 50, 65; 54, 66; 54, 67; 55, 68; 55, 69; 56, 70; 56, 71; 62, 72; 62, 73; 63, 74; 63, 75; 65, 76; 67, 77; 67, 78; 69, 79; 69, 80; 73, 81; 73, 82; 74, 83; 74, 84; 75, 85; 75, 86; 76, 87; 76, 88; 77, 89; 77, 90; 79, 91; 79, 92; 80, 93; 80, 94; 81, 95; 81, 96; 87, 97; 87, 98; 88, 99 | def __sort_registry(self, svc_ref):
# type: (ServiceReference) -> None
"""
Sorts the registry, after the update of the sort key of given service
reference
:param svc_ref: A service reference with a modified sort key
"""
with self.__svc_lock:
if svc_ref not in self.__svc_registry:
raise BundleException("Unknown service: {0}".format(svc_ref))
# Remove current references
for spec in svc_ref.get_property(OBJECTCLASS):
# Use bisect to remove the reference (faster)
spec_refs = self.__svc_specs[spec]
idx = bisect.bisect_left(spec_refs, svc_ref)
del spec_refs[idx]
# ... use the new sort key
svc_ref.update_sort_key()
for spec in svc_ref.get_property(OBJECTCLASS):
# ... and insert it again
spec_refs = self.__svc_specs[spec]
bisect.insort_left(spec_refs, svc_ref) |
0, module; 1, function_definition; 2, function_name:sorted_timezones; 3, parameters; 4, block; 5, expression_statement; 6, function_definition; 7, expression_statement; 8, comment:# Make a list of country code mappings; 9, expression_statement; 10, for_statement; 11, comment:# Make a list of timezones, discarding the US/* and Canada/* zones since they aren't reliable for; 12, comment:# DST, and discarding UTC and GMT since timezones in that zone have their own names; 13, expression_statement; 14, comment:# Sort timezones by offset from UTC and their human-readable name; 15, expression_statement; 16, expression_statement; 17, comment:# Return a list of (timezone, label) with the timezone offset included in the label.; 18, return_statement; 19, comment:"""
Return a list of timezones sorted by offset from UTC.
"""; 20, function_name:hourmin; 21, parameters; 22, block; 23, assignment; 24, assignment; 25, identifier:countrycode; 26, attribute; 27, block; 28, assignment; 29, assignment; 30, call; 31, list_comprehension; 32, identifier:delta; 33, if_statement; 34, expression_statement; 35, return_statement; 36, identifier:now; 37, call; 38, identifier:timezone_country; 39, dictionary; 40, identifier:pytz; 41, identifier:country_timezones; 42, for_statement; 43, identifier:timezones; 44, list_comprehension; 45, identifier:presorted; 46, list_comprehension; 47, attribute; 48, argument_list; 49, tuple; 50, for_in_clause; 51, comparison_operator:delta.days < 0; 52, block; 53, else_clause; 54, assignment; 55, expression_list; 56, attribute; 57, argument_list; 58, identifier:timezone; 59, subscript; 60, block; 61, tuple; 62, for_in_clause; 63, if_clause; 64, tuple; 65, for_in_clause; 66, identifier:presorted; 67, identifier:sort; 68, identifier:name; 69, identifier:label; 70, tuple_pattern; 71, identifier:presorted; 72, attribute; 73, integer:0; 74, expression_statement; 75, block; 76, pattern_list; 77, call; 78, identifier:hours; 79, identifier:minutes; 80, identifier:datetime; 81, identifier:utcnow; 82, attribute; 83, identifier:countrycode; 84, expression_statement; 85, call; 86, identifier:tzname; 87, identifier:tzname; 88, attribute; 89, boolean_operator; 90, identifier:delta; 91, binary_operator:'%s%s - %s%s (%s)' % (
(delta.days < 0 and '-') or (delta.days == 0 and delta.seconds == 0 and ' ') or '+',
'%02d:%02d' % hourmin(delta),
(pytz.country_names[timezone_country[name]] + ': ') if name in timezone_country else '',
name.replace('_', ' '),
pytz.timezone(name).tzname(now, is_dst=False)); 92, identifier:name; 93, pattern_list; 94, identifier:timezones; 95, identifier:delta; 96, identifier:label; 97, identifier:name; 98, identifier:delta; 99, identifier:days; 100, assignment; 101, expression_statement; 102, identifier:minutes; 103, identifier:remaining; 104, identifier:divmod; 105, argument_list; 106, identifier:pytz; 107, identifier:country_timezones; 108, assignment; 109, attribute; 110, argument_list; 111, identifier:pytz; 112, identifier:common_timezones; 113, boolean_operator; 114, comparison_operator:tzname not in ('GMT', 'UTC'); 115, string; 116, tuple; 117, identifier:delta; 118, identifier:name; 119, pattern_list; 120, call; 121, assignment; 122, identifier:remaining; 123, integer:60; 124, subscript; 125, identifier:countrycode; 126, call; 127, identifier:utcoffset; 128, identifier:now; 129, keyword_argument; 130, not_operator; 131, not_operator; 132, identifier:tzname; 133, tuple; 134, string_content:%s%s - %s%s (%s); 135, boolean_operator; 136, binary_operator:'%02d:%02d' % hourmin(delta); 137, conditional_expression:(pytz.country_names[timezone_country[name]] + ': ') if name in timezone_country else ''; 138, call; 139, call; 140, identifier:hours; 141, identifier:remaining; 142, identifier:divmod; 143, argument_list; 144, pattern_list; 145, call; 146, identifier:timezone_country; 147, identifier:timezone; 148, attribute; 149, argument_list; 150, identifier:is_dst; 151, False; 152, call; 153, call; 154, string; 155, string; 156, boolean_operator; 157, string; 158, string; 159, call; 160, parenthesized_expression; 161, comparison_operator:name in timezone_country; 162, string; 163, attribute; 164, argument_list; 165, attribute; 166, argument_list; 167, binary_operator:86400 - delta.seconds; 168, integer:3600; 169, identifier:hours; 170, identifier:remaining; 171, identifier:divmod; 172, argument_list; 173, identifier:pytz; 174, identifier:timezone; 175, identifier:tzname; 176, attribute; 177, argument_list; 178, attribute; 179, argument_list; 180, string_content:GMT; 181, string_content:UTC; 182, parenthesized_expression; 183, parenthesized_expression; 184, string_content:+; 185, string_content:%02d:%02d; 186, identifier:hourmin; 187, argument_list; 188, binary_operator:pytz.country_names[timezone_country[name]] + ': '; 189, identifier:name; 190, identifier:timezone_country; 191, identifier:name; 192, identifier:replace; 193, string; 194, string; 195, call; 196, identifier:tzname; 197, identifier:now; 198, keyword_argument; 199, integer:86400; 200, attribute; 201, attribute; 202, integer:3600; 203, identifier:tzname; 204, identifier:startswith; 205, string; 206, identifier:tzname; 207, identifier:startswith; 208, string; 209, boolean_operator; 210, boolean_operator; 211, identifier:delta; 212, subscript; 213, string; 214, string_content:_; 215, string_content:; 216, attribute; 217, argument_list; 218, identifier:is_dst; 219, False; 220, identifier:delta; 221, identifier:seconds; 222, identifier:delta; 223, identifier:seconds; 224, string_content:US/; 225, string_content:Canada/; 226, comparison_operator:delta.days < 0; 227, string; 228, boolean_operator; 229, string; 230, attribute; 231, subscript; 232, string_content::; 233, identifier:pytz; 234, identifier:timezone; 235, identifier:name; 236, attribute; 237, integer:0; 238, string_content:-; 239, comparison_operator:delta.days == 0; 240, comparison_operator:delta.seconds == 0; 241, string_content:; 242, identifier:pytz; 243, identifier:country_names; 244, identifier:timezone_country; 245, identifier:name; 246, identifier:delta; 247, identifier:days; 248, attribute; 249, integer:0; 250, attribute; 251, integer:0; 252, identifier:delta; 253, identifier:days; 254, identifier:delta; 255, identifier:seconds | 0, 1; 1, 2; 1, 3; 1, 4; 4, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 5, 19; 6, 20; 6, 21; 6, 22; 7, 23; 9, 24; 10, 25; 10, 26; 10, 27; 13, 28; 15, 29; 16, 30; 18, 31; 21, 32; 22, 33; 22, 34; 22, 35; 23, 36; 23, 37; 24, 38; 24, 39; 26, 40; 26, 41; 27, 42; 28, 43; 28, 44; 29, 45; 29, 46; 30, 47; 30, 48; 31, 49; 31, 50; 33, 51; 33, 52; 33, 53; 34, 54; 35, 55; 37, 56; 37, 57; 42, 58; 42, 59; 42, 60; 44, 61; 44, 62; 44, 63; 46, 64; 46, 65; 47, 66; 47, 67; 49, 68; 49, 69; 50, 70; 50, 71; 51, 72; 51, 73; 52, 74; 53, 75; 54, 76; 54, 77; 55, 78; 55, 79; 56, 80; 56, 81; 59, 82; 59, 83; 60, 84; 61, 85; 61, 86; 62, 87; 62, 88; 63, 89; 64, 90; 64, 91; 64, 92; 65, 93; 65, 94; 70, 95; 70, 96; 70, 97; 72, 98; 72, 99; 74, 100; 75, 101; 76, 102; 76, 103; 77, 104; 77, 105; 82, 106; 82, 107; 84, 108; 85, 109; 85, 110; 88, 111; 88, 112; 89, 113; 89, 114; 91, 115; 91, 116; 93, 117; 93, 118; 100, 119; 100, 120; 101, 121; 105, 122; 105, 123; 108, 124; 108, 125; 109, 126; 109, 127; 110, 128; 110, 129; 113, 130; 113, 131; 114, 132; 114, 133; 115, 134; 116, 135; 116, 136; 116, 137; 116, 138; 116, 139; 119, 140; 119, 141; 120, 142; 120, 143; 121, 144; 121, 145; 124, 146; 124, 147; 126, 148; 126, 149; 129, 150; 129, 151; 130, 152; 131, 153; 133, 154; 133, 155; 135, 156; 135, 157; 136, 158; 136, 159; 137, 160; 137, 161; 137, 162; 138, 163; 138, 164; 139, 165; 139, 166; 143, 167; 143, 168; 144, 169; 144, 170; 145, 171; 145, 172; 148, 173; 148, 174; 149, 175; 152, 176; 152, 177; 153, 178; 153, 179; 154, 180; 155, 181; 156, 182; 156, 183; 157, 184; 158, 185; 159, 186; 159, 187; 160, 188; 161, 189; 161, 190; 163, 191; 163, 192; 164, 193; 164, 194; 165, 195; 165, 196; 166, 197; 166, 198; 167, 199; 167, 200; 172, 201; 172, 202; 176, 203; 176, 204; 177, 205; 178, 206; 178, 207; 179, 208; 182, 209; 183, 210; 187, 211; 188, 212; 188, 213; 193, 214; 194, 215; 195, 216; 195, 217; 198, 218; 198, 219; 200, 220; 200, 221; 201, 222; 201, 223; 205, 224; 208, 225; 209, 226; 209, 227; 210, 228; 210, 229; 212, 230; 212, 231; 213, 232; 216, 233; 216, 234; 217, 235; 226, 236; 226, 237; 227, 238; 228, 239; 228, 240; 229, 241; 230, 242; 230, 243; 231, 244; 231, 245; 236, 246; 236, 247; 239, 248; 239, 249; 240, 250; 240, 251; 248, 252; 248, 253; 250, 254; 250, 255 | def sorted_timezones():
"""
Return a list of timezones sorted by offset from UTC.
"""
def hourmin(delta):
if delta.days < 0:
hours, remaining = divmod(86400 - delta.seconds, 3600)
else:
hours, remaining = divmod(delta.seconds, 3600)
minutes, remaining = divmod(remaining, 60)
return hours, minutes
now = datetime.utcnow()
# Make a list of country code mappings
timezone_country = {}
for countrycode in pytz.country_timezones:
for timezone in pytz.country_timezones[countrycode]:
timezone_country[timezone] = countrycode
# Make a list of timezones, discarding the US/* and Canada/* zones since they aren't reliable for
# DST, and discarding UTC and GMT since timezones in that zone have their own names
timezones = [(pytz.timezone(tzname).utcoffset(now, is_dst=False), tzname) for tzname in pytz.common_timezones
if not tzname.startswith('US/') and not tzname.startswith('Canada/') and tzname not in ('GMT', 'UTC')]
# Sort timezones by offset from UTC and their human-readable name
presorted = [(delta, '%s%s - %s%s (%s)' % (
(delta.days < 0 and '-') or (delta.days == 0 and delta.seconds == 0 and ' ') or '+',
'%02d:%02d' % hourmin(delta),
(pytz.country_names[timezone_country[name]] + ': ') if name in timezone_country else '',
name.replace('_', ' '),
pytz.timezone(name).tzname(now, is_dst=False)), name) for delta, name in timezones]
presorted.sort()
# Return a list of (timezone, label) with the timezone offset included in the label.
return [(name, label) for (delta, label, name) in presorted] |
0, module; 1, function_definition; 2, function_name:alphanum_order; 3, parameters; 4, block; 5, identifier:triples; 6, expression_statement; 7, return_statement; 8, comment:"""
Sort a list of triples by relation name.
Embedded integers are sorted numerically, but otherwise the sorting
is alphabetic.
"""; 9, call; 10, identifier:sorted; 11, argument_list; 12, identifier:triples; 13, keyword_argument; 14, identifier:key; 15, lambda; 16, lambda_parameters; 17, list_comprehension; 18, identifier:t; 19, conditional_expression:int(t) if t.isdigit() else t; 20, for_in_clause; 21, call; 22, call; 23, identifier:t; 24, identifier:t; 25, call; 26, identifier:int; 27, argument_list; 28, attribute; 29, argument_list; 30, attribute; 31, argument_list; 32, identifier:t; 33, identifier:t; 34, identifier:isdigit; 35, identifier:re; 36, identifier:split; 37, string; 38, boolean_operator; 39, string_content:([0-9]+); 40, attribute; 41, string; 42, identifier:t; 43, identifier:relation | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 9, 10; 9, 11; 11, 12; 11, 13; 13, 14; 13, 15; 15, 16; 15, 17; 16, 18; 17, 19; 17, 20; 19, 21; 19, 22; 19, 23; 20, 24; 20, 25; 21, 26; 21, 27; 22, 28; 22, 29; 25, 30; 25, 31; 27, 32; 28, 33; 28, 34; 30, 35; 30, 36; 31, 37; 31, 38; 37, 39; 38, 40; 38, 41; 40, 42; 40, 43 | def alphanum_order(triples):
"""
Sort a list of triples by relation name.
Embedded integers are sorted numerically, but otherwise the sorting
is alphabetic.
"""
return sorted(
triples,
key=lambda t: [
int(t) if t.isdigit() else t
for t in re.split(r'([0-9]+)', t.relation or '')
]
) |
0, module; 1, function_definition; 2, function_name:_encode_penman; 3, parameters; 4, block; 5, identifier:self; 6, identifier:g; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, comment:# (preferred, dispreferred); 14, for_statement; 15, expression_statement; 16, expression_statement; 17, function_definition; 18, function_definition; 19, expression_statement; 20, while_statement; 21, return_statement; 22, identifier:top; 23, None; 24, comment:"""
Walk graph g and find a spanning dag, then serialize the result.
First, depth-first traversal of preferred orientations (whether
true or inverted) to create graph p.
If any triples remain, select the first remaining triple whose
source in the dispreferred orientation exists in p, where
'first' is determined by the order of inserted nodes (i.e. a
topological sort). Add this triple, then repeat the depth-first
traversal of preferred orientations from its target. Repeat
until no triples remain, or raise an error if there are no
candidates in the dispreferred orientation (which likely means
the graph is disconnected).
"""; 25, comparison_operator:top is None; 26, block; 27, assignment; 28, assignment; 29, assignment; 30, identifier:t; 31, call; 32, block; 33, assignment; 34, assignment; 35, function_name:_update; 36, parameters; 37, block; 38, function_name:_explore_preferred; 39, parameters; 40, block; 41, call; 42, identifier:remaining; 43, block; 44, call; 45, identifier:top; 46, None; 47, expression_statement; 48, identifier:remaining; 49, call; 50, identifier:variables; 51, call; 52, identifier:store; 53, call; 54, attribute; 55, argument_list; 56, if_statement; 57, identifier:p; 58, call; 59, identifier:topolist; 60, list; 61, identifier:t; 62, expression_statement; 63, expression_statement; 64, expression_statement; 65, if_statement; 66, return_statement; 67, identifier:src; 68, expression_statement; 69, for_statement; 70, expression_statement; 71, comment:# clear explored list; 72, identifier:_explore_preferred; 73, argument_list; 74, expression_statement; 75, for_statement; 76, if_statement; 77, expression_statement; 78, expression_statement; 79, if_statement; 80, attribute; 81, argument_list; 82, assignment; 83, identifier:set; 84, argument_list; 85, attribute; 86, argument_list; 87, identifier:defaultdict; 88, argument_list; 89, identifier:g; 90, identifier:triples; 91, attribute; 92, block; 93, else_clause; 94, identifier:defaultdict; 95, argument_list; 96, identifier:top; 97, assignment; 98, call; 99, call; 100, boolean_operator; 101, block; 102, None; 103, assignment; 104, identifier:t; 105, identifier:ts; 106, block; 107, assignment; 108, identifier:top; 109, assignment; 110, identifier:fc; 111, identifier:flip_candidates; 112, block; 113, not_operator; 114, block; 115, assignment; 116, assignment; 117, comparison_operator:tgt is not None; 118, block; 119, identifier:self; 120, identifier:_layout; 121, identifier:p; 122, identifier:top; 123, integer:0; 124, call; 125, identifier:top; 126, attribute; 127, call; 128, identifier:g; 129, identifier:variables; 130, lambda; 131, identifier:t; 132, identifier:inverted; 133, expression_statement; 134, expression_statement; 135, block; 136, identifier:list; 137, pattern_list; 138, conditional_expression:(t[2], t[0]) if t.inverted else (t[0], t[2]); 139, attribute; 140, argument_list; 141, attribute; 142, argument_list; 143, comparison_operator:tgt in variables; 144, comparison_operator:t.relation != self.TYPE_REL; 145, expression_statement; 146, return_statement; 147, identifier:ts; 148, subscript; 149, if_statement; 150, subscript; 151, list; 152, identifier:flip_candidates; 153, list_comprehension; 154, expression_statement; 155, comment:# clear superfluous; 156, call; 157, raise_statement; 158, identifier:c; 159, call; 160, identifier:tgt; 161, call; 162, identifier:tgt; 163, None; 164, expression_statement; 165, identifier:set; 166, argument_list; 167, identifier:g; 168, identifier:top; 169, attribute; 170, argument_list; 171, tuple; 172, call; 173, call; 174, expression_statement; 175, expression_statement; 176, identifier:src; 177, identifier:tgt; 178, tuple; 179, attribute; 180, tuple; 181, subscript; 182, identifier:append; 183, identifier:t; 184, identifier:remaining; 185, identifier:remove; 186, identifier:t; 187, identifier:tgt; 188, identifier:variables; 189, attribute; 190, attribute; 191, call; 192, identifier:tgt; 193, call; 194, integer:0; 195, comparison_operator:t in remaining; 196, block; 197, identifier:ts; 198, slice; 199, subscript; 200, for_in_clause; 201, assignment; 202, identifier:any; 203, generator_expression; 204, call; 205, identifier:next; 206, generator_expression; 207, identifier:_update; 208, argument_list; 209, call; 210, identifier:g; 211, identifier:triples; 212, list; 213, list; 214, attribute; 215, argument_list; 216, attribute; 217, argument_list; 218, call; 219, call; 220, subscript; 221, subscript; 222, identifier:t; 223, identifier:inverted; 224, subscript; 225, subscript; 226, identifier:p; 227, identifier:src; 228, identifier:t; 229, identifier:relation; 230, identifier:self; 231, identifier:TYPE_REL; 232, attribute; 233, argument_list; 234, attribute; 235, argument_list; 236, identifier:t; 237, identifier:remaining; 238, expression_statement; 239, if_statement; 240, call; 241, integer:1; 242, identifier:v; 243, identifier:topolist; 244, subscript; 245, list_comprehension; 246, comparison_operator:len(fc) > 0; 247, for_in_clause; 248, identifier:EncodeError; 249, argument_list; 250, identifier:c; 251, for_in_clause; 252, for_in_clause; 253, identifier:c; 254, identifier:_explore_preferred; 255, argument_list; 256, subscript; 257, identifier:append; 258, identifier:t; 259, subscript; 260, identifier:append; 261, call; 262, attribute; 263, argument_list; 264, attribute; 265, argument_list; 266, identifier:t; 267, integer:2; 268, identifier:t; 269, integer:0; 270, identifier:t; 271, integer:0; 272, identifier:t; 273, integer:2; 274, identifier:topolist; 275, identifier:append; 276, identifier:tgt; 277, identifier:store; 278, identifier:get; 279, identifier:src; 280, tuple; 281, assignment; 282, comparison_operator:tgt is not None; 283, block; 284, attribute; 285, argument_list; 286, identifier:fc; 287, slice; 288, identifier:c; 289, for_in_clause; 290, if_clause; 291, call; 292, integer:0; 293, identifier:fc; 294, identifier:flip_candidates; 295, string; 296, identifier:fc; 297, identifier:flip_candidates; 298, identifier:c; 299, identifier:fc; 300, identifier:tgt; 301, subscript; 302, integer:0; 303, subscript; 304, integer:1; 305, identifier:Triple; 306, argument_list; 307, subscript; 308, identifier:append; 309, identifier:t; 310, subscript; 311, identifier:append; 312, call; 313, list; 314, list; 315, identifier:tgt; 316, call; 317, identifier:tgt; 318, None; 319, expression_statement; 320, identifier:store; 321, identifier:get; 322, identifier:v; 323, tuple; 324, identifier:c; 325, identifier:fc; 326, comparison_operator:c in remaining; 327, identifier:len; 328, argument_list; 329, string_content:Invalid graph; possibly disconnected.; 330, identifier:store; 331, attribute; 332, identifier:store; 333, attribute; 334, list_splat; 335, keyword_argument; 336, subscript; 337, integer:0; 338, subscript; 339, integer:1; 340, identifier:Triple; 341, argument_list; 342, identifier:_update; 343, argument_list; 344, call; 345, list; 346, list; 347, identifier:c; 348, identifier:remaining; 349, identifier:fc; 350, identifier:t; 351, identifier:target; 352, identifier:t; 353, identifier:source; 354, identifier:t; 355, identifier:inverted; 356, False; 357, identifier:store; 358, attribute; 359, identifier:store; 360, attribute; 361, list_splat; 362, keyword_argument; 363, identifier:t; 364, identifier:_explore_preferred; 365, argument_list; 366, identifier:t; 367, identifier:source; 368, identifier:t; 369, identifier:target; 370, identifier:t; 371, identifier:inverted; 372, True; 373, identifier:tgt | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 7, 22; 7, 23; 8, 24; 9, 25; 9, 26; 10, 27; 11, 28; 12, 29; 14, 30; 14, 31; 14, 32; 15, 33; 16, 34; 17, 35; 17, 36; 17, 37; 18, 38; 18, 39; 18, 40; 19, 41; 20, 42; 20, 43; 21, 44; 25, 45; 25, 46; 26, 47; 27, 48; 27, 49; 28, 50; 28, 51; 29, 52; 29, 53; 31, 54; 31, 55; 32, 56; 33, 57; 33, 58; 34, 59; 34, 60; 36, 61; 37, 62; 37, 63; 37, 64; 37, 65; 37, 66; 39, 67; 40, 68; 40, 69; 40, 70; 40, 71; 41, 72; 41, 73; 43, 74; 43, 75; 43, 76; 43, 77; 43, 78; 43, 79; 44, 80; 44, 81; 47, 82; 49, 83; 49, 84; 51, 85; 51, 86; 53, 87; 53, 88; 54, 89; 54, 90; 56, 91; 56, 92; 56, 93; 58, 94; 58, 95; 60, 96; 62, 97; 63, 98; 64, 99; 65, 100; 65, 101; 66, 102; 68, 103; 69, 104; 69, 105; 69, 106; 70, 107; 73, 108; 74, 109; 75, 110; 75, 111; 75, 112; 76, 113; 76, 114; 77, 115; 78, 116; 79, 117; 79, 118; 80, 119; 80, 120; 81, 121; 81, 122; 81, 123; 81, 124; 82, 125; 82, 126; 84, 127; 85, 128; 85, 129; 88, 130; 91, 131; 91, 132; 92, 133; 92, 134; 93, 135; 95, 136; 97, 137; 97, 138; 98, 139; 98, 140; 99, 141; 99, 142; 100, 143; 100, 144; 101, 145; 101, 146; 103, 147; 103, 148; 106, 149; 107, 150; 107, 151; 109, 152; 109, 153; 112, 154; 112, 155; 113, 156; 114, 157; 115, 158; 115, 159; 116, 160; 116, 161; 117, 162; 117, 163; 118, 164; 124, 165; 124, 166; 126, 167; 126, 168; 127, 169; 127, 170; 130, 171; 133, 172; 134, 173; 135, 174; 135, 175; 137, 176; 137, 177; 138, 178; 138, 179; 138, 180; 139, 181; 139, 182; 140, 183; 141, 184; 141, 185; 142, 186; 143, 187; 143, 188; 144, 189; 144, 190; 145, 191; 146, 192; 148, 193; 148, 194; 149, 195; 149, 196; 150, 197; 150, 198; 153, 199; 153, 200; 154, 201; 156, 202; 156, 203; 157, 204; 159, 205; 159, 206; 161, 207; 161, 208; 164, 209; 169, 210; 169, 211; 171, 212; 171, 213; 172, 214; 172, 215; 173, 216; 173, 217; 174, 218; 175, 219; 178, 220; 178, 221; 179, 222; 179, 223; 180, 224; 180, 225; 181, 226; 181, 227; 189, 228; 189, 229; 190, 230; 190, 231; 191, 232; 191, 233; 193, 234; 193, 235; 195, 236; 195, 237; 196, 238; 196, 239; 199, 240; 199, 241; 200, 242; 200, 243; 201, 244; 201, 245; 203, 246; 203, 247; 204, 248; 204, 249; 206, 250; 206, 251; 206, 252; 208, 253; 209, 254; 209, 255; 214, 256; 214, 257; 215, 258; 216, 259; 216, 260; 217, 261; 218, 262; 218, 263; 219, 264; 219, 265; 220, 266; 220, 267; 221, 268; 221, 269; 224, 270; 224, 271; 225, 272; 225, 273; 232, 274; 232, 275; 233, 276; 234, 277; 234, 278; 235, 279; 235, 280; 238, 281; 239, 282; 239, 283; 240, 284; 240, 285; 244, 286; 244, 287; 245, 288; 245, 289; 245, 290; 246, 291; 246, 292; 247, 293; 247, 294; 249, 295; 251, 296; 251, 297; 252, 298; 252, 299; 255, 300; 256, 301; 256, 302; 259, 303; 259, 304; 261, 305; 261, 306; 262, 307; 262, 308; 263, 309; 264, 310; 264, 311; 265, 312; 280, 313; 280, 314; 281, 315; 281, 316; 282, 317; 282, 318; 283, 319; 284, 320; 284, 321; 285, 322; 285, 323; 289, 324; 289, 325; 290, 326; 291, 327; 291, 328; 295, 329; 301, 330; 301, 331; 303, 332; 303, 333; 306, 334; 306, 335; 307, 336; 307, 337; 310, 338; 310, 339; 312, 340; 312, 341; 316, 342; 316, 343; 319, 344; 323, 345; 323, 346; 326, 347; 326, 348; 328, 349; 331, 350; 331, 351; 333, 352; 333, 353; 334, 354; 335, 355; 335, 356; 336, 357; 336, 358; 338, 359; 338, 360; 341, 361; 341, 362; 343, 363; 344, 364; 344, 365; 358, 366; 358, 367; 360, 368; 360, 369; 361, 370; 362, 371; 362, 372; 365, 373 | def _encode_penman(self, g, top=None):
"""
Walk graph g and find a spanning dag, then serialize the result.
First, depth-first traversal of preferred orientations (whether
true or inverted) to create graph p.
If any triples remain, select the first remaining triple whose
source in the dispreferred orientation exists in p, where
'first' is determined by the order of inserted nodes (i.e. a
topological sort). Add this triple, then repeat the depth-first
traversal of preferred orientations from its target. Repeat
until no triples remain, or raise an error if there are no
candidates in the dispreferred orientation (which likely means
the graph is disconnected).
"""
if top is None:
top = g.top
remaining = set(g.triples())
variables = g.variables()
store = defaultdict(lambda: ([], [])) # (preferred, dispreferred)
for t in g.triples():
if t.inverted:
store[t.target][0].append(t)
store[t.source][1].append(Triple(*t, inverted=False))
else:
store[t.source][0].append(t)
store[t.target][1].append(Triple(*t, inverted=True))
p = defaultdict(list)
topolist = [top]
def _update(t):
src, tgt = (t[2], t[0]) if t.inverted else (t[0], t[2])
p[src].append(t)
remaining.remove(t)
if tgt in variables and t.relation != self.TYPE_REL:
topolist.append(tgt)
return tgt
return None
def _explore_preferred(src):
ts = store.get(src, ([], []))[0]
for t in ts:
if t in remaining:
tgt = _update(t)
if tgt is not None:
_explore_preferred(tgt)
ts[:] = [] # clear explored list
_explore_preferred(top)
while remaining:
flip_candidates = [store.get(v, ([],[]))[1] for v in topolist]
for fc in flip_candidates:
fc[:] = [c for c in fc if c in remaining] # clear superfluous
if not any(len(fc) > 0 for fc in flip_candidates):
raise EncodeError('Invalid graph; possibly disconnected.')
c = next(c for fc in flip_candidates for c in fc)
tgt = _update(c)
if tgt is not None:
_explore_preferred(tgt)
return self._layout(p, top, 0, set()) |
0, module; 1, function_definition; 2, function_name:copy; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, return_statement; 8, comment:"""Return a shallow copy of the sorted list."""; 9, call; 10, attribute; 11, argument_list; 12, identifier:self; 13, identifier:__class__; 14, identifier:self; 15, keyword_argument; 16, keyword_argument; 17, identifier:key; 18, attribute; 19, identifier:load; 20, attribute; 21, identifier:self; 22, identifier:_key; 23, identifier:self; 24, identifier:_load | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 9, 10; 9, 11; 10, 12; 10, 13; 11, 14; 11, 15; 11, 16; 15, 17; 15, 18; 16, 19; 16, 20; 18, 21; 18, 22; 20, 23; 20, 24 | def copy(self):
"""Return a shallow copy of the sorted list."""
return self.__class__(self, key=self._key, load=self._load) |
0, module; 1, function_definition; 2, function_name:copy; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, return_statement; 8, comment:"""Return a shallow copy of the sorted dictionary."""; 9, call; 10, attribute; 11, argument_list; 12, identifier:self; 13, identifier:__class__; 14, attribute; 15, attribute; 16, call; 17, identifier:self; 18, identifier:_key; 19, identifier:self; 20, identifier:_load; 21, attribute; 22, argument_list; 23, identifier:self; 24, identifier:_iteritems | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 9, 10; 9, 11; 10, 12; 10, 13; 11, 14; 11, 15; 11, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 21, 23; 21, 24 | def copy(self):
"""Return a shallow copy of the sorted dictionary."""
return self.__class__(self._key, self._load, self._iteritems()) |
0, module; 1, function_definition; 2, function_name:sort_group; 3, parameters; 4, block; 5, identifier:d; 6, default_parameter; 7, expression_statement; 8, comment:# First, sort the paths in order (this must be a couple: (parent_dir, filename), so that there's no ambiguity because else a file at root will be considered as being after a folder/file since the ordering is done alphabetically without any notion of tree structure).; 9, expression_statement; 10, comment:# Pop the first item in the ordered list; 11, expression_statement; 12, while_statement; 13, comment:# No element, then we just return; 14, if_statement; 15, identifier:return_only_first; 16, False; 17, string; 18, assignment; 19, assignment; 20, parenthesized_expression; 21, block; 22, comparison_operator:base_elt[1] is None; 23, block; 24, comment:# Else, we will now group equivalent files together (remember we are working on multiple directories, so we can have multiple equivalent relative filepaths, but of course the absolute filepaths are different).; 25, else_clause; 26, string_content:Sort a dictionary of relative paths and cluster equal paths together at the same time; 27, identifier:d_sort; 28, call; 29, identifier:base_elt; 30, tuple; 31, boolean_operator; 32, expression_statement; 33, subscript; 34, None; 35, return_statement; 36, comment:# Init by creating the first group and pushing the first ordered filepath into the first group; 37, block; 38, identifier:sort_dict_of_paths; 39, argument_list; 40, unary_operator; 41, None; 42, comparison_operator:base_elt[1] is None; 43, identifier:d_sort; 44, assignment; 45, identifier:base_elt; 46, integer:1; 47, None; 48, expression_statement; 49, expression_statement; 50, if_statement; 51, return_statement; 52, identifier:d; 53, integer:1; 54, subscript; 55, None; 56, identifier:base_elt; 57, call; 58, assignment; 59, call; 60, identifier:d_sort; 61, comment:# For each subsequent filepath; 62, block; 63, identifier:lst; 64, identifier:base_elt; 65, integer:1; 66, attribute; 67, argument_list; 68, identifier:lst; 69, list; 70, attribute; 71, argument_list; 72, for_statement; 73, identifier:d_sort; 74, identifier:pop; 75, integer:0; 76, identifier:lst; 77, identifier:append; 78, list; 79, identifier:elt; 80, identifier:d_sort; 81, comment:# If the filepath is not empty (generator died); 82, block; 83, identifier:base_elt; 84, if_statement; 85, comparison_operator:elt[1] is not None; 86, comment:# If the filepath is the same to the latest grouped filepath, we add it to the same group; 87, block; 88, subscript; 89, None; 90, if_statement; 91, identifier:elt; 92, integer:1; 93, comparison_operator:elt[1] == base_elt[1]; 94, block; 95, comment:# Else the filepath is different: we create a new group, add the filepath to this group, and replace the latest grouped filepath; 96, else_clause; 97, subscript; 98, subscript; 99, expression_statement; 100, block; 101, identifier:elt; 102, integer:1; 103, identifier:base_elt; 104, integer:1; 105, call; 106, if_statement; 107, expression_statement; 108, expression_statement; 109, comment:# replace the latest grouped filepath; 110, attribute; 111, argument_list; 112, identifier:return_only_first; 113, block; 114, call; 115, assignment; 116, subscript; 117, identifier:append; 118, identifier:elt; 119, break_statement; 120, comment:# break here if we only need the first group; 121, attribute; 122, argument_list; 123, identifier:base_elt; 124, identifier:elt; 125, identifier:lst; 126, unary_operator; 127, identifier:lst; 128, identifier:append; 129, list; 130, integer:1; 131, identifier:elt | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 6, 16; 7, 17; 9, 18; 11, 19; 12, 20; 12, 21; 14, 22; 14, 23; 14, 24; 14, 25; 17, 26; 18, 27; 18, 28; 19, 29; 19, 30; 20, 31; 21, 32; 22, 33; 22, 34; 23, 35; 25, 36; 25, 37; 28, 38; 28, 39; 30, 40; 30, 41; 31, 42; 31, 43; 32, 44; 33, 45; 33, 46; 35, 47; 37, 48; 37, 49; 37, 50; 37, 51; 39, 52; 40, 53; 42, 54; 42, 55; 44, 56; 44, 57; 48, 58; 49, 59; 50, 60; 50, 61; 50, 62; 51, 63; 54, 64; 54, 65; 57, 66; 57, 67; 58, 68; 58, 69; 59, 70; 59, 71; 62, 72; 66, 73; 66, 74; 67, 75; 70, 76; 70, 77; 71, 78; 72, 79; 72, 80; 72, 81; 72, 82; 78, 83; 82, 84; 84, 85; 84, 86; 84, 87; 85, 88; 85, 89; 87, 90; 88, 91; 88, 92; 90, 93; 90, 94; 90, 95; 90, 96; 93, 97; 93, 98; 94, 99; 96, 100; 97, 101; 97, 102; 98, 103; 98, 104; 99, 105; 100, 106; 100, 107; 100, 108; 100, 109; 105, 110; 105, 111; 106, 112; 106, 113; 107, 114; 108, 115; 110, 116; 110, 117; 111, 118; 113, 119; 113, 120; 114, 121; 114, 122; 115, 123; 115, 124; 116, 125; 116, 126; 121, 127; 121, 128; 122, 129; 126, 130; 129, 131 | def sort_group(d, return_only_first=False):
''' Sort a dictionary of relative paths and cluster equal paths together at the same time '''
# First, sort the paths in order (this must be a couple: (parent_dir, filename), so that there's no ambiguity because else a file at root will be considered as being after a folder/file since the ordering is done alphabetically without any notion of tree structure).
d_sort = sort_dict_of_paths(d)
# Pop the first item in the ordered list
base_elt = (-1, None)
while (base_elt[1] is None and d_sort):
base_elt = d_sort.pop(0)
# No element, then we just return
if base_elt[1] is None:
return None
# Else, we will now group equivalent files together (remember we are working on multiple directories, so we can have multiple equivalent relative filepaths, but of course the absolute filepaths are different).
else:
# Init by creating the first group and pushing the first ordered filepath into the first group
lst = []
lst.append([base_elt])
if d_sort:
# For each subsequent filepath
for elt in d_sort:
# If the filepath is not empty (generator died)
if elt[1] is not None:
# If the filepath is the same to the latest grouped filepath, we add it to the same group
if elt[1] == base_elt[1]:
lst[-1].append(elt)
# Else the filepath is different: we create a new group, add the filepath to this group, and replace the latest grouped filepath
else:
if return_only_first: break # break here if we only need the first group
lst.append([elt])
base_elt = elt # replace the latest grouped filepath
return lst |
0, module; 1, function_definition; 2, function_name:group_files_by_size_fast; 3, parameters; 4, comment:# pragma: no cover; 5, block; 6, identifier:fileslist; 7, identifier:nbgroups; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, comment:# [] or {}; 14, expression_statement; 15, expression_statement; 16, while_statement; 17, return_statement; 18, identifier:mode; 19, integer:1; 20, string; 21, assignment; 22, assignment; 23, assignment; 24, assignment; 25, assignment; 26, identifier:ford; 27, block; 28, identifier:fgrouped; 29, string_content:Given a files list with sizes, output a list where the files are grouped in nbgroups per cluster.
Pseudo-code for algorithm in O(n log(g)) (thank's to insertion sort or binary search trees)
See for more infos: http://cs.stackexchange.com/questions/44406/fast-algorithm-for-clustering-groups-of-elements-given-their-size-time/44614#44614
For each file:
- If to-fill list is empty or file.size > first-key(to-fill):
* Create cluster c with file in first group g1
* Add to-fill[file.size].append([c, g2], [c, g3], ..., [c, gn])
- Else:
* ksize = first-key(to-fill)
* c, g = to-fill[ksize].popitem(0)
* Add file to cluster c in group g
* nsize = ksize - file.size
* if nsize > 0:
. to-fill[nsize].append([c, g])
. sort to-fill if not an automatic ordering structure; 30, identifier:ftofill; 31, call; 32, identifier:ftofill_pointer; 33, dictionary; 34, identifier:fgrouped; 35, list; 36, identifier:ford; 37, call; 38, identifier:last_cid; 39, unary_operator; 40, expression_statement; 41, comment:#print "----\n"+fname, fsize; 42, comment:#if ftofill: print "beforebranch", fsize, ftofill[-1]; 43, comment:#print ftofill; 44, if_statement; 45, identifier:SortedList; 46, argument_list; 47, identifier:sorted; 48, argument_list; 49, integer:1; 50, assignment; 51, boolean_operator; 52, block; 53, else_clause; 54, call; 55, keyword_argument; 56, pattern_list; 57, call; 58, not_operator; 59, comparison_operator:fsize > ftofill[-1]; 60, expression_statement; 61, comment:#print "Branch A: create cluster %i" % last_cid; 62, expression_statement; 63, comment:#fgrouped[last_cid] = []; 64, expression_statement; 65, if_statement; 66, comment:#print "Branch B"; 67, block; 68, attribute; 69, argument_list; 70, identifier:key; 71, lambda; 72, identifier:fname; 73, identifier:fsize; 74, attribute; 75, argument_list; 76, identifier:ftofill; 77, identifier:fsize; 78, subscript; 79, augmented_assignment; 80, call; 81, call; 82, comparison_operator:mode==0; 83, block; 84, else_clause; 85, expression_statement; 86, expression_statement; 87, comment:#print "Assign to cluster %i group %i" % (c, g); 88, expression_statement; 89, expression_statement; 90, if_statement; 91, identifier:fileslist; 92, identifier:iteritems; 93, lambda_parameters; 94, subscript; 95, identifier:ford; 96, identifier:pop; 97, identifier:ftofill; 98, unary_operator; 99, identifier:last_cid; 100, integer:1; 101, attribute; 102, argument_list; 103, attribute; 104, argument_list; 105, identifier:mode; 106, integer:0; 107, for_statement; 108, block; 109, assignment; 110, assignment; 111, call; 112, assignment; 113, comparison_operator:nsize > 0; 114, block; 115, identifier:x; 116, identifier:x; 117, integer:1; 118, integer:1; 119, identifier:fgrouped; 120, identifier:append; 121, list; 122, subscript; 123, identifier:append; 124, list; 125, identifier:g; 126, call; 127, block; 128, for_statement; 129, identifier:ksize; 130, call; 131, pattern_list; 132, call; 133, attribute; 134, argument_list; 135, identifier:nsize; 136, binary_operator:ksize - fsize; 137, identifier:nsize; 138, integer:0; 139, if_statement; 140, expression_statement; 141, expression_statement; 142, identifier:fgrouped; 143, identifier:last_cid; 144, identifier:fname; 145, identifier:xrange; 146, argument_list; 147, expression_statement; 148, if_statement; 149, expression_statement; 150, expression_statement; 151, identifier:g; 152, call; 153, block; 154, attribute; 155, argument_list; 156, identifier:c; 157, identifier:g; 158, attribute; 159, argument_list; 160, subscript; 161, identifier:append; 162, identifier:fname; 163, identifier:ksize; 164, identifier:fsize; 165, not_operator; 166, block; 167, call; 168, call; 169, binary_operator:nbgroups-1; 170, integer:0; 171, unary_operator; 172, call; 173, not_operator; 174, block; 175, call; 176, call; 177, identifier:xrange; 178, argument_list; 179, try_statement; 180, expression_statement; 181, expression_statement; 182, if_statement; 183, identifier:ftofill; 184, identifier:pop; 185, subscript; 186, identifier:pop; 187, subscript; 188, identifier:g; 189, comparison_operator:nsize in ftofill_pointer; 190, expression_statement; 191, attribute; 192, argument_list; 193, attribute; 194, argument_list; 195, identifier:nbgroups; 196, integer:1; 197, integer:1; 198, attribute; 199, argument_list; 200, comparison_operator:fsize in ftofill_pointer; 201, expression_statement; 202, attribute; 203, argument_list; 204, attribute; 205, argument_list; 206, integer:1; 207, identifier:nbgroups; 208, block; 209, except_clause; 210, call; 211, assignment; 212, comparison_operator:diff_size > 0; 213, block; 214, identifier:ftofill_pointer; 215, identifier:ksize; 216, identifier:fgrouped; 217, identifier:c; 218, identifier:nsize; 219, identifier:ftofill_pointer; 220, assignment; 221, subscript; 222, identifier:append; 223, tuple; 224, identifier:ftofill; 225, identifier:add; 226, identifier:nsize; 227, subscript; 228, identifier:append; 229, list; 230, identifier:fsize; 231, identifier:ftofill_pointer; 232, assignment; 233, subscript; 234, identifier:append; 235, tuple; 236, identifier:ftofill; 237, identifier:add; 238, identifier:fsize; 239, expression_statement; 240, comment:#print "Added to group %i: %s %i" % (g, fgname, fgsize); 241, identifier:IndexError; 242, block; 243, attribute; 244, argument_list; 245, identifier:diff_size; 246, binary_operator:fsize - fgsize; 247, identifier:diff_size; 248, integer:0; 249, if_statement; 250, expression_statement; 251, expression_statement; 252, subscript; 253, list; 254, identifier:ftofill_pointer; 255, identifier:nsize; 256, identifier:c; 257, identifier:g; 258, identifier:fgrouped; 259, identifier:last_cid; 260, subscript; 261, list; 262, identifier:ftofill_pointer; 263, identifier:fsize; 264, identifier:last_cid; 265, identifier:g; 266, assignment; 267, break_statement; 268, subscript; 269, identifier:append; 270, list; 271, identifier:fsize; 272, identifier:fgsize; 273, not_operator; 274, block; 275, call; 276, call; 277, identifier:ftofill_pointer; 278, identifier:nsize; 279, identifier:ftofill_pointer; 280, identifier:fsize; 281, pattern_list; 282, call; 283, identifier:fgrouped; 284, identifier:last_cid; 285, identifier:fgname; 286, comparison_operator:diff_size in ftofill_pointer; 287, expression_statement; 288, attribute; 289, argument_list; 290, attribute; 291, argument_list; 292, identifier:fgname; 293, identifier:fgsize; 294, attribute; 295, argument_list; 296, identifier:diff_size; 297, identifier:ftofill_pointer; 298, assignment; 299, subscript; 300, identifier:append; 301, tuple; 302, identifier:ftofill; 303, identifier:add; 304, identifier:diff_size; 305, identifier:ford; 306, identifier:pop; 307, subscript; 308, list; 309, identifier:ftofill_pointer; 310, identifier:diff_size; 311, identifier:last_cid; 312, identifier:g; 313, identifier:ftofill_pointer; 314, identifier:diff_size | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 3, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 14; 5, 15; 5, 16; 5, 17; 8, 18; 8, 19; 9, 20; 10, 21; 11, 22; 12, 23; 14, 24; 15, 25; 16, 26; 16, 27; 17, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 23, 34; 23, 35; 24, 36; 24, 37; 25, 38; 25, 39; 27, 40; 27, 41; 27, 42; 27, 43; 27, 44; 31, 45; 31, 46; 37, 47; 37, 48; 39, 49; 40, 50; 44, 51; 44, 52; 44, 53; 48, 54; 48, 55; 50, 56; 50, 57; 51, 58; 51, 59; 52, 60; 52, 61; 52, 62; 52, 63; 52, 64; 52, 65; 53, 66; 53, 67; 54, 68; 54, 69; 55, 70; 55, 71; 56, 72; 56, 73; 57, 74; 57, 75; 58, 76; 59, 77; 59, 78; 60, 79; 62, 80; 64, 81; 65, 82; 65, 83; 65, 84; 67, 85; 67, 86; 67, 87; 67, 88; 67, 89; 67, 90; 68, 91; 68, 92; 71, 93; 71, 94; 74, 95; 74, 96; 78, 97; 78, 98; 79, 99; 79, 100; 80, 101; 80, 102; 81, 103; 81, 104; 82, 105; 82, 106; 83, 107; 84, 108; 85, 109; 86, 110; 88, 111; 89, 112; 90, 113; 90, 114; 93, 115; 94, 116; 94, 117; 98, 118; 101, 119; 101, 120; 102, 121; 103, 122; 103, 123; 104, 124; 107, 125; 107, 126; 107, 127; 108, 128; 109, 129; 109, 130; 110, 131; 110, 132; 111, 133; 111, 134; 112, 135; 112, 136; 113, 137; 113, 138; 114, 139; 114, 140; 114, 141; 122, 142; 122, 143; 124, 144; 126, 145; 126, 146; 127, 147; 127, 148; 127, 149; 127, 150; 128, 151; 128, 152; 128, 153; 130, 154; 130, 155; 131, 156; 131, 157; 132, 158; 132, 159; 133, 160; 133, 161; 134, 162; 136, 163; 136, 164; 139, 165; 139, 166; 140, 167; 141, 168; 146, 169; 146, 170; 146, 171; 147, 172; 148, 173; 148, 174; 149, 175; 150, 176; 152, 177; 152, 178; 153, 179; 153, 180; 153, 181; 153, 182; 154, 183; 154, 184; 158, 185; 158, 186; 160, 187; 160, 188; 165, 189; 166, 190; 167, 191; 167, 192; 168, 193; 168, 194; 169, 195; 169, 196; 171, 197; 172, 198; 172, 199; 173, 200; 174, 201; 175, 202; 175, 203; 176, 204; 176, 205; 178, 206; 178, 207; 179, 208; 179, 209; 180, 210; 181, 211; 182, 212; 182, 213; 185, 214; 185, 215; 187, 216; 187, 217; 189, 218; 189, 219; 190, 220; 191, 221; 191, 222; 192, 223; 193, 224; 193, 225; 194, 226; 198, 227; 198, 228; 199, 229; 200, 230; 200, 231; 201, 232; 202, 233; 202, 234; 203, 235; 204, 236; 204, 237; 205, 238; 208, 239; 208, 240; 209, 241; 209, 242; 210, 243; 210, 244; 211, 245; 211, 246; 212, 247; 212, 248; 213, 249; 213, 250; 213, 251; 220, 252; 220, 253; 221, 254; 221, 255; 223, 256; 223, 257; 227, 258; 227, 259; 232, 260; 232, 261; 233, 262; 233, 263; 235, 264; 235, 265; 239, 266; 242, 267; 243, 268; 243, 269; 244, 270; 246, 271; 246, 272; 249, 273; 249, 274; 250, 275; 251, 276; 252, 277; 252, 278; 260, 279; 260, 280; 266, 281; 266, 282; 268, 283; 268, 284; 270, 285; 273, 286; 274, 287; 275, 288; 275, 289; 276, 290; 276, 291; 281, 292; 281, 293; 282, 294; 282, 295; 286, 296; 286, 297; 287, 298; 288, 299; 288, 300; 289, 301; 290, 302; 290, 303; 291, 304; 294, 305; 294, 306; 298, 307; 298, 308; 299, 309; 299, 310; 301, 311; 301, 312; 307, 313; 307, 314 | def group_files_by_size_fast(fileslist, nbgroups, mode=1): # pragma: no cover
'''Given a files list with sizes, output a list where the files are grouped in nbgroups per cluster.
Pseudo-code for algorithm in O(n log(g)) (thank's to insertion sort or binary search trees)
See for more infos: http://cs.stackexchange.com/questions/44406/fast-algorithm-for-clustering-groups-of-elements-given-their-size-time/44614#44614
For each file:
- If to-fill list is empty or file.size > first-key(to-fill):
* Create cluster c with file in first group g1
* Add to-fill[file.size].append([c, g2], [c, g3], ..., [c, gn])
- Else:
* ksize = first-key(to-fill)
* c, g = to-fill[ksize].popitem(0)
* Add file to cluster c in group g
* nsize = ksize - file.size
* if nsize > 0:
. to-fill[nsize].append([c, g])
. sort to-fill if not an automatic ordering structure
'''
ftofill = SortedList()
ftofill_pointer = {}
fgrouped = [] # [] or {}
ford = sorted(fileslist.iteritems(), key=lambda x: x[1])
last_cid = -1
while ford:
fname, fsize = ford.pop()
#print "----\n"+fname, fsize
#if ftofill: print "beforebranch", fsize, ftofill[-1]
#print ftofill
if not ftofill or fsize > ftofill[-1]:
last_cid += 1
#print "Branch A: create cluster %i" % last_cid
fgrouped.append([])
#fgrouped[last_cid] = []
fgrouped[last_cid].append([fname])
if mode==0:
for g in xrange(nbgroups-1, 0, -1):
fgrouped[last_cid].append([])
if not fsize in ftofill_pointer:
ftofill_pointer[fsize] = []
ftofill_pointer[fsize].append((last_cid, g))
ftofill.add(fsize)
else:
for g in xrange(1, nbgroups):
try:
fgname, fgsize = ford.pop()
#print "Added to group %i: %s %i" % (g, fgname, fgsize)
except IndexError:
break
fgrouped[last_cid].append([fgname])
diff_size = fsize - fgsize
if diff_size > 0:
if not diff_size in ftofill_pointer:
ftofill_pointer[diff_size] = []
ftofill_pointer[diff_size].append((last_cid, g))
ftofill.add(diff_size)
else:
#print "Branch B"
ksize = ftofill.pop()
c, g = ftofill_pointer[ksize].pop()
#print "Assign to cluster %i group %i" % (c, g)
fgrouped[c][g].append(fname)
nsize = ksize - fsize
if nsize > 0:
if not nsize in ftofill_pointer:
ftofill_pointer[nsize] = []
ftofill_pointer[nsize].append((c, g))
ftofill.add(nsize)
return fgrouped |
0, module; 1, function_definition; 2, function_name:print_; 3, parameters; 4, block; 5, identifier:rows; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, comment:# input validation; 13, expression_statement; 14, if_statement; 15, expression_statement; 16, if_statement; 17, comment:# sort rows; 18, if_statement; 19, comment:# limit rows; 20, expression_statement; 21, for_statement; 22, comment:# print rows; 23, expression_statement; 24, expression_statement; 25, identifier:limit; 26, integer:15; 27, identifier:sort; 28, string; 29, identifier:order; 30, string; 31, comment:"""Print the rows as a summary.
Keyword arguments:
limit -- the maximum number of elements to be listed
sort -- sort elements by 'size', 'type', or '#'
order -- sort 'ascending' or 'descending'
"""; 32, assignment; 33, identifier:row; 34, identifier:rows; 35, block; 36, assignment; 37, comparison_operator:sort not in sortby; 38, block; 39, assignment; 40, comparison_operator:order not in orders; 41, block; 42, comparison_operator:sortby.index(sort) == 0; 43, block; 44, else_clause; 45, assignment; 46, identifier:row; 47, identifier:localrows; 48, block; 49, call; 50, call; 51, string_content:size; 52, string_content:descending; 53, identifier:localrows; 54, list; 55, expression_statement; 56, identifier:sortby; 57, list; 58, identifier:sort; 59, identifier:sortby; 60, raise_statement; 61, identifier:orders; 62, list; 63, identifier:order; 64, identifier:orders; 65, raise_statement; 66, call; 67, integer:0; 68, if_statement; 69, block; 70, identifier:localrows; 71, subscript; 72, expression_statement; 73, attribute; 74, argument_list; 75, identifier:_print_table; 76, argument_list; 77, call; 78, string; 79, string; 80, string; 81, call; 82, string; 83, string; 84, call; 85, attribute; 86, argument_list; 87, comparison_operator:order == "ascending"; 88, block; 89, elif_clause; 90, if_statement; 91, identifier:localrows; 92, slice; 93, assignment; 94, identifier:localrows; 95, identifier:insert; 96, integer:0; 97, list; 98, identifier:localrows; 99, attribute; 100, argument_list; 101, string_content:type; 102, string_content:#; 103, string_content:size; 104, identifier:ValueError; 105, argument_list; 106, string_content:ascending; 107, string_content:descending; 108, identifier:ValueError; 109, argument_list; 110, identifier:sortby; 111, identifier:index; 112, identifier:sort; 113, identifier:order; 114, string:"ascending"; 115, expression_statement; 116, comparison_operator:order == "descending"; 117, block; 118, comparison_operator:order == "ascending"; 119, block; 120, elif_clause; 121, integer:0; 122, identifier:limit; 123, subscript; 124, call; 125, string:"types"; 126, string:"# objects"; 127, string:"total size"; 128, identifier:localrows; 129, identifier:append; 130, call; 131, binary_operator:"invalid sort, should be one of" + str(sortby); 132, binary_operator:"invalid order, should be one of" + str(orders); 133, call; 134, identifier:order; 135, string:"descending"; 136, expression_statement; 137, identifier:order; 138, string:"ascending"; 139, expression_statement; 140, comparison_operator:order == "descending"; 141, block; 142, identifier:row; 143, integer:2; 144, attribute; 145, argument_list; 146, identifier:list; 147, argument_list; 148, string:"invalid sort, should be one of"; 149, call; 150, string:"invalid order, should be one of"; 151, call; 152, attribute; 153, argument_list; 154, call; 155, call; 156, identifier:order; 157, string:"descending"; 158, expression_statement; 159, identifier:stringutils; 160, identifier:pp; 161, subscript; 162, identifier:row; 163, identifier:str; 164, argument_list; 165, identifier:str; 166, argument_list; 167, identifier:localrows; 168, identifier:sort; 169, keyword_argument; 170, attribute; 171, argument_list; 172, attribute; 173, argument_list; 174, call; 175, identifier:row; 176, integer:2; 177, identifier:sortby; 178, identifier:orders; 179, identifier:key; 180, lambda; 181, identifier:localrows; 182, identifier:sort; 183, keyword_argument; 184, keyword_argument; 185, identifier:localrows; 186, identifier:sort; 187, keyword_argument; 188, attribute; 189, argument_list; 190, lambda_parameters; 191, call; 192, identifier:key; 193, lambda; 194, identifier:reverse; 195, True; 196, identifier:key; 197, lambda; 198, identifier:localrows; 199, identifier:sort; 200, keyword_argument; 201, keyword_argument; 202, identifier:x; 203, identifier:_repr; 204, argument_list; 205, lambda_parameters; 206, call; 207, lambda_parameters; 208, subscript; 209, identifier:key; 210, lambda; 211, identifier:reverse; 212, True; 213, subscript; 214, identifier:x; 215, identifier:_repr; 216, argument_list; 217, identifier:x; 218, identifier:x; 219, call; 220, lambda_parameters; 221, subscript; 222, identifier:x; 223, integer:0; 224, subscript; 225, attribute; 226, argument_list; 227, identifier:x; 228, identifier:x; 229, call; 230, identifier:x; 231, integer:0; 232, identifier:sortby; 233, identifier:index; 234, identifier:sort; 235, attribute; 236, argument_list; 237, identifier:sortby; 238, identifier:index; 239, identifier:sort | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 6, 25; 6, 26; 7, 27; 7, 28; 8, 29; 8, 30; 9, 31; 10, 32; 11, 33; 11, 34; 11, 35; 13, 36; 14, 37; 14, 38; 15, 39; 16, 40; 16, 41; 18, 42; 18, 43; 18, 44; 20, 45; 21, 46; 21, 47; 21, 48; 23, 49; 24, 50; 28, 51; 30, 52; 32, 53; 32, 54; 35, 55; 36, 56; 36, 57; 37, 58; 37, 59; 38, 60; 39, 61; 39, 62; 40, 63; 40, 64; 41, 65; 42, 66; 42, 67; 43, 68; 44, 69; 45, 70; 45, 71; 48, 72; 49, 73; 49, 74; 50, 75; 50, 76; 55, 77; 57, 78; 57, 79; 57, 80; 60, 81; 62, 82; 62, 83; 65, 84; 66, 85; 66, 86; 68, 87; 68, 88; 68, 89; 69, 90; 71, 91; 71, 92; 72, 93; 73, 94; 73, 95; 74, 96; 74, 97; 76, 98; 77, 99; 77, 100; 78, 101; 79, 102; 80, 103; 81, 104; 81, 105; 82, 106; 83, 107; 84, 108; 84, 109; 85, 110; 85, 111; 86, 112; 87, 113; 87, 114; 88, 115; 89, 116; 89, 117; 90, 118; 90, 119; 90, 120; 92, 121; 92, 122; 93, 123; 93, 124; 97, 125; 97, 126; 97, 127; 99, 128; 99, 129; 100, 130; 105, 131; 109, 132; 115, 133; 116, 134; 116, 135; 117, 136; 118, 137; 118, 138; 119, 139; 120, 140; 120, 141; 123, 142; 123, 143; 124, 144; 124, 145; 130, 146; 130, 147; 131, 148; 131, 149; 132, 150; 132, 151; 133, 152; 133, 153; 136, 154; 139, 155; 140, 156; 140, 157; 141, 158; 144, 159; 144, 160; 145, 161; 147, 162; 149, 163; 149, 164; 151, 165; 151, 166; 152, 167; 152, 168; 153, 169; 154, 170; 154, 171; 155, 172; 155, 173; 158, 174; 161, 175; 161, 176; 164, 177; 166, 178; 169, 179; 169, 180; 170, 181; 170, 182; 171, 183; 171, 184; 172, 185; 172, 186; 173, 187; 174, 188; 174, 189; 180, 190; 180, 191; 183, 192; 183, 193; 184, 194; 184, 195; 187, 196; 187, 197; 188, 198; 188, 199; 189, 200; 189, 201; 190, 202; 191, 203; 191, 204; 193, 205; 193, 206; 197, 207; 197, 208; 200, 209; 200, 210; 201, 211; 201, 212; 204, 213; 205, 214; 206, 215; 206, 216; 207, 217; 208, 218; 208, 219; 210, 220; 210, 221; 213, 222; 213, 223; 216, 224; 219, 225; 219, 226; 220, 227; 221, 228; 221, 229; 224, 230; 224, 231; 225, 232; 225, 233; 226, 234; 229, 235; 229, 236; 235, 237; 235, 238; 236, 239 | def print_(rows, limit=15, sort='size', order='descending'):
"""Print the rows as a summary.
Keyword arguments:
limit -- the maximum number of elements to be listed
sort -- sort elements by 'size', 'type', or '#'
order -- sort 'ascending' or 'descending'
"""
localrows = []
for row in rows:
localrows.append(list(row))
# input validation
sortby = ['type', '#', 'size']
if sort not in sortby:
raise ValueError("invalid sort, should be one of" + str(sortby))
orders = ['ascending', 'descending']
if order not in orders:
raise ValueError("invalid order, should be one of" + str(orders))
# sort rows
if sortby.index(sort) == 0:
if order == "ascending":
localrows.sort(key=lambda x: _repr(x[0]))
elif order == "descending":
localrows.sort(key=lambda x: _repr(x[0]), reverse=True)
else:
if order == "ascending":
localrows.sort(key=lambda x: x[sortby.index(sort)])
elif order == "descending":
localrows.sort(key=lambda x: x[sortby.index(sort)], reverse=True)
# limit rows
localrows = localrows[0:limit]
for row in localrows:
row[2] = stringutils.pp(row[2])
# print rows
localrows.insert(0,["types", "# objects", "total size"])
_print_table(localrows) |
0, module; 1, function_definition; 2, function_name:split_and_sort; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""
Split the graphs into sub graphs and return a list of all graphs sorted
by the number of nodes. The graph with most nodes is returned first.
"""; 12, assignment; 13, call; 14, pattern_list; 15, call; 16, block; 17, identifier:graphs; 18, identifier:graphs; 19, call; 20, attribute; 21, argument_list; 22, identifier:index; 23, identifier:graph; 24, identifier:enumerate; 25, argument_list; 26, expression_statement; 27, identifier:list; 28, argument_list; 29, identifier:graphs; 30, identifier:sort; 31, keyword_argument; 32, identifier:graphs; 33, assignment; 34, call; 35, identifier:key; 36, lambda; 37, attribute; 38, identifier:index; 39, attribute; 40, argument_list; 41, lambda_parameters; 42, unary_operator; 43, identifier:graph; 44, identifier:index; 45, identifier:self; 46, identifier:split; 47, identifier:x; 48, call; 49, identifier:len; 50, argument_list; 51, attribute; 52, identifier:x; 53, identifier:metadata | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 12, 18; 12, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 19, 27; 19, 28; 20, 29; 20, 30; 21, 31; 25, 32; 26, 33; 28, 34; 31, 35; 31, 36; 33, 37; 33, 38; 34, 39; 34, 40; 36, 41; 36, 42; 37, 43; 37, 44; 39, 45; 39, 46; 41, 47; 42, 48; 48, 49; 48, 50; 50, 51; 51, 52; 51, 53 | def split_and_sort(self):
"""
Split the graphs into sub graphs and return a list of all graphs sorted
by the number of nodes. The graph with most nodes is returned first.
"""
graphs = list(self.split())
graphs.sort(key=lambda x: -len(x.metadata))
for index, graph in enumerate(graphs):
graph.index = index
return graphs |
0, module; 1, function_definition; 2, function_name:profile; 3, parameters; 4, block; 5, default_parameter; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, expression_statement; 14, if_statement; 15, comment:# @profile syntax -- we are a decorator.; 16, if_statement; 17, for_statement; 18, expression_statement; 19, comment:# fp = HotShotFuncProfile(fn, skip=skip, filename=filename, ...); 20, comment:# or HotShotFuncProfile; 21, comment:# We cannot return fp or fp.__call__ directly as that would break method; 22, comment:# definitions, instead we need to return a plain function.; 23, function_definition; 24, expression_statement; 25, expression_statement; 26, expression_statement; 27, expression_statement; 28, return_statement; 29, identifier:fn; 30, None; 31, identifier:skip; 32, integer:0; 33, identifier:filename; 34, None; 35, identifier:immediate; 36, False; 37, identifier:dirs; 38, False; 39, identifier:sort; 40, None; 41, identifier:entries; 42, integer:40; 43, identifier:profiler; 44, tuple; 45, comment:"""Mark `fn` for profiling.
If `skip` is > 0, first `skip` calls to `fn` will not be profiled.
If `immediate` is False, profiling results will be printed to
sys.stdout on program termination. Otherwise results will be printed
after each call.
If `dirs` is False only the name of the file will be printed.
Otherwise the full path is used.
`sort` can be a list of sort keys (defaulting to ['cumulative',
'time', 'calls']). The following ones are recognized::
'calls' -- call count
'cumulative' -- cumulative time
'file' -- file name
'line' -- line number
'module' -- file name
'name' -- function name
'nfl' -- name/file/line
'pcalls' -- call count
'stdname' -- standard name
'time' -- internal time
`entries` limits the output to the first N entries.
`profiler` can be used to select the preferred profiler, or specify a
sequence of them, in order of preference. The default is ('cProfile'.
'profile', 'hotshot').
If `filename` is specified, the profile stats will be stored in the
named file. You can load them pstats.Stats(filename).
Usage::
def fn(...):
...
fn = profile(fn, skip=1)
If you are using Python 2.4, you should be able to use the decorator
syntax::
@profile(skip=3)
def fn(...):
...
or just ::
@profile
def fn(...):
...
"""; 46, comparison_operator:fn is None; 47, comment:# @profile() syntax -- we are a decorator maker; 48, block; 49, call; 50, block; 51, identifier:p; 52, identifier:profiler; 53, block; 54, else_clause; 55, assignment; 56, function_name:new_fn; 57, parameters; 58, block; 59, assignment; 60, assignment; 61, assignment; 62, assignment; 63, identifier:new_fn; 64, string; 65, string; 66, string; 67, identifier:fn; 68, None; 69, function_definition; 70, return_statement; 71, identifier:isinstance; 72, argument_list; 73, expression_statement; 74, if_statement; 75, block; 76, identifier:fp; 77, call; 78, list_splat_pattern; 79, dictionary_splat_pattern; 80, return_statement; 81, attribute; 82, attribute; 83, attribute; 84, attribute; 85, attribute; 86, attribute; 87, attribute; 88, attribute; 89, string_content:cProfile; 90, string_content:profile; 91, string_content:hotshot; 92, function_name:decorator; 93, parameters; 94, block; 95, identifier:decorator; 96, identifier:profiler; 97, identifier:str; 98, assignment; 99, comparison_operator:p in AVAILABLE_PROFILERS; 100, block; 101, raise_statement; 102, identifier:profiler_class; 103, argument_list; 104, identifier:args; 105, identifier:kw; 106, call; 107, identifier:new_fn; 108, identifier:__doc__; 109, identifier:fn; 110, identifier:__doc__; 111, identifier:new_fn; 112, identifier:__name__; 113, identifier:fn; 114, identifier:__name__; 115, identifier:new_fn; 116, identifier:__dict__; 117, identifier:fn; 118, identifier:__dict__; 119, identifier:new_fn; 120, identifier:__module__; 121, identifier:fn; 122, identifier:__module__; 123, identifier:fn; 124, return_statement; 125, identifier:profiler; 126, list; 127, identifier:p; 128, identifier:AVAILABLE_PROFILERS; 129, expression_statement; 130, break_statement; 131, call; 132, identifier:fn; 133, keyword_argument; 134, keyword_argument; 135, keyword_argument; 136, keyword_argument; 137, keyword_argument; 138, keyword_argument; 139, identifier:fp; 140, argument_list; 141, call; 142, identifier:profiler; 143, assignment; 144, identifier:ValueError; 145, argument_list; 146, identifier:skip; 147, identifier:skip; 148, identifier:filename; 149, identifier:filename; 150, identifier:immediate; 151, identifier:immediate; 152, identifier:dirs; 153, identifier:dirs; 154, identifier:sort; 155, identifier:sort; 156, identifier:entries; 157, identifier:entries; 158, list_splat; 159, dictionary_splat; 160, identifier:profile; 161, argument_list; 162, identifier:profiler_class; 163, subscript; 164, binary_operator:'only these profilers are available: %s'
% ', '.join(AVAILABLE_PROFILERS); 165, identifier:args; 166, identifier:kw; 167, identifier:fn; 168, keyword_argument; 169, keyword_argument; 170, keyword_argument; 171, keyword_argument; 172, keyword_argument; 173, keyword_argument; 174, keyword_argument; 175, identifier:AVAILABLE_PROFILERS; 176, identifier:p; 177, string; 178, call; 179, identifier:skip; 180, identifier:skip; 181, identifier:filename; 182, identifier:filename; 183, identifier:immediate; 184, identifier:immediate; 185, identifier:dirs; 186, identifier:dirs; 187, identifier:sort; 188, identifier:sort; 189, identifier:entries; 190, identifier:entries; 191, identifier:profiler; 192, identifier:profiler; 193, string_content:only these profilers are available: %s; 194, attribute; 195, argument_list; 196, string; 197, identifier:join; 198, identifier:AVAILABLE_PROFILERS; 199, string_content:, | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 5, 29; 5, 30; 6, 31; 6, 32; 7, 33; 7, 34; 8, 35; 8, 36; 9, 37; 9, 38; 10, 39; 10, 40; 11, 41; 11, 42; 12, 43; 12, 44; 13, 45; 14, 46; 14, 47; 14, 48; 16, 49; 16, 50; 17, 51; 17, 52; 17, 53; 17, 54; 18, 55; 23, 56; 23, 57; 23, 58; 24, 59; 25, 60; 26, 61; 27, 62; 28, 63; 44, 64; 44, 65; 44, 66; 46, 67; 46, 68; 48, 69; 48, 70; 49, 71; 49, 72; 50, 73; 53, 74; 54, 75; 55, 76; 55, 77; 57, 78; 57, 79; 58, 80; 59, 81; 59, 82; 60, 83; 60, 84; 61, 85; 61, 86; 62, 87; 62, 88; 64, 89; 65, 90; 66, 91; 69, 92; 69, 93; 69, 94; 70, 95; 72, 96; 72, 97; 73, 98; 74, 99; 74, 100; 75, 101; 77, 102; 77, 103; 78, 104; 79, 105; 80, 106; 81, 107; 81, 108; 82, 109; 82, 110; 83, 111; 83, 112; 84, 113; 84, 114; 85, 115; 85, 116; 86, 117; 86, 118; 87, 119; 87, 120; 88, 121; 88, 122; 93, 123; 94, 124; 98, 125; 98, 126; 99, 127; 99, 128; 100, 129; 100, 130; 101, 131; 103, 132; 103, 133; 103, 134; 103, 135; 103, 136; 103, 137; 103, 138; 106, 139; 106, 140; 124, 141; 126, 142; 129, 143; 131, 144; 131, 145; 133, 146; 133, 147; 134, 148; 134, 149; 135, 150; 135, 151; 136, 152; 136, 153; 137, 154; 137, 155; 138, 156; 138, 157; 140, 158; 140, 159; 141, 160; 141, 161; 143, 162; 143, 163; 145, 164; 158, 165; 159, 166; 161, 167; 161, 168; 161, 169; 161, 170; 161, 171; 161, 172; 161, 173; 161, 174; 163, 175; 163, 176; 164, 177; 164, 178; 168, 179; 168, 180; 169, 181; 169, 182; 170, 183; 170, 184; 171, 185; 171, 186; 172, 187; 172, 188; 173, 189; 173, 190; 174, 191; 174, 192; 177, 193; 178, 194; 178, 195; 194, 196; 194, 197; 195, 198; 196, 199 | def profile(fn=None, skip=0, filename=None, immediate=False, dirs=False,
sort=None, entries=40,
profiler=('cProfile', 'profile', 'hotshot')):
"""Mark `fn` for profiling.
If `skip` is > 0, first `skip` calls to `fn` will not be profiled.
If `immediate` is False, profiling results will be printed to
sys.stdout on program termination. Otherwise results will be printed
after each call.
If `dirs` is False only the name of the file will be printed.
Otherwise the full path is used.
`sort` can be a list of sort keys (defaulting to ['cumulative',
'time', 'calls']). The following ones are recognized::
'calls' -- call count
'cumulative' -- cumulative time
'file' -- file name
'line' -- line number
'module' -- file name
'name' -- function name
'nfl' -- name/file/line
'pcalls' -- call count
'stdname' -- standard name
'time' -- internal time
`entries` limits the output to the first N entries.
`profiler` can be used to select the preferred profiler, or specify a
sequence of them, in order of preference. The default is ('cProfile'.
'profile', 'hotshot').
If `filename` is specified, the profile stats will be stored in the
named file. You can load them pstats.Stats(filename).
Usage::
def fn(...):
...
fn = profile(fn, skip=1)
If you are using Python 2.4, you should be able to use the decorator
syntax::
@profile(skip=3)
def fn(...):
...
or just ::
@profile
def fn(...):
...
"""
if fn is None: # @profile() syntax -- we are a decorator maker
def decorator(fn):
return profile(fn, skip=skip, filename=filename,
immediate=immediate, dirs=dirs,
sort=sort, entries=entries,
profiler=profiler)
return decorator
# @profile syntax -- we are a decorator.
if isinstance(profiler, str):
profiler = [profiler]
for p in profiler:
if p in AVAILABLE_PROFILERS:
profiler_class = AVAILABLE_PROFILERS[p]
break
else:
raise ValueError('only these profilers are available: %s'
% ', '.join(AVAILABLE_PROFILERS))
fp = profiler_class(fn, skip=skip, filename=filename,
immediate=immediate, dirs=dirs,
sort=sort, entries=entries)
# fp = HotShotFuncProfile(fn, skip=skip, filename=filename, ...)
# or HotShotFuncProfile
# We cannot return fp or fp.__call__ directly as that would break method
# definitions, instead we need to return a plain function.
def new_fn(*args, **kw):
return fp(*args, **kw)
new_fn.__doc__ = fn.__doc__
new_fn.__name__ = fn.__name__
new_fn.__dict__ = fn.__dict__
new_fn.__module__ = fn.__module__
return new_fn |
0, module; 1, function_definition; 2, function_name:_get_kernel_arguments; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, return_statement; 10, comment:"""Get the list of kernel arguments for loading the kernel data elements into the kernel.
This will use the sorted keys for looping through the kernel input items.
Returns:
list of str: the list of parameter definitions
"""; 11, assignment; 12, pattern_list; 13, call; 14, block; 15, identifier:declarations; 16, identifier:declarations; 17, list; 18, identifier:name; 19, identifier:data; 20, attribute; 21, argument_list; 22, expression_statement; 23, attribute; 24, identifier:items; 25, call; 26, identifier:self; 27, identifier:_kernel_data; 28, attribute; 29, argument_list; 30, identifier:declarations; 31, identifier:extend; 32, call; 33, attribute; 34, argument_list; 35, identifier:data; 36, identifier:get_kernel_parameters; 37, binary_operator:'_' + name; 38, string; 39, identifier:name; 40, string_content:_ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 8, 14; 9, 15; 11, 16; 11, 17; 12, 18; 12, 19; 13, 20; 13, 21; 14, 22; 20, 23; 20, 24; 22, 25; 23, 26; 23, 27; 25, 28; 25, 29; 28, 30; 28, 31; 29, 32; 32, 33; 32, 34; 33, 35; 33, 36; 34, 37; 37, 38; 37, 39; 38, 40 | def _get_kernel_arguments(self):
"""Get the list of kernel arguments for loading the kernel data elements into the kernel.
This will use the sorted keys for looping through the kernel input items.
Returns:
list of str: the list of parameter definitions
"""
declarations = []
for name, data in self._kernel_data.items():
declarations.extend(data.get_kernel_parameters('_' + name))
return declarations |
0, module; 1, function_definition; 2, function_name:topological_sort; 3, parameters; 4, block; 5, identifier:data; 6, expression_statement; 7, function_definition; 8, function_definition; 9, function_definition; 10, function_definition; 11, function_definition; 12, expression_statement; 13, if_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, for_statement; 18, return_statement; 19, comment:"""Topological sort the given dictionary structure.
Args:
data (dict); dictionary structure where the value is a list of dependencies for that given key.
For example: ``{'a': (), 'b': ('a',)}``, where ``a`` depends on nothing and ``b`` depends on ``a``.
Returns:
tuple: the dependencies in constructor order
"""; 20, function_name:check_self_dependencies; 21, parameters; 22, block; 23, function_name:prepare_input_data; 24, parameters; 25, block; 26, function_name:find_items_without_dependencies; 27, parameters; 28, block; 29, function_name:add_empty_dependencies; 30, parameters; 31, block; 32, function_name:get_sorted; 33, parameters; 34, block; 35, call; 36, not_operator; 37, block; 38, assignment; 39, call; 40, assignment; 41, identifier:d; 42, call; 43, block; 44, identifier:result; 45, identifier:input_data; 46, expression_statement; 47, for_statement; 48, identifier:input_data; 49, expression_statement; 50, return_statement; 51, identifier:input_data; 52, expression_statement; 53, return_statement; 54, identifier:data; 55, expression_statement; 56, expression_statement; 57, identifier:input_data; 58, expression_statement; 59, while_statement; 60, if_statement; 61, identifier:check_self_dependencies; 62, argument_list; 63, call; 64, return_statement; 65, identifier:data_copy; 66, call; 67, identifier:add_empty_dependencies; 68, argument_list; 69, identifier:result; 70, list; 71, identifier:get_sorted; 72, argument_list; 73, try_statement; 74, expression_statement; 75, comment:"""Check if there are self dependencies within a node.
Self dependencies are for example: ``{'a': ('a',)}``.
Args:
input_data (dict): the input data. Of a structure similar to {key: (list of values), ...}.
Raises:
ValueError: if there are indeed self dependencies
"""; 76, pattern_list; 77, call; 78, block; 79, comment:"""Prepares the input data by making sets of the dependencies. This automatically removes redundant items.
Args:
input_data (dict): the input data. Of a structure similar to {key: (list of values), ...}.
Returns:
dict: a copy of the input dict but with sets instead of lists for the dependencies.
"""; 80, dictionary_comprehension; 81, comment:"""This searches the dependencies of all the items for items that have no dependencies.
For example, suppose the input is: ``{'a': ('b',)}``, then ``a`` depends on ``b`` and ``b`` depends on nothing.
This class returns ``(b,)`` in this example.
Args:
input_data (dict): the input data. Of a structure similar to {key: (list of values), ...}.
Returns:
list: the list of items without any dependency.
"""; 82, call; 83, assignment; 84, call; 85, assignment; 86, True; 87, block; 88, comparison_operator:len(data) != 0; 89, block; 90, identifier:data; 91, identifier:len; 92, argument_list; 93, list; 94, identifier:prepare_input_data; 95, argument_list; 96, identifier:data_copy; 97, identifier:data_copy; 98, block; 99, except_clause; 100, call; 101, identifier:k; 102, identifier:v; 103, attribute; 104, argument_list; 105, if_statement; 106, pair; 107, for_in_clause; 108, identifier:list; 109, argument_list; 110, identifier:items_without_dependencies; 111, call; 112, attribute; 113, argument_list; 114, identifier:data; 115, identifier:input_data; 116, expression_statement; 117, if_statement; 118, expression_statement; 119, expression_statement; 120, call; 121, integer:0; 122, raise_statement; 123, identifier:data; 124, identifier:data; 125, expression_statement; 126, identifier:TypeError; 127, block; 128, attribute; 129, argument_list; 130, identifier:input_data; 131, identifier:items; 132, comparison_operator:k in v; 133, block; 134, identifier:k; 135, call; 136, pattern_list; 137, call; 138, binary_operator:reduce(set.union, input_data.values()) - set(input_data.keys()); 139, identifier:find_items_without_dependencies; 140, argument_list; 141, identifier:data; 142, identifier:update; 143, dictionary_comprehension; 144, assignment; 145, not_operator; 146, block; 147, yield; 148, assignment; 149, identifier:len; 150, argument_list; 151, call; 152, assignment; 153, expression_statement; 154, identifier:result; 155, identifier:extend; 156, identifier:d; 157, identifier:k; 158, identifier:v; 159, raise_statement; 160, identifier:set; 161, argument_list; 162, identifier:k; 163, identifier:v; 164, attribute; 165, argument_list; 166, call; 167, call; 168, identifier:data; 169, pair; 170, for_in_clause; 171, identifier:ordered; 172, call; 173, identifier:ordered; 174, break_statement; 175, identifier:ordered; 176, identifier:data; 177, dictionary_comprehension; 178, identifier:data; 179, identifier:ValueError; 180, argument_list; 181, identifier:d; 182, call; 183, assignment; 184, call; 185, identifier:v; 186, identifier:input_data; 187, identifier:items; 188, identifier:reduce; 189, argument_list; 190, identifier:set; 191, argument_list; 192, identifier:item; 193, call; 194, identifier:item; 195, identifier:items_without_dependencies; 196, identifier:set; 197, generator_expression; 198, pair; 199, for_in_clause; 200, if_clause; 201, call; 202, identifier:sorted; 203, argument_list; 204, identifier:d; 205, call; 206, identifier:ValueError; 207, argument_list; 208, attribute; 209, call; 210, call; 211, identifier:set; 212, argument_list; 213, identifier:item; 214, for_in_clause; 215, if_clause; 216, identifier:item; 217, parenthesized_expression; 218, pattern_list; 219, call; 220, comparison_operator:item not in ordered; 221, attribute; 222, argument_list; 223, identifier:d; 224, identifier:list; 225, argument_list; 226, call; 227, identifier:set; 228, identifier:union; 229, attribute; 230, argument_list; 231, attribute; 232, argument_list; 233, pattern_list; 234, call; 235, comparison_operator:len(dep) == 0; 236, binary_operator:dep - ordered; 237, identifier:item; 238, identifier:dep; 239, attribute; 240, argument_list; 241, identifier:item; 242, identifier:ordered; 243, concatenated_string; 244, identifier:format; 245, call; 246, identifier:d; 247, attribute; 248, argument_list; 249, identifier:input_data; 250, identifier:values; 251, identifier:input_data; 252, identifier:keys; 253, identifier:item; 254, identifier:dep; 255, attribute; 256, argument_list; 257, call; 258, integer:0; 259, identifier:dep; 260, identifier:ordered; 261, identifier:data; 262, identifier:items; 263, string; 264, string; 265, attribute; 266, generator_expression; 267, string; 268, identifier:format; 269, identifier:k; 270, identifier:data; 271, identifier:items; 272, identifier:len; 273, argument_list; 274, string_content:Cyclic dependencies exist; 275, string_content:among these items: {}; 276, string; 277, identifier:join; 278, call; 279, for_in_clause; 280, string_content:Self-dependency, {} depends on itself.; 281, identifier:dep; 282, string_content:,; 283, identifier:repr; 284, argument_list; 285, identifier:x; 286, call; 287, identifier:x; 288, attribute; 289, argument_list; 290, identifier:data; 291, identifier:items | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 6, 19; 7, 20; 7, 21; 7, 22; 8, 23; 8, 24; 8, 25; 9, 26; 9, 27; 9, 28; 10, 29; 10, 30; 10, 31; 11, 32; 11, 33; 11, 34; 12, 35; 13, 36; 13, 37; 14, 38; 15, 39; 16, 40; 17, 41; 17, 42; 17, 43; 18, 44; 21, 45; 22, 46; 22, 47; 24, 48; 25, 49; 25, 50; 27, 51; 28, 52; 28, 53; 30, 54; 31, 55; 31, 56; 33, 57; 34, 58; 34, 59; 34, 60; 35, 61; 35, 62; 36, 63; 37, 64; 38, 65; 38, 66; 39, 67; 39, 68; 40, 69; 40, 70; 42, 71; 42, 72; 43, 73; 43, 74; 46, 75; 47, 76; 47, 77; 47, 78; 49, 79; 50, 80; 52, 81; 53, 82; 55, 83; 56, 84; 58, 85; 59, 86; 59, 87; 60, 88; 60, 89; 62, 90; 63, 91; 63, 92; 64, 93; 66, 94; 66, 95; 68, 96; 72, 97; 73, 98; 73, 99; 74, 100; 76, 101; 76, 102; 77, 103; 77, 104; 78, 105; 80, 106; 80, 107; 82, 108; 82, 109; 83, 110; 83, 111; 84, 112; 84, 113; 85, 114; 85, 115; 87, 116; 87, 117; 87, 118; 87, 119; 88, 120; 88, 121; 89, 122; 92, 123; 95, 124; 98, 125; 99, 126; 99, 127; 100, 128; 100, 129; 103, 130; 103, 131; 105, 132; 105, 133; 106, 134; 106, 135; 107, 136; 107, 137; 109, 138; 111, 139; 111, 140; 112, 141; 112, 142; 113, 143; 116, 144; 117, 145; 117, 146; 118, 147; 119, 148; 120, 149; 120, 150; 122, 151; 125, 152; 127, 153; 128, 154; 128, 155; 129, 156; 132, 157; 132, 158; 133, 159; 135, 160; 135, 161; 136, 162; 136, 163; 137, 164; 137, 165; 138, 166; 138, 167; 140, 168; 143, 169; 143, 170; 144, 171; 144, 172; 145, 173; 146, 174; 147, 175; 148, 176; 148, 177; 150, 178; 151, 179; 151, 180; 152, 181; 152, 182; 153, 183; 159, 184; 161, 185; 164, 186; 164, 187; 166, 188; 166, 189; 167, 190; 167, 191; 169, 192; 169, 193; 170, 194; 170, 195; 172, 196; 172, 197; 177, 198; 177, 199; 177, 200; 180, 201; 182, 202; 182, 203; 183, 204; 183, 205; 184, 206; 184, 207; 189, 208; 189, 209; 191, 210; 193, 211; 193, 212; 197, 213; 197, 214; 197, 215; 198, 216; 198, 217; 199, 218; 199, 219; 200, 220; 201, 221; 201, 222; 203, 223; 205, 224; 205, 225; 207, 226; 208, 227; 208, 228; 209, 229; 209, 230; 210, 231; 210, 232; 214, 233; 214, 234; 215, 235; 217, 236; 218, 237; 218, 238; 219, 239; 219, 240; 220, 241; 220, 242; 221, 243; 221, 244; 222, 245; 225, 246; 226, 247; 226, 248; 229, 249; 229, 250; 231, 251; 231, 252; 233, 253; 233, 254; 234, 255; 234, 256; 235, 257; 235, 258; 236, 259; 236, 260; 239, 261; 239, 262; 243, 263; 243, 264; 245, 265; 245, 266; 247, 267; 247, 268; 248, 269; 255, 270; 255, 271; 257, 272; 257, 273; 263, 274; 264, 275; 265, 276; 265, 277; 266, 278; 266, 279; 267, 280; 273, 281; 276, 282; 278, 283; 278, 284; 279, 285; 279, 286; 284, 287; 286, 288; 286, 289; 288, 290; 288, 291 | def topological_sort(data):
"""Topological sort the given dictionary structure.
Args:
data (dict); dictionary structure where the value is a list of dependencies for that given key.
For example: ``{'a': (), 'b': ('a',)}``, where ``a`` depends on nothing and ``b`` depends on ``a``.
Returns:
tuple: the dependencies in constructor order
"""
def check_self_dependencies(input_data):
"""Check if there are self dependencies within a node.
Self dependencies are for example: ``{'a': ('a',)}``.
Args:
input_data (dict): the input data. Of a structure similar to {key: (list of values), ...}.
Raises:
ValueError: if there are indeed self dependencies
"""
for k, v in input_data.items():
if k in v:
raise ValueError('Self-dependency, {} depends on itself.'.format(k))
def prepare_input_data(input_data):
"""Prepares the input data by making sets of the dependencies. This automatically removes redundant items.
Args:
input_data (dict): the input data. Of a structure similar to {key: (list of values), ...}.
Returns:
dict: a copy of the input dict but with sets instead of lists for the dependencies.
"""
return {k: set(v) for k, v in input_data.items()}
def find_items_without_dependencies(input_data):
"""This searches the dependencies of all the items for items that have no dependencies.
For example, suppose the input is: ``{'a': ('b',)}``, then ``a`` depends on ``b`` and ``b`` depends on nothing.
This class returns ``(b,)`` in this example.
Args:
input_data (dict): the input data. Of a structure similar to {key: (list of values), ...}.
Returns:
list: the list of items without any dependency.
"""
return list(reduce(set.union, input_data.values()) - set(input_data.keys()))
def add_empty_dependencies(data):
items_without_dependencies = find_items_without_dependencies(data)
data.update({item: set() for item in items_without_dependencies})
def get_sorted(input_data):
data = input_data
while True:
ordered = set(item for item, dep in data.items() if len(dep) == 0)
if not ordered:
break
yield ordered
data = {item: (dep - ordered) for item, dep in data.items() if item not in ordered}
if len(data) != 0:
raise ValueError('Cyclic dependencies exist '
'among these items: {}'.format(', '.join(repr(x) for x in data.items())))
check_self_dependencies(data)
if not len(data):
return []
data_copy = prepare_input_data(data)
add_empty_dependencies(data_copy)
result = []
for d in get_sorted(data_copy):
try:
d = sorted(d)
except TypeError:
d = list(d)
result.extend(d)
return result |
0, module; 1, function_definition; 2, function_name:get_posts; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, function_definition; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, return_statement; 14, identifier:include_draft; 15, False; 16, identifier:filter_functions; 17, None; 18, comment:"""
Get all posts from filesystem.
:param include_draft: return draft posts or not
:param filter_functions: filter to apply BEFORE result being sorted
:return: an iterable of Post objects (the first is the latest post)
"""; 19, function_name:posts_generator; 20, parameters; 21, block; 22, assignment; 23, assignment; 24, assignment; 25, call; 26, identifier:path; 27, expression_statement; 28, if_statement; 29, identifier:posts_path; 30, call; 31, identifier:result; 32, call; 33, identifier:result; 34, call; 35, identifier:sorted; 36, argument_list; 37, comment:"""Loads valid posts one by one in the given path."""; 38, call; 39, block; 40, attribute; 41, argument_list; 42, identifier:filter; 43, argument_list; 44, attribute; 45, argument_list; 46, identifier:result; 47, keyword_argument; 48, keyword_argument; 49, attribute; 50, argument_list; 51, for_statement; 52, attribute; 53, identifier:join; 54, attribute; 55, string; 56, lambda; 57, call; 58, identifier:self; 59, identifier:_filter_result; 60, identifier:result; 61, identifier:filter_functions; 62, identifier:key; 63, lambda; 64, identifier:reverse; 65, True; 66, attribute; 67, identifier:isdir; 68, identifier:path; 69, identifier:file; 70, call; 71, block; 72, identifier:os; 73, identifier:path; 74, identifier:current_app; 75, identifier:instance_path; 76, string_content:posts; 77, lambda_parameters; 78, boolean_operator; 79, identifier:posts_generator; 80, argument_list; 81, lambda_parameters; 82, attribute; 83, identifier:os; 84, identifier:path; 85, attribute; 86, argument_list; 87, expression_statement; 88, expression_statement; 89, if_statement; 90, identifier:p; 91, identifier:include_draft; 92, not_operator; 93, identifier:posts_path; 94, identifier:p; 95, identifier:p; 96, identifier:created; 97, identifier:os; 98, identifier:listdir; 99, identifier:path; 100, assignment; 101, assignment; 102, boolean_operator; 103, comment:# the format is supported and the filename is valid,; 104, comment:# so load this post; 105, block; 106, attribute; 107, pattern_list; 108, call; 109, identifier:format_name; 110, call; 111, comparison_operator:format_name is not None; 112, call; 113, expression_statement; 114, expression_statement; 115, expression_statement; 116, expression_statement; 117, expression_statement; 118, expression_statement; 119, identifier:p; 120, identifier:is_draft; 121, identifier:filename; 122, identifier:ext; 123, attribute; 124, argument_list; 125, identifier:get_standard_format_name; 126, argument_list; 127, identifier:format_name; 128, None; 129, attribute; 130, argument_list; 131, assignment; 132, assignment; 133, assignment; 134, assignment; 135, assignment; 136, yield; 137, attribute; 138, identifier:splitext; 139, identifier:file; 140, subscript; 141, identifier:re; 142, identifier:match; 143, string; 144, identifier:filename; 145, identifier:post; 146, call; 147, attribute; 148, identifier:format_name; 149, pattern_list; 150, call; 151, attribute; 152, binary_operator:filename.replace('-', '/', 3) + '/'; 153, attribute; 154, binary_operator:'/post/' + post.rel_url; 155, identifier:post; 156, identifier:os; 157, identifier:path; 158, identifier:ext; 159, slice; 160, string_content:\d{4}-\d{2}-\d{2}-.+; 161, identifier:Post; 162, argument_list; 163, identifier:post; 164, identifier:format; 165, attribute; 166, attribute; 167, attribute; 168, argument_list; 169, identifier:post; 170, identifier:rel_url; 171, call; 172, string; 173, identifier:post; 174, identifier:unique_key; 175, string; 176, attribute; 177, integer:1; 178, identifier:post; 179, identifier:meta; 180, identifier:post; 181, identifier:raw_content; 182, identifier:FileStorage; 183, identifier:read_file; 184, call; 185, attribute; 186, argument_list; 187, string_content:/; 188, string_content:/post/; 189, identifier:post; 190, identifier:rel_url; 191, attribute; 192, argument_list; 193, identifier:filename; 194, identifier:replace; 195, string; 196, string; 197, integer:3; 198, attribute; 199, identifier:join; 200, identifier:path; 201, identifier:file; 202, string_content:-; 203, string_content:/; 204, identifier:os; 205, identifier:path | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 6, 14; 6, 15; 7, 16; 7, 17; 8, 18; 9, 19; 9, 20; 9, 21; 10, 22; 11, 23; 12, 24; 13, 25; 20, 26; 21, 27; 21, 28; 22, 29; 22, 30; 23, 31; 23, 32; 24, 33; 24, 34; 25, 35; 25, 36; 27, 37; 28, 38; 28, 39; 30, 40; 30, 41; 32, 42; 32, 43; 34, 44; 34, 45; 36, 46; 36, 47; 36, 48; 38, 49; 38, 50; 39, 51; 40, 52; 40, 53; 41, 54; 41, 55; 43, 56; 43, 57; 44, 58; 44, 59; 45, 60; 45, 61; 47, 62; 47, 63; 48, 64; 48, 65; 49, 66; 49, 67; 50, 68; 51, 69; 51, 70; 51, 71; 52, 72; 52, 73; 54, 74; 54, 75; 55, 76; 56, 77; 56, 78; 57, 79; 57, 80; 63, 81; 63, 82; 66, 83; 66, 84; 70, 85; 70, 86; 71, 87; 71, 88; 71, 89; 77, 90; 78, 91; 78, 92; 80, 93; 81, 94; 82, 95; 82, 96; 85, 97; 85, 98; 86, 99; 87, 100; 88, 101; 89, 102; 89, 103; 89, 104; 89, 105; 92, 106; 100, 107; 100, 108; 101, 109; 101, 110; 102, 111; 102, 112; 105, 113; 105, 114; 105, 115; 105, 116; 105, 117; 105, 118; 106, 119; 106, 120; 107, 121; 107, 122; 108, 123; 108, 124; 110, 125; 110, 126; 111, 127; 111, 128; 112, 129; 112, 130; 113, 131; 114, 132; 115, 133; 116, 134; 117, 135; 118, 136; 123, 137; 123, 138; 124, 139; 126, 140; 129, 141; 129, 142; 130, 143; 130, 144; 131, 145; 131, 146; 132, 147; 132, 148; 133, 149; 133, 150; 134, 151; 134, 152; 135, 153; 135, 154; 136, 155; 137, 156; 137, 157; 140, 158; 140, 159; 143, 160; 146, 161; 146, 162; 147, 163; 147, 164; 149, 165; 149, 166; 150, 167; 150, 168; 151, 169; 151, 170; 152, 171; 152, 172; 153, 173; 153, 174; 154, 175; 154, 176; 159, 177; 165, 178; 165, 179; 166, 180; 166, 181; 167, 182; 167, 183; 168, 184; 171, 185; 171, 186; 172, 187; 175, 188; 176, 189; 176, 190; 184, 191; 184, 192; 185, 193; 185, 194; 186, 195; 186, 196; 186, 197; 191, 198; 191, 199; 192, 200; 192, 201; 195, 202; 196, 203; 198, 204; 198, 205 | def get_posts(self, include_draft=False, filter_functions=None):
"""
Get all posts from filesystem.
:param include_draft: return draft posts or not
:param filter_functions: filter to apply BEFORE result being sorted
:return: an iterable of Post objects (the first is the latest post)
"""
def posts_generator(path):
"""Loads valid posts one by one in the given path."""
if os.path.isdir(path):
for file in os.listdir(path):
filename, ext = os.path.splitext(file)
format_name = get_standard_format_name(ext[1:])
if format_name is not None and re.match(
r'\d{4}-\d{2}-\d{2}-.+', filename):
# the format is supported and the filename is valid,
# so load this post
post = Post()
post.format = format_name
post.meta, post.raw_content = FileStorage.read_file(
os.path.join(path, file))
post.rel_url = filename.replace('-', '/', 3) + '/'
post.unique_key = '/post/' + post.rel_url
yield post
posts_path = os.path.join(current_app.instance_path, 'posts')
result = filter(lambda p: include_draft or not p.is_draft,
posts_generator(posts_path))
result = self._filter_result(result, filter_functions)
return sorted(result, key=lambda p: p.created, reverse=True) |
0, module; 1, function_definition; 2, function_name:arbitrary_object_to_string; 3, parameters; 4, block; 5, identifier:a_thing; 6, expression_statement; 7, comment:# is it None?; 8, if_statement; 9, comment:# is it already a string?; 10, if_statement; 11, if_statement; 12, comment:# does it have a to_str function?; 13, try_statement; 14, comment:# is this a type proxy?; 15, try_statement; 16, comment:# is it a built in?; 17, try_statement; 18, comment:# is it something from a loaded module?; 19, try_statement; 20, comment:# maybe it has a __name__ attribute?; 21, try_statement; 22, comment:# punt and see what happens if we just cast it to string; 23, return_statement; 24, comment:"""take a python object of some sort, and convert it into a human readable
string. this function is used extensively to convert things like "subject"
into "subject_key, function -> function_key, etc."""; 25, comparison_operator:a_thing is None; 26, block; 27, call; 28, block; 29, boolean_operator; 30, block; 31, block; 32, except_clause; 33, block; 34, except_clause; 35, block; 36, except_clause; 37, block; 38, except_clause; 39, block; 40, except_clause; 41, call; 42, identifier:a_thing; 43, None; 44, return_statement; 45, identifier:isinstance; 46, argument_list; 47, return_statement; 48, attribute; 49, call; 50, try_statement; 51, return_statement; 52, tuple; 53, comment:# AttributeError - no to_str function?; 54, comment:# KeyError - DotDict has no to_str?; 55, comment:# TypeError - problem converting; 56, comment:# nope, no to_str function; 57, block; 58, return_statement; 59, tuple; 60, comment:#; 61, comment:# nope, no a_type property; 62, block; 63, return_statement; 64, tuple; 65, comment:# nope, not a builtin; 66, block; 67, if_statement; 68, identifier:AttributeError; 69, comment:# nope, not one of these; 70, block; 71, return_statement; 72, identifier:AttributeError; 73, comment:# nope, not one of these; 74, block; 75, identifier:str; 76, argument_list; 77, string; 78, identifier:a_thing; 79, attribute; 80, identifier:a_thing; 81, identifier:six; 82, identifier:PY3; 83, identifier:isinstance; 84, argument_list; 85, block; 86, except_clause; 87, call; 88, identifier:AttributeError; 89, identifier:KeyError; 90, identifier:TypeError; 91, pass_statement; 92, call; 93, identifier:AttributeError; 94, identifier:KeyError; 95, identifier:TypeError; 96, pass_statement; 97, subscript; 98, identifier:KeyError; 99, identifier:TypeError; 100, pass_statement; 101, comparison_operator:a_thing.__module__ not in ('__builtin__', 'builtins', 'exceptions'); 102, block; 103, pass_statement; 104, attribute; 105, pass_statement; 106, identifier:a_thing; 107, identifier:six; 108, identifier:string_types; 109, identifier:a_thing; 110, attribute; 111, return_statement; 112, identifier:UnicodeDecodeError; 113, block; 114, attribute; 115, argument_list; 116, identifier:arbitrary_object_to_string; 117, argument_list; 118, identifier:known_mapping_type_to_str; 119, identifier:a_thing; 120, attribute; 121, tuple; 122, if_statement; 123, return_statement; 124, identifier:a_thing; 125, identifier:__name__; 126, identifier:six; 127, identifier:binary_type; 128, call; 129, pass_statement; 130, identifier:a_thing; 131, identifier:to_str; 132, attribute; 133, identifier:a_thing; 134, identifier:__module__; 135, string; 136, string; 137, string; 138, comparison_operator:a_thing.__module__ == "__main__"; 139, block; 140, else_clause; 141, binary_operator:"%s.%s" % (module_name, a_thing.__name__); 142, attribute; 143, argument_list; 144, identifier:a_thing; 145, identifier:a_type; 146, string_content:__builtin__; 147, string_content:builtins; 148, string_content:exceptions; 149, attribute; 150, string:"__main__"; 151, expression_statement; 152, block; 153, string:"%s.%s"; 154, tuple; 155, identifier:a_thing; 156, identifier:decode; 157, string; 158, identifier:a_thing; 159, identifier:__module__; 160, assignment; 161, expression_statement; 162, identifier:module_name; 163, attribute; 164, string_content:utf-8; 165, identifier:module_name; 166, parenthesized_expression; 167, assignment; 168, identifier:a_thing; 169, identifier:__name__; 170, call; 171, identifier:module_name; 172, attribute; 173, attribute; 174, argument_list; 175, identifier:a_thing; 176, identifier:__module__; 177, call; 178, identifier:strip; 179, string; 180, attribute; 181, argument_list; 182, string_content:.; 183, subscript; 184, identifier:replace; 185, string; 186, string; 187, attribute; 188, slice; 189, string_content:/; 190, string_content:.; 191, subscript; 192, identifier:__file__; 193, unary_operator; 194, attribute; 195, string; 196, integer:3; 197, identifier:sys; 198, identifier:modules; 199, string_content:__main__ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 6, 24; 8, 25; 8, 26; 10, 27; 10, 28; 11, 29; 11, 30; 13, 31; 13, 32; 15, 33; 15, 34; 17, 35; 17, 36; 19, 37; 19, 38; 21, 39; 21, 40; 23, 41; 25, 42; 25, 43; 26, 44; 27, 45; 27, 46; 28, 47; 29, 48; 29, 49; 30, 50; 31, 51; 32, 52; 32, 53; 32, 54; 32, 55; 32, 56; 32, 57; 33, 58; 34, 59; 34, 60; 34, 61; 34, 62; 35, 63; 36, 64; 36, 65; 36, 66; 37, 67; 38, 68; 38, 69; 38, 70; 39, 71; 40, 72; 40, 73; 40, 74; 41, 75; 41, 76; 44, 77; 46, 78; 46, 79; 47, 80; 48, 81; 48, 82; 49, 83; 49, 84; 50, 85; 50, 86; 51, 87; 52, 88; 52, 89; 52, 90; 57, 91; 58, 92; 59, 93; 59, 94; 59, 95; 62, 96; 63, 97; 64, 98; 64, 99; 66, 100; 67, 101; 67, 102; 70, 103; 71, 104; 74, 105; 76, 106; 79, 107; 79, 108; 84, 109; 84, 110; 85, 111; 86, 112; 86, 113; 87, 114; 87, 115; 92, 116; 92, 117; 97, 118; 97, 119; 101, 120; 101, 121; 102, 122; 102, 123; 104, 124; 104, 125; 110, 126; 110, 127; 111, 128; 113, 129; 114, 130; 114, 131; 117, 132; 120, 133; 120, 134; 121, 135; 121, 136; 121, 137; 122, 138; 122, 139; 122, 140; 123, 141; 128, 142; 128, 143; 132, 144; 132, 145; 135, 146; 136, 147; 137, 148; 138, 149; 138, 150; 139, 151; 140, 152; 141, 153; 141, 154; 142, 155; 142, 156; 143, 157; 149, 158; 149, 159; 151, 160; 152, 161; 154, 162; 154, 163; 157, 164; 160, 165; 160, 166; 161, 167; 163, 168; 163, 169; 166, 170; 167, 171; 167, 172; 170, 173; 170, 174; 172, 175; 172, 176; 173, 177; 173, 178; 174, 179; 177, 180; 177, 181; 179, 182; 180, 183; 180, 184; 181, 185; 181, 186; 183, 187; 183, 188; 185, 189; 186, 190; 187, 191; 187, 192; 188, 193; 191, 194; 191, 195; 193, 196; 194, 197; 194, 198; 195, 199 | def arbitrary_object_to_string(a_thing):
"""take a python object of some sort, and convert it into a human readable
string. this function is used extensively to convert things like "subject"
into "subject_key, function -> function_key, etc."""
# is it None?
if a_thing is None:
return ''
# is it already a string?
if isinstance(a_thing, six.string_types):
return a_thing
if six.PY3 and isinstance(a_thing, six.binary_type):
try:
return a_thing.decode('utf-8')
except UnicodeDecodeError:
pass
# does it have a to_str function?
try:
return a_thing.to_str()
except (AttributeError, KeyError, TypeError):
# AttributeError - no to_str function?
# KeyError - DotDict has no to_str?
# TypeError - problem converting
# nope, no to_str function
pass
# is this a type proxy?
try:
return arbitrary_object_to_string(a_thing.a_type)
except (AttributeError, KeyError, TypeError):
#
# nope, no a_type property
pass
# is it a built in?
try:
return known_mapping_type_to_str[a_thing]
except (KeyError, TypeError):
# nope, not a builtin
pass
# is it something from a loaded module?
try:
if a_thing.__module__ not in ('__builtin__', 'builtins', 'exceptions'):
if a_thing.__module__ == "__main__":
module_name = (
sys.modules['__main__']
.__file__[:-3]
.replace('/', '.')
.strip('.')
)
else:
module_name = a_thing.__module__
return "%s.%s" % (module_name, a_thing.__name__)
except AttributeError:
# nope, not one of these
pass
# maybe it has a __name__ attribute?
try:
return a_thing.__name__
except AttributeError:
# nope, not one of these
pass
# punt and see what happens if we just cast it to string
return str(a_thing) |
0, module; 1, function_definition; 2, function_name:add_parser; 3, parameters; 4, block; 5, identifier:self; 6, list_splat_pattern; 7, dictionary_splat_pattern; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, return_statement; 17, identifier:args; 18, identifier:kwargs; 19, comment:"""each time a subparser action is used to create a new parser object
we must save the original args & kwargs. In a later phase of
configman, we'll need to reproduce the subparsers exactly without
resorting to copying. We save the args & kwargs in the 'foreign_data'
section of the configman option that corresponds with the subparser
action."""; 20, assignment; 21, assignment; 22, assignment; 23, assignment; 24, assignment; 25, assignment; 26, assignment; 27, identifier:a_subparser; 28, identifier:command_name; 29, subscript; 30, identifier:new_kwargs; 31, call; 32, subscript; 33, attribute; 34, subscript; 35, identifier:command_name; 36, identifier:subparsers; 37, attribute; 38, identifier:a_subparser; 39, call; 40, subscript; 41, call; 42, identifier:args; 43, integer:0; 44, attribute; 45, argument_list; 46, identifier:new_kwargs; 47, string; 48, identifier:self; 49, identifier:_configman_option; 50, identifier:new_kwargs; 51, string; 52, attribute; 53, identifier:subparsers; 54, attribute; 55, argument_list; 56, identifier:subparsers; 57, identifier:command_name; 58, identifier:DotDict; 59, argument_list; 60, identifier:kwargs; 61, identifier:copy; 62, string_content:configman_subparsers_option; 63, string_content:subparser_name; 64, attribute; 65, identifier:argparse; 66, call; 67, identifier:add_parser; 68, list_splat; 69, dictionary_splat; 70, dictionary; 71, attribute; 72, identifier:foreign_data; 73, identifier:super; 74, argument_list; 75, identifier:args; 76, identifier:new_kwargs; 77, pair; 78, pair; 79, pair; 80, identifier:self; 81, identifier:_configman_option; 82, identifier:ConfigmanSubParsersAction; 83, identifier:self; 84, string:"args"; 85, identifier:args; 86, string:"kwargs"; 87, identifier:new_kwargs; 88, string:"subparser"; 89, identifier:a_subparser | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 6, 17; 7, 18; 8, 19; 9, 20; 10, 21; 11, 22; 12, 23; 13, 24; 14, 25; 15, 26; 16, 27; 20, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 23, 34; 23, 35; 24, 36; 24, 37; 25, 38; 25, 39; 26, 40; 26, 41; 29, 42; 29, 43; 31, 44; 31, 45; 32, 46; 32, 47; 33, 48; 33, 49; 34, 50; 34, 51; 37, 52; 37, 53; 39, 54; 39, 55; 40, 56; 40, 57; 41, 58; 41, 59; 44, 60; 44, 61; 47, 62; 51, 63; 52, 64; 52, 65; 54, 66; 54, 67; 55, 68; 55, 69; 59, 70; 64, 71; 64, 72; 66, 73; 66, 74; 68, 75; 69, 76; 70, 77; 70, 78; 70, 79; 71, 80; 71, 81; 74, 82; 74, 83; 77, 84; 77, 85; 78, 86; 78, 87; 79, 88; 79, 89 | def add_parser(self, *args, **kwargs):
"""each time a subparser action is used to create a new parser object
we must save the original args & kwargs. In a later phase of
configman, we'll need to reproduce the subparsers exactly without
resorting to copying. We save the args & kwargs in the 'foreign_data'
section of the configman option that corresponds with the subparser
action."""
command_name = args[0]
new_kwargs = kwargs.copy()
new_kwargs['configman_subparsers_option'] = self._configman_option
new_kwargs['subparser_name'] = command_name
subparsers = self._configman_option.foreign_data.argparse.subparsers
a_subparser = super(ConfigmanSubParsersAction, self).add_parser(
*args,
**new_kwargs
)
subparsers[command_name] = DotDict({
"args": args,
"kwargs": new_kwargs,
"subparser": a_subparser
})
return a_subparser |
0, module; 1, function_definition; 2, function_name:_parse_and_sort_accept_header; 3, parameters; 4, block; 5, identifier:accept_header; 6, expression_statement; 7, return_statement; 8, comment:"""Parse and sort the accept header items.
>>> _parse_and_sort_accept_header('application/json;q=0.5, text/*')
[('text/*', 1.0), ('application/json', 0.5)]
"""; 9, call; 10, identifier:sorted; 11, argument_list; 12, list_comprehension; 13, keyword_argument; 14, keyword_argument; 15, call; 16, for_in_clause; 17, identifier:key; 18, lambda; 19, identifier:reverse; 20, True; 21, identifier:_split_into_mimetype_and_priority; 22, argument_list; 23, identifier:x; 24, call; 25, lambda_parameters; 26, subscript; 27, identifier:x; 28, attribute; 29, argument_list; 30, identifier:x; 31, identifier:x; 32, integer:1; 33, identifier:accept_header; 34, identifier:split; 35, string; 36, string_content:, | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 9, 10; 9, 11; 11, 12; 11, 13; 11, 14; 12, 15; 12, 16; 13, 17; 13, 18; 14, 19; 14, 20; 15, 21; 15, 22; 16, 23; 16, 24; 18, 25; 18, 26; 22, 27; 24, 28; 24, 29; 25, 30; 26, 31; 26, 32; 28, 33; 28, 34; 29, 35; 35, 36 | def _parse_and_sort_accept_header(accept_header):
"""Parse and sort the accept header items.
>>> _parse_and_sort_accept_header('application/json;q=0.5, text/*')
[('text/*', 1.0), ('application/json', 0.5)]
"""
return sorted([_split_into_mimetype_and_priority(x) for x in accept_header.split(',')],
key=lambda x: x[1], reverse=True) |
0, module; 1, function_definition; 2, function_name:sort_name; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, if_statement; 8, return_statement; 9, comment:""" Get the sorting name of this category """; 10, boolean_operator; 11, block; 12, attribute; 13, attribute; 14, attribute; 15, return_statement; 16, identifier:self; 17, identifier:name; 18, identifier:self; 19, identifier:_record; 20, attribute; 21, identifier:sort_name; 22, attribute; 23, identifier:self; 24, identifier:_record; 25, attribute; 26, identifier:sort_name; 27, identifier:self; 28, identifier:_record | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 7, 11; 8, 12; 10, 13; 10, 14; 11, 15; 12, 16; 12, 17; 13, 18; 13, 19; 14, 20; 14, 21; 15, 22; 20, 23; 20, 24; 22, 25; 22, 26; 25, 27; 25, 28 | def sort_name(self):
""" Get the sorting name of this category """
if self._record and self._record.sort_name:
return self._record.sort_name
return self.name |
Subsets and Splits