text_prompt
stringlengths 100
17.7k
⌀ | code_prompt
stringlengths 7
9.86k
⌀ |
|---|---|
<SYSTEM_TASK:>
Create an Scm for a component.
<END_TASK>
<USER_TASK:>
Description:
def _make_scm(current_target):
"""
Create an Scm for a component.
Arguments
component - The component being operated on.
""" |
# pylint: disable=protected-access
tool_key = devpipeline_core.toolsupport.choose_tool_key(
current_target, devpipeline_scm._SCM_TOOL_KEYS
)
return devpipeline_core.toolsupport.tool_builder(
current_target.config, tool_key, devpipeline_scm.SCMS, current_target
) |
<SYSTEM_TASK:>
Update or a local checkout.
<END_TASK>
<USER_TASK:>
Description:
def checkout_task(current_target):
"""
Update or a local checkout.
Arguments
target - The target to operate on.
""" |
try:
scm = _make_scm(current_target)
src_dir = current_target.config.get("dp.src_dir")
shared_dir = current_target.config.get("dp.src_dir_shared")
scm.checkout(repo_dir=src_dir, shared_dir=shared_dir)
scm.update(repo_dir=src_dir)
except devpipeline_core.toolsupport.MissingToolKey as mtk:
current_target.executor.warning(mtk) |
<SYSTEM_TASK:>
Process JSON data found in the response.
<END_TASK>
<USER_TASK:>
Description:
def proc_response(self, resp):
"""Process JSON data found in the response.""" |
# Try to interpret any JSON
try:
resp.obj = json.loads(resp.body)
self._debug(" Received entity: %r", resp.obj)
except ValueError:
resp.obj = None
self._debug(" No received entity; body %r", resp.body)
# Now, call superclass method for error handling
super(JSONRequest, self).proc_response(resp) |
<SYSTEM_TASK:>
Helper method to attach obj to req as JSON data.
<END_TASK>
<USER_TASK:>
Description:
def _attach_obj(self, req, obj):
"""Helper method to attach obj to req as JSON data.""" |
# Attach the object to the request
json.dump(obj, req)
# Also set the content-type header
req['content-type'] = self._content_type |
<SYSTEM_TASK:>
Find the path of the deployed egg package that may contain the
<END_TASK>
<USER_TASK:>
Description:
def find_module_egg_path(module_path):
"""
Find the path of the deployed egg package that may contain the
specified module path.
@param module_path: the path of a Python module.
@return: the absolute path of the deployed egg package that contains
the specified module path, or ``None`` if no deployed egg
package contains this module path.
""" |
if module_path.find('.egg') == -1:
return None
_module_absolute_path = os.path.abspath(module_path)
egg_paths = [os.path.relpath(_module_absolute_path, egg_path)
for egg_path in [egg_path for egg_path in sys.path
if REGEX_EGG_PACKAGE_PATH.match(egg_path) \
and _module_absolute_path.startswith(egg_path)]]
return None if len(egg_paths) == 0 else egg_paths[0] |
<SYSTEM_TASK:>
Shorten the given text to ``max_size``
<END_TASK>
<USER_TASK:>
Description:
def tmpl_shorten(text, max_size=32):
"""Shorten the given text to ``max_size``
* synopsis: ``%shorten{text}`` or ``%shorten{text,max_size}``
* example: ``%shorten{$title,32}``
* description: Shorten “text” on word boundarys.
""" |
max_size = int(max_size)
if len(text) <= max_size:
return text
text = textwrap.wrap(text, max_size)[0]
import re
text = re.sub(r'\W+$', '', text)
return text.strip() |
<SYSTEM_TASK:>
Format a time value using `strftime`.
<END_TASK>
<USER_TASK:>
Description:
def tmpl_time(text, fmt, cur_fmt):
"""Format a time value using `strftime`.
* synopsis: ``%time{date_time,format,curformat}``
* description: Return the date and time in any format accepted by \
strftime. For example, to get the year some music was added to \
your library, use %time{$added,%Y}.
""" |
return time.strftime(fmt, time.strptime(text, cur_fmt)) |
<SYSTEM_TASK:>
Download all binaries for the current platform
<END_TASK>
<USER_TASK:>
Description:
def download_binaries(package_dir=False):
"""Download all binaries for the current platform
Parameters
----------
package_dir: bool
If set to `True`, the binaries will be downloaded to the
`resources` directory of the qpsphere package instead of
to the users application data directory. Note that this
might require administrative rights if qpsphere is installed
in a system directory.
Returns
-------
paths: list of pathlib.Path
List of paths to binaries. This will always return binaries in
the `resources` directory of the qpsphere package (if binaries
are present there), in disregard of the parameter `package_dir`.
""" |
# bhfield
# make sure the binary is available on the system
paths = _bhfield.fetch.get_binaries()
if package_dir:
# Copy the binaries to the `resources` directory
# of qpsphere.
pdir = RESCR_PATH
outpaths = []
for pp in paths:
target = pdir / pp.name
if not target.exists():
shutil.copy(pp, target)
outpaths.append(target)
else:
outpaths = paths
return outpaths |
<SYSTEM_TASK:>
Remove all binaries for the current platform
<END_TASK>
<USER_TASK:>
Description:
def remove_binaries(package_dir=False):
"""Remove all binaries for the current platform
Parameters
----------
package_dir: bool
If True, remove all binaries from the `resources`
directory of the qpsphere package. If False,
remove all binaries from the user's cache directory.
""" |
paths = []
if package_dir:
pdir = RESCR_PATH
else:
pdir = CACHE_PATH
for pp in pdir.iterdir():
if pp.name != "shipped_resources_go_here":
paths.append(pp)
for pp in paths:
pp.unlink() |
<SYSTEM_TASK:>
A decorator for calculating time elapsed when execute function
<END_TASK>
<USER_TASK:>
Description:
def elapsed(func):
"""A decorator for calculating time elapsed when execute function""" |
@functools.wraps(func)
def wrapper(*args, **kw):
start = time.time()
print('Running `%s()` ...' % func.__name__)
res = func(*args, **kw)
end = time.time()
print('Function `%s()` running elapsed %.2f s' %
(func.__name__, end - start))
return res
return wrapper |
<SYSTEM_TASK:>
define a logger for your program
<END_TASK>
<USER_TASK:>
Description:
def create_logger(log_file, name='logger', cmd=True):
"""define a logger for your program
parameters
------------
log_file file name of log
name name of logger
example
------------
logger = create_logger('example.log',name='logger',)
logger.info('This is an example!')
logger.warning('This is a warn!')
""" |
import logging
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
# set format
formatter = logging.Formatter('%(asctime)s | %(name)s | %(levelname)s | %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
# file handler
fh = logging.FileHandler(log_file)
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
logger.addHandler(fh)
# cmd handler
if cmd:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
logger.addHandler(ch)
return logger |
<SYSTEM_TASK:>
Return an aproximate textual representation of the provioded duration of
<END_TASK>
<USER_TASK:>
Description:
def relative_time_to_text(l10n=locales.get(_default), **kwargs):
"""
Return an aproximate textual representation of the provioded duration of
time.
Examples:
relative_time_to_text(hours=6, minutes=34) -> "six and a half hours"
relative_time_to_text(years=5, months=8, days=5) -> "less than six years"
Keyword arguments:
l10n -- The locale of the language for the result. Default is en_US.
seconds
minutes
hours
days
weeks
months
years
""" |
kwargs = _normalize(**kwargs)
cor = _Chain()
cor.add(_LessThan1M(l10n, **kwargs))
cor.add(_LessThan1H(l10n, **kwargs))
cor.add(_LessThan23H(l10n, **kwargs))
cor.add(_LessThan6D1H(l10n, **kwargs))
cor.add(_LessThan25D10H(l10n, **kwargs))
cor.add(_LessThan11MM(l10n, **kwargs))
cor.add(_LessThan10Y(l10n, **kwargs))
cor.add(_MoreThan10Y(l10n, **kwargs))
return cor.run() |
<SYSTEM_TASK:>
Expects Compressor Block like objects
<END_TASK>
<USER_TASK:>
Description:
def do_heavy_work(self, block):
"""
Expects Compressor Block like objects
""" |
cipher_key = self.gen_key(32)
in_file_path = block.latest_file_info.path
dst_file_path = block.processed_data_file_info.path + self.get_extension()
self.log.debug("Encrypting file '%s' with key '%s' to file '%s'",
in_file_path, cipher_key, dst_file_path)
self.encrypt_file(key=cipher_key,
in_filename=in_file_path,
out_filename=dst_file_path)
block.cipher_key = cipher_key
block.ciphered_file_info = FileInfo(dst_file_path)
block.latest_file_info = block.ciphered_file_info
return block |
<SYSTEM_TASK:>
Update a `key` in the keystore.
<END_TASK>
<USER_TASK:>
Description:
def update(self, key, value):
"""Update a `key` in the keystore.
If the key is non-existent, it's being created
""" |
if not isinstance(value, dict):
raise BadValueError(
'The value {} is incorrect.'
' Values should be strings'.format(value))
if key in self.data:
v = self.get(key)
v.update(value)
else:
v = value
self.set(key, v) |
<SYSTEM_TASK:>
Filter data according to the given arguments.
<END_TASK>
<USER_TASK:>
Description:
def filter(self, **kwargs):
"""
Filter data according to the given arguments.
""" |
keys = self.filter_keys(**kwargs)
return self.keys_to_values(keys) |
<SYSTEM_TASK:>
Create an index.
<END_TASK>
<USER_TASK:>
Description:
def create_index(self, name, recreate=False, _type='default'):
"""
Create an index.
If recreate is True, recreate even if already there.
""" |
if name not in self.indexes or recreate:
self.build_index(name, _type) |
<SYSTEM_TASK:>
Create a TaskCommand with defined tasks.
<END_TASK>
<USER_TASK:>
Description:
def make_command(tasks, *args, **kwargs):
"""
Create a TaskCommand with defined tasks.
This is a helper function to avoid boiletplate when dealing with simple
cases (e.g., all cli arguments can be handled by TaskCommand), with no
special processing. In general, this means a command only needs to run
established tasks.
Arguments:
tasks - the tasks to execute
args - extra arguments to pass to the TargetCommand constructor
kwargs - extra keyword arguments to pass to the TargetCommand constructor
""" |
command = TaskCommand(tasks=tasks, *args, **kwargs)
return command |
<SYSTEM_TASK:>
Runs the provided command with the given args.
<END_TASK>
<USER_TASK:>
Description:
def execute_command(command, args):
"""
Runs the provided command with the given args.
Exceptions, if any, are propogated to the caller.
Arguments:
command - something that extends the Command class
args - A list of command line arguments. If args is None, sys.argv
(without the first argument--assumed to be the command name) will
be used.
""" |
if args is None:
args = sys.argv[1:]
try:
command.execute(args)
except IOError as failure:
if failure.errno == errno.EPIPE:
# This probably means we were piped into something that terminated
# (e.g., head). Might be a better way to handle this, but for now
# silently swallowing the error isn't terrible.
pass
except _PartialFailureException as failed:
for failure, skipped, message in failed.failed:
print("\nTask {} failed".format(failure), file=sys.stderr)
print("\tError: {}".format(message), file=sys.stderr)
print("\tSkipped: {}".format(skipped), file=sys.stderr)
sys.exit(1)
except Exception as failure: # pylint: disable=broad-except
print("Error: {}".format(str(failure)), file=sys.stderr)
sys.exit(1) |
<SYSTEM_TASK:>
Initializes and runs the tool.
<END_TASK>
<USER_TASK:>
Description:
def execute(self, *args, **kwargs):
"""
Initializes and runs the tool.
This is shorhand to parse command line arguments, then calling:
self.setup(parsed_arguments)
self.process()
""" |
args = self.parser.parse_args(*args, **kwargs)
self.process(args) |
<SYSTEM_TASK:>
Calls the tasks with the appropriate options for each of the targets.
<END_TASK>
<USER_TASK:>
Description:
def process_targets(self, targets, full_config, arguments):
"""
Calls the tasks with the appropriate options for each of the targets.
""" |
executor = _get_executor(arguments)
resolver = _get_resolver(arguments)
dep_manager = resolver(targets, full_config, self._task_order)
task_queue = dep_manager.get_queue()
config_info = devpipeline_core.configinfo.ConfigInfo(executor)
try:
failed = []
def _keep_going_on_failure(failure, task):
skipped = task_queue.fail(task)
failed.append((task, skipped, str(failure)))
def _fail_immediately(failure, task):
del task
raise failure
fail_fn = _fail_immediately
if arguments.keep_going:
fail_fn = _keep_going_on_failure
self._execute_targets(task_queue, config_info, full_config, fail_fn)
if failed:
raise _PartialFailureException(failed)
finally:
full_config.write() |
<SYSTEM_TASK:>
A helper function which waits for user multi-line input.
<END_TASK>
<USER_TASK:>
Description:
def _user_input() -> str:
"""
A helper function which waits for user multi-line input.
:return: A string input by user, separated by ``'\\n'``.
""" |
lines = []
try:
while True:
line = input()
if line != '':
lines.append(line)
else:
break
except (EOFError, KeyboardInterrupt):
return '\n'.join(lines) |
<SYSTEM_TASK:>
Create a generate that iterates the whole content of the file or string.
<END_TASK>
<USER_TASK:>
Description:
def generator(self) -> Iterator[str]:
"""
Create a generate that iterates the whole content of the file or string.
:return: An iterator iterating the lines of the text stream, separated by ``'\\n'`` or ``'\\r'``.
""" |
stream = self.stream # In case that ``self.stream`` is changed.
stream.seek(0)
for line in stream:
yield line |
<SYSTEM_TASK:>
Create a generate that iterates the whole content of the file or string, and also tells which offset is now.
<END_TASK>
<USER_TASK:>
Description:
def generator_telling_position(self) -> Iterator[Tuple[str, int]]:
"""
Create a generate that iterates the whole content of the file or string, and also tells which offset is now.
:return: An iterator iterating tuples, containing lines of the text stream,...
separated by ``'\\n'`` or ``'\\r'``; and the offset (in bytes) of current line.
""" |
stream = self.stream # In case that ``self.stream`` is changed.
stream.seek(0)
for line in stream:
yield line, stream.tell() |
<SYSTEM_TASK:>
Extract strings from the docstrings
<END_TASK>
<USER_TASK:>
Description:
def extract_value(self, string, key, inline_code=True):
"""Extract strings from the docstrings
.. code-block:: text
* synopsis: ``%shorten{text, max_size}``
* example: ``%shorten{$title, 32}``
* description: Shorten “text” on word boundarys.
""" |
regex = r'\* ' + key + ': '
if inline_code:
regex = regex + '``(.*)``'
else:
regex = regex + '(.*)'
value = re.findall(regex, string)
if value:
return value[0].replace('``', '')
else:
return False |
<SYSTEM_TASK:>
Apply textwrap to a given text string
<END_TASK>
<USER_TASK:>
Description:
def format(self, text, width=78, indent=4):
"""Apply textwrap to a given text string""" |
return textwrap.fill(
text,
width=width,
initial_indent=' ' * indent,
subsequent_indent=' ' * indent,
) |
<SYSTEM_TASK:>
Implement the cost function and its gradient for the propagation
<END_TASK>
<USER_TASK:>
Description:
def propagate(w, b, X, Y):
"""
Implement the cost function and its gradient for the propagation
Arguments:
w weights, a numpy array of size (dim, 1)
b bias, a scalar
X data of size (dim, number of examples)
Y true "label" vector of size (1, number of examples)
Return:
cost negative log-likelihood cost for logistic regression
dw gradient of the loss with respect to w, thus same shape as w
db gradient of the loss with respect to b, thus same shape as b
""" |
m = X.shape[1]
A = sigmoid(np.dot(w.T, X) + b)
cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))
# BACKWARD PROPAGATION (TO FIND GRAD)
dw = 1.0 / m * np.dot(X, (A - Y).T)
db = 1.0 / m * np.sum(A - Y)
assert (dw.shape == w.shape)
assert (db.dtype == float)
cost = np.squeeze(cost)
assert (cost.shape == ())
grads = {"dw": dw,
"db": db}
return grads, cost |
<SYSTEM_TASK:>
This function optimizes w and b by running a gradient descent algorithm
<END_TASK>
<USER_TASK:>
Description:
def LR_train(w, b, X, Y, num_iterations, learning_rate, print_cost=True):
"""
This function optimizes w and b by running a gradient descent algorithm
Arguments:
w weights, a numpy array of size (dim, 1)
b bias, a scalar
X data of shape (dim, number of examples)
Y true "label" vector, of shape (1, number of examples)
num_iterations number of iterations of the optimization loop
learning_rate learning rate of the gradient descent update rule
print_cost True to print the loss every 100 steps
Returns:
params dictionary containing the weights w and bias b
grads dictionary containing the gradients of the weights and bias with respect to the cost function
costs list of all the costs computed during the optimization, this will be used to plot the learning curve.
""" |
costs = []
for i in range(num_iterations):
# Cost and gradient calculation
grads, cost = propagate(w, b, X, Y)
# Retrieve derivatives from grads
dw = grads["dw"]
db = grads["db"]
# update rule
w = w - learning_rate * dw
b = b - learning_rate * db
# Record the costs
if i % 100 == 0:
costs.append(cost)
# Print the cost every 100 training examples
if print_cost and i % 100 == 0:
print("Cost after iteration %i: %f" % (i, cost))
params = {"w": w,
"b": b}
grads = {"dw": dw,
"db": db}
return params, grads, costs |
<SYSTEM_TASK:>
Builds the logistic regression model by calling the function
<END_TASK>
<USER_TASK:>
Description:
def model(X_train, Y_train, X_test, Y_test, num_iterations=2000,
learning_rate=0.5, print_cost=True):
"""
Builds the logistic regression model by calling the function
implemented above
Arguments:
X_train training set represented by a numpy array of shape (dim, m_train)
Y_train training labels represented by a numpy array (vector) of shape (1, m_train)
X_test test set represented by a numpy array of shape (dim, m_test)
Y_test test labels represented by a numpy array (vector) of shape (1, m_test)
num_iterations hyperparameter representing the number of iterations to optimize the parameters
learning_rate hyperparameter representing the learning rate used in the update rule of optimize()
print_cost Set to true to print the cost every 100 iterations
Returns:
d -- dictionary containing information about the model.
""" |
print('X_train shape:', X_train.shape)
# initialize parameters with zeros
w, b = initialize_with_zeros(X_train.shape[0])
print('w shape:', w.shape)
# Gradient descent
parameters, grads, costs = LR_train(w, b, X_train, Y_train, num_iterations,
learning_rate, print_cost)
# Retrieve parameters w and b from dictionary "parameters"
w = parameters["w"]
b = parameters["b"]
print('w shape params:', w.shape)
Y_prediction_test = LR_predict(w, b, X_test)
Y_prediction_train = LR_predict(w, b, X_train)
# Print train/test Errors
print("train accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
print("test accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations}
return d |
<SYSTEM_TASK:>
plot learning curve
<END_TASK>
<USER_TASK:>
Description:
def plot_lc(d):
"""plot learning curve
Arguments:
d Returned by model function. Dictionary containing information about the model.
""" |
costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(d["learning_rate"]))
plt.show() |
<SYSTEM_TASK:>
Return numerical log level or raise ValueError.
<END_TASK>
<USER_TASK:>
Description:
def getLogLevelNo(level):
"""Return numerical log level or raise ValueError.
A valid level is either an integer or a string such as WARNING etc.""" |
if isinstance(level,(int,long)):
return level
try:
return(int(logging.getLevelName(level.upper())))
except:
raise ValueError('illegal loglevel %s' % level) |
<SYSTEM_TASK:>
Return full command line with any necessary quoting.
<END_TASK>
<USER_TASK:>
Description:
def cmdLine(useBasename=False):
"""Return full command line with any necessary quoting.""" |
qargv = []
cmdwords = list(sys.argv)
if useBasename:
cmdwords[0] = os.path.basename(cmdwords[0])
for s in cmdwords:
# any white space or special characters in word so we need quoting?
if re.search(r'\s|\*|\?', s):
if "'" in s:
qargv.append('"%s"' % re.sub('"', "'", s))
else:
qargv.append("'%s'" % re.sub("'", '"', s))
else:
qargv.append(s)
cmd = ' '.join(qargv)
return cmd |
<SYSTEM_TASK:>
Error handling utility. Print more or less error information
<END_TASK>
<USER_TASK:>
Description:
def handleError(exception, debugFlag=False, abortFlag=True):
"""Error handling utility. Print more or less error information
depending on debug flag. Unless abort is set False, exits with
error code 1.""" |
if isinstance(exception, CmdError) or not debugFlag:
error(str(exception))
else:
import traceback
traceback.print_exc()
error(str(exception)) # or log complete traceback as well?
if abortFlag:
sys.exit(1) |
<SYSTEM_TASK:>
Get user confirmation or abort execution.
<END_TASK>
<USER_TASK:>
Description:
def confirm(msg, acceptByDefault=False, exitCodeOnAbort=1, batch=False):
"""Get user confirmation or abort execution.
confirm returns True (if user confirms) or False (if user declines
and exitCodeOnAbort is None) or aborts with sys.exit(exitCodeOnAbort)
(if user declines and exitCodeOnAbort is not None).
Depending on acceptByDefault, the default answer (if user presses
Return only), is to accept or abort. " - are you sure [y] ?" or "
- are you sure [n] ?" will be appended to msg, depending on the
value of acceptByDefault.
If batch is True, returns immediately.""" |
if batch:
return
if acceptByDefault:
msg += ' - are you sure [y] ? '
else:
msg += ' - are you sure [n] ? '
while True:
reply = raw_input(msg).lower()
print
if reply == '':
reply = 'y' if acceptByDefault else 'n'
if reply == 'y':
return True
elif reply == 'n':
if exitCodeOnAbort is None:
return False
else:
error('Program execution aborted by user')
sys.exit(exitCodeOnAbort)
else:
print "ERROR: Invalid reply - please enter either 'y' or 'n', or press just enter to accept default\n" |
<SYSTEM_TASK:>
Write text. An additional attribute terminator with a value of
<END_TASK>
<USER_TASK:>
Description:
def write(self, text):
"""Write text. An additional attribute terminator with a value of
None is added to the logging record to indicate that StreamHandler
should not add a newline.""" |
self.logger.log(self.loglevel, text, extra={'terminator': None}) |
<SYSTEM_TASK:>
Emit a record. Unless record.terminator is set, a trailing
<END_TASK>
<USER_TASK:>
Description:
def emit(self, record):
"""Emit a record. Unless record.terminator is set, a trailing
newline will be written to the output stream.""" |
try:
msg = self.format(record)
if isinstance(msg,unicode):
if hasattr(self.stream, "encoding") and self.stream.encoding:
# Stream should take care of encoding, but do it explicitly to
# prevent bug in Python 2.6 - see
# https://stackoverflow.com/questions/8016236/python-unicode-handling-differences-between-print-and-sys-stdout-write
self.stream.write(msg.encode(self.stream.encoding))
else:
self.stream.write(msg.encode(encoding))
else:
self.stream.write(msg)
terminator = getattr(record, 'terminator', '\n')
if terminator is not None:
self.stream.write(terminator)
self.flush()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.handleError(record) |
<SYSTEM_TASK:>
Flush the stream.
<END_TASK>
<USER_TASK:>
Description:
def flush(self):
"""Flush the stream.
In contrast to StreamHandler, errors are not caught so the program doesn't iterate
through tons of logging errors e.g. in case of a broken pipe.""" |
# See /usr/lib64/python2.7/logging/__init__.py, StreamHander.flush()
self.acquire()
try:
if self.stream and hasattr(self.stream, "flush"):
self.stream.flush()
except IOError as e:
if self.abortOnIOError:
sys.exit('IOError: %s' % e)
else:
raise e
finally:
self.release() |
<SYSTEM_TASK:>
Emit record after checking if message triggers later sending of e-mail.
<END_TASK>
<USER_TASK:>
Description:
def emit(self, record):
"""Emit record after checking if message triggers later sending of e-mail.""" |
if self.triggerLevelNo is not None and record.levelno>=self.triggerLevelNo:
self.triggered = True
logging.handlers.BufferingHandler.emit(self,record) |
<SYSTEM_TASK:>
Send messages by e-mail.
<END_TASK>
<USER_TASK:>
Description:
def flush(self):
"""Send messages by e-mail.
The sending of messages is suppressed if a trigger severity
level has been set and none of the received messages was at
that level or above. In that case the messages are
discarded. Empty e-mails are discarded.""" |
if self.triggered and len(self.buffer) > 0:
# Do not send empty e-mails
text = []
for record in self.buffer:
terminator = getattr(record, 'terminator', '\n')
s = self.format(record)
if terminator is not None:
text.append(s + terminator)
else:
text.append(s)
msg = MIMEText(''.join(text))
msg['From'] = self.fromAddr
msg['To'] = self.toAddr
msg['Subject'] = self.subject
# print 'BufferingSMTPHandler'
# print msg.as_string()
smtp = smtplib.SMTP('localhost')
smtp.sendmail(self.fromAddr, [self.toAddr], msg.as_string())
smtp.quit()
self.buffer = [] |
<SYSTEM_TASK:>
Add optparse or argparse option depending on CmdHelper initialization.
<END_TASK>
<USER_TASK:>
Description:
def add_option(self, *args, **kwargs):
"""Add optparse or argparse option depending on CmdHelper initialization.""" |
if self.parseTool == 'argparse':
if args and args[0] == '': # no short option
args = args[1:]
return self.parser.add_argument(*args, **kwargs)
else:
return self.parser.add_option(*args, **kwargs) |
<SYSTEM_TASK:>
Don't throw an exception when given an out of range character.
<END_TASK>
<USER_TASK:>
Description:
def make_string(seq):
"""
Don't throw an exception when given an out of range character.
""" |
string = ''
for c in seq:
# Screen out non-printing characters
try:
if 32 <= c and c < 256:
string += chr(c)
except TypeError:
pass
# If no printing chars
if not string:
return str(seq)
return string |
<SYSTEM_TASK:>
Read the content of the specified file.
<END_TASK>
<USER_TASK:>
Description:
def read_file(file_path_name):
"""
Read the content of the specified file.
@param file_path_name: path and name of the file to read.
@return: content of the specified file.
""" |
with io.open(os.path.join(os.path.dirname(__file__), file_path_name), mode='rt', encoding='utf-8') as fd:
return fd.read() |
<SYSTEM_TASK:>
Select a cast and perform the next scene.
<END_TASK>
<USER_TASK:>
Description:
def run(self, react=True, strict=True, roles=1):
"""Select a cast and perform the next scene.
:param bool react: If `True`, then Property directives are executed
at the point they are encountered. Pass `False` to skip them
so they can be enacted later on.
:param bool strict: Only fully-cast scripts to be performed.
:param int roles: Maximum number of roles permitted each character.
This method is a generator. It yields events from the performance.
If a :py:class:`~turberfield.dialogue.model.Model.Condition` is
encountered, it is evaluated. No events are generated while the most recent
condition is False.
A new :py:class:`~turberfield.dialogue.model.Model.Shot` resets the
current condition.
""" |
try:
folder, index, self.script, self.selection, interlude = self.next(
self.folders, self.ensemble,
strict=strict, roles=roles
)
except TypeError:
raise GeneratorExit
with self.script as dialogue:
model = dialogue.cast(self.selection).run()
for shot, item in model:
if self.condition is not False:
yield shot
yield item
if not self.shots or self.shots[-1][:2] != shot[:2]:
self.shots.append(shot._replace(items=self.script.fP))
self.condition = None
if isinstance(item, Model.Condition):
self.condition = self.allows(item)
if react:
self.react(item)
for key, value in model.metadata:
if value not in self.metadata[key]:
self.metadata[key].append(value) |
<SYSTEM_TASK:>
Returns the md5-sum of this file. This is of course potentially
<END_TASK>
<USER_TASK:>
Description:
def md5(self):
"""
Returns the md5-sum of this file. This is of course potentially
expensive!
""" |
hash_ = hashlib.md5()
with self.open("rb") as inf:
block = inf.read(4096)
while block:
hash_.update(block)
block = inf.read(4096)
return hash_.hexdigest() |
<SYSTEM_TASK:>
Allows to lock a file via abl.util.LockFile, with the
<END_TASK>
<USER_TASK:>
Description:
def lock(self, fail_on_lock=False, cleanup=False):
"""
Allows to lock a file via abl.util.LockFile, with the
same parameters there.
Returns an opened, writable file.
""" |
return self.connection.lock(self, fail_on_lock, cleanup) |
<SYSTEM_TASK:>
This is a semi-private method. It's current use is to
<END_TASK>
<USER_TASK:>
Description:
def _manipulate(self, *args, **kwargs):
"""
This is a semi-private method. It's current use is to
manipulate memory file system objects so that
you can create certain conditions, to provoke
errors that otherwise won't occur.
""" |
self.connection._manipulate(self, *args, **kwargs) |
<SYSTEM_TASK:>
the semantic should be like unix 'mv' command
<END_TASK>
<USER_TASK:>
Description:
def move(self, source, destination):
"""
the semantic should be like unix 'mv' command
""" |
if source.isfile():
source.copy(destination)
source.remove()
else:
source.copy(destination, recursive=True)
source.remove('r') |
<SYSTEM_TASK:>
Insantiates the subparsers for all commands
<END_TASK>
<USER_TASK:>
Description:
def subparsers(self):
"""
Insantiates the subparsers for all commands
""" |
if self._subparsers is None:
apkw = {
'title': 'commands',
'description': 'Commands for the %s program' % self.parser.prog,
}
self._subparsers = self.parser.add_subparsers(**apkw)
return self._subparsers |
<SYSTEM_TASK:>
Registers a command with the program
<END_TASK>
<USER_TASK:>
Description:
def register(self, command):
"""
Registers a command with the program
""" |
command = command()
if command.name in self.commands:
raise ConsoleError(
"Command %s already registered!" % command.name
)
command.create_parser(self.subparsers)
self.commands[command.name] = command |
<SYSTEM_TASK:>
Exit the console program sanely.
<END_TASK>
<USER_TASK:>
Description:
def exit(self, code=0, message=None):
"""
Exit the console program sanely.
""" |
## If we have a parser, use it to exit
if self._parser:
if code > 0:
self.parser.error(message)
else:
self.parser.exit(code, message)
## Else we are exiting before parser creation
else:
if message is not None:
if code > 0:
sys.stderr.write(message)
else:
sys.stdout.write(message)
sys.exit(code)
## If we're here we didn't exit for some reason?
raise Exception("Unable to exit the %s" % self.__class__.__name__) |
<SYSTEM_TASK:>
Entry point to the execution of the program.
<END_TASK>
<USER_TASK:>
Description:
def execute(self):
"""
Entry point to the execution of the program.
""" |
# Ensure that we have commands registered
if not self.commands or self._parser is None:
raise NotImplementedError(
"No commands registered with this program!"
)
# Handle input from the command line
args = self.parser.parse_args() # Parse the arguments
try:
handle_default_args(args) # Handle the default args
if not hasattr(args, 'func'): # Handle no subcommands
self.parser.print_help()
self.exit(0)
msg = args.func(args) # Call the default function
msg = "{}\n".format(msg) if msg else '' # Format the message
self.exit(0, msg) # Exit cleanly with message
except Exception as e:
if hasattr(args, 'traceback') and args.traceback:
traceback.print_exc()
msg = color.format(str(e), color.RED)
self.exit(1, msg) |
<SYSTEM_TASK:>
gets supported langs as an array
<END_TASK>
<USER_TASK:>
Description:
def get_lang_array(self):
"""gets supported langs as an array""" |
r = self.yandex_translate_request("getLangs", "")
self.handle_errors(r)
return r.json()["dirs"] |
<SYSTEM_TASK:>
gets supported langs as an dictionary
<END_TASK>
<USER_TASK:>
Description:
def get_lang_dict(self):
"""gets supported langs as an dictionary""" |
r = self.yandex_translate_request("getLangs")
self.handle_errors(r)
return r.json()["langs"] |
<SYSTEM_TASK:>
Init the browsing instance if not setup
<END_TASK>
<USER_TASK:>
Description:
def _browser_init(self):
"""
Init the browsing instance if not setup
:rtype: None
""" |
if self.session:
return
self.session = requests.Session()
headers = {}
if self.user_agent:
headers['User-agent'] = self.user_agent
self.session.headers.update(headers)
if self._auth_method in [None, "", "HTTPBasicAuth"]:
if self._auth_username is not None:
self.session.auth = (self._auth_username, self._auth_password) |
<SYSTEM_TASK:>
Load scraper settings from file
<END_TASK>
<USER_TASK:>
Description:
def load_scrap(self, path):
"""
Load scraper settings from file
:param path: Path to file
:type path: str
:rtype: None
:raises WEBFileException: Failed to load settings
:raises WEBParameterException: Missing parameters in file
""" |
try:
conf = self.load_settings(path)
except:
# Should only be IOError
self.exception("Failed to load file")
raise WEBFileException("Failed to load from {}".format(path))
if "scheme" not in conf:
raise WEBParameterException("Missing scheme definition")
if "url" not in conf:
raise WEBParameterException("Missing url definition")
version = conf.get('version', None)
if version != "1.0":
raise WEBParameterException(
"Unsupported version {}".format(version)
)
self.scheme = conf['scheme']
self.url = conf['url']
self.timeout = conf.get('timeout', self.timeout)
if conf.get('html2text'):
self._set_html2text(conf['html2text']) |
<SYSTEM_TASK:>
Make a request using the requests library
<END_TASK>
<USER_TASK:>
Description:
def request(
self, method, url, timeout=None,
headers=None, data=None, params=None
):
"""
Make a request using the requests library
:param method: Which http method to use (GET/POST)
:type method: str | unicode
:param url: Url to make request to
:type url: str | unicode
:param timeout: Timeout for request (default: None)
None -> infinite timeout
:type timeout: None | int | float
:param headers: Headers to be passed along (default: None)
:type headers: None | dict
:param data: Data to be passed along (e.g. body in POST)
(default: None)
:type data: None | dict
:param params: Parameters to be passed along (e.g. with url in GET)
(default: None)
:type params: None | dict
:return: Response to the request
:rtype: requests.Response
:raises WEBConnectException: Loading failed
""" |
if headers is None:
headers = {}
if not self.session:
self._browser_init()
try:
response = self.session.request(
method,
url,
timeout=timeout,
allow_redirects=self._handle_redirect,
headers=headers,
data=data,
params=params
)
except SSLError as e:
raise WEBConnectException(e)
except HTTPError:
raise WEBConnectException("Unable to load {}".format(url))
except (Timeout, socket.timeout):
raise WEBConnectException("Timeout loading {}".format(url))
except ConnectionError:
raise WEBConnectException("Failed to load {}".format(url))
except Exception:
self.exception("Failed to load {}".format(url))
raise WEBConnectException(
"Unknown failure loading {}".format(url)
)
return response |
<SYSTEM_TASK:>
Scrap a url and parse the content according to scheme
<END_TASK>
<USER_TASK:>
Description:
def scrap(self,
url=None, scheme=None, timeout=None,
html_parser=None, cache_ext=None
):
"""
Scrap a url and parse the content according to scheme
:param url: Url to parse (default: self._url)
:type url: str
:param scheme: Scheme to apply to html (default: self._scheme)
:type scheme: dict
:param timeout: Timeout for http operation (default: self._timout)
:type timeout: float
:param html_parser: What html parser to use (default: self._html_parser)
:type html_parser: str | unicode
:param cache_ext: External cache info
:type cache_ext: floscraper.models.CacheInfo
:return: Response data from url and parsed info
:rtype: floscraper.models.Response
:raises WEBConnectException: HTTP get failed
:raises WEBParameterException: Missing scheme or url
""" |
if not url:
url = self.url
if not scheme:
scheme = self.scheme
if not timeout:
timeout = self.timeout
if not html_parser:
html_parser = self.html_parser
if not scheme:
raise WEBParameterException("Missing scheme definition")
if not url:
raise WEBParameterException("Missing url definition")
resp = self.get(url, timeout, cache_ext=cache_ext)
soup = BeautifulSoup(resp.html, html_parser)
resp.scraped = self._parse_scheme(soup, scheme)
return resp |
<SYSTEM_TASK:>
Shrink list down to essentials
<END_TASK>
<USER_TASK:>
Description:
def _shrink_list(self, shrink):
"""
Shrink list down to essentials
:param shrink: List to shrink
:type shrink: list
:return: Shrunk list
:rtype: list
""" |
res = []
if len(shrink) == 1:
return self.shrink(shrink[0])
else:
for a in shrink:
temp = self.shrink(a)
if temp:
res.append(temp)
return res |
<SYSTEM_TASK:>
Shrink dict down to essentials
<END_TASK>
<USER_TASK:>
Description:
def _shrink_dict(self, shrink):
"""
Shrink dict down to essentials
:param shrink: Dict to shrink
:type shrink: dict
:return: Shrunk dict
:rtype: dict
""" |
res = {}
if len(shrink.keys()) == 1 and "value" in shrink:
return self.shrink(shrink['value'])
else:
for a in shrink:
res[a] = self.shrink(shrink[a])
if not res[a]:
del res[a]
return res |
<SYSTEM_TASK:>
Remove unnecessary parts
<END_TASK>
<USER_TASK:>
Description:
def shrink(self, shrink):
"""
Remove unnecessary parts
:param shrink: Object to shringk
:type shrink: dict | list
:return: Shrunk object
:rtype: dict | list
""" |
if isinstance(shrink, list):
return self._shrink_list(shrink)
if isinstance(shrink, dict):
return self._shrink_dict(shrink)
return shrink |
<SYSTEM_TASK:>
Simulate scattering at a sphere
<END_TASK>
<USER_TASK:>
Description:
def simulate(radius=5e-6, sphere_index=1.339, medium_index=1.333,
wavelength=550e-9, grid_size=(80, 80), model="projection",
pixel_size=None, center=None):
"""Simulate scattering at a sphere
Parameters
----------
radius: float
Radius of the sphere [m]
sphere_index: float
Refractive index of the object
medium_index: float
Refractive index of the surrounding medium
wavelength: float
Vacuum wavelength of the imaging light [m]
grid_size: tuple of ints or int
Resulting image size in x and y [px]
model: str
Sphere model to use (see :const:`available`)
pixel_size: float or None
Pixel size [m]; if set to `None` the pixel size is
chosen such that the radius fits at least three to
four times into the grid.
center: tuple of floats or None
Center position in image coordinates [px]; if set to
None, the center of the image (grid_size - 1)/2 is
used.
Returns
-------
qpi: qpimage.QPImage
Quantitative phase data set
""" |
if isinstance(grid_size, numbers.Integral):
# default to square-shape grid
grid_size = (grid_size, grid_size)
if pixel_size is None:
# select simulation automatically
rl = radius / wavelength
if rl < 5:
# a lot of diffraction artifacts may occur;
# use 4x radius to capture the full field
fact = 4
elif rl >= 5 and rl <= 10:
# linearly decrease towards 3x radius
fact = 4 - (rl - 5) / 5
else:
# not many diffraction artifacts occur;
# 3x radius is enough and allows to
# simulate larger radii with BHFIELD
fact = 3
pixel_size = fact * radius / np.min(grid_size)
if center is None:
center = (np.array(grid_size) - 1) / 2
model = model_dict[model]
qpi = model(radius=radius,
sphere_index=sphere_index,
medium_index=medium_index,
wavelength=wavelength,
pixel_size=pixel_size,
grid_size=grid_size,
center=center)
return qpi |
<SYSTEM_TASK:>
Current interpolation range of refractive index
<END_TASK>
<USER_TASK:>
Description:
def range_n(self):
"""Current interpolation range of refractive index""" |
return self.sphere_index - self.dn, self.sphere_index + self.dn |
<SYSTEM_TASK:>
Current interpolation range of radius
<END_TASK>
<USER_TASK:>
Description:
def range_r(self):
"""Current interpolation range of radius""" |
return self.radius - self.dr, self.radius + self.dr |
<SYSTEM_TASK:>
Compute model data with current parameters
<END_TASK>
<USER_TASK:>
Description:
def compute_qpi(self):
"""Compute model data with current parameters
Returns
-------
qpi: qpimage.QPImage
Modeled phase data
Notes
-----
The model image might deviate from the fitted image
because of interpolation during the fitting process.
""" |
kwargs = self.model_kwargs.copy()
kwargs["radius"] = self.radius
kwargs["sphere_index"] = self.sphere_index
kwargs["center"] = [self.posx_offset, self.posy_offset]
qpi = self.sphere_method(**kwargs)
# apply phase offset
bg_data = np.ones(qpi.shape) * -self.pha_offset
qpi.set_bg_data(bg_data=bg_data, which_data="phase")
return qpi |
<SYSTEM_TASK:>
Return one of nine border fields
<END_TASK>
<USER_TASK:>
Description:
def get_border_phase(self, idn=0, idr=0):
"""Return one of nine border fields
Parameters
----------
idn: int
Index for refractive index.
One of -1 (left), 0 (center), 1 (right)
idr: int
Index for radius.
One of -1 (left), 0 (center), 1 (right)
""" |
assert idn in [-1, 0, 1]
assert idr in [-1, 0, 1]
n = self.sphere_index + self.dn * idn
r = self.radius + self.dr * idr
# convert to array indices
idn += 1
idr += 1
# find out whether we need to compute a new border field
if self._n_border[idn, idr] == n and self._r_border[idn, idr] == r:
if self.verbose > 3:
print("Using cached border phase (n{}, r{})".format(idn, idr))
# return previously computed field
pha = self._border_pha[(idn, idr)]
else:
if self.verbose > 3:
print("Computing border phase (n{}, r{})".format(idn, idr))
kwargs = self.model_kwargs.copy()
kwargs["radius"] = r
kwargs["sphere_index"] = n
kwargs["center"] = [self.posx_offset, self.posy_offset]
tb = time.time()
pha = self.sphere_method(**kwargs).pha
if self.verbose > 2:
print("Border phase computation time:",
self.sphere_method.__module__, time.time() - tb)
self._border_pha[(idn, idr)] = pha
self._n_border[idn, idr] = n
self._r_border[idn, idr] = r
return pha |
<SYSTEM_TASK:>
Interpolate from the border fields to new coordinates
<END_TASK>
<USER_TASK:>
Description:
def get_phase(self, nintp=None, rintp=None,
delta_offset_x=0, delta_offset_y=0):
"""Interpolate from the border fields to new coordinates
Parameters
----------
nintp: float or None
Refractive index of the sphere
rintp: float or None
Radius of sphere [m]
delta_offset_x: float
Offset in x-direction [px]
delta_offset_y: float
Offset in y-direction [px]
Returns
-------
phase_intp: 2D real-valued np.ndarray
Interpolated phase at the given parameters
Notes
-----
Not all combinations are poosible, e.g.
- One of nintp or rintp must be None
- The current interpolation range must include the values
for rintp and nintp
""" |
if nintp is None:
nintp = self.sphere_index
if rintp is None:
rintp = self.radius
assert (rintp == self.radius or nintp ==
self.sphere_index), "Only r or n can be changed at a time."
assert rintp >= self.radius - self.dr
assert rintp <= self.radius + self.dr
assert nintp >= self.sphere_index - \
self.dn, "Out of range: {} !> {}".format(
nintp, self.sphere_index - self.dn)
assert nintp <= self.sphere_index + self.dn
left = self.get_border_phase(0, 0)
if rintp == self.radius:
dist = nintp - self.sphere_index
dmax = self.dn
if dist < 0:
righ = self.get_border_phase(-1, 0)
else:
righ = self.get_border_phase(1, 0)
else:
dist = rintp - self.radius
dmax = self.dr
if dist < 0:
righ = self.get_border_phase(0, -1)
else:
righ = self.get_border_phase(0, 1)
# make dist positive so that we are interpolating from left to right
dist = np.abs(dist)
# perform linear interpolation of data.
phas = left + (righ - left) * dist / dmax
# interpolation of lateral movement
ti = time.time()
ipphas = spintp.RectBivariateSpline(np.arange(phas.shape[0]),
np.arange(phas.shape[1]),
phas)
if delta_offset_x != 0 or delta_offset_y != 0:
# Shift the image. The offset values used here
# are not self.posx_offset and self.posy_offset!
# The offset values are added to the fields computed
# with self.posx_offset and self.posy_offset.
newx = np.arange(phas.shape[0]) + delta_offset_x
newy = np.arange(phas.shape[1]) + delta_offset_y
phas = ipphas(newx, newy)
if self.verbose > 2:
print("Interpolation time for {}: {}".format(
self.model, time.time() - ti))
return phas + self.pha_offset |
<SYSTEM_TASK:>
Builds a message from some headers and MIME parts.
<END_TASK>
<USER_TASK:>
Description:
def buildMessage(headers, parts):
"""
Builds a message from some headers and MIME parts.
""" |
message = multipart.MIMEMultipart('alternative')
for name, value in headers.iteritems():
name = name.title()
if name == "From":
multipart[name] = _encodeAddress(value)
elif name in ["To", "Cc", "Bcc"]:
multipart[name] = _encodeAddresses(value)
else:
multipart[name] = _encodeHeader(value)
for partType, part in parts.iteritems():
mimeText = text.MIMEText(part.encode("utf-8"), partType, "UTF-8")
message.attach(mimeText.encode())
return message |
<SYSTEM_TASK:>
Encodes a header value.
<END_TASK>
<USER_TASK:>
Description:
def _encodeHeader(headerValue):
"""
Encodes a header value.
Returns ASCII if possible, else returns an UTF-8 encoded e-mail header.
""" |
try:
return headerValue.encode('ascii', 'strict')
except UnicodeError:
encoded = headerValue.encode("utf-8")
return header.Header(encoded, "UTF-8").encode() |
<SYSTEM_TASK:>
Flattens a message into a file-like object.
<END_TASK>
<USER_TASK:>
Description:
def messageToFile(message):
"""
Flattens a message into a file-like object.
""" |
outFile = StringIO()
messageGenerator = generator.Generator(outFile, False)
messageGenerator.flatten(message)
outFile.seek(0, 0)
return outFile |
<SYSTEM_TASK:>
Determine refractive index and radius using Canny edge detection
<END_TASK>
<USER_TASK:>
Description:
def analyze(qpi, r0, edgekw={}, ret_center=False, ret_edge=False):
"""Determine refractive index and radius using Canny edge detection
Compute the refractive index of a spherical phase object by
detection of an edge in the phase image, a subsequent circle
fit to the edge, and finally a weighted average over the phase
image assuming a parabolic phase profile.
Parameters
----------
qpi: QPImage
Quantitative phase image information
r0: float
Approximate radius of the sphere [m]
edgekw: dict
Additional keyword arguments for :func:`contour_canny`
ret_center: bool
Return the center coordinate of the sphere
Returns
-------
n: float
Computed refractive index
r: float
Computed radius [m]
center: tuple of floats
Center position of the sphere [px], only returned
if `ret_center` is `True`
""" |
nmed = qpi["medium index"]
px_m = qpi["pixel size"]
wl_m = qpi["wavelength"]
px_wl = px_m / wl_m
phase = qpi.pha
# determine edge
edge = contour_canny(image=phase,
radius=r0 / px_m,
verbose=False,
**edgekw,
)
# fit circle to edge
center, r = circle_fit(edge)
# compute average phase density
avg_phase = average_sphere(phase, center, r)
# convert phase average to refractive index
n = nmed + avg_phase / (2 * np.pi * px_wl)
# convert radius from pixels to meters
ret = [n, r * px_m]
if ret_center:
ret.append(center)
if ret_edge:
ret.append(edge)
return ret |
<SYSTEM_TASK:>
Compute the weighted average phase from a phase image of a sphere
<END_TASK>
<USER_TASK:>
Description:
def average_sphere(image, center, radius, weighted=True, ret_crop=False):
"""Compute the weighted average phase from a phase image of a sphere
Parameters
----------
image: 2d ndarray
Quantitative phase image of a sphere
center: tuble (x,y)
Center of the sphere in `image` in ndarray coordinates
radius: float
Radius of the sphere in pixels
weighted: bool
If `True`, return average phase density weighted with the
height profile obtained from the radius, otherwise return
simple average phase density. Weighting gives data points
at the center of the sphere more weight than those points
at the boundary of the sphere, avoiding edge artifacts.
ret_crop: bool
Return the cropped image.
Returns
-------
average: float
The average phase value of the sphere from which the refractive
index can be computed
cropped_image: 2d ndarray
Returned if `ret_crop` is True
""" |
sx, sy = image.shape
x = np.arange(sx).reshape(-1, 1)
y = np.arange(sy).reshape(1, -1)
discsq = ((x - center[0])**2 + (y - center[1])**2)
root = radius**2 - discsq
# height of the cell for each x and y
h = 2 * np.sqrt(root * (root > 0))
# compute phase density
rho = np.zeros(image.shape)
hbin = h != 0
# phase density [rad/px]
rho[hbin] = image[hbin] / h[hbin]
if weighted:
# compute weighted average
average = np.sum(rho * h) / np.sum(h)
else:
# compute simple average
average = np.sum(rho) / np.sum(hbin)
ret = average
if ret_crop:
ret = (ret, rho)
return ret |
<SYSTEM_TASK:>
Fit a circle to a boolean edge image
<END_TASK>
<USER_TASK:>
Description:
def circle_fit(edge, ret_dev=False):
"""Fit a circle to a boolean edge image
Parameters
----------
edge: 2d boolean ndarray
Edge image
ret_dev: bool
Return the average deviation of the distance from contour to
center of the fitted circle.
Returns
-------
center: tuple of (float, float)
Coordinates of the circle center
radius: float
Radius of the circle [px]
rdev:
Only returned if `ret_dev` is True
Average deviation of the radius from the circle
""" |
sx, sy = edge.shape
x = np.linspace(0, sx, sx, endpoint=False).reshape(-1, 1)
y = np.linspace(0, sy, sy, endpoint=False).reshape(1, -1)
params = lmfit.Parameters()
# initial parameters
sum_edge = np.sum(edge)
params.add("cx", np.sum(x * edge) / sum_edge)
params.add("cy", np.sum(y * edge) / sum_edge)
# data
xedge, yedge = np.where(edge)
# minimize
out = lmfit.minimize(circle_residual, params, args=(xedge, yedge))
center = (out.params["cx"].value, out.params["cy"].value)
radii = circle_radii(out.params, xedge, yedge)
radius = np.mean(radii)
ret = [center, radius]
if ret_dev:
dev = np.average(np.abs(radii - radius))
ret.append(dev)
return ret |
<SYSTEM_TASK:>
Compute the distance to the center from cartesian coordinates
<END_TASK>
<USER_TASK:>
Description:
def circle_radii(params, xedge, yedge):
"""Compute the distance to the center from cartesian coordinates
This method is used for fitting a circle to a set of contour
points.
Parameters
----------
params: lmfit.Parameters
Must contain the keys:
- "cx": origin of x coordinate [px]
- "cy": origin of y coordinate [px]
xedge: 1D np.ndarray
Edge coordinates x [px]
yedge: 1D np.ndarray
Edge coordinates y [px]
Returns
-------
radii: 1D np.ndarray
Radii corresponding to edge coordinates relative to origin
""" |
cx = params["cx"].value
cy = params["cy"].value
radii = np.sqrt((cx - xedge)**2 + (cy - yedge)**2)
return radii |
<SYSTEM_TASK:>
Residuals for circle fitting
<END_TASK>
<USER_TASK:>
Description:
def circle_residual(params, xedge, yedge):
"""Residuals for circle fitting
Parameters
----------
params: lmfit.Parameters
Must contain the keys:
- "cx": origin of x coordinate [px]
- "cy": origin of y coordinate [px]
xedge: 1D np.ndarray
Edge coordinates x [px]
yedge: 1D np.ndarray
Edge coordinates y [px]
Returns
-------
rad_dev: 1D np.ndarray
Deviation of radii from average radius
""" |
radii = circle_radii(params, xedge, yedge)
return radii - np.mean(radii) |
<SYSTEM_TASK:>
Make an XML-RPC call to the server. This method will automatically
<END_TASK>
<USER_TASK:>
Description:
def call(self, action, payload):
"""
Make an XML-RPC call to the server. This method will automatically
authenticate the call with self.api_key, if that is set.
returns: deferred that when fired returns a dict with data from this
XML-RPC call.
""" |
if self.api_key:
payload['Bugzilla_api_key'] = self.api_key
d = self.proxy.callRemote(action, payload)
d.addErrback(self._parse_errback)
return d |
<SYSTEM_TASK:>
Assign a bug to a user.
<END_TASK>
<USER_TASK:>
Description:
def assign(self, bugids, user):
"""
Assign a bug to a user.
param bugid: ``int``, bug ID number.
param user: ``str``, the login name of the user to whom the bug is
assigned
returns: deferred that when fired returns True if the change succeeded,
False if the change was unnecessary (because the user is
already assigned.)
""" |
payload = {'ids': (bugids,), 'assigned_to': user}
d = self.call('Bug.update', payload)
d.addCallback(self._parse_bug_assigned_callback)
return d |
<SYSTEM_TASK:>
Find a list of bugs by searching an external tracker URL and ID.
<END_TASK>
<USER_TASK:>
Description:
def find_by_external_tracker(self, url, id_):
"""
Find a list of bugs by searching an external tracker URL and ID.
param url: ``str``, the external ticket URL, eg
"http://tracker.ceph.com". (Note this is the base URL.)
param id_: ``str``, the external ticket ID, eg "18812".
returns: deferred that when fired returns a list of ``AttrDict``s
representing these bugs.
""" |
payload = {
'include_fields': ['id', 'summary', 'status'],
'f1': 'external_bugzilla.url',
'o1': 'substring',
'v1': url,
'f2': 'ext_bz_bug_map.ext_bz_bug_id',
'o2': 'equals',
'v2': id_,
}
d = self.call('Bug.search', payload)
d.addCallback(self._parse_bugs_callback)
return d |
<SYSTEM_TASK:>
Fires when we get bug information back from the XML-RPC server.
<END_TASK>
<USER_TASK:>
Description:
def _parse_bugs_callback(self, value):
"""
Fires when we get bug information back from the XML-RPC server.
param value: dict of data from XML-RPC server. The "bugs" dict element
contains a list of bugs.
returns: ``list`` of ``AttrDict``
""" |
return list(map(lambda x: self._parse_bug(x), value['bugs'])) |
<SYSTEM_TASK:>
The plugin has been changed by the frontend
<END_TASK>
<USER_TASK:>
Description:
def onSettingsChange(self, plugin_name, data):
"""
The plugin has been changed by the frontend
:param plugin_name: Name of plugin that changed
:type plugin_name: str
:param data: Complete data (changed and unchanged)
:type data: dict
:rtype: None
""" |
logger.info(u"onSettingsChange: {}".format(data))
if not plugin_name:
logger.error("Missing plugin name")
return
if not data:
logger.error("Missing data")
return
logger.info(u"Sending data {}".format(data))
reactor.callFromThread(self._sendJSON, {
'msg': "plugin_data_set",
'plugin_name': plugin_name,
'data': data
})
# trigger db update
reactor.callFromThread(self._sendJSON, {
'msg': "plugin_data_get",
'plugin_name': plugin_name
}) |
<SYSTEM_TASK:>
Frontend requests a data refresh
<END_TASK>
<USER_TASK:>
Description:
def onRefreshPluginData(self, plugin_name, data):
"""
Frontend requests a data refresh
:param plugin_name: Name of plugin that changed
:type plugin_name: str
:param data: Additional data
:type data: None
:rtype: None
""" |
logger.info(u"onRefreshPluginData: {}".format(plugin_name))
if not plugin_name:
logger.error("Missing plugin name")
return
reactor.callFromThread(self._sendJSON, {
'msg': "plugin_data_get",
'plugin_name': plugin_name
}) |
<SYSTEM_TASK:>
This just creates the websocket connection
<END_TASK>
<USER_TASK:>
Description:
def connect(self,soft_reset=False,**options):
""" This just creates the websocket connection
""" |
self._state = STATE_CONNECTING
logger.debug("About to connect to {}".format(self.url))
m = re.search('(ws+)://([\w\.]+)(:?:(\d+))?',self.url)
options['subprotocols'] = ['wamp.2.json']
options['enable_multithread'] = True
options.setdefault('timeout',self._loop_timeout)
# Handle the weird issue in websocket that the origin
# port will be always http://host:port even though connection is
# wss. This causes some origin issues with demo.crossbar.io demo
# so we ensure we use http or https appropriately depending on the
# ws or wss protocol
if m and m.group(1).lower() == 'wss':
origin_port = ':'+m.group(3) if m.group(3) else ''
options['origin'] = u'https://{}{}'.format(m.group(2),origin_port)
# Attempt connection once unless it's autoreconnect in which
# case we try and try again...
while True:
try:
if self.sslopt:
options.setdefault('sslopt',self.sslopt)
# By default if no settings are chosen we apply
# the looser traditional policy (makes life less
# secure but less excruciating on windows)
if options.get('sslopt') is None:
options['sslopt'] = {
"cert_reqs":ssl.CERT_NONE,
"check_hostname": False
}
if self.sockopt:
options.setdefault('sockopt',self.sockopt)
self.ws = websocket.create_connection(
self.url,
**options
)
self.handle_connect()
except Exception as ex:
if self.auto_reconnect:
logger.debug(
"Error connecting to {url}. Reconnection attempt in {retry} second(s). {err}".format(
url=self.url,
retry=self.auto_reconnect,
err=ex
)
)
time.sleep(self.auto_reconnect)
continue
else:
raise
break
logger.debug("Connected to {}".format(self.url))
if not soft_reset:
self._subscriptions = {}
self._registered_calls = {}
self._requests_pending = {}
self._state = STATE_WEBSOCKET_CONNECTED
# notify the threading.Conditional that restart can happen
self._request_loop_notify_restart.acquire()
self._request_loop_notify_restart.notify()
self._request_loop_notify_restart.release() |
<SYSTEM_TASK:>
Say hello to the server and wait for the welcome
<END_TASK>
<USER_TASK:>
Description:
def hello(self,details=None):
""" Say hello to the server and wait for the welcome
message before proceeding
""" |
self._welcome_queue = queue.Queue()
if details is None:
details = {}
if self.authid:
details.setdefault('authid', self.authid)
details.setdefault('agent', u'swampyer-1.0')
details.setdefault('authmethods', self.authmethods or [u'anonymous'])
details.setdefault('roles', {
'subscriber': {},
'publisher': {},
'caller': {},
'callee': {},
})
self._state = STATE_AUTHENTICATING
self.send_message(HELLO(
realm = self.realm,
details = details
))
# Wait till we get a welcome message
try:
message = self._welcome_queue.get(block=True,timeout=self.timeout)
except Exception as ex:
raise ExWelcomeTimeout("Timed out waiting for WELCOME response")
if message == WAMP_ABORT:
raise ExAbort("Received abort when trying to connect: {}".format(
message.details.get('message',
message.reason)))
self.session_id = message.session_id
self.peer = message
self._state = STATE_CONNECTED
# And hook register/subscribe to anything that's required
self.handle_join(message) |
<SYSTEM_TASK:>
Send awamp message to the server. We don't wait
<END_TASK>
<USER_TASK:>
Description:
def send_message(self,message):
""" Send awamp message to the server. We don't wait
for a response here. Just fire out a message
""" |
if self._state == STATE_DISCONNECTED:
raise Exception("WAMP is currently disconnected!")
message = message.as_str()
logger.debug("SND>: {}".format(message))
if not self.ws:
raise Exception("WAMP is currently disconnected!")
self.ws.send(message) |
<SYSTEM_TASK:>
Used by most things. Sends out a request then awaits a response
<END_TASK>
<USER_TASK:>
Description:
def send_and_await_response(self,request):
""" Used by most things. Sends out a request then awaits a response
keyed by the request_id
""" |
if self._state == STATE_DISCONNECTED:
raise Exception("WAMP is currently disconnected!")
wait_queue = queue.Queue()
request_id = request.request_id
self._requests_pending[request_id] = wait_queue;
self.send_message(request)
try:
return wait_queue.get(block=True,timeout=self.timeout)
except Exception as ex:
raise Exception("Did not receive a response!") |
<SYSTEM_TASK:>
Send dat ato the appropriate queues
<END_TASK>
<USER_TASK:>
Description:
def dispatch_to_awaiting(self,result):
""" Send dat ato the appropriate queues
""" |
# If we are awaiting to login, then we might also get
# an abort message. Handle that here....
if self._state == STATE_AUTHENTICATING:
# If the authentication message is something unexpected,
# we'll just ignore it for now
if result == WAMP_ABORT \
or result == WAMP_WELCOME \
or result == WAMP_GOODBYE:
self._welcome_queue.put(result)
return
try:
request_id = result.request_id
if request_id in self._requests_pending:
self._requests_pending[request_id].put(result)
del self._requests_pending[request_id]
except:
raise Exception("Response does not have a request id. Do not know who to send data to. Data: {} ".format(result.dump())) |
<SYSTEM_TASK:>
Passes the invocation request to the appropriate
<END_TASK>
<USER_TASK:>
Description:
def handle_invocation(self, message):
""" Passes the invocation request to the appropriate
callback.
""" |
req_id = message.request_id
reg_id = message.registration_id
if reg_id in self._registered_calls:
handler = self._registered_calls[reg_id][REGISTERED_CALL_CALLBACK]
invoke = WampInvokeWrapper(self,handler,message)
invoke.start()
else:
error_uri = self.get_full_uri('error.unknown.uri')
self.send_message(ERROR(
request_code = WAMP_INVOCATION,
request_id = req_id,
details = {},
error =error_uri
)) |
<SYSTEM_TASK:>
Send the event to the subclass or simply reject
<END_TASK>
<USER_TASK:>
Description:
def handle_event(self, event):
""" Send the event to the subclass or simply reject
""" |
subscription_id = event.subscription_id
if subscription_id in self._subscriptions:
# FIXME: [1] should be a constant
handler = self._subscriptions[subscription_id][SUBSCRIPTION_CALLBACK]
WampSubscriptionWrapper(self,handler,event).start() |
<SYSTEM_TASK:>
Subscribe to a uri for events from a publisher
<END_TASK>
<USER_TASK:>
Description:
def subscribe(self,topic,callback=None,options=None):
""" Subscribe to a uri for events from a publisher
""" |
full_topic = self.get_full_uri(topic)
result = self.send_and_await_response(SUBSCRIBE(
options=options or {},
topic=full_topic
))
if result == WAMP_SUBSCRIBED:
if not callback:
callback = lambda a: None
self._subscriptions[result.subscription_id] = [topic,callback] |
<SYSTEM_TASK:>
Publishes a messages to the server
<END_TASK>
<USER_TASK:>
Description:
def publish(self,topic,options=None,args=None,kwargs=None):
""" Publishes a messages to the server
""" |
topic = self.get_full_uri(topic)
if options is None:
options = {'acknowledge':True}
if options.get('acknowledge'):
request = PUBLISH(
options=options or {},
topic=topic,
args=args or [],
kwargs=kwargs or {}
)
result = self.send_and_await_response(request)
return result
else:
request = PUBLISH(
options=options or {},
topic=topic,
args=args or [],
kwargs=kwargs or {}
)
self.send_message(request)
return request.request_id |
<SYSTEM_TASK:>
Disconnect from the websocket and pause the process
<END_TASK>
<USER_TASK:>
Description:
def disconnect(self):
""" Disconnect from the websocket and pause the process
till we reconnect
""" |
logger.debug("Disconnecting")
# Close off the websocket
if self.ws:
try:
if self._state == STATE_CONNECTED:
self.handle_leave()
self.send_message(GOODBYE(
details={},
reason="wamp.error.system_shutdown"
))
logger.debug("Closing Websocket")
try:
self.ws.close()
except Exception as ex:
logger.debug("Could not close websocket connection because: {}".format(ex))
except Exception as ex:
logger.debug("Could not send Goodbye message because {}".format(ex))
pass # FIXME: Maybe do better handling here
self.ws = None
# Cleanup the state variables. By settings this
# we're going to be telling the main loop to stop
# trying to read from a websocket and await a notice
# of restart via a threading.Condition object
self._state = STATE_DISCONNECTED
# Send a message to all queues that we have disconnected
# Without this, any requests that are awaiting a response
# will block until timeout needlessly
for request_id, request_queue in self._requests_pending.items():
request_queue.put(GOODBYE(
details={},
reason="wamp.error.system_shutdown"
))
self._requests_pending = {}
self.handle_disconnect() |
<SYSTEM_TASK:>
Request the system to shutdown the main loop and shutdown the system
<END_TASK>
<USER_TASK:>
Description:
def shutdown(self):
""" Request the system to shutdown the main loop and shutdown the system
This is a one-way trip! Reconnecting requires a new connection
to be made!
""" |
self._request_shutdown = True
for i in range(100):
if self._state == STATE_DISCONNECTED:
break
time.sleep(0.1) |
<SYSTEM_TASK:>
Initialize websockets, say hello, and start listening for events
<END_TASK>
<USER_TASK:>
Description:
def start(self):
""" Initialize websockets, say hello, and start listening for events
""" |
self.connect()
if not self.isAlive():
super(WAMPClient,self).start()
self.hello()
return self |
<SYSTEM_TASK:>
Waits and receives messages from the server. This
<END_TASK>
<USER_TASK:>
Description:
def run(self):
""" Waits and receives messages from the server. This
function somewhat needs to block so is executed in its
own thread until self._request_shutdown is called.
""" |
while not self._request_shutdown:
# Find out if we have any data pending from the
# server
try:
# If we've been asked to stop running the
# request loop. We'll just sit and wait
# till we get asked to run again
if self._state not in [STATE_AUTHENTICATING,STATE_WEBSOCKET_CONNECTED,STATE_CONNECTED]:
self._request_loop_notify_restart.acquire()
self._request_loop_notify_restart.wait(self._loop_timeout)
self._request_loop_notify_restart.release()
continue
# If we don't have a websocket defined.
# we don't go further either
elif not self.ws:
logger.debug("No longer have a websocket. Marking disconnected")
self._state = STATE_DISCONNECTED
continue
# Okay, we think we're okay so let's try and read some data
data = self.ws.recv()
except io.BlockingIOError:
continue
except websocket.WebSocketTimeoutException:
continue
except websocket.WebSocketConnectionClosedException as ex:
logger.debug("WebSocketConnectionClosedException: Requesting disconnect:".format(ex))
self.disconnect()
# If the server disconnected, let's try and reconnect
# back to the service after a random few seconds
if self.auto_reconnect:
# As doing a reconnect would block and would then
# prevent us from ticking the websoocket, we'll
# go into a subthread to deal with the reconnection
def reconnect():
self.reconnect()
t = threading.Thread(target=reconnect)
t.start()
# FIXME: need to randomly wait
time.sleep(1)
if not data: continue
except Exception as ex:
logger.error("ERROR in main loop: {}".format(ex))
continue
try:
logger.debug("<RCV: {}".format(data))
message = WampMessage.loads(data)
logger.debug("<RCV: {}".format(message.dump()))
try:
code_name = message.code_name.lower()
handler_name = "handle_"+code_name
handler_function = getattr(self,handler_name)
handler_function(message)
except AttributeError as ex:
self.handle_unknown(message)
except Exception as ex:
logger.error("ERROR in main loop: {}".format(ex)) |
<SYSTEM_TASK:>
Executed when the server requests additional
<END_TASK>
<USER_TASK:>
Description:
def handle_challenge(self,data):
""" Executed when the server requests additional
authentication
""" |
# Send challenge response
self.send_message(AUTHENTICATE(
signature = self.password,
extra = {}
)) |
<SYSTEM_TASK:>
Correct isotopic proxy data for ice-volume contribution
<END_TASK>
<USER_TASK:>
Description:
def icevol_correction(age, proxyvalue, proxytype='d18o', timeunit='ya',
benthic_stack=None):
"""Correct isotopic proxy data for ice-volume contribution
This function uses the LR04 benthic stack [1]_ scaled
such that the LGM-present change is assumed to be 1.0 ‰ in accordance
with the pore-water estimate from [2]_. This correction method
is adapted from [3]_.
Parameters
----------
age: ndarray
Age array associated with proxy data.
proxyvalue: ndarray
Isotopic proxy data to be corrected.
proxytype: str, optional
Type of proxy. Must be 'd18o' for δ18O or 'dd' for δD.
Default is 'd18o'.
timeunit: str, optional
Time unit for 'age'. Must be 'ya' (for years BP), 'ka'
(thousand years BP), or 'ma' (million years BP). Default is 'ya'.
benthic_stack: obj, optional
Benthic stack to use for ice-volume correction. Uses
erebusfall.benthic_stacks.lr04 by default. This is derived from LR04.
Returns
-------
A numpy array giving the corrected isotope data.
References
----------
.. [1] Lisiecki, L. E., & Raymo, M. E. (2005). A Pliocene-Pleistocene stack
of 57 globally distributed benthic δ18O records: PLIOCENE-PLEISTOCENE
BENTHIC STACK. Paleoceanography, 20(1). https://doi.org/10.1029/2004PA001071
.. [2] Schrag, D. P., Hampt, G., & Murray, D. W. (1996). Pore Fluid
Constraints on the Temperature and Oxygen Isotopic Composition of the
Glacial Ocean. Science, 272(5270), 1930–1932. https://doi.org/10.1126/science.272.5270.1930
.. [3] Tierney, J. E., deMenocal, P. B., & Zander, P. D. (2017). A climatic
context for the out-of-Africa migration. Geology, 45(11), 1023–1026.
https://doi.org/10.1130/G39457.1
Examples
--------
>>> import erebusfall
>>> import numpy as np
>>> age_ka = np.arange(0, 20, 1)
>>> proxy = np.random.normal(loc=-2.0, size=len(age_ka))
>>> proxy_adjusted = erebusfall.icevol_correction(age_ka, proxy,
... proxytype='d18o',
... timeunit='ka')
""" |
age = np.array(age)
proxyvalue = np.array(proxyvalue)
assert len(age) == len(proxyvalue)
proxytype = proxytype.lower()
timeunit = timeunit.lower()
assert proxytype in ['d18o', 'dd']
assert timeunit in ['ya', 'ka', 'ma']
if benthic_stack is None:
benthic_stack = stacks.lr04
sage = benthic_stack.age.copy()
if timeunit == 'ya':
sage *= 1000
elif timeunit == 'ma':
sage /= 1000
# Linearly interpolate the scaled benthic stack to the target data ages.
interp_f = interp1d(sage, benthic_stack.delo_scaled, kind='linear',
bounds_error=False)
target = interp_f(age)
# Find any ages that are negative (e.g., post-1950) and turn to 0
modern = age < 0
if any(modern):
target[modern] = 0
# Find any ages that are greater than the end of the benthic stack and set
# then to nan.
ancient = age > max(sage)
if any(ancient):
target[ancient] = np.nan
# adjust the isotope data
if proxytype == 'dd':
target = 8 * target
corrected = ((1000 + proxyvalue) / (target / 1000 + 1)) - 1000
return corrected |
<SYSTEM_TASK:>
Cast a set of objects into a sequence of scene scripts. Deliver the performance.
<END_TASK>
<USER_TASK:>
Description:
def rehearse(
folders, references, handler,
repeat=0, roles=1, strict=False,
loop=None
):
"""Cast a set of objects into a sequence of scene scripts. Deliver the performance.
:param folders: A sequence of
:py:class:`turberfield.dialogue.model.SceneScript.Folder` objects.
:param references: A sequence of Python objects.
:param handler: A callable object. This will be invoked with every event from the
performance.
:param int repeat: Extra repetitions of each folder.
:param int roles: Maximum number of roles permitted each character.
:param bool strict: Only fully-cast scripts to be performed.
This function is a generator. It yields events from the performance.
""" |
if isinstance(folders, SceneScript.Folder):
folders = [folders]
yield from handler(references, loop=loop)
matcher = Matcher(folders)
performer = Performer(folders, references)
while True:
folder, index, script, selection, interlude = performer.next(
folders, references, strict=strict, roles=roles
)
yield from handler(script, loop=loop)
for item in performer.run(react=False, strict=strict, roles=roles):
yield from handler(item, loop=loop)
if isinstance(interlude, Callable):
metadata = next(handler(
interlude, folder, index, references, loop=loop
), None)
yield metadata
if metadata is None:
return
branch = next(matcher.options(metadata))
if branch != folder:
performer = Performer([branch], references)
if not repeat:
break
else:
repeat -= 1 |
<SYSTEM_TASK:>
new content from file_info can be added into block iff
<END_TASK>
<USER_TASK:>
Description:
def can_add_new_content(self, block, file_info):
"""
new content from file_info can be added into block iff
- file count limit hasn't been reached for the block
- there is enough space to completely fit the info into the block
- OR the info can be split and some info can fit into the block
""" |
return ((self._max_files_per_container == 0 or self._max_files_per_container > len(block.content_file_infos))
and (self.does_content_fit(file_info, block)
or
# check if we can fit some content by splitting the file
# Note: if max size was unlimited, does_content_fit would have been True
(block.content_size < self._max_container_content_size_in_bytes
and (self._should_split_small_files or not self._is_small_file(file_info))))) |
<SYSTEM_TASK:>
Get the last_nonce used by the given key from the SQLAlchemy database.
<END_TASK>
<USER_TASK:>
Description:
def get_last_nonce(app, key, nonce):
"""
Get the last_nonce used by the given key from the SQLAlchemy database.
Update the last_nonce to nonce at the same time.
:param str key: the public key the nonce belongs to
:param int nonce: the last nonce used by this key
""" |
uk = ses.query(um.UserKey).filter(um.UserKey.key==key)\
.filter(um.UserKey.last_nonce<nonce * 1000).first()
if not uk:
return None
lastnonce = copy.copy(uk.last_nonce)
# TODO Update DB record in same query as above, if possible
uk.last_nonce = nonce * 1000
try:
ses.commit()
except Exception as e:
current_app.logger.exception(e)
ses.rollback()
ses.flush()
return lastnonce |
<SYSTEM_TASK:>
An SQLAlchemy User getting function. Get a user by public key.
<END_TASK>
<USER_TASK:>
Description:
def get_user_by_key(app, key):
"""
An SQLAlchemy User getting function. Get a user by public key.
:param str key: the public key the user belongs to
""" |
user = ses.query(um.User).join(um.UserKey).filter(um.UserKey.key==key).first()
return user |
<SYSTEM_TASK:>
Get your user object.
<END_TASK>
<USER_TASK:>
Description:
def get_user():
"""
Get your user object.
Users may only get their own info, not others'.
---
responses:
'200':
description: user response
schema:
$ref: '#/definitions/User'
default:
description: unexpected error
schema:
$ref: '#/definitions/errorModel'
description: get your user record
security:
- kid: []
- typ: []
- alg: []
operationId: getUserList
""" |
userdict = json.loads(jsonify2(current_user.dbuser, 'User'))
return current_app.bitjws.create_response(userdict) |
<SYSTEM_TASK:>
Create a proxy for a Widget
<END_TASK>
<USER_TASK:>
Description:
def proxy_for(widget):
"""Create a proxy for a Widget
:param widget: A gtk.Widget to proxy
This will raise a KeyError if there is no proxy type registered for the
widget type.
""" |
proxy_type = widget_proxies.get(widget.__class__)
if proxy_type is None:
raise KeyError('There is no proxy type registered for %r' % widget)
return proxy_type(widget) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.