text
stringlengths 78
104k
| score
float64 0
0.18
|
|---|---|
def _add_fluent_indexes(self):
"""
Add the index commands fluently specified on columns:
"""
for column in self._columns:
for index in ['primary', 'unique', 'index']:
column_index = column.get(index)
if column_index is True:
getattr(self, index)(column.name)
break
elif column_index:
getattr(self, index)(column.name, column_index)
break | 0.003906 |
def object_build_class(node, member, localname):
"""create astroid for a living class object"""
basenames = [base.__name__ for base in member.__bases__]
return _base_class_object_build(node, member, basenames, localname=localname) | 0.008264 |
def add(self, doc):
"""Add a doc's annotations to the binder for serialization."""
array = doc.to_array(self.attrs)
if len(array.shape) == 1:
array = array.reshape((array.shape[0], 1))
self.tokens.append(array)
spaces = doc.to_array(SPACY)
assert array.shape[0] == spaces.shape[0]
spaces = spaces.reshape((spaces.shape[0], 1))
self.spaces.append(numpy.asarray(spaces, dtype=bool))
self.strings.update(w.text for w in doc) | 0.00396 |
def _serial_connect(self, port, request):
'''
Handle connection request.
Parameters
----------
port : str
Device name/port.
request : dict
'''
# baudrate : int
# Baud rate such as 9600 or 115200 etc.
# bytesize : str, optional
# Number of data bits.
#
# Possible values: ``'FIVEBITS'``, ``'SIXBITS'``, ``'SEVENBITS'``,
# ``'EIGHTBITS'``.
#
# Default: ``'EIGHTBITS'``
# parity : str, optional
# Enable parity checking.
#
# Possible values: ``'PARITY_NONE'``, ``'PARITY_EVEN'``, ``'PARITY_ODD'``,
# ``'PARITY_MARK'``, ``'PARITY_SPACE'``.
#
# Default: ``'PARITY_NONE'``
# stopbits : str, optional
# Number of stop bits.
#
# Possible values: STOPBITS_ONE, STOPBITS_ONE_POINT_FIVE, STOPBITS_TWO
# xonxoff : bool, optional
# Enable software flow control.
#
# Default: ``False``
# rtscts : bool, optional
# Enable hardware (RTS/CTS) flow control.
#
# Default: ``False``
# dsrdtr : bool, optional
# Enable hardware (DSR/DTR) flow control.
#
# Default: ``False``
command = 'connect'
if port in self.open_devices:
logger.debug('Already connected to: `%s`', port)
self._publish_status(port)
return
# TODO Write JSON schema definition for valid connect request.
if 'baudrate' not in request:
logger.error('Invalid `%s` request: `baudrate` must be '
'specified.', command)
return
if 'bytesize' in request:
try:
bytesize = getattr(serial, request['bytesize'])
if not bytesize in serial.Serial.BYTESIZES:
logger.error('`%s` request: `bytesize` `%s` not '
'available on current platform.', command,
request['bytesize'])
return
except AttributeError as exception:
logger.error('`%s` request: invalid `bytesize`, `%s`', command,
request['bytesize'])
return
else:
bytesize = serial.EIGHTBITS
if 'parity' in request:
try:
parity = getattr(serial, request['parity'])
if not parity in serial.Serial.PARITIES:
logger.error('`%s` request: `parity` `%s` not available '
'on current platform.', command,
request['parity'])
return
except AttributeError as exception:
logger.error('`%s` request: invalid `parity`, `%s`', command,
request['parity'])
return
else:
parity = serial.PARITY_NONE
if 'stopbits' in request:
try:
stopbits = getattr(serial, request['stopbits'])
if not stopbits in serial.Serial.STOPBITS:
logger.error('`%s` request: `stopbits` `%s` not '
'available on current platform.', command,
request['stopbits'])
return
except AttributeError as exception:
logger.error('`%s` request: invalid `stopbits`, `%s`', command,
request['stopbits'])
return
else:
stopbits = serial.STOPBITS_ONE
try:
baudrate = int(request['baudrate'])
xonxoff = bool(request.get('xonxoff'))
rtscts = bool(request.get('rtscts'))
dsrdtr = bool(request.get('dsrdtr'))
except TypeError as exception:
logger.error('`%s` request: %s', command, exception)
return
try:
device = serial.serial_for_url(port, baudrate=baudrate,
bytesize=bytesize, parity=parity,
stopbits=stopbits, xonxoff=xonxoff,
rtscts=rtscts, dsrdtr=dsrdtr)
parent = self
class PassThroughProtocol(serial.threaded.Protocol):
PORT = port
def connection_made(self, transport):
"""Called when reader thread is started"""
parent.open_devices[port] = transport
parent._publish_status(self.PORT)
def data_received(self, data):
"""Called with snippets received from the serial port"""
parent.mqtt_client.publish(topic='serial_device/%s/received'
% self.PORT, payload=data)
def connection_lost(self, exception):
"""\
Called when the serial port is closed or the reader loop terminated
otherwise.
"""
if isinstance(exception, Exception):
logger.error('Connection to port `%s` lost: %s',
self.PORT, exception)
del parent.open_devices[self.PORT]
parent._publish_status(self.PORT)
reader_thread = serial.threaded.ReaderThread(device,
PassThroughProtocol)
reader_thread.start()
reader_thread.connect()
except Exception as exception:
logger.error('`%s` request: %s', command, exception)
return | 0.001677 |
def registered_aliases(self):
"""Return the registered aliases exposed in BUILD files.
These returned aliases aren't so useful for actually parsing BUILD files.
They are useful for generating things like http://pantsbuild.github.io/build_dictionary.html.
:returns: A new BuildFileAliases instance containing this BuildConfiguration's registered alias
mappings.
:rtype: :class:`pants.build_graph.build_file_aliases.BuildFileAliases`
"""
target_factories_by_alias = self._target_by_alias.copy()
target_factories_by_alias.update(self._target_macro_factory_by_alias)
return BuildFileAliases(
targets=target_factories_by_alias,
objects=self._exposed_object_by_alias.copy(),
context_aware_object_factories=self._exposed_context_aware_object_factory_by_alias.copy()
) | 0.004762 |
def measure_torsion_angles(residues):
"""Calculates the dihedral angles for a list of backbone atoms.
Parameters
----------
residues : [ampal.Residue]
List of `Residue` objects.
Returns
-------
torsion_angles : (float, float, float)
One triple for each residue, containing torsion angles in
the range [-pi, pi].
[0] omega
[1] phi
[2] psi
For the first residue, omega and phi are not defined. For
the final residue, psi is not defined.
Raises
------
ValueError
If the number of input residues is less than 2.
"""
if len(residues) < 2:
torsion_angles = [(None, None, None)] * len(residues)
else:
torsion_angles = []
for i in range(len(residues)):
if i == 0:
res1 = residues[i]
res2 = residues[i + 1]
omega = None
phi = None
try:
psi = dihedral(
res1['N']._vector, res1['CA']._vector,
res1['C']._vector, res2['N']._vector)
except KeyError as k:
print("{0} atom missing - can't assign psi".format(k))
psi = None
torsion_angles.append((omega, phi, psi))
elif i == len(residues) - 1:
res1 = residues[i - 1]
res2 = residues[i]
try:
omega = dihedral(
res1['CA']._vector, res1['C']._vector,
res2['N']._vector, res2['CA']._vector)
except KeyError as k:
print("{0} atom missing - can't assign omega".format(k))
omega = None
try:
phi = dihedral(
res1['C']._vector, res2['N']._vector,
res2['CA']._vector, res2['C']._vector)
except KeyError as k:
print("{0} atom missing - can't assign phi".format(k))
phi = None
psi = None
torsion_angles.append((omega, phi, psi))
else:
res1 = residues[i - 1]
res2 = residues[i]
res3 = residues[i + 1]
try:
omega = dihedral(
res1['CA']._vector, res1['C']._vector,
res2['N']._vector, res2['CA']._vector)
except KeyError as k:
print("{0} atom missing - can't assign omega".format(k))
omega = None
try:
phi = dihedral(
res1['C']._vector, res2['N']._vector,
res2['CA']._vector, res2['C']._vector)
except KeyError as k:
print("{0} atom missing - can't assign phi".format(k))
phi = None
try:
psi = dihedral(
res2['N']._vector, res2['CA']._vector,
res2['C']._vector, res3['N']._vector)
except KeyError as k:
print("{0} atom missing - can't assign psi".format(k))
psi = None
torsion_angles.append((omega, phi, psi))
return torsion_angles | 0.000294 |
def make_content_node(channeldir, rel_path, filename, metadata):
"""
Create ContentNode based on the file extention and metadata provided.
"""
file_key, file_ext = os.path.splitext(filename)
ext = file_ext[1:]
kind = None
if ext in content_kinds.MAPPING:
kind = content_kinds.MAPPING[ext] # guess what kind based on file extension
elif 'questions' in metadata:
kind = content_kinds.EXERCISE
else:
raise ValueError('Could not find kind for extension ' + str(ext) + ' in content_kinds.MAPPING')
# Extract metadata fields
source_id = metadata.get('source_id', None)
if source_id is None:
source_id = metadata['chan_path']
filepath = os.path.join(rel_path, filename)
title = metadata['title']
description = metadata.get('description', None)
author = metadata.get('author', None)
lang = metadata.get('language', None)
license_dict = metadata.get('license', None)
thumbnail_chan_path = metadata.get('thumbnail_chan_path', None)
if thumbnail_chan_path:
thumbnail_rel_path = rel_path_from_chan_path(thumbnail_chan_path, channeldir)
else:
thumbnail_rel_path = None
if kind == VIDEO_NODE:
content_node = dict(
kind=VIDEO_NODE,
source_id=source_id,
title=title,
author=author,
description=description,
language=lang,
license=license_dict,
derive_thumbnail=True, # video-specific option
thumbnail=thumbnail_rel_path,
files=[{'file_type':VIDEO_FILE, 'path':filepath, 'language':lang}], # ffmpeg_settings={"crf": 24},
)
elif kind == AUDIO_NODE:
content_node = dict(
kind=AUDIO_NODE,
source_id=source_id,
title=title,
author=author,
description=description,
language=lang,
license=license_dict,
thumbnail=thumbnail_rel_path,
files=[{'file_type':AUDIO_FILE, 'path':filepath, 'language':lang}],
)
elif kind == DOCUMENT_NODE:
content_node = dict(
kind=DOCUMENT_NODE,
source_id=source_id,
title=title,
author=author,
description=description,
language=lang,
license=license_dict,
thumbnail=thumbnail_rel_path,
files=[]
)
if ext == 'pdf':
pdf_file = {
'file_type':DOCUMENT_FILE,
'path':filepath,
'language':lang
}
content_node['files'].append(pdf_file)
elif ext == 'epub':
epub_file = {
'file_type':EPUB_FILE,
'path':filepath,
'language':lang
}
content_node['files'].append(epub_file)
else:
raise ValueError('Ext {} not supported for kind {}'.format(ext, kind))
elif kind == HTML5_NODE:
content_node = dict(
kind=HTML5_NODE,
source_id=source_id,
title=title,
author=author,
description=description,
language=lang,
license=license_dict,
thumbnail=thumbnail_rel_path,
files=[{'file_type':HTML5_FILE, 'path':filepath, 'language':lang}],
)
elif kind == EXERCISE_NODE:
content_node = dict(
kind=EXERCISE_NODE,
source_id=source_id,
title=title,
author=author,
description=description,
language=lang,
license=license_dict,
exercise_data=metadata['exercise_data'],
questions=metadata['questions'],
thumbnail=thumbnail_rel_path,
files=[],
)
else:
raise ValueError('Not implemented case for kind ' + str(kind))
return content_node | 0.00609 |
def start_workunit(self, workunit):
"""Implementation of Reporter callback."""
if not self.is_under_main_root(workunit):
return
label_format = self._get_label_format(workunit)
if label_format == LabelFormat.FULL:
if not WorkUnitLabel.SUPPRESS_LABEL in workunit.labels:
self._emit_indented_workunit_label(workunit)
# Start output on a new line.
tool_output_format = self._get_tool_output_format(workunit)
if tool_output_format == ToolOutputFormat.INDENT:
self.emit(self._prefix(workunit, '\n'))
elif tool_output_format == ToolOutputFormat.UNINDENTED:
self.emit('\n')
elif label_format == LabelFormat.DOT:
self.emit('.')
self.flush() | 0.012431 |
def get_me(self, *args, **kwargs):
"""See :func:`get_me`"""
return get_me(*args, **self._merge_overrides(**kwargs)).run() | 0.014599 |
def any(pred: Callable, xs: Iterable):
"""
Check if at least one element of the iterable `xs`
fullfills predicate `pred`.
:param pred:
predicate function.
:param xs:
iterable object.
:returns: boolean
"""
b = find_first(pred, xs)
return True if b is not None else False | 0.003115 |
def partial_ratio(s1, s2):
""""Return the ratio of the most similar substring
as a number between 0 and 100."""
s1, s2 = utils.make_type_consistent(s1, s2)
if len(s1) <= len(s2):
shorter = s1
longer = s2
else:
shorter = s2
longer = s1
m = SequenceMatcher(None, shorter, longer)
blocks = m.get_matching_blocks()
# each block represents a sequence of matching characters in a string
# of the form (idx_1, idx_2, len)
# the best partial match will block align with at least one of those blocks
# e.g. shorter = "abcd", longer = XXXbcdeEEE
# block = (1,3,3)
# best score === ratio("abcd", "Xbcd")
scores = []
for block in blocks:
long_start = block[1] - block[0] if (block[1] - block[0]) > 0 else 0
long_end = long_start + len(shorter)
long_substr = longer[long_start:long_end]
m2 = SequenceMatcher(None, shorter, long_substr)
r = m2.ratio()
if r > .995:
return 100
else:
scores.append(r)
return utils.intr(100 * max(scores)) | 0.000903 |
def gaps(args):
"""
%prog gaps A_vs_B.blast
Find distribution of gap sizes betwen adjacent HSPs.
"""
p = OptionParser(gaps.__doc__)
opts, args = p.parse_args(args)
if len(args) != 1:
sys.exit(not p.print_help())
blastfile, = args
blast = BlastSlow(blastfile)
logging.debug("A total of {} records imported".format(len(blast)))
query_gaps = list(collect_gaps(blast))
subject_gaps = list(collect_gaps(blast, use_subject=True))
logging.debug("Query gaps: {} Subject gaps: {}"\
.format(len(query_gaps), len(subject_gaps)))
from jcvi.graphics.base import savefig
import seaborn as sns
sns.distplot(query_gaps)
savefig("query_gaps.pdf") | 0.004098 |
def append(self, key, value):
"""Adds a (name, value) pair, doesn't overwrite the value if it already
exists."""
self.__items.append((key, value))
try:
dict_getitem(self, key).append(value)
except KeyError:
dict_setitem(self, key, [value]) | 0.006579 |
def upgradedb(options):
"""
Add 'fake' data migrations for existing tables from legacy GeoNode versions
"""
version = options.get('version')
if version in ['1.1', '1.2']:
sh("python manage.py migrate maps 0001 --fake")
sh("python manage.py migrate avatar 0001 --fake")
elif version is None:
print "Please specify your GeoNode version"
else:
print "Upgrades from version %s are not yet supported." % version | 0.002146 |
def _save_feed(cls, conf, benchmarks, data, revisions, revision_to_hash):
"""
Save the results as an Atom feed
"""
filename = os.path.join(conf.html_dir, 'regressions.xml')
# Determine publication date as the date when the benchmark
# was run --- if it is missing, use the date of the commit
run_timestamps = {}
revision_timestamps = {}
for results in iter_results(conf.results_dir):
if results.commit_hash not in revisions:
# revisions could be filtered when specifying a range
# in 'asv publish'
continue
revision = revisions[results.commit_hash]
revision_timestamps[revision] = results.date
# Time when the benchmark was run
for benchmark_name, timestamp in six.iteritems(results.ended_at):
key = (benchmark_name, revision)
run_timestamps[key] = timestamp
# Fallback to commit date
for benchmark_name in results.get_result_keys(benchmarks):
key = (benchmark_name, revision)
run_timestamps.setdefault(key, results.date)
# Generate feed entries
entries = []
for name, graph_path, graph_params, idx, last_value, best_value, jumps in data:
if '(' in name:
benchmark_name = name[:name.index('(')]
else:
benchmark_name = name
benchmark = benchmarks[benchmark_name]
if idx is not None:
graph_params = dict(graph_params)
# Add URL parameters
param_values, = itertools.islice(itertools.product(*benchmark['params']),
idx, idx + 1)
for k, v in zip(benchmark['param_names'], param_values):
graph_params['p-' + k] = v
for rev1, rev2, value1, value2 in jumps:
timestamps = (run_timestamps[benchmark_name, t] for t in (rev1, rev2) if t is not None)
last_timestamp = max(timestamps)
updated = datetime.datetime.fromtimestamp(last_timestamp/1000)
params = dict(graph_params)
if rev1 is None:
params['commits'] = '{0}'.format(revision_to_hash[rev2])
else:
params['commits'] = '{0}-{1}'.format(revision_to_hash[rev1],
revision_to_hash[rev2])
link = 'index.html#{0}?{1}'.format(benchmark_name, urlencode(params))
try:
best_percentage = "{0:.2f}%".format(100 * (last_value - best_value) / best_value)
except ZeroDivisionError:
best_percentage = "{0:.2g} units".format(last_value - best_value)
try:
percentage = "{0:.2f}%".format(100 * (value2 - value1) / value1)
except ZeroDivisionError:
percentage = "{0:.2g} units".format(value2 - value1)
jump_date = datetime.datetime.fromtimestamp(revision_timestamps[rev2]/1000)
jump_date_str = jump_date.strftime('%Y-%m-%d %H:%M:%S')
if rev1 is not None:
commit_a = revision_to_hash[rev1]
commit_b = revision_to_hash[rev2]
if 'github.com' in conf.show_commit_url:
commit_url = conf.show_commit_url + '../compare/' + commit_a + "..." + commit_b
else:
commit_url = conf.show_commit_url + commit_a
commit_ref = 'in commits <a href="{0}">{1}...{2}</a>'.format(commit_url,
commit_a[:8],
commit_b[:8])
else:
commit_a = revision_to_hash[rev2]
commit_url = conf.show_commit_url + commit_a
commit_ref = 'in commit <a href="{0}">{1}</a>'.format(commit_url, commit_a[:8])
unit = benchmark.get('unit', '')
best_value_str = util.human_value(best_value, unit)
last_value_str = util.human_value(last_value, unit)
value1_str = util.human_value(value1, unit)
value2_str = util.human_value(value2, unit)
title = "{percentage} {name}".format(**locals())
summary = """
<a href="{link}">{percentage} regression</a> on {jump_date_str} {commit_ref}.<br>
New value: {value2_str}, old value: {value1_str}.<br>
Latest value: {last_value_str} ({best_percentage} worse than best value {best_value_str}).
""".format(**locals()).strip()
# Information that uniquely identifies a regression
# --- if the values and the texts change on later
# runs, feed readers should is identify the regression
# as the same one, as long as the benchmark name and
# commits match.
id_context = [name, revision_to_hash.get(rev1, ""), revision_to_hash.get(rev2, "")]
entries.append(feed.FeedEntry(title, updated, link, summary, id_context))
entries.sort(key=lambda x: x.updated, reverse=True)
feed.write_atom(filename, entries,
title='{0} performance regressions'.format(conf.project),
author='Airspeed Velocity',
address='{0}.asv'.format(conf.project)) | 0.003839 |
def _proxy(self):
"""
Generate an instance context for the instance, the context is capable of
performing various actions. All instance actions are proxied to the context
:returns: ActivityContext for this ActivityInstance
:rtype: twilio.rest.taskrouter.v1.workspace.activity.ActivityContext
"""
if self._context is None:
self._context = ActivityContext(
self._version,
workspace_sid=self._solution['workspace_sid'],
sid=self._solution['sid'],
)
return self._context | 0.006623 |
def tile_to_pixel(tile, centered=False):
"""Transform tile to pixel coordinates"""
pixel = [tile[0] * 256, tile[1] * 256]
if centered:
# should clip on max map size
pixel = [pix + 128 for pix in pixel]
return pixel[0], pixel[1] | 0.007067 |
def _check_ver(pyver, op, wanted):
'''
>>> _check_ver('2.7.15', 'gt', '2.7')
True
>>> _check_ver('2.7.15', 'gt', '2.7.15')
False
>>> _check_ver('2.7.15', 'ge', '2.7.15')
True
>>> _check_ver('2.7.15', 'eq', '2.7.15')
True
'''
pyver = distutils.version.LooseVersion(pyver)
wanted = distutils.version.LooseVersion(wanted)
return getattr(operator, '__{}__'.format(op))(pyver, wanted) | 0.00232 |
def register_module_classes(yaml: ruamel.yaml.YAML, modules: Optional[Iterable[Any]] = None) -> ruamel.yaml.YAML:
""" Register all classes in the given modules with the YAML object.
This is a simple helper function.
"""
# Validation
if modules is None:
modules = []
# Extract the classes from the modules
classes_to_register = set()
for module in modules:
module_classes = [member[1] for member in inspect.getmembers(module, inspect.isclass)]
classes_to_register.update(module_classes)
# Register the extracted classes
return register_classes(yaml = yaml, classes = classes_to_register) | 0.01072 |
def insertOutputModuleConfig(self, remoteConfig, migration=False):
"""
Insert Release version, application, parameter set hashes and the map(output module config).
"""
otptIdList = []
missingList = []
conn = self.dbi.connection()
try:
for c in remoteConfig:
cfgid = self.otptModCfgid.execute(conn, app = c["app_name"],
release_version = c["release_version"],
pset_hash = c["pset_hash"],
output_label = c["output_module_label"],
global_tag=c['global_tag'])
if cfgid <= 0 :
missingList.append(c)
else:
key = (c['app_name'] + ':' + c['release_version'] + ':' +
c['pset_hash'] + ':' +
c['output_module_label'] + ':' + c['global_tag'])
self.datasetCache['conf'][key] = cfgid
otptIdList.append(cfgid)
#print "About to set cfgid: %s" % str(cfgid)
except KeyError as ex:
if conn:conn.close()
dbsExceptionHandler("dbsException-invalid-input2", "DBSBlockInsert/insertOutputModuleConfig: \
KeyError exception: %s. " %ex.args[0], self.logger.exception,
"DBSBlockInsert/insertOutputModuleConfig: KeyError exception: %s. " %ex.args[0] )
except Exception as ex:
if conn:conn.close()
raise
if len(missingList)==0:
if conn:conn.close()
return otptIdList
#Now insert the missing configs
try:
#tran = conn.begin()
for m in missingList:
# Start a new transaction
# This is to see if we can get better results
# by committing early if we're submitting
# multiple blocks with similar features
tran = conn.begin()
#Now insert the config
# Sort out the mess
# We're having some problems with different threads
# committing different pieces at the same time
# This makes the output module config ID wrong
# Trying to catch this via exception handling on duplication
# Start a new transaction
#global_tag is now required. YG 03/08/2011
try:
cfgid = 0
if not migration:
m['create_by'] = dbsUtils().getCreateBy()
m['creation_date'] = dbsUtils().getTime()
configObj = {"release_version": m["release_version"],
"pset_hash": m["pset_hash"], "pset_name":m.get('pset_name', None),
"app_name": m["app_name"],
'output_module_label' : m['output_module_label'],
'global_tag' : m['global_tag'],
'scenario' : m.get('scenario', None),
'creation_date' : m['creation_date'],
'create_by':m['create_by']
}
self.otptModCfgin.execute(conn, configObj, tran)
tran.commit()
tran = None
except KeyError as ex:
if tran:tran.rollback()
if conn:conn.close()
dbsExceptionHandler("dbsException-invalid-input2", "DBSBlockInsert/insertOutputModuleConfig: \
KeyError exception: %s. " %ex.args[0],
self.logger.exception,
"DBSBlockInsert/insertOutputModuleConfig: KeyError exception: %s. " %ex.args[0])
except exceptions.IntegrityError as ex:
#Another job inserted it just 1/100000 second earlier than
#you!! YG 11/17/2010
if str(ex).find("ORA-00001") != -1 or str(ex).lower().find("duplicate") !=-1:
if str(ex).find("TUC_OMC_1") != -1:
#the config is already in db, get the ID later
pass
else:
#reinsert it if one or two or three of the three attributes (vresion, hash and app) are inserted
#just 1/100000 second eailer.
try:
self.otptModCfgin.execute(conn, configObj, tran)
tran.commit()
tran = None
except exceptions.IntegrityError as ex:
if (str(ex).find("ORA-00001") != -1 and str(ex).find("TUC_OMC_1"))\
or str(ex).lower().find("duplicate") != -1:
pass
else:
if tran:tran.rollback()
if conn:conn.close()
dbsExceptionHandler('dbsException-invalid-input2',
'Invalid data when insert Configure. ',
self.logger.exception,
'Invalid data when insert Configure. '+ str(ex))
elif str(ex).find("ORA-01400") > -1:
if tran:tran.rollback()
if conn:conn.close()
dbsExceptionHandler("dbsException-missing-data", "Missing data when inserting Configure. ",
self.logger.exception, str(ex))
else:
if tran:tran.rollback()
if conn:conn.close()
dbsExceptionHandler('dbsException-invalid-input2',
'Invalid data when insert Configure. ',
self.logger.exception,
'Invalid data when insert Configure. '+ str(ex))
except exceptions as ex3:
if tran:tran.rollback()
if conn:conn.close()
raise ex3
cfgid = self.otptModCfgid.execute(conn,
app = m["app_name"],
release_version = m["release_version"],
pset_hash = m["pset_hash"],
output_label = m["output_module_label"],
global_tag=m['global_tag'])
otptIdList.append(cfgid)
key = (m['app_name'] + ':' + m['release_version'] + ':' +
m['pset_hash'] + ':' +m['output_module_label'] + ':' +
m['global_tag'])
self.datasetCache['conf'][key] = cfgid
finally:
if tran:tran.rollback()
if conn:conn.close()
return otptIdList | 0.016425 |
def load_remote_trajectory(url, format=None):
'''Load a trajectory file from a remote location specified by *url*.
.. seealso:: load_remote_system
'''
from urllib import urlretrieve
filename, headers = urlretrieve(url)
load_trajectory(filename, format) | 0.007092 |
def LSR(value, amount, width):
"""
The ARM LSR (logical shift right) operation.
:param value: Value to shift
:type value: int or long or BitVec
:param int amount: How many bits to shift it.
:param int width: Width of the value
:return: Resultant value
:rtype int or BitVec
"""
if amount == 0:
return value
result, _ = LSR_C(value, amount, width)
return result | 0.002404 |
def get_chromosomes(snps):
""" Get the chromosomes of SNPs.
Parameters
----------
snps : pandas.DataFrame
Returns
-------
list
list of str chromosomes (e.g., ['1', '2', '3', 'MT'], empty list if no chromosomes
"""
if isinstance(snps, pd.DataFrame):
return list(pd.unique(snps["chrom"]))
else:
return [] | 0.00542 |
def Download(campaign=0, queue='build', email=None, walltime=8, **kwargs):
'''
Submits a cluster job to the build queue to download all TPFs for a given
campaign.
:param int campaign: The `K2` campaign to run
:param str queue: The name of the queue to submit to. Default `build`
:param str email: The email to send job status notifications to. \
Default `None`
:param int walltime: The number of hours to request. Default `8`
'''
# Figure out the subcampaign
if type(campaign) is int:
subcampaign = -1
elif type(campaign) is float:
x, y = divmod(campaign, 1)
campaign = int(x)
subcampaign = round(y * 10)
# Submit the cluster job
pbsfile = os.path.join(EVEREST_SRC, 'missions', 'k2', 'download.pbs')
str_w = 'walltime=%d:00:00' % walltime
str_v = 'EVEREST_DAT=%s,CAMPAIGN=%d,SUBCAMPAIGN=%d' % (
EVEREST_DAT, campaign, subcampaign)
if subcampaign == -1:
str_name = 'download_c%02d' % campaign
else:
str_name = 'download_c%02d.%d' % (campaign, subcampaign)
str_out = os.path.join(EVEREST_DAT, 'k2', str_name + '.log')
qsub_args = ['qsub', pbsfile,
'-q', queue,
'-v', str_v,
'-o', str_out,
'-j', 'oe',
'-N', str_name,
'-l', str_w]
if email is not None:
qsub_args.append(['-M', email, '-m', 'ae'])
# Now we submit the job
print("Submitting the job...")
subprocess.call(qsub_args) | 0.000646 |
def query_by_tag(cat_id, kind='1'):
'''
Query recent posts of catalog.
'''
return TabPost.select().join(
TabPost2Tag,
on=(TabPost.uid == TabPost2Tag.post_id)
).where(
(TabPost.kind == kind) &
(TabPost2Tag.tag_id == cat_id)
).order_by(
TabPost.time_create.desc()
) | 0.005263 |
def leaveEvent( self, event ):
"""
Toggles the display for the tracker item.
"""
item = self.trackerItem()
if ( item ):
item.setVisible(False) | 0.03 |
def get_from_sources(self, index, doc_type, document_id):
"""Get source stored locally"""
return self.sources.get(index, {}).get(doc_type, {}).get(document_id, {}) | 0.01676 |
def set_ssl_logging(self, enable=False, func=_ssl_logging_cb):
u''' Enable or disable SSL logging
:param True | False enable: Enable or disable SSL logging
:param func: Callback function for logging
'''
if enable:
SSL_CTX_set_info_callback(self._ctx, func)
else:
SSL_CTX_set_info_callback(self._ctx, 0) | 0.005333 |
def record(self):
# type: () -> bytes
'''
A method to generate the string representing this UDF NSR Volume
Structure.
Parameters:
None.
Returns:
A string representing this UDF BEA Volume Strucutre.
'''
if not self._initialized:
raise pycdlibexception.PyCdlibInternalError('UDF NSR Volume Structure not initialized')
return struct.pack(self.FMT, 0, self.standard_ident, 1, b'\x00' * 2041) | 0.008163 |
def intervals_to_fragment_list(self, text_file, time_values):
"""
Transform a list of at least 4 time values
(corresponding to at least 3 intervals)
into a sync map fragment list and store it internally.
The first interval is a HEAD, the last is a TAIL.
For example:
time_values=[0.000, 1.000, 2.000, 3.456] => [(0.000, 1.000), (1.000, 2.000), (2.000, 3.456)]
:param text_file: the text file containing the text fragments associated
:type text_file: :class:`~aeneas.textfile.TextFile`
:param time_values: the time values
:type time_values: list of :class:`~aeneas.exacttiming.TimeValue`
:raises: TypeError: if ``text_file`` is not an instance of :class:`~aeneas.textfile.TextFile`
or ``time_values`` is not a list
:raises: ValueError: if ``time_values`` has length less than four
"""
if not isinstance(text_file, TextFile):
self.log_exc(u"text_file is not an instance of TextFile", None, True, TypeError)
if not isinstance(time_values, list):
self.log_exc(u"time_values is not a list", None, True, TypeError)
if len(time_values) < 4:
self.log_exc(u"time_values has length < 4", None, True, ValueError)
self.log(u"Converting time values to fragment list...")
begin = time_values[0]
end = time_values[-1]
self.log([u" Creating SyncMapFragmentList with begin %.3f and end %.3f", begin, end])
self.smflist = SyncMapFragmentList(
begin=begin,
end=end,
rconf=self.rconf,
logger=self.logger
)
self.log(u" Creating HEAD fragment")
self.smflist.add(SyncMapFragment(
# NOTE lines and filtered lines MUST be set,
# otherwise some output format might break
# when adding HEAD/TAIL to output
text_fragment=TextFragment(identifier=u"HEAD", lines=[], filtered_lines=[]),
begin=time_values[0],
end=time_values[1],
fragment_type=SyncMapFragment.HEAD
), sort=False)
self.log(u" Creating REGULAR fragments")
# NOTE text_file.fragments() returns a list,
# so we cache a copy here instead of
# calling it once per loop
fragments = text_file.fragments
for i in range(1, len(time_values) - 2):
self.log([u" Adding fragment %d ...", i])
self.smflist.add(SyncMapFragment(
text_fragment=fragments[i - 1],
begin=time_values[i],
end=time_values[i + 1],
fragment_type=SyncMapFragment.REGULAR
), sort=False)
self.log([u" Adding fragment %d ... done", i])
self.log(u" Creating TAIL fragment")
self.smflist.add(SyncMapFragment(
# NOTE lines and filtered lines MUST be set,
# otherwise some output format might break
# when adding HEAD/TAIL to output
text_fragment=TextFragment(identifier=u"TAIL", lines=[], filtered_lines=[]),
begin=time_values[len(time_values) - 2],
end=end,
fragment_type=SyncMapFragment.TAIL
), sort=False)
self.log(u"Converting time values to fragment list... done")
self.log(u"Sorting fragment list...")
self.smflist.sort()
self.log(u"Sorting fragment list... done")
return self.smflist | 0.002545 |
def _convert_date(self, date):
"""Convert '106/05/01' to '2017/05/01'"""
return '/'.join([str(int(date.split('/')[0]) + 1911)] + date.split('/')[1:]) | 0.018182 |
def flush_ct_inventory(self):
"""internal method used only if ct_inventory is enabled
"""
if hasattr(self, '_ct_inventory'):
# skip self from update
self._ct_inventory = None
self.update_view = False
self.save() | 0.007042 |
def build_plane_arrays(x, y, qlist):
"""Build a 2-D array out of data taken in the same plane, for contour
plotting.
"""
if type(qlist) is not list:
return_list = False
qlist = [qlist]
else:
return_list = True
xv = x[np.where(y==y[0])[0]]
yv = y[np.where(x==x[0])[0]]
qlistp = []
for n in range(len(qlist)):
qlistp.append(np.zeros((len(yv), len(xv))))
for j in range(len(qlist)):
for n in range(len(yv)):
i = np.where(y==yv[n])[0]
qlistp[j][n,:] = qlist[j][i]
if not return_list:
qlistp = qlistp[0]
return xv, yv, qlistp | 0.007576 |
def display(self):
"""A unicode value with the object's data, to be used for displaying
the object in your application."""
if self.title and self.organization:
disp = self.title + u' at ' + self.organization
else:
disp = self.title or self.organization or None
if disp and self.industry:
if self.date_range is not None:
disp += u' (%s, %d-%d)' % ((self.industry,) + \
self.date_range.years_range)
else:
disp += u' (%s)' % self.industry
else:
disp = ((disp or u'') + u' ' + (self.industry or u'')).strip()
if disp and self.date_range is not None:
disp += u' (%d-%d)' % self.date_range.years_range
return disp | 0.004739 |
def split_sequence_file_on_sample_ids_to_files(seqs,
outdir):
"""Split FASTA file on sample IDs.
Parameters
----------
seqs: file handler
file handler to demultiplexed FASTA file
outdir: string
dirpath to output split FASTA files
"""
logger = logging.getLogger(__name__)
logger.info('split_sequence_file_on_sample_ids_to_files'
' for file %s into dir %s' % (seqs, outdir))
outputs = {}
for bits in sequence_generator(seqs):
sample = sample_id_from_read_id(bits[0])
if sample not in outputs:
outputs[sample] = open(join(outdir, sample + '.fasta'), 'w')
outputs[sample].write(">%s\n%s\n" % (bits[0], bits[1]))
for sample in outputs:
outputs[sample].close()
logger.info('split to %d files' % len(outputs)) | 0.00114 |
def getlist(self, key, default=[]):
"""
Returns: The list of values for <key> if <key> is in the dictionary,
else <default>. If <default> is not provided, an empty list is
returned.
"""
if key in self:
return [node.value for node in self._map[key]]
return default | 0.006042 |
def _include_pretrained_vocab(self, pretrained_word_dict, candidates):
"""
Include terms available via pretrained embeddings
:param pretrained_word_dict:
:param candidates:
:return:
"""
terms = Counter()
for c in candidates:
for w in c.get_parent().words:
if w in pretrained_word_dict:
terms[w] += 1
list(map(self.word_dict.get, terms)) | 0.004367 |
def _guess_lines(ys, max_lines=50, confidence_minimum=0.0):
"""guesses and returns text inter-line distance, number of lines, y_position of first line"""
ys = ys.astype(numpy.float32)
compactness_list, means_list, diffs, deviations = [], [], [], []
start_n = 1
for k in range(start_n, min(len(ys), max_lines)):
compactness, classified_points, means = cv2.kmeans(data=ys, K=k, bestLabels=None, criteria=(
cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_MAX_ITER, 1, 10), attempts=2, flags=cv2.KMEANS_PP_CENTERS)
means = numpy.sort(means, axis=0)
means_list.append(means)
compactness_list.append(compactness)
if k < 3:
tmp1 = [1, 2, 500, 550] # forge data for bad clusters
else:
# calculate the center of each cluster. Assuming lines are equally spaced...
tmp1 = numpy.diff(means, axis=0) # diff will be equal or very similar
tmp2 = numpy.std(tmp1) / numpy.mean(means) # so variance is minimal
tmp3 = numpy.sum((tmp1 - numpy.mean(tmp1)) ** 2) # root mean square deviation, more sensitive than std
diffs.append(tmp1)
deviations.append(tmp3)
compactness_list = numpy.diff(
numpy.log(numpy.array(compactness_list) + 0.01)) # sum small amount to avoid log(0)
deviations = numpy.array(deviations[1:])
deviations[0] = numpy.mean(deviations[1:])
compactness_list = (compactness_list - numpy.mean(compactness_list)) / numpy.std(compactness_list)
deviations = (deviations - numpy.mean(deviations)) / numpy.std(deviations)
aglomerated_metric = 0.1 * compactness_list + 0.9 * deviations
i = numpy.argmin(aglomerated_metric) + 1
lines = means_list[i]
# calculate confidence
betterness = numpy.sort(aglomerated_metric, axis=0)
confidence = (betterness[1] - betterness[0]) / (betterness[2] - betterness[1])
if confidence < confidence_minimum:
raise Exception("low confidence")
return lines | 0.006594 |
def from_dict(data, ctx):
"""
Instantiate a new HomeConversions from a dict (generally from loading a
JSON response). The data used to instantiate the HomeConversions is a
shallow copy of the dict passed in, with any complex child types
instantiated appropriately.
"""
data = data.copy()
if data.get('accountGain') is not None:
data['accountGain'] = ctx.convert_decimal_number(
data.get('accountGain')
)
if data.get('accountLoss') is not None:
data['accountLoss'] = ctx.convert_decimal_number(
data.get('accountLoss')
)
if data.get('positionValue') is not None:
data['positionValue'] = ctx.convert_decimal_number(
data.get('positionValue')
)
return HomeConversions(**data) | 0.00226 |
def get_move_data(move):
"""Return the index number for the given move name. Check moves.json in the same directory."""
srcpath = path.dirname(__file__)
try:
f = open(path.join(srcpath, 'moves.json'), 'r')
except IOError:
get_moves()
f = open(path.join(srcpath, 'moves.json'), 'r')
finally:
with f:
return json.load(f)[move] | 0.005155 |
def finish(self):
"""
Restore the original SIGINT handler after finishing.
This should happen regardless of whether the progress display finishes
normally, or gets interrupted.
"""
super(InterruptibleMixin, self).finish()
signal(SIGINT, self.original_handler) | 0.006329 |
def get_user(self):
"""Get the user informations from the server.
:return: a dict with all the informations
:rtype: dict
raises ValueError in case of protocol issues
:Example:
>>> "creationTime": <time>,
>>> "lastUpdateTime": <time>,
>>> "userId": "<email for login>",
>>> "title": 0,
>>> "firstName": "<First>",
>>> "lastName": "<Last>",
>>> "email": "<contact email>",
>>> "phoneNumber": "<phone>",
>>> "mobilePhone": "<mobile>",
>>> "locale": "<two char country code>"
:Warning:
The type and amount of values in the dictionary can change any time.
"""
header = BASE_HEADERS.copy()
header['Cookie'] = self.__cookie
request = requests.get(BASE_URL + 'getEndUser',
headers=header,
timeout=10)
if request.status_code != 200:
self.__logged_in = False
self.login()
self.get_user()
return
try:
result = request.json()
except ValueError:
raise Exception(
"Not a valid result for getEndUser, protocol error!")
return result['endUser'] | 0.001553 |
def dataset_initialize(self, folder):
""" initialize a folder with a a dataset configuration (metadata) file
Parameters
==========
folder: the folder to initialize the metadata file in
"""
if not os.path.isdir(folder):
raise ValueError('Invalid folder: ' + folder)
ref = self.config_values[self.CONFIG_NAME_USER] + '/INSERT_SLUG_HERE'
licenses = []
default_license = {'name': 'CC0-1.0'}
licenses.append(default_license)
meta_data = {
'title': 'INSERT_TITLE_HERE',
'id': ref,
'licenses': licenses
}
meta_file = os.path.join(folder, self.DATASET_METADATA_FILE)
with open(meta_file, 'w') as f:
json.dump(meta_data, f, indent=2)
print('Data package template written to: ' + meta_file)
return meta_file | 0.00222 |
def new_stats_exporter(options=None, interval=None):
"""Get a stats exporter and running transport thread.
Create a new `StackdriverStatsExporter` with the given options and start
periodically exporting stats to stackdriver in the background.
Fall back to default auth if `options` is null. This will raise
`google.auth.exceptions.DefaultCredentialsError` if default credentials
aren't configured.
See `opencensus.metrics.transport.get_exporter_thread` for details on the
transport thread.
:type options: :class:`Options`
:param exporter: Options to pass to the exporter
:type interval: int or float
:param interval: Seconds between export calls.
:rtype: :class:`StackdriverStatsExporter`
:return: The newly-created exporter.
"""
if options is None:
_, project_id = google.auth.default()
options = Options(project_id=project_id)
if str(options.project_id).strip() == "":
raise ValueError(ERROR_BLANK_PROJECT_ID)
ci = client_info.ClientInfo(client_library_version=get_user_agent_slug())
client = monitoring_v3.MetricServiceClient(client_info=ci)
exporter = StackdriverStatsExporter(client=client, options=options)
transport.get_exporter_thread(stats.stats, exporter, interval=interval)
return exporter | 0.000758 |
def status(self):
"""
check the status of the network and the peers
:return: network_height, peer_status
"""
peer = random.choice(self.PEERS)
formatted_peer = 'http://{}:4001'.format(peer)
peerdata = requests.get(url=formatted_peer + '/api/peers/').json()['peers']
peers_status = {}
networkheight = max([x['height'] for x in peerdata])
for i in peerdata:
if 'http://{}:4001'.format(i['ip']) in self.PEERS:
peers_status.update({i['ip']: {
'height': i['height'],
'status': i['status'],
'version': i['version'],
'delay': i['delay'],
}})
return {
'network_height': networkheight,
'peer_status': peers_status
} | 0.003517 |
def addthisbunch(bunchdt, data, commdct, thisbunch, theidf):
"""add a bunch to model.
abunch usually comes from another idf file
or it can be used to copy within the idf file"""
key = thisbunch.key.upper()
obj = copy.copy(thisbunch.obj)
abunch = obj2bunch(data, commdct, obj)
bunchdt[key].append(abunch)
return abunch | 0.002865 |
def ein(self):
"""Generate a random United States Employer Identification Number (EIN).
An United States An Employer Identification Number (EIN) is
also known as a Federal Tax Identification Number, and is
used to identify a business entity. EINs follow a format of a
two-digit prefix followed by a hyphen and a seven-digit sequence:
##-######
https://www.irs.gov/businesses/small-businesses-self-employed/employer-id-numbers
"""
# Only certain EIN Prefix values are assigned:
#
# https://www.irs.gov/businesses/small-businesses-self-employed/how-eins-are-assigned-and-valid-ein-prefixes
ein_prefix_choices = [
'01',
'02',
'03',
'04',
'05',
'06',
'10',
'11',
'12',
'13',
'14',
'15',
'16',
'20',
'21',
'22',
'23',
'24',
'25',
'26',
'27',
'30',
'31',
'32',
'33',
'34',
'35',
'36',
'37',
'38',
'39',
'40',
'41',
'42',
'43',
'44',
'45',
'46',
'47',
'48',
'50',
'51',
'52',
'53',
'54',
'55',
'56',
'57',
'58',
'59',
'60',
'61',
'62',
'63',
'64',
'65',
'66',
'67',
'68',
'71',
'72',
'73',
'74',
'75',
'76',
'77',
'80',
'81',
'82',
'83',
'84',
'85',
'86',
'87',
'88',
'90',
'91',
'92',
'93',
'94',
'95',
'98',
'99']
ein_prefix = random.choice(ein_prefix_choices)
sequence = self.random_int(min=0, max=9999999)
ein = "{0:s}-{1:07d}".format(ein_prefix, sequence)
return ein | 0.00125 |
def discover_yaml(bank=None, **meta):
"""Discovers the YAML format and registers it if available.
Install YAML support via PIP::
pip install PyYAML
:param bank: The format bank to register the format in
:param meta: Extra information associated with the format
"""
try:
import yaml
if bank is None:
bank = default_bank
bank.register('yaml', yaml.load, yaml.dump, **meta)
except ImportError:
pass | 0.002092 |
def abspath(*path):
"""A method to determine absolute path for a given relative path to the
directory where this setup.py script is located"""
setup_dir = os.path.dirname(os.path.abspath(__file__))
return os.path.join(setup_dir, *path) | 0.003984 |
def inasafe_place_value_name(number, feature, parent):
"""Given a number, it will return the place value name.
For instance:
* inasafe_place_value_name(10) -> Ten \n
* inasafe_place_value_name(1700) -> Thousand
It needs to be used with inasafe_place_value_coefficient.
"""
_ = feature, parent # NOQA
if number is None:
return None
rounded_number = round_affected_number(
number,
use_rounding=True,
use_population_rounding=True
)
value, unit = denomination(rounded_number, 1000)
if not unit:
return None
else:
return unit['name'] | 0.00158 |
def dashboard(self, request):
"Basic dashboard panel"
# TODO: these should be ajax
module_set = []
for namespace, module in self.get_modules():
home_url = module.get_home_url(request)
if hasattr(module, 'render_on_dashboard'):
# Show by default, unless a permission is required
if not module.permission or request.user.has_perm(module.permission):
module_set.append((module.get_dashboard_title(), module.render_on_dashboard(request), home_url))
return self.render_to_response('nexus/dashboard.html', {
'module_set': module_set,
}, request) | 0.005908 |
def sv_variants(store, institute_obj, case_obj, variants_query, page=1, per_page=50):
"""Pre-process list of SV variants."""
skip_count = (per_page * max(page - 1, 0))
more_variants = True if variants_query.count() > (skip_count + per_page) else False
genome_build = case_obj.get('genome_build', '37')
if genome_build not in ['37','38']:
genome_build = '37'
return {
'variants': (parse_variant(store, institute_obj, case_obj, variant, genome_build=genome_build) for variant in
variants_query.skip(skip_count).limit(per_page)),
'more_variants': more_variants,
} | 0.007874 |
def set_exception(self, exception):
"""Sets the exception on the future."""
if not self.done():
raise TransferNotDoneError(
'set_exception can only be called once the transfer is '
'complete.')
self._coordinator.set_exception(exception, override=True) | 0.00627 |
def zSetSurfaceData(self, surfNum, radius=None, thick=None, material=None, semidia=None,
conic=None, comment=None):
"""Sets surface data"""
if self.pMode == 0: # Sequential mode
surf = self.pLDE.GetSurfaceAt(surfNum)
if radius is not None:
surf.pRadius = radius
if thick is not None:
surf.pThickness = thick
if material is not None:
surf.pMaterial = material
if semidia is not None:
surf.pSemiDiameter = semidia
if conic is not None:
surf.pConic = conic
if comment is not None:
surf.pComment = comment
else:
raise NotImplementedError('Function not implemented for non-sequential mode') | 0.008475 |
def get_sampletypes(self):
"""Returns the available SampleTypes of the system
"""
query = {
"portal_type": "SampleType",
"sort_on": "sortable_title",
"sort_order": "ascending",
"is_active": True,
}
results = api.search(query, "bika_setup_catalog")
return map(api.get_object, results) | 0.005277 |
def parse_list_line_windows(self, b):
"""
Parsing Microsoft Windows `dir` output
:param b: response line
:type b: :py:class:`bytes` or :py:class:`str`
:return: (path, info)
:rtype: (:py:class:`pathlib.PurePosixPath`, :py:class:`dict`)
"""
line = b.decode(encoding=self.encoding).rstrip("\r\n")
date_time_end = line.index("M")
date_time_str = line[:date_time_end + 1].strip().split(" ")
date_time_str = " ".join([x for x in date_time_str if len(x) > 0])
line = line[date_time_end + 1:].lstrip()
with setlocale("C"):
strptime = datetime.datetime.strptime
date_time = strptime(date_time_str, "%m/%d/%Y %I:%M %p")
info = {}
info["modify"] = self.format_date_time(date_time)
next_space = line.index(" ")
if line.startswith("<DIR>"):
info["type"] = "dir"
else:
info["type"] = "file"
info["size"] = line[:next_space].replace(",", "")
if not info["size"].isdigit():
raise ValueError
# This here could cause a problem if a filename started with
# whitespace, but if we were to try to detect such a condition
# we would have to make strong assumptions about the input format
filename = line[next_space:].lstrip()
if filename == "." or filename == "..":
raise ValueError
return pathlib.PurePosixPath(filename), info | 0.001335 |
def epcrparse(self):
"""
Run BLAST, and record results to the object
"""
from Bio.Blast.Applications import NcbiblastnCommandline
while True:
sample, record, line = self.epcrparsequeue.get()
# Split the data on tabs
gene, chromosome, strand, start, end, m_match, gaps, act_len_exp_len = line.split('\t')
# Extract the gene sequence from the contigs
# The record dictionary has the contig name, and the sequence. Splice out the data using the start and
# end coordinates specified by ePCR
genesequence = record[chromosome][int(start) - 1:int(end)]
# Set up BLASTn using blastn-short, as the probe sequences tend to be very short
blastn = NcbiblastnCommandline(db=sample[self.analysistype].probes.split('.')[0],
num_threads=12,
task='blastn-short',
num_alignments=1,
outfmt="'6 qseqid sseqid positive mismatch gaps "
"evalue bitscore slen length'")
# Run the BLASTn, with the gene sequence as stdin
out, err = blastn(stdin=genesequence)
# Split the output string on tabs
results = out.rstrip().split('\t')
# Populate the raw blast results
sample[self.analysistype].rawblastresults[gene] = results
# Create named variables from the list
positives = float(results[2])
mismatches = float(results[3])
gaps = float(results[4])
subjectlength = float(results[7])
# Calculate the percent identity
percentidentity = float('{:0.2f}'.format((positives - gaps) / subjectlength * 100))
# Create a dictionary with the desired values to store in the metadata object
resultdict = {
'matches': positives,
'mismatches': mismatches,
'gaps': gaps,
'subject_length': subjectlength,
'percent_identity': percentidentity,
'match_length': results[8].split('\n')[0]
}
# Populate the metadata object with the dictionary
sample[self.analysistype].blastresults[gene] = resultdict
self.epcrparsequeue.task_done() | 0.004042 |
def _BuildQuery(self,
subject,
attribute=None,
timestamp=None,
limit=None,
is_prefix=False):
"""Build the SELECT query to be executed."""
args = []
subject = utils.SmartUnicode(subject)
criteria = "WHERE aff4.subject_hash=unhex(md5(%s))"
args.append(subject)
sorting = ""
tables = "FROM aff4"
# Set fields, tables, and criteria and append args
if attribute is not None:
if is_prefix:
tables += " JOIN attributes ON aff4.attribute_hash=attributes.hash"
prefix = attribute + "%"
criteria += " AND attributes.attribute like %s"
args.append(prefix)
else:
criteria += " AND aff4.attribute_hash=unhex(md5(%s))"
args.append(attribute)
# Limit to time range if specified
if isinstance(timestamp, (tuple, list)):
criteria += " AND aff4.timestamp >= %s AND aff4.timestamp <= %s"
args.append(int(timestamp[0]))
args.append(int(timestamp[1]))
fields = "aff4.value, aff4.timestamp"
if is_prefix:
fields += ", attributes.attribute"
# Modify fields and sorting for timestamps.
if timestamp is None or timestamp == self.NEWEST_TIMESTAMP:
tables += (" JOIN (SELECT attribute_hash, MAX(timestamp) timestamp "
"%s %s GROUP BY attribute_hash) maxtime ON "
"aff4.attribute_hash=maxtime.attribute_hash AND "
"aff4.timestamp=maxtime.timestamp") % (tables, criteria)
criteria = "WHERE aff4.subject_hash=unhex(md5(%s))"
args.append(subject)
else:
# Always order results.
sorting = "ORDER BY aff4.timestamp DESC"
# Add limit if set.
if limit:
sorting += " LIMIT %s" % int(limit)
query = " ".join(["SELECT", fields, tables, criteria, sorting])
return (query, args) | 0.009554 |
def _parse_file(self):
"""Preprocess and parse C file into an AST"""
# We need to set the CPU type to pull in the right register definitions
# only preprocess the file (-E) and get rid of gcc extensions that aren't
# supported in ISO C.
args = utilities.build_includes(self.arch.includes())
# args.append('-mcpu=%s' % self.arch.property('chip'))
args.append('-E')
args.append('-D__attribute__(x)=')
args.append('-D__extension__=')
self.ast = parse_file(self.filepath, use_cpp=True, cpp_path='arm-none-eabi-gcc', cpp_args=args) | 0.006579 |
def get_layergroup(self, name, workspace=None):
'''
returns a single layergroup object.
Will return None if no layergroup is found.
Will raise an error if more than one layergroup with the same name is found.
'''
layergroups = self.get_layergroups(names=name, workspaces=workspace)
return self._return_first_item(layergroups) | 0.007732 |
def get_document_field_display(self, field_name, field):
""" Render a link to a document """
document = getattr(self.instance, field_name)
if document:
return mark_safe(
'<a href="%s">%s <span class="meta">(%s, %s)</span></a>' % (
document.url,
document.title,
document.file_extension.upper(),
filesizeformat(document.file.size),
)
)
return self.model_admin.get_empty_value_display() | 0.00363 |
def read_table(self):
"""
Read an AMQP table, and return as a Python dictionary.
Will raise BufferUnderflow if there's not enough bytes in the buffer.
Will raise UnicodeDecodeError if the text is mal-formed.
Will raise struct.error if the data is malformed
"""
# Only need to check underflow on the table once
tlen = self.read_long()
self._check_underflow(tlen)
end_pos = self._pos + tlen
result = {}
while self._pos < end_pos:
name = self._field_shortstr()
result[name] = self._read_field()
return result | 0.003155 |
def add_effect(self, effect):
"""
Add an Effect to the Frame.
:param effect: The Effect to be added.
"""
effect.register_scene(self._scene)
self._effects.append(effect) | 0.009217 |
def compute_pblum_scale(self, dataset, pblum, **kwargs):
"""
intensities should already be computed for this dataset at the time for which pblum is being provided
TODO: add documentation
"""
logger.debug("{}.compute_pblum_scale(dataset={}, pblum={})".format(self.component, dataset, pblum))
abs_luminosity = self.compute_luminosity(dataset, **kwargs)
# We now want to remember the scale for all intensities such that the
# luminosity in relative units gives the provided pblum
pblum_scale = pblum / abs_luminosity
self.set_pblum_scale(dataset, pblum_scale) | 0.00625 |
def parse(schema):
"""
Parse `schema`, either a string or a file-like object, and
return a :class:`MessageRegistry` with the loaded messages.
"""
if not isinstance(schema, basestring):
# assume it is file-like
schema = schema.read()
message = re.compile(r'^\(([^,]+),\s*(\d+)\):\s*$')
field = re.compile(r'^-\s*([^:]+):\s+(.+?)\s*$')
registry = MessageRegistry({})
messages = registry.messages
curr = None
names = None
for lineno, line in enumerate(schema.split('\n')):
line = line.strip()
if '#' in line:
line = line[:line.index('#')]
if line == '':
continue
f = field.match(line)
if f:
if curr is None:
raise ParseError(
'field definition outside of message at line %d' % lineno)
name = f.group(1)
type = f.group(2)
if name not in names:
f = Field(curr, name, type)
curr.fields.append(f)
names.add(name)
continue
else:
raise ParseError(
'duplicate field name "%s" at line %d' % (name, lineno))
m = message.match(line)
if m:
# new message definition
name, vers = m.group(1), int(m.group(2))
if (name, vers) in messages:
raise ParseError('Duplicate message (%s, %d)' % (name, vers))
curr = messages[(name, vers)] = Message(registry, name, vers, [])
names = set()
continue
for message in registry.messages.values():
message.fields = tuple(message.fields)
return registry | 0.000582 |
def report_exception(self, http_context=None, user=None):
""" Reports the details of the latest exceptions to Stackdriver Error
Reporting.
:type http_context: :class`google.cloud.error_reporting.HTTPContext`
:param http_context: The HTTP request which was processed when the
error was triggered.
:type user: str
:param user: The user who caused or was affected by the crash. This
can be a user ID, an email address, or an arbitrary
token that uniquely identifies the user. When sending an
error report, leave this field empty if the user was
not logged in. In this case the Error Reporting system
will use other data, such as remote IP address,
to distinguish affected users.
Example::
>>> try:
>>> raise NameError
>>> except Exception:
>>> client.report_exception()
"""
self._send_error_report(
traceback.format_exc(), http_context=http_context, user=user
) | 0.001631 |
def merge(into, d):
"""merge two containers
into is updated, d has priority
"""
if isinstance(into, dict):
for key in d.keys():
if key not in into:
into[key] = d[key]
else:
into[key] = merge(into[key], d[key])
return into
elif isinstance(into, list):
return into + d
else:
return d | 0.005025 |
def draw(board, term, cells):
"""Draw a board to the terminal."""
for (x, y), state in board.iteritems():
with term.location(x, y):
print cells[state], | 0.005587 |
def glob_all(folder: str, filt: str) -> List[str]:
"""Recursive glob"""
import os
import fnmatch
matches = []
for root, dirnames, filenames in os.walk(folder):
for filename in fnmatch.filter(filenames, filt):
matches.append(os.path.join(root, filename))
return matches | 0.003205 |
def get_sorted_nts_omit_section(self, hdrgo_prt, hdrgo_sort):
"""Return a flat list of sections (wo/section names) with GO terms grouped and sorted."""
nts_flat = []
# print("SSSS SorterNts:get_sorted_nts_omit_section(hdrgo_prt={}, hdrgo_sort={})".format(
# hdrgo_prt, hdrgo_sort))
hdrgos_seen = set()
hdrgos_actual = self.sortgos.grprobj.get_hdrgos()
for _, section_hdrgos_all in self.sections:
#section_hdrgos_act = set(section_hdrgos_all).intersection(hdrgos_actual)
section_hdrgos_act = [h for h in section_hdrgos_all if h in hdrgos_actual]
hdrgos_seen |= set(section_hdrgos_act)
self.sortgos.get_sorted_hdrgo2usrgos(
section_hdrgos_act, nts_flat, hdrgo_prt, hdrgo_sort)
remaining_hdrgos = set(self.sortgos.grprobj.get_hdrgos()).difference(hdrgos_seen)
self.sortgos.get_sorted_hdrgo2usrgos(remaining_hdrgos, nts_flat, hdrgo_prt, hdrgo_sort)
return nts_flat | 0.008929 |
def _get_distance_segment_coefficients(self, rval):
"""
Returns the coefficients describing the distance attenuation shape
for three different distance bins, equations 12a - 12c
"""
# Get distance segment ends
nsites = len(rval)
# Equation 12a
f_0 = np.log10(self.CONSTS["r0"] / rval)
f_0[rval > self.CONSTS["r0"]] = 0.0
# Equation 12b
f_1 = np.log10(rval)
f_1[rval > self.CONSTS["r1"]] = np.log10(self.CONSTS["r1"])
# Equation 12c
f_2 = np.log10(rval / self.CONSTS["r2"])
f_2[rval <= self.CONSTS["r2"]] = 0.0
return f_0, f_1, f_2 | 0.003035 |
def find_focusable(node):
"""
Search for the first focusable window within the node tree
"""
if not node.children:
return node
if node.focus:
return find_focusable(node.children_dict[node.focus[0]]) | 0.004237 |
def reformat(self, dtstring, before, after):
"""Edit the time string format.
See https://docs.python.org/2/library/datetime.html#strftime-and-strptime-behavior
for all format string options.
**中文文档**
将datetime string从一种格式转换成另一种格式。
"""
a_datetime = datetime.strptime(dtstring, before)
return datetime.strftime(a_datetime, after) | 0.014354 |
def FromBinary(cls, record_data, record_count=1):
"""Create an UpdateRecord subclass from binary record data.
This should be called with a binary record blob (NOT including the
record type header) and it will decode it into a SetGraphOnlineRecord.
Args:
record_data (bytearray): The raw record data that we wish to parse
into an UpdateRecord subclass NOT including its 8 byte record header.
record_count (int): The number of records included in record_data.
Raises:
ArgumentError: If the record_data is malformed and cannot be parsed.
Returns:
SetGraphOnlineRecord: The decoded reflash tile record.
"""
_cmd, address, _resp_length, payload = cls._parse_rpc_info(record_data)
try:
online, = struct.unpack("<H", payload)
online = bool(online)
except ValueError:
raise ArgumentError("Could not decode payload for set_online record", payload=payload)
return SetGraphOnlineRecord(online, address) | 0.004608 |
def set_log_level(self):
"""
Set log level according to command-line options
@returns: logger object
"""
if self.options.debug:
self.logger.setLevel(logging.DEBUG)
elif self.options.quiet:
self.logger.setLevel(logging.ERROR)
else:
self.logger.setLevel(logging.INFO)
self.logger.addHandler(logging.StreamHandler())
return self.logger | 0.004525 |
def next(self):
"""Trigger next agent to :py:meth:`~creamas.core.CreativeAgent.act` in
the current step.
"""
# all agents acted, init next step
t = time.time()
if len(self._agents_to_act) == 0:
self._init_step()
addr = self._agents_to_act.pop(0)
aiomas.run(until=self.env.trigger_act(addr=addr))
t2 = time.time()
self._step_processing_time += t2 - t
# all agents acted, finalize current step
if len(self._agents_to_act) == 0:
self._finalize_step() | 0.003515 |
def tcache(parser, token):
"""
This will cache the contents of a template fragment for a given amount
of time with support tags.
Usage::
{% tcache [expire_time] [fragment_name] [tags='tag1,tag2'] %}
.. some expensive processing ..
{% endtcache %}
This tag also supports varying by a list of arguments:
{% tcache [expire_time] [fragment_name] [var1] [var2] .. [tags=tags] %}
.. some expensive processing ..
{% endtcache %}
Each unique set of arguments will result in a unique cache entry.
"""
nodelist = parser.parse(('endtcache',))
parser.delete_first_token()
tokens = token.split_contents()
if len(tokens) < 3:
raise template.TemplateSyntaxError("'%r' tag requires at least 2 arguments." % tokens[0])
tags = None
if len(tokens) > 3 and 'tags=' in tokens[-1]:
tags = parser.compile_filter(tokens[-1][5:])
del tokens[-1]
return CacheNode(nodelist,
parser.compile_filter(tokens[1]),
tokens[2], # fragment_name can't be a variable.
[parser.compile_filter(token) for token in tokens[3:]],
tags
) | 0.003428 |
def merge(self, other_tc):
"""
Return the top-left ``<w:tc>`` element of a new span formed by
merging the rectangular region defined by using this tc element and
*other_tc* as diagonal corners.
"""
top, left, height, width = self._span_dimensions(other_tc)
top_tc = self._tbl.tr_lst[top].tc_at_grid_col(left)
top_tc._grow_to(width, height)
return top_tc | 0.004706 |
def unbroadcast(a, b):
'''
unbroadcast(a, b) yields a tuple (aa, bb) that is equivalent to (a, b) except that aa and bb
have been reshaped such that arithmetic numpy operations such as aa * bb will result in
row-wise operation instead of column-wise broadcasting.
'''
# they could be sparse:
spa = sps.issparse(a)
spb = sps.issparse(b)
if spa and spb: return (a,b)
elif spa or spb:
def fix(sp,nm):
nm = np.asarray(nm)
dnm = len(nm.shape)
nnm = np.prod(nm.shape)
# if we have (sparse matrix) * (high-dim array), unbroadcast the dense array
if dnm == 0: return (sp, np.reshape(nm, (1, 1)))
elif dnm == 1: return (sp, np.reshape(nm, (nnm, 1)))
elif dnm == 2: return (sp, nm)
else: return unbroadcast(sp.toarray(), nm)
return fix(a, b) if spa else tuple(reversed(fix(b, a)))
# okay, no sparse matrices found:
a = np.asarray(a)
b = np.asarray(b)
da = len(a.shape)
db = len(b.shape)
if da > db: return (a, np.reshape(b, b.shape + tuple(np.ones(da-db, dtype=np.int))))
elif da < db: return (np.reshape(a, a.shape + tuple(np.ones(db-da, dtype=np.int))), b)
else: return (a, b) | 0.017161 |
def iterRun(self, sqlTail = '', raw = False) :
"""Compile filters and run the query and returns an iterator. This much more efficient for large data sets but
you get the results one element at a time. One thing to keep in mind is that this function keeps the cursor open, that means that the sqlite databae is locked (no updates/inserts etc...) until all
the elements have been fetched. For batch updates to the database, preload the results into a list using get, then do you updates.
You can use sqlTail to add things such as order by
If raw, returns the raw tuple data (not wrapped into a raba object)"""
sql, sqlValues = self.getSQLQuery()
cur = self.con.execute('%s %s'% (sql, sqlTail), sqlValues)
for v in cur :
if not raw :
yield RabaPupa(self.rabaClass, v[0])
else :
yield v | 0.03198 |
def add_path_with_storage_account(self, remote_path, storage_account):
# type: (SourcePath, str, str) -> None
"""Add a path with an associated storage account
:param SourcePath self: this
:param str remote_path: remote path
:param str storage_account: storage account to associate with path
"""
if len(self._path_map) >= 1:
raise RuntimeError(
'cannot add multiple remote paths to SourcePath objects')
rpath = blobxfer.util.normalize_azure_path(remote_path)
self.add_path(rpath)
self._path_map[rpath] = storage_account | 0.004792 |
def _create_embedded_indices(self):
'''
Create indices for all the embedded structs. For parser internal use.
'''
try:
self._target._embedded_indices.update(((k,(self,v)) for k,v in getattr(self._parser.typedef, 'inline_names', {}).items()))
except AttributeError:
pass | 0.018018 |
def __add_tier(self, tier, token_tier_name):
"""
adds a tier to the document graph (either as additional attributes
to the token nodes or as a span node with outgoing edges to the token
nodes it represents)
"""
if tier.attrib['category'] == token_tier_name:
self.__add_tokens(tier)
else:
if self.is_token_annotation_tier(tier):
self.__add_token_annotation_tier(tier)
else:
self.__add_span_tier(tier) | 0.003817 |
def unbind(self, *args):
"""Unsubscribes from events or :class:`~pydispatch.properties.Property` updates
Multiple arguments can be given. Each of which can be either the method
that was used for the original call to :meth:`bind` or an instance
object.
If an instance of an object is supplied, any previously bound Events and
Properties will be 'unbound'.
"""
props = self.__property_events.values()
events = self.__events.values()
for arg in args:
for prop in props:
prop.remove_listener(arg)
for e in events:
e.remove_listener(arg) | 0.00597 |
def accumulator(init, update):
"""
Generic accumulator function.
.. code-block:: python
# Simplest Form
>>> a = 'this' + ' '
>>> b = 'that'
>>> c = functools.reduce(accumulator, a, b)
>>> c
'this that'
# The type of the initial value determines output type.
>>> a = 5
>>> b = Hello
>>> c = functools.reduce(accumulator, a, b)
>>> c
10
:param init: Initial Value
:param update: Value to accumulate
:return: Combined Values
"""
return (
init + len(update)
if isinstance(init, int) else
init + update
) | 0.003008 |
def handshake_timed_out(self):
"""
Checks if the handshake has timed out.
If `start_handshake` wasn't called before the call to this function,
the return value will always be `False`. If the handshake completed
before a timeout was reached, the return value will be `False`
:return: handshake time out status, as a `bool`
"""
if not self.__timer:
return False
if self.__handshake_complete:
return False
return self.__timer_expired | 0.003731 |
def get_action(self):
"""Returns the action to be taken from the request. Returns None if no
action is found
"""
action = self.request.get("workflow_action_id", None)
action = self.request.get("workflow_action", action)
if not action:
return None
# A condition in the form causes Plone to sometimes send two actions
# This usually happens when the previous action was not managed properly
# and the request was not able to complete, so the previous form value
# is kept, together with the new one.
if type(action) in (list, tuple):
actions = list(set(action))
if len(actions) > 0:
logger.warn("Multiple actions in request: {}. Fallback to '{}'"
.format(repr(actions), actions[-1]))
action = actions[-1]
return action | 0.003315 |
def ceil(x, context=None):
"""
Return the next higher or equal integer to x.
If the result is not exactly representable, it will be rounded according to
the current context. Note that the rounding step means that it's possible
for the result to be smaller than ``x``. For example::
>>> x = 2**100 + 1
>>> ceil(2**100 + 1) >= x
False
One way to be sure of getting a result that's greater than or equal to
``x`` is to use the ``RoundTowardPositive`` rounding mode::
>>> with RoundTowardPositive:
... x = 2**100 + 1
... ceil(x) >= x
...
True
Similar comments apply to the :func:`floor`, :func:`round` and
:func:`trunc` functions.
.. note::
This function corresponds to the MPFR function ``mpfr_rint_ceil``,
not to ``mpfr_ceil``.
"""
return _apply_function_in_current_context(
BigFloat,
mpfr.mpfr_rint_ceil,
(BigFloat._implicit_convert(x),),
context,
) | 0.000973 |
def _relevant_checkers(self, path):
"""
Get set of checkers for the given path.
TODO: currently this is based off the file extension. We would like to
honor magic bits as well, so that python binaries, shell scripts, etc
but we're not guaranteed that `path` currently exists on the filesystem
-- e.g. when version control for historical revs is used.
"""
_, ext = os.path.splitext(path)
ext = ext.lstrip('.')
return checkers.checkers.get(ext, []) | 0.003788 |
def authenticate(self):
"""Authenticate user by any means and return either true or false.
Args:
Returns:
tuple (is_valid, username): True is valid user, False if not
"""
basic_auth = request.authorization
is_valid = False
user = None
if basic_auth:
is_valid, user = self.check_basic_auth(
basic_auth.username, basic_auth.password
)
else: # Try token auth
token = request.headers.get('Authorization', None)
param_token = request.args.get('access_token')
if token or param_token:
if token:
# slice the 'token ' piece of the header (following
# github style):
token = token[6:]
else:
# Grab it from query dict instead
token = param_token
log.debug('Received token: %s', token)
is_valid, user = self.check_token_auth(token)
return (is_valid, user) | 0.001852 |
def bulk_update(object_list, ignore_errors=False, delete_first=False, verbosity=0):
'''Bulk_create objects in provided list of model instances, delete database rows for the original pks in the object list.
Returns any delta in the number of rows in the database table that resulted from the update.
If nonzero, an error has likely occurred and database integrity is suspect.
# delete_first = True is required if your model has unique constraints that would be violated by creating duplicate records
# FIXME: check for unique constraints and raise exception if any exist (won't work because new objects may violate!)
'''
if not object_list:
return 0
model = object_list[0].__class__
N_before = model.objects.count()
pks_to_delete = set()
for i, obj in enumerate(object_list):
pks_to_delete.add(obj.pk)
if delete_first:
object_list[i] = deepcopy(obj)
object_list[i].pk = None
if verbosity > 1:
print 'Creating %d %r objects.' % (len(object_list), model)
print 'BEFORE: %d' % model.objects.count()
if not delete_first:
model.objects.bulk_create(object_list)
if verbosity > 0:
print 'Deleting %d objects with pks: %r ........' % (len(pks_to_delete), pks_to_delete)
objs_to_delete = model.objects.filter(pk__in=pks_to_delete)
num_to_delete = objs_to_delete.count()
if num_to_delete != len(pks_to_delete):
msg = 'Attempt to delete redundant pks (len %d)! Queryset has count %d. Query was `filter(pk__in=%r). Queryset = %r' % (
len(pks_to_delete), num_to_delete, pks_to_delete, objs_to_delete)
if ignore_errors:
if verbosity > 0:
print msg
else:
raise RuntimeError(msg)
if verbosity > 1:
print 'Queryset to delete has %d objects' % objs_to_delete.count()
objs_to_delete.delete()
if delete_first:
model.objects.bulk_create(object_list)
if verbosity > 1:
print 'AFTER: %d' % model.objects.count()
N_after = model.objects.count()
if ignore_errors:
if verbosity > 1:
print 'AFTER: %d' % N_after
else:
if N_after != N_before:
print 'Number of records in %r changed by %d during bulk_create of %r.\n ' % (model, N_after - N_before, object_list)
msg = 'Records before and after bulk_create are not equal!!! Before=%d, After=%d' % (N_before, N_after)
raise RuntimeError(msg)
return N_before - N_after | 0.003956 |
def run(cmd, output_fpath=None, input_fpath=None, checks=None, stdout_to_outputfile=True,
stdout_tx=True, reuse=False, env_vars=None):
"""Run the provided command, logging details and checking for errors.
"""
if output_fpath and reuse:
if verify_file(output_fpath, silent=True):
info(output_fpath + ' exists, reusing')
return output_fpath
if not output_fpath.endswith('.gz') and verify_file(output_fpath + '.gz', silent=True):
info(output_fpath + '.gz exists, reusing')
return output_fpath
env = os.environ.copy()
if env_vars:
for k, v in env_vars.items():
if v is None:
if k in env:
del env[k]
else:
env[k] = v
if checks is None:
checks = [file_nonempty_check]
def _try_run(_cmd, _output_fpath, _input_fpath):
try:
info(' '.join(str(x) for x in _cmd) if not isinstance(_cmd, six.string_types) else _cmd)
_do_run(_cmd, checks, env, _output_fpath, _input_fpath)
except:
raise
if output_fpath:
if isfile(output_fpath):
os.remove(output_fpath)
if output_fpath:
if stdout_tx:
with file_transaction(None, output_fpath) as tx_out_file:
if stdout_to_outputfile:
cmd += ' > ' + tx_out_file
else:
cmd += '\n'
cmd = cmd.replace(' ' + output_fpath + ' ', ' ' + tx_out_file + ' ') \
.replace(' "' + output_fpath + '" ', ' ' + tx_out_file + '" ') \
.replace(' \'' + output_fpath + '\' ', ' ' + tx_out_file + '\' ') \
.replace(' ' + output_fpath + '\n', ' ' + tx_out_file) \
.replace(' "' + output_fpath + '"\n', ' ' + tx_out_file + '"') \
.replace(' \'' + output_fpath + '\'\n', ' ' + tx_out_file + '\'') \
.replace('\n', '')
_try_run(cmd, tx_out_file, input_fpath)
else:
_try_run(cmd, output_fpath, input_fpath)
else:
_try_run(cmd, None, input_fpath) | 0.004891 |
def externals_finder(dirname, filename):
"""Find any 'svn:externals' directories"""
found = False
f = open(filename,'rt')
for line in iter(f.readline, ''): # can't use direct iter!
parts = line.split()
if len(parts)==2:
kind,length = parts
data = f.read(int(length))
if kind=='K' and data=='svn:externals':
found = True
elif kind=='V' and found:
f.close()
break
else:
f.close()
return
for line in data.splitlines():
parts = line.split()
if parts:
yield joinpath(dirname, parts[0]) | 0.010542 |
def select(self, *args, **kwargs):
"""Python3 raises `ValueError` if socket is closed, because fd == -1"""
try:
return super(PatroniSequentialThreadingHandler, self).select(*args, **kwargs)
except ValueError as e:
raise select.error(9, str(e)) | 0.010309 |
def process_edge_flow(self, source, sink, i, j, algo, q):
'''
API: process_edge_flow(self, source, sink, i, j, algo, q)
Description:
Used by by max_flow_preflowpush() method. Processes edges along
prefolow push.
Input:
source: Source node name of flow graph.
sink: Sink node name of flow graph.
i: Source node in the processed edge (tail of arc).
j: Sink node in the processed edge (head of arc).
Post:
The 'flow' and 'excess' attributes of nodes may get updated.
Return:
Returns False if residual capacity is 0, True otherwise.
'''
if (self.get_node_attr(i, 'distance') !=
self.get_node_attr(j, 'distance') + 1):
return False
if (i, j) in self.edge_attr:
edge = (i, j)
capacity = self.get_edge_attr(i, j, 'capacity')
mult = 1
else:
edge = (j, i)
capacity = 0
mult = -1
flow = mult*self.edge_attr[edge]['flow']
residual_capacity = capacity - flow
if residual_capacity == 0:
return False
excess_i = self.get_node_attr(i, 'excess')
excess_j = self.get_node_attr(j, 'excess')
push_amount = min(excess_i, residual_capacity)
self.edge_attr[edge]['flow'] = mult*(flow + push_amount)
self.set_node_attr(i, 'excess', excess_i - push_amount)
self.set_node_attr(j, 'excess', excess_j + push_amount)
return True | 0.001928 |
def usage(self, subcommand):
"""
Returns *how to use command* text.
"""
usage = ' '.join(['%prog', subcommand, '[options]'])
if self.args:
usage = '%s %s' % (usage, str(self.args))
return usage | 0.007905 |
def long2ip(l):
"""Convert a network byte order 32-bit integer to a dotted quad ip
address.
>>> long2ip(2130706433)
'127.0.0.1'
>>> long2ip(MIN_IP)
'0.0.0.0'
>>> long2ip(MAX_IP)
'255.255.255.255'
>>> long2ip(None) #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: unsupported operand type(s) for >>: 'NoneType' and 'int'
>>> long2ip(-1) #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: expected int between 0 and 4294967295 inclusive
>>> long2ip(374297346592387463875) #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: expected int between 0 and 4294967295 inclusive
>>> long2ip(MAX_IP + 1) #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: expected int between 0 and 4294967295 inclusive
:param l: Network byte order 32-bit integer.
:type l: int
:returns: Dotted-quad ip address (eg. '127.0.0.1').
:raises: TypeError
"""
if MAX_IP < l or l < MIN_IP:
raise TypeError(
"expected int between %d and %d inclusive" % (MIN_IP, MAX_IP))
return '%d.%d.%d.%d' % (
l >> 24 & 255, l >> 16 & 255, l >> 8 & 255, l & 255) | 0.001514 |
def prune_urls(url_set, start_url, allowed_list, ignored_list):
"""Prunes URLs that should be ignored."""
result = set()
for url in url_set:
allowed = False
for allow_url in allowed_list:
if url.startswith(allow_url):
allowed = True
break
if not allowed:
continue
ignored = False
for ignore_url in ignored_list:
if url.startswith(ignore_url):
ignored = True
break
if ignored:
continue
prefix, suffix = (url.rsplit('.', 1) + [''])[:2]
if suffix.lower() in IGNORE_SUFFIXES:
continue
result.add(url)
return result | 0.001372 |
def clean_traceback(tb):
'''Fixes up the traceback to remove the from the file paths the part
preceeding the project root.
@param tb: C{str}
@rtype: C{str}'''
prefix = __file__[:__file__.find("feat/common/error.py")]
regex = re.compile("(\s*File\s*\")(%s)([a-zA-Z-_\. \\/]*)(\".*)"
% prefix.replace("\\", "\\\\"))
def cleanup(line):
m = regex.match(line)
if m:
return m.group(1) + ".../" + m.group(3) + m.group(4)
else:
return line
return '\n'.join(map(cleanup, tb.split('\n'))) | 0.006861 |
def page_factory(request):
""" Page factory.
Config models example:
.. code-block:: python
models = {
'': [WebPage, CatalogResource],
'catalogue': CatalogResource,
'news': NewsResource,
}
"""
prefix = request.matchdict['prefix'] # /{prefix}/page1/page2/page3...
settings = request.registry.settings
dbsession = settings[CONFIG_DBSESSION]
config = settings[CONFIG_MODELS]
if prefix not in config:
# prepend {prefix} to *traverse
request.matchdict['traverse'] =\
tuple([prefix] + list(request.matchdict['traverse']))
prefix = None
# Get all resources and models from config with the same prefix.
resources = config.get(
prefix, config.get( # 1. get resources with prefix same as URL prefix
'', config.get( # 2. if not, then try to get empty prefix
'/', None))) # 3. else try to get prefix '/' otherwise None
if not hasattr(resources, '__iter__'):
resources = (resources, )
tree = {}
if not resources:
return tree
# Add top level nodes of resources in the tree
for resource in resources:
table = None
if not hasattr(resource, '__table__')\
and hasattr(resource, 'model'):
table = resource.model
else:
table = resource
if not hasattr(table, 'slug'):
continue
nodes = dbsession.query(table)
if hasattr(table, 'parent_id'):
nodes = nodes.filter(or_(
table.parent_id == None, # noqa
table.parent.has(table.slug == '/')
))
for node in nodes:
if not node.slug:
continue
resource = resource_of_node(resources, node)
tree[node.slug] = resource(node, prefix=prefix)
return tree | 0.000524 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.