src
stringlengths 75
47.4k
| cfg
stringlengths 32
2.5k
| ast
stringlengths 78
54.9k
|
|---|---|---|
def _set_min_value(self, min_value):
"""Sets current minimum allowed value"""
# Check that the min value can be transformed if a transformation is present
if self._transformation is not None:
if min_value is not None:
try:
_ = self._transformation.forward(min_value)
except FloatingPointError:
raise ValueError("The provided minimum %s cannot be transformed with the transformation %s which "
"is defined for the parameter %s" % (min_value,
type(self._transformation),
self.path))
# Store the minimum as a pure float
self._external_min_value = min_value
# Check that the current value of the parameter is still within the boundaries. If not, issue a warning
if self._external_min_value is not None and self.value < self._external_min_value:
warnings.warn("The current value of the parameter %s (%s) "
"was below the new minimum %s." % (self.name, self.value, self._external_min_value),
exceptions.RuntimeWarning)
self.value = self._external_min_value | [2][SEP1][If][If][If][Try][None][None][None][SEP2][1,2][3,2][4][5,6][][2][][SEP3][0][0][0][0][1][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT IF COMPARE NAME LOAD ISNOT CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXCEPTHANDLER NAME LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT COMPARE ATTRIBUTE NAME LOAD LOAD LT ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD TUPLE ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE ATTRIBUTE NAME LOAD LOAD |
def find_schema_paths(schema_files_path=DEFAULT_SCHEMA_FILES_PATH):
"""Searches the locations in the `SCHEMA_FILES_PATH` to
try to find where the schema SQL files are located.
"""
paths = []
for path in schema_files_path:
if os.path.isdir(path):
paths.append(path)
if paths:
return paths
raise SchemaFilesNotFound("Searched " + os.pathsep.join(schema_files_path)) | [1][SEP1][None][For][If][If][None][Return][None][SEP2][1][2,3][4,1][5,6][1][][][SEP3][0][0][1][0][1][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG NAME LOAD EXPR CONSTANT ASSIGN NAME STORE LIST LOAD FOR NAME STORE NAME LOAD IF CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF NAME LOAD RETURN NAME LOAD RAISE CALL NAME LOAD BINOP CONSTANT ADD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def compress_delete_outdir(outdir):
"""Compress the contents of the passed directory to .tar.gz and delete."""
# Compress output in .tar.gz file and remove raw output
tarfn = outdir + ".tar.gz"
logger.info("\tCompressing output from %s to %s", outdir, tarfn)
with tarfile.open(tarfn, "w:gz") as fh:
fh.add(outdir)
logger.info("\tRemoving output directory %s", outdir)
shutil.rmtree(outdir) | [1][SEP1][None][None][None][SEP2][1][2][][SEP3][2][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE BINOP NAME LOAD ADD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD WITH WITHITEM CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT NAME STORE EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def add_coverage(self, qname, sname, qcover, scover=None):
"""Add percentage coverage values to self.alignment_coverage."""
self.alignment_coverage.loc[qname, sname] = qcover
if scover:
self.alignment_coverage.loc[sname, qname] = scover | [5][SEP1][If][None][SEP2][1][][SEP3][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE NAME LOAD NAME LOAD LOAD STORE NAME LOAD IF NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE NAME LOAD NAME LOAD LOAD STORE NAME LOAD |
def run_dependency_graph(jobgraph, logger=None, jgprefix="ANIm_SGE_JG",
sgegroupsize=10000, sgeargs=None):
"""Creates and runs GridEngine scripts for jobs based on the passed
jobgraph.
- jobgraph - list of jobs, which may have dependencies.
- verbose - flag for multiprocessing verbosity
- logger - a logger module logger (optional)
- jgprefix - a prefix for the submitted jobs, in the scheduler
- sgegroupsize - the maximum size for an array job submission
- sgeargs - additional arguments to qsub
The strategy here is to loop over each job in the list of jobs (jobgraph),
and create/populate a series of Sets of commands, to be run in
reverse order with multiprocessing_run as asynchronous pools.
The strategy here is to loop over each job in the dependency graph, and
add the job to a new list of jobs, swapping out the Job dependency for
the name of the Job on which it depends.
"""
joblist = build_joblist(jobgraph)
# Try to be informative by telling the user what jobs will run
dep_count = 0 # how many dependencies are there
if logger:
logger.info("Jobs to run with scheduler")
for job in joblist:
logger.info("{0}: {1}".format(job.name, job.command))
if len(job.dependencies):
dep_count += len(job.dependencies)
for dep in job.dependencies:
logger.info("\t[^ depends on: %s]" % dep.name)
logger.info("There are %d job dependencies" % dep_count)
# If there are no job dependencies, we can use an array (or series of
# arrays) to schedule our jobs. This cuts down on problems with long
# job lists choking up the queue.
if dep_count == 0:
logger.info("Compiling jobs into JobGroups")
joblist = compile_jobgroups_from_joblist(joblist, jgprefix,
sgegroupsize)
# Send jobs to scheduler
logger.info("Running jobs with scheduler...")
logger.info("Jobs passed to scheduler in order:")
for job in joblist:
logger.info("\t%s" % job.name)
build_and_submit_jobs(os.curdir, joblist, sgeargs)
logger.info("Waiting for SGE-submitted jobs to finish (polling)")
for job in joblist:
job.wait() | [5][SEP1][If][None][If][For][None][None][If][For][None][None][None][For][For][None][None][SEP2][1,2][3][4,5][6,2][5][7][8,3][9,10][11][7][12][13,3][14][11][12][SEP3][6][1][1][0][2][2][4][0][1][1][2][0][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CONSTANT IF NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR NAME STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD AUGASSIGN NAME STORE ADD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD NAME LOAD IF COMPARE NAME LOAD EQ CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR NAME STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD ATTRIBUTE NAME LOAD LOAD EXPR CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR NAME STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD |
def path(self):
"tuple: The full Datastore path represented by this key."
prefix = ()
if self.parent:
prefix = self.parent.path
if self.id_or_name:
return prefix + (self.kind, self.id_or_name)
return prefix + (self.kind,) | [1][SEP1][If][None][If][Return][Return][SEP2][1,2][2][3,4][][][SEP3][0][0][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE TUPLE LOAD IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD RETURN BINOP NAME LOAD ADD TUPLE ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD RETURN BINOP NAME LOAD ADD TUPLE ATTRIBUTE NAME LOAD LOAD LOAD |
def colex (listoflists,cnums):
"""
Extracts from listoflists the columns specified in the list 'cnums'
(cnums can be an integer, a sequence of integers, or a string-expression that
corresponds to a slice operation on the variable x ... e.g., 'x[3:]' will colex
columns 3 onward from the listoflists).
Usage: colex (listoflists,cnums)
Returns: a list-of-lists corresponding to the columns from listoflists
specified by cnums, in the order the column numbers appear in cnums
"""
global index
column = 0
if type(cnums) in [ListType,TupleType]: # if multiple columns to get
index = cnums[0]
column = [x[index] for x in listoflists]
for col in cnums[1:]:
index = col
column = abut(column,[x[index] for x in listoflists])
elif type(cnums) == StringType: # if an 'x[3:]' type expr.
evalstring = 'map(lambda x: x'+cnums+', listoflists)'
column = eval(evalstring)
else: # else it's just 1 col to get
index = cnums
column = [x[index] for x in listoflists]
return column | [2][SEP1][If][None][If][For][None][None][None][Return][SEP2][1,2][3][4,5][6,7][7][7][3][][SEP3][2][0][1][0][1][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT GLOBAL ASSIGN NAME STORE CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD IN LIST NAME LOAD NAME LOAD LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE LISTCOMP SUBSCRIPT NAME LOAD NAME LOAD LOAD COMPREHENSION NAME STORE NAME LOAD FOR NAME STORE SUBSCRIPT NAME LOAD SLICE CONSTANT LOAD ASSIGN NAME STORE NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD LISTCOMP SUBSCRIPT NAME LOAD NAME LOAD LOAD COMPREHENSION NAME STORE NAME LOAD IF COMPARE CALL NAME LOAD NAME LOAD EQ NAME LOAD ASSIGN NAME STORE BINOP BINOP CONSTANT ADD NAME LOAD ADD CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE NAME LOAD ASSIGN NAME STORE LISTCOMP SUBSCRIPT NAME LOAD NAME LOAD LOAD COMPREHENSION NAME STORE NAME LOAD RETURN NAME LOAD |
def lincr(l,cap): # to increment a list up to a max-list of 'cap'
"""
Simulate a counting system from an n-dimensional list.
Usage: lincr(l,cap) l=list to increment, cap=max values for each list pos'n
Returns: next set of values for list l, OR -1 (if overflow)
"""
l[0] = l[0] + 1 # e.g., [0,0,0] --> [2,4,3] (=cap)
for i in range(len(l)):
if l[i] > cap[i] and i < len(l)-1: # if carryover AND not done
l[i] = 0
l[i+1] = l[i+1] + 1
elif l[i] > cap[i] and i == len(l)-1: # overflow past last column, must be finished
l = -1
return l | [2][SEP1][None][For][If][Return][None][If][None][SEP2][1][2,3][4,5][][1][6,1][1][SEP3][0][2][1][0][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE BINOP SUBSCRIPT NAME LOAD CONSTANT LOAD ADD CONSTANT FOR NAME STORE CALL NAME LOAD CALL NAME LOAD NAME LOAD IF BOOLOP AND COMPARE SUBSCRIPT NAME LOAD NAME LOAD LOAD GT SUBSCRIPT NAME LOAD NAME LOAD LOAD COMPARE NAME LOAD LT BINOP CALL NAME LOAD NAME LOAD SUB CONSTANT ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE CONSTANT ASSIGN SUBSCRIPT NAME LOAD BINOP NAME LOAD ADD CONSTANT STORE BINOP SUBSCRIPT NAME LOAD BINOP NAME LOAD ADD CONSTANT LOAD ADD CONSTANT IF BOOLOP AND COMPARE SUBSCRIPT NAME LOAD NAME LOAD LOAD GT SUBSCRIPT NAME LOAD NAME LOAD LOAD COMPARE NAME LOAD EQ BINOP CALL NAME LOAD NAME LOAD SUB CONSTANT ASSIGN NAME STORE UNARYOP USUB CONSTANT RETURN NAME LOAD |
def as_dict( self, key="id" ):
"""
Return a dictionary containing all remaining motifs, using `key`
as the dictionary key.
"""
rval = {}
for motif in self:
rval[ getattr( motif, key ) ] = motif
return rval | [2][SEP1][None][For][None][Return][SEP2][1][2,3][1][][SEP3][0][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE DICT FOR NAME STORE NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD STORE NAME LOAD RETURN NAME LOAD |
def transformString( self, instring ):
"""Extension to scanString, to modify matching text with modified tokens that may
be returned from a parse action. To use transformString, define a grammar and
attach a parse action to it that modifies the returned token list.
Invoking transformString() on a target string will then scan for matches,
and replace the matched text patterns according to the logic in the parse
action. transformString() returns the resulting transformed string."""
out = []
lastE = 0
# force preservation of <TAB>s, to minimize unwanted transformation of string, and to
# keep string locs straight between transformString and scanString
self.keepTabs = True
for t,s,e in self.scanString( instring ):
out.append( instring[lastE:s] )
if t:
if isinstance(t,ParseResults):
out += t.asList()
elif isinstance(t,list):
out += t
else:
out.append(t)
lastE = e
out.append(instring[lastE:])
return "".join(map(_ustr,out)) | [2][SEP1][None][For][If][Return][If][None][None][If][None][None][SEP2][1][2,3][4,5][][6,7][1][5][8,9][5][5][SEP3][0][1][1][3][1][0][1][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT FOR TUPLE NAME STORE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT NAME LOAD SLICE NAME LOAD NAME LOAD LOAD IF NAME LOAD IF CALL NAME LOAD NAME LOAD NAME LOAD AUGASSIGN NAME STORE ADD CALL ATTRIBUTE NAME LOAD LOAD IF CALL NAME LOAD NAME LOAD NAME LOAD AUGASSIGN NAME STORE ADD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT NAME LOAD SLICE NAME LOAD LOAD RETURN CALL ATTRIBUTE CONSTANT LOAD CALL NAME LOAD NAME LOAD NAME LOAD |
def new( self, min, max ):
"""Create an empty index for intervals in the range min, max"""
# Ensure the range will fit given the shifting strategy
assert MIN <= min <= max <= MAX
self.min = min
self.max = max
# Determine offsets to use
self.offsets = offsets_for_max_size( max )
# Determine the largest bin we will actually use
self.bin_count = bin_for_range( max - 1, max, offsets = self.offsets ) + 1
# Create empty bins
self.bins = [ [] for i in range( self.bin_count ) ] | [3][SEP1][None][None][SEP2][1][][SEP3][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT ASSERT COMPARE NAME LOAD LTE LTE LTE NAME LOAD NAME LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE BINOP CALL NAME LOAD BINOP NAME LOAD SUB CONSTANT NAME LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD ADD CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE LISTCOMP LIST LOAD COMPREHENSION NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD |
def to_stormo_scoring_matrix( self, background=None ):
"""
Create a scoring matrix from this count matrix using the method from:
Hertz, G.Z. and G.D. Stormo (1999). Identifying DNA and protein patterns with statistically
significant alignments of multiple sequences. Bioinformatics 15(7): 563-577.
"""
alphabet_size = len( self.alphabet )
if background is None:
background = ones( alphabet_size, float32 ) / alphabet_size
# Row totals as a one column array
totals = numpy.sum( self.values, 1 )[:,newaxis]
values = log2( self.values + background ) \
- log2( totals + 1 ) - log2( background )
return ScoringMatrix.create_from_other( self, values.astype( float32 ) ) | [2][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][1][1][6] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE BINOP CALL NAME LOAD NAME LOAD NAME LOAD DIV NAME LOAD ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT TUPLE SLICE NAME LOAD LOAD LOAD ASSIGN NAME STORE BINOP BINOP CALL NAME LOAD BINOP ATTRIBUTE NAME LOAD LOAD ADD NAME LOAD SUB CALL NAME LOAD BINOP NAME LOAD ADD CONSTANT SUB CALL NAME LOAD NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def get_ip_report(self, this_ip, timeout=None):
""" Get IP address reports.
:param this_ip: a valid IPv4 address in dotted quad notation, for the time being only IPv4 addresses are
supported.
:param timeout: The amount of time in seconds the request should wait before timing out.
:return: JSON response
"""
params = {'apikey': self.api_key, 'ip': this_ip}
try:
response = requests.get(self.base + 'ip-address/report',
params=params,
proxies=self.proxies,
timeout=timeout)
except requests.RequestException as e:
return dict(error=str(e))
return _return_response_and_status_code(response) | [3][SEP1][Try][None][Return][Return][SEP2][1,2][3][][][SEP3][0][1][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE DICT CONSTANT CONSTANT ATTRIBUTE NAME LOAD LOAD NAME LOAD TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP ATTRIBUTE NAME LOAD LOAD ADD CONSTANT KEYWORD NAME LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD RETURN CALL NAME LOAD KEYWORD CALL NAME LOAD NAME LOAD RETURN CALL NAME LOAD NAME LOAD |
def web_hooks(self, include_global=True):
"""Get all web hooks for this project. Includes global hooks."""
from fabric_bolt.web_hooks.models import Hook
ors = [Q(project=self)]
if include_global:
ors.append(Q(project=None))
hooks = Hook.objects.filter(reduce(operator.or_, ors))
return hooks | [2][SEP1][If][None][Return][SEP2][1,2][2][][SEP3][1][2][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT IMPORTFROM ALIAS ASSIGN NAME STORE LIST CALL NAME LOAD KEYWORD NAME LOAD LOAD IF NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD KEYWORD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def form_valid(self, form):
"""After the form is valid lets let people know"""
ret = super(ProjectCopy, self).form_valid(form)
self.copy_relations()
# Good to make note of that
messages.add_message(self.request, messages.SUCCESS, 'Project %s copied' % self.object.name)
return ret | [2][SEP1][Return][SEP2][][SEP3][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE CALL NAME LOAD NAME LOAD NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD RETURN NAME LOAD |
def read_all(self, user=None):
"""
Marks all notifications as read for a user (if supplied)
:param user: Notification recipient.
:return: Updates QuerySet as read.
"""
qs = self.unread()
if user:
qs = qs.filter(recipient=user)
qs.update(read=True) | [2][SEP1][If][None][None][SEP2][1,2][2][][SEP3][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD KEYWORD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD KEYWORD CONSTANT |
def fetch_attributes(self, event, channel):
"""Returns attribute list for a given event/channel."""
try:
for sensor in self.event_states[event]:
if sensor[1] == int(channel):
return sensor
except KeyError:
return None | [3][SEP1][Try][For][Return][If][Return][SEP2][1,2][3][][4,1][][SEP3][0][0][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT TRY FOR NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD IF COMPARE SUBSCRIPT NAME LOAD CONSTANT LOAD EQ CALL NAME LOAD NAME LOAD RETURN NAME LOAD EXCEPTHANDLER NAME LOAD RETURN CONSTANT |
def parse_record(self, raw, indx=0):
"""Parse raw data (that is retrieved by "request") and return pandas.DataFrame.
Returns tuple (data, metadata)
data - pandas.DataFrame with retrieved data.
metadata - pandas.DataFrame with info about symbol, currency, frequency,
displayname and status of given request
"""
suffix = '' if indx == 0 else '_%i' % (indx + 1)
# Parsing status
status = self.status(raw)
# Testing if no errors
if status['StatusType'] != 'Connected':
if self.raise_on_error:
raise DatastreamException('%s (error %i): %s --> "%s"' %
(status['StatusType'], status['StatusCode'],
status['StatusMessage'], status['Request']))
else:
self._test_status_and_warn()
return pd.DataFrame(), {}
record = self.extract_data(raw)
get_field = lambda fldname: record[fldname + suffix]
try:
error = get_field('INSTERROR')
if self.raise_on_error:
raise DatastreamException('Error: %s --> "%s"' %
(error, status['Request']))
else:
self.last_status['StatusMessage'] = error
self.last_status['StatusType'] = 'INSTERROR'
self._test_status_and_warn()
metadata = {'Frequency': '', 'Currency': '', 'DisplayName': '',
'Symbol': '', 'Status': error}
except KeyError:
# Parsing metadata of the symbol
# NB! currency might be returned as symbol thus "unicode" should be used
metadata = {'Frequency': ustr(get_field('FREQUENCY')),
'Currency': ustr(get_field('CCY')),
'DisplayName': ustr(get_field('DISPNAME')),
'Symbol': ustr(get_field('SYMBOL')),
'Status': 'OK'}
# Fields with data
if suffix == '':
fields = [ustr(x) for x in record if '_' not in x]
else:
fields = [ustr(x) for x in record if suffix in x]
# Filter metadata
meta_fields = ['CCY', 'DISPNAME', 'FREQUENCY', 'SYMBOL', 'DATE', 'INSTERROR']
fields = [x.replace(suffix, '') for x in fields
if not any([y in x for y in meta_fields])]
if 'DATE' + suffix in record:
date = record['DATE' + suffix]
elif 'DATE' in record:
date = record['DATE']
else:
date = None
if len(fields) > 0 and date is not None:
# Check if we have a single value or a series
if isinstance(date, dt.datetime):
data = pd.DataFrame({x: [get_field(x)] for x in fields},
index=[date])
else:
data = pd.DataFrame({x: get_field(x)[0] for x in fields},
index=date[0])
else:
data = pd.DataFrame()
metadata = pd.DataFrame(metadata, index=[indx])
metadata = metadata[['Symbol', 'DisplayName', 'Currency', 'Frequency', 'Status']]
return data, metadata | [3][SEP1][If][If][Try][None][Return][If][None][None][None][If][None][None][If][None][If][If][None][None][If][None][None][None][Return][SEP2][1,2][3,4][5,6][][][7,8][9][][9][10,11][12][12][13,14][15][16,17][18,19][15][15][20,21][22][22][22][][SEP3][1][0][1][1][2][1][8][1][1][0][1][1][2][0][0][1][0][0][1][1][2][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE IFEXP COMPARE NAME LOAD EQ CONSTANT CONSTANT BINOP CONSTANT MOD BINOP NAME LOAD ADD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE SUBSCRIPT NAME LOAD CONSTANT LOAD NOTEQ CONSTANT IF ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD TUPLE SUBSCRIPT NAME LOAD CONSTANT LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD RETURN TUPLE CALL ATTRIBUTE NAME LOAD LOAD DICT LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE LAMBDA ARGUMENTS ARG SUBSCRIPT NAME LOAD BINOP NAME LOAD ADD NAME LOAD LOAD TRY ASSIGN NAME STORE CALL NAME LOAD CONSTANT IF ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT STORE NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT STORE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT NAME LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CALL NAME LOAD CALL NAME LOAD CONSTANT CALL NAME LOAD CALL NAME LOAD CONSTANT CALL NAME LOAD CALL NAME LOAD CONSTANT CALL NAME LOAD CALL NAME LOAD CONSTANT CONSTANT IF COMPARE NAME LOAD EQ CONSTANT ASSIGN NAME STORE LISTCOMP CALL NAME LOAD NAME LOAD COMPREHENSION NAME STORE NAME LOAD COMPARE CONSTANT NOTIN NAME LOAD ASSIGN NAME STORE LISTCOMP CALL NAME LOAD NAME LOAD COMPREHENSION NAME STORE NAME LOAD COMPARE NAME LOAD IN NAME LOAD ASSIGN NAME STORE LIST CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT LOAD ASSIGN NAME STORE LISTCOMP CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT COMPREHENSION NAME STORE NAME LOAD UNARYOP NOT CALL NAME LOAD LISTCOMP COMPARE NAME LOAD IN NAME LOAD COMPREHENSION NAME STORE NAME LOAD IF COMPARE BINOP CONSTANT ADD NAME LOAD IN NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD BINOP CONSTANT ADD NAME LOAD LOAD IF COMPARE CONSTANT IN NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE CONSTANT IF BOOLOP AND COMPARE CALL NAME LOAD NAME LOAD GT CONSTANT COMPARE NAME LOAD ISNOT CONSTANT IF CALL NAME LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD DICTCOMP NAME LOAD LIST CALL NAME LOAD NAME LOAD LOAD COMPREHENSION NAME STORE NAME LOAD KEYWORD LIST NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD DICTCOMP NAME LOAD SUBSCRIPT CALL NAME LOAD NAME LOAD CONSTANT LOAD COMPREHENSION NAME STORE NAME LOAD KEYWORD SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD LIST NAME LOAD LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD LIST CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT LOAD LOAD RETURN TUPLE NAME LOAD NAME LOAD LOAD |
def remove(self, child):
"""
Remove the given child from both child list and child indexes
:type child: :class:`Element <hl7apy.core.Element>`
:param child: an instance of :class:`Element <hl7apy.core.Element>` subclass
"""
try:
if self.element == child.traversal_parent:
self._remove_from_traversal_index(child)
else:
self._remove_from_index(child)
self.list.remove(child)
except:
raise | [2][SEP1][Try][If][None][None][None][SEP2][1,2][3,4][][][][SEP3][0][0][0][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT TRY IF COMPARE ATTRIBUTE NAME LOAD LOAD EQ ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXCEPTHANDLER RAISE |
def prepare(self):
'''Prepare to run the docker command'''
self.__make_scubadir()
if self.is_remote_docker:
'''
Docker is running remotely (e.g. boot2docker on OSX).
We don't need to do any user setup whatsoever.
TODO: For now, remote instances won't have any .scubainit
See:
https://github.com/JonathonReinhart/scuba/issues/17
'''
raise ScubaError('Remote docker not supported (DOCKER_HOST is set)')
# Docker is running natively
self.__setup_native_run()
# Apply environment vars from .scuba.yml
self.env_vars.update(self.context.environment) | [1][SEP1][If][None][None][SEP2][1,2][][][SEP3][1][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD EXPR CONSTANT RAISE CALL NAME LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD |
def get_country_long(self, ip):
''' Get country_long '''
rec = self.get_all(ip)
return rec and rec.country_long | [2][SEP1][Return][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN BOOLOP AND NAME LOAD ATTRIBUTE NAME LOAD LOAD |
def rates_for_location(self, postal_code, location_deets=None):
"""Shows the sales tax rates for a given location."""
request = self._get("rates/" + postal_code, location_deets)
return self.responder(request) | [3][SEP1][Return][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT ADD NAME LOAD NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def rubles(amount, zero_for_kopeck=False):
"""Converts float value to in-words representation (for money)"""
try:
res = numeral.rubles(amount, zero_for_kopeck)
except Exception as err:
# because filter must die silently
res = default_value % {'error': err, 'value': str(amount)}
return res | [2][SEP1][Try][None][None][Return][SEP2][1,2][3][3][][SEP3][0][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE BINOP NAME LOAD MOD DICT CONSTANT CONSTANT NAME LOAD CALL NAME LOAD NAME LOAD RETURN NAME LOAD |
def translify(text):
"""Translify russian text"""
try:
res = translit.translify(smart_text(text, encoding))
except Exception as err:
# because filter must die silently
res = default_value % {'error': err, 'value': text}
return res | [1][SEP1][Try][None][None][Return][SEP2][1,2][3][3][][SEP3][0][2][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD NAME LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE BINOP NAME LOAD MOD DICT CONSTANT CONSTANT NAME LOAD NAME LOAD RETURN NAME LOAD |
def fromargskw(argskw, argspecs, slf_or_clsm = False):
"""Turns a linearized list of args into (args, keywords) form
according to given argspecs (like inspect module provides).
"""
res_args = argskw
try:
kwds = argspecs.keywords
except AttributeError:
kwds = argspecs.varkw
if not kwds is None:
res_kw = argskw[-1]
res_args = argskw[:-1]
else:
res_kw = None
if not argspecs.varargs is None:
vargs_pos = (len(argspecs.args)-1) \
if slf_or_clsm else len(argspecs.args)
if vargs_pos > 0:
res_lst = list(argskw[:vargs_pos])
res_lst.extend(argskw[vargs_pos])
res_args = tuple(res_lst)
else:
res_args = argskw[0]
try:
if len(argspecs.kwonlyargs) > 0:
res_kw = {} if res_kw is None else dict(res_kw)
ipos = -len(argspecs.kwonlyargs) - (0 if kwds is None else 1)
for name in argspecs.kwonlyargs:
res_kw[name] = argskw[ipos]
ipos += 1
except AttributeError:
pass
if res_kw is None:
res_kw = {}
return res_args, res_kw | [3][SEP1][Try][None][None][If][None][None][If][If][Try][None][None][If][None][None][If][For][None][Return][None][SEP2][1,2][3][3][4,5][6][6][7,8][9,10][11,12][8][8][13,14][14][15][16,17][18,14][17][][15][SEP3][0][0][0][0][0][0][0][2][0][3][0][1][0][2][0][0][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE NAME LOAD TRY ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE SUBSCRIPT NAME LOAD UNARYOP USUB CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE UNARYOP USUB CONSTANT LOAD ASSIGN NAME STORE CONSTANT IF UNARYOP NOT COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT ASSIGN NAME STORE IFEXP NAME LOAD BINOP CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD SUB CONSTANT CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD GT CONSTANT ASSIGN NAME STORE CALL NAME LOAD SUBSCRIPT NAME LOAD SLICE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT NAME LOAD NAME LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD TRY IF COMPARE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD GT CONSTANT ASSIGN NAME STORE IFEXP COMPARE NAME LOAD IS CONSTANT DICT CALL NAME LOAD NAME LOAD ASSIGN NAME STORE BINOP UNARYOP USUB CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD SUB IFEXP COMPARE NAME LOAD IS CONSTANT CONSTANT CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD AUGASSIGN NAME STORE ADD CONSTANT EXCEPTHANDLER NAME LOAD PASS IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE DICT RETURN TUPLE NAME LOAD NAME LOAD LOAD |
def _tp_relfq_name(tp, tp_name=None, assumed_globals=None, update_assumed_globals=None,
implicit_globals=None):
# _type: (type, Optional[Union[Set[Union[type, types.ModuleType]], Mapping[Union[type, types.ModuleType], str]]], Optional[bool]) -> str
"""Provides the fully qualified name of a type relative to a set of
modules and types that is assumed as globally available.
If assumed_globals is None this always returns the fully qualified name.
If update_assumed_globals is True, this will return the plain type name,
but will add the type to assumed_globals (expected to be a set).
This way a caller can query how to generate an appropriate import section.
If update_assumed_globals is False, assumed_globals can alternatively be
a mapping rather than a set. In that case the mapping is expected to be
an alias table, mapping modules or types to their alias names desired for
displaying.
update_assumed_globals can be None (default). In that case this will return the
plain type name if assumed_globals is None as well (default).
This mode is there to have a less involved default behavior.
"""
if tp_name is None:
tp_name = util.get_class_qualname(tp)
if implicit_globals is None:
implicit_globals = _implicit_globals
else:
implicit_globals = implicit_globals.copy()
implicit_globals.update(_implicit_globals)
if assumed_globals is None:
if update_assumed_globals is None:
return tp_name
md = sys.modules[tp.__module__]
if md in implicit_globals:
return tp_name
name = tp.__module__+'.'+tp_name
pck = None
if not (md.__package__ is None or md.__package__ == ''
or name.startswith(md.__package__)):
pck = md.__package__
return name if pck is None else pck+'.'+name
if tp in assumed_globals:
try:
return assumed_globals[tp]
except:
return tp_name
elif hasattr(tp, '__origin__') and tp.__origin__ in assumed_globals:
try:
return assumed_globals[tp.__origin__]
except:
return tp_name
# For some reason Callable does not have __origin__, so we special-case
# it here. Todo: Find a cleaner solution.
elif is_Callable(tp) and typing.Callable in assumed_globals:
try:
return assumed_globals[typing.Callable]
except:
return tp_name
elif update_assumed_globals == True:
if not assumed_globals is None:
if hasattr(tp, '__origin__') and not tp.__origin__ is None:
toadd = tp.__origin__
elif is_Callable(tp):
toadd = typing.Callable
else:
toadd = tp
if not sys.modules[toadd.__module__] in implicit_globals:
assumed_globals.add(toadd)
return tp_name
else:
md = sys.modules[tp.__module__]
if md in implicit_globals:
return tp_name
md_name = tp.__module__
if md in assumed_globals:
try:
md_name = assumed_globals[md]
except:
pass
else:
if not (md.__package__ is None or md.__package__ == ''
or md_name.startswith(md.__package__)):
md_name = md.__package__+'.'+tp.__module__
return md_name+'.'+tp_name | [5][SEP1][If][None][If][None][None][If][If][If][Return][If][Try][If][Return][If][Return][Return][Try][If][None][Return][Return][Return][Try][If][Return][Return][If][If][If][Return][Return][If][None][If][Try][If][If][None][None][None][None][None][Return][None][SEP2][1,2][2][3,4][5][5][6,7][8,9][10,11][][12,13][14,15][16,17][][18,19][][][20,21][22,23][19][][][][24,25][26,27][][][28,29][30,31][32,33][][][34,35][36][37,38][39,40][41,42][43,29][36][36][42][42][42][][29][SEP3][0][1][0][0][2][1][0][0][0][0][0][1][0][1][0][0][0][1][0][0][0][0][0][1][0][0][1][0][1][0][0][0][0][1][0][1][0][0][0][0][0][0][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 CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD IS CONSTANT IF COMPARE NAME LOAD IS CONSTANT RETURN NAME LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE NAME LOAD IN NAME LOAD RETURN NAME LOAD ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD ADD CONSTANT ADD NAME LOAD ASSIGN NAME STORE CONSTANT IF UNARYOP NOT BOOLOP OR COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD RETURN IFEXP COMPARE NAME LOAD IS CONSTANT NAME LOAD BINOP BINOP NAME LOAD ADD CONSTANT ADD NAME LOAD IF COMPARE NAME LOAD IN NAME LOAD TRY RETURN SUBSCRIPT NAME LOAD NAME LOAD LOAD EXCEPTHANDLER RETURN NAME LOAD IF BOOLOP AND CALL NAME LOAD NAME LOAD CONSTANT COMPARE ATTRIBUTE NAME LOAD LOAD IN NAME LOAD TRY RETURN SUBSCRIPT NAME LOAD ATTRIBUTE NAME LOAD LOAD LOAD EXCEPTHANDLER RETURN NAME LOAD IF BOOLOP AND CALL NAME LOAD NAME LOAD COMPARE ATTRIBUTE NAME LOAD LOAD IN NAME LOAD TRY RETURN SUBSCRIPT NAME LOAD ATTRIBUTE NAME LOAD LOAD LOAD EXCEPTHANDLER RETURN NAME LOAD IF COMPARE NAME LOAD EQ CONSTANT IF UNARYOP NOT COMPARE NAME LOAD IS CONSTANT IF BOOLOP AND CALL NAME LOAD NAME LOAD CONSTANT UNARYOP NOT COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF CALL NAME LOAD NAME LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE NAME LOAD IF UNARYOP NOT COMPARE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD IN NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE NAME LOAD IN NAME LOAD RETURN NAME LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD IN NAME LOAD TRY ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD EXCEPTHANDLER PASS IF UNARYOP NOT BOOLOP OR COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD ADD CONSTANT ADD ATTRIBUTE NAME LOAD LOAD RETURN BINOP BINOP NAME LOAD ADD CONSTANT ADD NAME LOAD |
def combine_type(observations):
"""Combines a list of types into one.
Basically these are combined into a Union with some
additional unification effort (e.g. can apply PEP 484 style numeric tower).
"""
assert len(observations) > 0
if len(observations) == 1:
return observations[0]
else:
if simplify:
simplify_for_Union(observations)
return Union[tuple(observations)] | [1][SEP1][None][If][Return][If][None][Return][SEP2][1][2,3][][4,5][5][][SEP3][1][2][0][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSERT COMPARE CALL NAME LOAD NAME LOAD GT CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT RETURN SUBSCRIPT NAME LOAD CONSTANT LOAD IF NAME LOAD EXPR CALL NAME LOAD NAME LOAD RETURN SUBSCRIPT NAME LOAD CALL NAME LOAD NAME LOAD LOAD |
def is_no_type_check(memb):
"""Checks if an object was annotated with @no_type_check
(from typing or pytypes.typechecker).
"""
try:
return hasattr(memb, '__no_type_check__') and memb.__no_type_check__ or \
memb in _not_type_checked
except TypeError:
return False | [1][SEP1][Try][Return][Return][SEP2][1,2][][][SEP3][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY RETURN BOOLOP OR BOOLOP AND CALL NAME LOAD NAME LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD COMPARE NAME LOAD IN NAME LOAD EXCEPTHANDLER NAME LOAD RETURN CONSTANT |
def import_parallel_gateway_to_graph(diagram_graph, process_id, process_attributes, element):
"""
Adds to graph the new element that represents BPMN parallel gateway.
Parallel gateway doesn't have additional attributes. Separate method is used to improve code readability.
:param diagram_graph: NetworkX graph representing a BPMN process diagram,
:param process_id: string object, representing an ID of process element,
:param process_attributes: dictionary that holds attribute values of 'process' element, which is parent of
imported flow node,
:param element: object representing a BPMN XML 'parallelGateway'.
"""
BpmnDiagramGraphImport.import_gateway_to_graph(diagram_graph, process_id, process_attributes, element) | [4][SEP1][None][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD |
def export_child_lane_set(parent_xml_element, child_lane_set, plane_element):
"""
Creates 'childLaneSet' element for exported BPMN XML file.
:param parent_xml_element: an XML element, parent of exported 'childLaneSet' element,
:param child_lane_set: dictionary with exported 'childLaneSet' element attributes and child elements,
:param plane_element: XML object, representing 'plane' element of exported BPMN 2.0 XML.
"""
lane_set_xml = eTree.SubElement(parent_xml_element, consts.Consts.lane_set)
for key, value in child_lane_set[consts.Consts.lanes].items():
BpmnDiagramGraphExport.export_lane(lane_set_xml, key, value, plane_element) | [3][SEP1][None][For][None][SEP2][1][2][1][SEP3][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE SUBSCRIPT NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD |
def export_element(bpmn_graph, export_elements, node, nodes_classification, order=0, prefix="", condition="",
who="", add_join=False):
"""
Export a node with "Element" classification (task, subprocess or gateway)
:param bpmn_graph: an instance of BpmnDiagramGraph class,
:param export_elements: a dictionary object. The key is a node ID, value is a dictionary of parameters that
will be used in exported CSV document,
:param node: networkx.Node object,
:param nodes_classification: dictionary of classification labels. Key - node id. Value - a list of labels,
:param order: the order param of exported node,
:param prefix: the prefix of exported node - if the task appears after some gateway, the prefix will identify
the branch
:param condition: the condition param of exported node,
:param who: the condition param of exported node,
:param add_join: boolean flag. Used to indicate if "Join" element should be added to CSV.
:return: None or the next node object if the exported node was a gateway join.
"""
node_type = node[1][consts.Consts.type]
node_classification = nodes_classification[node[0]]
outgoing_flows = node[1].get(consts.Consts.outgoing_flow)
if node_type != consts.Consts.parallel_gateway and consts.Consts.default in node[1] \
and node[1][consts.Consts.default] is not None:
default_flow_id = node[1][consts.Consts.default]
else:
default_flow_id = None
if BpmnDiagramGraphCsvExport.classification_join in node_classification and not add_join:
# If the node is a join, then retract the recursion back to the split.
# In case of activity - return current node. In case of gateway - return outgoing node
# (we are making assumption that join has only one outgoing node)
if node_type == consts.Consts.task or node_type == consts.Consts.subprocess:
return node
else:
outgoing_flow_id = outgoing_flows[0]
outgoing_flow = bpmn_graph.get_flow_by_id(outgoing_flow_id)
outgoing_node = bpmn_graph.get_node_by_id(outgoing_flow[2][consts.Consts.target_ref])
return outgoing_node
else:
if node_type == consts.Consts.task:
export_elements.append({"Order": prefix + str(order), "Activity": node[1][consts.Consts.node_name],
"Condition": condition, "Who": who, "Subprocess": "", "Terminated": ""})
elif node_type == consts.Consts.subprocess:
export_elements.append({"Order": prefix + str(order), "Activity": node[1][consts.Consts.node_name],
"Condition": condition, "Who": who, "Subprocess": "yes", "Terminated": ""})
if BpmnDiagramGraphCsvExport.classification_split in node_classification:
next_node = None
alphabet_suffix_index = 0
for outgoing_flow_id in outgoing_flows:
outgoing_flow = bpmn_graph.get_flow_by_id(outgoing_flow_id)
outgoing_node = bpmn_graph.get_node_by_id(outgoing_flow[2][consts.Consts.target_ref])
# This will work only up to 26 outgoing flows
suffix = string.ascii_lowercase[alphabet_suffix_index]
next_prefix = prefix + str(order) + suffix
alphabet_suffix_index += 1
# parallel gateway does not uses conditions
if node_type != consts.Consts.parallel_gateway and consts.Consts.name in outgoing_flow[2] \
and outgoing_flow[2][consts.Consts.name] is not None:
condition = outgoing_flow[2][consts.Consts.name]
else:
condition = ""
if BpmnDiagramGraphCsvExport.classification_join in nodes_classification[outgoing_node[0]]:
export_elements.append(
{"Order": next_prefix + str(1), "Activity": "goto " + prefix + str(order + 1),
"Condition": condition, "Who": who, "Subprocess": "", "Terminated": ""})
elif outgoing_flow_id == default_flow_id:
tmp_next_node = BpmnDiagramGraphCsvExport.export_node(bpmn_graph, export_elements, outgoing_node,
nodes_classification, 1, next_prefix, "else",
who)
if tmp_next_node is not None:
next_node = tmp_next_node
else:
tmp_next_node = BpmnDiagramGraphCsvExport.export_node(bpmn_graph, export_elements, outgoing_node,
nodes_classification, 1, next_prefix,
condition, who)
if tmp_next_node is not None:
next_node = tmp_next_node
if next_node is not None:
return BpmnDiagramGraphCsvExport.export_node(bpmn_graph, export_elements, next_node,
nodes_classification, order=(order + 1), prefix=prefix,
who=who, add_join=True)
elif len(outgoing_flows) == 1:
outgoing_flow_id = outgoing_flows[0]
outgoing_flow = bpmn_graph.get_flow_by_id(outgoing_flow_id)
outgoing_node = bpmn_graph.get_node_by_id(outgoing_flow[2][consts.Consts.target_ref])
return BpmnDiagramGraphCsvExport.export_node(bpmn_graph, export_elements, outgoing_node,
nodes_classification, order=(order + 1), prefix=prefix,
who=who)
else:
return None | [9][SEP1][If][None][None][If][If][If][Return][Return][None][If][If][None][None][If][For][Return][Return][If][If][None][None][Return][If][None][If][If][If][None][None][SEP2][1,2][3][3][4,5][6,7][8,9][][][10][11,10][12,13][10][14][15,16][17,18][][][19,20][21][22][22][][23,24][14][25,26][27,14][28,14][14][14][SEP3][1][0][0][0][0][0][0][2][2][0][9][2][0][1][5][3][0][3][0][0][0][1][0][3][0][1][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF BOOLOP AND COMPARE NAME LOAD NOTEQ ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD COMPARE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IN SUBSCRIPT NAME LOAD CONSTANT LOAD COMPARE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ISNOT CONSTANT ASSIGN NAME STORE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ASSIGN NAME STORE CONSTANT IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD IN NAME LOAD UNARYOP NOT NAME LOAD IF BOOLOP OR COMPARE NAME LOAD EQ ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD COMPARE NAME LOAD EQ ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD RETURN NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD RETURN NAME LOAD IF COMPARE NAME LOAD EQ ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT BINOP NAME LOAD ADD CALL NAME LOAD NAME LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD NAME LOAD NAME LOAD CONSTANT CONSTANT IF COMPARE NAME LOAD EQ ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT BINOP NAME LOAD ADD CALL NAME LOAD NAME LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD NAME LOAD NAME LOAD CONSTANT CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD IN NAME LOAD ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CONSTANT FOR NAME STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD ASSIGN NAME STORE BINOP BINOP NAME LOAD ADD CALL NAME LOAD NAME LOAD ADD NAME LOAD AUGASSIGN NAME STORE ADD CONSTANT IF BOOLOP AND COMPARE NAME LOAD NOTEQ ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD COMPARE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IN SUBSCRIPT NAME LOAD CONSTANT LOAD COMPARE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ISNOT CONSTANT ASSIGN NAME STORE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ASSIGN NAME STORE CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD IN SUBSCRIPT NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT BINOP NAME LOAD ADD CALL NAME LOAD CONSTANT BINOP BINOP CONSTANT ADD NAME LOAD ADD CALL NAME LOAD BINOP NAME LOAD ADD CONSTANT NAME LOAD NAME LOAD CONSTANT CONSTANT IF COMPARE NAME LOAD EQ NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD CONSTANT NAME LOAD CONSTANT NAME LOAD IF COMPARE NAME LOAD ISNOT CONSTANT ASSIGN NAME STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD CONSTANT NAME LOAD NAME LOAD NAME LOAD IF COMPARE NAME LOAD ISNOT CONSTANT ASSIGN NAME STORE NAME LOAD IF COMPARE NAME LOAD ISNOT CONSTANT RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD BINOP NAME LOAD ADD CONSTANT KEYWORD NAME LOAD KEYWORD NAME LOAD KEYWORD CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT ASSIGN NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD KEYWORD BINOP NAME LOAD ADD CONSTANT KEYWORD NAME LOAD KEYWORD NAME LOAD RETURN CONSTANT |
def set_process_ref(self, value):
"""
Setter for 'process_ref' field.
:param value - a new value of 'process_ref' field. Must be either None (process_ref is optional according to
BPMN 2.0 XML Schema) or String.
"""
if not isinstance(value, str):
raise TypeError("ProcessRef must be set to a String")
self.__process_ref = value | [2][SEP1][If][None][None][SEP2][1,2][][][SEP3][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF UNARYOP NOT CALL NAME LOAD NAME LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD |
def add_exclusive_gateway_to_diagram(self, process_id, gateway_name="", gateway_direction="Unspecified",
default=None, node_id=None):
"""
Adds an exclusiveGateway element to BPMN diagram.
:param process_id: string object. ID of parent process,
:param gateway_name: string object. Name of exclusive gateway,
:param gateway_direction: string object. Accepted values - "Unspecified", "Converging", "Diverging", "Mixed".
Default value - "Unspecified".
:param default: string object. ID of flow node, target of gateway default path. Default value - None,
:param node_id: string object. ID of node. Default value - None.
:return: a tuple, where first value is exculusiveGateway ID, second a reference to created object.
"""
exclusive_gateway_id, exclusive_gateway = self.add_gateway_to_diagram(process_id,
consts.Consts.exclusive_gateway,
gateway_name=gateway_name,
gateway_direction=gateway_direction,
node_id=node_id)
self.diagram_graph.node[exclusive_gateway_id][consts.Consts.default] = default
return exclusive_gateway_id, exclusive_gateway | [6][SEP1][Return][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD ASSIGN SUBSCRIPT SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD STORE NAME LOAD RETURN TUPLE NAME LOAD NAME LOAD LOAD |
def _check_random_state(random_state):
"""Checks and processes user input for seeding random numbers.
Parameters
----------
random_state : int, RandomState instance or None
If int, a RandomState instance is created with this integer seed.
If RandomState instance, random_state is returned;
If None, a RandomState instance is created with arbitrary seed.
Returns
-------
scipy.random.RandomState instance
Raises
------
TypeError
If ``random_state`` is not appropriately set.
"""
if random_state is None or isinstance(random_state, int):
return sci.random.RandomState(random_state)
elif isinstance(random_state, sci.random.RandomState):
return random_state
else:
raise TypeError('Seed should be None, int or np.random.RandomState') | [1][SEP1][If][Return][If][Return][None][SEP2][1,2][][3,4][][][SEP3][1][1][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF BOOLOP OR COMPARE NAME LOAD IS CONSTANT CALL NAME LOAD NAME LOAD NAME LOAD RETURN CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD IF CALL NAME LOAD NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD RETURN NAME LOAD RAISE CALL NAME LOAD CONSTANT |
def check_value(self, value):
"""Check the validity of a value for the field."""
#if self.readonly:
# raise error.Error(
# "'{field_name}' field is readonly".format(
# field_name=self.name))
if value and self.size:
if not is_string(value):
raise ValueError("Value supplied has to be a string")
if len(value) > self.size:
raise ValueError(
"Lenght of the '{0}' is limited to {1}".format(
self.name, self.size))
if not value and self.required:
raise ValueError("'{0}' field is required".format(self.name))
return value | [2][SEP1][If][If][If][None][If][None][Return][None][SEP2][1,2][3,4][5,6][][7,2][][][][SEP3][3][1][0][1][1][2][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF BOOLOP AND NAME LOAD ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT CALL NAME LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD GT ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND UNARYOP NOT NAME LOAD ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD RETURN NAME LOAD |
def get_msi_token_webapp(resource):
"""Get a MSI token from inside a webapp or functions.
Env variable will look like:
- MSI_ENDPOINT = http://127.0.0.1:41741/MSI/token/
- MSI_SECRET = 69418689F1E342DD946CB82994CDA3CB
"""
try:
msi_endpoint = os.environ['MSI_ENDPOINT']
msi_secret = os.environ['MSI_SECRET']
except KeyError as err:
err_msg = "{} required env variable was not found. You might need to restart your app/function.".format(err)
_LOGGER.critical(err_msg)
raise RuntimeError(err_msg)
request_uri = '{}/?resource={}&api-version=2017-09-01'.format(msi_endpoint, resource)
headers = {
'secret': msi_secret
}
err = None
try:
result = requests.get(request_uri, headers=headers)
_LOGGER.debug("MSI: Retrieving a token from %s", request_uri)
if result.status_code != 200:
err = result.text
# Workaround since not all failures are != 200
if 'ExceptionMessage' in result.text:
err = result.text
except Exception as ex: # pylint: disable=broad-except
err = str(ex)
if err:
err_msg = "MSI: Failed to retrieve a token from '{}' with an error of '{}'.".format(
request_uri, err
)
_LOGGER.critical(err_msg)
raise RuntimeError(err_msg)
_LOGGER.debug('MSI: token retrieved')
token_entry = result.json()
return token_entry['token_type'], token_entry['access_token'], token_entry | [1][SEP1][Try][None][None][Try][If][None][None][If][If][None][None][Return][SEP2][1,2][3][][4,5][6,7][8][7][9,8][10,11][8][][][SEP3][0][0][3][1][2][1][0][0][0][0][3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RAISE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE DICT CONSTANT NAME LOAD ASSIGN NAME STORE CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ CONSTANT ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE CONSTANT IN ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RAISE CALL NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD RETURN TUPLE SUBSCRIPT NAME LOAD CONSTANT LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD |
def remove_done_callback(self, func):
"""Remove a callback from the long running operation.
:param callable func: The function to be removed from the callbacks.
:raises: ValueError if the long running operation has already
completed.
"""
if self._done is None or self._done.is_set():
raise ValueError("Process is complete.")
self._callbacks = [c for c in self._callbacks if c != func] | [2][SEP1][If][None][None][SEP2][1,2][][][SEP3][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF BOOLOP OR COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD RAISE CALL NAME LOAD CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE LISTCOMP NAME LOAD COMPREHENSION NAME STORE ATTRIBUTE NAME LOAD LOAD COMPARE NAME LOAD NOTEQ NAME LOAD |
def switch_window(self, window_id: int):
"""
Switches currently active tmux window for given task. 0 is the default window
Args:
window_id: integer id of tmux window to use
"""
# windows are numbered sequentially 0, 1, 2, ...
# create any missing windows and make them point to the same directory
if window_id not in self.tmux_available_window_ids:
for i in range(max(self.tmux_available_window_ids)+1, window_id+1):
self._run_raw(f'tmux new-window -t {self.tmux_session} -d')
tmux_window = self.tmux_session + ':' + str(i)
cmd = shlex.quote(f'cd {self.taskdir}')
tmux_cmd = f'tmux send-keys -t {tmux_window} {cmd} Enter'
self._run_raw(tmux_cmd)
self.tmux_available_window_ids.append(i)
self.tmux_window_id = window_id | [2][SEP1][If][For][None][None][SEP2][1,2][3,2][][1][SEP3][0][2][0][5] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG NAME LOAD EXPR CONSTANT IF COMPARE NAME LOAD NOTIN ATTRIBUTE NAME LOAD LOAD FOR NAME STORE CALL NAME LOAD BINOP CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD ADD CONSTANT BINOP NAME LOAD ADD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD JOINEDSTR CONSTANT FORMATTEDVALUE ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD ADD CONSTANT ADD CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD JOINEDSTR CONSTANT FORMATTEDVALUE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE JOINEDSTR CONSTANT FORMATTEDVALUE NAME LOAD CONSTANT FORMATTEDVALUE NAME LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD |
def validate_aws_name(name):
"""Validate resource name using AWS name restrictions from # http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-restrictions"""
assert len(name) <= 127
# disallow unicode characters to avoid pain
assert name == name.encode('ascii').decode('ascii')
assert aws_name_regexp.match(name) | [1][SEP1][None][None][None][SEP2][1][2][][SEP3][1][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSERT COMPARE CALL NAME LOAD NAME LOAD LTE CONSTANT ASSERT COMPARE NAME LOAD EQ CALL ATTRIBUTE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD CONSTANT ASSERT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def pop_ctx():
"""Removes the test context(s) from the current stack(s)
"""
if getattr(_request_ctx_stack.top, 'fixtures_request_context', False):
_request_ctx_stack.pop()
if _app_ctx_stack is not None and getattr(_app_ctx_stack.top, 'fixtures_app_context', False):
_app_ctx_stack.pop() | [0][SEP1][If][None][If][None][SEP2][1,2][2][3][][SEP3][1][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS EXPR CONSTANT IF CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD |
def parse(self, ddl=None, source_database=None):
"""
Parse DDL script.
:param ddl: DDL script
:return: DdlParseTable, Parsed table define info.
"""
if ddl is not None:
self._ddl = ddl
if source_database is not None:
self.source_database = source_database
if self._ddl is None:
raise ValueError("DDL is not specified")
ret = self._DDL_PARSE_EXPR.parseString(self._ddl)
# print(ret.dump())
if "schema" in ret:
self._table.schema = ret["schema"]
self._table.name = ret["table"]
self._table.is_temp = True if "temp" in ret else False
for ret_col in ret["columns"]:
if ret_col.getName() == "column":
# add column
col = self._table.columns.append(
column_name=ret_col["name"],
data_type_array=ret_col["type"],
array_brackets=ret_col['array_brackets'] if "array_brackets" in ret_col else None)
if "constraint" in ret_col:
col.constraint = ret_col["constraint"]
elif ret_col.getName() == "constraint":
# set column constraint
for col_name in ret_col["constraint_columns"]:
col = self._table.columns[col_name]
if ret_col["type"] == "PRIMARY KEY":
col.not_null = True
col.primary_key = True
elif ret_col["type"] in ["UNIQUE", "UNIQUE KEY"]:
col.unique = True
elif ret_col["type"] == "NOT NULL":
col.not_null = True
return self._table | [3][SEP1][If][None][If][None][If][None][If][None][None][For][If][Return][If][If][None][For][If][None][If][None][If][None][SEP2][1,2][2][3,4][4][5,6][][7,8][8][9][10,11][12,13][][14,9][15,9][9][16,9][17,18][15][19,20][15][21,15][15][SEP3][0][0][0][0][0][1][1][0][0][0][1][0][1][1][0][0][0][0][0][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT CONSTANT EXPR CONSTANT IF COMPARE NAME LOAD ISNOT CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD IF COMPARE NAME LOAD ISNOT CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD IS CONSTANT RAISE CALL NAME LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE CONSTANT IN NAME LOAD ASSIGN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD STORE IFEXP COMPARE CONSTANT IN NAME LOAD CONSTANT CONSTANT FOR NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD EQ CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD KEYWORD SUBSCRIPT NAME LOAD CONSTANT LOAD KEYWORD SUBSCRIPT NAME LOAD CONSTANT LOAD KEYWORD IFEXP COMPARE CONSTANT IN NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD CONSTANT IF COMPARE CONSTANT IN NAME LOAD ASSIGN ATTRIBUTE NAME LOAD STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD EQ CONSTANT FOR NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LOAD IF COMPARE SUBSCRIPT NAME LOAD CONSTANT LOAD EQ CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT IF COMPARE SUBSCRIPT NAME LOAD CONSTANT LOAD IN LIST CONSTANT CONSTANT LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT IF COMPARE SUBSCRIPT NAME LOAD CONSTANT LOAD EQ CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT RETURN ATTRIBUTE NAME LOAD LOAD |
def _checks(self, do_checks=False, do_actions=False, poller_tags=None,
reactionner_tags=None, worker_name='none', module_types=None):
"""Get checks from scheduler, used by poller or reactionner when they are
in active mode (passive = False)
This function is not intended for external use. Let the poller and reactionner
manage all this stuff by themselves ;)
:param do_checks: used for poller to get checks
:type do_checks: bool
:param do_actions: used for reactionner to get actions
:type do_actions: bool
:param poller_tags: poller tags to filter on this poller
:type poller_tags: list
:param reactionner_tags: reactionner tags to filter on this reactionner
:type reactionner_tags: list
:param worker_name: Worker name asking (so that the scheduler add it to actions objects)
:type worker_name: str
:param module_types: Module type to filter actions/checks
:type module_types: list
:return: serialized check/action list
:rtype: str
"""
if poller_tags is None:
poller_tags = ['None']
if reactionner_tags is None:
reactionner_tags = ['None']
if module_types is None:
module_types = ['fork']
do_checks = (do_checks == 'True')
do_actions = (do_actions == 'True')
res = self.app.sched.get_to_run_checks(do_checks, do_actions, poller_tags, reactionner_tags,
worker_name, module_types)
return serialize(res, True) | [7][SEP1][If][None][If][None][If][None][Return][SEP2][1,2][2][3,4][4][5,6][6][][SEP3][0][0][0][0][0][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT EXPR CONSTANT IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE LIST CONSTANT LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE LIST CONSTANT LOAD IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE LIST CONSTANT LOAD ASSIGN NAME STORE COMPARE NAME LOAD EQ CONSTANT ASSIGN NAME STORE COMPARE NAME LOAD EQ CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD RETURN CALL NAME LOAD NAME LOAD CONSTANT |
def get_next_invalid_time_from_t(self, timestamp):
"""Get next invalid time for time range
:param timestamp: time we compute from
:type timestamp: int
:return: timestamp of the next invalid time (LOCAL TIME)
:rtype: int
"""
if not self.is_time_valid(timestamp):
return timestamp
# First we search for the day of time range
t_day = self.get_next_invalid_day(timestamp)
# We search for the min of all tr.start > sec_from_morning
# if it's the next day, use a start of the day search for timerange
if timestamp < t_day:
sec_from_morning = self.get_next_future_timerange_invalid(t_day)
else: # it is in this day, so look from t (can be in the evening or so)
sec_from_morning = self.get_next_future_timerange_invalid(timestamp)
# tr can't be valid, or it will be return at the beginning
# sec_from_morning = self.get_next_future_timerange_invalid(t)
# Ok we've got a next invalid day and a invalid possibility in
# timerange, so the next invalid is this day+sec_from_morning
if t_day is not None and sec_from_morning is not None:
return t_day + sec_from_morning + 1
# We've got a day but no sec_from_morning: the timerange is full (0->24h)
# so the next invalid is this day at the day_start
if t_day is not None and sec_from_morning is None:
return t_day
# Then we search for the next day of t
# The sec will be the min of the day
timestamp = get_day(timestamp) + 86400
t_day2 = self.get_next_invalid_day(timestamp)
sec_from_morning = self.get_next_future_timerange_invalid(t_day2)
if t_day2 is not None and sec_from_morning is not None:
return t_day2 + sec_from_morning + 1
if t_day2 is not None and sec_from_morning is None:
return t_day2
# I did not found any valid time
return None | [2][SEP1][If][Return][If][None][None][If][Return][If][Return][If][Return][If][Return][Return][SEP2][1,2][][3,4][5][5][6,7][][8,9][][10,11][][12,13][][][SEP3][1][0][1][1][1][0][0][0][0][3][0][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD LT NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT COMPARE NAME LOAD ISNOT CONSTANT RETURN BINOP BINOP NAME LOAD ADD NAME LOAD ADD CONSTANT IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT COMPARE NAME LOAD IS CONSTANT RETURN NAME LOAD ASSIGN NAME STORE BINOP CALL NAME LOAD NAME LOAD ADD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT COMPARE NAME LOAD ISNOT CONSTANT RETURN BINOP BINOP NAME LOAD ADD NAME LOAD ADD CONSTANT IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT COMPARE NAME LOAD IS CONSTANT RETURN NAME LOAD RETURN CONSTANT |
def change_custom_contact_var(self, contact, varname, varvalue):
"""Change custom contact variable
Format of the line that triggers function call::
CHANGE_CUSTOM_CONTACT_VAR;<contact_name>;<varname>;<varvalue>
:param contact: contact to edit
:type contact: alignak.objects.contact.Contact
:param varname: variable name to change
:type varname: str
:param varvalue: variable new value
:type varvalue: str
:return: None
"""
if varname.upper() in contact.customs:
contact.modified_attributes |= DICT_MODATTR["MODATTR_CUSTOM_VARIABLE"].value
contact.customs[varname.upper()] = varvalue
self.send_an_element(contact.get_update_status_brok()) | [4][SEP1][If][None][SEP2][1][][SEP3][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD IN ATTRIBUTE NAME LOAD LOAD AUGASSIGN ATTRIBUTE NAME LOAD STORE BITOR ATTRIBUTE SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD |
def delay_svc_notification(self, service, notification_time):
"""Modify service first notification delay
Format of the line that triggers function call::
DELAY_SVC_NOTIFICATION;<host_name>;<service_description>;<notification_time>
:param service: service to edit
:type service: alignak.objects.service.Service
:param notification_time: new value to set
:type notification_time:
:return: None
"""
service.first_notification_delay = notification_time
self.send_an_element(service.get_update_status_brok()) | [3][SEP1][None][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD |
def disable_hostgroup_svc_checks(self, hostgroup):
"""Disable service checks for a hostgroup
Format of the line that triggers function call::
DISABLE_HOSTGROUP_SVC_CHECKS;<hostgroup_name>
:param hostgroup: hostgroup to disable
:type hostgroup: alignak.objects.hostgroup.Hostgroup
:return: None
"""
for host_id in hostgroup.get_hosts():
if host_id in self.daemon.hosts:
for service_id in self.daemon.hosts[host_id].services:
if service_id in self.daemon.services:
self.disable_svc_check(self.daemon.services[service_id]) | [2][SEP1][None][For][If][For][If][None][SEP2][1][2][3,1][4,1][5,3][3][SEP3][0][1][0][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD IN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR NAME STORE ATTRIBUTE SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LOAD LOAD IF COMPARE NAME LOAD IN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD LOAD |
def disable_service_flap_detection(self, service):
"""Disable flap detection for a service
Format of the line that triggers function call::
DISABLE_SERVICE_FLAP_DETECTION;<host_name>;<service_description>
:param service: service to edit
:type service: alignak.objects.service.Service
:return: None
"""
if service.flap_detection_enabled:
service.modified_attributes |= DICT_MODATTR["MODATTR_FLAP_DETECTION_ENABLED"].value
service.flap_detection_enabled = False
# Maybe the service was flapping, if so, stop flapping
if service.is_flapping:
service.is_flapping = False
service.flapping_changes = []
self.send_an_element(service.get_update_status_brok()) | [2][SEP1][If][If][None][None][SEP2][1][2,3][3][][SEP3][2][0][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD AUGASSIGN ATTRIBUTE NAME LOAD STORE BITOR ATTRIBUTE SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT IF ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD |
def enable_host_freshness_checks(self):
"""Enable freshness checks (globally)
Format of the line that triggers function call::
ENABLE_HOST_FRESHNESS_CHECKS
:return: None
"""
if not self.my_conf.check_host_freshness:
self.my_conf.modified_attributes |= \
DICT_MODATTR["MODATTR_FRESHNESS_CHECKS_ENABLED"].value
self.my_conf.check_host_freshness = True
self.my_conf.explode_global_conf()
self.daemon.update_program_status() | [1][SEP1][If][None][SEP2][1][][SEP3][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD AUGASSIGN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD STORE BITOR ATTRIBUTE SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD ASSIGN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD STORE CONSTANT EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD |
def process_host_check_result(self, host, status_code, plugin_output):
"""Process host check result
Format of the line that triggers function call::
PROCESS_HOST_CHECK_RESULT;<host_name>;<status_code>;<plugin_output>
:param host: host to process check to
:type host: alignak.objects.host.Host
:param status_code: exit code of plugin
:type status_code: int
:param plugin_output: plugin output
:type plugin_output: str
:return: None
TODO: say that check is PASSIVE
"""
now = time.time()
cls = host.__class__
# If globally disabled OR host disabled, do not launch..
if not cls.accept_passive_checks or not host.passive_checks_enabled:
return
try:
plugin_output = plugin_output.decode('utf8', 'ignore')
logger.debug('%s > Passive host check plugin output: %s',
host.get_full_name(), plugin_output)
except AttributeError:
# Python 3 will raise an exception
pass
except UnicodeError:
pass
# Maybe the check is just too old, if so, bail out!
if self.current_timestamp < host.last_chk:
logger.debug('%s > Passive host check is too old (%.2f seconds). '
'Ignoring, check output: %s',
host.get_full_name(), self.current_timestamp < host.last_chk,
plugin_output)
return
chk = host.launch_check(now, self.hosts, self.services, self.timeperiods,
self.daemon.macromodulations, self.daemon.checkmodulations,
self.daemon.checks, force=True)
# We will not have a check if an host/service is checked but it has no defined check_command
if not chk:
return
# Now we 'transform the check into a result'
# So exit_status, output and status is eaten by the host
chk.exit_status = status_code
chk.get_outputs(plugin_output, host.max_plugins_output_length)
chk.status = ACT_STATUS_WAIT_CONSUME
chk.check_time = self.current_timestamp # we are using the external command timestamps
# Set the corresponding host's check type to passive
chk.set_type_passive()
# self.daemon.nb_check_received += 1
self.send_an_element(chk)
# Ok now this result will be read by the scheduler the next loop
# raise a passive check log only if needed
if self.my_conf.log_passive_checks:
log_level = 'info'
if status_code == 1: # DOWN
log_level = 'error'
if status_code == 2: # UNREACHABLE
log_level = 'warning'
self.send_an_element(make_monitoring_log(
log_level, 'PASSIVE HOST CHECK: %s;%d;%s;%s;%s' % (
host.get_name(), status_code, chk.output, chk.long_output, chk.perf_data))) | [4][SEP1][If][Return][Try][None][None][None][If][Return][If][Return][If][If][None][If][None][None][SEP2][1,2][][3,4,5][6][6][6][7,8][][9,10][][11][12,13][13][14,15][15][][SEP3][1][0][0][3][0][0][0][2][1][0][6][0][0][0][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF BOOLOP OR UNARYOP NOT ATTRIBUTE NAME LOAD LOAD UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RETURN TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXCEPTHANDLER NAME LOAD PASS EXCEPTHANDLER NAME LOAD PASS IF COMPARE ATTRIBUTE NAME LOAD LOAD LT ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD COMPARE ATTRIBUTE NAME LOAD LOAD LT ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD KEYWORD CONSTANT IF UNARYOP NOT NAME LOAD RETURN ASSIGN ATTRIBUTE NAME LOAD STORE NAME 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 ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CONSTANT IF COMPARE NAME LOAD EQ CONSTANT ASSIGN NAME STORE CONSTANT IF COMPARE NAME LOAD EQ CONSTANT ASSIGN NAME STORE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD BINOP CONSTANT MOD TUPLE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD |
def schedule_svc_downtime(self, service, start_time, end_time, fixed,
trigger_id, duration, author, comment):
"""Schedule a service downtime
Format of the line that triggers function call::
SCHEDULE_SVC_DOWNTIME;<host_name>;<service_description><start_time>;<end_time>;
<fixed>;<trigger_id>;<duration>;<author>;<comment>
:param service: service to check
:type service: alignak.object.service.Service
:param start_time: downtime start time
:type start_time:
:param end_time: downtime end time
:type end_time:
:param fixed: is downtime fixed
:type fixed: bool
:param trigger_id: downtime id that triggered this one
:type trigger_id: int
:param duration: downtime duration
:type duration: int
:param author: downtime author
:type author: str
:param comment: downtime comment
:type comment: str
:return: None
"""
data = {'ref': service.uuid, 'ref_type': service.my_type, 'start_time': start_time,
'end_time': end_time, 'fixed': fixed, 'trigger_id': trigger_id,
'duration': duration, 'author': author, 'comment': comment}
downtime = Downtime(data)
downtime.add_automatic_comment(service)
service.add_downtime(downtime)
self.send_an_element(service.get_update_status_brok())
if trigger_id not in ('', 0):
for item in self.daemon.services:
if trigger_id in item.downtimes:
service.downtimes[trigger_id].trigger_me(downtime.uuid) | [9][SEP1][If][For][If][None][SEP2][1][2][3,1][1][SEP3][5][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE DICT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL NAME 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 CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD NOTIN TUPLE CONSTANT CONSTANT LOAD FOR NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE NAME LOAD IN ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD |
def post(self, path, args, wait=False):
"""POST an HTTP request to a daemon
:param path: path to do the request
:type path: str
:param args: args to add in the request
:type args: dict
:param wait: True for a long timeout
:type wait: bool
:return: Content of the HTTP response if server returned 200
:rtype: str
"""
uri = self.make_uri(path)
timeout = self.make_timeout(wait)
for (key, value) in list(args.items()):
args[key] = serialize(value, True)
try:
logger.debug("post: %s, timeout: %s, params: %s", uri, timeout, args)
rsp = self._requests_con.post(uri, json=args, timeout=timeout, verify=self.strong_ssl)
logger.debug("got: %d - %s", rsp.status_code, rsp.text)
if rsp.status_code != 200:
raise HTTPClientDataException(rsp.status_code, rsp.text, uri)
return rsp.content
except (requests.Timeout, requests.ConnectTimeout):
raise HTTPClientTimeoutException(timeout, uri)
except requests.ConnectionError as exp:
raise HTTPClientConnectionException(uri, exp.args[0])
except Exception as exp:
raise HTTPClientException('Request error to %s: %s' % (uri, exp)) | [4][SEP1][None][For][None][Try][If][None][None][None][None][Return][SEP2][1][2,3][1][4,5,6,7][8,9][][][][][][SEP3][2][2][1][0][3][1][1][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE CALL NAME LOAD NAME LOAD CONSTANT TRY EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD KEYWORD NAME LOAD KEYWORD NAME LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ CONSTANT RAISE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER TUPLE ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD RAISE CALL NAME LOAD NAME LOAD NAME LOAD EXCEPTHANDLER ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD NAME LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD EXCEPTHANDLER NAME LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD |
def get_broks(self):
"""Get brok list from satellite
:return: A copy of the broks list
:rtype: list
"""
res = copy.copy(self.broks)
del self.broks[:]
return res | [1][SEP1][Return][SEP2][][SEP3][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD DELETE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD SLICE DEL RETURN NAME LOAD |
def dict_to_serialized_dict(ref, the_dict):
"""Serialize the list of elements to a dictionary
Used for the retention store
:param ref: Not used
:type ref:
:param the_dict: dictionary to convert
:type the_dict: dict
:return: dict of serialized
:rtype: dict
"""
result = {}
for elt in list(the_dict.values()):
if not getattr(elt, 'serialize', None):
continue
result[elt.uuid] = elt.serialize()
return result | [2][SEP1][None][For][If][Return][None][SEP2][1][2,3][4,1][][1][SEP3][0][3][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE DICT FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT CALL NAME LOAD NAME LOAD CONSTANT CONSTANT CONTINUE ASSIGN SUBSCRIPT NAME LOAD ATTRIBUTE NAME LOAD LOAD STORE CALL ATTRIBUTE NAME LOAD LOAD RETURN NAME LOAD |
def load_global_conf(cls, global_configuration):
"""
Apply global Alignak configuration.
Some objects inherit some properties from the global configuration if they do not
define their own value. E.g. the global 'accept_passive_service_checks' is inherited
by the services as 'accept_passive_checks'
:param cls: parent object
:type cls: object
:param global_configuration: current object (child)
:type global_configuration: object
:return: None
"""
logger.debug("Propagate global parameter for %s:", cls)
for prop, entry in global_configuration.properties.items():
# If some global managed configuration properties have a class_inherit clause,
if not entry.managed or not getattr(entry, 'class_inherit'):
continue
for (cls_dest, change_name) in entry.class_inherit:
if cls_dest == cls: # ok, we've got something to get
value = getattr(global_configuration, prop)
logger.debug("- global parameter %s=%s -> %s=%s",
prop, getattr(global_configuration, prop),
change_name, value)
if change_name is None:
setattr(cls, prop, value)
else:
setattr(cls, change_name, value) | [2][SEP1][None][For][If][For][If][If][None][None][SEP2][1][2][3,1][4,1][5,3][6,7][3][3][SEP3][1][6][1][0][0][3][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF BOOLOP OR UNARYOP NOT ATTRIBUTE NAME LOAD LOAD UNARYOP NOT CALL NAME LOAD NAME LOAD CONSTANT CONTINUE FOR TUPLE NAME STORE NAME STORE STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD EQ NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD IF COMPARE NAME LOAD IS CONSTANT EXPR CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD |
def index_template(self, tpl):
"""
Indexes a template by `name` into the `name_to_template` dictionary.
:param tpl: The template to index
:type tpl: alignak.objects.item.Item
:return: None
"""
objcls = self.inner_class.my_type
name = getattr(tpl, 'name', '')
if not name:
mesg = "a %s template has been defined without name, from: %s" % \
(objcls, tpl.imported_from)
tpl.add_error(mesg)
elif name in self.name_to_template:
tpl = self.manage_conflict(tpl, name)
self.name_to_template[name] = tpl
logger.debug("Indexed a %s template: %s, uses: %s",
tpl.my_type, name, getattr(tpl, 'use', 'Nothing'))
return tpl | [2][SEP1][If][None][If][Return][None][SEP2][1,2][3][4,3][][3][SEP3][1][1][0][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD CONSTANT CONSTANT IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE BINOP CONSTANT MOD TUPLE NAME LOAD ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD IN ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD NAME LOAD CALL NAME LOAD NAME LOAD CONSTANT CONSTANT RETURN NAME LOAD |
def get_hosts_from_hostgroups(hgname, hostgroups):
"""
Get hosts of hostgroups
:param hgname: hostgroup name
:type hgname: str
:param hostgroups: hostgroups object (all hostgroups)
:type hostgroups: alignak.objects.hostgroup.Hostgroups
:return: list of hosts
:rtype: list
"""
if not isinstance(hgname, list):
hgname = [e.strip() for e in hgname.split(',') if e.strip()]
host_names = []
for name in hgname:
hostgroup = hostgroups.find_by_name(name)
if hostgroup is None:
raise ValueError("the hostgroup '%s' is unknown" % hgname)
mbrs = [h.strip() for h in hostgroup.get_hosts() if h.strip()]
host_names.extend(mbrs)
return host_names | [2][SEP1][If][None][None][For][If][Return][None][None][SEP2][1,2][2][3][4,5][6,7][][][3][SEP3][1][3][0][4][1][0][1][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF UNARYOP NOT CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE LISTCOMP CALL ATTRIBUTE NAME LOAD LOAD COMPREHENSION NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE LIST LOAD FOR NAME STORE NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD IS CONSTANT RAISE CALL NAME LOAD BINOP CONSTANT MOD NAME LOAD ASSIGN NAME STORE LISTCOMP CALL ATTRIBUTE NAME LOAD LOAD COMPREHENSION NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def list_all_elements(self):
"""Get all host/service uuid in our node and below
:return: list of hosts/services uuids
:rtype: list
"""
res = []
# We are a host/service
if self.operand in ['host', 'service']:
return [self.sons[0]]
for son in self.sons:
res.extend(son.list_all_elements())
# and returns a list of unique uuids
return list(set(res)) | [1][SEP1][If][Return][For][None][Return][SEP2][1,2][][3,4][2][][SEP3][0][0][0][2][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD IN LIST CONSTANT CONSTANT LOAD RETURN LIST SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD RETURN CALL NAME LOAD CALL NAME LOAD NAME LOAD |
def is_correct(self):
"""
check if each properties of timeperiods are valid
:return: True if is correct, otherwise False
:rtype: bool
"""
valid = True
# We do not want a same hg to be explode again and again
# so we tag it
for timeperiod in list(self.items.values()):
timeperiod.rec_tag = False
for timeperiod in list(self.items.values()):
for tmp_tp in list(self.items.values()):
tmp_tp.rec_tag = False
valid = timeperiod.check_exclude_rec() and valid
# We clean the tags and collect the warning/erro messages
for timeperiod in list(self.items.values()):
del timeperiod.rec_tag
# Now other checks
if not timeperiod.is_correct():
valid = False
source = getattr(timeperiod, 'imported_from', "unknown source")
msg = "Configuration in %s::%s is incorrect; from: %s" % (
timeperiod.my_type, timeperiod.get_name(), source
)
self.add_error(msg)
self.configuration_errors += timeperiod.configuration_errors
self.configuration_warnings += timeperiod.configuration_warnings
# And check all timeperiods for correct (sunday is false)
for timeperiod in self:
valid = timeperiod.is_correct() and valid
return valid | [1][SEP1][None][For][None][For][For][For][None][None][If][For][None][None][None][Return][SEP2][1][2,3][1][4,5][6,7][8,9][4][3][10,11][12,13][11][5][9][][SEP3][0][2][0][3][2][2][0][1][1][0][3][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CONSTANT FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT ASSIGN NAME STORE BOOLOP AND CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD FOR NAME STORE CALL NAME LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD DELETE ATTRIBUTE NAME LOAD DEL IF UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD CONSTANT CONSTANT ASSIGN NAME STORE BINOP CONSTANT MOD TUPLE ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD AUGASSIGN ATTRIBUTE NAME LOAD STORE ADD ATTRIBUTE NAME LOAD LOAD AUGASSIGN ATTRIBUTE NAME LOAD STORE ADD ATTRIBUTE NAME LOAD LOAD FOR NAME STORE NAME LOAD ASSIGN NAME STORE BOOLOP AND CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def _delete_unwanted_caracters(self, chain):
"""Remove not wanted char from chain
unwanted char are illegal_macro_output_chars attribute
:param chain: chain to remove char from
:type chain: str
:return: chain cleaned
:rtype: str
"""
try:
chain = chain.decode('utf8', 'replace')
except UnicodeEncodeError:
# If it is still encoded correctly, ignore...
pass
except AttributeError:
# Python 3 will raise an exception because the line is still unicode
pass
for char in self.illegal_macro_output_chars:
chain = chain.replace(char, '')
return chain | [2][SEP1][Try][None][None][None][For][None][Return][SEP2][1,2,3][4][4][4][5,6][4][][SEP3][0][1][0][0][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CONSTANT EXCEPTHANDLER NAME LOAD PASS EXCEPTHANDLER NAME LOAD PASS FOR NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT RETURN NAME LOAD |
def get_instances(self):
"""Create, init and then returns the list of module instances that the caller needs.
This method is called once the Python modules are loaded to initialize the modules.
If an instance can't be created or initialized then only log is doneand that
instance is skipped. The previous modules instance(s), if any, are all cleaned.
:return: module instances list
:rtype: list
"""
self.clear_instances()
for (alignak_module, python_module) in self.modules_assoc:
alignak_module.properties = python_module.properties.copy()
alignak_module.my_daemon = self.daemon
logger.info("Alignak starting module '%s'", alignak_module.get_name())
if getattr(alignak_module, 'modules', None):
modules = []
for module_uuid in alignak_module.modules:
if module_uuid in self.modules:
modules.append(self.modules[module_uuid])
alignak_module.modules = modules
logger.debug("Module '%s', parameters: %s",
alignak_module.get_name(), alignak_module.__dict__)
try:
instance = python_module.get_instance(alignak_module)
if not isinstance(instance, BaseModule): # pragma: no cover, simple protection
self.configuration_errors.append("Module %s instance is not a "
"BaseModule instance: %s"
% (alignak_module.get_name(),
type(instance)))
raise AttributeError
# pragma: no cover, simple protection
except Exception as exp: # pylint: disable=broad-except
logger.error("The module %s raised an exception on loading, I remove it!",
alignak_module.get_name())
logger.exception("Exception: %s", exp)
self.configuration_errors.append("The module %s raised an exception on "
"loading: %s, I remove it!"
% (alignak_module.get_name(), str(exp)))
else:
# Give the module the data to which daemon/module it is loaded into
instance.set_loaded_into(self.daemon.name)
self.instances.append(instance)
for instance in self.instances:
# External instances are not initialized now, but only when they are started
if not instance.is_external and not self.try_instance_init(instance):
# If the init failed, we put in in the restart queue
logger.warning("The module '%s' failed to initialize, "
"I will try to restart it later", instance.name)
self.set_to_restart(instance)
return self.instances | [1][SEP1][None][For][If][For][None][Try][If][Return][For][If][None][None][If][None][None][None][None][SEP2][1][2,3][4,5][6,7][8][9,10][11,3][][12,13][14,15][1][3][16,8][5][][1][8][SEP3][1][15][5][0][0][4][1][0][0][2][6][2][0][0][3][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD FOR TUPLE NAME STORE NAME STORE STORE ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD IF CALL NAME LOAD NAME LOAD CONSTANT CONSTANT ASSIGN NAME STORE LIST LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD IN ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF UNARYOP NOT CALL NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD BINOP CONSTANT MOD TUPLE CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD LOAD RAISE NAME LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD BINOP CONSTANT MOD TUPLE CALL ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND UNARYOP NOT ATTRIBUTE NAME LOAD LOAD UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN ATTRIBUTE NAME LOAD LOAD |
def check_dir(self, dirname):
"""Check and create directory
:param dirname: file name
:type dirname; str
:return: None
"""
try:
os.makedirs(dirname)
dir_stat = os.stat(dirname)
print("Created the directory: %s, stat: %s" % (dirname, dir_stat))
if not dir_stat.st_uid == self.uid:
os.chown(dirname, self.uid, self.gid)
os.chmod(dirname, 0o775)
dir_stat = os.stat(dirname)
print("Changed directory ownership and permissions: %s, stat: %s"
% (dirname, dir_stat))
self.pre_log.append(("DEBUG",
"Daemon '%s' directory %s checking... "
"User uid: %s, directory stat: %s."
% (self.name, dirname, os.getuid(), dir_stat)))
self.pre_log.append(("INFO",
"Daemon '%s' directory %s did not exist, I created it. "
"I set ownership for this directory to %s:%s."
% (self.name, dirname, self.user, self.group)))
except OSError as exp:
if exp.errno == errno.EEXIST and os.path.isdir(dirname):
# Directory still exists...
pass
else:
self.pre_log.append(("ERROR",
"Daemon directory '%s' did not exist, "
"and I could not create. Exception: %s"
% (dirname, exp)))
self.exit_on_error("Daemon directory '%s' did not exist, "
"and I could not create.'. Exception: %s"
% (dirname, exp), exit_code=3) | [2][SEP1][Try][If][If][None][None][None][None][SEP2][1,2][3,4][5,6][4][][][][SEP3][3][3][1][4][3][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT TRY EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD IF UNARYOP NOT COMPARE ATTRIBUTE NAME LOAD LOAD EQ ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE CONSTANT BINOP CONSTANT MOD TUPLE ATTRIBUTE NAME LOAD LOAD NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE CONSTANT BINOP CONSTANT MOD TUPLE ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD LOAD EXCEPTHANDLER NAME LOAD IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD EQ ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD PASS EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE CONSTANT BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD TUPLE NAME LOAD NAME LOAD LOAD KEYWORD CONSTANT |
def wait_for_initial_conf(self, timeout=1.0):
"""Wait initial configuration from the arbiter.
Basically sleep 1.0 and check if new_conf is here
:param timeout: timeout to wait
:type timeout: int
:return: None
"""
logger.info("Waiting for initial configuration")
# Arbiter do not already set our have_conf param
_ts = time.time()
while not self.new_conf and not self.interrupted:
# Make a pause and check if the system time changed
_, _ = self.make_a_pause(timeout, check_time_change=True)
if not self.interrupted:
logger.info("Got initial configuration, waited for: %.2f seconds", time.time() - _ts)
statsmgr.timer('configuration.initial', time.time() - _ts)
else:
logger.info("Interrupted before getting the initial configuration") | [2][SEP1][None][While][None][If][None][None][SEP2][1][2,3][1][4,5][][][SEP3][2][0][1][0][4][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG CONSTANT EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD WHILE BOOLOP AND UNARYOP NOT ATTRIBUTE NAME LOAD LOAD UNARYOP NOT ATTRIBUTE NAME LOAD LOAD ASSIGN TUPLE NAME STORE NAME STORE STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT BINOP CALL ATTRIBUTE NAME LOAD LOAD SUB NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT BINOP CALL ATTRIBUTE NAME LOAD LOAD SUB NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT |
def get_instance(mod_conf):
"""
Return a module instance for the modules manager
:param mod_conf: the module properties as defined globally in this file
:return:
"""
logger.info("Giving an instance of %s for alias: %s",
mod_conf.python_name, mod_conf.module_alias)
return InnerMetrics(mod_conf) | [1][SEP1][Return][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD RETURN CALL NAME LOAD NAME LOAD |
def update_recurrent_works_tick(self, conf):
"""Modify the tick value for the scheduler recurrent work
A tick is an amount of loop of the scheduler before executing the recurrent work
The provided configuration may contain some tick-function_name keys that contain
a tick value to be updated. Those parameters are defined in the alignak environment file.
Indeed this function is called with the Scheduler daemon object. Note that the ``conf``
parameter may also be a dictionary.
:param conf: the daemon link configuration to search in
:type conf: alignak.daemons.schedulerdaemon.Alignak
:return: None
"""
for key in self.recurrent_works:
(name, fun, _) = self.recurrent_works[key]
if isinstance(conf, dict):
new_tick = conf.get('tick_%s' % name, None)
else:
new_tick = getattr(conf, 'tick_%s' % name, None)
if new_tick is not None:
logger.debug("Requesting to change the default tick to %d for the action %s",
int(new_tick), name)
else:
continue
# Update the default scheduler tick for this function
try:
new_tick = int(new_tick)
logger.info("Changing the default tick to %d for the action %s", new_tick, name)
self.recurrent_works[key] = (name, fun, new_tick)
except ValueError:
logger.warning("Changing the default tick for '%s' to '%s' failed!", new_tick, name) | [2][SEP1][None][For][If][None][None][If][None][Try][None][None][SEP2][1][2][3,4][5][5][6,1][7][8,9][1][1][SEP3][0][5][1][1][1][0][2][0][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN TUPLE NAME STORE NAME STORE NAME STORE STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD LOAD IF CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD BINOP CONSTANT MOD NAME LOAD CONSTANT ASSIGN NAME STORE CALL NAME LOAD NAME LOAD BINOP CONSTANT MOD NAME LOAD CONSTANT IF COMPARE NAME LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL NAME LOAD NAME LOAD NAME LOAD CONTINUE TRY ASSIGN NAME STORE CALL NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD ASSIGN SUBSCRIPT ATTRIBUTE NAME LOAD LOAD NAME LOAD STORE TUPLE NAME LOAD NAME LOAD NAME LOAD LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD |
def get_retention_data(self): # pylint: disable=too-many-branches,too-many-statements
# pylint: disable=too-many-locals
"""Get all hosts and services data to be sent to the retention storage.
This function only prepares the data because a module is in charge of making
the data survive to the scheduler restart.
todo: Alignak scheduler creates two separate dictionaries: hosts and services
It would be better to merge the services into the host dictionary!
:return: dict containing host and service data
:rtype: dict
"""
retention_data = {
'hosts': {}, 'services': {}
}
for host in self.hosts:
h_dict = {}
# Get the hosts properties and running properties
properties = host.__class__.properties
properties.update(host.__class__.running_properties)
for prop, entry in list(properties.items()):
if not entry.retention:
continue
val = getattr(host, prop)
# If a preparation function exists...
prepare_retention = entry.retention_preparation
if prepare_retention:
val = prepare_retention(host, val)
h_dict[prop] = val
retention_data['hosts'][host.host_name] = h_dict
logger.info('%d hosts sent to retention', len(retention_data['hosts']))
# Same for services
for service in self.services:
s_dict = {}
# Get the services properties and running properties
properties = service.__class__.properties
properties.update(service.__class__.running_properties)
for prop, entry in list(properties.items()):
if not entry.retention:
continue
val = getattr(service, prop)
# If a preparation function exists...
prepare_retention = entry.retention_preparation
if prepare_retention:
val = prepare_retention(service, val)
s_dict[prop] = val
retention_data['services'][(service.host_name, service.service_description)] = s_dict
logger.info('%d services sent to retention', len(retention_data['services']))
return retention_data | [1][SEP1][None][For][None][None][For][For][If][None][None][Return][If][For][None][None][If][None][If][None][None][SEP2][1][2,3][4][5][6,7][8,9][10,4][1][11][][12,13][14,15][13][4][16,11][5][17,18][18][11][SEP3][0][4][1][2][4][4][0][0][1][2][1][4][1][0][0][0][1][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE DICT CONSTANT CONSTANT DICT DICT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD CONTINUE ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE NAME LOAD ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE DICT ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD CONTINUE ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD NAME LOAD STORE NAME LOAD ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD TUPLE ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD STORE NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD RETURN NAME LOAD |
def get_return_from(self, check):
"""Update check data from action (notification for instance)
:param check: action to get data from
:type check: alignak.action.Action
:return: None
"""
for prop in ['exit_status', 'output', 'long_output', 'check_time', 'execution_time',
'perf_data', 'u_time', 's_time']:
setattr(self, prop, getattr(check, prop)) | [2][SEP1][None][For][None][SEP2][1][2][1][SEP3][0][0][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR NAME STORE LIST CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT LOAD EXPR CALL NAME LOAD NAME LOAD NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD |
def apply_dependencies(self):
"""Loop on hosts and register dependency between parent and son
call Host.fill_parents_dependency()
:return: None
"""
for host in self:
for parent_id in getattr(host, 'parents', []):
if parent_id is None:
continue
parent = self[parent_id]
if parent.active_checks_enabled:
# Add parent in the list
host.act_depend_of.append((parent_id, ['d', 'x', 's', 'f'], '', True))
# Add child in the parent
parent.act_depend_of_me.append((host.uuid, ['d', 'x', 's', 'f'], '', True))
# And add the parent/child dep filling too, for broking
parent.child_dependencies.add(host.uuid)
host.parent_dependencies.add(parent_id) | [1][SEP1][None][For][For][If][If][None][SEP2][1][2][3,1][4,2][5,2][2][SEP3][0][0][5][0][0][4] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT FOR NAME STORE NAME LOAD FOR NAME STORE CALL NAME LOAD NAME LOAD CONSTANT LIST LOAD IF COMPARE NAME LOAD IS CONSTANT CONTINUE ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD IF ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE NAME LOAD LIST CONSTANT CONSTANT CONSTANT CONSTANT LOAD CONSTANT CONSTANT LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD TUPLE ATTRIBUTE NAME LOAD LOAD LIST CONSTANT CONSTANT CONSTANT CONSTANT LOAD CONSTANT CONSTANT LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def create_connection(self):
"""Initialize HTTP connection with a satellite (con attribute) and
set its uri attribute
This is called on the satellite link initialization
:return: None
"""
# Create the HTTP client for the connection
try:
self.con = HTTPClient(address=self.satellite_map['address'],
port=self.satellite_map['port'],
short_timeout=self.short_timeout, long_timeout=self.long_timeout,
use_ssl=self.satellite_map['use_ssl'],
strong_ssl=self.satellite_map['hard_ssl_name_check'])
self.uri = self.con.uri
except HTTPClientException as exp:
# logger.error("Error with '%s' when creating client: %s", self.name, str(exp))
# Set the satellite as dead
self.set_dead()
raise LinkError("Error with '%s' when creating client: %s" % (self.name, str(exp))) | [1][SEP1][Try][None][None][SEP2][1,2][][][SEP3][0][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD KEYWORD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD KEYWORD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD KEYWORD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD ASSIGN ATTRIBUTE NAME LOAD STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD BINOP CONSTANT MOD TUPLE ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD LOAD |
def linkify(self, modules):
"""Link modules and Satellite links
:param modules: Module object list
:type modules: alignak.objects.module.Modules
:return: None
"""
logger.debug("Linkify %s with %s", self, modules)
self.linkify_s_by_module(modules) | [2][SEP1][None][SEP2][][SEP3][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def monitoring_problems(self):
"""Get Alignak detailed monitoring status
This will return an object containing the properties of the `identity`, plus a `problems`
object which contains 2 properties for each known scheduler:
- _freshness, which is the timestamp when the provided data were fetched
- problems, which is an object with the scheduler known problems:
{
...
"problems": {
"scheduler-master": {
"_freshness": 1528903945,
"problems": {
"fdfc986d-4ab4-4562-9d2f-4346832745e6": {
"last_state": "CRITICAL",
"service": "dummy_critical",
"last_state_type": "SOFT",
"last_state_update": 1528902442,
"last_hard_state": "CRITICAL",
"last_hard_state_change": 1528902442,
"last_state_change": 1528902381,
"state": "CRITICAL",
"state_type": "HARD",
"host": "host-all-8",
"output": "Hi, checking host-all-8/dummy_critical -> exit=2"
},
"2445f2a3-2a3b-4b13-96ed-4cfb60790e7e": {
"last_state": "WARNING",
"service": "dummy_warning",
"last_state_type": "SOFT",
"last_state_update": 1528902463,
"last_hard_state": "WARNING",
"last_hard_state_change": 1528902463,
"last_state_change": 1528902400,
"state": "WARNING",
"state_type": "HARD",
"host": "host-all-6",
"output": "Hi, checking host-all-6/dummy_warning -> exit=1"
},
...
}
}
}
}
:return: schedulers live synthesis list
:rtype: dict
"""
res = self.identity()
res['problems'] = {}
for scheduler_link in self.app.conf.schedulers:
sched_res = scheduler_link.con.get('monitoring_problems', wait=True)
res['problems'][scheduler_link.name] = {}
if '_freshness' in sched_res:
res['problems'][scheduler_link.name].update({'_freshness': sched_res['_freshness']})
if 'problems' in sched_res:
res['problems'][scheduler_link.name].update({'problems': sched_res['problems']})
res['_freshness'] = int(time.time())
return res | [1][SEP1][None][For][If][Return][None][If][None][SEP2][1][2,3][4,5][][5][6,1][1][SEP3][1][1][1][2][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE DICT FOR NAME STORE ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CONSTANT KEYWORD CONSTANT ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD STORE DICT IF COMPARE CONSTANT IN NAME LOAD EXPR CALL ATTRIBUTE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD LOAD LOAD DICT CONSTANT SUBSCRIPT NAME LOAD CONSTANT LOAD IF COMPARE CONSTANT IN NAME LOAD EXPR CALL ATTRIBUTE SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD LOAD LOAD DICT CONSTANT SUBSCRIPT NAME LOAD CONSTANT LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE CALL NAME LOAD CALL ATTRIBUTE NAME LOAD LOAD RETURN NAME LOAD |
def create_objects(self, raw_objects):
"""Create all the objects got after the post configuration file initialization
:param raw_objects: dict with all object with str values
:type raw_objects: dict
:return: None
"""
types_creations = self.__class__.types_creations
early_created_types = self.__class__.early_created_types
logger.info("Creating objects...")
# Before really creating the objects, we add some ghost
# ones like the bp_rule for correlation
self.add_self_defined_objects(raw_objects)
for o_type in sorted(types_creations):
if o_type not in early_created_types:
self.create_objects_for_type(raw_objects, o_type)
logger.info("Done") | [2][SEP1][None][For][If][None][None][SEP2][1][2,3][4,1][][1][SEP3][2][1][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD FOR NAME STORE CALL NAME LOAD NAME LOAD IF COMPARE NAME LOAD NOTIN NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT |
def show_errors(self):
"""
Loop over configuration warnings and log them as INFO log
Loop over configuration errors and log them as INFO log
Note that the warnings and errors are logged on the fly during the configuration parsing.
It is not necessary to log as WARNING and ERROR in this function which is used as a sum-up
on the end of configuration parsing when an error has been detected.
:return: None
"""
if self.configuration_warnings:
logger.warning("Configuration warnings:")
for msg in self.configuration_warnings:
logger.warning(msg)
if self.configuration_errors:
logger.warning("Configuration errors:")
for msg in self.configuration_errors:
logger.warning(msg) | [1][SEP1][If][None][If][For][None][None][For][None][SEP2][1,2][3][4][5,2][6][3][7][6][SEP3][1][1][1][0][1][1][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD |
def get_monitoring_problems(self):
"""Get the schedulers satellites problems list
:return: problems dictionary
:rtype: dict
"""
res = self.get_id()
res['problems'] = {}
# Report our schedulers information, but only if a dispatcher exists
if getattr(self, 'dispatcher', None) is None:
return res
for satellite in self.dispatcher.all_daemons_links:
if satellite.type not in ['scheduler']:
continue
if not satellite.active:
continue
if satellite.statistics and 'problems' in satellite.statistics:
res['problems'][satellite.name] = {
'_freshness': satellite.statistics['_freshness'],
'problems': satellite.statistics['problems']
}
return res | [1][SEP1][If][Return][For][If][Return][If][If][None][SEP2][1,2][][3,4][5,2][][6,2][7,2][2][SEP3][2][0][0][0][0][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT NAME LOAD CONSTANT STORE DICT IF COMPARE CALL NAME LOAD NAME LOAD CONSTANT CONSTANT IS CONSTANT RETURN NAME LOAD FOR NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTIN LIST CONSTANT LOAD CONTINUE IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD CONTINUE IF BOOLOP AND ATTRIBUTE NAME LOAD LOAD COMPARE CONSTANT IN ATTRIBUTE NAME LOAD LOAD ASSIGN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD STORE DICT CONSTANT CONSTANT SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD RETURN NAME LOAD |
def apply_implicit_inheritance(self, hosts):
"""Apply implicit inheritance for special properties:
contact_groups, notification_interval , notification_period
So service will take info from host if necessary
:param hosts: hosts list needed to look for a simple host
:type hosts: alignak.objects.host.Hosts
:return: None
"""
for prop in ('contacts', 'contact_groups', 'notification_interval',
'notification_period', 'resultmodulations', 'business_impact_modulations',
'escalations', 'poller_tag', 'reactionner_tag', 'check_period',
'business_impact', 'maintenance_period'):
for serv in self:
if hasattr(serv, 'host_name') and not getattr(serv, prop, None):
host = hosts.find_by_name(serv.host_name)
if host is not None and hasattr(host, prop):
logger.debug("Implicit inheritance for %s/%s: %s = %s",
serv.host_name, serv, prop, getattr(host, prop))
setattr(serv, prop, getattr(host, prop)) | [2][SEP1][None][For][For][If][If][None][SEP2][1][2][3,1][4,2][5,2][2][SEP3][0][0][0][2][2][4] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT FOR NAME STORE TUPLE CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT CONSTANT LOAD FOR NAME STORE NAME LOAD IF BOOLOP AND CALL NAME LOAD NAME LOAD CONSTANT UNARYOP NOT CALL NAME LOAD NAME LOAD NAME LOAD CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND COMPARE NAME LOAD ISNOT CONSTANT CALL NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD EXPR CALL NAME LOAD NAME LOAD NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD |
def start_module(self):
"""Wrapper for _main function.
Catch and raise any exception occurring in the main function
:return: None
"""
try:
self._main()
except Exception as exp:
logger.exception('%s', traceback.format_exc())
raise Exception(exp) | [1][SEP1][Try][None][None][SEP2][1,2][][][SEP3][0][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY EXPR CALL ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD NAME LOAD |
def set_myself_as_problem(self, hosts, services, timeperiods, bi_modulations):
# pylint: disable=too-many-locals
""" Raise all impact from my error. I'm setting myself
as a problem, and I register myself as this in all
hosts/services that depend_on_me. So they are now my
impacts
:param hosts: hosts objects, used to get impacts
:type hosts: alignak.objects.host.Hosts
:param services: services objects, used to get impacts
:type services: alignak.objects.service.Services
:param timeperiods: Timeperiods objects, used to get act_depend_of_me timeperiod
:type timeperiods: alignak.objects.timeperiod.Timeperiods
:param bi_modulations: business impact modulations objects
:type bi_modulations: alignak.object.businessimpactmodulation.Businessimpactmodulations
:return: None
"""
now = time.time()
self.is_problem = True
# we should warn potentials impact of our problem
# and they should be cool to register them so I've got
# my impacts list
impacts = list(self.impacts)
for (impact_id, status, timeperiod_id, _) in self.act_depend_of_me:
# Check if the status is ok for impact
if impact_id in hosts:
impact = hosts[impact_id]
elif impact_id in services:
impact = services[impact_id]
else:
logger.warning("Problem with my impacts: %s", self)
timeperiod = timeperiods[timeperiod_id]
for stat in status:
if self.is_state(stat):
# now check if we should bailout because of a
# not good timeperiod for dep
if timeperiod is None or timeperiod.is_time_valid(now):
new_impacts = impact.register_a_problem(self, hosts, services, timeperiods,
bi_modulations)
impacts.extend(new_impacts)
# Only update impacts and create new brok if impacts changed.
s_impacts = set(impacts)
if s_impacts == set(self.impacts):
return
self.impacts = list(s_impacts)
# We can update our business_impact value now
self.update_business_impact_value(hosts, services, timeperiods, bi_modulations)
# And we register a new broks for update status
self.broks.append(self.get_update_status_brok()) | [5][SEP1][None][For][If][If][None][If][Return][None][None][None][None][For][If][If][None][SEP2][1][2,3][4,5][6,7][8][9,10][][][11][8][8][12,1][13,11][14,11][11][SEP3][2][4][0][2][0][0][0][4][0][0][1][0][1][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CONSTANT ASSIGN NAME STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD FOR TUPLE NAME STORE NAME STORE NAME STORE NAME STORE STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD IN NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD IF COMPARE NAME LOAD IN NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT NAME LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD FOR NAME STORE NAME LOAD IF CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF BOOLOP OR COMPARE NAME LOAD IS CONSTANT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF COMPARE NAME LOAD EQ CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD RETURN ASSIGN ATTRIBUTE NAME LOAD STORE CALL NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD |
def get_perfdata_command(self, hosts, macromodulations, timeperiods):
"""Add event_handler to process performance data if necessary (not disabled)
:param macromodulations: Macro modulations objects, used in commands (notif, check)
:type macromodulations: alignak.objects.macromodulation.Macromodulations
:return: None
"""
cls = self.__class__
if not cls.process_performance_data or not self.process_perf_data:
return
if cls.perfdata_command is not None:
macroresolver = MacroResolver()
data = self.get_data_for_event_handler(hosts)
cmd = macroresolver.resolve_command(cls.perfdata_command, data, macromodulations,
timeperiods)
reactionner_tag = cls.perfdata_command.reactionner_tag
event_h = EventHandler({
'command': cmd,
'timeout': cls.perfdata_timeout,
'ref': self.uuid,
'reactionner_tag': reactionner_tag
})
# ok we can put it in our temp action queue
self.actions.append(event_h) | [4][SEP1][If][Return][If][None][SEP2][1,2][][3][][SEP3][0][0][0][5] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE ATTRIBUTE NAME LOAD LOAD IF BOOLOP OR UNARYOP NOT ATTRIBUTE NAME LOAD LOAD UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RETURN IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT ASSIGN NAME STORE CALL NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD DICT CONSTANT CONSTANT CONSTANT CONSTANT NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def setup_logger(logger_configuration_file, log_dir=None, process_name='', log_file=''):
# pylint: disable=too-many-branches
"""
Configure the provided logger
- get and update the content of the Json configuration file
- configure the logger with this file
If a log_dir and process_name are provided, the format and filename in the configuration file
are updated with the provided values if they contain the patterns %(logdir)s and %(daemon)s
If no log_dir and process_name are provided, this function will truncate the log file
defined in the configuration file.
If a log file name is provided, it will override the default defined log file name.
At first, this function checks if the logger is still existing and initialized to
update the handlers and formatters. This mainly happens during the unit tests.
:param logger_configuration_file: Python Json logger configuration file
:rtype logger_configuration_file: str
:param log_dir: default log directory to update the defined logging handlers
:rtype log_dir: str
:param process_name: process name to update the defined logging formatters
:rtype process_name: str
:param log_file: log file name to update the defined log file
:rtype log_file: str
:return: None
"""
logger_ = logging.getLogger(ALIGNAK_LOGGER_NAME)
for handler in logger_.handlers:
if not process_name:
break
# Logger is already configured?
if getattr(handler, '_name', None) == 'daemons':
# Update the declared formats and file names with the process name
# This is for unit tests purpose only: alignak_tests will be replaced
# with the provided process name
for hdlr in logger_.handlers:
# print("- handler : %s (%s)" % (hdlr, hdlr.formatter._fmt))
if 'alignak_tests' in hdlr.formatter._fmt:
formatter = logging.Formatter(hdlr.formatter._fmt.replace("alignak_tests",
process_name))
hdlr.setFormatter(formatter)
if getattr(hdlr, 'filename', None) and 'alignak_tests' in hdlr.filename:
hdlr.filename = hdlr.filename._fmt.replace("alignak_tests", process_name)
# print("- handler : %s (%s) -> %s" % (hdlr, hdlr.formatter._fmt,
# hdlr.filename))
# else:
# print("- handler : %s (%s)" % (hdlr, hdlr.formatter._fmt))
break
else:
if not logger_configuration_file or not os.path.exists(logger_configuration_file):
print("The logger configuration file does not exist: %s" % logger_configuration_file)
return
with open(logger_configuration_file, 'rt') as _file:
config = json.load(_file)
truncate = False
if not process_name and not log_dir:
truncate = True
if not process_name:
process_name = 'alignak_tests'
if not log_dir:
log_dir = '/tmp'
# Update the declared formats with the process name
for formatter in config['formatters']:
if 'format' not in config['formatters'][formatter]:
continue
config['formatters'][formatter]['format'] = \
config['formatters'][formatter]['format'].replace("%(daemon)s", process_name)
# Update the declared log file names with the log directory
for hdlr in config['handlers']:
if 'filename' not in config['handlers'][hdlr]:
continue
if log_file and hdlr == 'daemons':
config['handlers'][hdlr]['filename'] = log_file
else:
config['handlers'][hdlr]['filename'] = \
config['handlers'][hdlr]['filename'].replace("%(logdir)s", log_dir)
config['handlers'][hdlr]['filename'] = \
config['handlers'][hdlr]['filename'].replace("%(daemon)s", process_name)
if truncate and os.path.exists(config['handlers'][hdlr]['filename']):
with open(config['handlers'][hdlr]['filename'], "w") as file_log_file:
file_log_file.truncate()
# Configure the logger, any error will raise an exception
logger_dictConfig(config) | [4][SEP1][None][For][If][If][For][If][None][If][None][SEP2][1][2][3][4,1][5][6,7][7][8,4][4][SEP3][1][17][0][1][2][0][3][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF UNARYOP NOT NAME LOAD BREAK IF COMPARE CALL NAME LOAD NAME LOAD CONSTANT CONSTANT EQ CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE CONSTANT IN ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD CONSTANT NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF BOOLOP AND CALL NAME LOAD NAME LOAD CONSTANT CONSTANT COMPARE CONSTANT IN ATTRIBUTE NAME LOAD LOAD ASSIGN ATTRIBUTE NAME LOAD STORE CALL ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD CONSTANT NAME LOAD BREAK IF BOOLOP OR UNARYOP NOT NAME LOAD UNARYOP NOT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXPR CALL NAME LOAD BINOP CONSTANT MOD NAME LOAD RETURN WITH WITHITEM CALL NAME LOAD NAME LOAD CONSTANT NAME STORE ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CONSTANT IF BOOLOP AND UNARYOP NOT NAME LOAD UNARYOP NOT NAME LOAD ASSIGN NAME STORE CONSTANT IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE CONSTANT IF UNARYOP NOT NAME LOAD ASSIGN NAME STORE CONSTANT FOR NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF COMPARE CONSTANT NOTIN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONTINUE ASSIGN SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT STORE CALL ATTRIBUTE SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT LOAD LOAD CONSTANT NAME LOAD FOR NAME STORE SUBSCRIPT NAME LOAD CONSTANT LOAD IF COMPARE CONSTANT NOTIN SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONTINUE IF BOOLOP AND NAME LOAD COMPARE NAME LOAD EQ CONSTANT ASSIGN SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT STORE NAME LOAD ASSIGN SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT STORE CALL ATTRIBUTE SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT LOAD LOAD CONSTANT NAME LOAD ASSIGN SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT STORE CALL ATTRIBUTE SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT LOAD LOAD CONSTANT NAME LOAD IF BOOLOP AND NAME LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT LOAD WITH WITHITEM CALL NAME LOAD SUBSCRIPT SUBSCRIPT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD LOAD CONSTANT LOAD CONSTANT NAME STORE EXPR CALL ATTRIBUTE NAME LOAD LOAD EXPR CALL NAME LOAD NAME LOAD |
def _send_int(self,value):
"""
Convert a numerical value into an integer, then to a bytes object Check
bounds for signed int.
"""
# Coerce to int. This will throw a ValueError if the value can't
# actually be converted.
if type(value) != int:
new_value = int(value)
if self.give_warnings:
w = "Coercing {} into int ({})".format(value,new_value)
warnings.warn(w,Warning)
value = new_value
# Range check
if value > self.board.int_max or value < self.board.int_min:
err = "Value {} exceeds the size of the board's int.".format(value)
raise OverflowError(err)
return struct.pack(self.board.int_type,value) | [2][SEP1][If][If][If][None][None][Return][SEP2][1,2][3,2][4,5][2][][][SEP3][1][1][0][2][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF COMPARE CALL NAME LOAD NAME LOAD NOTEQ NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD NAME LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE NAME LOAD IF BOOLOP OR COMPARE NAME LOAD GT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD COMPARE NAME LOAD LT ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE CONSTANT LOAD NAME LOAD RAISE CALL NAME LOAD NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD |
def emit(self, record):
"""Convert a :class:`logging.LogRecord` to GELF and emit it to Graylog
via an HTTP POST request
:param record: :class:`logging.LogRecord` to convert into a
Graylog GELF log and emit to Graylog via HTTP POST.
:type record: logging.LogRecord
"""
pickle = self.makePickle(record)
connection = httplib.HTTPConnection(
host=self.host,
port=self.port,
timeout=self.timeout
)
connection.request('POST', self.path, pickle, self.headers) | [2][SEP1][None][SEP2][][SEP3][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD KEYWORD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD |
def query_param(self, key, value=None, default=None, as_list=False):
"""
Return or set a query parameter for the given key
The value can be a list.
:param string key: key to look for
:param string default: value to return if ``key`` isn't found
:param boolean as_list: whether to return the values as a list
:param string value: the new query parameter to use
"""
parse_result = self.query_params()
if value is not None:
# Need to ensure all strings are unicode
if isinstance(value, (list, tuple)):
value = list(map(to_unicode, value))
else:
value = to_unicode(value)
parse_result[to_unicode(key)] = value
return URL._mutate(
self, query=unicode_urlencode(parse_result, doseq=True))
try:
result = parse_result[key]
except KeyError:
return default
if as_list:
return result
return result[0] if len(result) == 1 else result | [5][SEP1][If][If][Try][None][None][None][Return][Return][If][Return][Return][SEP2][1,2][3,4][5,6][7][7][8][][][9,10][][][SEP3][4][1][0][2][1][0][0][3][0][0][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG CONSTANT CONSTANT CONSTANT EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD ISNOT CONSTANT IF CALL NAME LOAD NAME LOAD TUPLE NAME LOAD NAME LOAD LOAD ASSIGN NAME STORE CALL NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD ASSIGN SUBSCRIPT NAME LOAD CALL NAME LOAD NAME LOAD STORE NAME LOAD RETURN CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD KEYWORD CALL NAME LOAD NAME LOAD KEYWORD CONSTANT TRY ASSIGN NAME STORE SUBSCRIPT NAME LOAD NAME LOAD LOAD EXCEPTHANDLER NAME LOAD RETURN NAME LOAD IF NAME LOAD RETURN NAME LOAD RETURN IFEXP COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT SUBSCRIPT NAME LOAD CONSTANT LOAD NAME LOAD |
def get_directory_as_zip(self, remote_path, local_file):
"""Downloads a remote directory as zip
:param remote_path: path to the remote directory to download
:param local_file: path and name of the target local file
:returns: True if the operation succeeded, False otherwise
:raises: HTTPResponseError in case an HTTP error status was returned
"""
remote_path = self._normalize_path(remote_path)
url = self.url + 'index.php/apps/files/ajax/download.php?dir=' \
+ parse.quote(remote_path)
res = self._session.get(url, stream=True)
if res.status_code == 200:
if local_file is None:
# use downloaded file name from Content-Disposition
# targetFile = res.headers['content-disposition']
local_file = os.path.basename(remote_path)
file_handle = open(local_file, 'wb', 8192)
for chunk in res.iter_content(8192):
file_handle.write(chunk)
file_handle.close()
return True
elif res.status_code >= 400:
raise HTTPResponseError(res)
return False | [3][SEP1][If][If][If][None][None][None][Return][For][None][Return][SEP2][1,2][3,4][5,6][4][7][][][8,9][7][][SEP3][7][0][0][1][1][1][0][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG EXPR CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD ADD CONSTANT ADD CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD KEYWORD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT IF COMPARE NAME LOAD IS CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ASSIGN NAME STORE CALL NAME LOAD NAME LOAD CONSTANT CONSTANT FOR NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD RETURN CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD GTE CONSTANT RAISE CALL NAME LOAD NAME LOAD RETURN CONSTANT |
def get_apps(self):
""" List all enabled apps through the provisioning api.
:returns: a dict of apps, with values True/False, representing the enabled state.
:raises: HTTPResponseError in case an HTTP error status was returned
"""
ena_apps = {}
res = self._make_ocs_request('GET', self.OCS_SERVICE_CLOUD, 'apps')
if res.status_code != 200:
raise HTTPResponseError(res)
tree = ET.fromstring(res.content)
self._check_ocs_status(tree)
# <data><apps><element>files</element><element>activity</element> ...
for el in tree.findall('data/apps/element'):
ena_apps[el.text] = False
res = self._make_ocs_request('GET', self.OCS_SERVICE_CLOUD,
'apps?filter=enabled')
if res.status_code != 200:
raise HTTPResponseError(res)
tree = ET.fromstring(res.content)
self._check_ocs_status(tree)
for el in tree.findall('data/apps/element'):
ena_apps[el.text] = True
return ena_apps | [1][SEP1][If][None][None][For][None][If][None][None][For][None][Return][SEP2][1,2][][3][4,5][3][6,7][][8][9,10][8][][SEP3][1][1][2][1][0][1][1][2][1][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE DICT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ CONSTANT RAISE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD FOR NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN SUBSCRIPT NAME LOAD ATTRIBUTE NAME LOAD LOAD STORE CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ATTRIBUTE NAME LOAD LOAD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ CONSTANT RAISE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD FOR NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN SUBSCRIPT NAME LOAD ATTRIBUTE NAME LOAD LOAD STORE CONSTANT RETURN NAME LOAD |
def load_patterns(filename):
"""Loads the patters contained in the filename and puts them into a list
of patterns, each pattern being a list of occurrence, and each
occurrence being a list of (onset, midi) pairs.
The input file must be formatted as described in MIREX 2013:
http://www.music-ir.org/mirex/wiki/2013:Discovery_of_Repeated_Themes_%26_Sections
Parameters
----------
filename : str
The input file path containing the patterns of a given piece using the
MIREX 2013 format.
Returns
-------
pattern_list : list
The list of patterns, containing all their occurrences,
using the following format::
onset_midi = (onset_time, midi_number)
occurrence = [onset_midi1, ..., onset_midiO]
pattern = [occurrence1, ..., occurrenceM]
pattern_list = [pattern1, ..., patternN]
where ``N`` is the number of patterns, ``M[i]`` is the number of
occurrences of the ``i`` th pattern, and ``O[j]`` is the number of
onsets in the ``j``'th occurrence. E.g.::
occ1 = [(0.5, 67.0), (1.0, 67.0), (1.5, 67.0), (2.0, 64.0)]
occ2 = [(4.5, 65.0), (5.0, 65.0), (5.5, 65.0), (6.0, 62.0)]
pattern1 = [occ1, occ2]
occ1 = [(10.5, 67.0), (11.0, 67.0), (11.5, 67.0), (12.0, 64.0),
(12.5, 69.0), (13.0, 69.0), (13.5, 69.0), (14.0, 67.0),
(14.5, 76.0), (15.0, 76.0), (15.5, 76.0), (16.0, 72.0)]
occ2 = [(18.5, 67.0), (19.0, 67.0), (19.5, 67.0), (20.0, 62.0),
(20.5, 69.0), (21.0, 69.0), (21.5, 69.0), (22.0, 67.0),
(22.5, 77.0), (23.0, 77.0), (23.5, 77.0), (24.0, 74.0)]
pattern2 = [occ1, occ2]
pattern_list = [pattern1, pattern2]
"""
# List with all the patterns
pattern_list = []
# Current pattern, which will contain all occs
pattern = []
# Current occurrence, containing (onset, midi)
occurrence = []
with _open(filename, mode='r') as input_file:
for line in input_file.readlines():
if "pattern" in line:
if occurrence != []:
pattern.append(occurrence)
if pattern != []:
pattern_list.append(pattern)
occurrence = []
pattern = []
continue
if "occurrence" in line:
if occurrence != []:
pattern.append(occurrence)
occurrence = []
continue
string_values = line.split(",")
onset_midi = (float(string_values[0]), float(string_values[1]))
occurrence.append(onset_midi)
# Add last occurrence and pattern to pattern_list
if occurrence != []:
pattern.append(occurrence)
if pattern != []:
pattern_list.append(pattern)
return pattern_list | [1][SEP1][None][For][If][If][If][If][None][If][None][If][If][None][None][Return][None][None][None][None][SEP2][1][2,3][4,5][6,7][8,9][10,11][7][12,13][9][14,15][16,17][1][13][][15][1][17][1][SEP3][3][6][1][0][0][0][1][0][1][0][0][4][1][0][1][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE LIST LOAD WITH WITHITEM CALL NAME LOAD NAME LOAD KEYWORD CONSTANT NAME STORE FOR NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE CONSTANT IN NAME LOAD IF COMPARE NAME LOAD NOTEQ LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD NOTEQ LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE LIST LOAD ASSIGN NAME STORE LIST LOAD CONTINUE IF COMPARE CONSTANT IN NAME LOAD IF COMPARE NAME LOAD NOTEQ LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ASSIGN NAME STORE LIST LOAD CONTINUE ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE TUPLE CALL NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD CALL NAME LOAD SUBSCRIPT NAME LOAD CONSTANT LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD NOTEQ LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD IF COMPARE NAME LOAD NOTEQ LIST LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def first_n_three_layer_P(reference_patterns, estimated_patterns, n=5):
"""First n three-layer precision.
This metric is basically the same as the three-layer FPR but it is only
applied to the first n estimated patterns, and it only returns the
precision. In MIREX and typically, n = 5.
Examples
--------
>>> ref_patterns = mir_eval.io.load_patterns("ref_pattern.txt")
>>> est_patterns = mir_eval.io.load_patterns("est_pattern.txt")
>>> P = mir_eval.pattern.first_n_three_layer_P(ref_patterns,
... est_patterns, n=5)
Parameters
----------
reference_patterns : list
The reference patterns in the format returned by
:func:`mir_eval.io.load_patterns()`
estimated_patterns : list
The estimated patterns in the same format
n : int
Number of patterns to consider from the estimated results, in
the order they appear in the matrix
(Default value = 5)
Returns
-------
precision : float
The first n three-layer Precision
"""
validate(reference_patterns, estimated_patterns)
# If no patterns were provided, metric is zero
if _n_onset_midi(reference_patterns) == 0 or \
_n_onset_midi(estimated_patterns) == 0:
return 0., 0., 0.
# Get only the first n patterns from the estimated results
fn_est_patterns = estimated_patterns[:min(len(estimated_patterns), n)]
# Compute the three-layer scores for the first n estimated patterns
F, P, R = three_layer_FPR(reference_patterns, fn_est_patterns)
return P | [3][SEP1][If][Return][Return][SEP2][1,2][][][SEP3][3][0][3] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG CONSTANT EXPR CONSTANT EXPR CALL NAME LOAD NAME LOAD NAME LOAD IF BOOLOP OR COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT COMPARE CALL NAME LOAD NAME LOAD EQ CONSTANT RETURN TUPLE CONSTANT CONSTANT CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT NAME LOAD SLICE CALL NAME LOAD CALL NAME LOAD NAME LOAD NAME LOAD LOAD ASSIGN TUPLE NAME STORE NAME STORE NAME STORE STORE CALL NAME LOAD NAME LOAD NAME LOAD RETURN NAME LOAD |
def validate(reference_sources, estimated_sources):
"""Checks that the input data to a metric are valid, and throws helpful
errors if not.
Parameters
----------
reference_sources : np.ndarray, shape=(nsrc, nsampl)
matrix containing true sources
estimated_sources : np.ndarray, shape=(nsrc, nsampl)
matrix containing estimated sources
"""
if reference_sources.shape != estimated_sources.shape:
raise ValueError('The shape of estimated sources and the true '
'sources should match. reference_sources.shape '
'= {}, estimated_sources.shape '
'= {}'.format(reference_sources.shape,
estimated_sources.shape))
if reference_sources.ndim > 3 or estimated_sources.ndim > 3:
raise ValueError('The number of dimensions is too high (must be less '
'than 3). reference_sources.ndim = {}, '
'estimated_sources.ndim '
'= {}'.format(reference_sources.ndim,
estimated_sources.ndim))
if reference_sources.size == 0:
warnings.warn("reference_sources is empty, should be of size "
"(nsrc, nsample). sdr, sir, sar, and perm will all "
"be empty np.ndarrays")
elif _any_source_silent(reference_sources):
raise ValueError('All the reference sources should be non-silent (not '
'all-zeros), but at least one of the reference '
'sources is all 0s, which introduces ambiguity to the'
' evaluation. (Otherwise we can add infinitely many '
'all-zero sources.)')
if estimated_sources.size == 0:
warnings.warn("estimated_sources is empty, should be of size "
"(nsrc, nsample). sdr, sir, sar, and perm will all "
"be empty np.ndarrays")
elif _any_source_silent(estimated_sources):
raise ValueError('All the estimated sources should be non-silent (not '
'all-zeros), but at least one of the estimated '
'sources is all 0s. Since we require each reference '
'source to be non-silent, having a silent estimated '
'source will result in an underdetermined system.')
if (estimated_sources.shape[0] > MAX_SOURCES or
reference_sources.shape[0] > MAX_SOURCES):
raise ValueError('The supplied matrices should be of shape (nsrc,'
' nsampl) but reference_sources.shape[0] = {} and '
'estimated_sources.shape[0] = {} which is greater '
'than mir_eval.separation.MAX_SOURCES = {}. To '
'override this check, set '
'mir_eval.separation.MAX_SOURCES to a '
'larger value.'.format(reference_sources.shape[0],
estimated_sources.shape[0],
MAX_SOURCES)) | [2][SEP1][If][None][If][None][If][None][If][If][None][None][If][If][None][None][SEP2][1,2][][3,4][][5,6][7][8,7][9,10][][11][12,11][13][][][SEP3][0][2][0][2][0][1][1][0][1][1][1][0][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ ATTRIBUTE NAME LOAD LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF BOOLOP OR COMPARE ATTRIBUTE NAME LOAD LOAD GT CONSTANT COMPARE ATTRIBUTE NAME LOAD LOAD GT CONSTANT RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT IF CALL NAME LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CONSTANT IF CALL NAME LOAD NAME LOAD RAISE CALL NAME LOAD CONSTANT IF BOOLOP OR COMPARE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD GT NAME LOAD COMPARE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD GT NAME LOAD RAISE CALL NAME LOAD CALL ATTRIBUTE CONSTANT LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD SUBSCRIPT ATTRIBUTE NAME LOAD LOAD CONSTANT LOAD NAME LOAD |
def pairwise(reference_intervals, reference_labels,
estimated_intervals, estimated_labels,
frame_size=0.1, beta=1.0):
"""Frame-clustering segmentation evaluation by pair-wise agreement.
Examples
--------
>>> (ref_intervals,
... ref_labels) = mir_eval.io.load_labeled_intervals('ref.lab')
>>> (est_intervals,
... est_labels) = mir_eval.io.load_labeled_intervals('est.lab')
>>> # Trim or pad the estimate to match reference timing
>>> (ref_intervals,
... ref_labels) = mir_eval.util.adjust_intervals(ref_intervals,
... ref_labels,
... t_min=0)
>>> (est_intervals,
... est_labels) = mir_eval.util.adjust_intervals(
... est_intervals, est_labels, t_min=0, t_max=ref_intervals.max())
>>> precision, recall, f = mir_eval.structure.pairwise(ref_intervals,
... ref_labels,
... est_intervals,
... est_labels)
Parameters
----------
reference_intervals : np.ndarray, shape=(n, 2)
reference segment intervals, in the format returned by
:func:`mir_eval.io.load_labeled_intervals`.
reference_labels : list, shape=(n,)
reference segment labels, in the format returned by
:func:`mir_eval.io.load_labeled_intervals`.
estimated_intervals : np.ndarray, shape=(m, 2)
estimated segment intervals, in the format returned by
:func:`mir_eval.io.load_labeled_intervals`.
estimated_labels : list, shape=(m,)
estimated segment labels, in the format returned by
:func:`mir_eval.io.load_labeled_intervals`.
frame_size : float > 0
length (in seconds) of frames for clustering
(Default value = 0.1)
beta : float > 0
beta value for F-measure
(Default value = 1.0)
Returns
-------
precision : float > 0
Precision of detecting whether frames belong in the same cluster
recall : float > 0
Recall of detecting whether frames belong in the same cluster
f : float > 0
F-measure of detecting whether frames belong in the same cluster
"""
validate_structure(reference_intervals, reference_labels,
estimated_intervals, estimated_labels)
# Check for empty annotations. Don't need to check labels because
# validate_structure makes sure they're the same size as intervals
if reference_intervals.size == 0 or estimated_intervals.size == 0:
return 0., 0., 0.
# Generate the cluster labels
y_ref = util.intervals_to_samples(reference_intervals,
reference_labels,
sample_size=frame_size)[-1]
y_ref = util.index_labels(y_ref)[0]
# Map to index space
y_est = util.intervals_to_samples(estimated_intervals,
estimated_labels,
sample_size=frame_size)[-1]
y_est = util.index_labels(y_est)[0]
# Build the reference label agreement matrix
agree_ref = np.equal.outer(y_ref, y_ref)
# Count the unique pairs
n_agree_ref = (agree_ref.sum() - len(y_ref)) / 2.0
# Repeat for estimate
agree_est = np.equal.outer(y_est, y_est)
n_agree_est = (agree_est.sum() - len(y_est)) / 2.0
# Find where they agree
matches = np.logical_and(agree_ref, agree_est)
n_matches = (matches.sum() - len(y_ref)) / 2.0
precision = n_matches / n_agree_est
recall = n_matches / n_agree_ref
f_measure = util.f_measure(precision, recall, beta=beta)
return precision, recall, f_measure | [6][SEP1][If][Return][Return][SEP2][1,2][][][SEP3][1][0][14] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG CONSTANT CONSTANT EXPR CONSTANT EXPR CALL NAME LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD IF BOOLOP OR COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT COMPARE ATTRIBUTE NAME LOAD LOAD EQ CONSTANT RETURN TUPLE CONSTANT CONSTANT CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD UNARYOP USUB CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD UNARYOP USUB CONSTANT LOAD ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD CONSTANT LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE BINOP BINOP CALL ATTRIBUTE NAME LOAD LOAD SUB CALL NAME LOAD NAME LOAD DIV CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE BINOP BINOP CALL ATTRIBUTE NAME LOAD LOAD SUB CALL NAME LOAD NAME LOAD DIV CONSTANT ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD ASSIGN NAME STORE BINOP BINOP CALL ATTRIBUTE NAME LOAD LOAD SUB CALL NAME LOAD NAME LOAD DIV CONSTANT ASSIGN NAME STORE BINOP NAME LOAD DIV NAME LOAD ASSIGN NAME STORE BINOP NAME LOAD DIV NAME LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD KEYWORD NAME LOAD RETURN TUPLE NAME LOAD NAME LOAD NAME LOAD LOAD |
def filter(self):
"""
Get a filtered list of file imports
:return: A list of file imports, with only the id set (you need to
refresh them if you want all the attributes to be filled in)
:rtype: list of :class:`carto.file_import.FileImportJob`
:raise: CartoException
"""
try:
response = self.send(self.get_collection_endpoint(), "get")
if self.json_collection_attribute is not None:
resource_ids = self.client.get_response_data(
response,
self.Meta.parse_json)[self.json_collection_attribute]
else:
resource_ids = self.client.get_response_data(
response, self.Meta.parse_json)
except Exception as e:
raise CartoException(e)
resources = []
for resource_id in resource_ids:
try:
resource = self.resource_class(self.client)
except (ValueError, TypeError):
continue
else:
setattr(resource, resource.Meta.id_field, resource_id)
resources.append(resource)
return resources | [1][SEP1][Try][If][None][None][None][None][For][Try][Return][None][None][SEP2][1,2][3,4][][5][5][6][7,8][9,6][][10][6][SEP3][0][2][1][1][1][0][0][2][0][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT ASSIGN NAME STORE SUBSCRIPT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EXCEPTHANDLER NAME LOAD RAISE CALL NAME LOAD NAME LOAD ASSIGN NAME STORE LIST LOAD FOR NAME STORE NAME LOAD TRY ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD EXCEPTHANDLER TUPLE NAME LOAD NAME LOAD LOAD CONTINUE EXPR CALL NAME LOAD NAME LOAD ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD RETURN NAME LOAD |
def copyto_file_path(self, query, path, append=False):
"""
Gets data from a table into a writable file
:param query: The "COPY { table_name [(column_name[, ...])] | (query) }
TO STDOUT [WITH(option[,...])]" query to execute
:type query: str
:param path: A path to a writable file
:type path: str
:param append: Whether to append or not if the file already exists
Default value is False
:type append: bool
:raise CartoException:
"""
file_mode = 'wb' if not append else 'ab'
with open(path, file_mode) as f:
self.copyto_file_object(query, f) | [4][SEP1][None][None][SEP2][1][][SEP3][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG CONSTANT EXPR CONSTANT ASSIGN NAME STORE IFEXP UNARYOP NOT NAME LOAD CONSTANT CONSTANT WITH WITHITEM CALL NAME LOAD NAME LOAD NAME LOAD NAME STORE EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD |
def new_symlink(self, vd, name, parent, rr_target, seqnum, rock_ridge,
rr_name, xa):
# type: (headervd.PrimaryOrSupplementaryVD, bytes, DirectoryRecord, bytes, int, str, bytes, bool) -> None
'''
Create a new symlink Directory Record. This implies that the new
record will be Rock Ridge.
Parameters:
vd - The Volume Descriptor this record is part of.
name - The name for this directory record.
parent - The parent of this directory record.
rr_target - The symlink target for this directory record.
seqnum - The sequence number for this directory record.
rock_ridge - The version of Rock Ridge to use for this directory record.
rr_name - The Rock Ridge name for this directory record.
xa - True if this is an Extended Attribute record.
Returns:
Nothing.
'''
if self._initialized:
raise pycdlibexception.PyCdlibInternalError('Directory Record already initialized')
self._new(vd, name, parent, seqnum, False, 0, xa)
if rock_ridge:
self._rr_new(rock_ridge, rr_name, rr_target, False, False, False,
0o0120555) | [9][SEP1][If][None][If][None][SEP2][1,2][][3][][SEP3][0][1][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG ARG ARG ARG ARG ARG EXPR CONSTANT IF ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD NAME LOAD CONSTANT CONSTANT NAME LOAD IF NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD NAME LOAD CONSTANT CONSTANT CONSTANT CONSTANT |
def record(self):
# type: () -> bytes
'''
Return a string representation of the Directory Record date.
Parameters:
None.
Returns:
A string representing this Directory Record Date.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('Directory Record Date not initialized')
return struct.pack(self.FMT, self.years_since_1900, self.month,
self.day_of_month, self.hour, self.minute,
self.second, self.gmtoffset) | [1][SEP1][If][None][Return][SEP2][1,2][][][SEP3][0][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT RETURN CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD |
def record(self):
# type: () -> bytes
'''
Generate a string representing the Rock Ridge Extensions Reference
record.
Parameters:
None.
Returns:
String containing the Rock Ridge record.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('ER record not yet initialized!')
return b'ER' + struct.pack('=BBBBBB', RRERRecord.length(self.ext_id, self.ext_des, self.ext_src), SU_ENTRY_VERSION, len(self.ext_id), len(self.ext_des), len(self.ext_src), self.ext_ver) + self.ext_id + self.ext_des + self.ext_src | [1][SEP1][If][None][Return][SEP2][1,2][][][SEP3][0][1][5] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT RETURN BINOP BINOP BINOP BINOP CONSTANT ADD CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD NAME LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ADD ATTRIBUTE NAME LOAD LOAD ADD ATTRIBUTE NAME LOAD LOAD ADD ATTRIBUTE NAME LOAD LOAD |
def record(self):
# type: () -> bytes
'''
Generate a string representing the Rock Ridge Child Link record.
Parameters:
None.
Returns:
String containing the Rock Ridge record.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('CL record not yet initialized!')
return b'CL' + struct.pack('=BBLL', RRCLRecord.length(), SU_ENTRY_VERSION, self.child_log_block_num, utils.swab_32bit(self.child_log_block_num)) | [1][SEP1][If][None][Return][SEP2][1,2][][][SEP3][0][1][3] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT RETURN BINOP CONSTANT ADD CALL ATTRIBUTE NAME LOAD LOAD CONSTANT CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD |
def _record(self, entries):
# type: (RockRidgeEntries) -> bytes
'''
Return a string representing the Rock Ridge entry.
Parameters:
entries - The dr_entries or ce_entries to generate a record for.
Returns:
A string representing the Rock Ridge entry.
'''
outlist = []
if entries.sp_record is not None:
outlist.append(entries.sp_record.record())
if entries.rr_record is not None:
outlist.append(entries.rr_record.record())
for nm_record in entries.nm_records:
outlist.append(nm_record.record())
if entries.px_record is not None:
outlist.append(entries.px_record.record(self.rr_version))
for sl_record in entries.sl_records:
outlist.append(sl_record.record())
if entries.tf_record is not None:
outlist.append(entries.tf_record.record())
if entries.cl_record is not None:
outlist.append(entries.cl_record.record())
if entries.pl_record is not None:
outlist.append(entries.pl_record.record())
if entries.re_record is not None:
outlist.append(entries.re_record.record())
for es_record in entries.es_records:
outlist.append(es_record.record())
if entries.er_record is not None:
outlist.append(entries.er_record.record())
if entries.ce_record is not None:
outlist.append(entries.ce_record.record())
for pd_record in entries.pd_records:
outlist.append(pd_record.record())
if entries.st_record is not None:
outlist.append(entries.st_record.record())
if entries.sf_record is not None:
outlist.append(entries.sf_record.record())
return b''.join(outlist) | [2][SEP1][If][None][If][None][For][None][If][None][For][None][If][None][If][None][If][None][If][None][For][None][If][None][If][None][For][None][If][None][If][None][Return][SEP2][1,2][2][3,4][4][5,6][4][7,8][8][9,10][8][11,12][12][13,14][14][15,16][16][17,18][18][19,20][18][21,22][22][23,24][24][25,26][24][27,28][28][29,30][30][][SEP3][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][0][2][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE LIST LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD IF COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD RETURN CALL ATTRIBUTE CONSTANT LOAD NAME LOAD |
def add_entry(self, length):
# type: (int) -> int
'''
Add a new entry to this Rock Ridge Continuation Block. This method
attempts to find a gap that fits the new length anywhere within this
Continuation Block. If successful, it returns the offset at which
it placed this entry. If unsuccessful, it returns None.
Parameters:
length - The length of the entry to find a gap for.
Returns:
The offset the entry was placed at, or None if no gap was found.
'''
offset = -1
# Need to find a gap
for index, entry in enumerate(self._entries):
if index == 0:
if entry.offset != 0 and length <= entry.offset:
# We can put it at the beginning!
offset = 0
break
else:
lastentry = self._entries[index - 1]
lastend = lastentry.offset + lastentry.length - 1
gapsize = entry.offset - lastend - 1
if gapsize >= length:
# We found a spot for it!
offset = lastend + 1
break
else:
# We reached the end without finding a gap for it. Look at the last
# entry and see if there is room at the end.
if self._entries:
lastentry = self._entries[-1]
lastend = lastentry.offset + lastentry.length - 1
left = self._max_block_size - lastend - 1
if left >= length:
offset = lastend + 1
else:
if self._max_block_size >= length:
offset = 0
if offset >= 0:
bisect.insort_left(self._entries,
RockRidgeContinuationEntry(offset, length))
return offset | [2][SEP1][None][For][If][If][If][If][None][Return][None][None][SEP2][1][2,3][4,5][6,7][8,1][9,1][7][][3][3][SEP3][0][1][0][0][0][0][2][0][0][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT ASSIGN NAME STORE UNARYOP USUB CONSTANT FOR TUPLE NAME STORE NAME STORE STORE CALL NAME LOAD ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD EQ CONSTANT IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD NOTEQ CONSTANT COMPARE NAME LOAD LTE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CONSTANT BREAK ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD BINOP NAME LOAD SUB CONSTANT LOAD ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD ADD ATTRIBUTE NAME LOAD LOAD SUB CONSTANT ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD SUB NAME LOAD SUB CONSTANT IF COMPARE NAME LOAD GTE NAME LOAD ASSIGN NAME STORE BINOP NAME LOAD ADD CONSTANT BREAK IF ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE SUBSCRIPT ATTRIBUTE NAME LOAD LOAD UNARYOP USUB CONSTANT LOAD ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD ADD ATTRIBUTE NAME LOAD LOAD SUB CONSTANT ASSIGN NAME STORE BINOP BINOP ATTRIBUTE NAME LOAD LOAD SUB NAME LOAD SUB CONSTANT IF COMPARE NAME LOAD GTE NAME LOAD ASSIGN NAME STORE BINOP NAME LOAD ADD CONSTANT IF COMPARE ATTRIBUTE NAME LOAD LOAD GTE NAME LOAD ASSIGN NAME STORE CONSTANT IF COMPARE NAME LOAD GTE CONSTANT EXPR CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD CALL NAME LOAD NAME LOAD NAME LOAD RETURN NAME LOAD |
def record(self):
# type: () -> bytes
'''
A method to generate the string representing this UDF Implementation Use
Volume Descriptor Implementation Use field.
Parameters:
None.
Returns:
A string representing this UDF Implementation Use Volume Descriptor.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('UDF Implementation Use Volume Descriptor Implementation Use field not initialized')
return struct.pack(self.FMT, self.char_set, self.log_vol_ident,
self.lv_info1, self.lv_info2, self.lv_info3,
self.impl_ident.record(), self.impl_use) | [1][SEP1][If][None][Return][SEP2][1,2][][][SEP3][0][1][2] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT RETURN CALL ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD ATTRIBUTE NAME LOAD LOAD CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ATTRIBUTE NAME LOAD LOAD |
def set_extent_location(self, new_location):
# type: (int) -> None
'''
A method to set the location of this UDF File Set Descriptor.
Parameters:
new_location - The new extent this UDF File Set Descriptor should be located at.
Returns:
Nothing.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('UDF File Set Descriptor not initialized')
self.new_extent_loc = new_location | [2][SEP1][If][None][None][SEP2][1,2][][][SEP3][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD |
def track_rr_ce_entry(self, extent, offset, length):
# type: (int, int, int) -> rockridge.RockRidgeContinuationBlock
'''
Start tracking a new Rock Ridge Continuation Entry entry in this Volume
Descriptor, at the extent, offset, and length provided. Since Rock
Ridge Continuation Blocks are shared across multiple Rock Ridge
Directory Records, the most logical place to track them is in the PVD.
This method is expected to be used during parse time, when an extent,
offset and length are already assigned to the entry.
Parameters:
extent - The extent that this Continuation Entry lives at.
offset - The offset within the extent that this Continuation Entry
lives at.
length - The length of this Continuation Entry.
Returns:
The object representing the block in which the Continuation Entry was
placed in.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('This Primary Volume Descriptor is not yet initialized')
for block in self.rr_ce_blocks:
if block.extent_location() == extent:
break
else:
# We didn't find it in the list, add it
block = rockridge.RockRidgeContinuationBlock(extent, self.log_block_size)
self.rr_ce_blocks.append(block)
block.track_entry(offset, length)
return block | [4][SEP1][If][None][For][If][Return][SEP2][1,2][][3,4][4,2][][SEP3][0][1][2][1][1] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG ARG ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF COMPARE CALL ATTRIBUTE NAME LOAD LOAD EQ NAME LOAD BREAK ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD ATTRIBUTE NAME LOAD LOAD EXPR CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD NAME LOAD EXPR CALL ATTRIBUTE NAME LOAD LOAD NAME LOAD NAME LOAD RETURN NAME LOAD |
def set_inode(self, ino):
# type: (inode.Inode) -> None
'''
A method to set the Inode associated with this El Torito Entry.
Parameters:
ino - The Inode object corresponding to this entry.
Returns:
Nothing.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('El Torito Entry not yet initialized')
self.inode = ino | [2][SEP1][If][None][None][SEP2][1,2][][][SEP3][0][1][0] | MODULE FUNCTIONDEF ARGUMENTS ARG ARG EXPR CONSTANT IF UNARYOP NOT ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN ATTRIBUTE NAME LOAD STORE NAME LOAD |
def _yield_children(rec):
# type: (dr.DirectoryRecord) -> Generator
'''
An internal function to gather and yield all of the children of a Directory
Record.
Parameters:
rec - The Directory Record to get all of the children from (must be a
directory)
Yields:
Children of this Directory Record.
Returns:
Nothing.
'''
if not rec.is_dir():
raise pycdlibexception.PyCdlibInvalidInput('Record is not a directory!')
last = b''
for child in rec.children:
# Check to see if the filename of this child is the same as the
# last one, and if so, skip the child. This can happen if we
# have very large files with more than one directory entry.
fi = child.file_identifier()
if fi == last:
continue
last = fi
if child.rock_ridge is not None and child.rock_ridge.child_link_record_exists() and child.rock_ridge.cl_to_moved_dr is not None and child.rock_ridge.cl_to_moved_dr.parent is not None:
# If this is the case, this is a relocated entry. We actually
# want to go find the entry this was relocated to; we do that
# by following the child_link, then going up to the parent and
# finding the entry that links to the same one as this one.
cl_parent = child.rock_ridge.cl_to_moved_dr.parent
for cl_child in cl_parent.children:
if cl_child.rock_ridge is not None and cl_child.rock_ridge.name() == child.rock_ridge.name():
child = cl_child
break
# If we ended up not finding the right one in the parent of the
# moved entry, weird, but just return the one we would have
# anyway.
yield child | [1][SEP1][If][None][None][For][If][If][None][None][For][If][None][SEP2][1,2][][3][4][5,3][6,7][8][3][9,7][10,8][7][SEP3][1][1][0][3][1][3][0][0][0][2][0] | MODULE FUNCTIONDEF ARGUMENTS ARG EXPR CONSTANT IF UNARYOP NOT CALL ATTRIBUTE NAME LOAD LOAD RAISE CALL ATTRIBUTE NAME LOAD LOAD CONSTANT ASSIGN NAME STORE CONSTANT FOR NAME STORE ATTRIBUTE NAME LOAD LOAD ASSIGN NAME STORE CALL ATTRIBUTE NAME LOAD LOAD IF COMPARE NAME LOAD EQ NAME LOAD CONTINUE ASSIGN NAME STORE NAME LOAD IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD COMPARE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ISNOT CONSTANT COMPARE ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD ISNOT CONSTANT ASSIGN NAME STORE ATTRIBUTE ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD LOAD FOR NAME STORE ATTRIBUTE NAME LOAD LOAD IF BOOLOP AND COMPARE ATTRIBUTE NAME LOAD LOAD ISNOT CONSTANT COMPARE CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD EQ CALL ATTRIBUTE ATTRIBUTE NAME LOAD LOAD LOAD ASSIGN NAME STORE NAME LOAD BREAK EXPR YIELD NAME LOAD |