code
stringlengths 75
104k
| docstring
stringlengths 1
46.9k
| text
stringlengths 164
112k
|
|---|---|---|
def xception_exit(inputs):
"""Xception exit flow."""
with tf.variable_scope("xception_exit"):
x = inputs
x_shape = x.get_shape().as_list()
if x_shape[1] is None or x_shape[2] is None:
length_float = tf.to_float(tf.shape(x)[1])
length_float *= tf.to_float(tf.shape(x)[2])
spatial_dim_float = tf.sqrt(length_float)
spatial_dim = tf.to_int32(spatial_dim_float)
x_depth = x_shape[3]
x = tf.reshape(x, [-1, spatial_dim, spatial_dim, x_depth])
elif x_shape[1] != x_shape[2]:
spatial_dim = int(math.sqrt(float(x_shape[1] * x_shape[2])))
if spatial_dim * spatial_dim != x_shape[1] * x_shape[2]:
raise ValueError("Assumed inputs were square-able but they were "
"not. Shape: %s" % x_shape)
x = tf.reshape(x, [-1, spatial_dim, spatial_dim, x_depth])
x = common_layers.conv_block_downsample(x, (3, 3), (2, 2), "SAME")
return tf.nn.relu(x) | Xception exit flow. | Below is the the instruction that describes the task:
### Input:
Xception exit flow.
### Response:
def xception_exit(inputs):
"""Xception exit flow."""
with tf.variable_scope("xception_exit"):
x = inputs
x_shape = x.get_shape().as_list()
if x_shape[1] is None or x_shape[2] is None:
length_float = tf.to_float(tf.shape(x)[1])
length_float *= tf.to_float(tf.shape(x)[2])
spatial_dim_float = tf.sqrt(length_float)
spatial_dim = tf.to_int32(spatial_dim_float)
x_depth = x_shape[3]
x = tf.reshape(x, [-1, spatial_dim, spatial_dim, x_depth])
elif x_shape[1] != x_shape[2]:
spatial_dim = int(math.sqrt(float(x_shape[1] * x_shape[2])))
if spatial_dim * spatial_dim != x_shape[1] * x_shape[2]:
raise ValueError("Assumed inputs were square-able but they were "
"not. Shape: %s" % x_shape)
x = tf.reshape(x, [-1, spatial_dim, spatial_dim, x_depth])
x = common_layers.conv_block_downsample(x, (3, 3), (2, 2), "SAME")
return tf.nn.relu(x) |
def _convert_eq(self, eq):
"""WORKS INPLACE on eq
"""
rename = dict(enumerate(self.index))
eq['eq_sets'] = {rename[k]: {rename[x] for x in v}
for k, v in eq['eq_sets'].items()}
eq['sym_ops'] = {rename[k]: {rename[x]: v[x] for x in v}
for k, v in eq['sym_ops'].items()}
try:
sym_mol = self.from_pymatgen_molecule(eq['sym_mol'])
sym_mol.index = self.index
eq['sym_mol'] = sym_mol._to_numeric()
except KeyError:
pass | WORKS INPLACE on eq | Below is the the instruction that describes the task:
### Input:
WORKS INPLACE on eq
### Response:
def _convert_eq(self, eq):
"""WORKS INPLACE on eq
"""
rename = dict(enumerate(self.index))
eq['eq_sets'] = {rename[k]: {rename[x] for x in v}
for k, v in eq['eq_sets'].items()}
eq['sym_ops'] = {rename[k]: {rename[x]: v[x] for x in v}
for k, v in eq['sym_ops'].items()}
try:
sym_mol = self.from_pymatgen_molecule(eq['sym_mol'])
sym_mol.index = self.index
eq['sym_mol'] = sym_mol._to_numeric()
except KeyError:
pass |
def load(self, specfiles=None):
"""Imports the specified ``fic`` files from the hard disk.
:param specfiles: the name of an ms-run file or a list of names. If None
all specfiles are selected.
:type specfiles: None, str, [str, str]
"""
if specfiles is None:
specfiles = [_ for _ in viewkeys(self.info)]
else:
specfiles = aux.toList(specfiles)
for specfile in specfiles:
if specfile not in self.info:
warntext = 'Error while calling "FiContainer.load()": "%s" is'\
' not present in "FiContainer.info"!'\
% (specfile, )
warnings.warn(warntext)
continue
else:
fiPath = aux.joinpath(self.info[specfile]['path'],
specfile+'.fic'
)
with zipfile.ZipFile(fiPath, 'r') as containerZip:
#Convert the zipfile data into a str object, necessary since
#containerZip.read() returns a bytes object.
jsonString = io.TextIOWrapper(containerZip.open('data'),
encoding='utf-8'
).read()
#infoString = io.TextIOWrapper(containerZip.open('info'),
# encoding='utf-8'
# ).read()
self.container[specfile] = json.loads(jsonString,
object_hook=Fi.jsonHook
) | Imports the specified ``fic`` files from the hard disk.
:param specfiles: the name of an ms-run file or a list of names. If None
all specfiles are selected.
:type specfiles: None, str, [str, str] | Below is the the instruction that describes the task:
### Input:
Imports the specified ``fic`` files from the hard disk.
:param specfiles: the name of an ms-run file or a list of names. If None
all specfiles are selected.
:type specfiles: None, str, [str, str]
### Response:
def load(self, specfiles=None):
"""Imports the specified ``fic`` files from the hard disk.
:param specfiles: the name of an ms-run file or a list of names. If None
all specfiles are selected.
:type specfiles: None, str, [str, str]
"""
if specfiles is None:
specfiles = [_ for _ in viewkeys(self.info)]
else:
specfiles = aux.toList(specfiles)
for specfile in specfiles:
if specfile not in self.info:
warntext = 'Error while calling "FiContainer.load()": "%s" is'\
' not present in "FiContainer.info"!'\
% (specfile, )
warnings.warn(warntext)
continue
else:
fiPath = aux.joinpath(self.info[specfile]['path'],
specfile+'.fic'
)
with zipfile.ZipFile(fiPath, 'r') as containerZip:
#Convert the zipfile data into a str object, necessary since
#containerZip.read() returns a bytes object.
jsonString = io.TextIOWrapper(containerZip.open('data'),
encoding='utf-8'
).read()
#infoString = io.TextIOWrapper(containerZip.open('info'),
# encoding='utf-8'
# ).read()
self.container[specfile] = json.loads(jsonString,
object_hook=Fi.jsonHook
) |
def printAllColorsToConsole(cls):
''' A simple enumeration of the colors to the console to help decide :) '''
for elem in cls.__dict__:
# ignore specials such as __class__ or __module__
if not elem.startswith("__"):
color_fmt = cls.__dict__[elem]
if isinstance(color_fmt, six.string_types) and color_fmt != "BOLD" and color_fmt != "DIM" and \
color_fmt != "UNDER" and color_fmt != "INV":
print("\033[{fmt}AnsiColors.{name}\033[0m".format(fmt=color_fmt, name=elem)) | A simple enumeration of the colors to the console to help decide :) | Below is the the instruction that describes the task:
### Input:
A simple enumeration of the colors to the console to help decide :)
### Response:
def printAllColorsToConsole(cls):
''' A simple enumeration of the colors to the console to help decide :) '''
for elem in cls.__dict__:
# ignore specials such as __class__ or __module__
if not elem.startswith("__"):
color_fmt = cls.__dict__[elem]
if isinstance(color_fmt, six.string_types) and color_fmt != "BOLD" and color_fmt != "DIM" and \
color_fmt != "UNDER" and color_fmt != "INV":
print("\033[{fmt}AnsiColors.{name}\033[0m".format(fmt=color_fmt, name=elem)) |
def get_widget_for(self, fieldname):
"""Lookup the widget
"""
field = self.context.getField(fieldname)
if not field:
return None
return field.widget | Lookup the widget | Below is the the instruction that describes the task:
### Input:
Lookup the widget
### Response:
def get_widget_for(self, fieldname):
"""Lookup the widget
"""
field = self.context.getField(fieldname)
if not field:
return None
return field.widget |
def mavgen(opts, args):
"""Generate mavlink message formatters and parsers (C and Python ) using options
and args where args are a list of xml files. This function allows python
scripts under Windows to control mavgen using the same interface as
shell scripts under Unix"""
xml = []
# Enable validation by default, disabling it if explicitly requested
if opts.validate:
try:
from lxml import etree
with open(schemaFile, 'r') as f:
xmlschema_root = etree.parse(f)
xmlschema = etree.XMLSchema(xmlschema_root)
except:
print("WARNING: Unable to load XML validator libraries. XML validation will not be performed", file=sys.stderr)
opts.validate = False
def mavgen_validate(xmlfile):
"""Uses lxml to validate an XML file. We define mavgen_validate
here because it relies on the XML libs that were loaded in mavgen(), so it can't be called standalone"""
xmlvalid = True
try:
with open(xmlfile, 'r') as f:
xmldocument = etree.parse(f)
xmlschema.assertValid(xmldocument)
forbidden_names_re = re.compile("^(break$|case$|class$|catch$|const$|continue$|debugger$|default$|delete$|do$|else$|\
export$|extends$|finally$|for$|function$|if$|import$|in$|instanceof$|let$|new$|\
return$|super$|switch$|this$|throw$|try$|typeof$|var$|void$|while$|with$|yield$|\
enum$|await$|implements$|package$|protected$|static$|interface$|private$|public$|\
abstract$|boolean$|byte$|char$|double$|final$|float$|goto$|int$|long$|native$|\
short$|synchronized$|transient$|volatile$).*", re.IGNORECASE)
for element in xmldocument.iter('enum', 'entry', 'message', 'field'):
if forbidden_names_re.search(element.get('name')):
print("Validation error:", file=sys.stderr)
print("Element : %s at line : %s contains forbidden word" % (element.tag, element.sourceline), file=sys.stderr)
xmlvalid = False
return xmlvalid
except etree.XMLSchemaError:
return False
# Process all XML files, validating them as necessary.
for fname in args:
if opts.validate:
print("Validating %s" % fname)
if not mavgen_validate(fname):
return False
else:
print("Validation skipped for %s." % fname)
print("Parsing %s" % fname)
xml.append(mavparse.MAVXML(fname, opts.wire_protocol))
# expand includes
for x in xml[:]:
for i in x.include:
fname = os.path.join(os.path.dirname(x.filename), i)
# Validate XML file with XSD file if possible.
if opts.validate:
print("Validating %s" % fname)
if not mavgen_validate(fname):
return False
else:
print("Validation skipped for %s." % fname)
# Parsing
print("Parsing %s" % fname)
xml.append(mavparse.MAVXML(fname, opts.wire_protocol))
# include message lengths and CRCs too
x.message_crcs.update(xml[-1].message_crcs)
x.message_lengths.update(xml[-1].message_lengths)
x.message_min_lengths.update(xml[-1].message_min_lengths)
x.message_flags.update(xml[-1].message_flags)
x.message_target_system_ofs.update(xml[-1].message_target_system_ofs)
x.message_target_component_ofs.update(xml[-1].message_target_component_ofs)
x.message_names.update(xml[-1].message_names)
x.largest_payload = max(x.largest_payload, xml[-1].largest_payload)
# work out max payload size across all includes
largest_payload = 0
for x in xml:
if x.largest_payload > largest_payload:
largest_payload = x.largest_payload
for x in xml:
x.largest_payload = largest_payload
if mavparse.check_duplicates(xml):
sys.exit(1)
print("Found %u MAVLink message types in %u XML files" % (
mavparse.total_msgs(xml), len(xml)))
# Convert language option to lowercase and validate
opts.language = opts.language.lower()
if opts.language == 'python':
from . import mavgen_python
mavgen_python.generate(opts.output, xml)
elif opts.language == 'c':
from . import mavgen_c
mavgen_c.generate(opts.output, xml)
elif opts.language == 'wlua':
from . import mavgen_wlua
mavgen_wlua.generate(opts.output, xml)
elif opts.language == 'cs':
from . import mavgen_cs
mavgen_cs.generate(opts.output, xml)
elif opts.language == 'javascript':
from . import mavgen_javascript
mavgen_javascript.generate(opts.output, xml)
elif opts.language == 'objc':
from . import mavgen_objc
mavgen_objc.generate(opts.output, xml)
elif opts.language == 'swift':
from . import mavgen_swift
mavgen_swift.generate(opts.output, xml)
elif opts.language == 'java':
from . import mavgen_java
mavgen_java.generate(opts.output, xml)
else:
print("Unsupported language %s" % opts.language)
return True | Generate mavlink message formatters and parsers (C and Python ) using options
and args where args are a list of xml files. This function allows python
scripts under Windows to control mavgen using the same interface as
shell scripts under Unix | Below is the the instruction that describes the task:
### Input:
Generate mavlink message formatters and parsers (C and Python ) using options
and args where args are a list of xml files. This function allows python
scripts under Windows to control mavgen using the same interface as
shell scripts under Unix
### Response:
def mavgen(opts, args):
"""Generate mavlink message formatters and parsers (C and Python ) using options
and args where args are a list of xml files. This function allows python
scripts under Windows to control mavgen using the same interface as
shell scripts under Unix"""
xml = []
# Enable validation by default, disabling it if explicitly requested
if opts.validate:
try:
from lxml import etree
with open(schemaFile, 'r') as f:
xmlschema_root = etree.parse(f)
xmlschema = etree.XMLSchema(xmlschema_root)
except:
print("WARNING: Unable to load XML validator libraries. XML validation will not be performed", file=sys.stderr)
opts.validate = False
def mavgen_validate(xmlfile):
"""Uses lxml to validate an XML file. We define mavgen_validate
here because it relies on the XML libs that were loaded in mavgen(), so it can't be called standalone"""
xmlvalid = True
try:
with open(xmlfile, 'r') as f:
xmldocument = etree.parse(f)
xmlschema.assertValid(xmldocument)
forbidden_names_re = re.compile("^(break$|case$|class$|catch$|const$|continue$|debugger$|default$|delete$|do$|else$|\
export$|extends$|finally$|for$|function$|if$|import$|in$|instanceof$|let$|new$|\
return$|super$|switch$|this$|throw$|try$|typeof$|var$|void$|while$|with$|yield$|\
enum$|await$|implements$|package$|protected$|static$|interface$|private$|public$|\
abstract$|boolean$|byte$|char$|double$|final$|float$|goto$|int$|long$|native$|\
short$|synchronized$|transient$|volatile$).*", re.IGNORECASE)
for element in xmldocument.iter('enum', 'entry', 'message', 'field'):
if forbidden_names_re.search(element.get('name')):
print("Validation error:", file=sys.stderr)
print("Element : %s at line : %s contains forbidden word" % (element.tag, element.sourceline), file=sys.stderr)
xmlvalid = False
return xmlvalid
except etree.XMLSchemaError:
return False
# Process all XML files, validating them as necessary.
for fname in args:
if opts.validate:
print("Validating %s" % fname)
if not mavgen_validate(fname):
return False
else:
print("Validation skipped for %s." % fname)
print("Parsing %s" % fname)
xml.append(mavparse.MAVXML(fname, opts.wire_protocol))
# expand includes
for x in xml[:]:
for i in x.include:
fname = os.path.join(os.path.dirname(x.filename), i)
# Validate XML file with XSD file if possible.
if opts.validate:
print("Validating %s" % fname)
if not mavgen_validate(fname):
return False
else:
print("Validation skipped for %s." % fname)
# Parsing
print("Parsing %s" % fname)
xml.append(mavparse.MAVXML(fname, opts.wire_protocol))
# include message lengths and CRCs too
x.message_crcs.update(xml[-1].message_crcs)
x.message_lengths.update(xml[-1].message_lengths)
x.message_min_lengths.update(xml[-1].message_min_lengths)
x.message_flags.update(xml[-1].message_flags)
x.message_target_system_ofs.update(xml[-1].message_target_system_ofs)
x.message_target_component_ofs.update(xml[-1].message_target_component_ofs)
x.message_names.update(xml[-1].message_names)
x.largest_payload = max(x.largest_payload, xml[-1].largest_payload)
# work out max payload size across all includes
largest_payload = 0
for x in xml:
if x.largest_payload > largest_payload:
largest_payload = x.largest_payload
for x in xml:
x.largest_payload = largest_payload
if mavparse.check_duplicates(xml):
sys.exit(1)
print("Found %u MAVLink message types in %u XML files" % (
mavparse.total_msgs(xml), len(xml)))
# Convert language option to lowercase and validate
opts.language = opts.language.lower()
if opts.language == 'python':
from . import mavgen_python
mavgen_python.generate(opts.output, xml)
elif opts.language == 'c':
from . import mavgen_c
mavgen_c.generate(opts.output, xml)
elif opts.language == 'wlua':
from . import mavgen_wlua
mavgen_wlua.generate(opts.output, xml)
elif opts.language == 'cs':
from . import mavgen_cs
mavgen_cs.generate(opts.output, xml)
elif opts.language == 'javascript':
from . import mavgen_javascript
mavgen_javascript.generate(opts.output, xml)
elif opts.language == 'objc':
from . import mavgen_objc
mavgen_objc.generate(opts.output, xml)
elif opts.language == 'swift':
from . import mavgen_swift
mavgen_swift.generate(opts.output, xml)
elif opts.language == 'java':
from . import mavgen_java
mavgen_java.generate(opts.output, xml)
else:
print("Unsupported language %s" % opts.language)
return True |
def get_features(self, organism=None, sequence=None):
"""
Get the features for an organism / sequence
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {}
data = self._update_data(data, organism, sequence)
return self.post('getFeatures', data) | Get the features for an organism / sequence
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]}) | Below is the the instruction that describes the task:
### Input:
Get the features for an organism / sequence
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
### Response:
def get_features(self, organism=None, sequence=None):
"""
Get the features for an organism / sequence
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {}
data = self._update_data(data, organism, sequence)
return self.post('getFeatures', data) |
def textrank(self, sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'), withFlag=False):
"""
Extract keywords from sentence using TextRank algorithm.
Parameter:
- topK: return how many top keywords. `None` for all possible words.
- withWeight: if True, return a list of (word, weight);
if False, return a list of words.
- allowPOS: the allowed POS list eg. ['ns', 'n', 'vn', 'v'].
if the POS of w is not in this list, it will be filtered.
- withFlag: if True, return a list of pair(word, weight) like posseg.cut
if False, return a list of words
"""
self.pos_filt = frozenset(allowPOS)
g = UndirectWeightedGraph()
cm = defaultdict(int)
words = tuple(self.tokenizer.cut(sentence))
for i, wp in enumerate(words):
if self.pairfilter(wp):
for j in xrange(i + 1, i + self.span):
if j >= len(words):
break
if not self.pairfilter(words[j]):
continue
if allowPOS and withFlag:
cm[(wp, words[j])] += 1
else:
cm[(wp.word, words[j].word)] += 1
for terms, w in cm.items():
g.addEdge(terms[0], terms[1], w)
nodes_rank = g.rank()
if withWeight:
tags = sorted(nodes_rank.items(), key=itemgetter(1), reverse=True)
else:
tags = sorted(nodes_rank, key=nodes_rank.__getitem__, reverse=True)
if topK:
return tags[:topK]
else:
return tags | Extract keywords from sentence using TextRank algorithm.
Parameter:
- topK: return how many top keywords. `None` for all possible words.
- withWeight: if True, return a list of (word, weight);
if False, return a list of words.
- allowPOS: the allowed POS list eg. ['ns', 'n', 'vn', 'v'].
if the POS of w is not in this list, it will be filtered.
- withFlag: if True, return a list of pair(word, weight) like posseg.cut
if False, return a list of words | Below is the the instruction that describes the task:
### Input:
Extract keywords from sentence using TextRank algorithm.
Parameter:
- topK: return how many top keywords. `None` for all possible words.
- withWeight: if True, return a list of (word, weight);
if False, return a list of words.
- allowPOS: the allowed POS list eg. ['ns', 'n', 'vn', 'v'].
if the POS of w is not in this list, it will be filtered.
- withFlag: if True, return a list of pair(word, weight) like posseg.cut
if False, return a list of words
### Response:
def textrank(self, sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'), withFlag=False):
"""
Extract keywords from sentence using TextRank algorithm.
Parameter:
- topK: return how many top keywords. `None` for all possible words.
- withWeight: if True, return a list of (word, weight);
if False, return a list of words.
- allowPOS: the allowed POS list eg. ['ns', 'n', 'vn', 'v'].
if the POS of w is not in this list, it will be filtered.
- withFlag: if True, return a list of pair(word, weight) like posseg.cut
if False, return a list of words
"""
self.pos_filt = frozenset(allowPOS)
g = UndirectWeightedGraph()
cm = defaultdict(int)
words = tuple(self.tokenizer.cut(sentence))
for i, wp in enumerate(words):
if self.pairfilter(wp):
for j in xrange(i + 1, i + self.span):
if j >= len(words):
break
if not self.pairfilter(words[j]):
continue
if allowPOS and withFlag:
cm[(wp, words[j])] += 1
else:
cm[(wp.word, words[j].word)] += 1
for terms, w in cm.items():
g.addEdge(terms[0], terms[1], w)
nodes_rank = g.rank()
if withWeight:
tags = sorted(nodes_rank.items(), key=itemgetter(1), reverse=True)
else:
tags = sorted(nodes_rank, key=nodes_rank.__getitem__, reverse=True)
if topK:
return tags[:topK]
else:
return tags |
def process_value_pairs(self, tokens, type_):
"""
Metadata, Values, and Validation blocks can either
have string pairs or attributes
Attributes will already be processed
"""
key, body = self.check_composite_tokens(type_, tokens)
key_name = self.key_name(key)
d = CaseInsensitiveOrderedDict(CaseInsensitiveOrderedDict)
for t in body:
k = self.clean_string(t[0].value).lower()
v = self.clean_string(t[1].value)
if k in d.keys():
log.warning("A duplicate key ({}) was found in {}. Only the last value ({}) will be used. ".format(
k, type_, v))
d[k] = v
if self.include_position:
pd = self.create_position_dict(key, body)
d["__position__"] = pd
d["__type__"] = key_name
# return the token as well as the processed dict so the
# composites function works the same way
return d | Metadata, Values, and Validation blocks can either
have string pairs or attributes
Attributes will already be processed | Below is the the instruction that describes the task:
### Input:
Metadata, Values, and Validation blocks can either
have string pairs or attributes
Attributes will already be processed
### Response:
def process_value_pairs(self, tokens, type_):
"""
Metadata, Values, and Validation blocks can either
have string pairs or attributes
Attributes will already be processed
"""
key, body = self.check_composite_tokens(type_, tokens)
key_name = self.key_name(key)
d = CaseInsensitiveOrderedDict(CaseInsensitiveOrderedDict)
for t in body:
k = self.clean_string(t[0].value).lower()
v = self.clean_string(t[1].value)
if k in d.keys():
log.warning("A duplicate key ({}) was found in {}. Only the last value ({}) will be used. ".format(
k, type_, v))
d[k] = v
if self.include_position:
pd = self.create_position_dict(key, body)
d["__position__"] = pd
d["__type__"] = key_name
# return the token as well as the processed dict so the
# composites function works the same way
return d |
def bottom(self, features):
"""Transforms features to feed into body.
Args:
features: dict of str to Tensor. Typically it is the preprocessed data
batch after Problem's preprocess_example().
Returns:
transformed_features: dict of same key-value pairs as features. The value
Tensors are newly transformed.
"""
if not self._problem_hparams:
log_warn("Without a Problem, T2TModel.bottom is a passthrough.")
return features
transformed_features = collections.OrderedDict()
all_previous_modalities = []
target_modality = _create_target_modality(self._problem_hparams.modality)
# Transform features via its corresponding modality.
for feature_name, modality in sorted(
six.iteritems(self._problem_hparams.modality)):
if feature_name not in features:
tf.logging.warning("Missing feature %s - ignoring." % feature_name)
continue
vocab_size = self._problem_hparams.vocab_size[feature_name]
if vocab_size is not None and hasattr(self._hparams, "vocab_divisor"):
vocab_size += (-vocab_size) % self._hparams.vocab_divisor
modality_name = self._hparams.name.get(
feature_name,
modalities.get_name(modality))(self._hparams, vocab_size)
# Use if-else clauses to preserve behavior of previous changes: namely,
# the variable scope name for the targets feature if there is only one
# target modality; and to reuse variable scopes for only input modalities.
if feature_name in target_modality:
if len(target_modality) > 1:
variable_scope_name = "%s/%s" % (modality_name, feature_name)
else:
variable_scope_name = modality_name
bottom = self._hparams.bottom.get(
feature_name,
modalities.get_targets_bottom(modality))
# TODO(aidangomez): share variables?
with tf.variable_scope(variable_scope_name) as vs:
self._add_variable_scope(variable_scope_name, vs)
log_info("Transforming feature '%s' with %s.targets_bottom",
feature_name,
modality_name)
transformed_features[feature_name] = bottom(features[feature_name],
self._hparams,
vocab_size)
else:
bottom = self._hparams.bottom.get(feature_name,
modalities.get_bottom(modality))
do_reuse = modality_name in all_previous_modalities
with tf.variable_scope(modality_name, reuse=do_reuse) as vs:
self._add_variable_scope(modality_name, vs)
log_info("Transforming feature '%s' with %s.bottom",
feature_name,
modality_name)
transformed_features[feature_name] = bottom(features[feature_name],
self._hparams,
vocab_size)
all_previous_modalities.append(modality_name)
for key in features:
if key not in transformed_features:
# For features without a modality, we pass them along as is
transformed_features[key] = features[key]
else:
# Other features get passed along with the "raw" suffix
transformed_features[key + "_raw"] = features[key]
return transformed_features | Transforms features to feed into body.
Args:
features: dict of str to Tensor. Typically it is the preprocessed data
batch after Problem's preprocess_example().
Returns:
transformed_features: dict of same key-value pairs as features. The value
Tensors are newly transformed. | Below is the the instruction that describes the task:
### Input:
Transforms features to feed into body.
Args:
features: dict of str to Tensor. Typically it is the preprocessed data
batch after Problem's preprocess_example().
Returns:
transformed_features: dict of same key-value pairs as features. The value
Tensors are newly transformed.
### Response:
def bottom(self, features):
"""Transforms features to feed into body.
Args:
features: dict of str to Tensor. Typically it is the preprocessed data
batch after Problem's preprocess_example().
Returns:
transformed_features: dict of same key-value pairs as features. The value
Tensors are newly transformed.
"""
if not self._problem_hparams:
log_warn("Without a Problem, T2TModel.bottom is a passthrough.")
return features
transformed_features = collections.OrderedDict()
all_previous_modalities = []
target_modality = _create_target_modality(self._problem_hparams.modality)
# Transform features via its corresponding modality.
for feature_name, modality in sorted(
six.iteritems(self._problem_hparams.modality)):
if feature_name not in features:
tf.logging.warning("Missing feature %s - ignoring." % feature_name)
continue
vocab_size = self._problem_hparams.vocab_size[feature_name]
if vocab_size is not None and hasattr(self._hparams, "vocab_divisor"):
vocab_size += (-vocab_size) % self._hparams.vocab_divisor
modality_name = self._hparams.name.get(
feature_name,
modalities.get_name(modality))(self._hparams, vocab_size)
# Use if-else clauses to preserve behavior of previous changes: namely,
# the variable scope name for the targets feature if there is only one
# target modality; and to reuse variable scopes for only input modalities.
if feature_name in target_modality:
if len(target_modality) > 1:
variable_scope_name = "%s/%s" % (modality_name, feature_name)
else:
variable_scope_name = modality_name
bottom = self._hparams.bottom.get(
feature_name,
modalities.get_targets_bottom(modality))
# TODO(aidangomez): share variables?
with tf.variable_scope(variable_scope_name) as vs:
self._add_variable_scope(variable_scope_name, vs)
log_info("Transforming feature '%s' with %s.targets_bottom",
feature_name,
modality_name)
transformed_features[feature_name] = bottom(features[feature_name],
self._hparams,
vocab_size)
else:
bottom = self._hparams.bottom.get(feature_name,
modalities.get_bottom(modality))
do_reuse = modality_name in all_previous_modalities
with tf.variable_scope(modality_name, reuse=do_reuse) as vs:
self._add_variable_scope(modality_name, vs)
log_info("Transforming feature '%s' with %s.bottom",
feature_name,
modality_name)
transformed_features[feature_name] = bottom(features[feature_name],
self._hparams,
vocab_size)
all_previous_modalities.append(modality_name)
for key in features:
if key not in transformed_features:
# For features without a modality, we pass them along as is
transformed_features[key] = features[key]
else:
# Other features get passed along with the "raw" suffix
transformed_features[key + "_raw"] = features[key]
return transformed_features |
def post_public(self, path, data, is_json=True):
'''Make a post request requiring no auth.'''
return self._post(path, data, is_json) | Make a post request requiring no auth. | Below is the the instruction that describes the task:
### Input:
Make a post request requiring no auth.
### Response:
def post_public(self, path, data, is_json=True):
'''Make a post request requiring no auth.'''
return self._post(path, data, is_json) |
def get_available_references(self, datas):
"""
Get available manifest reference names.
Every rules starting with prefix from ``nomenclature.RULE_REFERENCE``
are available references.
Only name validation is performed on these references.
Arguments:
datas (dict): Data where to search for reference declarations.
Returns:
list: List of every available reference names. This is the real
name unprefixed.
"""
names = []
for k, v in datas.items():
if k.startswith(RULE_REFERENCE):
names.append(k[len(RULE_REFERENCE)+1:])
return names | Get available manifest reference names.
Every rules starting with prefix from ``nomenclature.RULE_REFERENCE``
are available references.
Only name validation is performed on these references.
Arguments:
datas (dict): Data where to search for reference declarations.
Returns:
list: List of every available reference names. This is the real
name unprefixed. | Below is the the instruction that describes the task:
### Input:
Get available manifest reference names.
Every rules starting with prefix from ``nomenclature.RULE_REFERENCE``
are available references.
Only name validation is performed on these references.
Arguments:
datas (dict): Data where to search for reference declarations.
Returns:
list: List of every available reference names. This is the real
name unprefixed.
### Response:
def get_available_references(self, datas):
"""
Get available manifest reference names.
Every rules starting with prefix from ``nomenclature.RULE_REFERENCE``
are available references.
Only name validation is performed on these references.
Arguments:
datas (dict): Data where to search for reference declarations.
Returns:
list: List of every available reference names. This is the real
name unprefixed.
"""
names = []
for k, v in datas.items():
if k.startswith(RULE_REFERENCE):
names.append(k[len(RULE_REFERENCE)+1:])
return names |
def moses_multi_bleu(hypotheses, references, lowercase=False):
"""Calculate the bleu score for hypotheses and references
using the MOSES ulti-bleu.perl script.
Parameters
------------
hypotheses : numpy.array.string
A numpy array of strings where each string is a single example.
references : numpy.array.string
A numpy array of strings where each string is a single example.
lowercase : boolean
If True, pass the "-lc" flag to the multi-bleu script
Examples
---------
>>> hypotheses = ["a bird is flying on the sky"]
>>> references = ["two birds are flying on the sky", "a bird is on the top of the tree", "an airplane is on the sky",]
>>> score = tl.nlp.moses_multi_bleu(hypotheses, references)
Returns
--------
float
The BLEU score
References
----------
- `Google/seq2seq/metric/bleu <https://github.com/google/seq2seq>`__
"""
if np.size(hypotheses) == 0:
return np.float32(0.0)
# Get MOSES multi-bleu script
try:
multi_bleu_path, _ = urllib.request.urlretrieve(
"https://raw.githubusercontent.com/moses-smt/mosesdecoder/"
"master/scripts/generic/multi-bleu.perl"
)
os.chmod(multi_bleu_path, 0o755)
except Exception: # pylint: disable=W0702
tl.logging.info("Unable to fetch multi-bleu.perl script, using local.")
metrics_dir = os.path.dirname(os.path.realpath(__file__))
bin_dir = os.path.abspath(os.path.join(metrics_dir, "..", "..", "bin"))
multi_bleu_path = os.path.join(bin_dir, "tools/multi-bleu.perl")
# Dump hypotheses and references to tempfiles
hypothesis_file = tempfile.NamedTemporaryFile()
hypothesis_file.write("\n".join(hypotheses).encode("utf-8"))
hypothesis_file.write(b"\n")
hypothesis_file.flush()
reference_file = tempfile.NamedTemporaryFile()
reference_file.write("\n".join(references).encode("utf-8"))
reference_file.write(b"\n")
reference_file.flush()
# Calculate BLEU using multi-bleu script
with open(hypothesis_file.name, "r") as read_pred:
bleu_cmd = [multi_bleu_path]
if lowercase:
bleu_cmd += ["-lc"]
bleu_cmd += [reference_file.name]
try:
bleu_out = subprocess.check_output(bleu_cmd, stdin=read_pred, stderr=subprocess.STDOUT)
bleu_out = bleu_out.decode("utf-8")
bleu_score = re.search(r"BLEU = (.+?),", bleu_out).group(1)
bleu_score = float(bleu_score)
except subprocess.CalledProcessError as error:
if error.output is not None:
tl.logging.warning("multi-bleu.perl script returned non-zero exit code")
tl.logging.warning(error.output)
bleu_score = np.float32(0.0)
# Close temp files
hypothesis_file.close()
reference_file.close()
return np.float32(bleu_score) | Calculate the bleu score for hypotheses and references
using the MOSES ulti-bleu.perl script.
Parameters
------------
hypotheses : numpy.array.string
A numpy array of strings where each string is a single example.
references : numpy.array.string
A numpy array of strings where each string is a single example.
lowercase : boolean
If True, pass the "-lc" flag to the multi-bleu script
Examples
---------
>>> hypotheses = ["a bird is flying on the sky"]
>>> references = ["two birds are flying on the sky", "a bird is on the top of the tree", "an airplane is on the sky",]
>>> score = tl.nlp.moses_multi_bleu(hypotheses, references)
Returns
--------
float
The BLEU score
References
----------
- `Google/seq2seq/metric/bleu <https://github.com/google/seq2seq>`__ | Below is the the instruction that describes the task:
### Input:
Calculate the bleu score for hypotheses and references
using the MOSES ulti-bleu.perl script.
Parameters
------------
hypotheses : numpy.array.string
A numpy array of strings where each string is a single example.
references : numpy.array.string
A numpy array of strings where each string is a single example.
lowercase : boolean
If True, pass the "-lc" flag to the multi-bleu script
Examples
---------
>>> hypotheses = ["a bird is flying on the sky"]
>>> references = ["two birds are flying on the sky", "a bird is on the top of the tree", "an airplane is on the sky",]
>>> score = tl.nlp.moses_multi_bleu(hypotheses, references)
Returns
--------
float
The BLEU score
References
----------
- `Google/seq2seq/metric/bleu <https://github.com/google/seq2seq>`__
### Response:
def moses_multi_bleu(hypotheses, references, lowercase=False):
"""Calculate the bleu score for hypotheses and references
using the MOSES ulti-bleu.perl script.
Parameters
------------
hypotheses : numpy.array.string
A numpy array of strings where each string is a single example.
references : numpy.array.string
A numpy array of strings where each string is a single example.
lowercase : boolean
If True, pass the "-lc" flag to the multi-bleu script
Examples
---------
>>> hypotheses = ["a bird is flying on the sky"]
>>> references = ["two birds are flying on the sky", "a bird is on the top of the tree", "an airplane is on the sky",]
>>> score = tl.nlp.moses_multi_bleu(hypotheses, references)
Returns
--------
float
The BLEU score
References
----------
- `Google/seq2seq/metric/bleu <https://github.com/google/seq2seq>`__
"""
if np.size(hypotheses) == 0:
return np.float32(0.0)
# Get MOSES multi-bleu script
try:
multi_bleu_path, _ = urllib.request.urlretrieve(
"https://raw.githubusercontent.com/moses-smt/mosesdecoder/"
"master/scripts/generic/multi-bleu.perl"
)
os.chmod(multi_bleu_path, 0o755)
except Exception: # pylint: disable=W0702
tl.logging.info("Unable to fetch multi-bleu.perl script, using local.")
metrics_dir = os.path.dirname(os.path.realpath(__file__))
bin_dir = os.path.abspath(os.path.join(metrics_dir, "..", "..", "bin"))
multi_bleu_path = os.path.join(bin_dir, "tools/multi-bleu.perl")
# Dump hypotheses and references to tempfiles
hypothesis_file = tempfile.NamedTemporaryFile()
hypothesis_file.write("\n".join(hypotheses).encode("utf-8"))
hypothesis_file.write(b"\n")
hypothesis_file.flush()
reference_file = tempfile.NamedTemporaryFile()
reference_file.write("\n".join(references).encode("utf-8"))
reference_file.write(b"\n")
reference_file.flush()
# Calculate BLEU using multi-bleu script
with open(hypothesis_file.name, "r") as read_pred:
bleu_cmd = [multi_bleu_path]
if lowercase:
bleu_cmd += ["-lc"]
bleu_cmd += [reference_file.name]
try:
bleu_out = subprocess.check_output(bleu_cmd, stdin=read_pred, stderr=subprocess.STDOUT)
bleu_out = bleu_out.decode("utf-8")
bleu_score = re.search(r"BLEU = (.+?),", bleu_out).group(1)
bleu_score = float(bleu_score)
except subprocess.CalledProcessError as error:
if error.output is not None:
tl.logging.warning("multi-bleu.perl script returned non-zero exit code")
tl.logging.warning(error.output)
bleu_score = np.float32(0.0)
# Close temp files
hypothesis_file.close()
reference_file.close()
return np.float32(bleu_score) |
def add_query(self, name, filter, **kwargs):
"""Add a new query to device query service.
.. code-block:: python
f = api.add_query(
name = "Query name",
filter = {
"device_id": {"$eq": "01234"},
custom_attributes = {
"foo": {"$eq": "bar"}
}
}
)
print(f.created_at)
:param str name: Name of query (Required)
:param dict filter: Filter properties to apply (Required)
:param return: The newly created query object.
:return: the newly created query object
:rtype: Query
"""
# Ensure we have the correct types and get the new query object
filter_obj = filters.legacy_filter_formatter(
dict(filter=filter),
Device._get_attributes_map()
) if filter else None
query_map = Query._create_request_map(kwargs)
# Create the DeviceQuery object
f = DeviceQuery(name=name, query=filter_obj['filter'], **query_map)
api = self._get_api(device_directory.DefaultApi)
return Query(api.device_query_create(f)) | Add a new query to device query service.
.. code-block:: python
f = api.add_query(
name = "Query name",
filter = {
"device_id": {"$eq": "01234"},
custom_attributes = {
"foo": {"$eq": "bar"}
}
}
)
print(f.created_at)
:param str name: Name of query (Required)
:param dict filter: Filter properties to apply (Required)
:param return: The newly created query object.
:return: the newly created query object
:rtype: Query | Below is the the instruction that describes the task:
### Input:
Add a new query to device query service.
.. code-block:: python
f = api.add_query(
name = "Query name",
filter = {
"device_id": {"$eq": "01234"},
custom_attributes = {
"foo": {"$eq": "bar"}
}
}
)
print(f.created_at)
:param str name: Name of query (Required)
:param dict filter: Filter properties to apply (Required)
:param return: The newly created query object.
:return: the newly created query object
:rtype: Query
### Response:
def add_query(self, name, filter, **kwargs):
"""Add a new query to device query service.
.. code-block:: python
f = api.add_query(
name = "Query name",
filter = {
"device_id": {"$eq": "01234"},
custom_attributes = {
"foo": {"$eq": "bar"}
}
}
)
print(f.created_at)
:param str name: Name of query (Required)
:param dict filter: Filter properties to apply (Required)
:param return: The newly created query object.
:return: the newly created query object
:rtype: Query
"""
# Ensure we have the correct types and get the new query object
filter_obj = filters.legacy_filter_formatter(
dict(filter=filter),
Device._get_attributes_map()
) if filter else None
query_map = Query._create_request_map(kwargs)
# Create the DeviceQuery object
f = DeviceQuery(name=name, query=filter_obj['filter'], **query_map)
api = self._get_api(device_directory.DefaultApi)
return Query(api.device_query_create(f)) |
def get_dashboard_history(self, id, **kwargs): # noqa: E501
"""Get the version history of a specific dashboard # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_dashboard_history(id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str id: (required)
:param int offset:
:param int limit:
:return: ResponseContainerHistoryResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_dashboard_history_with_http_info(id, **kwargs) # noqa: E501
else:
(data) = self.get_dashboard_history_with_http_info(id, **kwargs) # noqa: E501
return data | Get the version history of a specific dashboard # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_dashboard_history(id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str id: (required)
:param int offset:
:param int limit:
:return: ResponseContainerHistoryResponse
If the method is called asynchronously,
returns the request thread. | Below is the the instruction that describes the task:
### Input:
Get the version history of a specific dashboard # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_dashboard_history(id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str id: (required)
:param int offset:
:param int limit:
:return: ResponseContainerHistoryResponse
If the method is called asynchronously,
returns the request thread.
### Response:
def get_dashboard_history(self, id, **kwargs): # noqa: E501
"""Get the version history of a specific dashboard # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_dashboard_history(id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str id: (required)
:param int offset:
:param int limit:
:return: ResponseContainerHistoryResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_dashboard_history_with_http_info(id, **kwargs) # noqa: E501
else:
(data) = self.get_dashboard_history_with_http_info(id, **kwargs) # noqa: E501
return data |
def get_hash(name, password=None):
'''
Returns the hash of a certificate in the keychain.
name
The name of the certificate (which you can get from keychain.get_friendly_name) or the
location of a p12 file.
password
The password that is used in the certificate. Only required if your passing a p12 file.
Note: This will be outputted to logs
CLI Example:
.. code-block:: bash
salt '*' keychain.get_hash /tmp/test.p12 test123
'''
if '.p12' in name[-4:]:
cmd = 'openssl pkcs12 -in {0} -passin pass:{1} -passout pass:{1}'.format(name, password)
else:
cmd = 'security find-certificate -c "{0}" -m -p'.format(name)
out = __salt__['cmd.run'](cmd)
matches = re.search('-----BEGIN CERTIFICATE-----(.*)-----END CERTIFICATE-----', out, re.DOTALL | re.MULTILINE)
if matches:
return matches.group(1)
else:
return False | Returns the hash of a certificate in the keychain.
name
The name of the certificate (which you can get from keychain.get_friendly_name) or the
location of a p12 file.
password
The password that is used in the certificate. Only required if your passing a p12 file.
Note: This will be outputted to logs
CLI Example:
.. code-block:: bash
salt '*' keychain.get_hash /tmp/test.p12 test123 | Below is the the instruction that describes the task:
### Input:
Returns the hash of a certificate in the keychain.
name
The name of the certificate (which you can get from keychain.get_friendly_name) or the
location of a p12 file.
password
The password that is used in the certificate. Only required if your passing a p12 file.
Note: This will be outputted to logs
CLI Example:
.. code-block:: bash
salt '*' keychain.get_hash /tmp/test.p12 test123
### Response:
def get_hash(name, password=None):
'''
Returns the hash of a certificate in the keychain.
name
The name of the certificate (which you can get from keychain.get_friendly_name) or the
location of a p12 file.
password
The password that is used in the certificate. Only required if your passing a p12 file.
Note: This will be outputted to logs
CLI Example:
.. code-block:: bash
salt '*' keychain.get_hash /tmp/test.p12 test123
'''
if '.p12' in name[-4:]:
cmd = 'openssl pkcs12 -in {0} -passin pass:{1} -passout pass:{1}'.format(name, password)
else:
cmd = 'security find-certificate -c "{0}" -m -p'.format(name)
out = __salt__['cmd.run'](cmd)
matches = re.search('-----BEGIN CERTIFICATE-----(.*)-----END CERTIFICATE-----', out, re.DOTALL | re.MULTILINE)
if matches:
return matches.group(1)
else:
return False |
def contains(self, time: datetime.datetime,
inclusive: bool = True) -> bool:
"""
Does the interval contain a momentary time?
Args:
time: the ``datetime.datetime`` to check
inclusive: use inclusive rather than exclusive range checks?
"""
if inclusive:
return self.start <= time <= self.end
else:
return self.start < time < self.end | Does the interval contain a momentary time?
Args:
time: the ``datetime.datetime`` to check
inclusive: use inclusive rather than exclusive range checks? | Below is the the instruction that describes the task:
### Input:
Does the interval contain a momentary time?
Args:
time: the ``datetime.datetime`` to check
inclusive: use inclusive rather than exclusive range checks?
### Response:
def contains(self, time: datetime.datetime,
inclusive: bool = True) -> bool:
"""
Does the interval contain a momentary time?
Args:
time: the ``datetime.datetime`` to check
inclusive: use inclusive rather than exclusive range checks?
"""
if inclusive:
return self.start <= time <= self.end
else:
return self.start < time < self.end |
def set_client_cert(self, cert):
"""*Sets the client cert for the requests.*
The cert is either a path to a .pem file, or a JSON array, or a list
having the cert path and the key path.
Values ``null`` and ``${None}`` can be used for clearing the cert.
*Examples*
| `Set Client Cert` | ${CURDIR}/client.pem |
| `Set Client Cert` | ["${CURDIR}/client.cert", "${CURDIR}/client.key"] |
| `Set Client Cert` | ${paths_list} |
"""
self.request["cert"] = self._input_client_cert(cert)
return self.request["cert"] | *Sets the client cert for the requests.*
The cert is either a path to a .pem file, or a JSON array, or a list
having the cert path and the key path.
Values ``null`` and ``${None}`` can be used for clearing the cert.
*Examples*
| `Set Client Cert` | ${CURDIR}/client.pem |
| `Set Client Cert` | ["${CURDIR}/client.cert", "${CURDIR}/client.key"] |
| `Set Client Cert` | ${paths_list} | | Below is the the instruction that describes the task:
### Input:
*Sets the client cert for the requests.*
The cert is either a path to a .pem file, or a JSON array, or a list
having the cert path and the key path.
Values ``null`` and ``${None}`` can be used for clearing the cert.
*Examples*
| `Set Client Cert` | ${CURDIR}/client.pem |
| `Set Client Cert` | ["${CURDIR}/client.cert", "${CURDIR}/client.key"] |
| `Set Client Cert` | ${paths_list} |
### Response:
def set_client_cert(self, cert):
"""*Sets the client cert for the requests.*
The cert is either a path to a .pem file, or a JSON array, or a list
having the cert path and the key path.
Values ``null`` and ``${None}`` can be used for clearing the cert.
*Examples*
| `Set Client Cert` | ${CURDIR}/client.pem |
| `Set Client Cert` | ["${CURDIR}/client.cert", "${CURDIR}/client.key"] |
| `Set Client Cert` | ${paths_list} |
"""
self.request["cert"] = self._input_client_cert(cert)
return self.request["cert"] |
def fetch_items(self, category, **kwargs):
"""Fetch the bugs
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
logger.info("Looking for bugs: '%s' updated from '%s'",
self.url, str(from_date))
nbugs = 0
for bug in self.__fetch_and_parse_bugs(from_date):
nbugs += 1
yield bug
logger.info("Fetch process completed: %s bugs fetched", nbugs) | Fetch the bugs
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items | Below is the the instruction that describes the task:
### Input:
Fetch the bugs
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
### Response:
def fetch_items(self, category, **kwargs):
"""Fetch the bugs
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
logger.info("Looking for bugs: '%s' updated from '%s'",
self.url, str(from_date))
nbugs = 0
for bug in self.__fetch_and_parse_bugs(from_date):
nbugs += 1
yield bug
logger.info("Fetch process completed: %s bugs fetched", nbugs) |
def _disable(name, started, result=True, skip_verify=False, **kwargs):
'''
Disable the service
'''
ret = {}
if not skip_verify:
# is service available?
try:
if not _available(name, ret):
ret['result'] = True
return ret
except CommandExecutionError as exc:
ret['result'] = False
ret['comment'] = exc.strerror
return ret
# Set default expected result
ret['result'] = result
# is enable/disable available?
if 'service.disable' not in __salt__ or 'service.disabled' not in __salt__:
if started is True:
ret['comment'] = ('Disable is not available on this minion,'
' service {0} started').format(name)
elif started is None:
ret['comment'] = ('Disable is not available on this minion,'
' service {0} is in the desired state'
).format(name)
else:
ret['comment'] = ('Disable is not available on this minion,'
' service {0} is dead').format(name)
return ret
# Service can be disabled
if salt.utils.platform.is_windows():
# service.disabled in Windows returns True for services that are set to
# Manual start, so we need to check specifically for Disabled
before_toggle_disable_status = __salt__['service.info'](name)['StartType'] in ['Disabled']
else:
before_toggle_disable_status = __salt__['service.disabled'](name)
if before_toggle_disable_status:
# Service is disabled
if started is True:
ret['comment'] = ('Service {0} is already disabled,'
' and is running').format(name)
elif started is None:
# always be sure in this case to reset the changes dict
ret['changes'] = {}
ret['comment'] = ('Service {0} is already disabled,'
' and is in the desired state').format(name)
else:
ret['comment'] = ('Service {0} is already disabled,'
' and is dead').format(name)
return ret
# Service needs to be disabled
if __opts__['test']:
ret['result'] = None
ret['comment'] = 'Service {0} set to be disabled'.format(name)
return ret
if __salt__['service.disable'](name, **kwargs):
# Service has been disabled
ret['changes'] = {}
after_toggle_disable_status = __salt__['service.disabled'](name)
# on upstart, certain services like apparmor will always return
# False, even if correctly activated
# do not trigger a change
if before_toggle_disable_status != after_toggle_disable_status:
ret['changes'][name] = True
if started is True:
ret['comment'] = ('Service {0} has been disabled,'
' and is running').format(name)
elif started is None:
ret['comment'] = ('Service {0} has been disabled,'
' and is in the desired state').format(name)
else:
ret['comment'] = ('Service {0} has been disabled,'
' and is dead').format(name)
return ret
# Service failed to be disabled
ret['result'] = False
if started is True:
ret['comment'] = ('Failed when setting service {0} to not start'
' at boot, and is running').format(name)
elif started is None:
ret['comment'] = ('Failed when setting service {0} to not start'
' at boot, but the service was already running'
).format(name)
else:
ret['comment'] = ('Failed when setting service {0} to not start'
' at boot, and the service is dead').format(name)
return ret | Disable the service | Below is the the instruction that describes the task:
### Input:
Disable the service
### Response:
def _disable(name, started, result=True, skip_verify=False, **kwargs):
'''
Disable the service
'''
ret = {}
if not skip_verify:
# is service available?
try:
if not _available(name, ret):
ret['result'] = True
return ret
except CommandExecutionError as exc:
ret['result'] = False
ret['comment'] = exc.strerror
return ret
# Set default expected result
ret['result'] = result
# is enable/disable available?
if 'service.disable' not in __salt__ or 'service.disabled' not in __salt__:
if started is True:
ret['comment'] = ('Disable is not available on this minion,'
' service {0} started').format(name)
elif started is None:
ret['comment'] = ('Disable is not available on this minion,'
' service {0} is in the desired state'
).format(name)
else:
ret['comment'] = ('Disable is not available on this minion,'
' service {0} is dead').format(name)
return ret
# Service can be disabled
if salt.utils.platform.is_windows():
# service.disabled in Windows returns True for services that are set to
# Manual start, so we need to check specifically for Disabled
before_toggle_disable_status = __salt__['service.info'](name)['StartType'] in ['Disabled']
else:
before_toggle_disable_status = __salt__['service.disabled'](name)
if before_toggle_disable_status:
# Service is disabled
if started is True:
ret['comment'] = ('Service {0} is already disabled,'
' and is running').format(name)
elif started is None:
# always be sure in this case to reset the changes dict
ret['changes'] = {}
ret['comment'] = ('Service {0} is already disabled,'
' and is in the desired state').format(name)
else:
ret['comment'] = ('Service {0} is already disabled,'
' and is dead').format(name)
return ret
# Service needs to be disabled
if __opts__['test']:
ret['result'] = None
ret['comment'] = 'Service {0} set to be disabled'.format(name)
return ret
if __salt__['service.disable'](name, **kwargs):
# Service has been disabled
ret['changes'] = {}
after_toggle_disable_status = __salt__['service.disabled'](name)
# on upstart, certain services like apparmor will always return
# False, even if correctly activated
# do not trigger a change
if before_toggle_disable_status != after_toggle_disable_status:
ret['changes'][name] = True
if started is True:
ret['comment'] = ('Service {0} has been disabled,'
' and is running').format(name)
elif started is None:
ret['comment'] = ('Service {0} has been disabled,'
' and is in the desired state').format(name)
else:
ret['comment'] = ('Service {0} has been disabled,'
' and is dead').format(name)
return ret
# Service failed to be disabled
ret['result'] = False
if started is True:
ret['comment'] = ('Failed when setting service {0} to not start'
' at boot, and is running').format(name)
elif started is None:
ret['comment'] = ('Failed when setting service {0} to not start'
' at boot, but the service was already running'
).format(name)
else:
ret['comment'] = ('Failed when setting service {0} to not start'
' at boot, and the service is dead').format(name)
return ret |
def position(self):
"""
Returns the current position of the motor in pulses of the rotary
encoder. When the motor rotates clockwise, the position will increase.
Likewise, rotating counter-clockwise causes the position to decrease.
Writing will set the position to that value.
"""
self._position, value = self.get_attr_int(self._position, 'position')
return value | Returns the current position of the motor in pulses of the rotary
encoder. When the motor rotates clockwise, the position will increase.
Likewise, rotating counter-clockwise causes the position to decrease.
Writing will set the position to that value. | Below is the the instruction that describes the task:
### Input:
Returns the current position of the motor in pulses of the rotary
encoder. When the motor rotates clockwise, the position will increase.
Likewise, rotating counter-clockwise causes the position to decrease.
Writing will set the position to that value.
### Response:
def position(self):
"""
Returns the current position of the motor in pulses of the rotary
encoder. When the motor rotates clockwise, the position will increase.
Likewise, rotating counter-clockwise causes the position to decrease.
Writing will set the position to that value.
"""
self._position, value = self.get_attr_int(self._position, 'position')
return value |
def setup_icons(self, ):
"""Set all icons on buttons
:returns: None
:rtype: None
:raises: None
"""
folder_icon = get_icon('glyphicons_144_folder_open.png', asicon=True)
self.asset_open_path_tb.setIcon(folder_icon)
self.shot_open_path_tb.setIcon(folder_icon)
current_icon = get_icon('glyphicons_181_download_alt.png', asicon=True)
self.current_pb.setIcon(current_icon)
refresh_icon = get_icon('refresh.png', asicon=True)
self.refresh_tb.setIcon(refresh_icon) | Set all icons on buttons
:returns: None
:rtype: None
:raises: None | Below is the the instruction that describes the task:
### Input:
Set all icons on buttons
:returns: None
:rtype: None
:raises: None
### Response:
def setup_icons(self, ):
"""Set all icons on buttons
:returns: None
:rtype: None
:raises: None
"""
folder_icon = get_icon('glyphicons_144_folder_open.png', asicon=True)
self.asset_open_path_tb.setIcon(folder_icon)
self.shot_open_path_tb.setIcon(folder_icon)
current_icon = get_icon('glyphicons_181_download_alt.png', asicon=True)
self.current_pb.setIcon(current_icon)
refresh_icon = get_icon('refresh.png', asicon=True)
self.refresh_tb.setIcon(refresh_icon) |
def epsilon_crit(self):
"""
returns the critical projected mass density in units of M_sun/Mpc^2 (physical units)
:return: critical projected mass density
"""
if not hasattr(self, '_Epsilon_Crit'):
const_SI = const.c ** 2 / (4 * np.pi * const.G) #c^2/(4*pi*G) in units of [kg/m]
conversion = const.Mpc / const.M_sun # converts [kg/m] to [M_sun/Mpc]
factor = const_SI*conversion #c^2/(4*pi*G) in units of [M_sun/Mpc]
self._Epsilon_Crit = self.D_s/(self.D_d*self.D_ds) * factor #[M_sun/Mpc^2]
return self._Epsilon_Crit | returns the critical projected mass density in units of M_sun/Mpc^2 (physical units)
:return: critical projected mass density | Below is the the instruction that describes the task:
### Input:
returns the critical projected mass density in units of M_sun/Mpc^2 (physical units)
:return: critical projected mass density
### Response:
def epsilon_crit(self):
"""
returns the critical projected mass density in units of M_sun/Mpc^2 (physical units)
:return: critical projected mass density
"""
if not hasattr(self, '_Epsilon_Crit'):
const_SI = const.c ** 2 / (4 * np.pi * const.G) #c^2/(4*pi*G) in units of [kg/m]
conversion = const.Mpc / const.M_sun # converts [kg/m] to [M_sun/Mpc]
factor = const_SI*conversion #c^2/(4*pi*G) in units of [M_sun/Mpc]
self._Epsilon_Crit = self.D_s/(self.D_d*self.D_ds) * factor #[M_sun/Mpc^2]
return self._Epsilon_Crit |
def assert_any_call(self, *args, **kwargs):
"""assert the mock has been called with the specified arguments.
The assert passes if the mock has *ever* been called, unlike
`assert_called_with` and `assert_called_once_with` that only pass if
the call is the most recent one."""
expected = self._call_matcher((args, kwargs))
actual = [self._call_matcher(c) for c in self.call_args_list]
if expected not in actual:
cause = expected if isinstance(expected, Exception) else None
expected_string = self._format_mock_call_signature(args, kwargs)
six.raise_from(AssertionError(
'%s call not found' % expected_string
), cause) | assert the mock has been called with the specified arguments.
The assert passes if the mock has *ever* been called, unlike
`assert_called_with` and `assert_called_once_with` that only pass if
the call is the most recent one. | Below is the the instruction that describes the task:
### Input:
assert the mock has been called with the specified arguments.
The assert passes if the mock has *ever* been called, unlike
`assert_called_with` and `assert_called_once_with` that only pass if
the call is the most recent one.
### Response:
def assert_any_call(self, *args, **kwargs):
"""assert the mock has been called with the specified arguments.
The assert passes if the mock has *ever* been called, unlike
`assert_called_with` and `assert_called_once_with` that only pass if
the call is the most recent one."""
expected = self._call_matcher((args, kwargs))
actual = [self._call_matcher(c) for c in self.call_args_list]
if expected not in actual:
cause = expected if isinstance(expected, Exception) else None
expected_string = self._format_mock_call_signature(args, kwargs)
six.raise_from(AssertionError(
'%s call not found' % expected_string
), cause) |
def calc_significand(prefix, dpd_bits, num_bits):
"""
prefix: High bits integer value
dpd_bits: dpd encoded bits
num_bits: bit length of dpd_bits
"""
# https://en.wikipedia.org/wiki/Decimal128_floating-point_format#Densely_packed_decimal_significand_field
num_segments = num_bits // 10
segments = []
for i in range(num_segments):
segments.append(dpd_bits & 0b1111111111)
dpd_bits >>= 10
segments.reverse()
v = prefix
for dpd in segments:
v = v * 1000 + dpd_to_int(dpd)
return v | prefix: High bits integer value
dpd_bits: dpd encoded bits
num_bits: bit length of dpd_bits | Below is the the instruction that describes the task:
### Input:
prefix: High bits integer value
dpd_bits: dpd encoded bits
num_bits: bit length of dpd_bits
### Response:
def calc_significand(prefix, dpd_bits, num_bits):
"""
prefix: High bits integer value
dpd_bits: dpd encoded bits
num_bits: bit length of dpd_bits
"""
# https://en.wikipedia.org/wiki/Decimal128_floating-point_format#Densely_packed_decimal_significand_field
num_segments = num_bits // 10
segments = []
for i in range(num_segments):
segments.append(dpd_bits & 0b1111111111)
dpd_bits >>= 10
segments.reverse()
v = prefix
for dpd in segments:
v = v * 1000 + dpd_to_int(dpd)
return v |
def on_message(self, ws, message):
"""Websocket on_message event handler
Saves message as RTMMessage in self._inbox
"""
try:
data = json.loads(message)
except Exception:
self._set_error(message, "decode message failed")
else:
self._inbox.put(RTMMessage(data)) | Websocket on_message event handler
Saves message as RTMMessage in self._inbox | Below is the the instruction that describes the task:
### Input:
Websocket on_message event handler
Saves message as RTMMessage in self._inbox
### Response:
def on_message(self, ws, message):
"""Websocket on_message event handler
Saves message as RTMMessage in self._inbox
"""
try:
data = json.loads(message)
except Exception:
self._set_error(message, "decode message failed")
else:
self._inbox.put(RTMMessage(data)) |
def set_link(self, link,y=0,page=-1):
"Set destination of internal link"
if(y==-1):
y=self.y
if(page==-1):
page=self.page
self.links[link]=[page,y] | Set destination of internal link | Below is the the instruction that describes the task:
### Input:
Set destination of internal link
### Response:
def set_link(self, link,y=0,page=-1):
"Set destination of internal link"
if(y==-1):
y=self.y
if(page==-1):
page=self.page
self.links[link]=[page,y] |
def await_flush_completion(self, timeout=None):
"""
Mark all partitions as ready to send and block until the send is complete
"""
try:
for batch in self._incomplete.all():
log.debug('Waiting on produce to %s',
batch.produce_future.topic_partition)
if not batch.produce_future.wait(timeout=timeout):
raise Errors.KafkaTimeoutError('Timeout waiting for future')
if not batch.produce_future.is_done:
raise Errors.UnknownError('Future not done')
if batch.produce_future.failed():
log.warning(batch.produce_future.exception)
finally:
self._flushes_in_progress.decrement() | Mark all partitions as ready to send and block until the send is complete | Below is the the instruction that describes the task:
### Input:
Mark all partitions as ready to send and block until the send is complete
### Response:
def await_flush_completion(self, timeout=None):
"""
Mark all partitions as ready to send and block until the send is complete
"""
try:
for batch in self._incomplete.all():
log.debug('Waiting on produce to %s',
batch.produce_future.topic_partition)
if not batch.produce_future.wait(timeout=timeout):
raise Errors.KafkaTimeoutError('Timeout waiting for future')
if not batch.produce_future.is_done:
raise Errors.UnknownError('Future not done')
if batch.produce_future.failed():
log.warning(batch.produce_future.exception)
finally:
self._flushes_in_progress.decrement() |
def autodiscover():
"""
Auto-discover INSTALLED_APPS backbone_api.py modules.
"""
# This code is based off django.contrib.admin.__init__
from django.conf import settings
try:
# Django versions >= 1.9
from django.utils.module_loading import import_module
except ImportError:
# Django versions < 1.9
from django.utils.importlib import import_module
from django.utils.module_loading import module_has_submodule
from backbone.views import BackboneAPIView # This is to prevent a circular import issue
for app in settings.INSTALLED_APPS:
mod = import_module(app)
# Attempt to import the app's backbone module.
try:
import_module('%s.backbone_api' % app)
except:
# Decide whether to bubble up this error. If the app just
# doesn't have an backbone module, we can ignore the error
# attempting to import it, otherwise we want it to bubble up.
if module_has_submodule(mod, 'backbone_api'):
raise | Auto-discover INSTALLED_APPS backbone_api.py modules. | Below is the the instruction that describes the task:
### Input:
Auto-discover INSTALLED_APPS backbone_api.py modules.
### Response:
def autodiscover():
"""
Auto-discover INSTALLED_APPS backbone_api.py modules.
"""
# This code is based off django.contrib.admin.__init__
from django.conf import settings
try:
# Django versions >= 1.9
from django.utils.module_loading import import_module
except ImportError:
# Django versions < 1.9
from django.utils.importlib import import_module
from django.utils.module_loading import module_has_submodule
from backbone.views import BackboneAPIView # This is to prevent a circular import issue
for app in settings.INSTALLED_APPS:
mod = import_module(app)
# Attempt to import the app's backbone module.
try:
import_module('%s.backbone_api' % app)
except:
# Decide whether to bubble up this error. If the app just
# doesn't have an backbone module, we can ignore the error
# attempting to import it, otherwise we want it to bubble up.
if module_has_submodule(mod, 'backbone_api'):
raise |
def DeleteUser(self, user_link, options=None):
"""Deletes a user.
:param str user_link:
The link to the user entity.
:param dict options:
The request options for the request.
:return:
The deleted user.
:rtype:
dict
"""
if options is None:
options = {}
path = base.GetPathFromLink(user_link)
user_id = base.GetResourceIdOrFullNameFromLink(user_link)
return self.DeleteResource(path,
'users',
user_id,
None,
options) | Deletes a user.
:param str user_link:
The link to the user entity.
:param dict options:
The request options for the request.
:return:
The deleted user.
:rtype:
dict | Below is the the instruction that describes the task:
### Input:
Deletes a user.
:param str user_link:
The link to the user entity.
:param dict options:
The request options for the request.
:return:
The deleted user.
:rtype:
dict
### Response:
def DeleteUser(self, user_link, options=None):
"""Deletes a user.
:param str user_link:
The link to the user entity.
:param dict options:
The request options for the request.
:return:
The deleted user.
:rtype:
dict
"""
if options is None:
options = {}
path = base.GetPathFromLink(user_link)
user_id = base.GetResourceIdOrFullNameFromLink(user_link)
return self.DeleteResource(path,
'users',
user_id,
None,
options) |
def visit_image(self, node):
"""
Image directive
"""
uri = node.attributes['uri']
doc_folder = os.path.dirname(self.builder.current_docname)
if uri.startswith(doc_folder):
# drop docname prefix
uri = uri[len(doc_folder):]
if uri.startswith("/"):
uri = "." + uri
self.add('\n\n\n\n' % uri) | Image directive | Below is the the instruction that describes the task:
### Input:
Image directive
### Response:
def visit_image(self, node):
"""
Image directive
"""
uri = node.attributes['uri']
doc_folder = os.path.dirname(self.builder.current_docname)
if uri.startswith(doc_folder):
# drop docname prefix
uri = uri[len(doc_folder):]
if uri.startswith("/"):
uri = "." + uri
self.add('\n\n\n\n' % uri) |
def push_broks_to_broker(self): # pragma: no cover - not used!
"""Send all broks from arbiter internal list to broker
The arbiter get some broks and then pushes them to all the brokers.
:return: None
"""
someone_is_concerned = False
sent = False
for broker_link in self.conf.brokers:
# Send only if the broker is concerned...
if not broker_link.manage_arbiters:
continue
someone_is_concerned = True
if broker_link.reachable:
logger.debug("Sending %d broks to the broker %s", len(self.broks), broker_link.name)
if broker_link.push_broks(self.broks):
statsmgr.counter('broks.pushed.count', len(self.broks))
sent = True
if not someone_is_concerned or sent:
# No one is anymore interested with...
del self.broks[:] | Send all broks from arbiter internal list to broker
The arbiter get some broks and then pushes them to all the brokers.
:return: None | Below is the the instruction that describes the task:
### Input:
Send all broks from arbiter internal list to broker
The arbiter get some broks and then pushes them to all the brokers.
:return: None
### Response:
def push_broks_to_broker(self): # pragma: no cover - not used!
"""Send all broks from arbiter internal list to broker
The arbiter get some broks and then pushes them to all the brokers.
:return: None
"""
someone_is_concerned = False
sent = False
for broker_link in self.conf.brokers:
# Send only if the broker is concerned...
if not broker_link.manage_arbiters:
continue
someone_is_concerned = True
if broker_link.reachable:
logger.debug("Sending %d broks to the broker %s", len(self.broks), broker_link.name)
if broker_link.push_broks(self.broks):
statsmgr.counter('broks.pushed.count', len(self.broks))
sent = True
if not someone_is_concerned or sent:
# No one is anymore interested with...
del self.broks[:] |
def absent(name, force=False):
'''
Ensure that a container is absent
name
Name of the container
force : False
Set to ``True`` to remove the container even if it is running
Usage Examples:
.. code-block:: yaml
mycontainer:
docker_container.absent
multiple_containers:
docker_container.absent:
- names:
- foo
- bar
- baz
'''
ret = {'name': name,
'changes': {},
'result': False,
'comment': ''}
if name not in __salt__['docker.list_containers'](all=True):
ret['result'] = True
ret['comment'] = 'Container \'{0}\' does not exist'.format(name)
return ret
pre_state = __salt__['docker.state'](name)
if pre_state != 'stopped' and not force:
ret['comment'] = ('Container is running, set force to True to '
'forcibly remove it')
return ret
if __opts__['test']:
ret['result'] = None
ret['comment'] = ('Container \'{0}\' will be removed'.format(name))
return ret
try:
ret['changes']['removed'] = __salt__['docker.rm'](name, force=force)
except Exception as exc:
ret['comment'] = ('Failed to remove container \'{0}\': {1}'
.format(name, exc))
return ret
if name in __salt__['docker.list_containers'](all=True):
ret['comment'] = 'Failed to remove container \'{0}\''.format(name)
else:
if force and pre_state != 'stopped':
method = 'Forcibly'
else:
method = 'Successfully'
ret['comment'] = '{0} removed container \'{1}\''.format(method, name)
ret['result'] = True
return ret | Ensure that a container is absent
name
Name of the container
force : False
Set to ``True`` to remove the container even if it is running
Usage Examples:
.. code-block:: yaml
mycontainer:
docker_container.absent
multiple_containers:
docker_container.absent:
- names:
- foo
- bar
- baz | Below is the the instruction that describes the task:
### Input:
Ensure that a container is absent
name
Name of the container
force : False
Set to ``True`` to remove the container even if it is running
Usage Examples:
.. code-block:: yaml
mycontainer:
docker_container.absent
multiple_containers:
docker_container.absent:
- names:
- foo
- bar
- baz
### Response:
def absent(name, force=False):
'''
Ensure that a container is absent
name
Name of the container
force : False
Set to ``True`` to remove the container even if it is running
Usage Examples:
.. code-block:: yaml
mycontainer:
docker_container.absent
multiple_containers:
docker_container.absent:
- names:
- foo
- bar
- baz
'''
ret = {'name': name,
'changes': {},
'result': False,
'comment': ''}
if name not in __salt__['docker.list_containers'](all=True):
ret['result'] = True
ret['comment'] = 'Container \'{0}\' does not exist'.format(name)
return ret
pre_state = __salt__['docker.state'](name)
if pre_state != 'stopped' and not force:
ret['comment'] = ('Container is running, set force to True to '
'forcibly remove it')
return ret
if __opts__['test']:
ret['result'] = None
ret['comment'] = ('Container \'{0}\' will be removed'.format(name))
return ret
try:
ret['changes']['removed'] = __salt__['docker.rm'](name, force=force)
except Exception as exc:
ret['comment'] = ('Failed to remove container \'{0}\': {1}'
.format(name, exc))
return ret
if name in __salt__['docker.list_containers'](all=True):
ret['comment'] = 'Failed to remove container \'{0}\''.format(name)
else:
if force and pre_state != 'stopped':
method = 'Forcibly'
else:
method = 'Successfully'
ret['comment'] = '{0} removed container \'{1}\''.format(method, name)
ret['result'] = True
return ret |
def write_training_data(self, features, targets):
""" Writes data dictionary to filename """
assert len(features) == len(targets)
data = dict(zip(features, targets))
with open(os.path.join(self.repopath, 'training.pkl'), 'w') as fp:
pickle.dump(data, fp) | Writes data dictionary to filename | Below is the the instruction that describes the task:
### Input:
Writes data dictionary to filename
### Response:
def write_training_data(self, features, targets):
""" Writes data dictionary to filename """
assert len(features) == len(targets)
data = dict(zip(features, targets))
with open(os.path.join(self.repopath, 'training.pkl'), 'w') as fp:
pickle.dump(data, fp) |
def prediction_model_dict(self):
"""
Converts the list of prediction_models passed in into properly formatted dictionaries
:return: formatted prediction model dict
"""
models = {}
for model in self.predictions_models:
models[model.name] = model.keywords
return models | Converts the list of prediction_models passed in into properly formatted dictionaries
:return: formatted prediction model dict | Below is the the instruction that describes the task:
### Input:
Converts the list of prediction_models passed in into properly formatted dictionaries
:return: formatted prediction model dict
### Response:
def prediction_model_dict(self):
"""
Converts the list of prediction_models passed in into properly formatted dictionaries
:return: formatted prediction model dict
"""
models = {}
for model in self.predictions_models:
models[model.name] = model.keywords
return models |
def basicauthfail(self, realm = b'all'):
"""
Return 401 for authentication failure. This will end the handler.
"""
if not isinstance(realm, bytes):
realm = realm.encode('ascii')
self.start_response(401, [(b'WWW-Authenticate', b'Basic realm="' + realm + b'"')])
self.exit(b'<h1>' + _createstatus(401) + b'</h1>') | Return 401 for authentication failure. This will end the handler. | Below is the the instruction that describes the task:
### Input:
Return 401 for authentication failure. This will end the handler.
### Response:
def basicauthfail(self, realm = b'all'):
"""
Return 401 for authentication failure. This will end the handler.
"""
if not isinstance(realm, bytes):
realm = realm.encode('ascii')
self.start_response(401, [(b'WWW-Authenticate', b'Basic realm="' + realm + b'"')])
self.exit(b'<h1>' + _createstatus(401) + b'</h1>') |
def check_throttles(self, request):
"""
Check if request should be throttled.
Raises an appropriate exception if the request is throttled.
"""
for throttle in self.get_throttles():
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait()) | Check if request should be throttled.
Raises an appropriate exception if the request is throttled. | Below is the the instruction that describes the task:
### Input:
Check if request should be throttled.
Raises an appropriate exception if the request is throttled.
### Response:
def check_throttles(self, request):
"""
Check if request should be throttled.
Raises an appropriate exception if the request is throttled.
"""
for throttle in self.get_throttles():
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait()) |
def video_category(self):
"""doc: http://open.youku.com/docs/doc?id=90
"""
url = 'https://openapi.youku.com/v2/schemas/video/category.json'
r = requests.get(url)
check_error(r)
return r.json() | doc: http://open.youku.com/docs/doc?id=90 | Below is the the instruction that describes the task:
### Input:
doc: http://open.youku.com/docs/doc?id=90
### Response:
def video_category(self):
"""doc: http://open.youku.com/docs/doc?id=90
"""
url = 'https://openapi.youku.com/v2/schemas/video/category.json'
r = requests.get(url)
check_error(r)
return r.json() |
def add_code_cell(work_notebook, code):
"""Add a code cell to the notebook
Parameters
----------
code : str
Cell content
"""
code_cell = {
"cell_type": "code",
"execution_count": None,
"metadata": {"collapsed": False},
"outputs": [],
"source": [code.strip()]
}
work_notebook["cells"].append(code_cell) | Add a code cell to the notebook
Parameters
----------
code : str
Cell content | Below is the the instruction that describes the task:
### Input:
Add a code cell to the notebook
Parameters
----------
code : str
Cell content
### Response:
def add_code_cell(work_notebook, code):
"""Add a code cell to the notebook
Parameters
----------
code : str
Cell content
"""
code_cell = {
"cell_type": "code",
"execution_count": None,
"metadata": {"collapsed": False},
"outputs": [],
"source": [code.strip()]
}
work_notebook["cells"].append(code_cell) |
def _get_acceleration(self, data):
'''Return acceleration mG'''
if (data[7:8] == 0x7FFF or
data[9:10] == 0x7FFF or
data[11:12] == 0x7FFF):
return (None, None, None)
acc_x = twos_complement((data[7] << 8) + data[8], 16)
acc_y = twos_complement((data[9] << 8) + data[10], 16)
acc_z = twos_complement((data[11] << 8) + data[12], 16)
return (acc_x, acc_y, acc_z) | Return acceleration mG | Below is the the instruction that describes the task:
### Input:
Return acceleration mG
### Response:
def _get_acceleration(self, data):
'''Return acceleration mG'''
if (data[7:8] == 0x7FFF or
data[9:10] == 0x7FFF or
data[11:12] == 0x7FFF):
return (None, None, None)
acc_x = twos_complement((data[7] << 8) + data[8], 16)
acc_y = twos_complement((data[9] << 8) + data[10], 16)
acc_z = twos_complement((data[11] << 8) + data[12], 16)
return (acc_x, acc_y, acc_z) |
def start(self):
"""
start
"""
def main_thread():
# create resp, req thread pool
self._create_thread_pool()
# start connection, this will block until stop()
self.conn_thread = Thread(target=self._conn.connect)
self.conn_thread.daemon = True
self.conn_thread.start()
# register model to controller...
self.is_ready.wait()
if hasattr(self, 'run'):
_logger.debug("Start running...")
self.run()
# start main_thread
self.main_thread = Thread(target=main_thread)
self.main_thread.daemon = True
self.main_thread.start()
if threading.current_thread().__class__.__name__ == '_MainThread':
# control this bundle stop or not
while not self.stop_event.wait(1):
sleep(1)
else:
self.stop_event.wait()
self.stop()
_logger.debug("Shutdown successfully") | start | Below is the the instruction that describes the task:
### Input:
start
### Response:
def start(self):
"""
start
"""
def main_thread():
# create resp, req thread pool
self._create_thread_pool()
# start connection, this will block until stop()
self.conn_thread = Thread(target=self._conn.connect)
self.conn_thread.daemon = True
self.conn_thread.start()
# register model to controller...
self.is_ready.wait()
if hasattr(self, 'run'):
_logger.debug("Start running...")
self.run()
# start main_thread
self.main_thread = Thread(target=main_thread)
self.main_thread.daemon = True
self.main_thread.start()
if threading.current_thread().__class__.__name__ == '_MainThread':
# control this bundle stop or not
while not self.stop_event.wait(1):
sleep(1)
else:
self.stop_event.wait()
self.stop()
_logger.debug("Shutdown successfully") |
def calc_fracrain_v1(self):
"""Determine the temperature-dependent fraction of (liquid) rainfall
and (total) precipitation.
Required control parameters:
|NmbZones|
|TT|,
|TTInt|
Required flux sequence:
|TC|
Calculated flux sequences:
|FracRain|
Basic equation:
:math:`FracRain = \\frac{TC-(TT-\\frac{TTInt}{2})}{TTInt}`
Restriction:
:math:`0 \\leq FracRain \\leq 1`
Examples:
The threshold temperature of seven zones is 0°C and the corresponding
temperature interval of mixed precipitation 2°C:
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(7)
>>> tt(0.0)
>>> ttint(2.0)
The fraction of rainfall is zero below -1°C, is one above 1°C and
increases linearly in between:
>>> fluxes.tc = -10.0, -1.0, -0.5, 0.0, 0.5, 1.0, 10.0
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0)
Note the special case of a zero temperature interval. With a
actual temperature being equal to the threshold temperature, the
rainfall fraction is one:
>>> ttint(0.0)
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0)
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
for k in range(con.nmbzones):
if flu.tc[k] >= (con.tt[k]+con.ttint[k]/2.):
flu.fracrain[k] = 1.
elif flu.tc[k] <= (con.tt[k]-con.ttint[k]/2.):
flu.fracrain[k] = 0.
else:
flu.fracrain[k] = ((flu.tc[k]-(con.tt[k]-con.ttint[k]/2.)) /
con.ttint[k]) | Determine the temperature-dependent fraction of (liquid) rainfall
and (total) precipitation.
Required control parameters:
|NmbZones|
|TT|,
|TTInt|
Required flux sequence:
|TC|
Calculated flux sequences:
|FracRain|
Basic equation:
:math:`FracRain = \\frac{TC-(TT-\\frac{TTInt}{2})}{TTInt}`
Restriction:
:math:`0 \\leq FracRain \\leq 1`
Examples:
The threshold temperature of seven zones is 0°C and the corresponding
temperature interval of mixed precipitation 2°C:
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(7)
>>> tt(0.0)
>>> ttint(2.0)
The fraction of rainfall is zero below -1°C, is one above 1°C and
increases linearly in between:
>>> fluxes.tc = -10.0, -1.0, -0.5, 0.0, 0.5, 1.0, 10.0
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0)
Note the special case of a zero temperature interval. With a
actual temperature being equal to the threshold temperature, the
rainfall fraction is one:
>>> ttint(0.0)
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0) | Below is the the instruction that describes the task:
### Input:
Determine the temperature-dependent fraction of (liquid) rainfall
and (total) precipitation.
Required control parameters:
|NmbZones|
|TT|,
|TTInt|
Required flux sequence:
|TC|
Calculated flux sequences:
|FracRain|
Basic equation:
:math:`FracRain = \\frac{TC-(TT-\\frac{TTInt}{2})}{TTInt}`
Restriction:
:math:`0 \\leq FracRain \\leq 1`
Examples:
The threshold temperature of seven zones is 0°C and the corresponding
temperature interval of mixed precipitation 2°C:
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(7)
>>> tt(0.0)
>>> ttint(2.0)
The fraction of rainfall is zero below -1°C, is one above 1°C and
increases linearly in between:
>>> fluxes.tc = -10.0, -1.0, -0.5, 0.0, 0.5, 1.0, 10.0
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0)
Note the special case of a zero temperature interval. With a
actual temperature being equal to the threshold temperature, the
rainfall fraction is one:
>>> ttint(0.0)
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0)
### Response:
def calc_fracrain_v1(self):
"""Determine the temperature-dependent fraction of (liquid) rainfall
and (total) precipitation.
Required control parameters:
|NmbZones|
|TT|,
|TTInt|
Required flux sequence:
|TC|
Calculated flux sequences:
|FracRain|
Basic equation:
:math:`FracRain = \\frac{TC-(TT-\\frac{TTInt}{2})}{TTInt}`
Restriction:
:math:`0 \\leq FracRain \\leq 1`
Examples:
The threshold temperature of seven zones is 0°C and the corresponding
temperature interval of mixed precipitation 2°C:
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(7)
>>> tt(0.0)
>>> ttint(2.0)
The fraction of rainfall is zero below -1°C, is one above 1°C and
increases linearly in between:
>>> fluxes.tc = -10.0, -1.0, -0.5, 0.0, 0.5, 1.0, 10.0
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.25, 0.5, 0.75, 1.0, 1.0)
Note the special case of a zero temperature interval. With a
actual temperature being equal to the threshold temperature, the
rainfall fraction is one:
>>> ttint(0.0)
>>> model.calc_fracrain_v1()
>>> fluxes.fracrain
fracrain(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0)
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
for k in range(con.nmbzones):
if flu.tc[k] >= (con.tt[k]+con.ttint[k]/2.):
flu.fracrain[k] = 1.
elif flu.tc[k] <= (con.tt[k]-con.ttint[k]/2.):
flu.fracrain[k] = 0.
else:
flu.fracrain[k] = ((flu.tc[k]-(con.tt[k]-con.ttint[k]/2.)) /
con.ttint[k]) |
def _raise_error(self, status_code, raw_data):
"""
Locate appropriate exception and raise it.
"""
error_message = raw_data
additional_info = None
try:
additional_info = json.loads(raw_data)
error_message = additional_info.get('error', error_message)
if isinstance(error_message, dict) and 'type' in error_message:
error_message = error_message['type']
except:
pass
raise HTTP_EXCEPTIONS.get(status_code, TransportError)(status_code, error_message, additional_info) | Locate appropriate exception and raise it. | Below is the the instruction that describes the task:
### Input:
Locate appropriate exception and raise it.
### Response:
def _raise_error(self, status_code, raw_data):
"""
Locate appropriate exception and raise it.
"""
error_message = raw_data
additional_info = None
try:
additional_info = json.loads(raw_data)
error_message = additional_info.get('error', error_message)
if isinstance(error_message, dict) and 'type' in error_message:
error_message = error_message['type']
except:
pass
raise HTTP_EXCEPTIONS.get(status_code, TransportError)(status_code, error_message, additional_info) |
def extend(self, table, keys=None):
"""Extends all rows in the texttable.
The rows are extended with the new columns from the table.
Args:
table: A texttable, the table to extend this table by.
keys: A set, the set of columns to use as the key. If None, the
row index is used.
Raises:
IndexError: If key is not a valid column name.
"""
if keys:
for k in keys:
if k not in self._Header():
raise IndexError("Unknown key: '%s'", k)
extend_with = []
for column in table.header:
if column not in self.header:
extend_with.append(column)
if not extend_with:
return
for column in extend_with:
self.AddColumn(column)
if not keys:
for row1, row2 in zip(self, table):
for column in extend_with:
row1[column] = row2[column]
return
for row1 in self:
for row2 in table:
for k in keys:
if row1[k] != row2[k]:
break
else:
for column in extend_with:
row1[column] = row2[column]
break | Extends all rows in the texttable.
The rows are extended with the new columns from the table.
Args:
table: A texttable, the table to extend this table by.
keys: A set, the set of columns to use as the key. If None, the
row index is used.
Raises:
IndexError: If key is not a valid column name. | Below is the the instruction that describes the task:
### Input:
Extends all rows in the texttable.
The rows are extended with the new columns from the table.
Args:
table: A texttable, the table to extend this table by.
keys: A set, the set of columns to use as the key. If None, the
row index is used.
Raises:
IndexError: If key is not a valid column name.
### Response:
def extend(self, table, keys=None):
"""Extends all rows in the texttable.
The rows are extended with the new columns from the table.
Args:
table: A texttable, the table to extend this table by.
keys: A set, the set of columns to use as the key. If None, the
row index is used.
Raises:
IndexError: If key is not a valid column name.
"""
if keys:
for k in keys:
if k not in self._Header():
raise IndexError("Unknown key: '%s'", k)
extend_with = []
for column in table.header:
if column not in self.header:
extend_with.append(column)
if not extend_with:
return
for column in extend_with:
self.AddColumn(column)
if not keys:
for row1, row2 in zip(self, table):
for column in extend_with:
row1[column] = row2[column]
return
for row1 in self:
for row2 in table:
for k in keys:
if row1[k] != row2[k]:
break
else:
for column in extend_with:
row1[column] = row2[column]
break |
def color_scale_HSV(c: Color, scoef: float, vcoef: float) -> None:
"""Scale a color's saturation and value.
Does not return a new Color. ``c`` is modified inplace.
Args:
c (Union[Color, List[int]]): A Color instance, or an [r, g, b] list.
scoef (float): Saturation multiplier, from 0 to 1.
Use 1 to keep current saturation.
vcoef (float): Value multiplier, from 0 to 1.
Use 1 to keep current value.
"""
color_p = ffi.new("TCOD_color_t*")
color_p.r, color_p.g, color_p.b = c.r, c.g, c.b
lib.TCOD_color_scale_HSV(color_p, scoef, vcoef)
c[:] = color_p.r, color_p.g, color_p.b | Scale a color's saturation and value.
Does not return a new Color. ``c`` is modified inplace.
Args:
c (Union[Color, List[int]]): A Color instance, or an [r, g, b] list.
scoef (float): Saturation multiplier, from 0 to 1.
Use 1 to keep current saturation.
vcoef (float): Value multiplier, from 0 to 1.
Use 1 to keep current value. | Below is the the instruction that describes the task:
### Input:
Scale a color's saturation and value.
Does not return a new Color. ``c`` is modified inplace.
Args:
c (Union[Color, List[int]]): A Color instance, or an [r, g, b] list.
scoef (float): Saturation multiplier, from 0 to 1.
Use 1 to keep current saturation.
vcoef (float): Value multiplier, from 0 to 1.
Use 1 to keep current value.
### Response:
def color_scale_HSV(c: Color, scoef: float, vcoef: float) -> None:
"""Scale a color's saturation and value.
Does not return a new Color. ``c`` is modified inplace.
Args:
c (Union[Color, List[int]]): A Color instance, or an [r, g, b] list.
scoef (float): Saturation multiplier, from 0 to 1.
Use 1 to keep current saturation.
vcoef (float): Value multiplier, from 0 to 1.
Use 1 to keep current value.
"""
color_p = ffi.new("TCOD_color_t*")
color_p.r, color_p.g, color_p.b = c.r, c.g, c.b
lib.TCOD_color_scale_HSV(color_p, scoef, vcoef)
c[:] = color_p.r, color_p.g, color_p.b |
def write_file(path, content, mode='w'):
# type: (Text, Union[Text,bytes], Text) -> None
""" --pretend aware file writing.
You can always write files manually but you should always handle the
--pretend case.
Args:
path (str):
content (str):
mode (str):
"""
from peltak.core import context
from peltak.core import log
if context.get('pretend', False):
log.info("Would overwrite <34>{path}<32> with:\n<90>{content}",
path=path,
content=content)
else:
with open(path, mode) as fp:
fp.write(content) | --pretend aware file writing.
You can always write files manually but you should always handle the
--pretend case.
Args:
path (str):
content (str):
mode (str): | Below is the the instruction that describes the task:
### Input:
--pretend aware file writing.
You can always write files manually but you should always handle the
--pretend case.
Args:
path (str):
content (str):
mode (str):
### Response:
def write_file(path, content, mode='w'):
# type: (Text, Union[Text,bytes], Text) -> None
""" --pretend aware file writing.
You can always write files manually but you should always handle the
--pretend case.
Args:
path (str):
content (str):
mode (str):
"""
from peltak.core import context
from peltak.core import log
if context.get('pretend', False):
log.info("Would overwrite <34>{path}<32> with:\n<90>{content}",
path=path,
content=content)
else:
with open(path, mode) as fp:
fp.write(content) |
def decode(tokens):
"""Decode a list of tokens to a unicode string.
Args:
tokens: a list of Unicode strings
Returns:
a unicode string
"""
token_is_alnum = [t[0] in _ALPHANUMERIC_CHAR_SET for t in tokens]
ret = []
for i, token in enumerate(tokens):
if i > 0 and token_is_alnum[i - 1] and token_is_alnum[i]:
ret.append(u" ")
ret.append(token)
return "".join(ret) | Decode a list of tokens to a unicode string.
Args:
tokens: a list of Unicode strings
Returns:
a unicode string | Below is the the instruction that describes the task:
### Input:
Decode a list of tokens to a unicode string.
Args:
tokens: a list of Unicode strings
Returns:
a unicode string
### Response:
def decode(tokens):
"""Decode a list of tokens to a unicode string.
Args:
tokens: a list of Unicode strings
Returns:
a unicode string
"""
token_is_alnum = [t[0] in _ALPHANUMERIC_CHAR_SET for t in tokens]
ret = []
for i, token in enumerate(tokens):
if i > 0 and token_is_alnum[i - 1] and token_is_alnum[i]:
ret.append(u" ")
ret.append(token)
return "".join(ret) |
def parse_classname(self, tup_tree):
"""
Parse a CLASSNAME element and return the class path it represents as a
CIMClassName object.
::
<!ELEMENT CLASSNAME EMPTY>
<!ATTLIST CLASSNAME
%CIMName;>
Returns:
CIMClassName object (without namespace or host)
"""
self.check_node(tup_tree, 'CLASSNAME', ('NAME',), (), ())
classname = attrs(tup_tree)['NAME']
class_path = CIMClassName(classname)
return class_path | Parse a CLASSNAME element and return the class path it represents as a
CIMClassName object.
::
<!ELEMENT CLASSNAME EMPTY>
<!ATTLIST CLASSNAME
%CIMName;>
Returns:
CIMClassName object (without namespace or host) | Below is the the instruction that describes the task:
### Input:
Parse a CLASSNAME element and return the class path it represents as a
CIMClassName object.
::
<!ELEMENT CLASSNAME EMPTY>
<!ATTLIST CLASSNAME
%CIMName;>
Returns:
CIMClassName object (without namespace or host)
### Response:
def parse_classname(self, tup_tree):
"""
Parse a CLASSNAME element and return the class path it represents as a
CIMClassName object.
::
<!ELEMENT CLASSNAME EMPTY>
<!ATTLIST CLASSNAME
%CIMName;>
Returns:
CIMClassName object (without namespace or host)
"""
self.check_node(tup_tree, 'CLASSNAME', ('NAME',), (), ())
classname = attrs(tup_tree)['NAME']
class_path = CIMClassName(classname)
return class_path |
def start_kline_socket(self, symbol, callback, interval=Client.KLINE_INTERVAL_1MINUTE):
"""Start a websocket for symbol kline data
https://github.com/binance-exchange/binance-official-api-docs/blob/master/web-socket-streams.md#klinecandlestick-streams
:param symbol: required
:type symbol: str
:param callback: callback function to handle messages
:type callback: function
:param interval: Kline interval, default KLINE_INTERVAL_1MINUTE
:type interval: str
:returns: connection key string if successful, False otherwise
Message Format
.. code-block:: python
{
"e": "kline", # event type
"E": 1499404907056, # event time
"s": "ETHBTC", # symbol
"k": {
"t": 1499404860000, # start time of this bar
"T": 1499404919999, # end time of this bar
"s": "ETHBTC", # symbol
"i": "1m", # interval
"f": 77462, # first trade id
"L": 77465, # last trade id
"o": "0.10278577", # open
"c": "0.10278645", # close
"h": "0.10278712", # high
"l": "0.10278518", # low
"v": "17.47929838", # volume
"n": 4, # number of trades
"x": false, # whether this bar is final
"q": "1.79662878", # quote volume
"V": "2.34879839", # volume of active buy
"Q": "0.24142166", # quote volume of active buy
"B": "13279784.01349473" # can be ignored
}
}
"""
socket_name = '{}@kline_{}'.format(symbol.lower(), interval)
return self._start_socket(socket_name, callback) | Start a websocket for symbol kline data
https://github.com/binance-exchange/binance-official-api-docs/blob/master/web-socket-streams.md#klinecandlestick-streams
:param symbol: required
:type symbol: str
:param callback: callback function to handle messages
:type callback: function
:param interval: Kline interval, default KLINE_INTERVAL_1MINUTE
:type interval: str
:returns: connection key string if successful, False otherwise
Message Format
.. code-block:: python
{
"e": "kline", # event type
"E": 1499404907056, # event time
"s": "ETHBTC", # symbol
"k": {
"t": 1499404860000, # start time of this bar
"T": 1499404919999, # end time of this bar
"s": "ETHBTC", # symbol
"i": "1m", # interval
"f": 77462, # first trade id
"L": 77465, # last trade id
"o": "0.10278577", # open
"c": "0.10278645", # close
"h": "0.10278712", # high
"l": "0.10278518", # low
"v": "17.47929838", # volume
"n": 4, # number of trades
"x": false, # whether this bar is final
"q": "1.79662878", # quote volume
"V": "2.34879839", # volume of active buy
"Q": "0.24142166", # quote volume of active buy
"B": "13279784.01349473" # can be ignored
}
} | Below is the the instruction that describes the task:
### Input:
Start a websocket for symbol kline data
https://github.com/binance-exchange/binance-official-api-docs/blob/master/web-socket-streams.md#klinecandlestick-streams
:param symbol: required
:type symbol: str
:param callback: callback function to handle messages
:type callback: function
:param interval: Kline interval, default KLINE_INTERVAL_1MINUTE
:type interval: str
:returns: connection key string if successful, False otherwise
Message Format
.. code-block:: python
{
"e": "kline", # event type
"E": 1499404907056, # event time
"s": "ETHBTC", # symbol
"k": {
"t": 1499404860000, # start time of this bar
"T": 1499404919999, # end time of this bar
"s": "ETHBTC", # symbol
"i": "1m", # interval
"f": 77462, # first trade id
"L": 77465, # last trade id
"o": "0.10278577", # open
"c": "0.10278645", # close
"h": "0.10278712", # high
"l": "0.10278518", # low
"v": "17.47929838", # volume
"n": 4, # number of trades
"x": false, # whether this bar is final
"q": "1.79662878", # quote volume
"V": "2.34879839", # volume of active buy
"Q": "0.24142166", # quote volume of active buy
"B": "13279784.01349473" # can be ignored
}
}
### Response:
def start_kline_socket(self, symbol, callback, interval=Client.KLINE_INTERVAL_1MINUTE):
"""Start a websocket for symbol kline data
https://github.com/binance-exchange/binance-official-api-docs/blob/master/web-socket-streams.md#klinecandlestick-streams
:param symbol: required
:type symbol: str
:param callback: callback function to handle messages
:type callback: function
:param interval: Kline interval, default KLINE_INTERVAL_1MINUTE
:type interval: str
:returns: connection key string if successful, False otherwise
Message Format
.. code-block:: python
{
"e": "kline", # event type
"E": 1499404907056, # event time
"s": "ETHBTC", # symbol
"k": {
"t": 1499404860000, # start time of this bar
"T": 1499404919999, # end time of this bar
"s": "ETHBTC", # symbol
"i": "1m", # interval
"f": 77462, # first trade id
"L": 77465, # last trade id
"o": "0.10278577", # open
"c": "0.10278645", # close
"h": "0.10278712", # high
"l": "0.10278518", # low
"v": "17.47929838", # volume
"n": 4, # number of trades
"x": false, # whether this bar is final
"q": "1.79662878", # quote volume
"V": "2.34879839", # volume of active buy
"Q": "0.24142166", # quote volume of active buy
"B": "13279784.01349473" # can be ignored
}
}
"""
socket_name = '{}@kline_{}'.format(symbol.lower(), interval)
return self._start_socket(socket_name, callback) |
def _set_vcs_cluster_type_info(self, v, load=False):
"""
Setter method for vcs_cluster_type_info, mapped from YANG variable /brocade_vcs_rpc/show_vcs/output/vcs_cluster_type_info (vcs-cluster-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vcs_cluster_type_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vcs_cluster_type_info() directly.
YANG Description: Vcs Type
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="dict_key", restriction_arg={u'vcs-fabric-cluster': {'value': 3}, u'vcs-unknown-cluster': {'value': 1}, u'vcs-stand-alone': {'value': 2}, u'vcs-management-cluster': {'value': 4}},), is_leaf=True, yang_name="vcs-cluster-type-info", rest_name="vcs-cluster-type-info", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-vcs', defining_module='brocade-vcs', yang_type='vcs-cluster-type', is_config=True)
except (TypeError, ValueError):
raise ValueError({
'error-string': """vcs_cluster_type_info must be of a type compatible with vcs-cluster-type""",
'defined-type': "brocade-vcs:vcs-cluster-type",
'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_type="dict_key", restriction_arg={u'vcs-fabric-cluster': {'value': 3}, u'vcs-unknown-cluster': {'value': 1}, u'vcs-stand-alone': {'value': 2}, u'vcs-management-cluster': {'value': 4}},), is_leaf=True, yang_name="vcs-cluster-type-info", rest_name="vcs-cluster-type-info", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-vcs', defining_module='brocade-vcs', yang_type='vcs-cluster-type', is_config=True)""",
})
self.__vcs_cluster_type_info = t
if hasattr(self, '_set'):
self._set() | Setter method for vcs_cluster_type_info, mapped from YANG variable /brocade_vcs_rpc/show_vcs/output/vcs_cluster_type_info (vcs-cluster-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vcs_cluster_type_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vcs_cluster_type_info() directly.
YANG Description: Vcs Type | Below is the the instruction that describes the task:
### Input:
Setter method for vcs_cluster_type_info, mapped from YANG variable /brocade_vcs_rpc/show_vcs/output/vcs_cluster_type_info (vcs-cluster-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vcs_cluster_type_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vcs_cluster_type_info() directly.
YANG Description: Vcs Type
### Response:
def _set_vcs_cluster_type_info(self, v, load=False):
"""
Setter method for vcs_cluster_type_info, mapped from YANG variable /brocade_vcs_rpc/show_vcs/output/vcs_cluster_type_info (vcs-cluster-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vcs_cluster_type_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vcs_cluster_type_info() directly.
YANG Description: Vcs Type
"""
if hasattr(v, "_utype"):
v = v._utype(v)
try:
t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="dict_key", restriction_arg={u'vcs-fabric-cluster': {'value': 3}, u'vcs-unknown-cluster': {'value': 1}, u'vcs-stand-alone': {'value': 2}, u'vcs-management-cluster': {'value': 4}},), is_leaf=True, yang_name="vcs-cluster-type-info", rest_name="vcs-cluster-type-info", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-vcs', defining_module='brocade-vcs', yang_type='vcs-cluster-type', is_config=True)
except (TypeError, ValueError):
raise ValueError({
'error-string': """vcs_cluster_type_info must be of a type compatible with vcs-cluster-type""",
'defined-type': "brocade-vcs:vcs-cluster-type",
'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_type="dict_key", restriction_arg={u'vcs-fabric-cluster': {'value': 3}, u'vcs-unknown-cluster': {'value': 1}, u'vcs-stand-alone': {'value': 2}, u'vcs-management-cluster': {'value': 4}},), is_leaf=True, yang_name="vcs-cluster-type-info", rest_name="vcs-cluster-type-info", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-vcs', defining_module='brocade-vcs', yang_type='vcs-cluster-type', is_config=True)""",
})
self.__vcs_cluster_type_info = t
if hasattr(self, '_set'):
self._set() |
def check(self, check_all=True, do_reload=True):
"""Check whether some modules need to be reloaded."""
with enaml.imports():
super(EnamlReloader, self).check(check_all=check_all, do_reload=do_reload) | Check whether some modules need to be reloaded. | Below is the the instruction that describes the task:
### Input:
Check whether some modules need to be reloaded.
### Response:
def check(self, check_all=True, do_reload=True):
"""Check whether some modules need to be reloaded."""
with enaml.imports():
super(EnamlReloader, self).check(check_all=check_all, do_reload=do_reload) |
def convert_choices_to_dict(choices):
""" Takes a list of tuples and converts it to a list of dictionaries of
where each dictionary has a value and text key. This is the expected format
of question choices to be returned by self.ask()
:param convert_choices_to_dict:
:type convert_choices_to_dict: list
:return:
:rtype:
"""
formatted_choices = []
for x in choices:
formatted_choices.append({
'value': x[0],
'text': x[1],
})
return formatted_choices | Takes a list of tuples and converts it to a list of dictionaries of
where each dictionary has a value and text key. This is the expected format
of question choices to be returned by self.ask()
:param convert_choices_to_dict:
:type convert_choices_to_dict: list
:return:
:rtype: | Below is the the instruction that describes the task:
### Input:
Takes a list of tuples and converts it to a list of dictionaries of
where each dictionary has a value and text key. This is the expected format
of question choices to be returned by self.ask()
:param convert_choices_to_dict:
:type convert_choices_to_dict: list
:return:
:rtype:
### Response:
def convert_choices_to_dict(choices):
""" Takes a list of tuples and converts it to a list of dictionaries of
where each dictionary has a value and text key. This is the expected format
of question choices to be returned by self.ask()
:param convert_choices_to_dict:
:type convert_choices_to_dict: list
:return:
:rtype:
"""
formatted_choices = []
for x in choices:
formatted_choices.append({
'value': x[0],
'text': x[1],
})
return formatted_choices |
def partial_fit(self, X):
"""Train model based on mini-batch of input data.
Return cost of mini-batch.
"""
opt, cost = self.sess.run((self.optimizer, self.cost),
feed_dict={self.x: X})
return cost | Train model based on mini-batch of input data.
Return cost of mini-batch. | Below is the the instruction that describes the task:
### Input:
Train model based on mini-batch of input data.
Return cost of mini-batch.
### Response:
def partial_fit(self, X):
"""Train model based on mini-batch of input data.
Return cost of mini-batch.
"""
opt, cost = self.sess.run((self.optimizer, self.cost),
feed_dict={self.x: X})
return cost |
def update_observation(observation_id: int, params: Dict[str, Any], access_token: str) -> List[Dict[str, Any]]:
"""
Update a single observation. See https://www.inaturalist.org/pages/api+reference#put-observations-id
:param observation_id: the ID of the observation to update
:param params: to be passed to iNaturalist API
:param access_token: the access token, as returned by :func:`get_access_token()`
:return: iNaturalist's JSON response, as a Python object
:raise: requests.HTTPError, if the call is not successful. iNaturalist returns an error 410 if the observation
doesn't exists or belongs to another user (as of November 2018).
"""
response = requests.put(url="{base_url}/observations/{id}.json".format(base_url=INAT_BASE_URL, id=observation_id),
json=params,
headers=_build_auth_header(access_token))
response.raise_for_status()
return response.json() | Update a single observation. See https://www.inaturalist.org/pages/api+reference#put-observations-id
:param observation_id: the ID of the observation to update
:param params: to be passed to iNaturalist API
:param access_token: the access token, as returned by :func:`get_access_token()`
:return: iNaturalist's JSON response, as a Python object
:raise: requests.HTTPError, if the call is not successful. iNaturalist returns an error 410 if the observation
doesn't exists or belongs to another user (as of November 2018). | Below is the the instruction that describes the task:
### Input:
Update a single observation. See https://www.inaturalist.org/pages/api+reference#put-observations-id
:param observation_id: the ID of the observation to update
:param params: to be passed to iNaturalist API
:param access_token: the access token, as returned by :func:`get_access_token()`
:return: iNaturalist's JSON response, as a Python object
:raise: requests.HTTPError, if the call is not successful. iNaturalist returns an error 410 if the observation
doesn't exists or belongs to another user (as of November 2018).
### Response:
def update_observation(observation_id: int, params: Dict[str, Any], access_token: str) -> List[Dict[str, Any]]:
"""
Update a single observation. See https://www.inaturalist.org/pages/api+reference#put-observations-id
:param observation_id: the ID of the observation to update
:param params: to be passed to iNaturalist API
:param access_token: the access token, as returned by :func:`get_access_token()`
:return: iNaturalist's JSON response, as a Python object
:raise: requests.HTTPError, if the call is not successful. iNaturalist returns an error 410 if the observation
doesn't exists or belongs to another user (as of November 2018).
"""
response = requests.put(url="{base_url}/observations/{id}.json".format(base_url=INAT_BASE_URL, id=observation_id),
json=params,
headers=_build_auth_header(access_token))
response.raise_for_status()
return response.json() |
def resample(grid, wl, flux):
""" Resample spectrum onto desired grid """
flux_rs = (interpolate.interp1d(wl, flux))(grid)
return flux_rs | Resample spectrum onto desired grid | Below is the the instruction that describes the task:
### Input:
Resample spectrum onto desired grid
### Response:
def resample(grid, wl, flux):
""" Resample spectrum onto desired grid """
flux_rs = (interpolate.interp1d(wl, flux))(grid)
return flux_rs |
def data_nodes(self):
"""
Returns all data nodes of the dispatcher.
:return:
All data nodes of the dispatcher.
:rtype: dict[str, dict]
"""
return {k: v for k, v in self.nodes.items() if v['type'] == 'data'} | Returns all data nodes of the dispatcher.
:return:
All data nodes of the dispatcher.
:rtype: dict[str, dict] | Below is the the instruction that describes the task:
### Input:
Returns all data nodes of the dispatcher.
:return:
All data nodes of the dispatcher.
:rtype: dict[str, dict]
### Response:
def data_nodes(self):
"""
Returns all data nodes of the dispatcher.
:return:
All data nodes of the dispatcher.
:rtype: dict[str, dict]
"""
return {k: v for k, v in self.nodes.items() if v['type'] == 'data'} |
def unpack_results(
data: bytes,
repetitions: int,
key_sizes: Sequence[Tuple[str, int]]
) -> Dict[str, np.ndarray]:
"""Unpack data from a bitstring into individual measurement results.
Args:
data: Packed measurement results, in the form <rep0><rep1>...
where each repetition is <key0_0>..<key0_{size0-1}><key1_0>...
with bits packed in little-endian order in each byte.
repetitions: number of repetitions.
key_sizes: Keys and sizes of the measurements in the data.
Returns:
Dict mapping measurement key to a 2D array of boolean results. Each
array has shape (repetitions, size) with size for that measurement.
"""
bits_per_rep = sum(size for _, size in key_sizes)
total_bits = repetitions * bits_per_rep
byte_arr = np.frombuffer(data, dtype='uint8').reshape((len(data), 1))
bits = np.unpackbits(byte_arr, axis=1)[:, ::-1].reshape(-1).astype(bool)
bits = bits[:total_bits].reshape((repetitions, bits_per_rep))
results = {}
ofs = 0
for key, size in key_sizes:
results[key] = bits[:, ofs:ofs + size]
ofs += size
return results | Unpack data from a bitstring into individual measurement results.
Args:
data: Packed measurement results, in the form <rep0><rep1>...
where each repetition is <key0_0>..<key0_{size0-1}><key1_0>...
with bits packed in little-endian order in each byte.
repetitions: number of repetitions.
key_sizes: Keys and sizes of the measurements in the data.
Returns:
Dict mapping measurement key to a 2D array of boolean results. Each
array has shape (repetitions, size) with size for that measurement. | Below is the the instruction that describes the task:
### Input:
Unpack data from a bitstring into individual measurement results.
Args:
data: Packed measurement results, in the form <rep0><rep1>...
where each repetition is <key0_0>..<key0_{size0-1}><key1_0>...
with bits packed in little-endian order in each byte.
repetitions: number of repetitions.
key_sizes: Keys and sizes of the measurements in the data.
Returns:
Dict mapping measurement key to a 2D array of boolean results. Each
array has shape (repetitions, size) with size for that measurement.
### Response:
def unpack_results(
data: bytes,
repetitions: int,
key_sizes: Sequence[Tuple[str, int]]
) -> Dict[str, np.ndarray]:
"""Unpack data from a bitstring into individual measurement results.
Args:
data: Packed measurement results, in the form <rep0><rep1>...
where each repetition is <key0_0>..<key0_{size0-1}><key1_0>...
with bits packed in little-endian order in each byte.
repetitions: number of repetitions.
key_sizes: Keys and sizes of the measurements in the data.
Returns:
Dict mapping measurement key to a 2D array of boolean results. Each
array has shape (repetitions, size) with size for that measurement.
"""
bits_per_rep = sum(size for _, size in key_sizes)
total_bits = repetitions * bits_per_rep
byte_arr = np.frombuffer(data, dtype='uint8').reshape((len(data), 1))
bits = np.unpackbits(byte_arr, axis=1)[:, ::-1].reshape(-1).astype(bool)
bits = bits[:total_bits].reshape((repetitions, bits_per_rep))
results = {}
ofs = 0
for key, size in key_sizes:
results[key] = bits[:, ofs:ofs + size]
ofs += size
return results |
def find_faces(self, image, draw_box=False):
"""Uses a haarcascade to detect faces inside an image.
Args:
image: The image.
draw_box: If True, the image will be marked with a rectangle.
Return:
The faces as returned by OpenCV's detectMultiScale method for
cascades.
"""
frame_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
faces = self.cascade.detectMultiScale(
frame_gray,
scaleFactor=1.3,
minNeighbors=5,
minSize=(50, 50),
flags=0)
if draw_box:
for x, y, w, h in faces:
cv2.rectangle(image, (x, y),
(x + w, y + h), (0, 255, 0), 2)
return faces | Uses a haarcascade to detect faces inside an image.
Args:
image: The image.
draw_box: If True, the image will be marked with a rectangle.
Return:
The faces as returned by OpenCV's detectMultiScale method for
cascades. | Below is the the instruction that describes the task:
### Input:
Uses a haarcascade to detect faces inside an image.
Args:
image: The image.
draw_box: If True, the image will be marked with a rectangle.
Return:
The faces as returned by OpenCV's detectMultiScale method for
cascades.
### Response:
def find_faces(self, image, draw_box=False):
"""Uses a haarcascade to detect faces inside an image.
Args:
image: The image.
draw_box: If True, the image will be marked with a rectangle.
Return:
The faces as returned by OpenCV's detectMultiScale method for
cascades.
"""
frame_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
faces = self.cascade.detectMultiScale(
frame_gray,
scaleFactor=1.3,
minNeighbors=5,
minSize=(50, 50),
flags=0)
if draw_box:
for x, y, w, h in faces:
cv2.rectangle(image, (x, y),
(x + w, y + h), (0, 255, 0), 2)
return faces |
def init_default_config(self, path):
''' Initialize the config object and load the default configuration.
The path to the config file must be provided. The name of the
application is read from the config file.
The config file stores the description and the default values for
all configurations including the application name.
@param path: The path to the config config file.
'''
if not (os.path.exists(path) and os.path.isfile(path)):
raise AppConfigValueException('The given config config file does '
'not exist. ({0})'.format(path))
cfl = open(path, 'r')
data = json.load(cfl)
cfl.close()
for key in data.keys():
if 'application_name' == key:
self.application_name = data[key].lower()
continue
if 'application_author' == key:
self.application_author = data[key].lower()
continue
if 'application_version' == key:
self.application_version = data[key].lower()
continue
self._add_section_default(key, data[key]) | Initialize the config object and load the default configuration.
The path to the config file must be provided. The name of the
application is read from the config file.
The config file stores the description and the default values for
all configurations including the application name.
@param path: The path to the config config file. | Below is the the instruction that describes the task:
### Input:
Initialize the config object and load the default configuration.
The path to the config file must be provided. The name of the
application is read from the config file.
The config file stores the description and the default values for
all configurations including the application name.
@param path: The path to the config config file.
### Response:
def init_default_config(self, path):
''' Initialize the config object and load the default configuration.
The path to the config file must be provided. The name of the
application is read from the config file.
The config file stores the description and the default values for
all configurations including the application name.
@param path: The path to the config config file.
'''
if not (os.path.exists(path) and os.path.isfile(path)):
raise AppConfigValueException('The given config config file does '
'not exist. ({0})'.format(path))
cfl = open(path, 'r')
data = json.load(cfl)
cfl.close()
for key in data.keys():
if 'application_name' == key:
self.application_name = data[key].lower()
continue
if 'application_author' == key:
self.application_author = data[key].lower()
continue
if 'application_version' == key:
self.application_version = data[key].lower()
continue
self._add_section_default(key, data[key]) |
def set_style(self):
"""
Set font style with the following attributes:
'foreground_color', 'background_color', 'italic',
'bold' and 'underline'
"""
if self.current_format is None:
assert self.base_format is not None
self.current_format = QTextCharFormat(self.base_format)
# Foreground color
if self.foreground_color is None:
qcolor = self.base_format.foreground()
else:
cstr = self.ANSI_COLORS[self.foreground_color-30][self.intensity]
qcolor = QColor(cstr)
self.current_format.setForeground(qcolor)
# Background color
if self.background_color is None:
qcolor = self.base_format.background()
else:
cstr = self.ANSI_COLORS[self.background_color-40][self.intensity]
qcolor = QColor(cstr)
self.current_format.setBackground(qcolor)
font = self.current_format.font()
# Italic
if self.italic is None:
italic = self.base_format.fontItalic()
else:
italic = self.italic
font.setItalic(italic)
# Bold
if self.bold is None:
bold = self.base_format.font().bold()
else:
bold = self.bold
font.setBold(bold)
# Underline
if self.underline is None:
underline = self.base_format.font().underline()
else:
underline = self.underline
font.setUnderline(underline)
self.current_format.setFont(font) | Set font style with the following attributes:
'foreground_color', 'background_color', 'italic',
'bold' and 'underline' | Below is the the instruction that describes the task:
### Input:
Set font style with the following attributes:
'foreground_color', 'background_color', 'italic',
'bold' and 'underline'
### Response:
def set_style(self):
"""
Set font style with the following attributes:
'foreground_color', 'background_color', 'italic',
'bold' and 'underline'
"""
if self.current_format is None:
assert self.base_format is not None
self.current_format = QTextCharFormat(self.base_format)
# Foreground color
if self.foreground_color is None:
qcolor = self.base_format.foreground()
else:
cstr = self.ANSI_COLORS[self.foreground_color-30][self.intensity]
qcolor = QColor(cstr)
self.current_format.setForeground(qcolor)
# Background color
if self.background_color is None:
qcolor = self.base_format.background()
else:
cstr = self.ANSI_COLORS[self.background_color-40][self.intensity]
qcolor = QColor(cstr)
self.current_format.setBackground(qcolor)
font = self.current_format.font()
# Italic
if self.italic is None:
italic = self.base_format.fontItalic()
else:
italic = self.italic
font.setItalic(italic)
# Bold
if self.bold is None:
bold = self.base_format.font().bold()
else:
bold = self.bold
font.setBold(bold)
# Underline
if self.underline is None:
underline = self.base_format.font().underline()
else:
underline = self.underline
font.setUnderline(underline)
self.current_format.setFont(font) |
def normalize(body_part_tup,):
"""Normalize a tuple of BodyPart objects to a string.
Normalization is done by sorting the body_parts by the Content- Disposition headers,
which is typically on the form, ``form-data; name="name_of_part``.
"""
return '\n\n'.join(
[
'{}\n\n{}'.format(
str(p.headers[b'Content-Disposition'], p.encoding), p.text
)
for p in sorted(
body_part_tup, key=lambda p: p.headers[b'Content-Disposition']
)
]
) | Normalize a tuple of BodyPart objects to a string.
Normalization is done by sorting the body_parts by the Content- Disposition headers,
which is typically on the form, ``form-data; name="name_of_part``. | Below is the the instruction that describes the task:
### Input:
Normalize a tuple of BodyPart objects to a string.
Normalization is done by sorting the body_parts by the Content- Disposition headers,
which is typically on the form, ``form-data; name="name_of_part``.
### Response:
def normalize(body_part_tup,):
"""Normalize a tuple of BodyPart objects to a string.
Normalization is done by sorting the body_parts by the Content- Disposition headers,
which is typically on the form, ``form-data; name="name_of_part``.
"""
return '\n\n'.join(
[
'{}\n\n{}'.format(
str(p.headers[b'Content-Disposition'], p.encoding), p.text
)
for p in sorted(
body_part_tup, key=lambda p: p.headers[b'Content-Disposition']
)
]
) |
def run_subprocess(command, cwd=None, stdout=None, stderr=None, shell=False, beat_freq=None):
"""
Parameters
----------
command: command
cwd: current working directory
stdout: output info stream (must have 'write' method)
stderr: output error stream (must have 'write' method)
shell: see subprocess.Popen
beat_freq: if not none, stdout will be used at least every beat_freq (in seconds)
"""
sys.encoding = CONF.encoding
# prepare variables
stdout = sys.stdout if stdout is None else stdout
stderr = sys.stderr if stderr is None else stderr
# run subprocess
with subprocess.Popen(
command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=cwd,
shell=shell,
universal_newlines=True
) as sub_p:
# link output streams
with redirect_stream(sub_p.stdout, stdout), redirect_stream(sub_p.stderr, stderr):
while True:
try:
sub_p.wait(timeout=beat_freq)
break
except subprocess.TimeoutExpired:
stdout.write("subprocess is still running\n")
if hasattr(sys.stdout, "flush"):
sys.stdout.flush()
return sub_p.returncode | Parameters
----------
command: command
cwd: current working directory
stdout: output info stream (must have 'write' method)
stderr: output error stream (must have 'write' method)
shell: see subprocess.Popen
beat_freq: if not none, stdout will be used at least every beat_freq (in seconds) | Below is the the instruction that describes the task:
### Input:
Parameters
----------
command: command
cwd: current working directory
stdout: output info stream (must have 'write' method)
stderr: output error stream (must have 'write' method)
shell: see subprocess.Popen
beat_freq: if not none, stdout will be used at least every beat_freq (in seconds)
### Response:
def run_subprocess(command, cwd=None, stdout=None, stderr=None, shell=False, beat_freq=None):
"""
Parameters
----------
command: command
cwd: current working directory
stdout: output info stream (must have 'write' method)
stderr: output error stream (must have 'write' method)
shell: see subprocess.Popen
beat_freq: if not none, stdout will be used at least every beat_freq (in seconds)
"""
sys.encoding = CONF.encoding
# prepare variables
stdout = sys.stdout if stdout is None else stdout
stderr = sys.stderr if stderr is None else stderr
# run subprocess
with subprocess.Popen(
command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=cwd,
shell=shell,
universal_newlines=True
) as sub_p:
# link output streams
with redirect_stream(sub_p.stdout, stdout), redirect_stream(sub_p.stderr, stderr):
while True:
try:
sub_p.wait(timeout=beat_freq)
break
except subprocess.TimeoutExpired:
stdout.write("subprocess is still running\n")
if hasattr(sys.stdout, "flush"):
sys.stdout.flush()
return sub_p.returncode |
def _shares_exec_prefix(basedir):
''' Whether a give base directory is on the system exex prefix
'''
import sys
prefix = sys.exec_prefix
return (prefix is not None and basedir.startswith(prefix)) | Whether a give base directory is on the system exex prefix | Below is the the instruction that describes the task:
### Input:
Whether a give base directory is on the system exex prefix
### Response:
def _shares_exec_prefix(basedir):
''' Whether a give base directory is on the system exex prefix
'''
import sys
prefix = sys.exec_prefix
return (prefix is not None and basedir.startswith(prefix)) |
def create(self, email, device_name, passphrase=None,
api_token=None, redirect_uri=None, **kwargs):
"""Create a new User object and add it to this Users collection.
In addition to creating a user, this call will create a device for that
user, whose device_token will be returned from this call. Store the
device_token, as it's required to complete Gem-Device authentication
after the user approves the device at the end of their signup flow.
If you lose the device_token returned from users.create, you'll have to
create a new device for the user to gain access to their account again.
Also, after this call, be sure to redirect the user to the location in
`mfa_uri` (second return value of this function) to complete their
account.
If you get a 409 Conflict error, then the user already exists in the Gem
system and you'll want to do a
`client.user(email).devices.create(device_name)`
Args:
email (str)
device_name (str): Human-readable name for the device through which
your Application will be authorized to access the new User's account.
passphrase (str, optional): A passphrase with which to encrypt a user
wallet. If not provided, a default_wallet parameter must be passed in
kwargs.
api_token (str, optional): Your app's API token. This is optional if
and only if the Client which will be calling this function already
has Gem-Application or Gem-Identify authentication.
redirect_uri (str, optional): A URI to which to redirect the User after
they confirm their Gem account.
**kwargs
Returns: device_token
"""
if not passphrase and u'default_wallet' not in kwargs:
raise ValueError("Usage: users.create(email, passphrase, device_name"
", api_token, redirect_uri)")
elif passphrase:
default_wallet = generate(passphrase, ['primary'])['primary']
else:
default_wallet = kwargs['default_wallet']
default_wallet['name'] = 'default'
default_wallet['primary_private_seed'] = default_wallet['encrypted_seed']
default_wallet['primary_public_seed'] = default_wallet['public_seed']
del default_wallet['encrypted_seed']
del default_wallet['public_seed']
del default_wallet['private_seed']
# If not supplied, we assume the client already has an api_token param.
if api_token:
self.client.authenticate_identify(api_token)
user_data = dict(email=email,
default_wallet=default_wallet,
device_name=device_name)
if redirect_uri:
user_data['redirect_uri'] = redirect_uri
if 'first_name' in kwargs:
user_data['first_name'] = kwargs['first_name']
if 'last_name' in kwargs:
user_data['last_name'] = kwargs['last_name']
try:
resource = self.resource.create(user_data)
except ResponseError as e:
if "conflict" in e.message:
raise ConflictError(
"This user already exists. Use "
"client.user(email).devices.create(name) to request "
"authorization from the user.")
raise e
return resource.attributes['metadata']['device_token'] | Create a new User object and add it to this Users collection.
In addition to creating a user, this call will create a device for that
user, whose device_token will be returned from this call. Store the
device_token, as it's required to complete Gem-Device authentication
after the user approves the device at the end of their signup flow.
If you lose the device_token returned from users.create, you'll have to
create a new device for the user to gain access to their account again.
Also, after this call, be sure to redirect the user to the location in
`mfa_uri` (second return value of this function) to complete their
account.
If you get a 409 Conflict error, then the user already exists in the Gem
system and you'll want to do a
`client.user(email).devices.create(device_name)`
Args:
email (str)
device_name (str): Human-readable name for the device through which
your Application will be authorized to access the new User's account.
passphrase (str, optional): A passphrase with which to encrypt a user
wallet. If not provided, a default_wallet parameter must be passed in
kwargs.
api_token (str, optional): Your app's API token. This is optional if
and only if the Client which will be calling this function already
has Gem-Application or Gem-Identify authentication.
redirect_uri (str, optional): A URI to which to redirect the User after
they confirm their Gem account.
**kwargs
Returns: device_token | Below is the the instruction that describes the task:
### Input:
Create a new User object and add it to this Users collection.
In addition to creating a user, this call will create a device for that
user, whose device_token will be returned from this call. Store the
device_token, as it's required to complete Gem-Device authentication
after the user approves the device at the end of their signup flow.
If you lose the device_token returned from users.create, you'll have to
create a new device for the user to gain access to their account again.
Also, after this call, be sure to redirect the user to the location in
`mfa_uri` (second return value of this function) to complete their
account.
If you get a 409 Conflict error, then the user already exists in the Gem
system and you'll want to do a
`client.user(email).devices.create(device_name)`
Args:
email (str)
device_name (str): Human-readable name for the device through which
your Application will be authorized to access the new User's account.
passphrase (str, optional): A passphrase with which to encrypt a user
wallet. If not provided, a default_wallet parameter must be passed in
kwargs.
api_token (str, optional): Your app's API token. This is optional if
and only if the Client which will be calling this function already
has Gem-Application or Gem-Identify authentication.
redirect_uri (str, optional): A URI to which to redirect the User after
they confirm their Gem account.
**kwargs
Returns: device_token
### Response:
def create(self, email, device_name, passphrase=None,
api_token=None, redirect_uri=None, **kwargs):
"""Create a new User object and add it to this Users collection.
In addition to creating a user, this call will create a device for that
user, whose device_token will be returned from this call. Store the
device_token, as it's required to complete Gem-Device authentication
after the user approves the device at the end of their signup flow.
If you lose the device_token returned from users.create, you'll have to
create a new device for the user to gain access to their account again.
Also, after this call, be sure to redirect the user to the location in
`mfa_uri` (second return value of this function) to complete their
account.
If you get a 409 Conflict error, then the user already exists in the Gem
system and you'll want to do a
`client.user(email).devices.create(device_name)`
Args:
email (str)
device_name (str): Human-readable name for the device through which
your Application will be authorized to access the new User's account.
passphrase (str, optional): A passphrase with which to encrypt a user
wallet. If not provided, a default_wallet parameter must be passed in
kwargs.
api_token (str, optional): Your app's API token. This is optional if
and only if the Client which will be calling this function already
has Gem-Application or Gem-Identify authentication.
redirect_uri (str, optional): A URI to which to redirect the User after
they confirm their Gem account.
**kwargs
Returns: device_token
"""
if not passphrase and u'default_wallet' not in kwargs:
raise ValueError("Usage: users.create(email, passphrase, device_name"
", api_token, redirect_uri)")
elif passphrase:
default_wallet = generate(passphrase, ['primary'])['primary']
else:
default_wallet = kwargs['default_wallet']
default_wallet['name'] = 'default'
default_wallet['primary_private_seed'] = default_wallet['encrypted_seed']
default_wallet['primary_public_seed'] = default_wallet['public_seed']
del default_wallet['encrypted_seed']
del default_wallet['public_seed']
del default_wallet['private_seed']
# If not supplied, we assume the client already has an api_token param.
if api_token:
self.client.authenticate_identify(api_token)
user_data = dict(email=email,
default_wallet=default_wallet,
device_name=device_name)
if redirect_uri:
user_data['redirect_uri'] = redirect_uri
if 'first_name' in kwargs:
user_data['first_name'] = kwargs['first_name']
if 'last_name' in kwargs:
user_data['last_name'] = kwargs['last_name']
try:
resource = self.resource.create(user_data)
except ResponseError as e:
if "conflict" in e.message:
raise ConflictError(
"This user already exists. Use "
"client.user(email).devices.create(name) to request "
"authorization from the user.")
raise e
return resource.attributes['metadata']['device_token'] |
def spia_matrices_to_excel(spia_matrices: Mapping[str, pd.DataFrame], path: str) -> None:
"""Export a SPIA data dictionary into an Excel sheet at the given path.
.. note::
# The R import should add the values:
# ["nodes"] from the columns
# ["title"] from the name of the file
# ["NumberOfReactions"] set to "0"
"""
writer = pd.ExcelWriter(path, engine='xlsxwriter')
for relation, df in spia_matrices.items():
df.to_excel(writer, sheet_name=relation, index=False)
# Save excel
writer.save() | Export a SPIA data dictionary into an Excel sheet at the given path.
.. note::
# The R import should add the values:
# ["nodes"] from the columns
# ["title"] from the name of the file
# ["NumberOfReactions"] set to "0" | Below is the the instruction that describes the task:
### Input:
Export a SPIA data dictionary into an Excel sheet at the given path.
.. note::
# The R import should add the values:
# ["nodes"] from the columns
# ["title"] from the name of the file
# ["NumberOfReactions"] set to "0"
### Response:
def spia_matrices_to_excel(spia_matrices: Mapping[str, pd.DataFrame], path: str) -> None:
"""Export a SPIA data dictionary into an Excel sheet at the given path.
.. note::
# The R import should add the values:
# ["nodes"] from the columns
# ["title"] from the name of the file
# ["NumberOfReactions"] set to "0"
"""
writer = pd.ExcelWriter(path, engine='xlsxwriter')
for relation, df in spia_matrices.items():
df.to_excel(writer, sheet_name=relation, index=False)
# Save excel
writer.save() |
def _run_env(self):
"""
Augment the current environment providing the PYTHONUSERBASE.
"""
env = dict(os.environ)
env.update(
getattr(self, 'env', {}),
PYTHONUSERBASE=self.env_path,
PIP_USER="1",
)
self._disable_venv(env)
return env | Augment the current environment providing the PYTHONUSERBASE. | Below is the the instruction that describes the task:
### Input:
Augment the current environment providing the PYTHONUSERBASE.
### Response:
def _run_env(self):
"""
Augment the current environment providing the PYTHONUSERBASE.
"""
env = dict(os.environ)
env.update(
getattr(self, 'env', {}),
PYTHONUSERBASE=self.env_path,
PIP_USER="1",
)
self._disable_venv(env)
return env |
def p_casecontent_statement(self, p):
'casecontent_statement : casecontent_condition COLON basic_statement'
p[0] = Case(p[1], p[3], lineno=p.lineno(1))
p.set_lineno(0, p.lineno(1)) | casecontent_statement : casecontent_condition COLON basic_statement | Below is the the instruction that describes the task:
### Input:
casecontent_statement : casecontent_condition COLON basic_statement
### Response:
def p_casecontent_statement(self, p):
'casecontent_statement : casecontent_condition COLON basic_statement'
p[0] = Case(p[1], p[3], lineno=p.lineno(1))
p.set_lineno(0, p.lineno(1)) |
def write(self, output):
"""
Writes specified text to the underlying stream
Parameters
----------
output bytes-like object
Bytes to write
"""
self._stream.write(output)
if self._auto_flush:
self._stream.flush() | Writes specified text to the underlying stream
Parameters
----------
output bytes-like object
Bytes to write | Below is the the instruction that describes the task:
### Input:
Writes specified text to the underlying stream
Parameters
----------
output bytes-like object
Bytes to write
### Response:
def write(self, output):
"""
Writes specified text to the underlying stream
Parameters
----------
output bytes-like object
Bytes to write
"""
self._stream.write(output)
if self._auto_flush:
self._stream.flush() |
def L(self,*args,**kwargs):
"""
NAME:
L
PURPOSE:
calculate the angular momentum
INPUT:
(none)
OUTPUT:
angular momentum
HISTORY:
2010-09-15 - Written - Bovy (NYU)
"""
#Make sure you are not using physical coordinates
old_physical= kwargs.get('use_physical',None)
kwargs['use_physical']= False
Omega= kwargs.pop('Omega',None)
t= kwargs.pop('t',None)
thiso= self(*args,**kwargs)
if not len(thiso.shape) == 2: thiso= thiso.reshape((thiso.shape[0],1))
if len(thiso[:,0]) < 3:
raise AttributeError("'linearOrbit has no angular momentum")
elif len(thiso[:,0]) == 3 or len(thiso[:,0]) == 4:
if Omega is None:
out= thiso[0,:]*thiso[2,:]
else:
out= thiso[0,:]*(thiso[2,:]-Omega*t*thiso[0,:])
elif len(thiso[:,0]) == 5:
raise AttributeError("You must track the azimuth to get the angular momentum of a 3D Orbit")
else: #len(thiso[:,0]) == 6
vx= self.vx(*args,**kwargs)
vy= self.vy(*args,**kwargs)
vz= self.vz(*args,**kwargs)
x= self.x(*args,**kwargs)
y= self.y(*args,**kwargs)
z= self.z(*args,**kwargs)
out= nu.zeros((len(x),3))
out[:,0]= y*vz-z*vy
out[:,1]= z*vx-x*vz
out[:,2]= x*vy-y*vx
if not old_physical is None:
kwargs['use_physical']= old_physical
else:
kwargs.pop('use_physical')
return out | NAME:
L
PURPOSE:
calculate the angular momentum
INPUT:
(none)
OUTPUT:
angular momentum
HISTORY:
2010-09-15 - Written - Bovy (NYU) | Below is the the instruction that describes the task:
### Input:
NAME:
L
PURPOSE:
calculate the angular momentum
INPUT:
(none)
OUTPUT:
angular momentum
HISTORY:
2010-09-15 - Written - Bovy (NYU)
### Response:
def L(self,*args,**kwargs):
"""
NAME:
L
PURPOSE:
calculate the angular momentum
INPUT:
(none)
OUTPUT:
angular momentum
HISTORY:
2010-09-15 - Written - Bovy (NYU)
"""
#Make sure you are not using physical coordinates
old_physical= kwargs.get('use_physical',None)
kwargs['use_physical']= False
Omega= kwargs.pop('Omega',None)
t= kwargs.pop('t',None)
thiso= self(*args,**kwargs)
if not len(thiso.shape) == 2: thiso= thiso.reshape((thiso.shape[0],1))
if len(thiso[:,0]) < 3:
raise AttributeError("'linearOrbit has no angular momentum")
elif len(thiso[:,0]) == 3 or len(thiso[:,0]) == 4:
if Omega is None:
out= thiso[0,:]*thiso[2,:]
else:
out= thiso[0,:]*(thiso[2,:]-Omega*t*thiso[0,:])
elif len(thiso[:,0]) == 5:
raise AttributeError("You must track the azimuth to get the angular momentum of a 3D Orbit")
else: #len(thiso[:,0]) == 6
vx= self.vx(*args,**kwargs)
vy= self.vy(*args,**kwargs)
vz= self.vz(*args,**kwargs)
x= self.x(*args,**kwargs)
y= self.y(*args,**kwargs)
z= self.z(*args,**kwargs)
out= nu.zeros((len(x),3))
out[:,0]= y*vz-z*vy
out[:,1]= z*vx-x*vz
out[:,2]= x*vy-y*vx
if not old_physical is None:
kwargs['use_physical']= old_physical
else:
kwargs.pop('use_physical')
return out |
def metadata_add_description(self):
""" Metadata: add description """
service_description = {}
if (self.args.json):
service_description = json.loads(self.args.json)
if (self.args.url):
if "url" in service_description:
raise Exception("json service description already contains url field")
service_description["url"] = self.args.url
if (self.args.description):
if "description" in service_description:
raise Exception("json service description already contains description field")
service_description["description"] = self.args.description
metadata = load_mpe_service_metadata(self.args.metadata_file)
# merge with old service_description if necessary
if ("service_description" in metadata):
service_description = {**metadata["service_description"], **service_description}
metadata.set_simple_field("service_description", service_description)
metadata.save_pretty(self.args.metadata_file) | Metadata: add description | Below is the the instruction that describes the task:
### Input:
Metadata: add description
### Response:
def metadata_add_description(self):
""" Metadata: add description """
service_description = {}
if (self.args.json):
service_description = json.loads(self.args.json)
if (self.args.url):
if "url" in service_description:
raise Exception("json service description already contains url field")
service_description["url"] = self.args.url
if (self.args.description):
if "description" in service_description:
raise Exception("json service description already contains description field")
service_description["description"] = self.args.description
metadata = load_mpe_service_metadata(self.args.metadata_file)
# merge with old service_description if necessary
if ("service_description" in metadata):
service_description = {**metadata["service_description"], **service_description}
metadata.set_simple_field("service_description", service_description)
metadata.save_pretty(self.args.metadata_file) |
def FromReadings(cls, uuid, readings, root_key=AuthProvider.NoKey, signer=None,
report_id=IOTileReading.InvalidReadingID, selector=0xFFFF, streamer=0, sent_timestamp=0):
"""Generate an instance of the report format from a list of readings and a uuid.
The signed list report is created using the passed readings and signed using the specified method
and AuthProvider. If no auth provider is specified, the report is signed using the default authorization
chain.
Args:
uuid (int): The uuid of the deviec that this report came from
readings (list): A list of IOTileReading objects containing the data in the report
root_key (int): The key that should be used to sign the report (must be supported
by an auth_provider)
signer (AuthProvider): An optional preconfigured AuthProvider that should be used to sign this
report. If no AuthProvider is provided, the default ChainedAuthProvider is used.
report_id (int): The id of the report. If not provided it defaults to IOTileReading.InvalidReadingID.
Note that you can specify anything you want for the report id but for actual IOTile devices
the report id will always be greater than the id of all of the readings contained in the report
since devices generate ids sequentially.
selector (int): The streamer selector of this report. This can be anything but if the report came from
a device, it would correspond with the query the device used to pick readings to go into the report.
streamer (int): The streamer id that this reading was sent from.
sent_timestamp (int): The device's uptime that sent this report.
"""
lowest_id = IOTileReading.InvalidReadingID
highest_id = IOTileReading.InvalidReadingID
report_len = 20 + 16*len(readings) + 24
len_low = report_len & 0xFF
len_high = report_len >> 8
unique_readings = [x.reading_id for x in readings if x.reading_id != IOTileReading.InvalidReadingID]
if len(unique_readings) > 0:
lowest_id = min(unique_readings)
highest_id = max(unique_readings)
header = struct.pack("<BBHLLLBBH", cls.ReportType, len_low, len_high, uuid, report_id,
sent_timestamp, root_key, streamer, selector)
header = bytearray(header)
packed_readings = bytearray()
for reading in readings:
packed_reading = struct.pack("<HHLLL", reading.stream, 0, reading.reading_id,
reading.raw_time, reading.value)
packed_readings += bytearray(packed_reading)
footer_stats = struct.pack("<LL", lowest_id, highest_id)
if signer is None:
signer = ChainedAuthProvider()
# If we are supposed to encrypt this report, do the encryption
if root_key != signer.NoKey:
enc_data = packed_readings
try:
result = signer.encrypt_report(uuid, root_key, enc_data, report_id=report_id,
sent_timestamp=sent_timestamp)
except NotFoundError:
raise ExternalError("Could not encrypt report because no AuthProvider supported "
"the requested encryption method for the requested device",
device_id=uuid, root_key=root_key)
signed_data = header + result['data'] + footer_stats
else:
signed_data = header + packed_readings + footer_stats
try:
signature = signer.sign_report(uuid, root_key, signed_data, report_id=report_id,
sent_timestamp=sent_timestamp)
except NotFoundError:
raise ExternalError("Could not sign report because no AuthProvider supported the requested "
"signature method for the requested device", device_id=uuid, root_key=root_key)
footer = struct.pack("16s", bytes(signature['signature'][:16]))
footer = bytearray(footer)
data = signed_data + footer
return SignedListReport(data) | Generate an instance of the report format from a list of readings and a uuid.
The signed list report is created using the passed readings and signed using the specified method
and AuthProvider. If no auth provider is specified, the report is signed using the default authorization
chain.
Args:
uuid (int): The uuid of the deviec that this report came from
readings (list): A list of IOTileReading objects containing the data in the report
root_key (int): The key that should be used to sign the report (must be supported
by an auth_provider)
signer (AuthProvider): An optional preconfigured AuthProvider that should be used to sign this
report. If no AuthProvider is provided, the default ChainedAuthProvider is used.
report_id (int): The id of the report. If not provided it defaults to IOTileReading.InvalidReadingID.
Note that you can specify anything you want for the report id but for actual IOTile devices
the report id will always be greater than the id of all of the readings contained in the report
since devices generate ids sequentially.
selector (int): The streamer selector of this report. This can be anything but if the report came from
a device, it would correspond with the query the device used to pick readings to go into the report.
streamer (int): The streamer id that this reading was sent from.
sent_timestamp (int): The device's uptime that sent this report. | Below is the the instruction that describes the task:
### Input:
Generate an instance of the report format from a list of readings and a uuid.
The signed list report is created using the passed readings and signed using the specified method
and AuthProvider. If no auth provider is specified, the report is signed using the default authorization
chain.
Args:
uuid (int): The uuid of the deviec that this report came from
readings (list): A list of IOTileReading objects containing the data in the report
root_key (int): The key that should be used to sign the report (must be supported
by an auth_provider)
signer (AuthProvider): An optional preconfigured AuthProvider that should be used to sign this
report. If no AuthProvider is provided, the default ChainedAuthProvider is used.
report_id (int): The id of the report. If not provided it defaults to IOTileReading.InvalidReadingID.
Note that you can specify anything you want for the report id but for actual IOTile devices
the report id will always be greater than the id of all of the readings contained in the report
since devices generate ids sequentially.
selector (int): The streamer selector of this report. This can be anything but if the report came from
a device, it would correspond with the query the device used to pick readings to go into the report.
streamer (int): The streamer id that this reading was sent from.
sent_timestamp (int): The device's uptime that sent this report.
### Response:
def FromReadings(cls, uuid, readings, root_key=AuthProvider.NoKey, signer=None,
report_id=IOTileReading.InvalidReadingID, selector=0xFFFF, streamer=0, sent_timestamp=0):
"""Generate an instance of the report format from a list of readings and a uuid.
The signed list report is created using the passed readings and signed using the specified method
and AuthProvider. If no auth provider is specified, the report is signed using the default authorization
chain.
Args:
uuid (int): The uuid of the deviec that this report came from
readings (list): A list of IOTileReading objects containing the data in the report
root_key (int): The key that should be used to sign the report (must be supported
by an auth_provider)
signer (AuthProvider): An optional preconfigured AuthProvider that should be used to sign this
report. If no AuthProvider is provided, the default ChainedAuthProvider is used.
report_id (int): The id of the report. If not provided it defaults to IOTileReading.InvalidReadingID.
Note that you can specify anything you want for the report id but for actual IOTile devices
the report id will always be greater than the id of all of the readings contained in the report
since devices generate ids sequentially.
selector (int): The streamer selector of this report. This can be anything but if the report came from
a device, it would correspond with the query the device used to pick readings to go into the report.
streamer (int): The streamer id that this reading was sent from.
sent_timestamp (int): The device's uptime that sent this report.
"""
lowest_id = IOTileReading.InvalidReadingID
highest_id = IOTileReading.InvalidReadingID
report_len = 20 + 16*len(readings) + 24
len_low = report_len & 0xFF
len_high = report_len >> 8
unique_readings = [x.reading_id for x in readings if x.reading_id != IOTileReading.InvalidReadingID]
if len(unique_readings) > 0:
lowest_id = min(unique_readings)
highest_id = max(unique_readings)
header = struct.pack("<BBHLLLBBH", cls.ReportType, len_low, len_high, uuid, report_id,
sent_timestamp, root_key, streamer, selector)
header = bytearray(header)
packed_readings = bytearray()
for reading in readings:
packed_reading = struct.pack("<HHLLL", reading.stream, 0, reading.reading_id,
reading.raw_time, reading.value)
packed_readings += bytearray(packed_reading)
footer_stats = struct.pack("<LL", lowest_id, highest_id)
if signer is None:
signer = ChainedAuthProvider()
# If we are supposed to encrypt this report, do the encryption
if root_key != signer.NoKey:
enc_data = packed_readings
try:
result = signer.encrypt_report(uuid, root_key, enc_data, report_id=report_id,
sent_timestamp=sent_timestamp)
except NotFoundError:
raise ExternalError("Could not encrypt report because no AuthProvider supported "
"the requested encryption method for the requested device",
device_id=uuid, root_key=root_key)
signed_data = header + result['data'] + footer_stats
else:
signed_data = header + packed_readings + footer_stats
try:
signature = signer.sign_report(uuid, root_key, signed_data, report_id=report_id,
sent_timestamp=sent_timestamp)
except NotFoundError:
raise ExternalError("Could not sign report because no AuthProvider supported the requested "
"signature method for the requested device", device_id=uuid, root_key=root_key)
footer = struct.pack("16s", bytes(signature['signature'][:16]))
footer = bytearray(footer)
data = signed_data + footer
return SignedListReport(data) |
def get_max_ptrm_check(ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x, t_Arai, x_Arai):
"""
input: ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x, t_Arai, x_Arai.
sorts through included ptrm_checks and finds the largest ptrm check diff,
the sum of the total diffs,
and the percentage of the largest check / original measurement at that temperature step
output: max_diff, sum_diffs, check_percent, sum_abs_diffs.
"""
if not ptrm_checks_included_temps:
return [], float('nan'), float('nan'), float('nan'), float('nan')
diffs = []
abs_diffs = []
x_Arai_compare = []
ptrm_compare = []
check_percents = []
ptrm_checks_all_temps = list(ptrm_checks_all_temps)
for check in ptrm_checks_included_temps: # goes through each included temperature step
ptrm_ind = ptrm_checks_all_temps.index(check) # indexes the number of the check
ptrm_check = ptrm_x[ptrm_ind] # x value at that temperature step
ptrm_compare.append(ptrm_check) #
arai_ind = t_Arai.index(check)
ptrm_orig = x_Arai[arai_ind]
x_Arai_compare.append(ptrm_orig)
diff = ptrm_orig - ptrm_check
diffs.append(diff)
abs_diffs.append(abs(diff))
if ptrm_orig == 0:
check_percents.append(0)
else:
check_percents.append((old_div(abs(diff), ptrm_orig)) * 100)
max_diff = max(abs_diffs)
check_percent = max(check_percents)
sum_diffs = abs(sum(diffs))
sum_abs_diffs = sum(abs_diffs)
return diffs, max_diff, sum_diffs, check_percent, sum_abs_diffs | input: ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x, t_Arai, x_Arai.
sorts through included ptrm_checks and finds the largest ptrm check diff,
the sum of the total diffs,
and the percentage of the largest check / original measurement at that temperature step
output: max_diff, sum_diffs, check_percent, sum_abs_diffs. | Below is the the instruction that describes the task:
### Input:
input: ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x, t_Arai, x_Arai.
sorts through included ptrm_checks and finds the largest ptrm check diff,
the sum of the total diffs,
and the percentage of the largest check / original measurement at that temperature step
output: max_diff, sum_diffs, check_percent, sum_abs_diffs.
### Response:
def get_max_ptrm_check(ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x, t_Arai, x_Arai):
"""
input: ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x, t_Arai, x_Arai.
sorts through included ptrm_checks and finds the largest ptrm check diff,
the sum of the total diffs,
and the percentage of the largest check / original measurement at that temperature step
output: max_diff, sum_diffs, check_percent, sum_abs_diffs.
"""
if not ptrm_checks_included_temps:
return [], float('nan'), float('nan'), float('nan'), float('nan')
diffs = []
abs_diffs = []
x_Arai_compare = []
ptrm_compare = []
check_percents = []
ptrm_checks_all_temps = list(ptrm_checks_all_temps)
for check in ptrm_checks_included_temps: # goes through each included temperature step
ptrm_ind = ptrm_checks_all_temps.index(check) # indexes the number of the check
ptrm_check = ptrm_x[ptrm_ind] # x value at that temperature step
ptrm_compare.append(ptrm_check) #
arai_ind = t_Arai.index(check)
ptrm_orig = x_Arai[arai_ind]
x_Arai_compare.append(ptrm_orig)
diff = ptrm_orig - ptrm_check
diffs.append(diff)
abs_diffs.append(abs(diff))
if ptrm_orig == 0:
check_percents.append(0)
else:
check_percents.append((old_div(abs(diff), ptrm_orig)) * 100)
max_diff = max(abs_diffs)
check_percent = max(check_percents)
sum_diffs = abs(sum(diffs))
sum_abs_diffs = sum(abs_diffs)
return diffs, max_diff, sum_diffs, check_percent, sum_abs_diffs |
def cmRecall(cm, average=True):
"""
Calculates recall using :class:`~ignite.metrics.ConfusionMatrix` metric.
Args:
cm (ConfusionMatrix): instance of confusion matrix metric
average (bool, optional): if True metric value is averaged over all classes
Returns:
MetricsLambda
"""
# Increase floating point precision
cm = cm.type(torch.float64)
recall = cm.diag() / (cm.sum(dim=1) + 1e-15)
if average:
return recall.mean()
return recall | Calculates recall using :class:`~ignite.metrics.ConfusionMatrix` metric.
Args:
cm (ConfusionMatrix): instance of confusion matrix metric
average (bool, optional): if True metric value is averaged over all classes
Returns:
MetricsLambda | Below is the the instruction that describes the task:
### Input:
Calculates recall using :class:`~ignite.metrics.ConfusionMatrix` metric.
Args:
cm (ConfusionMatrix): instance of confusion matrix metric
average (bool, optional): if True metric value is averaged over all classes
Returns:
MetricsLambda
### Response:
def cmRecall(cm, average=True):
"""
Calculates recall using :class:`~ignite.metrics.ConfusionMatrix` metric.
Args:
cm (ConfusionMatrix): instance of confusion matrix metric
average (bool, optional): if True metric value is averaged over all classes
Returns:
MetricsLambda
"""
# Increase floating point precision
cm = cm.type(torch.float64)
recall = cm.diag() / (cm.sum(dim=1) + 1e-15)
if average:
return recall.mean()
return recall |
def set_state(self, site, timestamp=None):
"""Write status dict to client status file.
FIXME - should have some file lock to avoid race
"""
parser = ConfigParser()
parser.read(self.status_file)
status_section = 'incremental'
if (not parser.has_section(status_section)):
parser.add_section(status_section)
if (timestamp is None):
parser.remove_option(
status_section,
self.config_site_to_name(site))
else:
parser.set(
status_section,
self.config_site_to_name(site),
str(timestamp))
with open(self.status_file, 'w') as configfile:
parser.write(configfile)
configfile.close() | Write status dict to client status file.
FIXME - should have some file lock to avoid race | Below is the the instruction that describes the task:
### Input:
Write status dict to client status file.
FIXME - should have some file lock to avoid race
### Response:
def set_state(self, site, timestamp=None):
"""Write status dict to client status file.
FIXME - should have some file lock to avoid race
"""
parser = ConfigParser()
parser.read(self.status_file)
status_section = 'incremental'
if (not parser.has_section(status_section)):
parser.add_section(status_section)
if (timestamp is None):
parser.remove_option(
status_section,
self.config_site_to_name(site))
else:
parser.set(
status_section,
self.config_site_to_name(site),
str(timestamp))
with open(self.status_file, 'w') as configfile:
parser.write(configfile)
configfile.close() |
def get_blast(pdb_id, chain_id='A'):
"""
Return BLAST search results for a given PDB ID
The key of the output dict())that outputs the full search results is
'BlastOutput_iterations'
To get a list of just the results without the metadata of the search use:
hits = full_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Parameters
----------
pdb_id : string
A 4 character string giving a pdb entry of interest
chain_id : string
A single character designating the chain ID of interest
Returns
-------
out : dict()
A nested dict() consisting of the BLAST search results and all associated metadata
If you just want the hits, look under four levels of keys:
results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Examples
--------
>>> blast_results = get_blast('2F5N', chain_id='A')
>>> just_hits = blast_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
>>> print(just_hits[50]['Hit_hsps']['Hsp']['Hsp_hseq'])
PELPEVETVRRELEKRIVGQKIISIEATYPRMVL--TGFEQLKKELTGKTIQGISRRGKYLIFEIGDDFRLISHLRMEGKYRLATLDAPREKHDHL
TMKFADG-QLIYADVRKFGTWELISTDQVLPYFLKKKIGPEPTYEDFDEKLFREKLRKSTKKIKPYLLEQTLVAGLGNIYVDEVLWLAKIHPEKET
NQLIESSIHLLHDSIIEILQKAIKLGGSSIRTY-SALGSTGKMQNELQVYGKTGEKCSRCGAEIQKIKVAGRGTHFCPVCQQ
"""
raw_results = get_raw_blast(pdb_id, output_form='XML', chain_id=chain_id)
out = xmltodict.parse(raw_results, process_namespaces=True)
out = to_dict(out)
out = out['BlastOutput']
return out | Return BLAST search results for a given PDB ID
The key of the output dict())that outputs the full search results is
'BlastOutput_iterations'
To get a list of just the results without the metadata of the search use:
hits = full_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Parameters
----------
pdb_id : string
A 4 character string giving a pdb entry of interest
chain_id : string
A single character designating the chain ID of interest
Returns
-------
out : dict()
A nested dict() consisting of the BLAST search results and all associated metadata
If you just want the hits, look under four levels of keys:
results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Examples
--------
>>> blast_results = get_blast('2F5N', chain_id='A')
>>> just_hits = blast_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
>>> print(just_hits[50]['Hit_hsps']['Hsp']['Hsp_hseq'])
PELPEVETVRRELEKRIVGQKIISIEATYPRMVL--TGFEQLKKELTGKTIQGISRRGKYLIFEIGDDFRLISHLRMEGKYRLATLDAPREKHDHL
TMKFADG-QLIYADVRKFGTWELISTDQVLPYFLKKKIGPEPTYEDFDEKLFREKLRKSTKKIKPYLLEQTLVAGLGNIYVDEVLWLAKIHPEKET
NQLIESSIHLLHDSIIEILQKAIKLGGSSIRTY-SALGSTGKMQNELQVYGKTGEKCSRCGAEIQKIKVAGRGTHFCPVCQQ | Below is the the instruction that describes the task:
### Input:
Return BLAST search results for a given PDB ID
The key of the output dict())that outputs the full search results is
'BlastOutput_iterations'
To get a list of just the results without the metadata of the search use:
hits = full_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Parameters
----------
pdb_id : string
A 4 character string giving a pdb entry of interest
chain_id : string
A single character designating the chain ID of interest
Returns
-------
out : dict()
A nested dict() consisting of the BLAST search results and all associated metadata
If you just want the hits, look under four levels of keys:
results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Examples
--------
>>> blast_results = get_blast('2F5N', chain_id='A')
>>> just_hits = blast_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
>>> print(just_hits[50]['Hit_hsps']['Hsp']['Hsp_hseq'])
PELPEVETVRRELEKRIVGQKIISIEATYPRMVL--TGFEQLKKELTGKTIQGISRRGKYLIFEIGDDFRLISHLRMEGKYRLATLDAPREKHDHL
TMKFADG-QLIYADVRKFGTWELISTDQVLPYFLKKKIGPEPTYEDFDEKLFREKLRKSTKKIKPYLLEQTLVAGLGNIYVDEVLWLAKIHPEKET
NQLIESSIHLLHDSIIEILQKAIKLGGSSIRTY-SALGSTGKMQNELQVYGKTGEKCSRCGAEIQKIKVAGRGTHFCPVCQQ
### Response:
def get_blast(pdb_id, chain_id='A'):
"""
Return BLAST search results for a given PDB ID
The key of the output dict())that outputs the full search results is
'BlastOutput_iterations'
To get a list of just the results without the metadata of the search use:
hits = full_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Parameters
----------
pdb_id : string
A 4 character string giving a pdb entry of interest
chain_id : string
A single character designating the chain ID of interest
Returns
-------
out : dict()
A nested dict() consisting of the BLAST search results and all associated metadata
If you just want the hits, look under four levels of keys:
results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
Examples
--------
>>> blast_results = get_blast('2F5N', chain_id='A')
>>> just_hits = blast_results['BlastOutput_iterations']['Iteration']['Iteration_hits']['Hit']
>>> print(just_hits[50]['Hit_hsps']['Hsp']['Hsp_hseq'])
PELPEVETVRRELEKRIVGQKIISIEATYPRMVL--TGFEQLKKELTGKTIQGISRRGKYLIFEIGDDFRLISHLRMEGKYRLATLDAPREKHDHL
TMKFADG-QLIYADVRKFGTWELISTDQVLPYFLKKKIGPEPTYEDFDEKLFREKLRKSTKKIKPYLLEQTLVAGLGNIYVDEVLWLAKIHPEKET
NQLIESSIHLLHDSIIEILQKAIKLGGSSIRTY-SALGSTGKMQNELQVYGKTGEKCSRCGAEIQKIKVAGRGTHFCPVCQQ
"""
raw_results = get_raw_blast(pdb_id, output_form='XML', chain_id=chain_id)
out = xmltodict.parse(raw_results, process_namespaces=True)
out = to_dict(out)
out = out['BlastOutput']
return out |
def check_include_exclude(attributes):
"""Check __include__ and __exclude__ attributes.
:type attributes: dict
"""
include = attributes.get('__include__', tuple())
exclude = attributes.get('__exclude__', tuple())
if not isinstance(include, tuple):
raise TypeError("Attribute __include__ must be a tuple.")
if not isinstance(exclude, tuple):
raise TypeError("Attribute __exclude__ must be a tuple.")
if all((not include, not exclude)):
return None
if all((include, exclude)):
raise AttributeError("Usage of __include__ and __exclude__ "
"at the same time is prohibited.") | Check __include__ and __exclude__ attributes.
:type attributes: dict | Below is the the instruction that describes the task:
### Input:
Check __include__ and __exclude__ attributes.
:type attributes: dict
### Response:
def check_include_exclude(attributes):
"""Check __include__ and __exclude__ attributes.
:type attributes: dict
"""
include = attributes.get('__include__', tuple())
exclude = attributes.get('__exclude__', tuple())
if not isinstance(include, tuple):
raise TypeError("Attribute __include__ must be a tuple.")
if not isinstance(exclude, tuple):
raise TypeError("Attribute __exclude__ must be a tuple.")
if all((not include, not exclude)):
return None
if all((include, exclude)):
raise AttributeError("Usage of __include__ and __exclude__ "
"at the same time is prohibited.") |
def get_sampletype_info(self, obj):
"""Returns the info for a Sample Type
"""
info = self.get_base_info(obj)
# Bika Setup folder
bika_setup = api.get_bika_setup()
# bika samplepoints
bika_samplepoints = bika_setup.bika_samplepoints
bika_samplepoints_uid = api.get_uid(bika_samplepoints)
# bika analysisspecs
bika_analysisspecs = bika_setup.bika_analysisspecs
bika_analysisspecs_uid = api.get_uid(bika_analysisspecs)
# client
client = self.get_client()
client_uid = client and api.get_uid(client) or ""
# sample matrix
sample_matrix = obj.getSampleMatrix()
sample_matrix_uid = sample_matrix and sample_matrix.UID() or ""
sample_matrix_title = sample_matrix and sample_matrix.Title() or ""
# container type
container_type = obj.getContainerType()
container_type_uid = container_type and container_type.UID() or ""
container_type_title = container_type and container_type.Title() or ""
# sample points
sample_points = obj.getSamplePoints()
sample_point_uids = map(lambda sp: sp.UID(), sample_points)
sample_point_titles = map(lambda sp: sp.Title(), sample_points)
info.update({
"prefix": obj.getPrefix(),
"minimum_volume": obj.getMinimumVolume(),
"hazardous": obj.getHazardous(),
"retention_period": obj.getRetentionPeriod(),
"sample_matrix_uid": sample_matrix_uid,
"sample_matrix_title": sample_matrix_title,
"container_type_uid": container_type_uid,
"container_type_title": container_type_title,
"sample_point_uids": sample_point_uids,
"sample_point_titles": sample_point_titles,
})
# catalog queries for UI field filtering
filter_queries = {
"samplepoint": {
"getSampleTypeTitles": [obj.Title(), ''],
"getClientUID": [client_uid, bika_samplepoints_uid],
"sort_order": "descending",
},
"specification": {
"getSampleTypeTitle": obj.Title(),
"getClientUID": [client_uid, bika_analysisspecs_uid],
"sort_order": "descending",
}
}
info["filter_queries"] = filter_queries
return info | Returns the info for a Sample Type | Below is the the instruction that describes the task:
### Input:
Returns the info for a Sample Type
### Response:
def get_sampletype_info(self, obj):
"""Returns the info for a Sample Type
"""
info = self.get_base_info(obj)
# Bika Setup folder
bika_setup = api.get_bika_setup()
# bika samplepoints
bika_samplepoints = bika_setup.bika_samplepoints
bika_samplepoints_uid = api.get_uid(bika_samplepoints)
# bika analysisspecs
bika_analysisspecs = bika_setup.bika_analysisspecs
bika_analysisspecs_uid = api.get_uid(bika_analysisspecs)
# client
client = self.get_client()
client_uid = client and api.get_uid(client) or ""
# sample matrix
sample_matrix = obj.getSampleMatrix()
sample_matrix_uid = sample_matrix and sample_matrix.UID() or ""
sample_matrix_title = sample_matrix and sample_matrix.Title() or ""
# container type
container_type = obj.getContainerType()
container_type_uid = container_type and container_type.UID() or ""
container_type_title = container_type and container_type.Title() or ""
# sample points
sample_points = obj.getSamplePoints()
sample_point_uids = map(lambda sp: sp.UID(), sample_points)
sample_point_titles = map(lambda sp: sp.Title(), sample_points)
info.update({
"prefix": obj.getPrefix(),
"minimum_volume": obj.getMinimumVolume(),
"hazardous": obj.getHazardous(),
"retention_period": obj.getRetentionPeriod(),
"sample_matrix_uid": sample_matrix_uid,
"sample_matrix_title": sample_matrix_title,
"container_type_uid": container_type_uid,
"container_type_title": container_type_title,
"sample_point_uids": sample_point_uids,
"sample_point_titles": sample_point_titles,
})
# catalog queries for UI field filtering
filter_queries = {
"samplepoint": {
"getSampleTypeTitles": [obj.Title(), ''],
"getClientUID": [client_uid, bika_samplepoints_uid],
"sort_order": "descending",
},
"specification": {
"getSampleTypeTitle": obj.Title(),
"getClientUID": [client_uid, bika_analysisspecs_uid],
"sort_order": "descending",
}
}
info["filter_queries"] = filter_queries
return info |
def templates(self):
"""Iterate over the defined Templates."""
template = lib.EnvGetNextDeftemplate(self._env, ffi.NULL)
while template != ffi.NULL:
yield Template(self._env, template)
template = lib.EnvGetNextDeftemplate(self._env, template) | Iterate over the defined Templates. | Below is the the instruction that describes the task:
### Input:
Iterate over the defined Templates.
### Response:
def templates(self):
"""Iterate over the defined Templates."""
template = lib.EnvGetNextDeftemplate(self._env, ffi.NULL)
while template != ffi.NULL:
yield Template(self._env, template)
template = lib.EnvGetNextDeftemplate(self._env, template) |
def validate_field_matches_type(field, value, field_type, select_items=None, _min=None, _max=None):
"""Validate a config field against a specific type."""
if (field_type == defs.TEXT_TYPE and not isinstance(value, six.string_types)) or \
(field_type == defs.STRING_TYPE and not isinstance(value, six.string_types)) or \
(field_type == defs.BOOLEAN_TYPE and not isinstance(value, bool)) or \
(field_type == defs.INTEGER_TYPE and not isinstance(value, int)):
raise exceptions.ConfigFieldTypeMismatch(field, value, field_type)
if field_type == defs.INTEGER_TYPE:
if _min and value < _min:
raise exceptions.ConfigFieldTypeMismatch(field, value, "must be higher than {}".format(_min))
if _max and value > _max:
raise exceptions.ConfigFieldTypeMismatch(field, value, "must be lower than {}".format(_max))
if field_type == defs.SELECT_TYPE:
from honeycomb.utils.plugin_utils import get_select_items
items = get_select_items(select_items)
if value not in items:
raise exceptions.ConfigFieldTypeMismatch(field, value, "one of: {}".format(", ".join(items))) | Validate a config field against a specific type. | Below is the the instruction that describes the task:
### Input:
Validate a config field against a specific type.
### Response:
def validate_field_matches_type(field, value, field_type, select_items=None, _min=None, _max=None):
"""Validate a config field against a specific type."""
if (field_type == defs.TEXT_TYPE and not isinstance(value, six.string_types)) or \
(field_type == defs.STRING_TYPE and not isinstance(value, six.string_types)) or \
(field_type == defs.BOOLEAN_TYPE and not isinstance(value, bool)) or \
(field_type == defs.INTEGER_TYPE and not isinstance(value, int)):
raise exceptions.ConfigFieldTypeMismatch(field, value, field_type)
if field_type == defs.INTEGER_TYPE:
if _min and value < _min:
raise exceptions.ConfigFieldTypeMismatch(field, value, "must be higher than {}".format(_min))
if _max and value > _max:
raise exceptions.ConfigFieldTypeMismatch(field, value, "must be lower than {}".format(_max))
if field_type == defs.SELECT_TYPE:
from honeycomb.utils.plugin_utils import get_select_items
items = get_select_items(select_items)
if value not in items:
raise exceptions.ConfigFieldTypeMismatch(field, value, "one of: {}".format(", ".join(items))) |
def get(self, name: Text, final: C) -> C:
"""
Get the function to call which will run all middlewares.
:param name: Name of the function to be called
:param final: Function to call at the bottom of the stack (that's the
one provided by the implementer).
:return:
"""
# noinspection PyTypeChecker
return Caller(self, name, final) | Get the function to call which will run all middlewares.
:param name: Name of the function to be called
:param final: Function to call at the bottom of the stack (that's the
one provided by the implementer).
:return: | Below is the the instruction that describes the task:
### Input:
Get the function to call which will run all middlewares.
:param name: Name of the function to be called
:param final: Function to call at the bottom of the stack (that's the
one provided by the implementer).
:return:
### Response:
def get(self, name: Text, final: C) -> C:
"""
Get the function to call which will run all middlewares.
:param name: Name of the function to be called
:param final: Function to call at the bottom of the stack (that's the
one provided by the implementer).
:return:
"""
# noinspection PyTypeChecker
return Caller(self, name, final) |
def clone(self):
''' Returns a shallow copy of the current instance, except that all
variables are deep-cloned.
'''
clone = copy(self)
clone.variables = {k: v.clone() for (k, v) in self.variables.items()}
return clone | Returns a shallow copy of the current instance, except that all
variables are deep-cloned. | Below is the the instruction that describes the task:
### Input:
Returns a shallow copy of the current instance, except that all
variables are deep-cloned.
### Response:
def clone(self):
''' Returns a shallow copy of the current instance, except that all
variables are deep-cloned.
'''
clone = copy(self)
clone.variables = {k: v.clone() for (k, v) in self.variables.items()}
return clone |
def _run_link(self, stream=sys.stdout, dry_run=False,
stage_files=True, resubmit_failed=False):
"""Internal function that actually runs this link.
This checks if input and output files are present.
If input files are missing this will raise `OSError` if dry_run is False
If all output files are present this will skip execution.
Parameters
-----------
stream : `file`
Stream that this `Link` will print to,
must have 'write' function.
dry_run : bool
Print command but do not run it.
stage_files : bool
Stage files to and from the scratch area.
resubmit_failed : bool
Resubmit failed jobs.
"""
if resubmit_failed:
self.args['action'] = 'resubmit'
argv = self._make_argv()
if dry_run:
argv.append('--dry_run')
self._invoke(argv, stream, resubmit_failed=resubmit_failed) | Internal function that actually runs this link.
This checks if input and output files are present.
If input files are missing this will raise `OSError` if dry_run is False
If all output files are present this will skip execution.
Parameters
-----------
stream : `file`
Stream that this `Link` will print to,
must have 'write' function.
dry_run : bool
Print command but do not run it.
stage_files : bool
Stage files to and from the scratch area.
resubmit_failed : bool
Resubmit failed jobs. | Below is the the instruction that describes the task:
### Input:
Internal function that actually runs this link.
This checks if input and output files are present.
If input files are missing this will raise `OSError` if dry_run is False
If all output files are present this will skip execution.
Parameters
-----------
stream : `file`
Stream that this `Link` will print to,
must have 'write' function.
dry_run : bool
Print command but do not run it.
stage_files : bool
Stage files to and from the scratch area.
resubmit_failed : bool
Resubmit failed jobs.
### Response:
def _run_link(self, stream=sys.stdout, dry_run=False,
stage_files=True, resubmit_failed=False):
"""Internal function that actually runs this link.
This checks if input and output files are present.
If input files are missing this will raise `OSError` if dry_run is False
If all output files are present this will skip execution.
Parameters
-----------
stream : `file`
Stream that this `Link` will print to,
must have 'write' function.
dry_run : bool
Print command but do not run it.
stage_files : bool
Stage files to and from the scratch area.
resubmit_failed : bool
Resubmit failed jobs.
"""
if resubmit_failed:
self.args['action'] = 'resubmit'
argv = self._make_argv()
if dry_run:
argv.append('--dry_run')
self._invoke(argv, stream, resubmit_failed=resubmit_failed) |
def dasopr(fname):
"""
Open a DAS file for reading.
http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/dasopr_c.html
:param fname: Name of a DAS file to be opened.
:type fname: str
:return: Handle assigned to the opened DAS file.
:rtype: int
"""
fname = stypes.stringToCharP(fname)
handle = ctypes.c_int()
libspice.dasopr_c(fname, ctypes.byref(handle))
return handle.value | Open a DAS file for reading.
http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/dasopr_c.html
:param fname: Name of a DAS file to be opened.
:type fname: str
:return: Handle assigned to the opened DAS file.
:rtype: int | Below is the the instruction that describes the task:
### Input:
Open a DAS file for reading.
http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/dasopr_c.html
:param fname: Name of a DAS file to be opened.
:type fname: str
:return: Handle assigned to the opened DAS file.
:rtype: int
### Response:
def dasopr(fname):
"""
Open a DAS file for reading.
http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/dasopr_c.html
:param fname: Name of a DAS file to be opened.
:type fname: str
:return: Handle assigned to the opened DAS file.
:rtype: int
"""
fname = stypes.stringToCharP(fname)
handle = ctypes.c_int()
libspice.dasopr_c(fname, ctypes.byref(handle))
return handle.value |
def enable_mfa_device(self,
user_name,
serial_number,
authentication_code_1,
authentication_code_2):
"""Enable MFA Device for user."""
user = self.get_user(user_name)
if serial_number in user.mfa_devices:
raise IAMConflictException(
"EntityAlreadyExists",
"Device {0} already exists".format(serial_number)
)
user.enable_mfa_device(
serial_number,
authentication_code_1,
authentication_code_2
) | Enable MFA Device for user. | Below is the the instruction that describes the task:
### Input:
Enable MFA Device for user.
### Response:
def enable_mfa_device(self,
user_name,
serial_number,
authentication_code_1,
authentication_code_2):
"""Enable MFA Device for user."""
user = self.get_user(user_name)
if serial_number in user.mfa_devices:
raise IAMConflictException(
"EntityAlreadyExists",
"Device {0} already exists".format(serial_number)
)
user.enable_mfa_device(
serial_number,
authentication_code_1,
authentication_code_2
) |
def s3_download(url, dst): # type: (str, str) -> None
"""Download a file from S3.
Args:
url (str): the s3 url of the file.
dst (str): the destination where the file will be saved.
"""
url = parse.urlparse(url)
if url.scheme != 's3':
raise ValueError("Expecting 's3' scheme, got: %s in %s" % (url.scheme, url))
bucket, key = url.netloc, url.path.lstrip('/')
region = os.environ.get('AWS_REGION', os.environ.get(_params.REGION_NAME_ENV))
s3 = boto3.resource('s3', region_name=region)
s3.Bucket(bucket).download_file(key, dst) | Download a file from S3.
Args:
url (str): the s3 url of the file.
dst (str): the destination where the file will be saved. | Below is the the instruction that describes the task:
### Input:
Download a file from S3.
Args:
url (str): the s3 url of the file.
dst (str): the destination where the file will be saved.
### Response:
def s3_download(url, dst): # type: (str, str) -> None
"""Download a file from S3.
Args:
url (str): the s3 url of the file.
dst (str): the destination where the file will be saved.
"""
url = parse.urlparse(url)
if url.scheme != 's3':
raise ValueError("Expecting 's3' scheme, got: %s in %s" % (url.scheme, url))
bucket, key = url.netloc, url.path.lstrip('/')
region = os.environ.get('AWS_REGION', os.environ.get(_params.REGION_NAME_ENV))
s3 = boto3.resource('s3', region_name=region)
s3.Bucket(bucket).download_file(key, dst) |
def job_terminate(object_id, input_params={}, always_retry=True, **kwargs):
"""
Invokes the /job-xxxx/terminate API method.
For more info, see: https://wiki.dnanexus.com/API-Specification-v1.0.0/Applets-and-Entry-Points#API-method%3A-%2Fjob-xxxx%2Fterminate
"""
return DXHTTPRequest('/%s/terminate' % object_id, input_params, always_retry=always_retry, **kwargs) | Invokes the /job-xxxx/terminate API method.
For more info, see: https://wiki.dnanexus.com/API-Specification-v1.0.0/Applets-and-Entry-Points#API-method%3A-%2Fjob-xxxx%2Fterminate | Below is the the instruction that describes the task:
### Input:
Invokes the /job-xxxx/terminate API method.
For more info, see: https://wiki.dnanexus.com/API-Specification-v1.0.0/Applets-and-Entry-Points#API-method%3A-%2Fjob-xxxx%2Fterminate
### Response:
def job_terminate(object_id, input_params={}, always_retry=True, **kwargs):
"""
Invokes the /job-xxxx/terminate API method.
For more info, see: https://wiki.dnanexus.com/API-Specification-v1.0.0/Applets-and-Entry-Points#API-method%3A-%2Fjob-xxxx%2Fterminate
"""
return DXHTTPRequest('/%s/terminate' % object_id, input_params, always_retry=always_retry, **kwargs) |
def __liftover_coordinates_genomic_deletions(self, intersecting_region):
"""
A 'private' helper member function to perform liftover in coordinate space
when the length of the genomic match is smaller than the concensus match.
We assume the genomic region contains deletions. In this case, we uniformly
distribute the deletions (gaps) through the genomic region. This is the
trickiest liftover case because it fragments the region after liftover.
This method should only be called when the aboe condition is true (longer
consensus region than genomic region) otherwise an assertion will be
failed.
:param intersecting_region: a region that intersects this occurrence.
:return: list of GenomicInterval objects. This is a list because a genomic
deletion of part of the retrotransposon can fragment the
intersecting region and result in more than one returned interval.
"""
# should never happen, but check anyway...
consensus_match_length = self.consensus_end - self.consensus_start
size_dif = consensus_match_length - len(self)
assert(size_dif > 0)
name = self.repeat_name()
gap_interval = int(math.ceil(len(self) / float(size_dif)))
s_dist_to_gen_start = max(intersecting_region.start - self.start, 0)
e_dist_to_gen_start = min(max(intersecting_region.end -
self.start, 0), len(self))
gaps_before = s_dist_to_gen_start / gap_interval
gaps_in = ((e_dist_to_gen_start - 1) / gap_interval) - gaps_before
gen_s_dist = s_dist_to_gen_start
left_to_lift = (min(self.end, intersecting_region.end) -
max(self.start, intersecting_region.start))
res = []
if self.consensus_match_strand is '+':
s = s_dist_to_gen_start + self.consensus_start
s = s + gaps_before
for i in range(0, gaps_in):
e = s + min((gap_interval - (gen_s_dist % gap_interval)), left_to_lift)
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
gen_s_dist += (e - s)
left_to_lift -= (e - s)
s = e + 1
e = min(s + min(gap_interval, left_to_lift), self.consensus_end)
if e - s != 0:
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
else:
e = self.consensus_end - s_dist_to_gen_start
e = e - gaps_before
for i in range(0, gaps_in):
s = e - min((gap_interval - (gen_s_dist % gap_interval)), left_to_lift)
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
gen_s_dist += (e - s)
left_to_lift -= (e - s)
e = s - 1
s = max(e - min(gap_interval, left_to_lift), self.consensus_start)
if e - s != 0:
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
return res | A 'private' helper member function to perform liftover in coordinate space
when the length of the genomic match is smaller than the concensus match.
We assume the genomic region contains deletions. In this case, we uniformly
distribute the deletions (gaps) through the genomic region. This is the
trickiest liftover case because it fragments the region after liftover.
This method should only be called when the aboe condition is true (longer
consensus region than genomic region) otherwise an assertion will be
failed.
:param intersecting_region: a region that intersects this occurrence.
:return: list of GenomicInterval objects. This is a list because a genomic
deletion of part of the retrotransposon can fragment the
intersecting region and result in more than one returned interval. | Below is the the instruction that describes the task:
### Input:
A 'private' helper member function to perform liftover in coordinate space
when the length of the genomic match is smaller than the concensus match.
We assume the genomic region contains deletions. In this case, we uniformly
distribute the deletions (gaps) through the genomic region. This is the
trickiest liftover case because it fragments the region after liftover.
This method should only be called when the aboe condition is true (longer
consensus region than genomic region) otherwise an assertion will be
failed.
:param intersecting_region: a region that intersects this occurrence.
:return: list of GenomicInterval objects. This is a list because a genomic
deletion of part of the retrotransposon can fragment the
intersecting region and result in more than one returned interval.
### Response:
def __liftover_coordinates_genomic_deletions(self, intersecting_region):
"""
A 'private' helper member function to perform liftover in coordinate space
when the length of the genomic match is smaller than the concensus match.
We assume the genomic region contains deletions. In this case, we uniformly
distribute the deletions (gaps) through the genomic region. This is the
trickiest liftover case because it fragments the region after liftover.
This method should only be called when the aboe condition is true (longer
consensus region than genomic region) otherwise an assertion will be
failed.
:param intersecting_region: a region that intersects this occurrence.
:return: list of GenomicInterval objects. This is a list because a genomic
deletion of part of the retrotransposon can fragment the
intersecting region and result in more than one returned interval.
"""
# should never happen, but check anyway...
consensus_match_length = self.consensus_end - self.consensus_start
size_dif = consensus_match_length - len(self)
assert(size_dif > 0)
name = self.repeat_name()
gap_interval = int(math.ceil(len(self) / float(size_dif)))
s_dist_to_gen_start = max(intersecting_region.start - self.start, 0)
e_dist_to_gen_start = min(max(intersecting_region.end -
self.start, 0), len(self))
gaps_before = s_dist_to_gen_start / gap_interval
gaps_in = ((e_dist_to_gen_start - 1) / gap_interval) - gaps_before
gen_s_dist = s_dist_to_gen_start
left_to_lift = (min(self.end, intersecting_region.end) -
max(self.start, intersecting_region.start))
res = []
if self.consensus_match_strand is '+':
s = s_dist_to_gen_start + self.consensus_start
s = s + gaps_before
for i in range(0, gaps_in):
e = s + min((gap_interval - (gen_s_dist % gap_interval)), left_to_lift)
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
gen_s_dist += (e - s)
left_to_lift -= (e - s)
s = e + 1
e = min(s + min(gap_interval, left_to_lift), self.consensus_end)
if e - s != 0:
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
else:
e = self.consensus_end - s_dist_to_gen_start
e = e - gaps_before
for i in range(0, gaps_in):
s = e - min((gap_interval - (gen_s_dist % gap_interval)), left_to_lift)
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
gen_s_dist += (e - s)
left_to_lift -= (e - s)
e = s - 1
s = max(e - min(gap_interval, left_to_lift), self.consensus_start)
if e - s != 0:
res.append(GenomicInterval(name, s, e, intersecting_region.name,
intersecting_region.score, self.strand))
return res |
def rawData(self, fileAdres=None):
# skip skiprows
skiprows = None
skip_from = [b'Field', b'Moment']
with open(fileAdres, 'rb') as fr:
#f = fr.read()
for i, line in enumerate(fr, 1):
# print(line.split())
if skip_from == line.split():
skiprows = i+2
break
# else:
# print('file format wrong, cannot find the data row.')
skiprows = 34 if skiprows == None else skiprows
df = pd.read_csv(fileAdres, skiprows=skiprows, sep='\s+',
delimiter=',', names=['H', 'M'], skipfooter=1,
engine='python')
H = df.H # measured field
M = df.M # measured magnetic moment
'''
#=================================================
/datainterval_H/_M
/slice the measured data into pieces
/for every measured FORC
#=================================================
'''
dataInterval_H = []
dataInterval_M = []
# print(H)
cretia = df.H.mean() # edge of linear programing for selecting data
H0 = df.H.max() # the maximum field
self.x, self.y, self.z = [[], [], []]
for i in np.arange(1, len(H)):
dataInterval_H.append(H[i])
dataInterval_M.append(M[i])
if abs(H[i]-H0) <= 0.001: # when the filed reach the max, a new forc
if len(dataInterval_H) >= 0 and len(dataInterval_H) <= 200:
# print(dataInterval_H)
Ha = dataInterval_H[0]
dataInterval_H.pop(-1)
dataInterval_M.pop(-1)
Hb = dataInterval_H[1:-1]
Hm = dataInterval_M[1:-1]
for t in np.arange(len(Hb)):
self.x.append(Hb[t])
self.y.append(Ha)
self.z.append(Hm[t])
# print(Ha)
dataInterval_H = []
dataInterval_M = []
self.rawdf = df
'''
#=================================================
transfer the data set to matrix as len(x)*len(y) with z value
/mesh up the rawdata
/select the data area by X,Y ranges
/obtain regular spaced data potins by np.linspace
/use interplote to caculate the Hm values
/loop Ha(Y),Hb(X)
/fill every position with Hm, else with np.nan
#=================================================
'''
self.z = self.z/np.max(self.z)
# print(int(np.min(self.x)*100)/100,np.max(self.x))
xrange = [int((np.min(self.x)-0.1)*10)/10,
int((np.max(self.x)+0.1)*10)/10]
yrange = [int((np.min(self.y)-0.1)*10)/10,
int((np.max(self.y)+0.1)*10)/10]
X = np.linspace(xrange[0], xrange[1], 200)
Y = np.linspace(yrange[0], yrange[1], 200)
yi, xi = np.mgrid[yrange[0]:yrange[1]:200j, xrange[0]:xrange[1]:200j]
#X = np.linspace(-0.2,0.3,200)
#Y = np.linspace(-0.2,0.3,200)
#xi,yi = np.mgrid[-0.2:0.3:200j,-0.2:0.3:200j]
zi = griddata((self.x, self.y), self.z, (xi, yi),
method='linear') # !!! must linear
self.matrix_z = zi
self.x_range = X
self.y_range = Y | #=================================================
/datainterval_H/_M
/slice the measured data into pieces
/for every measured FORC
#================================================= | Below is the the instruction that describes the task:
### Input:
#=================================================
/datainterval_H/_M
/slice the measured data into pieces
/for every measured FORC
#=================================================
### Response:
def rawData(self, fileAdres=None):
# skip skiprows
skiprows = None
skip_from = [b'Field', b'Moment']
with open(fileAdres, 'rb') as fr:
#f = fr.read()
for i, line in enumerate(fr, 1):
# print(line.split())
if skip_from == line.split():
skiprows = i+2
break
# else:
# print('file format wrong, cannot find the data row.')
skiprows = 34 if skiprows == None else skiprows
df = pd.read_csv(fileAdres, skiprows=skiprows, sep='\s+',
delimiter=',', names=['H', 'M'], skipfooter=1,
engine='python')
H = df.H # measured field
M = df.M # measured magnetic moment
'''
#=================================================
/datainterval_H/_M
/slice the measured data into pieces
/for every measured FORC
#=================================================
'''
dataInterval_H = []
dataInterval_M = []
# print(H)
cretia = df.H.mean() # edge of linear programing for selecting data
H0 = df.H.max() # the maximum field
self.x, self.y, self.z = [[], [], []]
for i in np.arange(1, len(H)):
dataInterval_H.append(H[i])
dataInterval_M.append(M[i])
if abs(H[i]-H0) <= 0.001: # when the filed reach the max, a new forc
if len(dataInterval_H) >= 0 and len(dataInterval_H) <= 200:
# print(dataInterval_H)
Ha = dataInterval_H[0]
dataInterval_H.pop(-1)
dataInterval_M.pop(-1)
Hb = dataInterval_H[1:-1]
Hm = dataInterval_M[1:-1]
for t in np.arange(len(Hb)):
self.x.append(Hb[t])
self.y.append(Ha)
self.z.append(Hm[t])
# print(Ha)
dataInterval_H = []
dataInterval_M = []
self.rawdf = df
'''
#=================================================
transfer the data set to matrix as len(x)*len(y) with z value
/mesh up the rawdata
/select the data area by X,Y ranges
/obtain regular spaced data potins by np.linspace
/use interplote to caculate the Hm values
/loop Ha(Y),Hb(X)
/fill every position with Hm, else with np.nan
#=================================================
'''
self.z = self.z/np.max(self.z)
# print(int(np.min(self.x)*100)/100,np.max(self.x))
xrange = [int((np.min(self.x)-0.1)*10)/10,
int((np.max(self.x)+0.1)*10)/10]
yrange = [int((np.min(self.y)-0.1)*10)/10,
int((np.max(self.y)+0.1)*10)/10]
X = np.linspace(xrange[0], xrange[1], 200)
Y = np.linspace(yrange[0], yrange[1], 200)
yi, xi = np.mgrid[yrange[0]:yrange[1]:200j, xrange[0]:xrange[1]:200j]
#X = np.linspace(-0.2,0.3,200)
#Y = np.linspace(-0.2,0.3,200)
#xi,yi = np.mgrid[-0.2:0.3:200j,-0.2:0.3:200j]
zi = griddata((self.x, self.y), self.z, (xi, yi),
method='linear') # !!! must linear
self.matrix_z = zi
self.x_range = X
self.y_range = Y |
def _get_all(self):
""" Get all users from db and turn into list of dicts """
return [self._to_dict(row) for row in models.User.objects.all()] | Get all users from db and turn into list of dicts | Below is the the instruction that describes the task:
### Input:
Get all users from db and turn into list of dicts
### Response:
def _get_all(self):
""" Get all users from db and turn into list of dicts """
return [self._to_dict(row) for row in models.User.objects.all()] |
def _get_access_token(self):
"""
Get IAM access token using API key.
"""
err = 'Failed to contact IAM token service'
try:
resp = super(IAMSession, self).request(
'POST',
self._token_url,
auth=self._token_auth,
headers={'Accepts': 'application/json'},
data={
'grant_type': 'urn:ibm:params:oauth:grant-type:apikey',
'response_type': 'cloud_iam',
'apikey': self._api_key
}
)
err = response_to_json_dict(resp).get('errorMessage', err)
resp.raise_for_status()
return response_to_json_dict(resp)['access_token']
except KeyError:
raise CloudantException('Invalid response from IAM token service')
except RequestException:
raise CloudantException(err) | Get IAM access token using API key. | Below is the the instruction that describes the task:
### Input:
Get IAM access token using API key.
### Response:
def _get_access_token(self):
"""
Get IAM access token using API key.
"""
err = 'Failed to contact IAM token service'
try:
resp = super(IAMSession, self).request(
'POST',
self._token_url,
auth=self._token_auth,
headers={'Accepts': 'application/json'},
data={
'grant_type': 'urn:ibm:params:oauth:grant-type:apikey',
'response_type': 'cloud_iam',
'apikey': self._api_key
}
)
err = response_to_json_dict(resp).get('errorMessage', err)
resp.raise_for_status()
return response_to_json_dict(resp)['access_token']
except KeyError:
raise CloudantException('Invalid response from IAM token service')
except RequestException:
raise CloudantException(err) |
def handle(self, request: HttpRequest) -> HttpResponse:
"""
Prepares for the CallBackResolver and handles the response and exceptions
:param request HttpRequest
:rtype: HttpResponse
"""
self.__request_start = datetime.now()
self.__request = request
self.__uri = request.path[1:]
self.__method = request.method
# Initializes the callable controller and call it's connect method to get the mapped end-points.
controller: RouteMapping = self.__controller().connect(self.app)
self.__end_points = controller.get_routes()
indent = self.get_json_ident(request.META)
if self.set_end_point_uri() is False:
return self.set_response_headers(self.no_route_found(self.__request).render(indent))
response = HttpResponse(None)
try:
response = self.exec_route_callback()
except RinzlerHttpException as e:
client.captureException()
self.app.log.error(f"< {e.status_code}", exc_info=True)
response = Response(None, status=e.status_code)
except RequestDataTooBig:
client.captureException()
self.app.log.error("< 413", exc_info=True)
response = Response(None, status=413)
except BaseException:
client.captureException()
self.app.log.error("< 500", exc_info=True)
response = Response(None, status=500)
finally:
if type(response) == Response:
return self.set_response_headers(response.render(indent))
else:
return self.set_response_headers(response) | Prepares for the CallBackResolver and handles the response and exceptions
:param request HttpRequest
:rtype: HttpResponse | Below is the the instruction that describes the task:
### Input:
Prepares for the CallBackResolver and handles the response and exceptions
:param request HttpRequest
:rtype: HttpResponse
### Response:
def handle(self, request: HttpRequest) -> HttpResponse:
"""
Prepares for the CallBackResolver and handles the response and exceptions
:param request HttpRequest
:rtype: HttpResponse
"""
self.__request_start = datetime.now()
self.__request = request
self.__uri = request.path[1:]
self.__method = request.method
# Initializes the callable controller and call it's connect method to get the mapped end-points.
controller: RouteMapping = self.__controller().connect(self.app)
self.__end_points = controller.get_routes()
indent = self.get_json_ident(request.META)
if self.set_end_point_uri() is False:
return self.set_response_headers(self.no_route_found(self.__request).render(indent))
response = HttpResponse(None)
try:
response = self.exec_route_callback()
except RinzlerHttpException as e:
client.captureException()
self.app.log.error(f"< {e.status_code}", exc_info=True)
response = Response(None, status=e.status_code)
except RequestDataTooBig:
client.captureException()
self.app.log.error("< 413", exc_info=True)
response = Response(None, status=413)
except BaseException:
client.captureException()
self.app.log.error("< 500", exc_info=True)
response = Response(None, status=500)
finally:
if type(response) == Response:
return self.set_response_headers(response.render(indent))
else:
return self.set_response_headers(response) |
def parse(filename, format=u"Jæren Sparebank", encoding="latin1"):
"""Parses bank CSV file and returns Transactions instance.
Args:
filename: Path to CSV file to read.
format: CSV format; one of the entries in `elv.formats`.
encoding: The CSV file encoding.
Returns:
A ``Transactions`` object.
"""
Class = formats[format.lower()]
if PY3:
kw = {"encoding": encoding}
else:
kw = {}
with open(filename, "rt", **kw) as f:
return Class.csv_to_transactions(f) | Parses bank CSV file and returns Transactions instance.
Args:
filename: Path to CSV file to read.
format: CSV format; one of the entries in `elv.formats`.
encoding: The CSV file encoding.
Returns:
A ``Transactions`` object. | Below is the the instruction that describes the task:
### Input:
Parses bank CSV file and returns Transactions instance.
Args:
filename: Path to CSV file to read.
format: CSV format; one of the entries in `elv.formats`.
encoding: The CSV file encoding.
Returns:
A ``Transactions`` object.
### Response:
def parse(filename, format=u"Jæren Sparebank", encoding="latin1"):
"""Parses bank CSV file and returns Transactions instance.
Args:
filename: Path to CSV file to read.
format: CSV format; one of the entries in `elv.formats`.
encoding: The CSV file encoding.
Returns:
A ``Transactions`` object.
"""
Class = formats[format.lower()]
if PY3:
kw = {"encoding": encoding}
else:
kw = {}
with open(filename, "rt", **kw) as f:
return Class.csv_to_transactions(f) |
def _send_float(self,value):
"""
Return a float as a IEEE 754 format bytes object.
"""
# convert to float. this will throw a ValueError if the type is not
# readily converted
if type(value) != float:
value = float(value)
# Range check
if value > self.board.float_max or value < self.board.float_min:
err = "Value {} exceeds the size of the board's float.".format(value)
raise OverflowError(err)
return struct.pack(self.board.float_type,value) | Return a float as a IEEE 754 format bytes object. | Below is the the instruction that describes the task:
### Input:
Return a float as a IEEE 754 format bytes object.
### Response:
def _send_float(self,value):
"""
Return a float as a IEEE 754 format bytes object.
"""
# convert to float. this will throw a ValueError if the type is not
# readily converted
if type(value) != float:
value = float(value)
# Range check
if value > self.board.float_max or value < self.board.float_min:
err = "Value {} exceeds the size of the board's float.".format(value)
raise OverflowError(err)
return struct.pack(self.board.float_type,value) |
def _CreateLineStringForShape(self, parent, shape):
"""Create a KML LineString using coordinates from a shape.
Args:
parent: The parent ElementTree.Element instance.
shape: The transitfeed.Shape instance.
Returns:
The LineString ElementTree.Element instance or None if coordinate_list is
empty.
"""
coordinate_list = [(longitude, latitude) for
(latitude, longitude, distance) in shape.points]
return self._CreateLineString(parent, coordinate_list) | Create a KML LineString using coordinates from a shape.
Args:
parent: The parent ElementTree.Element instance.
shape: The transitfeed.Shape instance.
Returns:
The LineString ElementTree.Element instance or None if coordinate_list is
empty. | Below is the the instruction that describes the task:
### Input:
Create a KML LineString using coordinates from a shape.
Args:
parent: The parent ElementTree.Element instance.
shape: The transitfeed.Shape instance.
Returns:
The LineString ElementTree.Element instance or None if coordinate_list is
empty.
### Response:
def _CreateLineStringForShape(self, parent, shape):
"""Create a KML LineString using coordinates from a shape.
Args:
parent: The parent ElementTree.Element instance.
shape: The transitfeed.Shape instance.
Returns:
The LineString ElementTree.Element instance or None if coordinate_list is
empty.
"""
coordinate_list = [(longitude, latitude) for
(latitude, longitude, distance) in shape.points]
return self._CreateLineString(parent, coordinate_list) |
def create(self, resource):
"""
Set all the labels for a resource.
Args:
resource: The object containing the resource URI and a list of labels
Returns:
dict: Resource Labels
"""
uri = self.URI + self.RESOURCES_PATH
return self._client.create(resource=resource, uri=uri) | Set all the labels for a resource.
Args:
resource: The object containing the resource URI and a list of labels
Returns:
dict: Resource Labels | Below is the the instruction that describes the task:
### Input:
Set all the labels for a resource.
Args:
resource: The object containing the resource URI and a list of labels
Returns:
dict: Resource Labels
### Response:
def create(self, resource):
"""
Set all the labels for a resource.
Args:
resource: The object containing the resource URI and a list of labels
Returns:
dict: Resource Labels
"""
uri = self.URI + self.RESOURCES_PATH
return self._client.create(resource=resource, uri=uri) |
def sanitize(self):
'''
Check if the current settings conform to the LISP specifications and
fix where possible.
'''
# WARNING: http://tools.ietf.org/html/draft-ietf-lisp-ddt-00
# does not define this field so the description is taken from
# http://tools.ietf.org/html/draft-ietf-lisp-24
#
# Record TTL: The time in minutes the recipient of the Map-Reply will
# store the mapping. If the TTL is 0, the entry SHOULD be removed
# from the cache immediately. If the value is 0xffffffff, the
# recipient can decide locally how long to store the mapping.
if not isinstance(self.ttl, numbers.Integral) \
or self.ttl < 0 or self.ttl > 0xffffffff:
raise ValueError('Invalid TTL')
# ACT: The "action" field of the mapping record in a Map-Referral
# message encodes 6 action types. The values for the action types are:
#
# NODE-REFERRAL (0): Sent by a DDT node with a child delegation which
# is authoritative for the EID.
#
# MS-REFERRAL (1): Sent by a DDT node that has information about Map
# Server(s) for the EID but it is not one of the Map Servers listed,
# i.e. the DDT-Node sending the referral is not a Map Server.
#
# MS-ACK (2): Sent by a DDT Map Server that has one or more ETR
# registered for the EID.
#
# MS-NOT-REGISTERED (3): Sent by a DDT Map Server that is configured
# for the EID-prefix but for which no ETRs are registered.
#
# DELEGATION-HOLE (4): Sent by an intermediate DDT node with
# authoritative configuration covering the requested EID but without
# any child delegation for the EID. Also sent by a DDT Map Server
# with authoritative configuration covering the requested EID but
# for which no specific site ETR is configured.
#
# NOT-AUTHORITATIVE (5): Sent by a DDT node that does not have
# authoritative configuration for the requested EID. The EID-prefix
# returned MUST be the original requested EID and the TTL MUST be
# set to 0. However, if such a DDT node has a child delegation
# covering the requested EID, it may choose to return NODE-REFERRAL
# or MS-REFERRAL as appropriate. A DDT Map Server with site
# information may choose to return of type MS-ACK or MS-NOT-
# REGISTERED as appropriate.
if self.action not in (self.ACT_NODE_REFERRAL,
self.ACT_MS_REFERRAL,
self.ACT_MS_ACK,
self.ACT_MS_NOT_REGISTERED,
self.ACT_DELEGATION_HOLE,
self.ACT_NOT_AUTHORITATIVE):
raise ValueError('Invalid action')
# WARNING: http://tools.ietf.org/html/draft-ietf-lisp-ddt-00
# does not define this field so the description is taken from
# http://tools.ietf.org/html/draft-ietf-lisp-24
#
# A: The Authoritative bit, when sent is always set to 1 by an ETR.
# When a Map-Server is proxy Map-Replying [LISP-MS] for a LISP site,
# the Authoritative bit is set to 0. This indicates to requesting
# ITRs that the Map-Reply was not originated by a LISP node managed
# at the site that owns the EID-prefix.
if not isinstance(self.authoritative, bool):
raise ValueError('Authoritative flag must be a boolean')
# Incomplete: The "I" bit indicates that a DDT node's referral-set of
# locators is incomplete and the receiver of this message should not
# cache the referral
if not isinstance(self.incomplete, bool):
raise ValueError('Incomplete flag must be a boolean')
# A DDT sets the "incomplete" flag, the TTL, and the Action Type field
# as follows:
#
# -------------------------------------------------------------------
# Type (Action field) Incomplete Referral-set TTL values
# -------------------------------------------------------------------
# 0 NODE-REFERRAL NO YES 1440
# 1 MS-REFERRAL NO YES 1440
# 2 MS-ACK * * 1440
# 3 MS-NOT-REGISTERED * * 1
# 4 DELEGATION-HOLE NO NO 15
# 5 NOT-AUTHORITATIVE YES NO 0
# -------------------------------------------------------------------
#
# *: The "Incomplete" flag setting on Map Server originated referral of
# MS-REFERRAL and MS-NOT-REGISTERED types depend on whether the Map
# Server has the full peer Map Server configuration for the same
# prefix and has encoded the information in the mapping record.
# Incomplete bit is not set when the Map Server has encoded the
# information, which means the referral-set includes all the RLOCs
# of all Map Servers that serve the prefix. It is set when the Map
# Server has not encoded the Map Server set information.
if self.action == self.ACT_NODE_REFERRAL:
if self.incomplete:
raise ValueError('NODE-REFERRAL messages cannot be incomplete')
if not self.locator_records:
raise ValueError('NODE-REFERRAL messages must have locators')
if self.ttl != 1440:
raise ValueError('NODE-REFERRAL messages must have TTL=1440')
elif self.action == self.ACT_MS_REFERRAL:
if self.incomplete:
raise ValueError('MS-REFERRAL messages cannot be incomplete')
if not self.locator_records:
raise ValueError('MS-REFERRAL messages must have locators')
if self.ttl != 1440:
raise ValueError('MS-REFERRAL messages must have TTL=1440')
elif self.action == self.ACT_MS_ACK:
if self.ttl != 1440:
raise ValueError('MS-ACK messages must have TTL=1440')
elif self.action == self.ACT_MS_NOT_REGISTERED:
if self.ttl != 1:
raise ValueError('MS-NOT-REGISTERED messages must have '
'TTL=1')
elif self.action == self.ACT_DELEGATION_HOLE:
if self.incomplete:
raise ValueError('DELEGATION-HOLE messages cannot be '
'incomplete')
if self.locator_records:
raise ValueError('DELEGATION-HOLE messages can not have '
'locators')
if self.ttl != 15:
raise ValueError('DELEGATION-HOLE messages must have TTL=15')
elif self.action == self.ACT_NOT_AUTHORITATIVE:
if not self.incomplete:
raise ValueError('NOT-AUTHORITATIVE messages must be '
'incomplete')
if self.locator_records:
raise ValueError('NOT-AUTHORITATIVE messages can not have '
'locators')
if self.ttl != 0:
raise ValueError('NOT-AUTHORITATIVE messages must have TTL=0')
# WARNING: http://tools.ietf.org/html/draft-ietf-lisp-ddt-00
# does not define this field so the description is taken from
# http://tools.ietf.org/html/draft-ietf-lisp-24
#
# Map-Version Number: When this 12-bit value is non-zero the Map-Reply
# sender is informing the ITR what the version number is for the
# EID-record contained in the Map-Reply. The ETR can allocate this
# number internally but MUST coordinate this value with other ETRs
# for the site. When this value is 0, there is no versioning
# information conveyed. The Map-Version Number can be included in
# Map-Request and Map-Register messages. See Section 6.6.3 for more
# details.
if not isinstance(self.map_version, numbers.Integral) \
or self.map_version < 0 \
or self.map_version >= 2 ** 12:
raise ValueError('Invalid map version')
# EID-prefix: 4 octets if an IPv4 address-family, 16 octets if an IPv6
# address-family.
if not isinstance(self.eid_prefix, LCAFInstanceAddress):
if not isinstance(self.eid_prefix, (IPv4Network, IPv6Network)):
raise ValueError("Unexpected EID prefix %r", self.eid_prefix)
# Wrap in LCAF address with Instance ID
self.eid_prefix = LCAFInstanceAddress(instance_id=0,
address=self.eid_prefix)
# Check locator records
# The probed_locator bits aren't used in this context
for locator_record in self.locator_records:
if not isinstance(locator_record, LocatorRecord) \
or locator_record.probed_locator:
raise ValueError('Invalid Locator record')
locator_record.sanitize()
# For each Map-Reply record, the list of Locators in a Locator-Set MUST
# appear in the same order for each ETR that originates a Map-Reply
# message. The Locator-Set MUST be sorted in order of ascending IP
# address where an IPv4 locator address is considered numerically 'less
# than' an IPv6 locator address.
self.locator_records.sort(key=LocatorRecord.sort_key)
# Check signatures
for dummy in self.signatures:
# TODO: Implement signatures [LISP-Security]
pass | Check if the current settings conform to the LISP specifications and
fix where possible. | Below is the the instruction that describes the task:
### Input:
Check if the current settings conform to the LISP specifications and
fix where possible.
### Response:
def sanitize(self):
'''
Check if the current settings conform to the LISP specifications and
fix where possible.
'''
# WARNING: http://tools.ietf.org/html/draft-ietf-lisp-ddt-00
# does not define this field so the description is taken from
# http://tools.ietf.org/html/draft-ietf-lisp-24
#
# Record TTL: The time in minutes the recipient of the Map-Reply will
# store the mapping. If the TTL is 0, the entry SHOULD be removed
# from the cache immediately. If the value is 0xffffffff, the
# recipient can decide locally how long to store the mapping.
if not isinstance(self.ttl, numbers.Integral) \
or self.ttl < 0 or self.ttl > 0xffffffff:
raise ValueError('Invalid TTL')
# ACT: The "action" field of the mapping record in a Map-Referral
# message encodes 6 action types. The values for the action types are:
#
# NODE-REFERRAL (0): Sent by a DDT node with a child delegation which
# is authoritative for the EID.
#
# MS-REFERRAL (1): Sent by a DDT node that has information about Map
# Server(s) for the EID but it is not one of the Map Servers listed,
# i.e. the DDT-Node sending the referral is not a Map Server.
#
# MS-ACK (2): Sent by a DDT Map Server that has one or more ETR
# registered for the EID.
#
# MS-NOT-REGISTERED (3): Sent by a DDT Map Server that is configured
# for the EID-prefix but for which no ETRs are registered.
#
# DELEGATION-HOLE (4): Sent by an intermediate DDT node with
# authoritative configuration covering the requested EID but without
# any child delegation for the EID. Also sent by a DDT Map Server
# with authoritative configuration covering the requested EID but
# for which no specific site ETR is configured.
#
# NOT-AUTHORITATIVE (5): Sent by a DDT node that does not have
# authoritative configuration for the requested EID. The EID-prefix
# returned MUST be the original requested EID and the TTL MUST be
# set to 0. However, if such a DDT node has a child delegation
# covering the requested EID, it may choose to return NODE-REFERRAL
# or MS-REFERRAL as appropriate. A DDT Map Server with site
# information may choose to return of type MS-ACK or MS-NOT-
# REGISTERED as appropriate.
if self.action not in (self.ACT_NODE_REFERRAL,
self.ACT_MS_REFERRAL,
self.ACT_MS_ACK,
self.ACT_MS_NOT_REGISTERED,
self.ACT_DELEGATION_HOLE,
self.ACT_NOT_AUTHORITATIVE):
raise ValueError('Invalid action')
# WARNING: http://tools.ietf.org/html/draft-ietf-lisp-ddt-00
# does not define this field so the description is taken from
# http://tools.ietf.org/html/draft-ietf-lisp-24
#
# A: The Authoritative bit, when sent is always set to 1 by an ETR.
# When a Map-Server is proxy Map-Replying [LISP-MS] for a LISP site,
# the Authoritative bit is set to 0. This indicates to requesting
# ITRs that the Map-Reply was not originated by a LISP node managed
# at the site that owns the EID-prefix.
if not isinstance(self.authoritative, bool):
raise ValueError('Authoritative flag must be a boolean')
# Incomplete: The "I" bit indicates that a DDT node's referral-set of
# locators is incomplete and the receiver of this message should not
# cache the referral
if not isinstance(self.incomplete, bool):
raise ValueError('Incomplete flag must be a boolean')
# A DDT sets the "incomplete" flag, the TTL, and the Action Type field
# as follows:
#
# -------------------------------------------------------------------
# Type (Action field) Incomplete Referral-set TTL values
# -------------------------------------------------------------------
# 0 NODE-REFERRAL NO YES 1440
# 1 MS-REFERRAL NO YES 1440
# 2 MS-ACK * * 1440
# 3 MS-NOT-REGISTERED * * 1
# 4 DELEGATION-HOLE NO NO 15
# 5 NOT-AUTHORITATIVE YES NO 0
# -------------------------------------------------------------------
#
# *: The "Incomplete" flag setting on Map Server originated referral of
# MS-REFERRAL and MS-NOT-REGISTERED types depend on whether the Map
# Server has the full peer Map Server configuration for the same
# prefix and has encoded the information in the mapping record.
# Incomplete bit is not set when the Map Server has encoded the
# information, which means the referral-set includes all the RLOCs
# of all Map Servers that serve the prefix. It is set when the Map
# Server has not encoded the Map Server set information.
if self.action == self.ACT_NODE_REFERRAL:
if self.incomplete:
raise ValueError('NODE-REFERRAL messages cannot be incomplete')
if not self.locator_records:
raise ValueError('NODE-REFERRAL messages must have locators')
if self.ttl != 1440:
raise ValueError('NODE-REFERRAL messages must have TTL=1440')
elif self.action == self.ACT_MS_REFERRAL:
if self.incomplete:
raise ValueError('MS-REFERRAL messages cannot be incomplete')
if not self.locator_records:
raise ValueError('MS-REFERRAL messages must have locators')
if self.ttl != 1440:
raise ValueError('MS-REFERRAL messages must have TTL=1440')
elif self.action == self.ACT_MS_ACK:
if self.ttl != 1440:
raise ValueError('MS-ACK messages must have TTL=1440')
elif self.action == self.ACT_MS_NOT_REGISTERED:
if self.ttl != 1:
raise ValueError('MS-NOT-REGISTERED messages must have '
'TTL=1')
elif self.action == self.ACT_DELEGATION_HOLE:
if self.incomplete:
raise ValueError('DELEGATION-HOLE messages cannot be '
'incomplete')
if self.locator_records:
raise ValueError('DELEGATION-HOLE messages can not have '
'locators')
if self.ttl != 15:
raise ValueError('DELEGATION-HOLE messages must have TTL=15')
elif self.action == self.ACT_NOT_AUTHORITATIVE:
if not self.incomplete:
raise ValueError('NOT-AUTHORITATIVE messages must be '
'incomplete')
if self.locator_records:
raise ValueError('NOT-AUTHORITATIVE messages can not have '
'locators')
if self.ttl != 0:
raise ValueError('NOT-AUTHORITATIVE messages must have TTL=0')
# WARNING: http://tools.ietf.org/html/draft-ietf-lisp-ddt-00
# does not define this field so the description is taken from
# http://tools.ietf.org/html/draft-ietf-lisp-24
#
# Map-Version Number: When this 12-bit value is non-zero the Map-Reply
# sender is informing the ITR what the version number is for the
# EID-record contained in the Map-Reply. The ETR can allocate this
# number internally but MUST coordinate this value with other ETRs
# for the site. When this value is 0, there is no versioning
# information conveyed. The Map-Version Number can be included in
# Map-Request and Map-Register messages. See Section 6.6.3 for more
# details.
if not isinstance(self.map_version, numbers.Integral) \
or self.map_version < 0 \
or self.map_version >= 2 ** 12:
raise ValueError('Invalid map version')
# EID-prefix: 4 octets if an IPv4 address-family, 16 octets if an IPv6
# address-family.
if not isinstance(self.eid_prefix, LCAFInstanceAddress):
if not isinstance(self.eid_prefix, (IPv4Network, IPv6Network)):
raise ValueError("Unexpected EID prefix %r", self.eid_prefix)
# Wrap in LCAF address with Instance ID
self.eid_prefix = LCAFInstanceAddress(instance_id=0,
address=self.eid_prefix)
# Check locator records
# The probed_locator bits aren't used in this context
for locator_record in self.locator_records:
if not isinstance(locator_record, LocatorRecord) \
or locator_record.probed_locator:
raise ValueError('Invalid Locator record')
locator_record.sanitize()
# For each Map-Reply record, the list of Locators in a Locator-Set MUST
# appear in the same order for each ETR that originates a Map-Reply
# message. The Locator-Set MUST be sorted in order of ascending IP
# address where an IPv4 locator address is considered numerically 'less
# than' an IPv6 locator address.
self.locator_records.sort(key=LocatorRecord.sort_key)
# Check signatures
for dummy in self.signatures:
# TODO: Implement signatures [LISP-Security]
pass |
def dcmanonym(
dcmpth,
displayonly=False,
patient='anonymised',
physician='anonymised',
dob='19800101',
verbose=True):
''' Anonymise DICOM file(s)
Arguments:
> dcmpth: it can be passed as a single DICOM file, or
a folder containing DICOM files, or a list of DICOM file paths.
> patient: the name of the patient.
> physician:the name of the referring physician.
> dob: patient's date of birth.
> verbose: display processing output.
'''
#> check if a single DICOM file
if isinstance(dcmpth, basestring) and os.path.isfile(dcmpth):
dcmlst = [dcmpth]
if verbose:
print 'i> recognised the input argument as a single DICOM file.'
#> check if a folder containing DICOM files
elif isinstance(dcmpth, basestring) and os.path.isdir(dcmpth):
dircontent = os.listdir(dcmpth)
#> create a list of DICOM files inside the folder
dcmlst = [os.path.join(dcmpth,d) for d in dircontent if os.path.isfile(os.path.join(dcmpth,d)) and d.endswith(dcmext)]
if verbose:
print 'i> recognised the input argument as the folder containing DICOM files.'
#> check if a folder containing DICOM files
elif isinstance(dcmpth, list):
if not all([os.path.isfile(d) and d.endswith(dcmext) for d in dcmpth]):
raise IOError('Not all files in the list are DICOM files.')
dcmlst = dcmpth
if verbose:
print 'i> recognised the input argument as the list of DICOM file paths.'
#> check if dictionary of data input <datain>
elif isinstance(dcmpth, dict) and 'corepath' in dcmpth:
dcmlst = list_dcm_datain(dcmpth)
if verbose:
print 'i> recognised the input argument as the dictionary of scanner data.'
else:
raise IOError('Unrecognised input!')
for dcmf in dcmlst:
#> read the file
dhdr = dcm.dcmread(dcmf)
#> get the basic info about the DICOM file
dcmtype = dcminfo(dhdr, verbose=False)
if verbose:
print '-------------------------------'
print 'i> the DICOM file is for:', dcmtype
#> anonymise mMR data.
if 'mmr' in dcmtype:
if [0x029, 0x1120] in dhdr and dhdr[0x029, 0x1120].name=='[CSA Series Header Info]':
csafield = dhdr[0x029, 0x1120]
csa = csafield.value
elif [0x029, 0x1020] in dhdr and dhdr[0x029, 0x1020].name=='[CSA Series Header Info]':
csafield = dhdr[0x029, 0x1020]
csa = csafield.value
else:
csa = ''
# string length considered for replacement
strlen = 200
idx = [m.start() for m in re.finditer(r'([Pp]atients{0,1}[Nn]ame)', csa)]
if idx and verbose:
print ' > found sensitive information deep in DICOM headers:', dcmtype
#> run the anonymisation
iupdate = 0
for i in idx:
ci = i - iupdate
if displayonly:
print ' > sensitive info:'
print ' ', csa[ci:ci+strlen]
continue
rplcmnt = re.sub( r'(\{\s*\"{1,2}\W*\w+\W*\w+\W*\"{1,2}\s*\})',
'{ ""' +patient+ '"" }',
csa[ci:ci+strlen]
)
#> update string
csa = csa[:ci] + rplcmnt + csa[ci+strlen:]
print ' > removed sensitive information.'
#> correct for the number of removed letters
iupdate = strlen-len(rplcmnt)
#> update DICOM
if not displayonly and csa!='':
csafield.value = csa
#> Patient's name
if [0x010,0x010] in dhdr:
if displayonly:
print ' > sensitive info:', dhdr[0x010,0x010].name
print ' ', dhdr[0x010,0x010].value
else:
dhdr[0x010,0x010].value = patient
if verbose: print ' > anonymised patients name'
#> date of birth
if [0x010,0x030] in dhdr:
if displayonly:
print ' > sensitive info:', dhdr[0x010,0x030].name
print ' ', dhdr[0x010,0x030].value
else:
dhdr[0x010,0x030].value = dob
if verbose: print ' > anonymised date of birh'
#> physician's name
if [0x008, 0x090] in dhdr:
if displayonly:
print ' > sensitive info:', dhdr[0x008,0x090].name
print ' ', dhdr[0x008,0x090].value
else:
dhdr[0x008,0x090].value = physician
if verbose: print ' > anonymised physician name'
dhdr.save_as(dcmf) | Anonymise DICOM file(s)
Arguments:
> dcmpth: it can be passed as a single DICOM file, or
a folder containing DICOM files, or a list of DICOM file paths.
> patient: the name of the patient.
> physician:the name of the referring physician.
> dob: patient's date of birth.
> verbose: display processing output. | Below is the the instruction that describes the task:
### Input:
Anonymise DICOM file(s)
Arguments:
> dcmpth: it can be passed as a single DICOM file, or
a folder containing DICOM files, or a list of DICOM file paths.
> patient: the name of the patient.
> physician:the name of the referring physician.
> dob: patient's date of birth.
> verbose: display processing output.
### Response:
def dcmanonym(
dcmpth,
displayonly=False,
patient='anonymised',
physician='anonymised',
dob='19800101',
verbose=True):
''' Anonymise DICOM file(s)
Arguments:
> dcmpth: it can be passed as a single DICOM file, or
a folder containing DICOM files, or a list of DICOM file paths.
> patient: the name of the patient.
> physician:the name of the referring physician.
> dob: patient's date of birth.
> verbose: display processing output.
'''
#> check if a single DICOM file
if isinstance(dcmpth, basestring) and os.path.isfile(dcmpth):
dcmlst = [dcmpth]
if verbose:
print 'i> recognised the input argument as a single DICOM file.'
#> check if a folder containing DICOM files
elif isinstance(dcmpth, basestring) and os.path.isdir(dcmpth):
dircontent = os.listdir(dcmpth)
#> create a list of DICOM files inside the folder
dcmlst = [os.path.join(dcmpth,d) for d in dircontent if os.path.isfile(os.path.join(dcmpth,d)) and d.endswith(dcmext)]
if verbose:
print 'i> recognised the input argument as the folder containing DICOM files.'
#> check if a folder containing DICOM files
elif isinstance(dcmpth, list):
if not all([os.path.isfile(d) and d.endswith(dcmext) for d in dcmpth]):
raise IOError('Not all files in the list are DICOM files.')
dcmlst = dcmpth
if verbose:
print 'i> recognised the input argument as the list of DICOM file paths.'
#> check if dictionary of data input <datain>
elif isinstance(dcmpth, dict) and 'corepath' in dcmpth:
dcmlst = list_dcm_datain(dcmpth)
if verbose:
print 'i> recognised the input argument as the dictionary of scanner data.'
else:
raise IOError('Unrecognised input!')
for dcmf in dcmlst:
#> read the file
dhdr = dcm.dcmread(dcmf)
#> get the basic info about the DICOM file
dcmtype = dcminfo(dhdr, verbose=False)
if verbose:
print '-------------------------------'
print 'i> the DICOM file is for:', dcmtype
#> anonymise mMR data.
if 'mmr' in dcmtype:
if [0x029, 0x1120] in dhdr and dhdr[0x029, 0x1120].name=='[CSA Series Header Info]':
csafield = dhdr[0x029, 0x1120]
csa = csafield.value
elif [0x029, 0x1020] in dhdr and dhdr[0x029, 0x1020].name=='[CSA Series Header Info]':
csafield = dhdr[0x029, 0x1020]
csa = csafield.value
else:
csa = ''
# string length considered for replacement
strlen = 200
idx = [m.start() for m in re.finditer(r'([Pp]atients{0,1}[Nn]ame)', csa)]
if idx and verbose:
print ' > found sensitive information deep in DICOM headers:', dcmtype
#> run the anonymisation
iupdate = 0
for i in idx:
ci = i - iupdate
if displayonly:
print ' > sensitive info:'
print ' ', csa[ci:ci+strlen]
continue
rplcmnt = re.sub( r'(\{\s*\"{1,2}\W*\w+\W*\w+\W*\"{1,2}\s*\})',
'{ ""' +patient+ '"" }',
csa[ci:ci+strlen]
)
#> update string
csa = csa[:ci] + rplcmnt + csa[ci+strlen:]
print ' > removed sensitive information.'
#> correct for the number of removed letters
iupdate = strlen-len(rplcmnt)
#> update DICOM
if not displayonly and csa!='':
csafield.value = csa
#> Patient's name
if [0x010,0x010] in dhdr:
if displayonly:
print ' > sensitive info:', dhdr[0x010,0x010].name
print ' ', dhdr[0x010,0x010].value
else:
dhdr[0x010,0x010].value = patient
if verbose: print ' > anonymised patients name'
#> date of birth
if [0x010,0x030] in dhdr:
if displayonly:
print ' > sensitive info:', dhdr[0x010,0x030].name
print ' ', dhdr[0x010,0x030].value
else:
dhdr[0x010,0x030].value = dob
if verbose: print ' > anonymised date of birh'
#> physician's name
if [0x008, 0x090] in dhdr:
if displayonly:
print ' > sensitive info:', dhdr[0x008,0x090].name
print ' ', dhdr[0x008,0x090].value
else:
dhdr[0x008,0x090].value = physician
if verbose: print ' > anonymised physician name'
dhdr.save_as(dcmf) |
def distribute(n, iterable):
"""Distribute the items from *iterable* among *n* smaller iterables.
>>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
>>> list(group_1)
[1, 3, 5]
>>> list(group_2)
[2, 4, 6]
If the length of *iterable* is not evenly divisible by *n*, then the
length of the returned iterables will not be identical:
>>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
>>> [list(c) for c in children]
[[1, 4, 7], [2, 5], [3, 6]]
If the length of *iterable* is smaller than *n*, then the last returned
iterables will be empty:
>>> children = distribute(5, [1, 2, 3])
>>> [list(c) for c in children]
[[1], [2], [3], [], []]
This function uses :func:`itertools.tee` and may require significant
storage. If you need the order items in the smaller iterables to match the
original iterable, see :func:`divide`.
"""
if n < 1:
raise ValueError('n must be at least 1')
children = tee(iterable, n)
return [islice(it, index, None, n) for index, it in enumerate(children)] | Distribute the items from *iterable* among *n* smaller iterables.
>>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
>>> list(group_1)
[1, 3, 5]
>>> list(group_2)
[2, 4, 6]
If the length of *iterable* is not evenly divisible by *n*, then the
length of the returned iterables will not be identical:
>>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
>>> [list(c) for c in children]
[[1, 4, 7], [2, 5], [3, 6]]
If the length of *iterable* is smaller than *n*, then the last returned
iterables will be empty:
>>> children = distribute(5, [1, 2, 3])
>>> [list(c) for c in children]
[[1], [2], [3], [], []]
This function uses :func:`itertools.tee` and may require significant
storage. If you need the order items in the smaller iterables to match the
original iterable, see :func:`divide`. | Below is the the instruction that describes the task:
### Input:
Distribute the items from *iterable* among *n* smaller iterables.
>>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
>>> list(group_1)
[1, 3, 5]
>>> list(group_2)
[2, 4, 6]
If the length of *iterable* is not evenly divisible by *n*, then the
length of the returned iterables will not be identical:
>>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
>>> [list(c) for c in children]
[[1, 4, 7], [2, 5], [3, 6]]
If the length of *iterable* is smaller than *n*, then the last returned
iterables will be empty:
>>> children = distribute(5, [1, 2, 3])
>>> [list(c) for c in children]
[[1], [2], [3], [], []]
This function uses :func:`itertools.tee` and may require significant
storage. If you need the order items in the smaller iterables to match the
original iterable, see :func:`divide`.
### Response:
def distribute(n, iterable):
"""Distribute the items from *iterable* among *n* smaller iterables.
>>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
>>> list(group_1)
[1, 3, 5]
>>> list(group_2)
[2, 4, 6]
If the length of *iterable* is not evenly divisible by *n*, then the
length of the returned iterables will not be identical:
>>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
>>> [list(c) for c in children]
[[1, 4, 7], [2, 5], [3, 6]]
If the length of *iterable* is smaller than *n*, then the last returned
iterables will be empty:
>>> children = distribute(5, [1, 2, 3])
>>> [list(c) for c in children]
[[1], [2], [3], [], []]
This function uses :func:`itertools.tee` and may require significant
storage. If you need the order items in the smaller iterables to match the
original iterable, see :func:`divide`.
"""
if n < 1:
raise ValueError('n must be at least 1')
children = tee(iterable, n)
return [islice(it, index, None, n) for index, it in enumerate(children)] |
def resource_request_encode(self, request_id, uri_type, uri, transfer_type, storage):
'''
The autopilot is requesting a resource (file, binary, other type of
data)
request_id : Request ID. This ID should be re-used when sending back URI contents (uint8_t)
uri_type : The type of requested URI. 0 = a file via URL. 1 = a UAVCAN binary (uint8_t)
uri : The requested unique resource identifier (URI). It is not necessarily a straight domain name (depends on the URI type enum) (uint8_t)
transfer_type : The way the autopilot wants to receive the URI. 0 = MAVLink FTP. 1 = binary stream. (uint8_t)
storage : The storage path the autopilot wants the URI to be stored in. Will only be valid if the transfer_type has a storage associated (e.g. MAVLink FTP). (uint8_t)
'''
return MAVLink_resource_request_message(request_id, uri_type, uri, transfer_type, storage) | The autopilot is requesting a resource (file, binary, other type of
data)
request_id : Request ID. This ID should be re-used when sending back URI contents (uint8_t)
uri_type : The type of requested URI. 0 = a file via URL. 1 = a UAVCAN binary (uint8_t)
uri : The requested unique resource identifier (URI). It is not necessarily a straight domain name (depends on the URI type enum) (uint8_t)
transfer_type : The way the autopilot wants to receive the URI. 0 = MAVLink FTP. 1 = binary stream. (uint8_t)
storage : The storage path the autopilot wants the URI to be stored in. Will only be valid if the transfer_type has a storage associated (e.g. MAVLink FTP). (uint8_t) | Below is the the instruction that describes the task:
### Input:
The autopilot is requesting a resource (file, binary, other type of
data)
request_id : Request ID. This ID should be re-used when sending back URI contents (uint8_t)
uri_type : The type of requested URI. 0 = a file via URL. 1 = a UAVCAN binary (uint8_t)
uri : The requested unique resource identifier (URI). It is not necessarily a straight domain name (depends on the URI type enum) (uint8_t)
transfer_type : The way the autopilot wants to receive the URI. 0 = MAVLink FTP. 1 = binary stream. (uint8_t)
storage : The storage path the autopilot wants the URI to be stored in. Will only be valid if the transfer_type has a storage associated (e.g. MAVLink FTP). (uint8_t)
### Response:
def resource_request_encode(self, request_id, uri_type, uri, transfer_type, storage):
'''
The autopilot is requesting a resource (file, binary, other type of
data)
request_id : Request ID. This ID should be re-used when sending back URI contents (uint8_t)
uri_type : The type of requested URI. 0 = a file via URL. 1 = a UAVCAN binary (uint8_t)
uri : The requested unique resource identifier (URI). It is not necessarily a straight domain name (depends on the URI type enum) (uint8_t)
transfer_type : The way the autopilot wants to receive the URI. 0 = MAVLink FTP. 1 = binary stream. (uint8_t)
storage : The storage path the autopilot wants the URI to be stored in. Will only be valid if the transfer_type has a storage associated (e.g. MAVLink FTP). (uint8_t)
'''
return MAVLink_resource_request_message(request_id, uri_type, uri, transfer_type, storage) |
def enable_command(self, command: str) -> None:
"""
Enable a command by restoring its functions
:param command: the command being enabled
"""
# If the commands is already enabled, then return
if command not in self.disabled_commands:
return
help_func_name = HELP_FUNC_PREFIX + command
# Restore the command and help functions to their original values
dc = self.disabled_commands[command]
setattr(self, self.cmd_func_name(command), dc.command_function)
if dc.help_function is None:
delattr(self, help_func_name)
else:
setattr(self, help_func_name, dc.help_function)
# Remove the disabled command entry
del self.disabled_commands[command] | Enable a command by restoring its functions
:param command: the command being enabled | Below is the the instruction that describes the task:
### Input:
Enable a command by restoring its functions
:param command: the command being enabled
### Response:
def enable_command(self, command: str) -> None:
"""
Enable a command by restoring its functions
:param command: the command being enabled
"""
# If the commands is already enabled, then return
if command not in self.disabled_commands:
return
help_func_name = HELP_FUNC_PREFIX + command
# Restore the command and help functions to their original values
dc = self.disabled_commands[command]
setattr(self, self.cmd_func_name(command), dc.command_function)
if dc.help_function is None:
delattr(self, help_func_name)
else:
setattr(self, help_func_name, dc.help_function)
# Remove the disabled command entry
del self.disabled_commands[command] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.