src
stringlengths 75
47.4k
| cfg
stringlengths 32
2.5k
| ast
stringlengths 78
54.9k
|
|---|---|---|
def _normalize_joliet_path(self, joliet_path):
# type: (str) -> bytes
'''
An internal method to check whether this ISO does or does not require
a Joliet path. If a Joliet path is required, the path is normalized
and returned.
Parameters:
joliet_path - The joliet_path to normalize (if necessary).
Returns:
The normalized joliet_path if this ISO has Joliet, None otherwise.
'''
tmp_path = b''
if self.joliet_vd is not None:
if not joliet_path:
raise pycdlibexception.PyCdlibInvalidInput('A Joliet path must be passed for a Joliet ISO')
tmp_path = utils.normpath(joliet_path)
else:
if joliet_path:
raise pycdlibexception.PyCdlibInvalidInput('A Joliet path can only be specified for a Joliet ISO')
return tmp_path | [2][SEP1][If][If][If][None][None][None][Return][SEP2][1,2][3,4][5,6][][6][][][SEP3][1][0][0][1][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT IF UNARYOP NOT NAME LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF NAME LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT RETURN NAME LOAD |
def add_file(self, filename, iso_path, rr_name=None, joliet_path=None,
file_mode=None, udf_path=None):
# type: (Any, str, Optional[str], str, Optional[int], Optional[str]) -> None
'''
Add a file to the ISO. If the ISO is a Rock Ridge one, then a Rock
Ridge name must also be provided. If the ISO is a Joliet one, then a
Joliet path may also be provided; while it is optional to do so, it is
highly recommended.
Parameters:
filename - The filename to use for the data contents for the new file.
iso_path - The ISO9660 absolute path to the file destination on the ISO.
rr_name - The Rock Ridge name of the file destination on the ISO.
joliet_path - The Joliet absolute path to the file destination on the ISO.
file_mode - The POSIX file_mode to apply to this file. This only
applies if this is a Rock Ridge ISO. If this is None (the
default), the permissions from the original file are used.
udf_path - The UDF name of the file destination on the ISO.
Returns:
Nothing.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInvalidInput('This object is not yet initialized; call either open() or new() to create an ISO')
num_bytes_to_add = self._add_fp(filename, os.stat(filename).st_size,
True, iso_path, rr_name, joliet_path,
udf_path, file_mode, False)
self._finish_add(0, num_bytes_to_add) | [7][SEP1][If][None][None][SEP2][1,2][][][SEP3][0][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD |
def configuration_check(config):
"""Perform a sanity check on configuration.
First it performs a sanity check against settings for daemon
and then against settings for each service check.
Arguments:
config (obj): A configparser object which holds our configuration.
Returns:
None if all checks are successfully passed otherwise raises a
ValueError exception.
"""
log_level = config.get('daemon', 'loglevel')
num_level = getattr(logging, log_level.upper(), None)
pidfile = config.get('daemon', 'pidfile')
# Catch the case where the directory, under which we store the pid file, is
# missing.
if not os.path.isdir(os.path.dirname(pidfile)):
raise ValueError("{d} doesn't exit".format(d=os.path.dirname(pidfile)))
if not isinstance(num_level, int):
raise ValueError('Invalid log level: {}'.format(log_level))
for _file in 'log_file', 'stderr_file':
if config.has_option('daemon', _file):
try:
touch(config.get('daemon', _file))
except OSError as exc:
raise ValueError(exc)
for option, getter in DAEMON_OPTIONS_TYPE.items():
try:
getattr(config, getter)('daemon', option)
except configparser.NoOptionError as error:
if option not in DAEMON_OPTIONAL_OPTIONS:
raise ValueError(error)
except configparser.Error as error:
raise ValueError(error)
except ValueError as exc:
msg = ("invalid data for '{opt}' option in daemon section: {err}"
.format(opt=option, err=exc))
raise ValueError(msg)
service_configuration_check(config) | [1][SEP1][If][None][If][None][For][If][For][Try][Try][None][None][None][None][If][None][None][None][SEP2][1,2][][3,4][][5,6][7,4][8,9][10,11][12,13,14,15][][4][][6][16,6][][][][SEP3][6][3][1][2][0][1][1][0][0][1][2][1][1][0][1][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT IF UNARYOP NOT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD KEYWORD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD IF UNARYOP NOT CALL NAME LOAD NAME LOAD NAME LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD NAME LOAD FOR NAME STORE TUPLE CONSTANT CONSTANT LOAD IF CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD TRY EXPR CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD EXCEPTHANDLER NAME LOAD RAISE CALL NAME LOAD NAME LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD TRY EXPR CALL CALL NAME LOAD NAME LOAD NAME LOAD CONSTANT NAME LOAD EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD NOTIN NAME LOAD RAISE CALL NAME LOAD NAME LOAD EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD NAME LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD RAISE CALL NAME LOAD NAME LOAD EXPR CALL NAME LOAD NAME LOAD |
def main():
"""The main command-line entry point, with system interactions.
"""
argv = sys.argv[1:]
returncode = 1
try:
returncode = _main(os.environ, argv)
except exceptions.InvalidArgument as error:
if error.message:
sys.stderr.write("Error: " + error.message + '\n')
else:
raise
sys.exit(returncode) | [0][SEP1][Try][None][If][None][None][None][SEP2][1,2][3][4,5][][3][][SEP3][0][1][0][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS EXPR CONSTANT ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD SLICE CONSTANT LOAD ASSIGN NAME STORE CONSTANT TRY ASSIGN NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD BINOP BINOP CONSTANT ADD ATTRIBUTE NAME LOAD LOAD ADD CONSTANT RAISE EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def piece_size(self):
"""
Piece size/length or ``None``
If set to ``None``, :attr:`calculate_piece_size` is called.
If :attr:`size` returns ``None``, this also returns ``None``.
Setting this property sets ``piece length`` in :attr:`metainfo`\
``['info']``.
"""
if 'piece length' not in self.metainfo['info']:
if self.size is None:
return None
else:
self.calculate_piece_size()
return self.metainfo['info']['piece length'] | [1][SEP1][If][If][Return][Return][None][SEP2][1,2][3,4][][][2][SEP3][0][0][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF COMPARE CONSTANT NOTIN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT RETURN CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD RETURN SUBSCRIPT SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD CONSTANT LOAD |
def key_exists_in_list_or_dict(key, lst_or_dct):
"""True if `lst_or_dct[key]` does not raise an Exception"""
if isinstance(lst_or_dct, dict) and key in lst_or_dct:
return True
elif isinstance(lst_or_dct, list):
min_i, max_i = 0, len(lst_or_dct)
if min_i <= key < max_i:
return True
return False | [2][SEP1][If][Return][If][If][Return][Return][SEP2][1,2][][3,4][5,4][][][SEP3][1][0][1][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF BOOLOP AND CALL NAME LOAD NAME LOAD NAME LOAD COMPARE NAME LOAD IN NAME LOAD RETURN CONSTANT IF CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN TUPLE NAME STORE NAME STORE STORE TUPLE CONSTANT CALL NAME LOAD NAME LOAD LOAD IF COMPARE NAME LOAD LTE LT NAME LOAD NAME LOAD RETURN CONSTANT RETURN CONSTANT |
def task_status(self, task_id):
"""Find the status of a task."""
data = {
'task_ids': task_id,
}
return self._perform_post_request(self.task_status_endpoint, data, self.token_header) | [2][SEP1][Return][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE DICT CONSTANT NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD |
def get_current_url(request, ignore_params=None):
"""
Giving a django request, return the current http url, possibly ignoring some GET parameters
:param django.http.HttpRequest request: The current request object.
:param set ignore_params: An optional set of GET parameters to ignore
:return: The URL of the current page, possibly omitting some parameters from
``ignore_params`` in the querystring.
:rtype: unicode
"""
if ignore_params is None:
ignore_params = set()
protocol = u'https' if request.is_secure() else u"http"
service_url = u"%s://%s%s" % (protocol, request.get_host(), request.path)
if request.GET:
params = copy_params(request.GET, ignore_params)
if params:
service_url += u"?%s" % urlencode(params)
return service_url | [2][SEP1][If][None][If][If][Return][None][SEP2][1,2][2][3,4][5,4][][4][SEP3][0][1][2][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE CALL NAME LOAD ASSIGN NAME STORE IFEXP CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT ASSIGN NAME STORE BINOP CONSTANT MOD TUPLE NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD IF NAME LOAD AUGASSIGN NAME STORE ADD BINOP CONSTANT MOD CALL NAME LOAD NAME LOAD RETURN NAME LOAD |
def post(self, request, provider=None):
"""
method called on POST request
:param django.http.HttpRequest request: The current request object
:param unicode provider: Optional parameter. The user provider suffix.
"""
# if settings.CAS_FEDERATE is not True redirect to the login page
if not settings.CAS_FEDERATE:
logger.warning("CAS_FEDERATE is False, set it to True to use federation")
return redirect("cas_server:login")
# POST with a provider suffix, this is probably an SLO request. csrf is disabled for
# allowing SLO requests reception
try:
provider = FederatedIendityProvider.objects.get(suffix=provider)
auth = self.get_cas_client(request, provider)
try:
auth.clean_sessions(request.POST['logoutRequest'])
except (KeyError, AttributeError):
pass
return HttpResponse("ok")
# else, a User is trying to log in using an identity provider
except FederatedIendityProvider.DoesNotExist:
# Manually checking for csrf to protect the code below
reason = CsrfViewMiddleware().process_view(request, None, (), {})
if reason is not None: # pragma: no cover (csrf checks are disabled during tests)
return reason # Failed the test, stop here.
form = forms.FederateSelect(request.POST)
if form.is_valid():
params = utils.copy_params(
request.POST,
ignore={"provider", "csrfmiddlewaretoken", "ticket", "lt"}
)
if params.get("renew") == "False":
del params["renew"]
url = utils.reverse_params(
"cas_server:federateAuth",
kwargs=dict(provider=form.cleaned_data["provider"].suffix),
params=params
)
return HttpResponseRedirect(url)
else:
return redirect("cas_server:login") | [3][SEP1][If][Return][Try][Try][If][None][None][Return][If][Return][If][Return][None][Return][SEP2][1,2][][3,4][5,6][7,8][9][9][][10,11][][12,13][][13][][SEP3][0][2][9][2][2][1][0][0][5][1][2][1][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT RETURN CALL NAME LOAD CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD TRY EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD EXCEPTHANDLER TUPLE NAME LOAD NAME LOAD LOAD PASS RETURN CALL NAME LOAD CONSTANT EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE CALL NAME LOAD LOAD NAME LOAD CONSTANT TUPLE LOAD DICT IF COMPARE NAME LOAD ISNOT CONSTANT RETURN NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD KEYWORD SET CONSTANT CONSTANT CONSTANT CONSTANT IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EQ CONSTANT DELETE SUBSCRIPT NAME LOAD CONSTANT DEL ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT KEYWORD CALL NAME LOAD KEYWORD ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD KEYWORD NAME LOAD RETURN CALL NAME LOAD NAME LOAD RETURN CALL NAME LOAD CONSTANT |
def validate_object(obj, field_validators=None, non_field_validators=None,
schema=None, context=None):
"""
Takes a mapping and applies a mapping of validator functions to it
collecting and reraising any validation errors that occur.
"""
if schema is None:
schema = {}
if context is None:
context = {}
if field_validators is None:
field_validators = ValidationDict()
if non_field_validators is None:
non_field_validators = ValidationList()
from flex.validation.schema import (
construct_schema_validators,
)
schema_validators = construct_schema_validators(schema, context)
if '$ref' in schema_validators and hasattr(schema_validators['$ref'], 'validators'):
ref_ = field_validators.pop('$ref')
for k, v in ref_.validators.items():
if k not in schema_validators:
schema_validators.add_validator(k, v)
if 'discriminator' in schema:
schema_validators = add_polymorphism_requirements(obj, schema, context, schema_validators)
# delete resolved discriminator to avoid infinite recursion
del schema['discriminator']
schema_validators.update(field_validators)
schema_validators.validate_object(obj, context=context)
non_field_validators.validate_object(obj, context=context)
return obj | [5][SEP1][If][None][If][None][If][None][If][None][If][None][If][For][None][Return][If][None][SEP2][1,2][2][3,4][4][5,6][6][7,8][8][9,10][11][12,13][14,10][13][][15,11][11][SEP3][0][0][0][0][0][1][0][1][4][1][0][1][1][3][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE DICT IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE DICT IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE CALL NAME LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE CALL NAME LOAD IMPORTFROM ALIAS ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD IF BOOLOP AND COMPARE CONSTANT IN NAME LOAD CALL NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE NAME LOAD NOTIN NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD IF COMPARE CONSTANT IN NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD DELETE SUBSCRIPT NAME LOAD CONSTANT DEL EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD NAME LOAD RETURN NAME LOAD |
def create_block(mc, block_id, subtype=None):
"""Build a block with the specified id and subtype under the player in the
Minecraft world. Subtype is optional and can be specified as None to use
the default subtype for the block.
"""
# Get player tile position and real position.
ptx, pty, ptz = mc.player.getTilePos()
px, py, pz = mc.player.getPos()
# Create block at current player tile location.
if subtype is None:
mc.setBlock(ptx, pty, ptz, block_id)
else:
mc.setBlock(ptx, pty, ptz, block_id, subtype)
# Move the player's real positon up one block.
mc.player.setPos(px, py+1, pz) | [3][SEP1][If][None][None][None][SEP2][1,2][3][3][][SEP3][2][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN TUPLE NAME STORE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN TUPLE NAME STORE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE NAME LOAD IS CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD BINOP NAME LOAD ADD CONSTANT NAME LOAD |
def _create(self, postData) :
"""Creates an index of any type according to postData"""
if self.infos is None :
r = self.connection.session.post(self.indexesURL, params = {"collection" : self.collection.name}, data = json.dumps(postData, default=str))
data = r.json()
if (r.status_code >= 400) or data['error'] :
raise CreationError(data['errorMessage'], data)
self.infos = data | [2][SEP1][If][If][None][None][SEP2][1][2,3][][][SEP3][0][3][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD KEYWORD DICT CONSTANT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF BOOLOP OR COMPARE ATTRIBUTE NAME LOAD LOAD GTE CONSTANT SUBSCRIPT NAME LOAD CONSTANT LOAD RAISE CALL NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD |
def validatePrivate(self, field, value) :
"""validate a private field value"""
if field not in self.arangoPrivates :
raise ValueError("%s is not a private field of collection %s" % (field, self))
if field in self._fields :
self._fields[field].validate(value)
return True | [3][SEP1][If][None][If][None][Return][SEP2][1,2][][3,4][4][][SEP3][0][1][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT IF COMPARE NAME LOAD NOTIN ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD IF COMPARE NAME LOAD IN ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD LOAD NAME LOAD RETURN CONSTANT |
def reset(self, collection, jsonFieldInit = None) :
if not jsonFieldInit:
jsonFieldInit = {}
"""replaces the current values in the document by those in jsonFieldInit"""
self.collection = collection
self.connection = self.collection.connection
self.documentsURL = self.collection.documentsURL
self.URL = None
self.setPrivates(jsonFieldInit)
self._store = DocumentStore(self.collection, validators=self.collection._fields, initDct=jsonFieldInit)
if self.collection._validation['on_load']:
self.validate()
self.modified = True | [3][SEP1][If][None][If][None][None][SEP2][1,2][2][3,4][4][][SEP3][0][0][2][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE DICT EXPR CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD NAME LOAD IF SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT |
def filter(self):
'''
Filters exit the proccess if the event should not be handled.
Filtering events is deprecated and will be removed in a future release.
'''
if self.deprecated_filtering_enabled():
print('warning: event filtering in sensu-plugin is deprecated,' +
'see http://bit.ly/sensu-plugin')
self.filter_disabled()
self.filter_silenced()
self.filter_dependencies()
if self.deprecated_occurrence_filtering():
print('warning: occurrence filtering in sensu-plugin is' +
'deprecated, see http://bit.ly/sensu-plugin')
self.filter_repeated() | [1][SEP1][If][If][None][SEP2][1][2][][SEP3][1][5][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL NAME LOAD BINOP CONSTANT ADD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD IF CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL NAME LOAD BINOP CONSTANT ADD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD |
def create(cls, path_name=None, name=None, crawlable=True):
"""initialize an instance and save it to db."""
project = cls(path_name, name, crawlable)
db.session.add(project)
db.session.commit()
return collect_results(project, force=True) | [4][SEP1][Return][SEP2][][SEP3][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD RETURN CALL NAME LOAD NAME LOAD KEYWORD CONSTANT |
def _path_insensitive(path):
"""
Recursive part of path_insensitive to do the work.
"""
path = str(path)
if path == '' or os.path.exists(path):
return path
base = os.path.basename(path) # may be a directory or a file
dirname = os.path.dirname(path)
suffix = ''
if not base: # dir ends with a slash?
if len(dirname) < len(path):
suffix = path[:len(path) - len(dirname)]
base = os.path.basename(dirname)
dirname = os.path.dirname(dirname)
if not os.path.exists(dirname):
dirname = _path_insensitive(dirname)
if not dirname:
return
# at this point, the directory exists but not the file
try: # we are expecting dirname to be a directory, but it could be a file
files = os.listdir(dirname)
except OSError:
return
baselow = base.lower()
try:
basefinal = next(fl for fl in files if fl.lower() == baselow)
except StopIteration:
return
if basefinal:
return os.path.join(dirname, basefinal) + suffix
else:
return | [1][SEP1][If][Return][If][If][If][None][None][If][Try][Return][None][Return][Try][None][Return][If][Return][Return][SEP2][1,2][][3,4][5,6][7,8][6][4][9,8][10,11][][12][][13,14][15][][16,17][][][SEP3][2][0][4][2][1][2][2][1][0][0][1][0][1][2][0][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF BOOLOP OR COMPARE NAME LOAD EQ CONSTANT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD RETURN NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CONSTANT IF UNARYOP NOT NAME LOAD IF COMPARE CALL NAME LOAD NAME LOAD LT CALL NAME LOAD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE BINOP CALL NAME LOAD NAME LOAD SUB CALL NAME LOAD NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD IF UNARYOP NOT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF UNARYOP NOT NAME LOAD RETURN TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXCEPTHANDLER NAME LOAD RETURN ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD TRY ASSIGN NAME STORE CALL NAME LOAD GENERATOREXP NAME LOAD COMPREHENSION NAME STORE NAME LOAD COMPARE CALL ATTRIBUTE NAME LOAD LOAD EQ NAME LOAD EXCEPTHANDLER NAME LOAD RETURN IF NAME LOAD RETURN BINOP CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD ADD NAME LOAD RETURN |
def get_ser_val_alt(lat: float, lon: float,
da_alt_x: xr.DataArray,
da_alt: xr.DataArray, da_val: xr.DataArray)->pd.Series:
'''interpolate atmospheric variable to a specified altitude
Parameters
----------
lat : float
latitude of specified site
lon : float
longitude of specified site
da_alt_x : xr.DataArray
desired altitude to interpolate variable at
da_alt : xr.DataArray
altitude associated with `da_val`: variable array to interpolate
da_val : xr.DataArray
atmospheric varialble to interpolate
Returns
-------
pd.Series
interpolated values at the specified altitude of site positioned by [`lat`, `lon`]
'''
alt_t_1d = da_alt.sel(
latitude=lat, longitude=lon, method='nearest')
val_t_1d = da_val.sel(
latitude=lat, longitude=lon, method='nearest')
alt_x = da_alt_x.sel(
latitude=lat, longitude=lon, method='nearest')[0]
val_alt = np.array(
[interp1d(alt_1d, val_1d)(alt_x)
for alt_1d, val_1d
in zip(alt_t_1d, val_t_1d)])
ser_alt = pd.Series(
val_alt,
index=da_val.time.values,
name=da_val.name,
)
return ser_alt | [5][SEP1][Return][SEP2][][SEP3][7] | MODULE FUNCTIONDEF ARGUMENTS ARG NAME LOAD ARG NAME LOAD ARG ATTRIBUTE NAME LOAD LOAD ARG ATTRIBUTE NAME LOAD LOAD ARG ATTRIBUTE NAME LOAD LOAD EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD KEYWORD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD KEYWORD CONSTANT ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD KEYWORD CONSTANT CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD LISTCOMP CALL CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD COMPREHENSION TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD RETURN NAME LOAD ATTRIBUTE NAME LOAD LOAD |
def interactor(self, geneList=None, org=None):
"""
Supposing geneList returns an unique item.
"""
geneList = geneList or []
organisms = organisms or []
querydata = self.interactions(geneList, org)
returnData = {}
for i in querydata:
if not returnData.get(i["symB"]["name"]):
returnData[i["symB"]["name"]] = {"interactions": []}
returnData[i["symB"]["name"]]["interactions"].append(i)
return returnData | [3][SEP1][None][For][If][Return][None][None][SEP2][1][2,3][4,5][][5][1][SEP3][1][1][1][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE BOOLOP OR NAME LOAD LIST LOAD ASSIGN NAME STORE BOOLOP OR NAME LOAD LIST LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE DICT FOR NAME STORE NAME LOAD IF UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT LOAD ASSIGN SUBSCRIPT NAME LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT LOAD STORE DICT CONSTANT LIST LOAD EXPR CALL ATTRIBUTE SUBSCRIPT SUBSCRIPT NAME LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT LOAD LOAD CONSTANT LOAD LOAD NAME LOAD RETURN NAME LOAD |
def readACTIONRECORD(self):
""" Read a SWFActionRecord """
action = None
actionCode = self.readUI8()
if actionCode != 0:
actionLength = self.readUI16() if actionCode >= 0x80 else 0
#print "0x%x"%actionCode, actionLength
action = SWFActionFactory.create(actionCode, actionLength)
action.parse(self)
return action | [1][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][1][3][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD NOTEQ CONSTANT ASSIGN NAME STORE IFEXP COMPARE NAME LOAD GTE CONSTANT CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def export(self, swf, force_stroke=False):
""" Exports the specified SWF to SVG.
@param swf The SWF.
@param force_stroke Whether to force strokes on non-stroked fills.
"""
self.svg = self._e.svg(version=SVG_VERSION)
self.force_stroke = force_stroke
self.defs = self._e.defs()
self.root = self._e.g()
self.svg.append(self.defs)
self.svg.append(self.root)
self.shape_exporter.defs = self.defs
self._num_filters = 0
self.fonts = dict([(x.characterId,x) for x in swf.all_tags_of_type(TagDefineFont)])
self.fontInfos = dict([(x.characterId,x) for x in swf.all_tags_of_type(TagDefineFontInfo)])
# GO!
super(SVGExporter, self).export(swf, force_stroke)
# Setup svg @width, @height and @viewBox
# and add the optional margin
self.bounds = SVGBounds(self.svg)
self.svg.set("width", "%dpx" % round(self.bounds.width))
self.svg.set("height", "%dpx" % round(self.bounds.height))
if self._margin > 0:
self.bounds.grow(self._margin)
vb = [self.bounds.minx, self.bounds.miny,
self.bounds.width, self.bounds.height]
self.svg.set("viewBox", "%s" % " ".join(map(str,vb)))
# Return the SVG as StringIO
return self._serialize() | [3][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][16][1][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD STORE ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD LISTCOMP TUPLE ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD COMPREHENSION NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD LISTCOMP TUPLE ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD COMPREHENSION NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE CALL NAME LOAD NAME LOAD NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT BINOP CONSTANT MOD CALL NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT BINOP CONSTANT MOD CALL NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD GT CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE LIST ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT BINOP CONSTANT MOD CALL ATTRIBUTE CONSTANT LOAD CALL NAME LOAD NAME LOAD NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD |
def transfer_funds(self, from_, to, amount):
"""Transfer funds between the UK Exchange and Australian Exchange wallets.
:param Wallet from_: Source wallet
:param Wallet to: Destination wallet
:param float amount: Amount to transfer
"""
return self.make_api_request(
'Account',
'transferFunds',
utils.get_kwargs(locals()),
model=models.TransferResponse,
) | [4][SEP1][Return][SEP2][][SEP3][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT RETURN CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD |
def _get_id_token_user(token, issuers, audiences, allowed_client_ids, time_now, cache):
"""Get a User for the given id token, if the token is valid.
Args:
token: The id_token to check.
issuers: dict of Issuers
audiences: List of audiences that are acceptable.
allowed_client_ids: List of client IDs that are acceptable.
time_now: The current time as a long (eg. long(time.time())).
cache: Cache to use (eg. the memcache module).
Returns:
A User if the token is valid, None otherwise.
"""
# Verify that the token is valid before we try to extract anything from it.
# This verifies the signature and some of the basic info in the token.
for issuer_key, issuer in issuers.items():
issuer_cert_uri = convert_jwks_uri(issuer.jwks_uri)
try:
parsed_token = _verify_signed_jwt_with_certs(
token, time_now, cache, cert_uri=issuer_cert_uri)
except Exception: # pylint: disable=broad-except
_logger.debug(
'id_token verification failed for issuer %s', issuer_key, exc_info=True)
continue
issuer_values = _listlike_guard(issuer.issuer, 'issuer', log_warning=False)
if isinstance(audiences, _Mapping):
audiences = audiences[issuer_key]
if _verify_parsed_token(
parsed_token, issuer_values, audiences, allowed_client_ids,
# There's some special handling we do for Google issuers.
# ESP doesn't do this, and it's both unnecessary and invalid for other issuers.
# So we'll turn it off except in the Google issuer case.
is_legacy_google_auth=(issuer.issuer == _ISSUERS)):
email = parsed_token['email']
# The token might have an id, but it's a Gaia ID that's been
# obfuscated with the Focus key, rather than the AppEngine (igoogle)
# key. If the developer ever put this email into the user DB
# and retrieved the ID from that, it'd be different from the ID we'd
# return here, so it's safer to not return the ID.
# Instead, we'll only return the email.
return users.User(email) | [6][SEP1][None][For][Try][None][None][If][None][If][Return][SEP2][1][2][3,4][5][1][6,7][7][8,1][][SEP3][0][5][1][1][1][2][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG EXPR CONSTANT FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD TRY ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD KEYWORD CONSTANT CONTINUE ASSIGN NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT KEYWORD CONSTANT IF CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD IF CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD COMPARE ATTRIBUTE NAME LOAD LOAD EQ NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def _add_discovery_config(self):
"""Add the Discovery configuration to our list of configs.
This should only be called with self._config_lock. The code here assumes
the lock is held.
"""
lookup_key = (discovery_service.DiscoveryService.API_CONFIG['name'],
discovery_service.DiscoveryService.API_CONFIG['version'])
self._configs[lookup_key] = discovery_service.DiscoveryService.API_CONFIG | [1][SEP1][None][SEP2][][SEP3][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE TUPLE SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT LOAD SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT LOAD LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD |
def transform_rest_request(self, orig_request, params, method_parameters):
"""Translates a Rest request into an apiserving request.
This makes a copy of orig_request and transforms it to apiserving
format (moving request parameters to the body).
The request can receive values from the path, query and body and combine
them before sending them along to the backend. In cases of collision,
objects from the body take precedence over those from the query, which in
turn take precedence over those from the path.
In the case that a repeated value occurs in both the query and the path,
those values can be combined, but if that value also occurred in the body,
it would override any other values.
In the case of nested values from message fields, non-colliding values
from subfields can be combined. For example, if '?a.c=10' occurs in the
query string and "{'a': {'b': 11}}" occurs in the body, then they will be
combined as
{
'a': {
'b': 11,
'c': 10,
}
}
before being sent to the backend.
Args:
orig_request: An ApiRequest, the original request from the user.
params: A dict with URL path parameters extracted by the config_manager
lookup.
method_parameters: A dictionary containing the API configuration for the
parameters for the request.
Returns:
A copy of the current request that's been modified so it can be sent
to the backend. The body is updated to include parameters from the
URL.
"""
request = orig_request.copy()
body_json = {}
# Handle parameters from the URL path.
for key, value in params.iteritems():
# Values need to be in a list to interact with query parameter values
# and to account for case of repeated parameters
body_json[key] = [value]
# Add in parameters from the query string.
if request.parameters:
# For repeated elements, query and path work together
for key, value in request.parameters.iteritems():
if key in body_json:
body_json[key] = value + body_json[key]
else:
body_json[key] = value
# Validate all parameters we've merged so far and convert any '.' delimited
# parameters to nested parameters. We don't use iteritems since we may
# modify body_json within the loop. For instance, 'a.b' is not a valid key
# and would be replaced with 'a'.
for key, value in body_json.items():
current_parameter = method_parameters.get(key, {})
repeated = current_parameter.get('repeated', False)
if not repeated:
body_json[key] = body_json[key][0]
# Order is important here. Parameter names are dot-delimited in
# parameters instead of nested in dictionaries as a message field is, so
# we need to call transform_parameter_value on them before calling
# _add_message_field.
body_json[key] = parameter_converter.transform_parameter_value(
key, body_json[key], current_parameter)
# Remove the old key and try to convert to nested message value
message_value = body_json.pop(key)
self._add_message_field(key, message_value, body_json)
# Add in values from the body of the request.
if request.body_json:
self._update_from_body(body_json, request.body_json)
request.body_json = body_json
request.body = json.dumps(request.body_json)
return request | [4][SEP1][None][For][None][If][For][For][If][If][If][None][None][None][None][None][Return][SEP2][1][2,3][1][4,5][6,5][7,8][9,10][11,12][13,14][4][4][12][5][14][][SEP3][1][1][0][0][1][4][0][2][0][0][0][0][3][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE LIST NAME LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE NAME LOAD IN NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE BINOP NAME LOAD ADD SUBSCRIPT NAME LOAD NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE NAME LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD DICT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT IF UNARYOP NOT NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE SUBSCRIPT SUBSCRIPT NAME LOAD NAME LOAD LOAD CONSTANT LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD SUBSCRIPT NAME LOAD NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD IF ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD RETURN NAME LOAD |
def __parameter_descriptor(self, subfield_list):
"""Creates descriptor for a parameter using the subfields that define it.
Each parameter is defined by a list of fields, with all but the last being
a message field and the final being a simple (non-message) field.
Many of the fields in the descriptor are determined solely by the simple
field at the end, though some (such as repeated and required) take the whole
chain of fields into consideration.
Args:
subfield_list: List of fields describing the parameter.
Returns:
Dictionary containing a descriptor for the parameter described by the list
of fields.
"""
descriptor = {}
final_subfield = subfield_list[-1]
# Required
if all(subfield.required for subfield in subfield_list):
descriptor['required'] = True
# Type
descriptor['type'] = self.__field_to_parameter_type(final_subfield)
# Default
default = self.__parameter_default(final_subfield)
if default is not None:
descriptor['default'] = default
# Repeated
if any(subfield.repeated for subfield in subfield_list):
descriptor['repeated'] = True
# Enum
enum_descriptor = self.__parameter_enum(final_subfield)
if enum_descriptor is not None:
descriptor['enum'] = enum_descriptor
return descriptor | [2][SEP1][If][None][If][None][If][None][If][None][Return][SEP2][1,2][2][3,4][4][5,6][6][7,8][8][][SEP3][1][0][2][0][1][0][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE DICT ASSIGN NAME STORE SUBSCRIPT NAME LOAD UNARYOP USUB CONSTANT LOAD IF CALL NAME LOAD GENERATOREXP ATTRIBUTE NAME LOAD LOAD COMPREHENSION NAME STORE NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD ISNOT CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE NAME LOAD IF CALL NAME LOAD GENERATOREXP ATTRIBUTE NAME LOAD LOAD COMPREHENSION NAME STORE NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD ISNOT CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE NAME LOAD RETURN NAME LOAD |
def put_headers_in_environ(headers, environ):
"""Given a list of headers, put them into environ based on PEP-333.
This converts headers to uppercase, prefixes them with 'HTTP_', and
converts dashes to underscores before adding them to the environ dict.
Args:
headers: A list of (header, value) tuples. The HTTP headers to add to the
environment.
environ: An environ dict for the request as defined in PEP-333.
"""
for key, value in headers:
environ['HTTP_%s' % key.upper().replace('-', '_')] = value | [2][SEP1][None][For][None][SEP2][1][2][1][SEP3][0][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR TUPLE NAME STORE NAME STORE STORE NAME LOAD ASSIGN SUBSCRIPT NAME LOAD BINOP CONSTANT MOD CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT CONSTANT STORE NAME LOAD |
def __request_message_descriptor(self, request_kind, message_type, method_id,
path):
"""Describes the parameters and body of the request.
Args:
request_kind: The type of request being made.
message_type: messages.Message or ResourceContainer class. The message to
describe.
method_id: string, Unique method identifier (e.g. 'myapi.items.method')
path: string, HTTP path to method.
Returns:
Dictionary describing the request.
Raises:
ValueError: if the method path and request required fields do not match
"""
if isinstance(message_type, resource_container.ResourceContainer):
base_message_type = message_type.body_message_class()
if (request_kind == self.__NO_BODY and
base_message_type != message_types.VoidMessage()):
msg = ('Method %s specifies a body message in its ResourceContainer, but '
'is a HTTP method type that cannot accept a body.') % method_id
raise api_exceptions.ApiConfigurationError(msg)
else:
base_message_type = message_type
if (request_kind != self.__NO_BODY and
base_message_type != message_types.VoidMessage()):
self.__request_schema[method_id] = self.__parser.add_message(
base_message_type.__class__)
params = self.__params_descriptor(message_type, request_kind, path,
method_id)
return params | [5][SEP1][If][If][None][None][If][None][Return][SEP2][1,2][3,4][4][][5,6][6][][SEP3][1][2][0][1][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG EXPR CONSTANT IF CALL NAME LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND COMPARE NAME LOAD EQ ATTRIBUTE NAME LOAD LOAD COMPARE NAME LOAD NOTEQ CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE BINOP CONSTANT MOD NAME LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE NAME LOAD IF BOOLOP AND COMPARE NAME LOAD NOTEQ ATTRIBUTE NAME LOAD LOAD COMPARE NAME LOAD NOTEQ CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD RETURN NAME LOAD |
def feincms_breadcrumbs(page, include_self=True):
"""
Generate a list of the page's ancestors suitable for use as breadcrumb navigation.
By default, generates an unordered list with the id "breadcrumbs" -
override breadcrumbs.html to change this.
::
{% feincms_breadcrumbs feincms_page %}
"""
if not page or not isinstance(page, Page):
raise ValueError("feincms_breadcrumbs must be called with a valid Page object")
ancs = page.get_ancestors()
bc = [(anc.get_absolute_url(), anc.short_title()) for anc in ancs]
if include_self:
bc.append((None, page.short_title()))
return {"trail": bc} | [2][SEP1][If][None][If][None][Return][SEP2][1,2][][3,4][4][][SEP3][1][1][3][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT IF BOOLOP OR UNARYOP NOT NAME LOAD UNARYOP NOT CALL NAME LOAD NAME LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE LISTCOMP TUPLE CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD LOAD COMPREHENSION NAME STORE NAME LOAD IF NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD TUPLE CONSTANT CALL ATTRIBUTE NAME LOAD LOAD LOAD RETURN DICT CONSTANT NAME LOAD |
def get_rows(self):
'''returns rows with items
[[item1 item2], [item3 item4], [item5]]'''
rows = []
row = []
for i, item in enumerate(self.items):
if i > 0 and i % self.objects_per_row == 0:
rows.append(row)
row = []
row.append(item)
rows.append(row)
return rows | [1][SEP1][None][For][If][Return][None][None][SEP2][1][2,3][4,5][][5][1][SEP3][0][2][0][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE LIST LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND COMPARE NAME LOAD GT CONSTANT COMPARE BINOP NAME LOAD MOD ATTRIBUTE NAME LOAD LOAD EQ CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def install_package(package, upgrade=True,
target=None):
"""Install a package on PyPi. Accepts pip compatible package strings.
Return boolean if install successful.
"""
# Not using 'import pip; pip.main([])' because it breaks the logger
with INSTALL_LOCK:
if check_package_exists(package, target):
return True
_LOGGER.info('Attempting install of %s', package)
args = [sys.executable, '-m', 'pip', 'install', '--quiet', package]
if upgrade:
args.append('--upgrade')
if target:
args += ['--target', os.path.abspath(target)]
try:
return subprocess.call(args) == 0
except subprocess.SubprocessError:
_LOGGER.exception('Unable to install pacakge %s', package)
return False | [3][SEP1][None][If][Return][If][None][If][None][Try][Return][Return][SEP2][1][2,3][][4,5][5][6,7][7][8,9][][][SEP3][5][1][0][1][1][0][1][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT CONSTANT EXPR CONSTANT WITH WITHITEM NAME LOAD IF CALL NAME LOAD NAME LOAD NAME LOAD RETURN CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD ASSIGN NAME STORE LIST ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT CONSTANT CONSTANT NAME LOAD LOAD IF NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT IF NAME LOAD AUGASSIGN NAME STORE ADD LIST CONSTANT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LOAD TRY RETURN COMPARE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EQ CONSTANT EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD RETURN CONSTANT |
def page_not_found(request, template_name='404.html'):
"""
Default 404 handler.
Templates: :template:`404.html`
Context:
request_path
The path of the requested URL (e.g., '/app/pages/bad_page/')
"""
response = render_in_page(request, template_name)
if response:
return response
template = Template(
'<h1>Not Found</h1>'
'<p>The requested URL {{ request_path }} was not found on this server.</p>')
body = template.render(RequestContext(
request, {'request_path': request.path}))
return http.HttpResponseNotFound(body, content_type=CONTENT_TYPE) | [2][SEP1][If][Return][Return][SEP2][1,2][][][SEP3][1][0][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD IF NAME LOAD RETURN NAME LOAD ASSIGN NAME STORE CALL NAME LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD DICT CONSTANT ATTRIBUTE NAME LOAD LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD NAME LOAD |
def send_templated_email(subject, template_name, context,
recipients, sender=None, bcc=None,
fail_silently=True, files=None):
"""
send_templated_mail() is a wrapper around Django's e-mail routines that
allows us to easily send multipart (text/plain & text/html) e-mails using
templates that are stored in the database. This lets the admin provide
both a text and a HTML template for each message.
template_name is the slug of the template to use for this message (see
models.EmailTemplate)
context is a dictionary to be used when rendering the template
recipients can be either a string, eg 'a@b.com', or a list of strings.
sender should contain a string, eg 'My Site <me@z.com>'. If you leave it
blank, it'll use settings.DEFAULT_FROM_EMAIL as a fallback.
bcc is an optional list of addresses that will receive this message as a
blind carbon copy.
fail_silently is passed to Django's mail routine. Set to 'True' to ignore
any errors at send time.
files can be a list of file paths to be attached, or it can be left blank.
eg ('/tmp/file1.txt', '/tmp/image.png')
"""
c = Context(context)
if not sender:
sender = settings.DEFAULT_FROM_EMAIL
template = loader.get_template(template_name)
text_part = strip_tags(template.render(c))
html_part = template.render(c)
if type(recipients) == str:
if recipients.find(','):
recipients = recipients.split(',')
elif type(recipients) != list:
recipients = [recipients, ]
msg = EmailMultiAlternatives(subject,
text_part,
sender,
recipients,
bcc=bcc)
msg.attach_alternative(html_part, "text/html")
if files:
if type(files) != list:
files = [files, ]
for file in files:
msg.attach_file(file)
return msg.send(fail_silently) | [8][SEP1][If][None][If][If][If][None][If][None][If][Return][None][For][None][SEP2][1,2][2][3,4][5,6][7,6][6][8,9][6][10,11][][11][12,9][11][SEP3][1][0][5][1][1][1][3][0][1][1][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE CALL NAME LOAD NAME LOAD EQ NAME LOAD IF CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD NOTEQ NAME LOAD ASSIGN NAME STORE LIST NAME LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT IF NAME LOAD IF COMPARE CALL NAME LOAD NAME LOAD NOTEQ NAME LOAD ASSIGN NAME STORE LIST NAME LOAD LOAD FOR NAME STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def _images_failed(cls, session, previous_transaction):
"""Deletes the files of :attr:`_stored_images` back and clears
the :attr:`_stored_images` and :attr:`_deleted_images` set
when the ongoing transaction has done rollback.
"""
for image, store in cls._stored_images:
store.delete(image)
cls._stored_images.clear()
cls._deleted_images.clear() | [3][SEP1][None][For][None][None][SEP2][1][2,3][1][][SEP3][0][0][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT FOR TUPLE NAME STORE NAME STORE STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD |
def load_config(self, config=None):
''' loads a config file
Parameters:
config (str):
Optional name of manual config file to load
'''
# Read the config file
cfgname = (config or self.config_name)
cfgname = 'sdsswork' if cfgname is None else cfgname
assert isinstance(cfgname, six.string_types), 'config name must be a string'
config_name = cfgname if cfgname.endswith('.cfg') else '{0}.cfg'.format(cfgname)
self.configfile = os.path.join(self.treedir, 'data', config_name)
assert os.path.isfile(self.configfile) is True, 'configfile {0} must exist in the proper directory'.format(self.configfile)
self._cfg = SafeConfigParser()
try:
self._cfg.read(self.configfile.decode('utf-8'))
except AttributeError:
self._cfg.read(self.configfile)
# create the local tree environment
self.environ = OrderedDict()
self.environ['default'] = self._cfg.defaults()
# set the filesystem envvar to sas_base_dir
self._file_replace = '@FILESYSTEM@'
if self.environ['default']['filesystem'] == self._file_replace:
self.environ['default']['filesystem'] = self.sasbasedir | [2][SEP1][None][None][Try][None][None][If][None][SEP2][1][2][3,4][5][5][6][][SEP3][1][5][1][2][1][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE BOOLOP OR NAME LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE IFEXP COMPARE NAME LOAD IS CONSTANT CONSTANT NAME LOAD ASSERT CALL NAME LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE IFEXP CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD CALL ATTRIBUTE CONSTANT LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD ASSERT COMPARE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD IS CONSTANT CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD TRY EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT IF COMPARE SUBSCRIPT SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD CONSTANT LOAD EQ ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD CONSTANT STORE ATTRIBUTE NAME LOAD LOAD |
def remove_args(parser):
''' Remove custom arguments from the parser '''
arguments = []
for action in list(parser._get_optional_actions()):
if '--help' not in action.option_strings:
arguments += action.option_strings
for arg in arguments:
if arg in sys.argv:
sys.argv.remove(arg) | [1][SEP1][None][For][If][For][None][If][None][SEP2][1][2,3][4,1][5][1][6,3][3][SEP3][0][2][0][0][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE CONSTANT NOTIN ATTRIBUTE NAME LOAD LOAD AUGASSIGN NAME STORE ADD ATTRIBUTE NAME LOAD LOAD FOR NAME STORE NAME LOAD IF COMPARE NAME LOAD IN ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def prepare_cache_id(self, combined_args_kw):
"get the cacheid (conc. string of argument self.ids in order)"
cache_id = "".join(self.id(a) for a in combined_args_kw)
return cache_id | [2][SEP1][Return][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD GENERATOREXP CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD COMPREHENSION NAME STORE NAME LOAD RETURN NAME LOAD |
def _remove_from_index_operations(self, which, transforms):
"""
Helper preventing copy code.
Remove given what (transform prior etc) from which param index ops.
"""
if len(transforms) == 0:
transforms = which.properties()
removed = np.empty((0,), dtype=int)
for t in list(transforms):
unconstrained = which.remove(t, self._raveled_index())
removed = np.union1d(removed, unconstrained)
if t is __fixed__:
self._highest_parent_._set_unfixed(self, unconstrained)
return removed | [3][SEP1][If][None][None][For][If][Return][None][SEP2][1,2][2][3][4,5][6,3][][3][SEP3][1][1][1][1][3][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD TUPLE CONSTANT LOAD KEYWORD NAME LOAD FOR NAME STORE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD IF COMPARE NAME LOAD IS NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD RETURN NAME LOAD |
def parse_fade_requirement(text):
"""Return a requirement and repo from the given text, already parsed and converted."""
text = text.strip()
if "::" in text:
repo_raw, requirement = text.split("::", 1)
try:
repo = {'pypi': REPO_PYPI, 'vcs': REPO_VCS}[repo_raw]
except KeyError:
logger.warning("Not understood fades repository: %r", repo_raw)
return
else:
if ":" in text and "/" in text:
repo = REPO_VCS
else:
repo = REPO_PYPI
requirement = text
if repo == REPO_VCS:
dependency = VCSDependency(requirement)
else:
dependency = list(parse_requirements(requirement))[0]
return repo, dependency | [1][SEP1][If][Try][If][None][Return][None][None][If][None][None][None][Return][SEP2][1,2][3,4][5,6][7][][8][8][9,10][7][11][11][][SEP3][1][1][0][0][1][0][0][0][0][1][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE CONSTANT IN NAME LOAD ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT TRY ASSIGN NAME STORE SUBSCRIPT DICT CONSTANT CONSTANT NAME LOAD NAME LOAD NAME LOAD LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD RETURN IF BOOLOP AND COMPARE CONSTANT IN NAME LOAD COMPARE CONSTANT IN NAME LOAD ASSIGN NAME STORE NAME LOAD ASSIGN NAME STORE NAME LOAD ASSIGN NAME STORE NAME LOAD IF COMPARE NAME LOAD EQ NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE SUBSCRIPT CALL NAME LOAD CALL NAME LOAD NAME LOAD CONSTANT LOAD RETURN TUPLE NAME LOAD NAME LOAD LOAD |
def get(self):
"""Get the script content from the URL using the decided downloader."""
method_name = "_download_" + self.name
method = getattr(self, method_name)
return method() | [1][SEP1][Return][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE BINOP CONSTANT ADD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD RETURN CALL NAME LOAD |
def _generate_configs_from_default(self, overrides=None):
# type: (Dict[str, int]) -> Dict[str, int]
""" Generate configs by inheriting from defaults """
config = DEFAULT_CONFIG.copy()
if not overrides:
overrides = {}
for k, v in overrides.items():
config[k] = v
return config | [2][SEP1][If][None][For][None][Return][SEP2][1,2][2][3,4][2][][SEP3][1][0][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE DICT FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE NAME LOAD RETURN NAME LOAD |
def get_interfaces(self, socket_connection=None):
"""Returns the a list of Interface objects the service implements."""
if not socket_connection:
socket_connection = self.open_connection()
close_socket = True
else:
close_socket = False
# noinspection PyUnresolvedReferences
_service = self.handler(self._interfaces["org.varlink.service"], socket_connection)
self.info = _service.GetInfo()
if close_socket:
socket_connection.close()
return self.info['interfaces'] | [2][SEP1][If][None][None][If][None][Return][SEP2][1,2][3][3][4,5][5][][SEP3][0][1][0][2][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD IF NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD RETURN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD |
def replace_units(self, units, copy=True):
"""Change the unit system of this potential.
Parameters
----------
units : `~gala.units.UnitSystem`
Set of non-reducable units that specify (at minimum) the
length, mass, time, and angle units.
copy : bool (optional)
If True, returns a copy, if False, changes this object.
"""
if copy:
pot = pycopy.deepcopy(self)
else:
pot = self
PotentialBase.__init__(pot,
parameters=self.parameters,
origin=self.origin,
R=self.R,
ndim=self.ndim,
units=units)
return pot | [3][SEP1][If][None][None][Return][SEP2][1,2][3][3][][SEP3][0][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT IF NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD RETURN NAME LOAD |
def create_account(self, email_address, password=None, client_id=None, client_secret=None):
''' Create a new account.
If the account is created via an app, then Account.oauth will contain the
OAuth data that can be used to execute actions on behalf of the newly created account.
Args:
email_address (str): Email address of the new account to create
password (str): [DEPRECATED] This parameter will be ignored
client_id (str, optional): Client id of the app to use to create this account
client_secret (str, optional): Secret of the app to use to create this account
Returns:
The new Account object
'''
request = self._get_request()
params = {
'email_address': email_address
}
if client_id:
params['client_id'] = client_id
params['client_secret'] = client_secret
response = request.post(self.ACCOUNT_CREATE_URL, params)
if 'oauth_data' in response:
response["account"]["oauth"] = response['oauth_data']
return response | [5][SEP1][If][None][If][None][Return][SEP2][1,2][2][3,4][4][][SEP3][1][0][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT CONSTANT NAME LOAD IF NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE CONSTANT IN NAME LOAD ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT STORE SUBSCRIPT NAME LOAD CONSTANT LOAD RETURN NAME LOAD |
def get_embedded_object(self, signature_id):
''' Retrieves a embedded signing object
Retrieves an embedded object containing a signature url that can be opened in an iFrame.
Args:
signature_id (str): The id of the signature to get a signature url for
Returns:
An Embedded object
'''
request = self._get_request()
return request.get(self.EMBEDDED_OBJECT_GET_URL + signature_id) | [2][SEP1][Return][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD BINOP ATTRIBUTE NAME LOAD LOAD ADD NAME LOAD |
def _check_warnings(self, json_response):
''' Extract warnings from the response to make them accessible
Args:
json_response (dict): JSON response
'''
self.warnings = None
if json_response:
self.warnings = json_response.get('warnings')
if self.debug and self.warnings:
for w in self.warnings:
print("WARNING: %s - %s" % (w['warning_name'], w['warning_msg'])) | [2][SEP1][If][None][If][For][None][SEP2][1,2][2][3][4][3][SEP3][0][1][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT IF NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT IF BOOLOP AND ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD TUPLE SUBSCRIPT NAME LOAD CONSTANT LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD |
def can_recommend(self, client_data, extra_data={}):
"""The ensemble recommender is always going to be
available if at least one recommender is available"""
ensemble_recommend = self._ensemble_recommender.can_recommend(
client_data, extra_data
)
curated_recommend = self._curated_recommender.can_recommend(
client_data, extra_data
)
result = ensemble_recommend and curated_recommend
self.logger.info("Hybrid can_recommend: {}".format(result))
return result | [3][SEP1][Return][SEP2][][SEP3][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG DICT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE BOOLOP AND NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE CONSTANT LOAD NAME LOAD RETURN NAME LOAD |
def refresh_all_states(self):
"""Update all states."""
header = BASE_HEADERS.copy()
header['Cookie'] = self.__cookie
request = requests.get(
BASE_URL + "refreshAllStates", headers=header, timeout=10)
if request.status_code != 200:
self.__logged_in = False
self.login()
self.refresh_all_states()
return | [1][SEP1][If][Return][SEP2][1][][SEP3][2][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP NAME LOAD ADD CONSTANT KEYWORD NAME LOAD KEYWORD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD RETURN |
def parse_vasprun( self ):
"""
Read in `vasprun.xml` as a pymatgen Vasprun object.
Args:
None
Returns:
None
None:
If the vasprun.xml is not well formed this method will catch the ParseError
and set self.vasprun = None.
"""
self.vasprun_filename = match_filename( 'vasprun.xml' )
if not self.vasprun_filename:
raise FileNotFoundError( 'Could not find vasprun.xml or vasprun.xml.gz file' )
try:
self.vasprun = Vasprun( self.vasprun_filename, parse_potcar_file=False )
except ET.ParseError:
self.vasprun = None
except:
raise | [1][SEP1][If][None][Try][None][None][None][SEP2][1,2][][3,4,5][][][][SEP3][1][1][0][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD CONSTANT TRY ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD KEYWORD CONSTANT EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT EXCEPTHANDLER RAISE |
def patched_fax_v1_init(self, domain):
"""
Initialize the V1 version of Fax
:returns: V1 version of Fax
:rtype: twilio.rest.fax.v1.V1.V1
"""
print(domain.__class__.__name__)
super(TwilioV1, self).__init__(domain)
self.version = "2010-04-01/Accounts/" + domain.account_sid
self._faxes = None | [2][SEP1][None][SEP2][][SEP3][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT EXPR CALL NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE CALL NAME LOAD NAME LOAD NAME LOAD LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE BINOP CONSTANT ADD ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT |
def min(self):
"""
Returns the minimum value of the domain.
:rtype: `float` or `np.inf`
"""
return int(self._min) if not np.isinf(self._min) else self._min | [1][SEP1][Return][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT RETURN IFEXP UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD |
def fisher_information(self, modelparams, expparams):
"""
Returns the covariance of the score taken over possible outcomes,
known as the Fisher information.
The result is represented as the four-index tensor
``fisher[idx_modelparam_i, idx_modelparam_j, idx_model, idx_experiment]``,
which gives the Fisher information matrix for each model vector
and each experiment vector.
.. note::
The default implementation of this method calls
:meth:`~DifferentiableModel.score()` for each possible outcome,
which can be quite slow. If possible, overriding this method can
give significant speed advantages.
"""
if self.is_n_outcomes_constant:
outcomes = np.arange(self.n_outcomes(expparams))
scores, L = self.score(outcomes, modelparams, expparams, return_L=True)
assert len(scores.shape) in (3, 4)
if len(scores.shape) == 3:
scores = scores[np.newaxis, :, :, :]
# Note that E[score] = 0 by regularity assumptions, so we only
# need the expectation over the outer product.
return np.einsum("ome,iome,jome->ijme",
L, scores, scores
)
else:
# Indexing will be a major pain here, so we need to start
# by making an empty array, so that index errors will be raised
# when (not if!) we make mistakes.
fisher = np.empty((
self.n_modelparams, self.n_modelparams,
modelparams.shape[0], expparams.shape[0]
))
# Now we loop over experiments, since we cannot vectorize the
# expectation value over data.
for idx_experiment, experiment in enumerate(expparams):
experiment = experiment.reshape((1,))
n_o = self.n_outcomes(experiment)
outcomes = np.arange(n_o)
scores, L = self.score(outcomes, modelparams, experiment, return_L=True)
fisher[:, :, :, idx_experiment] = np.einsum("ome,iome,jome->ijme",
L, scores, scores
)
return fisher | [3][SEP1][If][None][None][If][For][None][Return][None][Return][SEP2][1,2][3][4][5,6][7,8][6][][4][][SEP3][8][4][1][1][1][0][1][5][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD CONSTANT ASSERT COMPARE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD IN TUPLE CONSTANT CONSTANT LOAD IF COMPARE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD EQ CONSTANT ASSIGN NAME STORE SUBSCRIPT NAME LOAD TUPLE ATTRIBUTE NAME LOAD LOAD SLICE SLICE SLICE LOAD LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD TUPLE ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD TUPLE CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD CONSTANT ASSIGN SUBSCRIPT NAME LOAD TUPLE SLICE SLICE SLICE NAME LOAD LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD NAME LOAD RETURN NAME LOAD |
def play_mode(self, playmode):
"""Set the speaker's mode."""
playmode = playmode.upper()
if playmode not in PLAY_MODES.keys():
raise KeyError("'%s' is not a valid play mode" % playmode)
self.avTransport.SetPlayMode([
('InstanceID', 0),
('NewPlayMode', playmode)
]) | [2][SEP1][If][None][None][SEP2][1,2][][][SEP3][2][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD NOTIN CALL ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LIST TUPLE CONSTANT CONSTANT LOAD TUPLE CONSTANT NAME LOAD LOAD LOAD |
def sort_loading_order(step_files):
"""Sort step files into correct loading order.
The correct loading order is first tools, then workflows without
subworkflows, and then workflows with subworkflows. This order is
required to avoid error messages when a working directory is used.
"""
tools = []
workflows = []
workflows_with_subworkflows = []
for f in step_files:
# assume that urls are tools
if f.startswith('http://') or f.startswith('https://'):
tools.append(f)
else:
obj = load_yaml(f)
if obj.get('class', '') == 'Workflow':
if 'requirements' in obj.keys():
subw = {'class': 'SubworkflowFeatureRequirement'}
if subw in obj['requirements']:
workflows_with_subworkflows.append(f)
else:
workflows.append(f)
else:
workflows.append(f)
else:
tools.append(f)
return tools + workflows + workflows_with_subworkflows | [1][SEP1][None][For][If][Return][None][If][If][None][If][None][None][None][SEP2][1][2,3][4,5][][1][6,7][8,9][1][10,11][1][1][1][SEP3][0][0][2][0][1][2][1][1][0][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE LIST LOAD FOR NAME STORE NAME LOAD IF BOOLOP OR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT EQ CONSTANT IF COMPARE CONSTANT IN CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT CONSTANT CONSTANT IF COMPARE NAME LOAD IN SUBSCRIPT NAME LOAD CONSTANT LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN BINOP BINOP NAME LOAD ADD NAME LOAD ADD NAME LOAD |
def plot_flat_gamut(
xy_to_2d=lambda xy: xy,
axes_labels=("x", "y"),
plot_rgb_triangle=True,
fill_horseshoe=True,
plot_planckian_locus=True,
):
"""Show a flat color gamut, by default xy. There exists a chroma gamut for
all color models which transform lines in XYZ to lines, and hence have a
natural decomposition into lightness and chroma components. Also, the flat
gamut is the same for every lightness value. Examples for color models with
this property are CIELUV and IPT, examples for color models without are
CIELAB and CIECAM02.
"""
observer = observers.cie_1931_2()
# observer = observers.cie_1964_10()
_plot_monochromatic(observer, xy_to_2d, fill_horseshoe=fill_horseshoe)
# plt.grid()
if plot_rgb_triangle:
_plot_rgb_triangle(xy_to_2d)
if plot_planckian_locus:
_plot_planckian_locus(observer, xy_to_2d)
plt.gca().set_aspect("equal")
# plt.legend()
plt.xlabel(axes_labels[0])
plt.ylabel(axes_labels[1])
return | [5][SEP1][If][None][If][None][Return][SEP2][1,2][2][3,4][4][][SEP3][2][1][0][1][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG LAMBDA ARGUMENTS ARG NAME LOAD TUPLE CONSTANT CONSTANT LOAD CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL NAME LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD IF NAME LOAD EXPR CALL NAME LOAD NAME LOAD IF NAME LOAD EXPR CALL NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD RETURN |
def get_config(self, name, default=_MISSING):
"""Get a configuration setting from this DeviceAdapter.
See :meth:`AbstractDeviceAdapter.get_config`.
"""
val = self._config.get(name, default)
if val is _MISSING:
raise ArgumentError("DeviceAdapter config {} did not exist and no default".format(name))
return val | [3][SEP1][If][None][Return][SEP2][1,2][][][SEP3][1][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG NAME LOAD EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD IF COMPARE NAME LOAD IS NAME LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD NAME LOAD RETURN NAME LOAD |
def sg_add_streamer(self, desc):
"""Add a graph streamer using a binary descriptor."""
if len(desc) == 13:
desc += b'\0'
err = self.sensor_graph.add_streamer(desc)
return [err] | [2][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT AUGASSIGN NAME STORE ADD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD RETURN LIST NAME LOAD LOAD |
def scan_recurse(self, node, path=()):
""" do a recursive scan of the top level target file
This lets us search for included files based on the
directory of the main file just as latex does"""
path_dict = dict(list(path))
queue = []
queue.extend( self.scan(node) )
seen = {}
# This is a hand-coded DSU (decorate-sort-undecorate, or
# Schwartzian transform) pattern. The sort key is the raw name
# of the file as specifed on the \include, \input, etc. line.
# TODO: what about the comment in the original Classic scanner:
# """which lets
# us keep the sort order constant regardless of whether the file
# is actually found in a Repository or locally."""
nodes = []
source_dir = node.get_dir()
#for include in includes:
while queue:
include = queue.pop()
inc_type, inc_subdir, inc_filename = include
try:
if seen[inc_filename] == 1:
continue
except KeyError:
seen[inc_filename] = 1
#
# Handle multiple filenames in include[1]
#
n, i = self.find_include(include, source_dir, path_dict)
if n is None:
# Do not bother with 'usepackage' warnings, as they most
# likely refer to system-level files
if inc_type != 'usepackage':
SCons.Warnings.warn(SCons.Warnings.DependencyWarning,
"No dependency generated for file: %s (included from: %s) -- file not found" % (i, node))
else:
sortkey = self.sort_key(n)
nodes.append((sortkey, n))
# recurse down
queue.extend( self.scan(n, inc_subdir) )
return [pair[1] for pair in sorted(nodes)] | [3][SEP1][None][While][Try][Return][If][None][If][If][None][None][SEP2][1][2,3][4,5][][1,6][6][7,8][9,1][1][1][SEP3][5][6][1][1][0][0][1][0][4][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG TUPLE LOAD EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD CALL NAME LOAD NAME LOAD ASSIGN NAME STORE LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE DICT ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD WHILE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN TUPLE NAME STORE NAME STORE NAME STORE STORE NAME LOAD TRY IF COMPARE SUBSCRIPT NAME LOAD NAME LOAD LOAD EQ CONSTANT CONTINUE EXCEPTHANDLER NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE CONSTANT ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD IF COMPARE NAME LOAD IS CONSTANT IF COMPARE NAME LOAD NOTEQ CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD TUPLE NAME LOAD NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD RETURN LISTCOMP SUBSCRIPT NAME LOAD CONSTANT LOAD COMPREHENSION NAME STORE CALL NAME LOAD NAME LOAD |
def putsz(self, addr, s):
"""Put bytes string in object at addr and append terminating zero at end."""
self.puts(addr, s)
self._buf[addr+len(s)] = 0 | [3][SEP1][None][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD BINOP NAME LOAD ADD CALL NAME LOAD NAME LOAD STORE CONSTANT |
def connect_async(self, connection_id, connection_string, callback):
"""Connect to a device by its connection_string
This function looks for the device on AWS IOT using the preconfigured
topic prefix and looking for:
<prefix>/devices/connection_string
It then attempts to lock that device for exclusive access and
returns a callback if successful.
Args:
connection_id (int): A unique integer set by the caller for referring to this connection
once created
connection_string (string): A device id of the form d--XXXX-YYYY-ZZZZ-WWWW
callback (callable): A callback function called when the connection has succeeded or
failed
"""
topics = MQTTTopicValidator(self.prefix + 'devices/{}'.format(connection_string))
key = self._generate_key()
name = self.name
conn_message = {'type': 'command', 'operation': 'connect', 'key': key, 'client': name}
context = {'key': key, 'slug': connection_string, 'topics': topics}
self.conns.begin_connection(connection_id, connection_string, callback, context, self.get_config('default_timeout'))
self._bind_topics(topics)
try:
self.client.publish(topics.connect, conn_message)
except IOTileException:
self._unbind_topics(topics)
self.conns.finish_connection(connection_id, False, 'Failed to send connection message') | [4][SEP1][Try][None][None][SEP2][1,2][][][SEP3][6][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD BINOP ATTRIBUTE NAME LOAD LOAD ADD CALL ATTRIBUTE CONSTANT LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT NAME LOAD NAME LOAD ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD TRY EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD CONSTANT CONSTANT |
def add_recipe_actions(self, recipe_actions):
"""Add additional valid recipe actions to RecipeManager
args:
recipe_actions (list): List of tuples. First value of tuple is the classname,
second value of tuple is RecipeAction Object
"""
for action_name, action in recipe_actions:
self._recipe_actions[action_name] = action | [2][SEP1][None][For][None][SEP2][1][2][1][SEP3][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR TUPLE NAME STORE NAME STORE STORE NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE NAME LOAD |
def _check_stop_conditions(self, sensor_graph):
"""Check if any of our stop conditions are met.
Args:
sensor_graph (SensorGraph): The sensor graph we are currently simulating
Returns:
bool: True if we should stop the simulation
"""
for stop in self.stop_conditions:
if stop.should_stop(self.tick_count, self.tick_count - self._start_tick, sensor_graph):
return True
return False | [2][SEP1][None][For][If][Return][Return][SEP2][1][2,3][4,1][][][SEP3][0][0][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD BINOP ATTRIBUTE NAME LOAD LOAD SUB ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN CONSTANT RETURN CONSTANT |
def declare_config_variable(self, name, config_id, type_name, default=None, convert=None): #pylint:disable=too-many-arguments;These are all necessary with sane defaults.
"""Declare a config variable that this emulated tile accepts.
The default value (if passed) may be specified as either a `bytes`
object or a python int or list of ints. If an int or list of ints is
passed, it is converted to binary. Otherwise, the raw binary data is
used.
Passing a unicode string is only allowed if as_string is True and it
will be encoded as utf-8 and null terminated for use as a default value.
Args:
name (str): A user friendly name for this config variable so that it can
be printed nicely.
config_id (int): A 16-bit integer id number to identify the config variable.
type_name (str): An encoded type name that will be parsed by parse_size_name()
default (object): The default value if there is one. This should be a
python object that will be converted to binary according to the rules for
the config variable type specified in type_name.
convert (str): whether this variable should be converted to a
python string or bool rather than an int or a list of ints. You can
pass either 'bool', 'string' or None
"""
config = ConfigDescriptor(config_id, type_name, default, name=name, python_type=convert)
self._config_variables[config_id] = config | [6][SEP1][None][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE NAME LOAD |
def format(self, indent_level, indent_size=4):
"""Format this verifier
Returns:
string: A formatted string
"""
name = self.format_name('Literal', indent_size)
if self.long_desc is not None:
name += '\n'
name += self.wrap_lines('value: %s\n' % str(self._literal), 1, indent_size)
return self.wrap_lines(name, indent_level, indent_size) | [3][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][1][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT AUGASSIGN NAME STORE ADD CONSTANT AUGASSIGN NAME STORE ADD CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD |
def CreateLibSymlinks(env, symlinks):
"""Physically creates symlinks. The symlinks argument must be a list in
form [ (link, linktarget), ... ], where link and linktarget are SCons
nodes.
"""
Verbose = False
for link, linktgt in symlinks:
linktgt = link.get_dir().rel_path(linktgt)
link = link.get_path()
if(Verbose):
print("CreateLibSymlinks: preparing to add symlink %r -> %r" % (link, linktgt))
# Delete the (previously created) symlink if exists. Let only symlinks
# to be deleted to prevent accidental deletion of source files...
if env.fs.islink(link):
env.fs.unlink(link)
if(Verbose):
print("CreateLibSymlinks: removed old symlink %r" % link)
# If a file or directory exists with the same name as link, an OSError
# will be thrown, which should be enough, I think.
env.fs.symlink(linktgt, link)
if(Verbose):
print("CreateLibSymlinks: add symlink %r -> %r" % (link, linktgt))
return 0 | [2][SEP1][None][For][If][Return][None][If][If][If][None][None][SEP2][1][2,3][4,5][][5][6,7][8,7][9,1][7][1][SEP3][0][5][3][0][1][1][1][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CONSTANT FOR TUPLE NAME STORE NAME STORE STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF NAME LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD IF CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD IF NAME LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD IF NAME LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD RETURN CONSTANT |
def add_dependency(self, depend):
"""Adds dependencies."""
try:
self._add_child(self.depends, self.depends_set, depend)
except TypeError as e:
e = e.args[0]
if SCons.Util.is_List(e):
s = list(map(str, e))
else:
s = str(e)
raise SCons.Errors.UserError("attempted to add a non-Node dependency to %s:\n\t%s is a %s, not a Node" % (str(self), s, type(e))) | [2][SEP1][Try][None][If][None][None][None][SEP2][1,2][][3,4][5][5][][SEP3][3][1][1][2][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT TRY EXPR CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD IF CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD RAISE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD BINOP CONSTANT MOD TUPLE CALL NAME LOAD NAME LOAD NAME LOAD CALL NAME LOAD NAME LOAD LOAD |
def build_dirs(self):
"""Return the build directory hierarchy:
Defines:
- build: build/chip
- output: build/output
- test: build/test/chip
where chip is the canonical name for the chip passed in
"""
arch = self.arch_name()
build_path = os.path.join('build', arch)
output = os.path.join('build', 'output')
test = os.path.join('build', 'test', arch)
return {'build': build_path, 'output': output, 'test': test} | [1][SEP1][Return][SEP2][][SEP3][4] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT CONSTANT NAME LOAD RETURN DICT CONSTANT CONSTANT CONSTANT NAME LOAD NAME LOAD NAME LOAD |
def get_program_files_dir():
"""
Get the location of the program files directory
Returns
-------
"""
# Now see if we can look in the registry...
val = ''
if SCons.Util.can_read_reg:
try:
# Look for Windows Program Files directory
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
'Software\\Microsoft\\Windows\\CurrentVersion')
val, tok = SCons.Util.RegQueryValueEx(k, 'ProgramFilesDir')
except SCons.Util.RegError:
val = ''
pass
if val == '':
# A reasonable default if we can't read the registry
# (Actually, it's pretty reasonable even if we can :-)
val = os.path.join(os.path.dirname(get_system_root()),"Program Files")
return val | [0][SEP1][If][Try][If][None][None][None][Return][SEP2][1,2][3,4][5,6][2][2][6][][SEP3][0][0][0][2][0][3][0] | MODULE FUNCTIONDEF ARGUMENTS EXPR CONSTANT ASSIGN NAME STORE CONSTANT IF ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TRY ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD CONSTANT ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD CONSTANT EXCEPTHANDLER ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CONSTANT PASS IF COMPARE NAME LOAD EQ CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL NAME LOAD CONSTANT RETURN NAME LOAD |
def add_f90_to_env(env):
"""Add Builders and construction variables for f90 to an Environment."""
try:
F90Suffixes = env['F90FILESUFFIXES']
except KeyError:
F90Suffixes = ['.f90']
#print("Adding %s to f90 suffixes" % F90Suffixes)
try:
F90PPSuffixes = env['F90PPFILESUFFIXES']
except KeyError:
F90PPSuffixes = []
DialectAddToEnv(env, "F90", F90Suffixes, F90PPSuffixes,
support_module = 1) | [1][SEP1][Try][None][None][Try][None][None][None][SEP2][1,2][3][3][4,5][6][6][][SEP3][0][0][0][0][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE LIST CONSTANT LOAD TRY ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE LIST LOAD EXPR CALL NAME LOAD NAME LOAD CONSTANT NAME LOAD NAME LOAD KEYWORD CONSTANT |
def ReplaceIxes(self, path, old_prefix, old_suffix, new_prefix, new_suffix):
"""
Replace old_prefix with new_prefix and old_suffix with new_suffix.
env - Environment used to interpolate variables.
path - the path that will be modified.
old_prefix - construction variable for the old prefix.
old_suffix - construction variable for the old suffix.
new_prefix - construction variable for the new prefix.
new_suffix - construction variable for the new suffix.
"""
old_prefix = self.subst('$'+old_prefix)
old_suffix = self.subst('$'+old_suffix)
new_prefix = self.subst('$'+new_prefix)
new_suffix = self.subst('$'+new_suffix)
dir,name = os.path.split(str(path))
if name[:len(old_prefix)] == old_prefix:
name = name[len(old_prefix):]
if name[-len(old_suffix):] == old_suffix:
name = name[:-len(old_suffix)]
return os.path.join(dir, new_prefix+name+new_suffix) | [6][SEP1][If][None][If][None][Return][SEP2][1,2][2][3,4][4][][SEP3][7][1][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT ADD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT ADD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT ADD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT ADD NAME LOAD ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL NAME LOAD NAME LOAD IF COMPARE SUBSCRIPT NAME LOAD SLICE CALL NAME LOAD NAME LOAD LOAD EQ NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE CALL NAME LOAD NAME LOAD LOAD IF COMPARE SUBSCRIPT NAME LOAD SLICE UNARYOP USUB CALL NAME LOAD NAME LOAD LOAD EQ NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE UNARYOP USUB CALL NAME LOAD NAME LOAD LOAD RETURN CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD BINOP BINOP NAME LOAD ADD NAME LOAD ADD NAME LOAD |
def encode_contents(self):
"""Encode the contents of this update record without including a record header.
Returns:
bytearray: The encoded contents.
"""
if self.variable_size:
resp_length = 1
else:
resp_length = self.fixed_response_size << 1
header = struct.pack("<HBB", self.rpc_id, self.address, resp_length)
return bytearray(header) + self.payload | [1][SEP1][If][None][None][Return][SEP2][1,2][3][3][][SEP3][0][0][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE BINOP ATTRIBUTE NAME LOAD LOAD LSHIFT CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN BINOP CALL NAME LOAD NAME LOAD ADD ATTRIBUTE NAME LOAD LOAD |
def stream_name(stream_id):
"""Map a stream id to a human readable name.
The mapping process is as follows:
If the stream id is globally known, its global name is used as <name>
otherwise a string representation of the stream is used as <name>.
In both cases the hex representation of the stream id is appended as a
number:
<name> (0x<stream id in hex>)
Args:
stream_id (int): An integer stream id.
Returns:
str: The nice name of the stream.
"""
name = _STREAM_NAME_MAP.get(stream_id)
if name is None:
name = str(DataStream.FromEncoded(stream_id))
return "{} (0x{:04X})".format(name, stream_id) | [1][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][1][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN CALL ATTRIBUTE CONSTANT LOAD NAME LOAD NAME LOAD |
def push(self, stream, value):
"""Update this stream walker with a new responsive reading.
Virtual stream walkers keep at most one reading so this function
just overwrites whatever was previously stored.
"""
if not self.matches(stream):
raise ArgumentError("Attempting to push reading to stream walker that does not match", selector=self.selector, stream=stream)
self.reading = value | [3][SEP1][If][None][None][SEP2][1,2][][][SEP3][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT IF UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD |
def attach_stream(self, stream):
"""Notify that we would like to attach a node input to this stream.
The return value from this function is the DataStream that should be attached
to since this function may internally allocate a new SGNode that copies the
stream if there is no space in the output list to hold another input.
This function should be called once for every node input before allocated a new
sensor graph node that attaches to a stream that is managed by the StreamAllocator.
Args:
stream (DataStream): The stream (originally returned from allocate_stream)
that we want to attach to.
Returns:
Datastream: A data stream, possible the same as stream, that should be attached
to a node input.
"""
curr_stream, count, prev = self._allocated_streams[stream]
# Check if we need to split this stream and allocate a new one
if count == (self.model.get(u'max_node_outputs') - 1):
new_stream = self.allocate_stream(curr_stream.stream_type, previous=curr_stream)
copy_desc = u"({} always) => {} using copy_all_a".format(curr_stream, new_stream)
self.sensor_graph.add_node(copy_desc)
self._allocated_streams[stream] = (new_stream, 1, curr_stream)
# If we are splitting a constant stream, make sure we also duplicate the initialization value
# FIXME: If there is no default value for the stream, that is probably a warning since all constant
# streams should be initialized with a value.
if curr_stream.stream_type == DataStream.ConstantType and curr_stream in self.sensor_graph.constant_database:
self.sensor_graph.add_constant(new_stream, self.sensor_graph.constant_database[curr_stream])
return new_stream
self._allocated_streams[stream] = (curr_stream, count + 1, prev)
return curr_stream | [2][SEP1][If][If][Return][None][Return][SEP2][1,2][3,4][][4][][SEP3][1][3][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN TUPLE NAME STORE NAME STORE NAME STORE STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD IF COMPARE NAME LOAD EQ BINOP CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT SUB CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE TUPLE NAME LOAD CONSTANT NAME LOAD LOAD IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD EQ ATTRIBUTE NAME LOAD LOAD COMPARE NAME LOAD IN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LOAD RETURN NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE TUPLE NAME LOAD BINOP NAME LOAD ADD CONSTANT NAME LOAD LOAD RETURN NAME LOAD |
def generate(env):
"""Add Builders and construction variables for ipkg to an Environment."""
try:
bld = env['BUILDERS']['Ipkg']
except KeyError:
bld = SCons.Builder.Builder(action='$IPKGCOM',
suffix='$IPKGSUFFIX',
source_scanner=None,
target_scanner=None)
env['BUILDERS']['Ipkg'] = bld
env['IPKG'] = 'ipkg-build'
env['IPKGCOM'] = '$IPKG $IPKGFLAGS ${SOURCE}'
if env.WhereIs('id'):
env['IPKGUSER'] = os.popen('id -un').read().strip()
env['IPKGGROUP'] = os.popen('id -gn').read().strip()
env['IPKGFLAGS'] = SCons.Util.CLVar('-o $IPKGUSER -g $IPKGGROUP')
env['IPKGSUFFIX'] = '.ipk' | [1][SEP1][Try][None][None][If][None][None][SEP2][1,2][3][3][4,5][5][][SEP3][0][0][1][1][6][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY ASSIGN NAME STORE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD CONSTANT KEYWORD CONSTANT KEYWORD CONSTANT KEYWORD CONSTANT ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT STORE NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT IF CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT |
def format_response(self, response_data):
"""Format an RPC response."""
_addr, length = self.response_info()
if len(response_data) != length:
raise HardwareError("Invalid response read length, should be the same as what response_info() returns", expected=length, actual=len(response_data))
resp, flags, received_length, payload = struct.unpack("<HxBL4x20s", response_data)
resp = resp & 0xFF
if flags & (1 << 3):
raise HardwareError("Could not grab external gate")
if received_length > 20:
raise HardwareError("Invalid received payload length > 20 bytes", received_length=received_length)
payload = payload[:received_length]
return {
'status': resp,
'payload': payload
} | [2][SEP1][If][None][If][None][If][None][Return][SEP2][1,2][][3,4][][5,6][][][SEP3][2][2][1][1][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE CALL NAME LOAD NAME LOAD NOTEQ NAME LOAD RAISE CALL NAME LOAD CONSTANT KEYWORD NAME LOAD KEYWORD CALL NAME LOAD NAME LOAD ASSIGN TUPLE NAME STORE NAME STORE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD ASSIGN NAME STORE BINOP NAME LOAD BITAND CONSTANT IF BINOP NAME LOAD BITAND BINOP CONSTANT LSHIFT CONSTANT RAISE CALL NAME LOAD CONSTANT IF COMPARE NAME LOAD GT CONSTANT RAISE CALL NAME LOAD CONSTANT KEYWORD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE NAME LOAD LOAD RETURN DICT CONSTANT CONSTANT NAME LOAD NAME LOAD |
def read_packet(self, timeout=3.0):
"""read one packet, timeout if one packet is not available in the timeout period"""
try:
return self.queue.get(timeout=timeout)
except Empty:
raise InternalTimeoutError("Timeout waiting for packet in AsyncPacketBuffer") | [2][SEP1][Try][Return][None][SEP2][1,2][][][SEP3][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT TRY RETURN CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD NAME LOAD EXCEPTHANDLER NAME LOAD RAISE CALL NAME LOAD CONSTANT |
def insert_tile(self, tile_info):
"""Add or replace an entry in the tile cache.
Args:
tile_info (TileInfo): The newly registered tile.
"""
for i, tile in enumerate(self.registered_tiles):
if tile.slot == tile_info.slot:
self.registered_tiles[i] = tile_info
return
self.registered_tiles.append(tile_info) | [2][SEP1][None][For][If][None][Return][SEP2][1][2,3][4,1][][][SEP3][0][1][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD EQ ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE NAME LOAD RETURN EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def build_args():
"""Create command line argument parser."""
parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('recipe', type=str, help="The recipe file to load and run.")
parser.add_argument('-d', '--define', action="append", default=[], help="Set a free variable in the recipe")
parser.add_argument('-l', '--loop', default=None, help="Loop over a free variable")
parser.add_argument('-i', '--info', action='store_true', help="Lists out all the steps of that recipe, doesn't run the recipe steps")
parser.add_argument('-a', '--archive', help="Archive the passed yaml recipe and do not run it")
parser.add_argument('-c', '--config', default=None, help="A YAML config file with variable definitions")
return parser | [0][SEP1][Return][SEP2][][SEP3][7] | MODULE FUNCTIONDEF ARGUMENTS EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT KEYWORD NAME LOAD KEYWORD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT KEYWORD CONSTANT KEYWORD LIST LOAD KEYWORD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT KEYWORD CONSTANT KEYWORD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT KEYWORD CONSTANT KEYWORD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT KEYWORD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT KEYWORD CONSTANT KEYWORD CONSTANT RETURN NAME LOAD |
def _connect_to_device(self, uuid, key, client):
"""Connect to a device given its uuid
Args:
uuid (int): The unique id of the device
key (string): A 64 byte string used to secure this connection
client (string): The client id for who is trying to connect
to the device.
"""
slug = self._build_device_slug(uuid)
message = {'client': client, 'type': 'response', 'operation': 'connect'}
self._logger.info("Connection attempt for device %d", uuid)
# If someone is already connected, fail the request
if uuid in self._connections:
message['success'] = False
message['failure_reason'] = 'Someone else is connected to the device'
self._publish_status(slug, message)
return
# Otherwise try to connect
resp = yield self._manager.connect(uuid)
message['success'] = resp['success']
if resp['success']:
conn_id = resp['connection_id']
self._connections[uuid] = {'key': key, 'client': client, 'connection_id': conn_id, 'last_touch': monotonic(),
'script': [], 'trace_accum': bytes(), 'last_trace': None, 'trace_scheduled': False,
'last_progress': None}
else:
message['failure_reason'] = resp['reason']
self._connections[uuid] = {}
connection = self._connections[uuid]
connection['report_monitor'] = self._manager.register_monitor(uuid, ['report'], self._notify_report)
connection['trace_monitor'] = self._manager.register_monitor(uuid, ['trace'], self._notify_trace)
self._publish_status(slug, message) | [4][SEP1][If][Return][None][If][None][None][None][SEP2][1,2][][3][4,5][6][6][][SEP3][2][1][1][0][2][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT NAME LOAD CONSTANT CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT NAME LOAD IF COMPARE NAME LOAD IN ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD RETURN ASSIGN NAME STORE YIELD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT NAME LOAD NAME LOAD NAME LOAD CALL NAME LOAD LIST LOAD CALL NAME LOAD CONSTANT CONSTANT CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE DICT ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LIST CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LIST CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD |
def ensure_prepared(self):
"""Calculate and cache UTC values for all exactly known anchor points."""
if self._prepared:
return
exact_count = 0
fixed_count = 0
inexact_count = 0
self._logger.debug("Preparing UTCAssigner (%d total anchors)", len(self._anchor_points))
for curr in self._anchor_points:
if not curr.exact:
assignment = self.assign_utc(curr.reading_id, curr.uptime)
if assignment is not None and assignment.exact:
curr.utc = assignment.utc
curr.exact = True
fixed_count += 1
else:
inexact_count += 1
else:
exact_count += 1
self._logger.debug("Prepared UTCAssigner with %d reference points, "
"%d exact anchors and %d inexact anchors",
exact_count, fixed_count, inexact_count)
self._prepared = True | [1][SEP1][If][Return][None][For][If][None][If][None][None][None][SEP2][1,2][][3][4,5][6,7][][8,9][3][3][3][SEP3][0][0][2][0][0][1][1][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD RETURN ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT AUGASSIGN NAME STORE ADD CONSTANT AUGASSIGN NAME STORE ADD CONSTANT AUGASSIGN NAME STORE ADD CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT NAME LOAD NAME LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT |
def File(self, name, directory = None, create = 1):
"""Look up or create a File node with the specified name. If
the name is a relative path (begins with ./, ../, or a file name),
then it is looked up relative to the supplied directory node,
or to the top level directory of the FS (supplied at construction
time) if no directory is supplied.
This method will raise TypeError if a directory is found at the
specified path.
"""
return self._lookup(name, directory, File, create) | [4][SEP1][Return][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG CONSTANT CONSTANT EXPR CONSTANT RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD |
def get_found_includes(self, env, scanner, path):
"""Return the included implicit dependencies in this file.
Cache results so we only scan the file once per path
regardless of how many times this information is requested.
"""
memo_key = (id(env), id(scanner), path)
try:
memo_dict = self._memo['get_found_includes']
except KeyError:
memo_dict = {}
self._memo['get_found_includes'] = memo_dict
else:
try:
return memo_dict[memo_key]
except KeyError:
pass
if scanner:
result = [n.disambiguate() for n in scanner(self, env, path)]
else:
result = []
memo_dict[memo_key] = result
return result | [4][SEP1][Try][None][None][Try][If][Return][None][None][None][Return][SEP2][1,2][3][4][5,6][7,8][][4][9][9][][SEP3][2][0][0][0][0][0][0][2][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE TUPLE CALL NAME LOAD NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD LOAD TRY ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE DICT ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT STORE NAME LOAD TRY RETURN SUBSCRIPT NAME LOAD NAME LOAD LOAD EXCEPTHANDLER NAME LOAD PASS IF NAME LOAD ASSIGN NAME STORE LISTCOMP CALL ATTRIBUTE NAME LOAD LOAD COMPREHENSION NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE LIST LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE NAME LOAD RETURN NAME LOAD |
def post_message(self, level, message, count=1, timestamp=None, now_reference=None):
"""Post a new message for service.
Args:
level (int): The level of the message (info, warning, error)
message (string): The message contents
count (int): The number of times the message has been repeated
timestamp (float): An optional monotonic value in seconds for when the message was created
now_reference (float): If timestamp is not relative to monotonic() as called from this
module then this should be now() as seen by whoever created the timestamp.
Returns:
ServiceMessage: The posted message
"""
if len(self.messages) > 0 and self.messages[-1].message == message:
self.messages[-1].count += 1
else:
msg_object = ServiceMessage(level, message, self._last_message_id, timestamp, now_reference)
msg_object.count = count
self.messages.append(msg_object)
self._last_message_id += 1
return self.messages[-1] | [6][SEP1][If][None][None][Return][SEP2][1,2][3][3][][SEP3][1][0][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT EXPR CONSTANT IF BOOLOP AND COMPARE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD GT CONSTANT COMPARE ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD UNARYOP USUB CONSTANT LOAD LOAD EQ NAME LOAD AUGASSIGN ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD UNARYOP USUB CONSTANT LOAD STORE ADD CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD AUGASSIGN ATTRIBUTE NAME LOAD STORE ADD CONSTANT RETURN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD UNARYOP USUB CONSTANT LOAD |
def CheckProg(context, prog_name):
"""Simple check if a program exists in the path. Returns the path
for the application, or None if not found.
"""
res = SCons.Conftest.CheckProg(context, prog_name)
context.did_show_result = 1
return res | [2][SEP1][Return][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT RETURN NAME LOAD |
def _create_binary_trigger(trigger):
"""Create an 8-bit binary trigger from an InputTrigger, TrueTrigger, FalseTrigger."""
ops = {
0: ">",
1: "<",
2: ">=",
3: "<=",
4: "==",
5: 'always'
}
op_codes = {y: x for x, y in ops.items()}
source = 0
if isinstance(trigger, TrueTrigger):
op_code = op_codes['always']
elif isinstance(trigger, FalseTrigger):
raise ArgumentError("Cannot express a never trigger in binary descriptor", trigger=trigger)
else:
op_code = op_codes[trigger.comp_string]
if trigger.use_count:
source = 1
return (op_code << 1) | source | [1][SEP1][If][None][If][Return][None][If][None][SEP2][1,2][3][4,5][][][6,3][3][SEP3][2][0][1][0][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT ASSIGN NAME STORE DICTCOMP NAME LOAD NAME LOAD COMPREHENSION TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT IF CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF CALL NAME LOAD NAME LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT KEYWORD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD ATTRIBUTE NAME LOAD LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT RETURN BINOP BINOP NAME LOAD LSHIFT CONSTANT BITOR NAME LOAD |
def make_ready(self):
"""Make a task ready for execution"""
SCons.Taskmaster.OutOfDateTask.make_ready(self)
if self.out_of_date and self.options.debug_explain:
explanation = self.out_of_date[0].explain()
if explanation:
sys.stdout.write("scons: " + explanation) | [1][SEP1][If][If][None][SEP2][1][2][][SEP3][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD NAME LOAD IF BOOLOP AND ATTRIBUTE NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD IF NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD BINOP CONSTANT ADD NAME LOAD |
def enable_tracing(self):
"""Open the tracing interface and accumulate traces in a queue.
This method is safe to call multiple times in a single device
connection. There is no way to check if the tracing interface is
opened or to close it once it is opened (apart from disconnecting from
the device).
The first time this method is called, it will open the tracing
interface and return a queue that will be filled asynchronously with
reports as they are received. Subsequent calls will just empty the
queue and return the same queue without interacting with the device at
all.
Returns:
queue.Queue: A queue that will be filled with trace data from the device.
The trace data will be in disjoint bytes objects in the queue
"""
if not self.connected:
raise HardwareError("Cannot enable tracing if we are not in a connected state")
if self._traces is not None:
_clear_queue(self._traces)
return self._traces
self._traces = queue.Queue()
self._loop.run_coroutine(self.adapter.open_interface(0, 'tracing'))
return self._traces | [1][SEP1][If][None][If][Return][Return][SEP2][1,2][][3,4][][][SEP3][0][1][0][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD RETURN ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT CONSTANT RETURN ATTRIBUTE NAME LOAD LOAD |
def __extend_targets_sources(target, source):
""" Prepare the lists of target and source files. """
if not SCons.Util.is_List(target):
target = [target]
if not source:
source = target[:]
elif not SCons.Util.is_List(source):
source = [source]
if len(target) < len(source):
target.extend(source[len(target):])
return target, source | [2][SEP1][If][None][If][None][If][If][None][None][Return][SEP2][1,2][2][3,4][5][6,5][7,8][5][8][][SEP3][1][0][0][0][1][2][0][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF UNARYOP NOT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE LIST NAME LOAD LOAD IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE LOAD IF UNARYOP NOT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE LIST NAME LOAD LOAD IF COMPARE CALL NAME LOAD NAME LOAD LT CALL NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT NAME LOAD SLICE CALL NAME LOAD NAME LOAD LOAD RETURN TUPLE NAME LOAD NAME LOAD LOAD |
def get_src_builders(self, env):
"""
Returns the list of source Builders for this Builder.
This exists mainly to look up Builders referenced as
strings in the 'BUILDER' variable of the construction
environment and cache the result.
"""
memo_key = id(env)
try:
memo_dict = self._memo['get_src_builders']
except KeyError:
memo_dict = {}
self._memo['get_src_builders'] = memo_dict
else:
try:
return memo_dict[memo_key]
except KeyError:
pass
builders = []
for bld in self.src_builder:
if SCons.Util.is_String(bld):
try:
bld = env['BUILDERS'][bld]
except KeyError:
continue
builders.append(bld)
memo_dict[memo_key] = builders
return builders | [2][SEP1][Try][None][None][Try][None][Return][None][For][If][Return][Try][None][None][SEP2][1,2][3][4][5,6][7][][4][8,9][10,11][][12,7][7][11][SEP3][1][0][0][0][0][0][0][1][1][0][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD TRY ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE DICT ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT STORE NAME LOAD TRY RETURN SUBSCRIPT NAME LOAD NAME LOAD LOAD EXCEPTHANDLER NAME LOAD PASS ASSIGN NAME STORE LIST LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD TRY ASSIGN NAME STORE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD EXCEPTHANDLER NAME LOAD CONTINUE EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE NAME LOAD RETURN NAME LOAD |
def begin_connection(self, connection_id, internal_id, callback, context, timeout):
"""Asynchronously begin a connection attempt
Args:
connection_id (int): The external connection id
internal_id (string): An internal identifier for the connection
callback (callable): The function to be called when the connection
attempt finishes
context (dict): Additional information to associate with this context
timeout (float): How long to allow this connection attempt to proceed
without timing it out
"""
data = {
'callback': callback,
'connection_id': connection_id,
'internal_id': internal_id,
'context': context
}
action = ConnectionAction('begin_connection', data, timeout=timeout, sync=False)
self._actions.put(action) | [6][SEP1][None][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT NAME LOAD NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD CONSTANT NAME LOAD KEYWORD NAME LOAD KEYWORD CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def annotate(node):
"""Annotate a node with the stack frame describing the
SConscript file and line number that created it."""
tb = sys.exc_info()[2]
while tb and stack_bottom not in tb.tb_frame.f_locals:
tb = tb.tb_next
if not tb:
# We did not find any exec of an SConscript file: what?!
raise SCons.Errors.InternalError("could not find SConscript stack frame")
node.creator = traceback.extract_stack(tb)[0] | [1][SEP1][None][While][None][If][None][None][SEP2][1][2,3][1][4,5][][][SEP3][1][0][0][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD WHILE BOOLOP AND NAME LOAD COMPARE NAME LOAD NOTIN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT NAME LOAD RAISE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT LOAD |
def updateRpmDicts(rpmrc, pyfile):
""" Read the given rpmrc file with RPM definitions and update the
info dictionaries in the file pyfile with it.
The arguments will usually be 'rpmrc.in' from a recent RPM source
tree, and 'rpmutils.py' referring to this script itself.
See also usage() below.
"""
try:
# Read old rpmutils.py file
oldpy = open(pyfile,"r").readlines()
# Read current rpmrc.in file
rpm = open(rpmrc,"r").readlines()
# Parse for data
data = {}
# Allowed section names that get parsed
sections = ['optflags',
'arch_canon',
'os_canon',
'buildarchtranslate',
'arch_compat',
'os_compat',
'buildarch_compat']
for l in rpm:
l = l.rstrip('\n').replace(':',' ')
# Skip comments
if l.lstrip().startswith('#'):
continue
tokens = l.strip().split()
if len(tokens):
key = tokens[0]
if key in sections:
# Have we met this section before?
if tokens[0] not in data:
# No, so insert it
data[key] = {}
# Insert data
data[key][tokens[1]] = tokens[2:]
# Write new rpmutils.py file
out = open(pyfile,"w")
pm = 0
for l in oldpy:
if pm:
if l.startswith('# End of rpmrc dictionaries'):
pm = 0
out.write(l)
else:
out.write(l)
if l.startswith('# Start of rpmrc dictionaries'):
pm = 1
# Write data sections to single dictionaries
for key, entries in data.items():
out.write("%s = {\n" % key)
for arch in sorted(entries.keys()):
out.write(" '%s' : ['%s'],\n" % (arch, "','".join(entries[arch])))
out.write("}\n\n")
out.close()
except:
pass | [2][SEP1][Try][None][None][For][If][None][If][For][If][If][None][If][If][If][None][None][None][None][For][None][For][None][None][SEP2][1,2][3][][4,5][6,3][7][8,3][9,10][11,3][12,13][][14,15][16,7][17,7][15][3][7][18][19,7][20][21,22][20][18][SEP3][20][4][0][3][4][1][3][0][0][0][1][0][1][9][0][0][1][0][6][1][2][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE CALL NAME LOAD NAME LOAD CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE CALL NAME LOAD NAME LOAD CONSTANT LOAD ASSIGN NAME STORE DICT ASSIGN NAME STORE LIST CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT LOAD FOR NAME STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD CONSTANT CONSTANT IF CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT CONTINUE ASSIGN NAME STORE CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD LOAD IF CALL NAME LOAD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF COMPARE NAME LOAD IN NAME LOAD IF COMPARE SUBSCRIPT NAME LOAD CONSTANT LOAD NOTIN NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE DICT ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD NAME LOAD LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD STORE SUBSCRIPT NAME LOAD SLICE CONSTANT LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD CONSTANT ASSIGN NAME STORE CONSTANT FOR NAME STORE NAME LOAD IF NAME LOAD IF CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CONSTANT FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD NAME LOAD FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD TUPLE NAME LOAD CALL ATTRIBUTE CONSTANT LOAD SUBSCRIPT NAME LOAD NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER PASS |
def stop_threadsafe(self):
"""Stop this task from another thread and wait for it to finish.
This method must not be called from within the BackgroundEventLoop but
will inject self.stop() into the event loop and block until it
returns.
Raises:
TimeoutExpiredError: If the task does not stop in the given
timeout specified in __init__()
"""
if self.stopped:
return
try:
self._loop.run_coroutine(self.stop())
except asyncio.TimeoutError:
raise TimeoutExpiredError("Timeout stopping task {} with {} subtasks".format(self.name, len(self.subtasks))) | [1][SEP1][If][Return][Try][None][None][SEP2][1,2][][3,4][][][SEP3][0][0][0][2][3] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD RETURN TRY EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD |
def _verify_realtime_streams(self, hw):
"""Check that the realtime streams are being produced
"""
print("--> Testing realtime data (takes 2 seconds)")
time.sleep(2.1)
reports = [x for x in hw.iter_reports()]
reports_seen = {key: 0 for key in self._realtime_streams}
for report in reports:
stream_value = report.visible_readings[0].stream
if reports_seen.get(stream_value) is not None:
reports_seen[stream_value] += 1
for stream in reports_seen.keys():
if reports_seen[stream] < 2:
raise ArgumentError("Realtime Stream not pushing any reports", stream=hex(stream), \
reports_seen=reports_seen[stream]) | [2][SEP1][None][For][If][For][None][If][None][SEP2][1][2,3][4,1][5][1][6,3][][SEP3][3][0][1][1][0][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT EXPR CALL NAME LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE LISTCOMP NAME LOAD COMPREHENSION NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICTCOMP NAME LOAD CONSTANT COMPREHENSION NAME STORE ATTRIBUTE NAME LOAD LOAD FOR NAME STORE NAME LOAD ASSIGN NAME STORE ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ISNOT CONSTANT AUGASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE ADD CONSTANT FOR NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE SUBSCRIPT NAME LOAD NAME LOAD LOAD LT CONSTANT RAISE CALL NAME LOAD CONSTANT KEYWORD CALL NAME LOAD NAME LOAD KEYWORD SUBSCRIPT NAME LOAD NAME LOAD LOAD |
def _do_create_keywords(args, kw):
"""This converts any arguments after the action argument into
their equivalent keywords and adds them to the kw argument.
"""
v = kw.get('varlist', ())
# prevent varlist="FOO" from being interpreted as ['F', 'O', 'O']
if is_String(v): v = (v,)
kw['varlist'] = tuple(v)
if args:
# turn positional args into equivalent keywords
cmdstrfunc = args[0]
if cmdstrfunc is None or is_String(cmdstrfunc):
kw['cmdstr'] = cmdstrfunc
elif callable(cmdstrfunc):
kw['strfunction'] = cmdstrfunc
else:
raise SCons.Errors.UserError(
'Invalid command display variable type. '
'You must either pass a string or a callback which '
'accepts (target, source, env) as parameters.')
if len(args) > 1:
kw['varlist'] = tuple(SCons.Util.flatten(args[1:])) + kw['varlist']
if kw.get('strfunction', _null) is not _null \
and kw.get('cmdstr', _null) is not _null:
raise SCons.Errors.UserError(
'Cannot have both strfunction and cmdstr args to Action()') | [2][SEP1][If][None][If][If][If][None][If][None][If][None][None][None][SEP2][1,2][2][3,4][5,6][7][8][9,10][][11,4][8][][4][SEP3][2][0][4][1][2][0][1][1][1][0][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT TUPLE LOAD IF CALL NAME LOAD NAME LOAD ASSIGN NAME STORE TUPLE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL NAME LOAD NAME LOAD IF NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF BOOLOP OR COMPARE NAME LOAD IS CONSTANT CALL NAME LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE NAME LOAD IF CALL NAME LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE NAME LOAD RAISE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD GT CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE BINOP CALL NAME LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD SUBSCRIPT NAME LOAD SLICE CONSTANT LOAD ADD SUBSCRIPT NAME LOAD CONSTANT LOAD IF BOOLOP AND COMPARE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD ISNOT NAME LOAD COMPARE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD ISNOT NAME LOAD RAISE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT |
def settings_directory():
"""Find a per user settings directory that is appropriate for each
type of system that we are installed on.
"""
system = platform.system()
basedir = None
if system == 'Windows':
if 'APPDATA' in os.environ:
basedir = os.environ['APPDATA']
# If we're not on Windows assume we're on some
# kind of posix system or Mac, where the appropriate place would be
# ~/.config
if basedir is None:
basedir = os.path.expanduser('~')
basedir = os.path.join(basedir, '.config')
settings_dir = os.path.abspath(os.path.join(basedir, 'IOTile-Core'))
return settings_dir | [0][SEP1][If][If][If][None][None][Return][SEP2][1,2][3,2][4,5][2][5][][SEP3][1][0][0][0][2][2] | MODULE FUNCTIONDEF ARGUMENTS EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT IF COMPARE NAME LOAD EQ CONSTANT IF COMPARE CONSTANT IN ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD CONSTANT RETURN NAME LOAD |
def set_config(self, key, value):
"""Set a persistent config key to a value, stored in the registry
Args:
key (string): The key name
value (string): The key value
"""
keyname = "config:" + key
self.kvstore.set(keyname, value) | [3][SEP1][None][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE BINOP CONSTANT ADD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD |
def format(self, indent_level, indent_size=4):
"""Format this verifier
Returns:
string: A formatted string
"""
name = self.format_name('Boolean', indent_size)
if self._require_value is not None:
if self.long_desc is not None:
name += '\n'
name += self.wrap_lines('must be %s\n' % str(self._require_value).lower(), 1, indent_size)
return self.wrap_lines(name, indent_level, indent_size) | [3][SEP1][If][If][Return][None][None][SEP2][1,2][3,4][][4][2][SEP3][4][0][1][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT AUGASSIGN NAME STORE ADD CONSTANT AUGASSIGN NAME STORE ADD CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD CALL ATTRIBUTE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD |
def generate(env):
"""Add Builders and construction variables for applelink to an
Environment."""
link.generate(env)
env['FRAMEWORKPATHPREFIX'] = '-F'
env['_FRAMEWORKPATH'] = '${_concat(FRAMEWORKPATHPREFIX, FRAMEWORKPATH, "", __env__)}'
env['_FRAMEWORKS'] = '${_concat("-framework ", FRAMEWORKS, "", __env__)}'
env['LINKCOM'] = env['LINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -dynamiclib')
env['SHLINKCOM'] = env['SHLINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
# TODO: Work needed to generate versioned shared libraries
# Leaving this commented out, and also going to disable versioned library checking for now
# see: http://docstore.mik.ua/orelly/unix3/mac/ch05_04.htm for proper naming
#link._setup_versioned_lib_variables(env, tool = 'applelink')#, use_soname = use_soname)
#env['LINKCALLBACKS'] = link._versioned_lib_callbacks()
# override the default for loadable modules, which are different
# on OS X than dynamic shared libs. echoing what XCode does for
# pre/suffixes:
env['LDMODULEPREFIX'] = ''
env['LDMODULESUFFIX'] = ''
env['LDMODULEFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -bundle')
env['LDMODULECOM'] = '$LDMODULE -o ${TARGET} $LDMODULEFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS' | [1][SEP1][None][SEP2][][SEP3][3] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE BINOP SUBSCRIPT NAME LOAD CONSTANT LOAD ADD CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE BINOP SUBSCRIPT NAME LOAD CONSTANT LOAD ADD CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CONSTANT |