content
stringlengths 35
762k
| sha1
stringlengths 40
40
| id
int64 0
3.66M
|
|---|---|---|
import requests
def list_with_one_dict(sort_type, url_param=None):
"""
Search by parameter that returns a list with one dictionary.
Used for full country name and capital city.
"""
extra_param = ""
if sort_type == 2:
url_endpoint = "/name/"
user_msg = "full country name"
extra_param = "?fullText=true"
desc = "\nSearch by full country name. Example: United States of America"
elif sort_type == 6:
url_endpoint = "/capital/"
user_msg = "capital city"
desc = "\nSearch by capital city. Example: Washington"
if url_param is None:
print(desc)
url_param = input("\nEnter " + user_msg + ": ")
res = requests.get(URL + url_endpoint +
url_param.strip().lower() + extra_param)
try:
res.raise_for_status()
except:
return "\nError! Could not find information for the given input."
res_json = res.json()
country_name = res_json[0]["name"]
info = get_info(res_json, country_name)
print(info)
save_to_file(info, country_name)
|
79f96ab76c123bfa3c3faee57e9af6c1900c3cd7
| 17,800 |
def get_form(case, action_filter=lambda a: True, form_filter=lambda f: True, reverse=False):
"""
returns the first form that passes through both filter functions
"""
gf = get_forms(case, action_filter=action_filter, form_filter=form_filter, reverse=reverse)
try:
return gf.next()
except StopIteration:
return None
|
b0e8caeb6fae1f56407aaf14475c5f06c9b4a3d0
| 17,801 |
from datetime import datetime
def csv_to_json_generator(df, field_map: dict, id_column: str, category_column: str):
"""
Creates a dictionary/json structure for a `single id dataframe` extracting content using the
`extract_features_by_category` function.
"""
id_list = find_ids(df=df, id_column=id_column)
logger.info('Found {} units on \'{}\' to process'.format(len(id_list), id_column))
out = []
for f_id in id_list:
f_info = {'id': str(f_id), '@timestamp': datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")}
f_df = single_id_df(df=df, id_column=id_column, id_value=f_id)
for key in field_map.keys():
try:
data = extract_features_by_category(single_id_df=f_df, category=key, category_column=category_column,
related_features=field_map[key])[key.lower()]
f_info[key.lower()] = data
except:
logger.error('id: {} key: \'{}\''.format(f_id, key))
out.append(f_info)
logger.info('Generated: {}. Delta: {}'.format(len(out), len(out)-len(id_list)))
return out
|
40bf0657d8ca7d141af919f03b9b6e7cc6887749
| 17,802 |
import argparse
import os
def parse_args():
"""Get command line arguments."""
parser = argparse.ArgumentParser(prog='metrics',
formatter_class=argparse.RawDescriptionHelpFormatter,
description=desc_str)
parser.add_argument('-v', '--version', action='version', version='%(prog)s v0.1')
parser.add_argument('-i', '--input', type=str, default=os.path.join('.', 'input'),
help=r'directory with input binarized and ground-truth images (default: "%(default)s")')
parser.add_argument('-o', '--output', type=str, default=os.path.join('.', 'output'),
help=r'directory with output metrics files (default: "%(default)s")')
parser.add_argument('-w', '--weights', type=str, default=os.path.join('weights', 'weights.exe'),
help=r'path to weights evaluation tool (default: %(default)s)')
parser.add_argument('-m', '--metrics', type=str, default=os.path.join('metrics', 'metrics.exe'),
help=r'path to metrics evaluation tool (default: %(default)s)')
parser.add_argument('-p', '--procs', type=int, default=cpu_count(),
help=r'number of processes (default: %(default)s)')
return parser.parse_args()
|
a15df38667bd95f87c7ce5fa7c150589a1082bae
| 17,803 |
def sunset_hour_angle(sinLat, cosLat, sinDec, cosDec):
"""
Calculate local sunset hour angle (radians) given sines and cosines
of latitude and declination.
"""
return np.arccos(np.clip(-sinDec / cosDec * sinLat / cosLat, -1, 1))
|
43e9e6d5026ea16f348f6704a8226763f0d08786
| 17,804 |
def handle_enable(options):
"""Enable a Sopel plugin.
:param options: parsed arguments
:type options: :class:`argparse.Namespace`
:return: 0 if everything went fine;
1 if the plugin doesn't exist
"""
plugin_names = options.names
allow_only = options.allow_only
settings = utils.load_settings(options)
usable_plugins = plugins.get_usable_plugins(settings)
# plugin does not exist
unknown_plugins = [
name
for name in plugin_names
if name not in usable_plugins
]
if unknown_plugins:
display_unknown_plugins(unknown_plugins)
return 1 # do nothing and return an error code
actually_enabled = tuple(
name
for name in plugin_names
if _handle_enable_plugin(settings, usable_plugins, name, allow_only)
)
# save if required
if actually_enabled:
settings.save()
else:
return 0 # nothing to disable or save, but not an error case
# display plugins actually disabled by the command
print(utils.get_many_text(
actually_enabled,
one='Plugin {item} enabled.',
two='Plugins {first} and {second} enabled.',
many='Plugins {left}, and {last} enabled.'
))
return 0
|
e3b931fcd8f90e7570f80604d7690cf8c8485cd9
| 17,805 |
def compare_img_hist(img_path_1, img_path_2):
"""
Get the comparison result of the similarity by the histogram of the
two images. This is suitable for checking whether the image is close
in color. Conversely, it is not suitable for checking whether shapes
are similar.
Parameters
----------
img_path_1 : str
The path of the first image for comparison.
img_path_2 : str
The path of the second image for comparison.
Returns
-------
similarity : float
Similarity between two images. The maximum is set to 1.0, and the
closer to 1.0, the higher the similarity. It is set by the mean
value of the histogram of RGB channels.
"""
assert_img_exists(img_path=img_path_1)
assert_img_exists(img_path=img_path_2)
img_1 = cv2.imread(img_path_1)
img_2 = cv2.imread(img_path_2)
channels_list = [[0], [1], [2]]
similarity_list = []
for channels in channels_list:
img_1_hist = cv2.calcHist(
images=[img_1],
channels=channels,
mask=None,
histSize=[256],
ranges=[0, 256]
)
img_2_hist = cv2.calcHist(
images=[img_2],
channels=channels,
mask=None,
histSize=[256],
ranges=[0, 256]
)
similarity_unit = cv2.compareHist(
H1=img_1_hist, H2=img_2_hist, method=cv2.HISTCMP_CORREL)
similarity_list.append(similarity_unit)
similarity = np.mean(similarity_list)
return similarity
|
4fa34b3186b69464be15052a9427bb274f95d28f
| 17,806 |
import json
def recombinant_example(resource_name, doc_type, indent=2, lang='json'):
"""
Return example data formatted for use in API documentation
"""
chromo = recombinant_get_chromo(resource_name)
if chromo and doc_type in chromo.get('examples', {}):
data = chromo['examples'][doc_type]
elif doc_type == 'sort':
data = "request_date desc, file_number asc"
elif doc_type == 'filters':
data = {"resource": "doc", "priority": "high"}
elif doc_type == 'filter_one':
data = {"file_number": "86086"}
else:
data = {
"request_date": "2016-01-01",
"file_number": "42042",
"resource": "doc",
"prioroty": "low",
}
if not isinstance(data, (list, dict)):
return json.dumps(data)
left = ' ' * indent
if lang == 'pythonargs':
return ',\n'.join(
"%s%s=%s" % (left, k, json.dumps(data[k]))
for k in sorted(data))
out = json.dumps(data, indent=2, sort_keys=True, ensure_ascii=False)
return left[2:] + ('\n' + left[2:]).join(out.split('\n')[1:-1])
|
1a6cfe474425ba4d62472f571ca0eae0d3cfbff0
| 17,807 |
def _integral_diff(x, pdf, a, q):
"""Return difference between q and the integral of the function `pdf`
between a and x. This is used for solving for the ppf."""
return integrate.quad(pdf, a, x)[0] - q
|
616cfba7361c92f7cbdf8bac55f9a65a60c2c32f
| 17,808 |
def Fcomplete(t,y,k0m,k1,k2m,k2p,k3,k4,k5m,k6m,k7,Kr0,Kr1,Kr2,Kr2p,Km5,Km6,Km7,Gt,Rt,Mt,k_Gp,Gpt,n):
"""
Right hand side of ODE y'(t) = f(t,y,...)
It receives parameters as f_args, as given py param_array (see param.py)
3 components: G, R, M
"""
k0=k0m*Kr0 # kmi =ki/Kri or ki/Kmi
k2=k2m*Kr2
k5=k5m*Km5
k6=k6m*Km6
G=y[0]
R=y[1]
M=y[2]
if len(y) > 3:
Gp=y[3] # GEF perturbation (what's given in the data)
Gpvis=y[4] # GEF perturbation (what's given in the data)
else:
Gp = 0.
Gpvis = 0
return np.array( [ k3*R*(Gt-G) - k4*M*G, (k0*G+Gpt*Gp)*(Rt-R)/(Kr0+(Rt-R)) + k1*(Rt-R)/(Kr1+(Rt-R)) - k2*R/(Kr2+R), k5*R*(Mt-M)**n/(Km5**n+(Mt-M)**n) - k6*M/(Km6+M) + k7*(Mt-M)/(Km7+(Mt-M)),k_Gp-k_Gp*Gp-k4*Gp*M, k_Gp-k_Gp*Gpvis] )
|
a6b614a34fb0c2dcaf29107c05eb397312825568
| 17,809 |
def lu_solve(l: np.ndarray, u: np.ndarray, b: np.ndarray) -> np.ndarray:
"""Решение СЛАУ, прошедшей через LU-разложение.
Требуется предварительно умножить вектор правых частей на матрицу перестановки.
:param l: нижняя треугольная матрица
:param u: верхняя треугольная матрица
:param b: вектор правых частей СЛАУ
:return: вектор-решение СЛАУ
"""
n = l.shape[0]
z = np.zeros_like(b)
z[0] = b[0]
for i in range(1, n):
s = 0
for j in range(i):
s += l[i, j] * z[j]
z[i] = b[i] - s
x = np.zeros_like(b)
x[-1] = z[-1] / u[-1, -1]
for i in range(n - 2, -1, -1):
s = 0
for j in range(i + 1, n):
s += u[i, j] * x[j]
x[i] = (z[i] - s) / u[i, i]
return x
|
5429fe91dfb15a5cf306871d07f0204f8f23a405
| 17,810 |
def datetime_to_httpdate(input_date):
# type: (datetime) -> Optional[str]
"""Converts datetime to http date string"""
if input_date is None:
return None
try:
return input_date.strftime(HTTP_DATE_FORMAT)
except (ValueError, TypeError) as e:
logger.debug(e)
return None
|
bf4cb68bb156a3abb214867e4e366497d091a17b
| 17,811 |
def zr_bfr_tj():
"""
Real Name: b'Zr bfr Tj'
Original Eqn: b'Zr aftr Dam-Wr sup aftr Zr Dam+(Wr sup aftr Zr Dam*0.2)'
Units: b''
Limits: (None, None)
Type: component
b''
"""
return zr_aftr_dam() - wr_sup_aftr_zr_dam() + (wr_sup_aftr_zr_dam() * 0.2)
|
aae58ac349a7039afd0f3f3f12166a39de8afe31
| 17,812 |
def simplify(n):
"""Remove decimal places."""
return int(round(n))
|
9856c8f5c0448634956d1d05e44027da2f4ebe6a
| 17,813 |
def resnet_qc_18(**kwargs):
"""Constructs a ResNet-18 model."""
model = ResNetQC(BasicBlock, [2, 2, 2, 2], **kwargs)
return model
|
a1554e044dd69e96474602c88e8e73d4d697c861
| 17,814 |
import scipy.sparse
def sparse_from_npz(file, **_kw):
"""
Possible dispatch function for ``from_path_impl``'s ``from_npz``.
Reads a scipy sparse matrix.
"""
return scipy.sparse.load_npz(file)
|
9909975ff0309cde98117e64718fe292de574987
| 17,815 |
import copy
def get_config():
"""
Read the configuration
:returns: current configuration
"""
global config
return copy.deepcopy(config)
|
3e9b064123ed9165c04cbc7e1c2b0d646703cb7a
| 17,816 |
def resnext20_2x64d_cifar100(classes=100, **kwargs):
"""
ResNeXt-20 (2x64d) model for CIFAR-100 from 'Aggregated Residual Transformations for Deep Neural Networks,'
http://arxiv.org/abs/1611.05431.
Parameters:
----------
classes : int, default 100
Number of classification classes.
pretrained : bool, default False
Whether to load the pretrained weights for model.
root : str, default '~/.tensorflow/models'
Location for keeping the model parameters.
"""
return get_resnext_cifar(classes=classes, blocks=20, cardinality=2, bottleneck_width=64,
model_name="resnext20_2x64d_cifar100", **kwargs)
|
147b9ff5565fdbbcaab68d66fbfa3e8a5a4b6062
| 17,817 |
def test_target(target):
"""Returns the label for the corresponding target in the test tree."""
label = to_label(target)
test_package = label.package.replace("src/main/", "src/test/", 1)
return Label("@{workspace}//{package}:{target_name}".format(
workspace = label.workspace_name,
package = test_package,
target_name = label.name,
))
|
8b4391a5acdea7b851ef6606ad3dfa0b21132ae1
| 17,818 |
def pred_fwd_rc(model, input_npy, output_fwd, output_rc, replicates=1, batch_size=512):
"""Predict pathogenic potentials from a preprocessed numpy array and its reverse-complement."""
y_fwd, _ = predict_npy(model, input_npy, output_fwd, rc=False, replicates=replicates, batch_size=batch_size)
y_rc, _ = predict_npy(model, input_npy, output_rc, rc=True, replicates=replicates, batch_size=batch_size)
return y_fwd, y_rc
|
90ed6c3a29dd3e24cef45415ec51381bf32a8b37
| 17,819 |
import os
def get_ids(viva_path, dataset):
"""Get image identifiers for corresponding list of dataset identifies.
Parameters
----------
viva_path : str
Path to VIVA directory.
datasets : list of str tuples
List of dataset identifiers in the form of (year, dataset) pairs.
Returns
-------
ids : list of str
List of all image identifiers for given datasets.
"""
dataset_path = os.path.join(viva_path, dataset, 'pos')
ids = [dir.replace('.png', '') for dir in os.listdir(dataset_path)]
return ids
|
526c094323af2be7611c3bf9261c703106442b24
| 17,820 |
def get_api_version(version_string):
"""Returns checked APIVersion object"""
version_string = str(version_string)
api_version = APIVersion(version_string)
check_major_version(api_version)
return api_version
|
9bbc88c3aee2139dc39367d4788d6c382f711903
| 17,821 |
def evaluate_g9( tau7, tau8, tau9, tau10, tau11, s9 ):
"""
Evaluate the ninth constraint equation and also return the Jacobian
:param float tau7: The seventh tau parameter
:param float tau8: The eighth tau parameter
:param float tau9: The ninth tau parameter
:param float tau10: The tenth tau parameter
:param float tau11: The eleventh tau parameter
:param float s9: The value of the constraint
"""
return tau7 + 2 * tau8 - abs( tau9 + tau10 + tau11 ) - s9**2,\
{ 'tau7':1., 'tau8':2., 'tau9':float( -np.sign( tau9 ) ),\
'tau10':float( -np.sign( tau10 ) ),\
'tau11':( -np.sign( tau11 ) ), 's9':-2*s9 }
|
9f8181e4d6abac9207eec721d6b347a560778ecf
| 17,822 |
from functools import reduce
import operator
def qmul(*q, qaxis=-1):
""" Quaternion multiplication.
Parameters
----------
q: iterable of array_like
Arrays containing quaternions to multiply. Their dtype can be
quaternion, otherwise `qaxis` specifies the axis representing
the quaternions.
qaxis: int, default -1
If `q` are not quaternion dtype, axis of the quaternion arrays
representing the coordinates of the quaternions.
Returns
-------
qm: ndarray
A new array containing the multiplied quaternions.
"""
# TODO xarray support
if len(q) < 2:
raise ValueError("Please provide at least 2 quaternions to multiply")
if all(qq.dtype != quaternion for qq in q):
q = (as_quat_array(np.swapaxes(qq, qaxis, -1)) for qq in q)
qm = reduce(operator.mul, q, 1)
return np.swapaxes(as_float_array(qm), -1, qaxis)
elif all(qq.dtype == quaternion for qq in q):
return reduce(operator.mul, q, 1)
else:
raise ValueError(
"Either all or none of the provided quaternions must be "
"quaternion dtype"
)
|
d745fc94a66ec20e5c673252fb3d289201025473
| 17,823 |
def iterable(value,
allow_empty = False,
forbid_literals = (str, bytes),
minimum_length = None,
maximum_length = None,
**kwargs):
"""Validate that ``value`` is a valid iterable.
.. hint::
This validator checks to ensure that ``value`` supports iteration using
any of Python's three iteration protocols: the ``__getitem__`` protocol,
the ``__iter__`` / ``next()`` protocol, or the inheritance from Python's
`Iterable` abstract base class.
If ``value`` supports any of these three iteration protocols, it will be
validated. However, if iteration across ``value`` raises an unsupported
exception, this function will raise an
:exc:`IterationFailedError <validator_collection.errors.IterationFailedError>`
:param value: The value to validate.
:param allow_empty: If ``True``, returns :obj:`None <python:None>` if ``value``
is empty. If ``False``, raises a
:class:`EmptyValueError <validator_collection.errors.EmptyValueError>` if
``value`` is empty. Defaults to ``False``.
:type allow_empty: :class:`bool <python:bool>`
:param forbid_literals: A collection of literals that will be considered invalid
even if they are (actually) iterable. Defaults to :class:`str <python:str>` and
:class:`bytes <python:bytes>`.
:type forbid_literals: iterable
:param minimum_length: If supplied, indicates the minimum number of members
needed to be valid.
:type minimum_length: :class:`int <python:int>`
:param maximum_length: If supplied, indicates the minimum number of members
needed to be valid.
:type maximum_length: :class:`int <python:int>`
:returns: ``value`` / :obj:`None <python:None>`
:rtype: iterable / :obj:`None <python:None>`
:raises EmptyValueError: if ``value`` is empty and ``allow_empty`` is ``False``
:raises NotAnIterableError: if ``value`` is not a valid iterable or
:obj:`None <python:None>`
:raises IterationFailedError: if ``value`` is a valid iterable, but iteration
fails for some unexpected exception
:raises MinimumLengthError: if ``minimum_length`` is supplied and the length of
``value`` is less than ``minimum_length`` and ``whitespace_padding`` is
``False``
:raises MaximumLengthError: if ``maximum_length`` is supplied and the length of
``value`` is more than the ``maximum_length``
"""
if not value and not allow_empty:
raise errors.EmptyValueError('value (%s) was empty' % value)
elif value is None:
return None
minimum_length = integer(minimum_length, allow_empty = True, force_run = True) # pylint: disable=E1123
maximum_length = integer(maximum_length, allow_empty = True, force_run = True) # pylint: disable=E1123
if isinstance(value, forbid_literals):
raise errors.NotAnIterableError('value type (%s) not iterable' % type(value))
try:
iter(value)
except TypeError:
raise errors.NotAnIterableError('value type (%s) not iterable' % type(value))
except Exception as error:
raise errors.IterationFailedError('iterating across value raised an unexpected Exception: "%s"' % error)
if value and minimum_length is not None and len(value) < minimum_length:
raise errors.MinimumLengthError(
'value has fewer items than the minimum length %s' % minimum_length
)
if value and maximum_length is not None and len(value) > maximum_length:
raise errors.MaximumLengthError(
'value has more items than the maximum length %s' % maximum_length
)
return value
|
57de6a43243d9c611725f1e9987e881cf1485b63
| 17,824 |
from typing import List
def settings_notification(color: bool, messages: List[ExitMessage]) -> Form:
"""Generate a warning notification for settings errors.
:param messages: List of messages to display
:param color: Bool to reflect if color is transferred or not
:returns: The form to display
"""
# Take the initial warning if there is one
if messages[0].prefix is ExitPrefix.WARNING:
title = messages.pop(0).to_lines(color=False, width=console_width(), with_prefix=True)[0]
else:
title = "Warning"
formatted = ExitMessages(messages).to_strings(color=color, width=console_width())
formatted_curses = CursesLines(
tuple(ansi_to_curses(line) for line in formatted),
)
form = Form(
FormType.NOTIFICATION,
title=title,
title_color=Color.YELLOW,
fields=[
FieldCursesInformation(
name="settings_warning",
information=formatted_curses,
),
],
)
return form
|
a1ff085c76e84e01ba293f17b662626a39fda26f
| 17,825 |
def message_type(ctx: 'Context', *types):
"""Filters massage_type with one of selected types.
Assumes update_type one of message, edited_message, channel_post, edited_channel_post.
:param ctx:
:param types:
:return: True or False
"""
m = None
if ctx.update.update_type is UpdateType.message:
m = ctx.update.message
elif ctx.update.update_type is UpdateType.edited_message:
m = ctx.update.edited_message
elif ctx.update.update_type is UpdateType.channel_post:
m = ctx.update.channel_post
elif ctx.update.update_type is UpdateType.edited_channel_post:
m = ctx.update.edited_channel_post
else:
return False
if m.message_type not in types:
return False
return True
|
231bbb3b802d6f6dcf4a22af7704fae3ce24e783
| 17,826 |
import math
def VSphere(R):
"""
Volume of a sphere or radius R.
"""
return 4. * math.pi * R * R * R / 3.
|
9e99d19683d9e86c2db79189809d24badccc197b
| 17,827 |
from typing import Optional
from typing import Any
def resolve_variable(
var_name: str,
var_def: BlueprintVariableTypeDef,
provided_variable: Optional[Variable],
blueprint_name: str,
) -> Any:
"""Resolve a provided variable value against the variable definition.
Args:
var_name: The name of the defined variable on a blueprint.
var_def: A dictionary representing the defined variables attributes.
provided_variable: The variable value provided to the blueprint.
blueprint_name: The name of the blueprint that the variable is being applied to.
Returns:
The resolved variable value, could be any python object.
Raises:
MissingVariable: Raised when a variable with no default is not
provided a value.
UnresolvedBlueprintVariable: Raised when the provided variable is
not already resolved.
ValueError: Raised when the value is not the right type and cannot be
cast as the correct type. Raised by
:func:`runway.cfngin.blueprints.base.validate_variable_type`
ValidatorError: Raised when a validator raises an exception. Wraps the
original exception.
"""
try:
var_type = var_def["type"]
except KeyError:
raise VariableTypeRequired(blueprint_name, var_name) from None
if provided_variable:
if not provided_variable.resolved:
raise UnresolvedBlueprintVariable(blueprint_name, provided_variable)
value = provided_variable.value
else:
# Variable value not provided, try using the default, if it exists
# in the definition
try:
value = var_def["default"]
except KeyError:
raise MissingVariable(blueprint_name, var_name) from None
# If no validator, return the value as is, otherwise apply validator
validator = var_def.get("validator", lambda v: v)
try:
value = validator(value)
except Exception as exc:
raise ValidatorError(var_name, validator.__name__, value, exc) from exc
# Ensure that the resulting value is the correct type
value = validate_variable_type(var_name, var_type, value)
allowed_values = var_def.get("allowed_values")
if not validate_allowed_values(allowed_values, value):
raise ValueError(
f"Invalid value passed to {var_name} in Blueprint {blueprint_name}. "
f"Got '{value}', expected one of {allowed_values}."
)
return value
|
1df7d4804f104c8f746999aaaad5f91ca96b5f78
| 17,828 |
import os
def generate_navbar(structure, pathprefix):
"""
Returns 2D list containing the nested navigational structure of the website
"""
navbar = []
for section in structure['sections']:
navbar_section = []
section_data = structure['sections'][section]
section_url = os.path.join('/', pathprefix, section + '/')
section_title = section_data['title']
if 'navtitle' in section_data:
section_title = section_data['navtitle']
section_hassub = False
if 'pages' in section_data:
section_hassub = True
for page in section_data['pages']:
url = os.path.join('/', pathprefix, section, page)
title = structure['sections'][section]['pages'][page]['title']
if 'navtitle' in structure['sections'][section]['pages'][page]:
title = structure['sections'][section]['pages'][page]['navtitle']
if title:
# Only add a page to the navigation if it has a title, otherwise it's hidden
navbar_section.append((url, page, title))
if section_title:
navbar.append((section_url, section, section_title, section_hassub, navbar_section))
return navbar
|
daed8a1a74887406700fc2ca380e22165fa300f6
| 17,829 |
def additional_args(**kwargs):
"""
Additional command-line arguments.
Provides additional command-line arguments that are unique to the extraction process.
Returns
-------
additional_args : dict
Dictionary of tuples in the form (fixed,keyword) that can be passed to an argument
parser to create a new command-line option
"""
module_name = kwargs.get('module_name', __name__)
base_defaults = get_defaults(module_name)
additional_args = {}
table_help = "The input metadata table to use."
table_args = ['table']
table_kwargs = {'help': table_help}
additional_args['table'] = (table_args, table_kwargs)
bkg_help = "Whether to subtract background before or after applying "
bkg_help += "flatfield. Default is 'flat_first'. Available options are "
bkg_help += "'flat_first', 'bkg_first' and 'bkg_only'."
bkg_args = ['-b', '--bkg_flat_order']
bkg_kwargs = {'dest': 'bkg_flat_order', 'default': base_defaults['bkg_flat_order'],
'help': bkg_help}
additional_args['bkg_flat_order'] = (bkg_args, bkg_kwargs)
plots_help = "Include result plots while running (default False)."
plots_args = ["-p", "--plots"]
plots_kwargs = {'dest': 'plots', 'action': 'store_true',
'default': base_defaults['plots'], 'help': trace_help}
additional_args['plots'] = (plots_args, plots_kwargs)
return additional_args
|
1b0f10f7f9c60077de9c580163b5e3893da63a83
| 17,830 |
import html
def extract_images_url(url, source):
"""
Extract image url for a chapter
"""
r = s.get(url)
tree = html.fromstring(r.text)
if source == 'blogtruyen':
return tree.xpath('//*[@id="content"]/img/@src')
elif source == 'nettruyen':
return tree.xpath('//*[@class="reading-detail box_doc"]/div/img/@src')
elif source == 'image-container-manga':
return tree.xpath('//*[@class="image-container-manga"]/div/img/@src')
|
f2299d3e1dde38fc7ac2d3789e8145f5a71a1299
| 17,831 |
from typing import Dict
from typing import Any
from typing import Optional
from typing import Literal
from typing import List
import pathlib
def _ntuple_paths(
general_path: str,
region: Dict[str, Any],
sample: Dict[str, Any],
systematic: Dict[str, Any],
template: Optional[Literal["Up", "Down"]],
) -> List[pathlib.Path]:
"""Returns the paths to ntuples for a region-sample-systematic-template.
A path is built starting from the path specified in the general options in the
configuration file. This path can contain placeholders for region- and sample-
specific overrides, via ``{Region}`` and ``{Sample}``. For non-nominal templates, it
is possible to override the sample path if the ``SamplePaths`` option is specified
for the template. If ``SamplePaths`` is a list, return a list of paths (one per
entry in the list).
Args:
general_path (str): path specified in general settings, with sections that can
be overridden by region / sample settings
region (Dict[str, Any]): containing all region information
sample (Dict[str, Any]): containing all sample information
systematic (Dict[str, Any]): containing all systematic information
template (Optional[Literal["Up", "Down"]]): template considered: "Up", "Down",
or None for nominal
Returns:
List[pathlib.Path]: list of paths to ntuples
"""
# obtain region and sample paths, if they are defined
region_path = region.get("RegionPath", None)
sample_paths = sample.get("SamplePaths", None)
# check whether a systematic is being processed, and whether overrides exist
if template is not None:
# determine whether the template has an override for RegionPath specified
region_override = _check_for_override(systematic, template, "RegionPath")
if region_override is not None:
region_path = region_override
# check for SamplePaths override
sample_override = _check_for_override(systematic, template, "SamplePaths")
if sample_override is not None:
sample_paths = sample_override
region_template_exists = "{RegionPath}" in general_path
if region_path is not None:
if not region_template_exists:
log.warning(
"region override specified, but {RegionPath} not found in default path"
)
general_path = general_path.replace("{RegionPath}", region_path)
elif region_template_exists:
raise ValueError(f"no path setting found for region {region['Name']}")
sample_template_exists = "{SamplePaths}" in general_path
if sample_paths is not None:
if not sample_template_exists:
log.warning(
"sample override specified, but {SamplePaths} not found in default path"
)
# SamplePaths can be a list, so need to construct all possible paths
sample_paths = configuration._setting_to_list(sample_paths)
path_list = []
for sample_path in sample_paths:
path_list.append(general_path.replace("{SamplePaths}", sample_path))
elif sample_template_exists:
raise ValueError(f"no path setting found for sample {sample['Name']}")
else:
# no need for multiple paths, and no SamplePaths are present, so turn
# the existing path into a list
path_list = [general_path]
# convert the contents of path_lists to paths and return them
paths = [pathlib.Path(path) for path in path_list]
return paths
|
efb96f1b977c30c83890c2030f312c0066eed4d8
| 17,832 |
def svn_ra_do_diff2(*args):
"""
svn_ra_do_diff2(svn_ra_session_t session, svn_revnum_t revision, char diff_target,
svn_boolean_t recurse, svn_boolean_t ignore_ancestry,
svn_boolean_t text_deltas,
char versus_url, svn_delta_editor_t diff_editor,
void diff_baton, apr_pool_t pool) -> svn_error_t
"""
return _ra.svn_ra_do_diff2(*args)
|
8964a6304582daf5631e8e26c8cf7ff9167837dd
| 17,833 |
def ntuple_dict_length(ntuple_dict):
"""Returns a dictionary from track types to the number of tracks of
that type. Raises an exception of any value lists within one of its
track properties dicts are different lengths."""
return dict(map(lambda track_type, track_prop_dict:
(track_type, track_prop_dict_length(track_prop_dict)),
ntuple_dict.keys(), ntuple_dict.values()))
|
e5f7805dfb4a641268792e4e8982e21a05298f9e
| 17,834 |
def range_ngram_distrib(text, n, top_most=-1):
"""
List n-grams with theis probabilities from the most popular to the smaller ones
:param text: text
:param n: n of n-gram
:param top_most: count of most popular n-grams to be returned, or -1 to return all
:return: list of ngrams, list of probs
"""
ngram_counts = count_ngrams(text, n)
if top_most >= 0:
ngrams = np.asarray(ngram_counts.most_common(top_most))[:, 0]
counts = np.asarray(np.asarray(ngram_counts.most_common(top_most))[:, 1], dtype=int)
else:
ngrams = np.asarray(ngram_counts.most_common())[:, 0]
counts = np.asarray(np.asarray(ngram_counts.most_common())[:, 1], dtype=int)
return ngrams, counts
|
0822b2e7824aee6cc28e2a734dea5d9aff0df1ac
| 17,835 |
import os
def extract_group_ids(caps_directory):
"""Extract list of group IDs (e.g. ['group-AD', 'group-HC']) based on `caps_directory`/groups folder."""
try:
group_ids = os.listdir(os.path.join(caps_directory, "groups"))
except FileNotFoundError:
group_ids = [""]
return group_ids
|
908ac1c3c06028f526b1d474618fca05d76f8792
| 17,836 |
import functools
def require_methods(*methods):
"""Returns a decorator which produces an error unless request.method is one
of |methods|.
"""
def decorator(func):
@functools.wraps(func)
def wrapped(request, *args, **kwds):
if request.method not in methods:
allowed = ', '.join(methods)
rsp = HttpTextResponse('This requires a specific method: %s' % allowed,
status=405)
rsp['Allow'] = allowed
return func(request, *args, **kwds)
return wrapped
return decorator
|
6c02675836c95f9ee7bab124cc1287bc6d3dfb95
| 17,837 |
def getUnit3d(prompt, default=None):
"""
Read a Unit3d for the termial with checking. This will accapt and
directon in any format accepted by Unit3d().parseAngle()
Allowed formats
* x,y,z or [x,y,z] three floats
* theta,psi or [theta,psi], in radians (quoted in "" for degrees)
* theta in radians (or quotes in "" for degrees)
:param prompt: the promp to be displayed
:type prompt: str
:param default: the default Unit3d
:type: Unit3d
"""
while True:
val = __getInput(prompt, default)
try:
if isinstance(val, str): # Its a string
val = eval(val) # Eval list
u = Unit3d().parseAngle(val)
return u
except (ValueError, NameError, ZeroDivisionError, SyntaxError):
logger.error("Conversion of '{0:s}' to Unit3d failed.".format(str(val)))
|
dd39a706114c72ce9059686e342e8a1db1e3464b
| 17,838 |
def checkOverlap(ra, rb):
"""
check the overlap of two anchors,ra=[chr,left_start,left_end,chr,right_start,right_end]
"""
if checkOneEndOverlap(ra[1], ra[2], rb[1], rb[2]) and checkOneEndOverlap(
ra[4], ra[5], rb[4], rb[5]):
return True
return False
|
9644ed7e2de9d9091e21a64c7c4cd43a0e0e1210
| 17,839 |
import typing
def saveable(item: praw.models.reddit.base.RedditBase) -> dict[str, typing.Any]:
"""Generate a saveable dict from an instance"""
result = {k: legalize(v) for k, v in item.__dict__.items() if not k.startswith("_")}
return _parent_ids_interpreted(result)
|
6e9e7092045e321de2beeba7debbd6dc2a2b2e61
| 17,840 |
import re
def decode_Tex_accents(in_str):
"""Converts a string containing LaTex accents (i.e. "{\\`{O}}") to ASCII
(i.e. "O"). Useful for correcting author names when bib entries were
queried from web via doi
:param in_str: input str to decode
:type in_str: str
:return: corrected string
:rtype: str
"""
# replaces latex accents with ascii letter (no accent)
pat = "\{\\\\'\{(\w)\}\}"
out = in_str
for x in re.finditer(pat, in_str):
out = out.replace(x.group(), x.groups()[0])
# replace latex {\textsinglequote} with underscore
out = out.replace('{\\textquotesingle}', "_")
# replace actual single quotes with underscore for bibtex compatibility
out = out.replace("'", '_')
return out
|
2a4bd71b53cdab047a1ddd1e0e6fd6e9c81b0e0a
| 17,841 |
from typing import Mapping
def tensor_dict_eq(dict1: Mapping, dict2: Mapping) -> bool:
"""Checks the equivalence between 2 dictionaries, that can contain torch Tensors as value. The dictionary can be
nested with other dictionaries or lists, they will be checked recursively.
:param dict1: Dictionary to compare.
:param dict2: Dictionary to compare.
:return: True, if dict1 and dict2 are equal, false otherwise.
"""
if len(dict1) != len(dict2):
return False
for (key1, value1), (key2, value2) in zip(dict1.items(), dict2.items()):
key_equal = key1 == key2
value_equal = tensor_container_element_eq(value1, value2)
if (not key_equal) or (not value_equal):
return False
return True
|
db3d7d23e633f5a240d0d0d13f6836494dc44e20
| 17,842 |
def calculate_stability(derivatives):
"""
Calculate the stability-axis derivatives with the body-axis derivatives.
"""
d = derivatives
if 'stability' not in d:
d['stability'] = {}
slat = calculate_stability_lateral(d['body'], np.deg2rad(d['alpha0']))
slong = calculate_stability_longitudinal(d['body'], np.deg2rad(d['alpha0']))
d['stability'].update(slat)
d['stability'].update(slong)
return d
|
888f63454265b3811751ae91654a9de083f25fec
| 17,843 |
import os
def apply_config(keys, options, path=None):
# type: (Any, optparse.Values, Optional[str]) -> Dict[str, str]
"""
Read setup.cfg from path or current working directory and apply it to the
parsed options
Parameters
----------
keys
options : optparse.Values
parsed options
path : Optional[str]
Returns
-------
Dict[str, str]
default types by argument name
"""
if not path:
path = os.getcwd()
config_file = os.path.join(path, 'setup.cfg')
parser = ConfigParser()
parser.read(config_file)
def addopt(key, typ, default):
if hasattr(options, key):
return
methname = 'get'
if typ not in ('string', 'choice'):
methname += typ
method = getattr(parser, methname)
try:
val = method('doc484', key)
except (NoSectionError, NoOptionError):
val = default
setattr(options, key, val)
for key, typ, default in keys:
addopt(key, typ, default)
try:
return dict(parser.items('doc484:default_arg_types'))
except NoSectionError:
return {}
|
b1a8bbb411fca106579fc543751b6f9336205d66
| 17,844 |
from os import linesep as ls
def convert_v1_to_v2(v1, max, asm, v2=None, first=0):
"""Converts a given v1 timecodes file to v2 timecodes.
Original idea from tritical's tcConv.
"""
ts = fn1 = fn2 = last = 0
asm = correct_to_ntsc(asm, True)
o = []
ap = o.append
en = str.encode
for line in v1:
ovr = line.split(',')
if len(ovr) == 3:
fn1, fn2, fps = ovr
fn1 = int(fn1)
fn2 = int(fn2)
ovf = correct_to_ntsc(fps, True)
while (last < fn1 and last < max):
ap(ts)
last, ts = last + 1, ts + asm
while (last <= fn2 and last < max):
ap(ts)
last, ts = last + 1, ts + ovf
while last < max:
ap(ts)
last, ts = last + 1, ts + asm
if v2:
with open(v2, 'wb') as v2f:
header = [en('# timecode format v2' + ls)] if first == 0 else [b'']
v2f.writelines(header + [en(('{0:3.6f}'.format(s)) + ls) for s in
o[first:]])
return o[first:]
|
350ed163977d06632297dd460e42a0ea8b70bd05
| 17,845 |
from datetime import datetime
def read_malmipsdetect(file_detect):
"""
This function is used to read the MALMI detection file which contains detection
information, that is for each detected event how many stations are triggered,
how many phases are triggered. Those information can be used for quality control.
Parameters
----------
file_detect : str
The filename including path of the input file.
Raises
------
ValueError
datetime format is not consistent with defined one.
Returns
-------
detect_info : dic
detect_info['starttime'] : list of datetime
starttime and folder name of the detected event;
detect_info['endtime'] : list of datetime
endtime of the detected event;
detect_info['station'] : list of float
number of stations triggered of the detected event;
detect_info['phase'] : list of float
number of phase triggered of the detected event;
"""
format_f = ['starttime', 'endtime', 'station', 'phase']
datetime_format_26 = '%Y-%m-%dT%H:%M:%S.%f' # datetime format in the input file
datetime_format_19 = '%Y-%m-%dT%H:%M:%S' # datetime format in the input file
# read file
df = pd.read_csv(file_detect, delimiter=' ', header=None, names=format_f,
skipinitialspace=True, encoding='utf-8', comment='#')
# format output data
detect_info = {}
detect_info['starttime'] = []
detect_info['endtime'] = []
for ii in range(len(df)):
if len(df.loc[ii,'starttime']) == 19:
detect_info['starttime'].append(datetime.datetime.strptime(df.loc[ii,'starttime'], datetime_format_19)) # origin time
elif len(df.loc[ii,'starttime']) == 26:
detect_info['starttime'].append(datetime.datetime.strptime(df.loc[ii,'starttime'], datetime_format_26)) # origin time
else:
raise ValueError('Error! Input datetime format not recoginzed!')
if len(df.loc[ii,'endtime']) == 19:
detect_info['endtime'].append(datetime.datetime.strptime(df.loc[ii,'endtime'], datetime_format_19)) # origin time
elif len(df.loc[ii,'endtime']) == 26:
detect_info['endtime'].append(datetime.datetime.strptime(df.loc[ii,'endtime'], datetime_format_26)) # origin time
else:
raise ValueError('Error! Input datetime format not recoginzed!')
detect_info['station'] = list(df['station'])
detect_info['phase'] = list(df['phase'])
return detect_info
|
cf42172e9f286254f31b2e57361c25360ed73d10
| 17,846 |
def GeneratePermissionUrl(client_id, scope='https://mail.google.com/'):
"""Generates the URL for authorizing access.
This uses the "OAuth2 for Installed Applications" flow described at
https://developers.google.com/accounts/docs/OAuth2InstalledApp
Args:
client_id: Client ID obtained by registering your app.
scope: scope for access token, e.g. 'https://mail.google.com'
Returns:
A URL that the user should visit in their browser.
"""
params = {}
params['client_id'] = client_id
params['redirect_uri'] = REDIRECT_URI
params['scope'] = scope
params['response_type'] = 'code'
return '%s?%s' % (AccountsUrl('o/oauth2/auth'),
FormatUrlParams(params))
|
b4471e78eab772a57be8d3073451050fd78d904c
| 17,847 |
import os
import shutil
import time
def download(request):
"""Download images as .zip file. """
def make_archive(source, destination):
print(source, destination)
base = os.path.basename(destination)
name = base.split('.')[0]
format = base.split('.')[1]
archive_from = os.path.dirname(source)
archive_to = os.path.basename(source.strip(os.sep))
print(source, destination, archive_from, archive_to)
shutil.make_archive(name, format, archive_from, archive_to)
shutil.move('%s.%s' % (name, format), destination)
user_id = request.session['user_id']
user_root = request.session['user_root']
search_id = request.session['search_id']
logger = Logger(user_root,user_id)
logger.write("start compressing images..")
t_start_zip=time.time()
zip_target = os.path.join(user_root, search_id)
zip_path = os.path.join(user_root, search_id, "Color_images.zip")
make_archive(zip_target, zip_path)
print("finish zip.")
zip_file = open(zip_path, '+rb')
response = HttpResponse(zip_file, content_type='application/zip')
response[
'Content-Disposition'] = 'attachment; filename=%s' % "dataset.zip"
response['Content-Length'] = os.path.getsize(zip_path)
zip_file.close()
logger.write("compressing images finished ("+convert_duration_time(time.time(),t_start_zip)+"s)")
return response
|
39fd231c96581f366f3a26f31bfc7bb17f977eb6
| 17,848 |
def get_scorekeeper_details():
"""Retrieve a list of scorekeeper and their corresponding
appearances"""
return scorekeepers.get_scorekeeper_details(database_connection)
|
78092d0ae6bcb21ee86a1fddfc678472c81eb55f
| 17,849 |
def layer_norm(input_tensor, axis):
"""Run layer normalization on the axis dimension of the tensor."""
layer_norma = tf.keras.layers.LayerNormalization(axis = axis)
return layer_norma(input_tensor)
|
9687dedf8c3a624013c5188401e86d7ef6d73969
| 17,850 |
def compute_depth(disparity, focal_length, distance_between_cameras):
"""
Computes depth in meters
Input:
-Disparity in pixels
-Focal Length in pixels
-Distance between cameras in meters
Output:
-Depth in meters
"""
with np.errstate(divide='ignore'): #ignore division by 0
# standard depth and disparity formula
depth = (focal_length * distance_between_cameras) / disparity
return depth
|
5ea475dae1d4aa0c429a7f6766293a39d403904d
| 17,851 |
def lecture(source=None,target=None,fseed=100,fpercent=100):
"""
Create conversion of the source file and the target file
Shuffle method is used, base on the seed (default 100)
"""
seed(fseed)
try:
copysource = []
copytarget = []
if(source!=None and target!=None):
source = create_inter_without(source)
target = create_inter_without(target)
shuffle(source)
shuffle(target)
for i in range(0,(int(len(source)*fpercent/100))):
copysource.append(source[i])
if(len(copysource)==0):
copysource.append(source[0])
for i in range(0,(int(len(target)*fpercent/100))):
copytarget.append(target[i])
if(len(copytarget)==0):
copytarget.append(target[0])
return copysource,copytarget
except Exception as e:
print(e)
|
b0878ab2b3d888db984aa0644080578a85e9e554
| 17,852 |
def getScale(im, scale, max_scale=None):
"""
获得图片的放缩比例
:param im:
:param scale:
:param max_scale:
:return:
"""
f = float(scale) / min(im.shape[0], im.shape[1])
if max_scale != None and f * max(im.shape[0], im.shape[1]) > max_scale:
f = float(max_scale) / max(im.shape[0], im.shape[1])
return f
|
52ae195714c1d39bccec553797bf6dbf2c6c2795
| 17,853 |
def load_swc(path):
"""Load swc morphology from file
Used for sKCSD
Parameters
----------
path : str
Returns
-------
morphology : np.array
"""
morphology = np.loadtxt(path)
return morphology
|
0b0a4f82344b6c16180b4a52b1077a0f28966fde
| 17,854 |
import os
def getFileName(in_path, with_extension=False):
"""Return the file name with the file extension appended.
Args:
in_path (str): the file path to extract the filename from.
with_extension=False (Bool): flag denoting whether to return
the filename with or without the extension.
Returns:
Str - file name, with or without the extension appended or a
blank string if there is no file name in the path.
"""
filename = os.path.basename(in_path)
if os.path.sep in in_path[-2:] or (with_extension and not '.' in filename):
return ''
if with_extension:
return filename
else:
filename = os.path.splitext(filename)[0]
return filename
|
56972e397a2b5961656175962ab799bb95761e7c
| 17,855 |
def quintic_extrap((y1,y2,y3,y4,y5,y6), (x1,x2,x3,x4,x5,x6)):
"""
Quintic extrapolate from three x,y pairs to x = 0.
y1,y2...: y values from x,y pairs. Note that these can be arrays of values.
x1,x2...: x values from x,y pairs. These should be scalars.
Returns extrapolated y at x=0.
"""
# This horrid implementation came from using CForm in Mathematica.
Power = numpy.power
return (-(x1*(x1 - x3)*x3*(x1 - x4)*(x3 - x4)*x4*(x1 - x5)* (x3 - x5)*(x4 - x5)*x5*(x1 - x6)*(x3 - x6)* (x4 - x6)*(x5 - x6)*x6*y2) + Power(x2,5)*(-(x1*(x1 - x4)*x4*(x1 - x5)* (x4 - x5)*x5*(x1 - x6)*(x4 - x6)*(x5 - x6)* x6*y3) + Power(x3,4)* (-(x1*(x1 - x5)*x5*(x1 - x6)*(x5 - x6)*x6* y4) + Power(x4,3)* (x1*x6*(-x1 + x6)*y5 + Power(x5,2)*(x6*y1 - x1*y6) + x5*(-(Power(x6,2)*y1) + Power(x1,2)*y6)) + Power(x4,2)* (x1*x6*(Power(x1,2) - Power(x6,2))*y5 + Power(x5,3)*(-(x6*y1) + x1*y6) + x5*(Power(x6,3)*y1 - Power(x1,3)*y6)) + x4*(Power(x1,2)*Power(x6,2)*(-x1 + x6)* y5 + Power(x5,3)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,3)*y1) + Power(x1,3)*y6))) + Power(x3,3)* (x1*x5*x6*(Power(x1,3)*(x5 - x6) + x5*x6*(Power(x5,2) - Power(x6,2)) + x1*(-Power(x5,3) + Power(x6,3)))*y4 + Power(x4,4)* (x1*(x1 - x6)*x6*y5 + Power(x5,2)*(-(x6*y1) + x1*y6) + x5*(Power(x6,2)*y1 - Power(x1,2)*y6)) + x4*(Power(x1,2)*Power(x6,2)* (Power(x1,2) - Power(x6,2))*y5 + Power(x5,4)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,4)*y1 - Power(x1,4)*y6)) + Power(x4,2)* (x1*x6*(-Power(x1,3) + Power(x6,3))*y5 + Power(x5,4)*(x6*y1 - x1*y6) + x5*(-(Power(x6,4)*y1) + Power(x1,4)*y6))) + x3*(Power(x1,2)*(x1 - x5)*Power(x5,2)* (x1 - x6)*(x5 - x6)*Power(x6,2)*y4 + Power(x4,4)* (Power(x1,2)*(x1 - x6)*Power(x6,2)*y5 + Power(x5,3)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,3)*y1 - Power(x1,3)*y6)) + Power(x4,2)* (Power(x1,3)*(x1 - x6)*Power(x6,3)*y5 + Power(x5,4)* (-(Power(x6,3)*y1) + Power(x1,3)*y6) + Power(x5,3)* (Power(x6,4)*y1 - Power(x1,4)*y6)) + Power(x4,3)* (Power(x1,2)*Power(x6,2)* (-Power(x1,2) + Power(x6,2))*y5 + Power(x5,4)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,4)*y1) + Power(x1,4)*y6))) + Power(x3,2)* (x1*x5*x6*(Power(x5,2)*Power(x6,2)* (-x5 + x6) + Power(x1,3)* (-Power(x5,2) + Power(x6,2)) + Power(x1,2)*(Power(x5,3) - Power(x6,3))) *y4 + Power(x4,4)* (x1*x6*(-Power(x1,2) + Power(x6,2))*y5 + Power(x5,3)*(x6*y1 - x1*y6) + x5*(-(Power(x6,3)*y1) + Power(x1,3)*y6)) + Power(x4,3)* (x1*x6*(Power(x1,3) - Power(x6,3))*y5 + Power(x5,4)*(-(x6*y1) + x1*y6) + x5*(Power(x6,4)*y1 - Power(x1,4)*y6)) + x4*(Power(x1,3)*Power(x6,3)*(-x1 + x6)* y5 + Power(x5,4)* (Power(x6,3)*y1 - Power(x1,3)*y6) + Power(x5,3)* (-(Power(x6,4)*y1) + Power(x1,4)*y6)))) + Power(x2,4)*(x1*(x1 - x4)*x4*(x1 - x5)* (x4 - x5)*x5*(x1 - x6)*(x4 - x6)*(x5 - x6)* x6*(x1 + x4 + x5 + x6)*y3 + Power(x3,5)*(x1*(x1 - x5)*x5*(x1 - x6)* (x5 - x6)*x6*y4 + Power(x4,3)* (x1*(x1 - x6)*x6*y5 + Power(x5,2)*(-(x6*y1) + x1*y6) + x5*(Power(x6,2)*y1 - Power(x1,2)*y6)) + x4*(Power(x1,2)*(x1 - x6)*Power(x6,2)*y5 + Power(x5,3)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,3)*y1 - Power(x1,3)*y6)) + Power(x4,2)* (x1*x6*(-Power(x1,2) + Power(x6,2))*y5 + Power(x5,3)*(x6*y1 - x1*y6) + x5*(-(Power(x6,3)*y1) + Power(x1,3)*y6))) + Power(x3,2)* (x1*x5*(Power(x1,2) - Power(x5,2))*x6* (Power(x1,2) - Power(x6,2))* (Power(x5,2) - Power(x6,2))*y4 + Power(x4,5)* (x1*x6*(Power(x1,2) - Power(x6,2))*y5 + Power(x5,3)*(-(x6*y1) + x1*y6) + x5*(Power(x6,3)*y1 - Power(x1,3)*y6)) + x4*(Power(x1,3)*Power(x6,3)* (Power(x1,2) - Power(x6,2))*y5 + Power(x5,5)* (-(Power(x6,3)*y1) + Power(x1,3)*y6) + Power(x5,3)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,3)* (x1*x6*(-Power(x1,4) + Power(x6,4))*y5 + Power(x5,5)*(x6*y1 - x1*y6) + x5*(-(Power(x6,5)*y1) + Power(x1,5)*y6))) + Power(x3,3)* (x1*x5*x6*(-(Power(x5,4)*x6) + x5*Power(x6,4) + Power(x1,4)*(-x5 + x6) + x1*(Power(x5,4) - Power(x6,4)))*y4 + Power(x4,5)* (x1*x6*(-x1 + x6)*y5 + Power(x5,2)*(x6*y1 - x1*y6) + x5*(-(Power(x6,2)*y1) + Power(x1,2)*y6)) + Power(x4,2)* (x1*x6*(Power(x1,4) - Power(x6,4))*y5 + Power(x5,5)*(-(x6*y1) + x1*y6) + x5*(Power(x6,5)*y1 - Power(x1,5)*y6)) + x4*(Power(x1,2)*Power(x6,2)* (-Power(x1,3) + Power(x6,3))*y5 + Power(x5,5)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,5)*y1) + Power(x1,5)*y6))) + x3*(Power(x1,2)*Power(x5,2)*Power(x6,2)* (-(Power(x5,3)*x6) + x5*Power(x6,3) + Power(x1,3)*(-x5 + x6) + x1*(Power(x5,3) - Power(x6,3)))*y4 + Power(x4,5)* (Power(x1,2)*Power(x6,2)*(-x1 + x6)*y5 + Power(x5,3)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,3)*y1) + Power(x1,3)*y6)) + Power(x4,3)* (Power(x1,2)*Power(x6,2)* (Power(x1,3) - Power(x6,3))*y5 + Power(x5,5)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,2)* (Power(x1,3)*Power(x6,3)* (-Power(x1,2) + Power(x6,2))*y5 + Power(x5,5)* (Power(x6,3)*y1 - Power(x1,3)*y6) + Power(x5,3)* (-(Power(x6,5)*y1) + Power(x1,5)*y6)))) + Power(x2,3)*(-(x1*(x1 - x4)*x4*(x1 - x5)* (x4 - x5)*x5*(x1 - x6)*(x4 - x6)*(x5 - x6)* x6*(x5*x6 + x4*(x5 + x6) + x1*(x4 + x5 + x6))*y3) + Power(x3,5)*(x1*x5*x6* (-(Power(x5,3)*x6) + x5*Power(x6,3) + Power(x1,3)*(-x5 + x6) + x1*(Power(x5,3) - Power(x6,3)))*y4 + Power(x4,4)* (x1*x6*(-x1 + x6)*y5 + Power(x5,2)*(x6*y1 - x1*y6) + x5*(-(Power(x6,2)*y1) + Power(x1,2)*y6)) + Power(x4,2)* (x1*x6*(Power(x1,3) - Power(x6,3))*y5 + Power(x5,4)*(-(x6*y1) + x1*y6) + x5*(Power(x6,4)*y1 - Power(x1,4)*y6)) + x4*(Power(x1,2)*Power(x6,2)* (-Power(x1,2) + Power(x6,2))*y5 + Power(x5,4)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,4)*y1) + Power(x1,4)*y6))) + Power(x3,4)* (x1*x5*x6*(Power(x1,4)*(x5 - x6) + x5*x6*(Power(x5,3) - Power(x6,3)) + x1*(-Power(x5,4) + Power(x6,4)))*y4 + Power(x4,5)* (x1*(x1 - x6)*x6*y5 + Power(x5,2)*(-(x6*y1) + x1*y6) + x5*(Power(x6,2)*y1 - Power(x1,2)*y6)) + x4*(Power(x1,2)*Power(x6,2)* (Power(x1,3) - Power(x6,3))*y5 + Power(x5,5)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,2)* (x1*x6*(-Power(x1,4) + Power(x6,4))*y5 + Power(x5,5)*(x6*y1 - x1*y6) + x5*(-(Power(x6,5)*y1) + Power(x1,5)*y6))) + x3*(Power(x1,2)*Power(x5,2)* Power(x6,2)* (Power(x5,2)*(x5 - x6)*Power(x6,2) + Power(x1,3)* (Power(x5,2) - Power(x6,2)) + Power(x1,2)*(-Power(x5,3) + Power(x6,3)))*y4 + Power(x4,5)* (Power(x1,2)*Power(x6,2)* (Power(x1,2) - Power(x6,2))*y5 + Power(x5,4)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,4)*y1 - Power(x1,4)*y6)) + Power(x4,2)* (Power(x1,4)*(x1 - x6)*Power(x6,4)*y5 + Power(x5,5)* (-(Power(x6,4)*y1) + Power(x1,4)*y6) + Power(x5,4)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,4)* (Power(x1,2)*Power(x6,2)* (-Power(x1,3) + Power(x6,3))*y5 + Power(x5,5)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,5)*y1) + Power(x1,5)*y6))) + Power(x3,2)* (x1*x5*x6*(Power(x5,3)*Power(x6,3)* (-x5 + x6) + Power(x1,4)* (-Power(x5,3) + Power(x6,3)) + Power(x1,3)*(Power(x5,4) - Power(x6,4))) *y4 + Power(x4,5)* (x1*x6*(-Power(x1,3) + Power(x6,3))*y5 + Power(x5,4)*(x6*y1 - x1*y6) + x5*(-(Power(x6,4)*y1) + Power(x1,4)*y6)) + Power(x4,4)* (x1*x6*(Power(x1,4) - Power(x6,4))*y5 + Power(x5,5)*(-(x6*y1) + x1*y6) + x5*(Power(x6,5)*y1 - Power(x1,5)*y6)) + x4*(Power(x1,4)*Power(x6,4)*(-x1 + x6)* y5 + Power(x5,5)* (Power(x6,4)*y1 - Power(x1,4)*y6) + Power(x5,4)* (-(Power(x6,5)*y1) + Power(x1,5)*y6)))) + x2*(-(Power(x1,2)*(x1 - x4)*Power(x4,2)* (x1 - x5)*(x4 - x5)*Power(x5,2)*(x1 - x6)* (x4 - x6)*(x5 - x6)*Power(x6,2)*y3) + Power(x3,5)*(-(Power(x1,2)*(x1 - x5)* Power(x5,2)*(x1 - x6)*(x5 - x6)* Power(x6,2)*y4) + Power(x4,4)* (Power(x1,2)*Power(x6,2)*(-x1 + x6)*y5 + Power(x5,3)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,3)*y1) + Power(x1,3)*y6)) + Power(x4,3)* (Power(x1,2)*Power(x6,2)* (Power(x1,2) - Power(x6,2))*y5 + Power(x5,4)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,4)*y1 - Power(x1,4)*y6)) + Power(x4,2)* (Power(x1,3)*Power(x6,3)*(-x1 + x6)*y5 + Power(x5,4)* (Power(x6,3)*y1 - Power(x1,3)*y6) + Power(x5,3)* (-(Power(x6,4)*y1) + Power(x1,4)*y6))) + Power(x3,4)* (Power(x1,2)*Power(x5,2)*Power(x6,2)* (Power(x1,3)*(x5 - x6) + x5*x6*(Power(x5,2) - Power(x6,2)) + x1*(-Power(x5,3) + Power(x6,3)))*y4 + Power(x4,5)* (Power(x1,2)*(x1 - x6)*Power(x6,2)*y5 + Power(x5,3)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,3)*y1 - Power(x1,3)*y6)) + Power(x4,2)* (Power(x1,3)*Power(x6,3)* (Power(x1,2) - Power(x6,2))*y5 + Power(x5,5)* (-(Power(x6,3)*y1) + Power(x1,3)*y6) + Power(x5,3)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,3)* (Power(x1,2)*Power(x6,2)* (-Power(x1,3) + Power(x6,3))*y5 + Power(x5,5)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,5)*y1) + Power(x1,5)*y6))) + Power(x3,2)* (Power(x1,3)*(x1 - x5)*Power(x5,3)*(x1 - x6)* (x5 - x6)*Power(x6,3)*y4 + Power(x4,5)* (Power(x1,3)*(x1 - x6)*Power(x6,3)*y5 + Power(x5,4)* (-(Power(x6,3)*y1) + Power(x1,3)*y6) + Power(x5,3)* (Power(x6,4)*y1 - Power(x1,4)*y6)) + Power(x4,3)* (Power(x1,4)*(x1 - x6)*Power(x6,4)*y5 + Power(x5,5)* (-(Power(x6,4)*y1) + Power(x1,4)*y6) + Power(x5,4)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,4)* (Power(x1,3)*Power(x6,3)* (-Power(x1,2) + Power(x6,2))*y5 + Power(x5,5)* (Power(x6,3)*y1 - Power(x1,3)*y6) + Power(x5,3)* (-(Power(x6,5)*y1) + Power(x1,5)*y6))) + Power(x3,3)* (Power(x1,2)*Power(x5,2)*Power(x6,2)* (Power(x5,2)*Power(x6,2)*(-x5 + x6) + Power(x1,3)* (-Power(x5,2) + Power(x6,2)) + Power(x1,2)*(Power(x5,3) - Power(x6,3))) *y4 + Power(x4,5)* (Power(x1,2)*Power(x6,2)* (-Power(x1,2) + Power(x6,2))*y5 + Power(x5,4)* (Power(x6,2)*y1 - Power(x1,2)*y6) + Power(x5,2)* (-(Power(x6,4)*y1) + Power(x1,4)*y6)) + Power(x4,4)* (Power(x1,2)*Power(x6,2)* (Power(x1,3) - Power(x6,3))*y5 + Power(x5,5)* (-(Power(x6,2)*y1) + Power(x1,2)*y6) + Power(x5,2)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,2)* (Power(x1,4)*Power(x6,4)*(-x1 + x6)*y5 + Power(x5,5)* (Power(x6,4)*y1 - Power(x1,4)*y6) + Power(x5,4)* (-(Power(x6,5)*y1) + Power(x1,5)*y6)))) + Power(x2,2)*(x1*(x1 - x4)*x4*(x1 - x5)* (x4 - x5)*x5*(x1 - x6)*(x4 - x6)*(x5 - x6)* x6*(x4*x5*x6 + x1*(x5*x6 + x4*(x5 + x6)))*y3 + Power(x3,5)* (x1*x5*x6*(Power(x5,2)*(x5 - x6)* Power(x6,2) + Power(x1,3)* (Power(x5,2) - Power(x6,2)) + Power(x1,2)*(-Power(x5,3) + Power(x6,3)))*y4 + Power(x4,4)* (x1*x6*(Power(x1,2) - Power(x6,2))*y5 + Power(x5,3)*(-(x6*y1) + x1*y6) + x5*(Power(x6,3)*y1 - Power(x1,3)*y6)) + x4*(Power(x1,3)*(x1 - x6)*Power(x6,3)*y5 + Power(x5,4)* (-(Power(x6,3)*y1) + Power(x1,3)*y6) + Power(x5,3)* (Power(x6,4)*y1 - Power(x1,4)*y6)) + Power(x4,3)* (x1*x6*(-Power(x1,3) + Power(x6,3))*y5 + Power(x5,4)*(x6*y1 - x1*y6) + x5*(-(Power(x6,4)*y1) + Power(x1,4)*y6))) + Power(x3,3)* (x1*x5*x6*(Power(x5,3)*(x5 - x6)* Power(x6,3) + Power(x1,4)* (Power(x5,3) - Power(x6,3)) + Power(x1,3)*(-Power(x5,4) + Power(x6,4)))*y4 + Power(x4,5)* (x1*x6*(Power(x1,3) - Power(x6,3))*y5 + Power(x5,4)*(-(x6*y1) + x1*y6) + x5*(Power(x6,4)*y1 - Power(x1,4)*y6)) + x4*(Power(x1,4)*(x1 - x6)*Power(x6,4)*y5 + Power(x5,5)* (-(Power(x6,4)*y1) + Power(x1,4)*y6) + Power(x5,4)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,4)* (x1*x6*(-Power(x1,4) + Power(x6,4))*y5 + Power(x5,5)*(x6*y1 - x1*y6) + x5*(-(Power(x6,5)*y1) + Power(x1,5)*y6))) + Power(x3,4)* (-(x1*x5*(Power(x1,2) - Power(x5,2))*x6* (Power(x1,2) - Power(x6,2))* (Power(x5,2) - Power(x6,2))*y4) + Power(x4,5)* (x1*x6*(-Power(x1,2) + Power(x6,2))*y5 + Power(x5,3)*(x6*y1 - x1*y6) + x5*(-(Power(x6,3)*y1) + Power(x1,3)*y6)) + Power(x4,3)* (x1*x6*(Power(x1,4) - Power(x6,4))*y5 + Power(x5,5)*(-(x6*y1) + x1*y6) + x5*(Power(x6,5)*y1 - Power(x1,5)*y6)) + x4*(Power(x1,3)*Power(x6,3)* (-Power(x1,2) + Power(x6,2))*y5 + Power(x5,5)* (Power(x6,3)*y1 - Power(x1,3)*y6) + Power(x5,3)* (-(Power(x6,5)*y1) + Power(x1,5)*y6))) + x3*(-(Power(x1,3)*(x1 - x5)*Power(x5,3)* (x1 - x6)*(x5 - x6)*Power(x6,3)*y4) + Power(x4,5)* (Power(x1,3)*Power(x6,3)*(-x1 + x6)*y5 + Power(x5,4)* (Power(x6,3)*y1 - Power(x1,3)*y6) + Power(x5,3)* (-(Power(x6,4)*y1) + Power(x1,4)*y6)) + Power(x4,4)* (Power(x1,3)*Power(x6,3)* (Power(x1,2) - Power(x6,2))*y5 + Power(x5,5)* (-(Power(x6,3)*y1) + Power(x1,3)*y6) + Power(x5,3)* (Power(x6,5)*y1 - Power(x1,5)*y6)) + Power(x4,3)* (Power(x1,4)*Power(x6,4)*(-x1 + x6)*y5 + Power(x5,5)* (Power(x6,4)*y1 - Power(x1,4)*y6) + Power(x5,4)* (-(Power(x6,5)*y1) + Power(x1,5)*y6)))))/((x1 - x2)*(x1 - x3)*(-x2 + x3)*(x1 - x4)* (-x2 + x4)*(-x3 + x4)*(x1 - x5)*(x2 - x5)* (x3 - x5)*(x4 - x5)*(x1 - x6)*(x2 - x6)* (x3 - x6)*(x4 - x6)*(x5 - x6))
|
41090e09f2b7f58e98fa9fc91ea6000d70594046
| 17,856 |
def answer_question_interactively(question):
"""Returns True or False for t yes/no question to the user"""
while True:
answer = input(question + '? [Y or N]: ')
if answer.lower() == 'y':
return True
elif answer.lower() == 'n':
return False
|
52a123cc2237441de3b0243da268e53b7cc0d807
| 17,857 |
def connect(
instance_id,
database_id,
project=None,
credentials=None,
pool=None,
user_agent=None,
):
"""Creates a connection to a Google Cloud Spanner database.
:type instance_id: str
:param instance_id: The ID of the instance to connect to.
:type database_id: str
:param database_id: The ID of the database to connect to.
:type project: str
:param project: (Optional) The ID of the project which owns the
instances, tables and data. If not provided, will
attempt to determine from the environment.
:type credentials: Union[:class:`~google.auth.credentials.Credentials`, str]
:param credentials: (Optional) The authorization credentials to attach to
requests. These credentials identify this application
to the service. These credentials may be specified as
a file path indicating where to retrieve the service
account JSON for the credentials to connect to
Cloud Spanner. If none are specified, the client will
attempt to ascertain the credentials from the
environment.
:type pool: Concrete subclass of
:class:`~google.cloud.spanner_v1.pool.AbstractSessionPool`.
:param pool: (Optional). Session pool to be used by database.
:type user_agent: str
:param user_agent: (Optional) User agent to be used with this connection's
requests.
:rtype: :class:`google.cloud.spanner_dbapi.connection.Connection`
:returns: Connection object associated with the given Google Cloud Spanner
resource.
:raises: :class:`ValueError` in case of given instance/database
doesn't exist.
"""
client_info = ClientInfo(
user_agent=user_agent or DEFAULT_USER_AGENT, python_version=PY_VERSION
)
if isinstance(credentials, str):
client = spanner.Client.from_service_account_json(
credentials, project=project, client_info=client_info
)
else:
client = spanner.Client(
project=project, credentials=credentials, client_info=client_info
)
instance = client.instance(instance_id)
if not instance.exists():
raise ValueError("instance '%s' does not exist." % instance_id)
database = instance.database(database_id, pool=pool)
if not database.exists():
raise ValueError("database '%s' does not exist." % database_id)
conn = Connection(instance, database)
if pool is not None:
conn._own_pool = False
return conn
|
7cff910615df346a5a503dec5e1938476cb701e6
| 17,858 |
from typing import List
def intersect(linked_list_1: List, linked_list_2: List):
"""Intersection point of two linked list."""
length_diff = len(linked_list_1) - len(linked_list_2)
enum1 = list(enumerate(linked_list_1))
enum2 = list(enumerate(linked_list_2))
if length_diff < 0:
enum2 = _helper(length_diff=length_diff, linked_list=enum2)
else:
enum1 = _helper(length_diff=length_diff, linked_list=enum1)
for (i, j,) in zip(enum1, enum2):
if i[1] == j[1]:
return (i[0], j[0],)
return None
|
dea64a6618ab3bda421250036e4eea8fa316a6ec
| 17,859 |
import fnmatch
def recognize_package_manifests(location):
"""
Return a list of Package objects if any package_manifests were recognized for this
`location`, or None if there were no Packages found. Raises Exceptions on errors.
"""
if not filetype.is_file(location):
return
T = contenttype.get_type(location)
ftype = T.filetype_file.lower()
mtype = T.mimetype_file
_base_name, extension = splitext_name(location, is_file=True)
filename = file_name(location)
extension = extension.lower()
if TRACE:
logger_debug(
'recognize_packages: ftype:', ftype, 'mtype:', mtype,
'pygtype:', T.filetype_pygment,
'fname:', filename, 'ext:', extension,
)
recognized_package_manifests = []
for package_type in PACKAGE_TYPES:
# Note: default to True if there is nothing to match against
metafiles = package_type.metafiles
if any(fnmatch.fnmatchcase(filename, metaf) for metaf in metafiles):
for recognized in package_type.recognize(location):
if TRACE:
logger_debug(
'recognize_packages: metafile matching: recognized:',
recognized,
)
if recognized and not recognized.license_expression:
# compute and set a normalized license expression
recognized.license_expression = recognized.compute_normalized_license()
if TRACE:
logger_debug(
'recognize_packages: recognized.license_expression:',
recognized.license_expression,
)
recognized_package_manifests.append(recognized)
return recognized_package_manifests
type_matched = False
if package_type.filetypes:
type_matched = any(t in ftype for t in package_type.filetypes)
mime_matched = False
if package_type.mimetypes:
mime_matched = any(m in mtype for m in package_type.mimetypes)
extension_matched = False
extensions = package_type.extensions
if extensions:
extensions = (e.lower() for e in extensions)
extension_matched = any(
fnmatch.fnmatchcase(extension, ext_pat)
for ext_pat in extensions
)
if type_matched and mime_matched and extension_matched:
if TRACE:
logger_debug(f'recognize_packages: all matching for {package_type}')
try:
for recognized in package_type.recognize(location):
# compute and set a normalized license expression
if recognized and not recognized.license_expression:
try:
recognized.license_expression = recognized.compute_normalized_license()
except Exception:
if SCANCODE_DEBUG_PACKAGE_API:
raise
recognized.license_expression = 'unknown'
if TRACE:
logger_debug('recognize_packages: recognized', recognized)
recognized_package_manifests.append(recognized)
except NotImplementedError:
# build a plain package if recognize is not yet implemented
recognized = package_type()
if TRACE:
logger_debug('recognize_packages: recognized', recognized)
recognized_package_manifests.append(recognized)
if SCANCODE_DEBUG_PACKAGE_API:
raise
return recognized_package_manifests
if TRACE: logger_debug('recognize_packages: no match for type:', package_type)
|
4e90726be78ec73b3d68dc52e1aa32b7bad420ab
| 17,860 |
import torch
def content_loss(sharp_images, deblur_images, cont_net):
"""
Computes the Content Loss to compare the
reconstructed (deblurred) and the original(sharp) images
Takes the output feature maps of the relu4_3 layer of pretrained VGG19 to compare the content between
images as proposed in :
Johnson et. al. "Perceptual losses for real-time style transfer and super-resolution." (ECCV 2016)
"""
# Torchvision models documentation:
# All pre-trained models expect input images normalized in the same way, The images have to be loaded in
# to a range of [0, 1] and then normalized using mean = [0.485, 0.456, 0.406] and std = [0.229, 0.224, 0.225].
deblur_images = (deblur_images + 1) * 0.5
sharp_images = (sharp_images + 1) * 0.5
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
deblur_images = normalize(deblur_images)
sharp_images= normalize(sharp_images)
content_deblur = cont_net(deblur_images)
content_sharp = cont_net(sharp_images)
content_sharp = content_sharp.detach()
loss = nn.MSELoss()
lossC = torch.mean(loss(content_deblur,content_sharp))
return lossC
|
f55b4c22391d6e562afb927251fb6af267f9da08
| 17,861 |
def generate_cashflow_diagram(
cashflows, d=None, net=False, scale=None, color=None, title=None, **kwargs):
""" Generates a barplot showing cashflows over time
Given a set of cashflows, produces a stacked barplot with bars at each
period. The height of each bar is set by the amount of cash produced
by a cashflow at the specified period.
Note that this function does not display the produced plot; call
matplotlib.pyplot.show() to view the plot.
Args:
cashflows: A sequence of cashflows to plot
d: Optional; A two-integer list whose elements represent the first
and final periods to be plotted
net: Optional; When true, only the net cashflows are shown, and the
individual cashflow information is omitted.
scale: Optional; The y-axis scale; must be a member or key of Scales
kwargs: A list of keyword arguments to be passed to Dataframe.plot()
Returns:
A Figure and Axis for the plot
"""
# Parse Args
cashflows = (cashflows,) if isinstance(cashflows, Cashflow) else cashflows
d = parse_d(d or get_final_period(cashflows, finite=True) or 5)
net = bool(net)
if color:
color = color.colors if isinstance(color, ListedColormap) else color
else:
color = default_colormap.colors
if scale:
scale = (
scale if isinstance(scale, Scales)
else Scales[scale.upper()])
# Extract information
periods = list(range(d[0], d[1] + 1))
titles = [cashflow.get_title() for cashflow in cashflows]
cashflows = [
[cashflow[n].amount for cashflow in cashflows]
for n in periods
]
# Format information
if net:
cashflows = [[sum(cashflows[n])] for n in periods]
if scale:
cashflows = [
[cashflow * scale.value for cashflow in cashflows[n]]
for n in periods
]
# Plot the Cashflow Diagram with matplotlib
plotdata = pd.DataFrame(cashflows, index=periods, columns=titles)
fig, ax = plt.subplots()
plotdata.plot(kind="bar", stacked="true", ax=ax, color=color, **kwargs)
ax.set_title(title)
ax.set_ylabel("Cashflows" + (f" [{scale.name.title()}]" if scale else ""))
ax.set_xlabel("Period")
ax.axhline()
return fig, ax
|
88afbd975a20041dccd24b8dc25899347a0b44ae
| 17,862 |
import collections
def is_iterable(obj):
# type: (Any) -> bool
"""
Returns True if obj is a non-string iterable
"""
if is_str(obj) is True or isinstance(obj, collections.Iterable) is False:
return False
else:
return True
|
92db9be57250a53cf27118c9a4c91344a9d14fcb
| 17,863 |
def other_players(me, r):
"""Return a list of all players but me, in turn order starting after me"""
return list(range(me+1, r.nPlayers)) + list(range(0, me))
|
5c2d2b03bfb3b99eb4c347319ccaaa3fc495b6c4
| 17,864 |
def mock_dd_slo_history(*args, **kwargs):
"""Mock Datadog response for datadog.api.ServiceLevelObjective.history."""
return load_fixture('dd_slo_history.json')
|
963fbbe20373e4e207852be82b88e33ca2c24e9a
| 17,865 |
import torch
def check_joints2d_visibility_torch(joints2d, img_wh):
"""
Checks if 2D joints are within the image dimensions.
"""
vis = torch.ones(joints2d.shape[:2], device=joints2d.device, dtype=torch.bool)
vis[joints2d[:, :, 0] > img_wh] = 0
vis[joints2d[:, :, 1] > img_wh] = 0
vis[joints2d[:, :, 0] < 0] = 0
vis[joints2d[:, :, 1] < 0] = 0
return vis
|
a276d93a66dfd5bca15a684f652a0eede3094868
| 17,866 |
def getIntervalIntersectionLength(aa, bb, wrapAt=360):
"""Returns the length of the intersection between two intervals."""
intersection = getIntervalIntersection(aa, bb, wrapAt=wrapAt)
if intersection is False:
return 0.0
else:
if wrapAt is None:
return (intersection[1] - intersection[0])
else:
return (intersection[1] - intersection[0]) % wrapAt
|
46924c149e8b5b802fc83e489417850f3a8dbd18
| 17,867 |
def test_jvp_construct_single_input_single_output_default_v_graph():
"""
Features: Function jvp
Description: Test jvp with Cell construct, single input, single output and default v in graph mode.
Expectation: No exception.
"""
x = Tensor(np.array([[1, 2], [3, 4]]).astype(np.float32))
v = Tensor(np.array([[1, 1], [1, 1]]).astype(np.float32))
class Net(nn.Cell):
def __init__(self, network):
super(Net, self).__init__()
self.net = network
def construct(self, inputs, vectors):
net_out, jvp_out = jvp(self.net, inputs, vectors)
return net_out, jvp_out
test_net = Net(SingleInputSingleOutputNet())
primal, grad = test_net(x, v)
expect_primal = Tensor(np.array([[1, 8], [27, 64]]).astype(np.float32))
expect_grad = Tensor(np.array([[3, 12], [27, 48]]).astype(np.float32))
assert np.allclose(primal.asnumpy(), expect_primal.asnumpy())
assert np.allclose(grad.asnumpy(), expect_grad.asnumpy())
|
edd6b1c93dc880310fc0af2012d3fbfca328b64c
| 17,868 |
def get_environment() -> Environment:
"""
Parses environment variables and sets their defaults if they do not exist.
"""
return Environment(
permission_url=get_endpoint("PERMISSION"),
media_url=get_endpoint("MEDIA"),
datastore_reader_url=get_endpoint("DATASTORE_READER"),
datastore_writer_url=get_endpoint("DATASTORE_WRITER"),
)
|
2ce9b56c76fadcd19a861f00e8d880a181b676ed
| 17,869 |
from typing import Optional
def get_kubernetes_cluster(name: Optional[str] = None,
resource_group_name: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetKubernetesClusterResult:
"""
Use this data source to access information about an existing Managed Kubernetes Cluster (AKS).
## Example Usage
```python
import pulumi
import pulumi_azure as azure
example = azure.containerservice.get_kubernetes_cluster(name="myakscluster",
resource_group_name="my-example-resource-group")
```
:param str name: The name of the managed Kubernetes Cluster.
:param str resource_group_name: The name of the Resource Group in which the managed Kubernetes Cluster exists.
"""
__args__ = dict()
__args__['name'] = name
__args__['resourceGroupName'] = resource_group_name
if opts is None:
opts = pulumi.InvokeOptions()
if opts.version is None:
opts.version = _utilities.get_version()
__ret__ = pulumi.runtime.invoke('azure:containerservice/getKubernetesCluster:getKubernetesCluster', __args__, opts=opts, typ=GetKubernetesClusterResult).value
return AwaitableGetKubernetesClusterResult(
addon_profiles=__ret__.addon_profiles,
agent_pool_profiles=__ret__.agent_pool_profiles,
api_server_authorized_ip_ranges=__ret__.api_server_authorized_ip_ranges,
disk_encryption_set_id=__ret__.disk_encryption_set_id,
dns_prefix=__ret__.dns_prefix,
fqdn=__ret__.fqdn,
id=__ret__.id,
identities=__ret__.identities,
kube_admin_config_raw=__ret__.kube_admin_config_raw,
kube_admin_configs=__ret__.kube_admin_configs,
kube_config_raw=__ret__.kube_config_raw,
kube_configs=__ret__.kube_configs,
kubelet_identities=__ret__.kubelet_identities,
kubernetes_version=__ret__.kubernetes_version,
linux_profiles=__ret__.linux_profiles,
location=__ret__.location,
name=__ret__.name,
network_profiles=__ret__.network_profiles,
node_resource_group=__ret__.node_resource_group,
private_cluster_enabled=__ret__.private_cluster_enabled,
private_fqdn=__ret__.private_fqdn,
private_link_enabled=__ret__.private_link_enabled,
resource_group_name=__ret__.resource_group_name,
role_based_access_controls=__ret__.role_based_access_controls,
service_principals=__ret__.service_principals,
tags=__ret__.tags,
windows_profiles=__ret__.windows_profiles)
|
38beb9a7a96e51364f35c658d85428991e0686a8
| 17,870 |
def gene_expression_conv_base():
"""Hparams for GeneExpressionConv model."""
hparams = common_hparams.basic_params1()
batch_size = 10
output_length = 2048
inputs_per_output = 128
chunk_size = 4
input_length = output_length * inputs_per_output // chunk_size
hparams.batch_size = input_length * batch_size
hparams.dropout = 0.1
hparams.add_hparam("num_conv_layers", 4)
hparams.add_hparam("num_dconv_layers", 7)
# The product of these pooling windows should match
# input_length/target_length.
hparams.add_hparam("pooling_windows", [2, 2, 2, 4])
hparams.hidden_size = 256
hparams.kernel_width = 20
hparams.add_hparam("stride", 1)
return hparams
|
7bd239fb511a7f72837a139f236557278f0c1dab
| 17,871 |
import typing
from typing import _GenericAlias
import collections
def is_callable(type_def, allow_callable_class: bool = False) -> bool:
"""
Checks whether the ``type_def`` is a callable according to the following rules:
1. Functions are callable.
2. ``typing.Callable`` types are callable.
3. Generic aliases of types which are ``is_callable`` are callable.
4. If ``allow_callable_class`` is set to ``True``, then classes which have a ``__call__`` method are callable.
:param type_def: the type to check.
:param allow_callable_class: set to ``True`` to consider classes which have a ``__call__`` method callable.
:return: ``True`` if ``type_def`` is a callable type, ``False`` otherwise.
"""
if isinstance(type_def, type(_check_callable_signature)):
return True
if isinstance(type_def, typing._SpecialForm):
return False
if isinstance(type_def, _GenericAlias):
if type_def.__origin__ == typing.Callable or type_def.__origin__ == collections.abc.Callable:
return True
if type_def._special:
return False
return is_callable(type_def.__origin__, allow_callable_class=allow_callable_class)
if allow_callable_class and hasattr(type_def, "__call__"):
return True
return False
|
68c51cfc4da4891c90c376e8ff1b26dc630a96de
| 17,872 |
def vgg19(pretrained=False, **kwargs):
"""VGG 19-layer model (configuration "E")
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = VGG(make_layers(cfg['E']), **kwargs)
if pretrained:
model.load_pretrained_model(model_zoo.load_url(model_urls['vgg19']))
return model
|
7c7e43eb46ffeb20fd5901d5761e11f701650727
| 17,873 |
def get_formats(input_f, input_case="cased", is_default=True):
"""
Adds various abbreviation format options to the list of acceptable input forms
"""
multiple_formats = load_labels(input_f)
additional_options = []
for x, y in multiple_formats:
if input_case == "lower_cased":
x = x.lower()
additional_options.append((f"{x}.", y)) # default "dr" -> doctor, this includes period "dr." -> doctor
additional_options.append((f"{x[0].upper() + x[1:]}", f"{y[0].upper() + y[1:]}")) # "Dr" -> Doctor
additional_options.append((f"{x[0].upper() + x[1:]}.", f"{y[0].upper() + y[1:]}")) # "Dr." -> Doctor
multiple_formats.extend(additional_options)
if not is_default:
multiple_formats = [(x, f"|raw_start|{x}|raw_end||norm_start|{y}|norm_end|") for (x, y) in multiple_formats]
multiple_formats = pynini.string_map(multiple_formats)
return multiple_formats
|
a20a02a7e85c1711d8b9d779e5804ed8e1dec83a
| 17,874 |
def db_select_entry(c, bibkey):
""" Select entry from database
:argument
c: sqlite3 cursor
:returns
entry_dict: dict
"""
fields = ['bibkey', 'author', 'genre', 'thesis', 'hypothesis',
'method', 'finding', 'comment', 'img_linkstr']
sql = "SELECT {:s} FROM note WHERE bibkey = (?)".format(','.join(fields))
c.execute(sql, (bibkey,))
result = c.fetchall()[0]
a_dict = {}
for field, value in zip(fields, result):
a_dict[field] = value
c.execute("SELECT tag FROM tags WHERE bibkey = (?) ORDER BY tag ASC",
(a_dict['bibkey'],))
tags = tuple(r[0] for r in c.fetchall())
return a_dict, tags
|
a93425aa2487f28bc3215a65ad1f963ea1173fcd
| 17,875 |
def to_bytes(obj, encoding='utf-8', errors='strict'):
"""Makes sure that a string is a byte string.
Args:
obj: An object to make sure is a byte string.
encoding: The encoding to use to transform from a text string to
a byte string. Defaults to using 'utf-8'.
errors: The error handler to use if the text string is not
encodable using the specified encoding. Any valid codecs error
handler may be specified.
Returns: Typically this returns a byte string.
"""
if isinstance(obj, bytes):
return obj
return bytes(obj, encoding=encoding, errors=errors)
|
4f8a0dcfdcfd3e2a77b5cbeedea4cb2a11acd4c1
| 17,876 |
def login() -> Response:
"""
Login to Afterglow
GET|POST /auth/login
- login to Afterglow; authentication required using any of the methods
defined in USER_AUTH
:return: empty response with "afterglow_core_access_token" cookie
if successfully logged in
"""
# TODO Ensure CORS is disabled for POSTS to this endpoint
# TODO Allow additional domains for cookies to be specified in server config
next_url = request.args.get('next')
if not next_url:
next_url = url_for('default')
if request.method == 'GET':
try:
authenticate()
return redirect(next_url)
except NotAuthenticatedError:
pass
# Do not allow login if Afterglow Core has not yet been configured
if DbUser.query.count() == 0:
return redirect(url_for('initialize'))
# raise NotInitializedError()
if request.method == 'GET':
return render_template(
'login.html.j2', oauth_plugins=oauth_plugins.values(),
next_url=next_url)
username = request.args.get('username')
if not username:
raise ValidationError('username', 'Username cannot be empty')
password = request.args.get('password')
if not password:
raise ValidationError('password', 'Password cannot be empty')
user = DbUser.query.filter_by(username=username).one_or_none()
if user is None:
raise HttpAuthFailedError()
if not verify_password(password, user.password):
raise HttpAuthFailedError()
# set token cookies
request.user = user
return set_access_cookies(json_response())
|
691540d0652b9909fa0f05af0dcc434d400be5a4
| 17,877 |
def compact(number, strip_check_digit=True):
"""Convert the MEID number to the minimal (hexadecimal) representation.
This strips grouping information, removes surrounding whitespace and
converts to hexadecimal if needed. If the check digit is to be preserved
and conversion is done a new check digit is recalculated."""
# first parse the number
number, cd = _parse(number)
# strip check digit if needed
if strip_check_digit:
cd = ''
# convert to hex if needed
if len(number) == 18:
number = '%08X%06X' % (int(number[0:10]), int(number[10:18]))
if cd:
cd = calc_check_digit(number)
# put parts back together again
return number + cd
|
ced106ed8c97d432a8059d8654cfb437620deb64
| 17,878 |
from typing import List
def hashtag_getter(doc: Doc) -> List[str]:
"""
Extract hashtags from text
Args:
doc (Doc): A SpaCy document
Returns:
List[str]: A list of hashtags
Example:
>>> from spacy.tokens import Doc
>>> Doc.set_extension("hashtag", getter=dacy.utilities.twitter.hashtags)
>>> doc = nlp("Fuck hvor fedt! #yolo #life")
>>> doc._.hashtag # extrac the hashtags from your document
["#yolo", "#life"]
"""
def find_hashtags(
text,
valid_tags={"#", "＃"},
valid_chars={"_", "-"},
invalid_tag_suffix={b"\xe2\x83\xa3", b"\xef\xb8\x8f"},
):
def is_letter(t):
if (
t.isalnum()
or t in valid_chars
or str.encode(t).startswith(b"\xcc")
or str.encode(t).startswith(b"\xe0")
):
return True
return False
start = None
for i, char in enumerate(text):
if (
char in valid_tags
and not (
i + 1 != len(text) and str.encode(text[i + 1]) in invalid_tag_suffix
)
and (i == 0 or not (is_letter(text[i - 1]) or text[i - 1] == "&"))
):
start = i
continue
if start is not None and not is_letter(char):
if char in valid_tags:
start = None
continue
print(start, i)
if not text[start + 1 : i].isnumeric():
yield "#" + text[start + 1 : i]
start = None
if start is not None and not text[start + 1 : i + 1].isnumeric():
print(start, i)
yield "#" + text[start + 1 : i + 1]
return list(find_hashtags(doc.text))
|
a85c5cf9bd2fec2ec74e70bf2dadfb1df688c128
| 17,879 |
def options():
"""Stub version of the parsed command line options."""
class StubOptions(object):
profile = None
return StubOptions()
|
dea85d2956eb6cbf97f870a74b122896915c8c19
| 17,880 |
import logging
def get_surface(shifts, orig_text, item, text, unit_shortening=0):
"""
Extract surface from regex hit.
"""
# handle cut end
span = (item.start(), item.end() - unit_shortening)
logging.debug('\tInitial span: %s ("%s")', span, text[span[0]:span[1]])
real_span = (span[0] - shifts[span[0]], span[1] - shifts[span[1] - 1])
surface = orig_text[real_span[0]:real_span[1]]
logging.debug('\tShifted span: %s ("%s")', real_span, surface)
while any(surface.endswith(i) for i in [' ', '-']):
surface = surface[:-1]
real_span = (real_span[0], real_span[1] - 1)
while surface.startswith(' '):
surface = surface[1:]
real_span = (real_span[0] + 1, real_span[1])
logging.debug('\tFinal span: %s ("%s")', real_span, surface)
return surface, real_span
|
dde9a59ed50a71ab21a2fcd8b3468f5414adc94a
| 17,881 |
def plot_bootstrap_delta_grp(dfboot, df, grp, force_xlim=None, title_add=''):
"""Plot delta between boostrap results, grouped"""
count_txt_h_kws, mean_txt_kws, pest_mean_point_kws, mean_point_kws = _get_kws_styling()
if dfboot[grp].dtypes != 'object':
dfboot = dfboot.copy()
dfboot[grp] = dfboot[grp].map(lambda x: f's{x}')
mn = dfboot.groupby(grp).size()
f = plt.figure(figsize=(14, 2+(len(mn)*.2))) #, constrained_layout=True)
gs = gridspec.GridSpec(1, 2, width_ratios=[11, 1], figure=f)
ax0 = f.add_subplot(gs[0])
ax1 = f.add_subplot(gs[1], sharey=ax0)
_ = sns.boxplot(x='lr_delta', y=grp, data=dfboot, palette='cubehelix_r',
sym='', whis=[3, 97], showmeans=True, notch=True, ax=ax0)
_ = ax0.axvline(0, ls='--', lw=2, c='#555555', zorder=-1)
if force_xlim is not None:
_ = ax0.set(xlim=force_xlim)
_ = sns.countplot(y=grp, data=df, ax=ax1, palette='cubehelix_r')
ct = df.groupby(grp).size().tolist()
_ = [ax1.annotate(f'{v}', xy=(v, i%len(ct)), **count_txt_h_kws) for i, v in enumerate(ct)]
ypos = 1.02
if title_add != '':
ypos = 1.05
title_add = f'\n{title_add}'
title = (f'2-sample bootstrap test - grouped by {grp}')
_ = f.suptitle(f'{title}{title_add}', y=ypos)
f.tight_layout() # prefer over constrained_layout
return gs
|
1d9d25604392433bc9cc10d645f0a8f2122a2a38
| 17,882 |
from typing import Tuple
from typing import Optional
from typing import Dict
from typing import Any
def inception_inspired_reservoir_model(
input_shape: Tuple[int, int, int],
reservoir_weight: np.ndarray,
num_output_channels: int,
seed: Optional[int] = None,
num_filters: int = 32,
reservoir_base: str = 'DenseReservoir',
reservoir_params: Optional[Dict[str, Any]] = None,
final_activation: Optional[str] = 'sigmoid',
task: str = 'segmentation',
) -> tf.keras.Model:
"""Builds a simple recurrent reservoir model with inception-style head.
The model is an SRN in the sense that a copy of the output of a first
reservoir is passed through a set of trainable weights and then through
a second identical reservoir.
Args:
input_shape: (image_height, image_width, num_channels) of the input image.
reservoir_weight: Weight matrix to be assigned to the fixed layers.
num_output_channels: how many output channels to use.
seed: int seed to use to get a deterministic set of "random" weights.
num_filters: how many filters to include in each layer of the inception
block.
reservoir_base: the reservoir base to use. Default is 'DenseReservoir'.
reservoir_params: the parameters to initialize the reservoir_base. (Any
field provided MUST be a Correct argument for the reservoir base,
e.g. common options include {
'recurrence_degree': 3,
'keep_memory': True,
'trainable_reservoir': True,
'use_bias': True,
'activation_within_recurrence': True,
'kernel_local_learning': 'hebbian',
'kernel_local_learning_params': {'eta': 0.1},
'recurrent_kernel_local_learning': 'hebbian',
'recurrent_kernel_local_learning_params': {'eta': 0.1},
'state_discount': 1.0,
}. If variable not included in the params, the default values are used.)
final_activation: 'sigmoid', 'softmax', 'tanh', or None.
task: which task this model is used for (options includes: 'segmentation',
'classification')
Returns:
A simple recurrent reservoir model with convolutional head
Raises:
ValueError: if task not in accepted tasks (segmentation, classification).
"""
if task not in ['segmentation', 'classification']:
raise ValueError(
f'Task not defined in accepted tasks (segmentation, classification). Got {task}'
)
# Create a sequential keras model
if reservoir_params is None:
reservoir_params = {}
reservoir_params['weight'] = reservoir_weight
inputs = tf.keras.layers.Input(input_shape)
if seed:
kernel_initializer = initializers.FixedRandomInitializer(seed=seed)
else:
kernel_initializer = tf.keras.initializers.RandomNormal()
# Inception 'stem'
x = tf.keras.layers.Conv2D(
num_filters, 8, padding='same', input_shape=input_shape,
activation='elu')(
inputs)
x = tf.keras.layers.MaxPooling2D(
pool_size=(3, 3), strides=(1, 1), padding='same')(
x)
x = tf.keras.layers.Conv2D(
num_filters, 1, activation='elu', padding='same')(
x)
x = tf.keras.layers.Conv2D(
num_filters, 3, activation='elu', padding='same')(
x)
x = tf.keras.layers.MaxPooling2D(
pool_size=(3, 3), strides=(1, 1), padding='same')(
x)
x = tf.keras.layers.Conv2D(
num_filters, 1, activation='elu', padding='same')(
x)
x = tf.keras.layers.Conv2D(
num_filters, 3, activation='elu', padding='same')(
x)
# Inception block
incepta = tf.keras.layers.Conv2D(
num_filters, [1, 1], strides=(1, 1), activation='elu', padding='same')(
x)
incepta = tf.keras.layers.Conv2D(
num_filters, [5, 5], strides=(1, 1), activation='elu', padding='same')(
incepta)
inceptb = tf.keras.layers.Conv2D(
num_filters, [1, 1], strides=(1, 1), activation='elu', padding='same')(
x)
inceptb = tf.keras.layers.Conv2D(
num_filters, [3, 3], strides=(1, 1), activation='elu', padding='same')(
inceptb)
inceptc = tf.keras.layers.MaxPooling2D(
pool_size=(3, 3), strides=(1, 1), padding='same')(
x)
inceptc = tf.keras.layers.Conv2D(
num_filters, [1, 1], strides=(1, 1), activation='elu', padding='same')(
inceptc)
inceptd = tf.keras.layers.Conv2D(
num_filters, [1, 1], strides=(1, 1), activation='elu', padding='same')(
x)
y = tf.concat([incepta, inceptb, inceptc, inceptd], -1)
# Dense layer
y = tf.keras.layers.Dense(reservoir_weight.shape[0], activation='elu')(y)
# The first reservoir layer
y = reservoir_registry.get_reservoir(reservoir_base)(**reservoir_params)(y)
# Trainable layer in between reservoirs
y = tf.keras.layers.Dense(reservoir_weight.shape[0], activation='elu')(y)
# The second fixed reservoir layer
y = reservoir_registry.get_reservoir(reservoir_base)(**reservoir_params)(y)
# Create outputs.
if task == 'classification':
y = tf.keras.layers.Flatten()(y)
outputs = tf.keras.layers.Dense(
units=num_output_channels,
activation=final_activation,
kernel_initializer=kernel_initializer)(
y)
model = tf.keras.models.Model(inputs, outputs)
return model
|
221c0c17035d44178ca460c011c92d37f26b4ed4
| 17,883 |
def midnight(date):
"""Returns a copy of a date with the hour, minute, second, and
millisecond fields set to zero.
Args:
date (Date): The starting date.
Returns:
Date: A new date, set to midnight of the day provided.
"""
return date.replace(hour=0, minute=0, second=0, microsecond=0)
|
b92086dd9d99a4cea6657d37f40e68696ad41f7c
| 17,884 |
import aiohttp
import os
async def api_call(method, data=None):
"""Slack API call."""
with aiohttp.ClientSession() as session:
token = os.environ.get('TOKEN')
if not token.startswith('xoxb-'):
return 'Define the token please'
form = aiohttp.FormData(data or {})
form.add_field('token', token)
async with session.post('https://slack.com/api/{0}'.format(method),data=form) as response:
assert 200 == response.status, ('{0} with {1} failed.'.format(method, data))
return await response.json()
|
1b7809c4138fc31bead83e6e94a23904fbaf87d7
| 17,885 |
from typing import Callable
from typing import Any
from typing import Sequence
def foldr(fun: Callable[[Any, Any], Any], acc: Any, seq: Sequence[Any]) -> Any:
"""Implementation of foldr in Python3.
This is an implementation of the right-handed
fold function from functional programming.
If the list is empty, we return the accumulator
value. Otherwise, we recurse by applying the
function which was passed to the foldr to
the head of the iterable collection
and the foldr called with fun, acc, and
the tail of the iterable collection.
Below are the implementations of the len
and sum functions using foldr to
demonstrate how foldr function works.
>>> foldr((lambda _, y: y + 1), 0, [0, 1, 2, 3, 4])
5
>>> foldr((lambda x, y: x + y), 0, [0, 1, 2, 3, 4])
10
foldr takes the second argument and the
last item of the list and applies the function,
then it takes the penultimate item from the end
and the result, and so on.
"""
return acc if not seq else fun(seq[0], foldr(fun, acc, seq[1:]))
|
5648d8ce8a2807270163ebcddad3f523f527986e
| 17,886 |
def tj_dom_dem(x):
"""
Real Name: b'Tj Dom Dem'
Original Eqn: b'( [(1,0.08)-(365,0.09)],(1,0.08333),(2,0.08333),(3,0.08333),(4,0.08333),(5,0.08333),(6\\\\ ,0.08333),(7,0.08333),(8,0.08333),(9,0.08333),(10,0.08333),(11,0.08333),(12,0.08333\\\\ ),(13,0.08333),(14,0.08333),(15,0.08333),(16,0.08333),(17,0.08333),(18,0.08333),(19\\\\ ,0.08333),(20,0.08333),(21,0.08333),(22,0.08333),(23,0.08333),(24,0.08333),(25,0.08333\\\\ ),(26,0.08333),(27,0.08333),(28,0.08333),(29,0.08333),(30,0.08333),(31,0.08333),(32\\\\ ,0.08333),(33,0.08333),(34,0.08333),(35,0.08333),(36,0.08333),(37,0.08333),(38,0.08333\\\\ ),(39,0.08333),(40,0.08333),(41,0.08333),(42,0.08333),(43,0.08333),(44,0.08333),(45\\\\ ,0.08333),(46,0.08333),(47,0.08333),(48,0.08333),(49,0.08333),(50,0.08333),(51,0.08333\\\\ ),(52,0.08333),(53,0.08333),(54,0.08333),(55,0.08333),(56,0.08333),(57,0.08333),(58\\\\ ,0.08333),(59,0.08333),(60,0.08333),(61,0.08333),(62,0.08333),(63,0.08333),(64,0.08333\\\\ ),(65,0.08333),(66,0.08333),(67,0.08333),(68,0.08333),(69,0.08333),(70,0.08333),(71\\\\ ,0.08333),(72,0.08333),(73,0.08333),(74,0.08333),(75,0.08333),(76,0.08333),(77,0.08333\\\\ ),(78,0.08333),(79,0.08333),(80,0.08333),(81,0.08333),(82,0.08333),(83,0.08333),(84\\\\ ,0.08333),(85,0.08333),(86,0.08333),(87,0.08333),(88,0.08333),(89,0.08333),(90,0.08333\\\\ ),(91,0.08333),(92,0.08333),(93,0.08333),(94,0.08333),(95,0.08333),(96,0.08333),(97\\\\ ,0.08333),(98,0.08333),(99,0.08333),(100,0.08333),(101,0.08333),(102,0.08333),(103,\\\\ 0.08333),(104,0.08333),(105,0.08333),(106,0.08333),(107,0.08333),(108,0.08333),(109\\\\ ,0.08333),(110,0.08333),(111,0.08333),(112,0.08333),(113,0.08333),(114,0.08333),(115\\\\ ,0.08333),(116,0.08333),(117,0.08333),(118,0.08333),(119,0.08333),(120,0.08333),(121\\\\ ,0.08333),(122,0.08333),(123,0.08333),(124,0.08333),(125,0.08333),(126,0.08333),(127\\\\ ,0.08333),(128,0.08333),(129,0.08333),(130,0.08333),(131,0.08333),(132,0.08333),(133\\\\ ,0.08333),(134,0.08333),(135,0.08333),(136,0.08333),(137,0.08333),(138,0.08333),(139\\\\ ,0.08333),(140,0.08333),(141,0.08333),(142,0.08333),(143,0.08333),(144,0.08333),(145\\\\ ,0.08333),(146,0.08333),(147,0.08333),(148,0.08333),(149,0.08333),(150,0.08333),(151\\\\ ,0.08333),(152,0.08333),(153,0.08333),(154,0.08333),(155,0.08333),(156,0.08333),(157\\\\ ,0.08333),(158,0.08333),(159,0.08333),(160,0.08333),(161,0.08333),(162,0.08333),(163\\\\ ,0.08333),(164,0.08333),(165,0.08333),(166,0.08333),(167,0.08333),(168,0.08333),(169\\\\ ,0.08333),(170,0.08333),(171,0.08333),(172,0.08333),(173,0.08333),(174,0.08333),(175\\\\ ,0.08333),(176,0.08333),(177,0.08333),(178,0.08333),(179,0.08333),(180,0.08333),(181\\\\ ,0.08333),(182,0.08333),(183,0.08333),(184,0.08333),(185,0.08333),(186,0.08333),(187\\\\ ,0.08333),(188,0.08333),(189,0.08333),(190,0.08333),(191,0.08333),(192,0.08333),(193\\\\ ,0.08333),(194,0.08333),(195,0.08333),(196,0.08333),(197,0.08333),(198,0.08333),(199\\\\ ,0.08333),(200,0.08333),(201,0.08333),(202,0.08333),(203,0.08333),(204,0.08333),(205\\\\ ,0.08333),(206,0.08333),(207,0.08333),(208,0.08333),(209,0.08333),(210,0.08333),(211\\\\ ,0.08333),(212,0.08333),(213,0.08333),(214,0.08333),(215,0.08333),(216,0.08333),(217\\\\ ,0.08333),(218,0.08333),(219,0.08333),(220,0.08333),(221,0.08333),(222,0.08333),(223\\\\ ,0.08333),(224,0.08333),(225,0.08333),(226,0.08333),(227,0.08333),(228,0.08333),(229\\\\ ,0.08333),(230,0.08333),(231,0.08333),(232,0.08333),(233,0.08333),(234,0.08333),(235\\\\ ,0.08333),(236,0.08333),(237,0.08333),(238,0.08333),(239,0.08333),(240,0.08333),(241\\\\ ,0.08333),(242,0.08333),(243,0.08333),(244,0.08333),(245,0.08333),(246,0.08333),(247\\\\ ,0.08333),(248,0.08333),(249,0.08333),(250,0.08333),(251,0.08333),(252,0.08333),(253\\\\ ,0.08333),(254,0.08333),(255,0.08333),(256,0.08333),(257,0.08333),(258,0.08333),(259\\\\ ,0.08333),(260,0.08333),(261,0.08333),(262,0.08333),(263,0.08333),(264,0.08333),(265\\\\ ,0.08333),(266,0.08333),(267,0.08333),(268,0.08333),(269,0.08333),(270,0.08333),(271\\\\ ,0.08333),(272,0.08333),(273,0.08333),(274,0.08333),(275,0.08333),(276,0.08333),(277\\\\ ,0.08333),(278,0.08333),(279,0.08333),(280,0.08333),(281,0.08333),(282,0.08333),(283\\\\ ,0.08333),(284,0.08333),(285,0.08333),(286,0.08333),(287,0.08333),(288,0.08333),(289\\\\ ,0.08333),(290,0.08333),(291,0.08333),(292,0.08333),(293,0.08333),(294,0.08333),(295\\\\ ,0.08333),(296,0.08333),(297,0.08333),(298,0.08333),(299,0.08333),(300,0.08333),(301\\\\ ,0.08333),(302,0.08333),(303,0.08333),(304,0.08333),(305,0.08333),(306,0.08333),(307\\\\ ,0.08333),(308,0.08333),(309,0.08333),(310,0.08333),(311,0.08333),(312,0.08333),(313\\\\ ,0.08333),(314,0.08333),(315,0.08333),(316,0.08333),(317,0.08333),(318,0.08333),(319\\\\ ,0.08333),(320,0.08333),(321,0.08333),(322,0.08333),(323,0.08333),(324,0.08333),(325\\\\ ,0.08333),(326,0.08333),(327,0.08333),(328,0.08333),(329,0.08333),(330,0.08333),(331\\\\ ,0.08333),(332,0.08333),(333,0.08333),(334,0.08333),(335,0.08333),(336,0.08333),(337\\\\ ,0.08333),(338,0.08333),(339,0.08333),(340,0.08333),(341,0.08333),(342,0.08333),(343\\\\ ,0.08333),(344,0.08333),(345,0.08333),(346,0.08333),(347,0.08333),(348,0.08333),(349\\\\ ,0.08333),(350,0.08333),(351,0.08333),(352,0.08333),(353,0.08333),(354,0.08333),(355\\\\ ,0.08333),(356,0.08333),(357,0.08333),(358,0.08333),(359,0.08333),(360,0.08333),(361\\\\ ,0.08333),(362,0.08333),(363,0.08333),(364,0.08333),(365,0.08333))'
Units: b'Dmnl'
Limits: (None, None)
Type: lookup
b''
"""
return functions.lookup(x, [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293,
294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329,
330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365
], [
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333, 0.08333,
0.08333, 0.08333, 0.08333, 0.08333, 0.08333
])
|
df670af98362fd67bece677aa85bf37d31a75389
| 17,887 |
def filter_chants_without_volpiano(chants, logger=None):
"""Exclude all chants with an empty volpiano field"""
has_volpiano = chants.volpiano.isnull() == False
return chants[has_volpiano]
|
3f03bbf3f247afd3a115442e8121a773aa90fb56
| 17,888 |
def split_trainer_ops_pass(program, config, default_device="cpu"):
"""
split cpu-trainer program from origin-program
1. find heter op (located on different device)
2. find input&output of every heter-block
3. create cpu-trainer program, add send&recv op
"""
# Todo: support user define default_device (MrChengmo)
default_device_ = default_device
program, heter_ops, default_ops, program_block_ops = find_heter_ops(
program, default_device_)
program_block_ops = union_forward_gradient_op(program_block_ops)
block_vars_detail = find_block_joints(program, program_block_ops, heter_ops)
trainer_program = program.clone()
create_trainer_program(trainer_program, program, config, program_block_ops,
block_vars_detail)
return trainer_program
|
254c4d8e8ea610bf69a8611eff5a471ba57b0f88
| 17,889 |
import pathlib
import os
def get_builtin_templates_path() -> pathlib.Path:
"""Return the pathlib.Path to the package's builtin templates
:return: template pathlib.Path
"""
return pathlib.Path(
os.path.dirname(os.path.realpath(__file__))
) / 'templates'
|
4b6bfeb826aa2badb000267e12a9bb6cf19f6a28
| 17,890 |
def sample_input():
"""Return the puzzle input and expected result for the part 1
example problem.
"""
lines = split_nonblank_lines("""
position=< 9, 1> velocity=< 0, 2>
position=< 7, 0> velocity=<-1, 0>
position=< 3, -2> velocity=<-1, 1>
position=< 6, 10> velocity=<-2, -1>
position=< 2, -4> velocity=< 2, 2>
position=<-6, 10> velocity=< 2, -2>
position=< 1, 8> velocity=< 1, -1>
position=< 1, 7> velocity=< 1, 0>
position=<-3, 11> velocity=< 1, -2>
position=< 7, 6> velocity=<-1, -1>
position=<-2, 3> velocity=< 1, 0>
position=<-4, 3> velocity=< 2, 0>
position=<10, -3> velocity=<-1, 1>
position=< 5, 11> velocity=< 1, -2>
position=< 4, 7> velocity=< 0, -1>
position=< 8, -2> velocity=< 0, 1>
position=<15, 0> velocity=<-2, 0>
position=< 1, 6> velocity=< 1, 0>
position=< 8, 9> velocity=< 0, -1>
position=< 3, 3> velocity=<-1, 1>
position=< 0, 5> velocity=< 0, -1>
position=<-2, 2> velocity=< 2, 0>
position=< 5, -2> velocity=< 1, 2>
position=< 1, 4> velocity=< 2, 1>
position=<-2, 7> velocity=< 2, -2>
position=< 3, 6> velocity=<-1, -1>
position=< 5, 0> velocity=< 1, 0>
position=<-6, 0> velocity=< 2, 0>
position=< 5, 9> velocity=< 1, -2>
position=<14, 7> velocity=<-2, 0>
position=<-3, 6> velocity=< 2, -1>""")
sky_lines = split_nonblank_lines("""
......................
......................
......................
......................
......#...#..###......
......#...#...#.......
......#...#...#.......
......#####...#.......
......#...#...#.......
......#...#...#.......
......#...#...#.......
......#...#..###......
......................
......................
......................
......................""")
expected = trim_sky(sky_lines)
return lines, expected
|
e027d2831ef5d16776b5c5f7bb8e759042056e2f
| 17,891 |
def vector_angle(v):
"""Angle between v and the positive x axis.
Only works with 2-D vectors.
returns: angle in radians
"""
assert len(v) == 2
x, y = v
return np.arctan2(y, x)
|
4402795a27ca20269dbfa5a5823c4e2768681ed0
| 17,892 |
def get_user_record_tuple(param) -> ():
"""
Internal method for retrieving the user registration record from the DB.
:return:
"""
conn = mariadb.connect(host=DB_URI, user=DB_USERNAME, password=DB_PASSWORD, database=DB_NAME)
db = conn.cursor()
# discord_id provided
if isinstance(param, int):
cmd = '''SELECT last_updated, token, discord_id, discord_name, is_verified, callsign
FROM registration WHERE discord_id=%s'''
# token provided
# else:
elif isinstance(param, str):
cmd = '''SELECT last_updated, token, discord_id, discord_name, is_verified, callsign
FROM registration WHERE token=%s'''
else:
return None
db.execute(cmd, (param,))
result = db.fetchone()
return result
|
d35468b7b2141f6c19f0c5669f80c103a7499221
| 17,893 |
def A_weighting(x, Fs):
"""A-weighting filter represented as polynomial transfer function.
:returns: Tuple of `num` and `den`.
See equation E.6 of the standard.
"""
f1 = _POLE_FREQUENCIES[1]
f2 = _POLE_FREQUENCIES[2]
f3 = _POLE_FREQUENCIES[3]
f4 = _POLE_FREQUENCIES[4]
offset = _NORMALIZATION_CONSTANTS['A']
numerator = np.array([(2.0 * np.pi * f4)**2.0 * (10**(-offset / 20.0)), 0.0, 0.0, 0.0, 0.0])
part1 = [1.0, 4.0 * np.pi * f4, (2.0 * np.pi * f4)**2.0]
part2 = [1.0, 4.0 * np.pi * f1, (2.0 * np.pi * f1)**2.0]
part3 = [1.0, 2.0 * np.pi * f3]
part4 = [1.0, 2.0 * np.pi * f2]
denomenator = np.convolve(np.convolve(np.convolve(part1, part2), part3), part4)
B, A = bilinear(numerator, denomenator, Fs)
return lfilter(B, A, x)
|
a4592939d3809da292c4f05f47ca69e41ad9d27a
| 17,894 |
import inspect
def register(class_=None, **kwargs):
"""Registers a dataset with segment specific hyperparameters.
When passing keyword arguments to `register`, they are checked to be valid
keyword arguments for the registered Dataset class constructor and are
saved in the registry. Registered keyword arguments can be retrieved with
the `list_datasets` function.
All arguments that result in creation of separate datasets should be
registered. Examples are datasets divided in different segments or
categories, or datasets containing multiple languages.
Once registered, an instance can be created by calling
:func:`~gluonnlp.data.create` with the class name.
Parameters
----------
**kwargs : list or tuple of allowed argument values
For each keyword argument, it's value must be a list or tuple of the
allowed argument values.
Examples
--------
>>> @gluonnlp.data.register(segment=['train', 'test', 'dev'])
... class MyDataset(gluon.data.Dataset):
... def __init__(self, segment='train'):
... pass
>>> my_dataset = gluonnlp.data.create('MyDataset')
>>> print(type(my_dataset))
<class 'MyDataset'>
"""
def _real_register(class_):
# Assert that the passed kwargs are meaningful
for kwarg_name, values in kwargs.items():
try:
real_args = inspect.getfullargspec(class_).args
except AttributeError:
# pylint: disable=deprecated-method
real_args = inspect.getargspec(class_.__init__).args
if not kwarg_name in real_args:
raise RuntimeError(
('{} is not a valid argument for {}. '
'Only valid arguments can be registered.').format(
kwarg_name, class_.__name__))
if not isinstance(values, (list, tuple)):
raise RuntimeError(('{} should be a list of '
'valid arguments for {}. ').format(
values, kwarg_name))
# Save the kwargs associated with this class_
_REGSITRY_NAME_KWARGS[class_] = kwargs
register_ = registry.get_register_func(Dataset, 'dataset')
return register_(class_)
if class_ is not None:
# Decorator was called without arguments
return _real_register(class_)
return _real_register
|
f1ce9a7abc8224fcd4bd80cddbf0d46e11ee997a
| 17,895 |
import random
def random_population(pop_size, tune_params, tuning_options, max_threads):
"""create a random population of pop_size unique members"""
population = []
option_space = np.prod([len(v) for v in tune_params.values()])
assert pop_size < option_space
while len(population) < pop_size:
dna = [random.choice(v) for v in tune_params.values()]
if not dna in population and util.config_valid(dna, tuning_options, max_threads):
population.append(dna)
return population
|
b5f2fa518e29bdd6ccb5d10213080f9c594f01b0
| 17,896 |
def check_genome(genome):
"""Check if genome is a valid FASTA file or genomepy genome genome.
Parameters
----------
genome : str
Genome name or file to check.
Returns
-------
is_genome : bool
"""
try:
Genome(genome)
return True
except Exception:
pass
return False
|
5f51d74203b77f39b0c8054d36fa6b68399540dd
| 17,897 |
def extract_row_loaded():
"""extract_row as it should appear in memory"""
result = {}
result['classification_id'] = '91178981'
result['user_name'] = 'MikeWalmsley'
result['user_id'] = '290475'
result['user_ip'] = '2c61707e96c97a759840'
result['workflow_id'] = '6122'
result['workflow_name'] = 'DECaLS DR5'
result['workflow_version'] = '28.30'
result['created_at'] = '2018-02-20 10:44:42 UTC'
result['gold_standard'] = ''
result['expert'] = ''
result['metadata'] = {
'session': 'e69d40c94873e2e4e2868226d5567e0e997bf58e8800eef4def679ff3e69f97f',
'viewport': {
'width': 1081,
'height': 1049
},
'started_at':'2018-02-20T10:41:13.381Z',
'user_agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:58.0) Gecko/20100101 Firefox/58.0',
'utc_offset': '0',
'finished_at': '2018-02-20T10:44:42.480Z',
'live_project': True,
'user_language': 'en',
'user_group_ids':[],
'subject_dimensions': [{
'clientWidth': 424,
'clientHeight': 424,
'naturalWidth': 424,
'naturalHeight': 424
}]}
result['annotations'] = [
{
'task': 'T0',
'task_label': 'Is the galaxy simply smooth and rounded, with no sign of a disk?',
'value':' Features or Disk'
},
{
'task': 'T2',
'task_label': 'Could this be a disk viewed edge-on?',
'value':' No'
},
{
'task': 'T4',
'task_label': 'Is there a bar feature through the centre of the galaxy?',
'value': 'No Bar'
},
{
'task': 'T5',
'task_label': 'Is there any sign of a spiral arm pattern?',
'value': 'Yes'
},
{
'task': 'T6',
'task_label': 'How tightly wound do the spiral arms appear?',
'value': ' Tight'
},
{
'task': 'T7',
'task_label':'How many spiral arms are there?',
'value':' Cant tell'
},
{
'task':'T8',
'task_label':'How prominent is the central bulge, compared with the rest of the galaxy?',
'value':' No bulge'
},
{
'task':'T11',
'task_label':'Is the galaxy currently merging, or is there any sign of tidal debris?',
'value':'Neither'
},
{
'task':'T10',
'task_label':'Do you see any of these rare features in the image?',
'value':[]
}
]
result['subject_data'] = {
'15715879': {
'retired': None,
'ra': 319.11521779916546,
'dec': -0.826509379829966,
'mag.g': 13.674222230911255,
'mag.i': 12.560198307037354,
'mag.r': 12.938228249549866,
'mag.u': 15.10558009147644,
'mag.z':12.32387661933899,
'nsa_id':189862.0,
'redshift':0.019291512668132782,
'mag.abs_r':-20.916738510131836,
'mag.faruv':16.92647397518158,
'petroflux':5388.59814453125,
'petroth50':13.936717987060547,
'mag.nearuv':16.298240423202515,
'petrotheta':28.682878494262695,
'absolute_size':11.334824080956198
}
}
result['subject_ids'] = '15715879'
return result
|
c5fd87149ab7dff6e9980a898013053ce309c259
| 17,898 |
def getb_reginsn(*args):
"""
getb_reginsn(ins) -> minsn_t
Skip assertions backward.
@param ins (C++: const minsn_t *)
"""
return _ida_hexrays.getb_reginsn(*args)
|
04f0141c0053e74981264b90b3bb0be1fbea8c08
| 17,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.