content
stringlengths 35
762k
| sha1
stringlengths 40
40
| id
int64 0
3.66M
|
|---|---|---|
def word_to_forms(word):
"""Return all possible forms for a word.
Args:
word (unicode)
Returns:
forms (set[unicode])
"""
forms = set()
lemmas = lemmatize(word)
for lemma in lemmas:
forms.update(lemma_to_forms(lemma))
return forms | eee7fee2389d180664ff6e07718461043716ba7e | 9,100 |
def load_decamCorners():
"""
Returns the CCD corners of the DECam camera.
Returns:
decamCorners : *list* of *float*
A list of the angular degree offsets of the CCD corners.
"""
with open('%s/DECam_corners.dat' % data_dir) as f:
corners_dct = eval(''.join(f.readlines()))
decamCorners = [v for v in corners_dct.values()]
return decamCorners | 5dd58af44029c87db5623dfa38a6223570836665 | 9,101 |
def reduce_expr(expr):
"""
Reduces a boolean algebraic expression based on the identity X + XY = X
Args:
expr (str): representation of the boolean algebraic expression
Returns:
A string representing the reduced algebraic expression
"""
reduced = True
for term in expr:
matches = [t for t in expr if t!=term and len(set(term).intersection(set(t))) == len(term)]
if(matches):
reduced = False
if reduced:
return expr
new_expr = []
temp_expr = expr
for term in expr:
#find the term that differs with it by at most one position
matches = [t for t in expr if t!=term and len(set(term).intersection(set(t))) == len(term)]
if(matches):
new_expr.append(term)
temp_expr.remove(term)
for match in matches:
temp_expr.remove(match)
#if such a term is found reduce it by the rule x+ xy =x
#remove both terms from the list and add to new expression
#if no term is found add the term to the next expression
expr = reduce_expr(new_expr+temp_expr)
return expr | 2c278e6ea6f133c51c5e98796f288f366fd10cb3 | 9,102 |
import tempfile
import os
import shutil
def get_mask(images, b_threshold=0) :
""" Return a mask computed from baseline image
"""
b0 = baseline(images, b_threshold)
skull_mask = medipy.segmentation.skull(b0)
skull = medipy.logic.apply_mask(b0, skull_mask, 0, 0)
directory = tempfile.mkdtemp()
medipy.io.save(skull, os.path.join(directory, "skull.nii.gz"))
bet = medipy.fsl.BET(
os.path.join(directory, "skull.nii.gz"), os.path.join(directory, "bet.nii.gz"),
intensity_threshold=0.2, create_brain_mask=True)
bet()
mask = medipy.io.load(bet.brain_mask)
shutil.rmtree(directory)
return mask | b1703aad04ebd22a63b4710a70ca1011a08fb9e7 | 9,103 |
import os
import pickle
def get_inputs():
"""
inputsdict contains {'Yte': Yte, 'Ytr': Ytr, 'Xtr': Xtr, 'Xte': Xte} where values are np.arrays
np. arrays are truncated to evenly split into batches of size = batchsize
"""
with open(os.path.join(dpath, dfile), 'rb') as f:
d_all = pickle.load(f)
return d_all | e96e64104fd5138a03ea15f6cbf3ecaf22e1f9e4 | 9,104 |
import json
def _apply(input_bundle_name, output_bundle_name, pipeline_class_name, pipeline_args,
input_tags, output_tags, output_bundle_uuid=None, force=False):
"""Apply a pipeline to an input bundle, and save the results in an
output bundle.
Args:
input_bundle_name: The human name of the input bundle
output_bundle_name: The human name of the output bundle
pipeline_class_name: Name of the pipeline class to run
pipeline_args: Optional arguments to pass to the pipeline class
pipeline_args: list
input_tags: Set of tags to find input bundle
output_tags: Set of tags to give the output bundle
output_bundle_uuid: A UUID specifying the version to save within
the output bundle; default `None`
force: If `True` force recomputation of all upstream pipe requirements
"""
_logger.debug("Applying '{}' to '{}' to get '{}'".format(pipeline_class_name, input_bundle_name, output_bundle_name))
apply_kwargs = {
'input_bundle': input_bundle_name,
'output_bundle': output_bundle_name,
'output_bundle_uuid': output_bundle_uuid,
'pipe_params': json.dumps(disdat.common.parse_params(pipeline_args)),
'pipe_cls': pipeline_class_name,
'input_tags': input_tags,
'output_tags': output_tags,
'force': force
}
p = Process(target=disdat.apply.apply, kwargs=apply_kwargs)
p.start()
p.join()
return p.exitcode == 0 | 811fc5b8da5a882508ea14c808f3989330e448df | 9,105 |
def arcColor(renderer, x, y, rad, start, end, color):
"""Draws an arc to the renderer with a given color.
The start and end of the arc are defined in units of degrees, with 0 being
the bottom of the arc circle and increasing counter-clockwise (e.g. 90 being
the rightmost point of the circle).
If the rendering color has any transparency, blending will be enabled.
Args:
renderer (:obj:`SDL_Renderer`): The renderer to draw on.
x (int): The X coordinate of the center of the circle.
y (int): The Y coordinate of the center of the circle.
rad (int): The radius (in pixels) of the circle.
start (int): The start of the arc (in degrees).
end (int): The end of the arc (in degrees).
color (int): The color to draw with as a 32-bit ``0xRRGGBBAA`` integer
(e.g. ``0xFF0000FF`` for solid red).
Returns:
int: 0 on success, or -1 on failure.
"""
return _funcs["arcColor"](renderer, x, y, rad, start, end, color) | 3297a32236afe2881979b105992df17742dd06c3 | 9,106 |
def dos_element_spd(
folder,
element_spd_dict,
output='dos_element_spd.png',
fill=True,
alpha=0.3,
linewidth=1.5,
sigma=0.05,
energyaxis='x',
color_list=None,
legend=True,
total=True,
figsize=(4, 3),
erange=[-6, 6],
spin='up',
combination_method='add',
fontsize=7,
save=True,
):
"""
This function plots the element projected density of states of the s, p, and d orbitals.
Parameters:
folder (str): This is the folder that contains the VASP files
element_spd_dict (dict[str:str]): A dictionary that contains the individual atoms and the corresponding
orbitals to project onto. For example, if the user wants to project onto the s, p, d orbitals
of In and the p orbitals of As for an InAs structure then the dictionary would be {'In':'spd', 'As':'p'}
output (str): File name of the resulting plot.
fill (bool): Determines wether or not to fill underneath the plot
alpha (float): Alpha value for the fill
linewidth (float): Linewidth of lines
sigma (float): Standard deviation for gaussian filter
energyaxis (str): Determines the axis to plot the energy on ('x' or 'y')
color_list (list): List of colors that is the same length as the number of projections
in the plot.
legend (bool): Determines whether to draw the legend or not
total (bool): Determines wheth to draw the total density of states or not
spin (str): Which spin direction to parse ('up' or 'down')
figsize (list / tuple): Desired size of the image in inches (width, height)
erange (list): Energy range for the DOS plot ([lower bound, upper bound])
combination_method (str): If spin == 'both', this determines if the spin up and spin down
desnities are added or subtracted. ('add' or 'sub')
fontsize (float): Font size of the text in the figure.
save (bool): Determines whether to automatically save the figure or not. If not
the figure and axis are return for further manipulation.
Returns:
If save == True, this function will return nothing and directly save the image as
the output name. If save == False, the function will return the matplotlib figure
and axis for further editing.
"""
dos = Dos(folder=folder, spin=spin, combination_method=combination_method)
fig = plt.figure(figsize=figsize, dpi=400)
ax = fig.add_subplot(111)
_figure_setup_dos(ax=ax, fontsize=fontsize, energyaxis=energyaxis)
dos.plot_element_spd(
ax=ax,
element_spd_dict=element_spd_dict,
fill=fill,
alpha=alpha,
linewidth=linewidth,
sigma=sigma,
energyaxis=energyaxis,
color_list=color_list,
legend=legend,
total=total,
erange=erange,
)
plt.tight_layout(pad=0.2)
if save:
plt.savefig(output)
else:
return fig, ax | bf20cee25ace85e91a32f3b05016b0cd34f20600 | 9,107 |
import yaml
def load(m, schema=UPLOAD_MANIFEST_SCHEMA):
""" Load and validate a manifest.
"""
manifest = yaml.load(m)
validate(
manifest, schema=schema,
)
return manifest | 2bdbaf856a476b14b7ca0a353c4cdd56b3de2ae0 | 9,108 |
def transform_phenotype(inv_root, y, fam_indices, null_mean = None):
"""
Transform phenotype based on inverse square root of phenotypic covariance matrix.
If the null model included covariates, the fitted mean is removed rather than the overall mean
"""
# Mean normalise phenotype
if null_mean is None:
y = y - np.mean(y)
else:
y = y - null_mean
# Transform by family
for fam in fam_indices.keys():
famsize = fam_indices[fam].shape[0]
if famsize == 1:
y[fam_indices[fam]] = inv_root[1] * y[fam_indices[fam]]
else:
y[fam_indices[fam]] = inv_root[famsize].dot(y[fam_indices[fam]])
return y | d16699bb04a578050608910a9eea0ee6ea0b450d | 9,109 |
import json
import requests
def download_site_build(event_file: str, download_path: str = "build-site.tar.gz") -> int:
"""Will download the site bulid if this is a forked PR bulid.
Args:
event_file (str): event file from the workflow
Returns:
int: PR num of the build if relevant
"""
with open(event_file, 'r') as f:
github_event = json.load(f)
target_url = github_event['target_url']
print(f'target_url: {target_url}')
# target_url is of the form:
# https://circleci.com/gh/demisto/content-docs/142?utm_campaign=vcs-integration-link&utm_medium=referral&utm_source=github-build-li
target_url = target_url.split('?')[0]
build_num = target_url.split('/')[-1]
print(f'circleci build: {build_num}')
circle_url = f'https://circleci.com/api/v1.1/project/github/demisto/content-docs/{build_num}'
print(f'Checking circleci url: {circle_url}')
res = requests.get(circle_url, verify=VERIFY_SSL)
res.raise_for_status()
build_json = res.json()
# check that this is a pull request
if not build_json.get('pull_requests') or not build_json.get('pull_requests')[0].get('url'):
print('Not a pull request. Skipping')
return 0
branch = build_json.get('branch')
if not branch or not branch.startswith('pull/'):
print(f'Skipping branch as it is not an external pull: {branch}')
return 0
pr_num = branch.split('/')[1]
# get artifacts
res = requests.get(f'{circle_url}/artifacts', verify=VERIFY_SSL)
res.raise_for_status()
artifacts = res.json()
download_url = None
for art in artifacts:
if 'build-site.tar.gz' in art.get('path'):
download_url = art.get('url')
break
if not download_url:
raise ValueError(f"download url missing for artifacts: {artifacts}")
print(f'Downloading build artifact from: {download_url} (pr num: {pr_num}) to: {download_path} ...')
download_file(download_url, download_path)
return int(pr_num) | 62250aa4a420a11745b76e41cffd111c7d675a3a | 9,110 |
def createVskDataDict(labels,data):
"""Creates a dictionary of vsk file values from labels and data.
Parameters
----------
labels : array
List of label names for vsk file values.
data : array
List of subject measurement values corresponding to the label
names in `labels`.
Returns
-------
vsk : dict
Dictionary of vsk file values. Dictionary keys correspond to
names in `labels` and dictionary values correspond to values in
`data`.
Examples
--------
This example tests for dictionary equality through python instead of
doctest since python does not guarantee the order in which dictionary
elements are printed.
>>> labels = ['MeanLegLength', 'LeftKneeWidth', 'RightAnkleWidth']
>>> data = [940.0, 105.0, 70.0]
>>> res = createVskDataDict(labels, data)
>>> res == {'MeanLegLength':940.0, 'LeftKneeWidth':105.0, 'RightAnkleWidth':70.0}
True
"""
vsk={}
for key,data in zip(labels,data):
vsk[key]=data
return vsk | a4669e4a173aaeef534d13faceaeab869eb62cb3 | 9,111 |
def window_partition(x, window_size):
"""
Args:
x: (B, H, W, C)
window_size (int): window size
Returns:
windows: (num_windows*B, window_size, window_size, C)
"""
B, H, W, L, C = x.shape
#print(x.shape)
#print(window_size[0])
x = x.view(B, H // window_size[0], window_size[0], W // window_size[1], window_size[1], L // window_size[2], window_size[2], C)
windows = x.permute(0, 1, 3, 5, 2, 4, 6, 7).contiguous().view(-1, window_size[0], window_size[1], window_size[2], C)
return windows | cfc97230e044f9d3a8fdfa7dde4b17a43f351169 | 9,112 |
def _get_unique(node_list, key, mode=None):
"""
Returns number or names of unique nodes in a list.
:param node_list: List of dictionaries returned by Neo4j transactions.
:param key: Key accessing specific node in dictionary.
:param mode: If 'num', the number of unique nodes is returned.
:return: Unique nodes (list of nodes) or node number
"""
unique_samples = list()
if node_list:
# it is possible that nodes do not yet exist
for item in node_list:
unique_samples.append(item[key].get('name'))
unique_samples = set(unique_samples)
if mode == 'num':
unique_samples = len(unique_samples)
return unique_samples | 8f639dfce0efe9f7d40f2bba5f2b8757706cd6d7 | 9,113 |
def calculate_cpufreq_weighted_time_in_state(
final_time_in_cpufreq_state_by_cpu, time_in_cpufreq_state_by_cpu):
"""Calculate the weighted average in each CPU frequency state.
Args:
final_time_in_cpufreq_state_by_cpu: Final time in each CPU frequency
state. See the return value of parse_cpufreq_stats_time_in_state() for
the format.
time_in_cpufreq_state_by_cpu: Initial time in each CPU frequency
state. See the return value of parse_cpufreq_stats_time_in_state() for
the format.
Returns:
(weighted_time_in_cpufreq_state, weighted_average_cpufreq) tuple where
weighted_time_in_cpufreq_state is a dictionary that contains the
fractional time (0..1) in each CPU frequency state keyed by CPU number and
weighted_average_cpufreq is a dictionary containing the overall weighted
average CPU frequency keyed by CPU number.
"""
weighted_average_cpufreq = dict([(c, 0.0)
for c in time_in_cpufreq_state_by_cpu])
weighted_time_in_cpufreq_state_by_cpu = {}
for cpu, time_in_cpufreq_state in time_in_cpufreq_state_by_cpu.iteritems():
final_time_in_cpufreq_state = final_time_in_cpufreq_state_by_cpu[cpu]
weighted_time_in_cpufreq_state = {}
delta_time_in_cpufreq_state = {}
total_time = 0.0
for freq in time_in_cpufreq_state:
delta_time_in_cpufreq_state[freq] = (
final_time_in_cpufreq_state.get(freq, 0) -
time_in_cpufreq_state.get(freq, 0))
total_time += delta_time_in_cpufreq_state[freq]
for freq, cpu_time in delta_time_in_cpufreq_state.iteritems():
weight = float(cpu_time) / total_time
weighted_time_in_cpufreq_state[freq] = weight
weighted_average_cpufreq[cpu] += freq * weight
weighted_time_in_cpufreq_state_by_cpu[cpu] = weighted_time_in_cpufreq_state
return (weighted_time_in_cpufreq_state_by_cpu, weighted_average_cpufreq) | 8f8f3646bbfef89c1d2c3f65d6b3a56b76fb19e4 | 9,114 |
from PIL import Image
def array2imgdata_pil(A, format='PNG'):
"""get png data from array via converting to PIL Image"""
if A.shape[2] == 3:
mode = 'RGB'
elif A.shape[2] == 4:
mode = 'RGBA'
else:
mode = 'L'
img = Image.fromstring(mode, A.shape[:2], A.tostring())
return pil2imgdata(img, format) | f206dc6eaefec2065c10c02b0ecafa5662f9d21c | 9,115 |
def h_eval(data):
"""
Function takes dictionary
Evaluate values and convert string to correct type (boolean/int/float/long/string)
"""
if isinstance(data, dict):
for _k in list(data.keys()):
data[_k] = h_eval(data[_k])
if data[_k] is None or (isinstance(data[_k], dict) and not data[_k]):
data.pop(_k)
return data
if isinstance(data, list) or isinstance(data, tuple) or isinstance(data, set):
res = []
for _k in data:
res.append(h_eval(_k))
if isinstance(data, tuple):
return tuple(res)
if isinstance(data, set):
return set(res)
return res
try:
if isinstance(data, str):
if data.endswith("%"):
data = data[:-1]
if data.lower() == "false":
return False
if data.lower() == "true":
return True
if data.lower() == "n/e":
return None
try:
return int(data)
except Exception:
pass
try:
return float(data)
except Exception:
pass
return data
except Exception:
return data | 28a3529283719cab321c712a9e8723d5ff314ef8 | 9,116 |
def _recursive_simplify(expr):
""" Simplify the expression as much as possible based on
domain knowledge. """
input_expr = expr
# Simplify even further, based on domain knowledge:
# windowses = ('WIN32', 'WINRT')
apples = ("MACOS", "UIKIT", "IOS", "TVOS", "WATCHOS")
bsds = ("FREEBSD", "OPENBSD", "NETBSD")
androids = ("ANDROID", "ANDROID_EMBEDDED")
unixes = (
"APPLE",
*apples,
"BSD",
*bsds,
"LINUX",
*androids,
"HAIKU",
"INTEGRITY",
"VXWORKS",
"QNX",
"WASM",
)
unix_expr = simplify_logic("UNIX")
win_expr = simplify_logic("WIN32")
false_expr = simplify_logic("false")
true_expr = simplify_logic("true")
expr = expr.subs(Not(unix_expr), win_expr) # NOT UNIX -> WIN32
expr = expr.subs(Not(win_expr), unix_expr) # NOT WIN32 -> UNIX
# UNIX [OR foo ]OR WIN32 -> ON [OR foo]
expr = _simplify_expressions(expr, Or, (unix_expr, win_expr), true_expr)
# UNIX [AND foo ]AND WIN32 -> OFF [AND foo]
expr = _simplify_expressions(expr, And, (unix_expr, win_expr), false_expr)
expr = _simplify_flavors_in_condition("WIN32", ("WINRT",), expr)
expr = _simplify_flavors_in_condition("APPLE", apples, expr)
expr = _simplify_flavors_in_condition("BSD", bsds, expr)
expr = _simplify_flavors_in_condition("UNIX", unixes, expr)
expr = _simplify_flavors_in_condition("ANDROID", ("ANDROID_EMBEDDED",), expr)
# Simplify families of OSes against other families:
expr = _simplify_os_families(expr, ("WIN32", "WINRT"), unixes)
expr = _simplify_os_families(expr, androids, unixes)
expr = _simplify_os_families(expr, ("BSD", *bsds), unixes)
for family in ("HAIKU", "QNX", "INTEGRITY", "LINUX", "VXWORKS"):
expr = _simplify_os_families(expr, (family,), unixes)
# Now simplify further:
expr = simplify_logic(expr)
while expr != input_expr:
input_expr = expr
expr = _recursive_simplify(expr)
return expr | 40b9dcc6d0a5b176f36ed2e01fc35a005c3c851f | 9,117 |
import uuid
def dropzone(url, **kwargs):
"""Dropzone component
A basic dropzone component that supports drag and drop uploading
of files which are posted to the URL provided.
>>> zoom.system.site = zoom.sites.Site()
>>> zoom.system.site.packages = {}
>>> zoom.system.request = zoom.utils.Bunch(app=zoom.utils.Bunch(name='hello', packages={}))
>>> c = dropzone('/app/files')
>>> isinstance(c, zoom.Component)
True
"""
zoom.requires('dropzone')
id = 'dropzone_' + uuid.uuid4().hex
js = """
var %(id)s = new Dropzone("#%(id)s", {url: "%(url)s"});
""" % dict(id=id, url=url)
html = div(classed='dropzone', id=id, **kwargs)
return zoom.Component(html) | d8626b158b8adb738a4f74f6009da93043365cc4 | 9,118 |
import math
def fmt_bytes(size_bytes):
"""Return a nice 'total_size' string with Gb, Mb, Kb, and Byte ranges"""
units = ["Bytes", "KB", "MB", "GB"]
if size_bytes == 0:
return f"{0} Bytes"
for unit in units:
digits = int(math.log10(size_bytes)) + 1
if digits < 4:
return f"{round(size_bytes, 1)} {unit}"
size_bytes /= 1024
return f"{size_bytes} TB" | 40613403092bdc9d8dca8b0b487d5af6c887b075 | 9,119 |
from datetime import datetime
def julianDays(year, month, day, hour, minute):
"""
Calculate the julian day (day of year) based on the known date/time
information.
:param year: :class:`numpy.ndarray` of the year of all observations.
:param month: As for year, but for the month of observation.
:param day: As for year, but for the day of observation.
:param hour: As for year, but for the hour of the observation.
:param minute: As for year, but for the hour of the observation.
:returns: :class:`numpy.ndarray` of julian day values for each
observation.
"""
LOG.debug("Calculating julian day (day of year) values")
if np.any(year < 0):
raise ValueError("Error in input year information - check input file")
if np.any(month >= 13):
raise ValueError("Error in input month information - check input file")
if np.any(day > 31):
raise ValueError("Error in input day information - check input file")
if np.any(hour > 24):
raise ValueError("Error in input hour information - check input file")
if np.any(minute > 60):
raise ValueError(
"Error in input minute information - check input file")
# set all years prior to 1900 to 1904 - strftime() requires year >=1900;
# and in the Gregorian calendar, 1900 is not a leap year (and there are
# many years prior to 1900 that are!).
second = np.zeros((hour.size), 'i')
jyear = np.copy(year)
jyear[np.where(jyear < 1900)] = 1904
day = [datetime(jyear[i], month[i], day[i], hour[i], minute[i],
second[i]) for i in xrange(year.size)]
jdays = np.array([int(day[i].strftime("%j")) for
i in xrange(year.size)])
return jdays | 5a00e840717dc08d4caeb71ec018f7d7d84fd1f7 | 9,120 |
from typing import Union
import warnings
def get_valid_split(records: dict, train_val_test: Union[list, np.ndarray]) -> dict:
""" Gets a train, val, test split with at least one instance of every class
Keep doing train_test_split until each split of the data has at least one single example of every behavior
in the dataset. it would be bad if your train data had class counts: [1000, 0, 0, 10] and your test data had
class counts: [500, 100, 300, 0]
Parameters
----------
records: dict of dicts
See train_val_test_split
train_val_test: list, np.ndarray
See train_val_test_split
Returns
-------
split_dict: dict
See train_val_test_split
"""
is_wrong = True
split_dict = None
while is_wrong:
split_dict = train_val_test_split(records, train_val_test)
should_continue = do_all_classes_have_labels(records, split_dict)
if not should_continue:
warnings.warn('Not all classes in the dataset have *any* labels!')
return split_dict
is_wrong = False
for split in ['train', 'val', 'test']:
labelfiles = [records[i]['label'] for i in split_dict[split]]
if len(labelfiles) > 0:
_, class_counts, _, _, _ = read_all_labels(labelfiles)
if not np.all(class_counts > 0):
is_wrong = True
return split_dict | ce575ba0937e32b527e5d70de9855b6fa9f4a686 | 9,121 |
def _random_op(sites, ldim, hermitian=False, normalized=False, randstate=None,
dtype=np.complex_):
"""Returns a random operator of shape (ldim,ldim) * sites with local
dimension `ldim` living on `sites` sites in global form.
:param sites: Number of local sites
:param ldim: Local ldimension
:param hermitian: Return only the hermitian part (default False)
:param normalized: Normalize to Frobenius norm=1 (default False)
:param randstate: numpy.random.RandomState instance or None
:returns: numpy.ndarray of shape (ldim,ldim) * sites
>>> A = _random_op(3, 2); A.shape
(2, 2, 2, 2, 2, 2)
"""
op = _randfuncs[dtype]((ldim**sites,) * 2, randstate=randstate)
if hermitian:
op += np.transpose(op).conj()
if normalized:
op /= np.linalg.norm(op)
return op.reshape((ldim,) * 2 * sites) | 202fe112e896b14abb38a8477afa9eab7689f7f6 | 9,122 |
def minimize(system, positions, platform=None, tolerance=1.0*unit.kilocalories_per_mole/unit.angstroms, maxIterations=50):
"""Minimize the energy of the given system.
Parameters
----------
platform : simtk.openmm.Platform or None, optional
If None, the global GLOBAL_ALCHEMY_PLATFORM will be used.
tolerance : simtk.unit.Quantity with units compatible with energy/distance, optional, default = 1*kilocalories_per_mole/angstroms
Minimization tolerance
maxIterations : int, optional, default=50
Maximum number of iterations for minimization
Returns
-------
minimized_positions : simtk.openmm.Quantity with shape [nparticle,3] with units compatible with distance
The energy-minimized positions.
"""
timestep = 1.0 * unit.femtoseconds
integrator = openmm.VerletIntegrator(timestep)
context = create_context(system, integrator, platform)
context.setPositions(positions)
openmm.LocalEnergyMinimizer.minimize(context, tolerance, maxIterations)
minimized_positions = context.getState(getPositions=True).getPositions(asNumpy=True)
del context, integrator
return minimized_positions | d8dc9d1eab96c512aa72da36909490adfa8bbd6f | 9,123 |
import aiohttp
async def fetch(url="", headers=DEFAULT_HEADERS, params={}, payload={}, method="GET", loop=None):
"""fetch content from the url"""
if not url:
return
async with aiohttp.ClientSession(loop=loop, headers=headers) as session:
_method = getattr(session, method.lower())
async with _method(url, params=params, data=payload) as resp:
return await resp.json() | 9be522a373532a3452a85ec1e8aae10e7659e999 | 9,124 |
import json
def retrieve_prefix_fixture():
"""Load test fixture data."""
j = json.load(open("./tests/fixtures/s3_prefix_list.json"))
return j | 5befb33c577263976edee6546bafca40b47e25bb | 9,125 |
def parse_args(version: str) -> Namespace:
"""
Parse arguments passed to the application.
A custom argument parser handles multiple commands and options to launch
the desired function.
Parameters
----------
version : string
A ``string`` of the Bobber version.
Returns
-------
Namespace
Returns a ``Namespace`` of all of the arguments that were parsed from
the application during runtime.
"""
parser = ArgumentParser(f'Bobber Version: {version}')
parser.add_argument('--version', action='version', version=__version__)
# Required positional command subparser which should be specified first
commands = parser.add_subparsers(dest='command', metavar='command')
commands_parent = ArgumentParser(add_help=False)
# More general options which apply to a majority of the running commands
# Note that all arguments prepended with '--' are optional
commands_parent.add_argument('log_path', metavar='log-path', help='Path '
'used to store log files on the head node')
commands_parent.add_argument('hosts', help='Comma-separated list of '
'hostnames or IP addresses',
type=unique_hosts)
commands_parent.add_argument('--config-path', help='Read a JSON config '
'file with expected parameters and use those '
'values for testing. Ignores all other '
'optional flags')
commands_parent.add_argument('--gpus', help='Number of GPUs contained '
'within a system or systems under test '
'(heterogeneous counts not supported)',
type=int)
commands_parent.add_argument('--compute-gid', help='The compute gid. '
'defaults to 0 - check with "show_gids" '
'command. A non-default gid is needed for '
'Ethernet (frequently gid 3)', type=int,
default=0)
commands_parent.add_argument('--nccl-tc', help='NCCL setting required to '
'use prio3 traffic for Ethernet. Set to 106 '
'for Ethernet, and do not set for IB.',
type=int)
commands_parent.add_argument('--batch-size-sm', help='Batch size to use '
'with DALI data ingest tests for small '
'images', type=int)
commands_parent.add_argument('--batch-size-lg', help='Batch size to use '
'with DALI data ingest tests for large '
'images', type=int)
commands_parent.add_argument('--nccl-max', help='Specify the maximum data '
'size to test with NCCL, in Gigabytes '
'(default is 1 GB)', type=int)
commands_parent.add_argument('--nccl-ib-hcas', help='Specify the list of '
'interfaces to use for NCCL test multinode '
'communication', default='')
commands_parent.add_argument('--ssh-iface', help='Specify ssh interface '
'for the system(s) under test ', default='')
commands_parent.add_argument('--no-direct', help='Disable running with '
'direct IO for applications that support it',
action='store_true')
commands_parent.add_argument('--io-depth', help='Customize the IO depth '
'for direct IO testing', type=int, default=16)
commands_parent.add_argument('--bw-threads', help='Maximum number of '
'threads to use for bandwidth tests',
type=int)
commands_parent.add_argument('--125k-threads', dest='stg_125k_threads',
help='Maximum number of threads to use for '
'125K IO size tests', type=int)
commands_parent.add_argument('--iops-threads', help='Maximum number of '
'threads to use for iops tests', type=int)
commands_parent.add_argument('--read-pattern', help='Specify IO pattern '
'for fio read tests. Supported values: '
'read, randread. Defaults to read.',
default='read',
choices=READ_PATTERNS)
commands_parent.add_argument('--write-pattern', help='Specify IO pattern '
'for fio write tests. Supported values: '
'write, randwrite. Defaults to write.',
default='write',
choices=WRITE_PATTERNS)
commands_parent.add_argument('--iterations', help='Number of iterations to'
' execute per test - a seperate log file will'
' be generated for each iteration', type=int,
default=10)
commands_parent.add_argument('--sweep', help='If present, will run all '
'tests for all specified iterations from a '
'single system to the number of systems '
'specified in the --hosts flag, with a step '
'of a single system (so, 3 systems specified '
'would result in tests for 1, 2, and 3 '
'systems)', action='store_true')
commands_parent.add_argument('--system', help='If system is specified, '
'iops-threads, 125k-threads, bw-threads, '
'gpus, batch size, and network interface '
'names are given default values - override '
'by specifying the flags you\'d prefer to '
'override, ignore the flags you are ok with '
'using defaults for '
'supported systems: dgx-a100-single, '
'dgx-a100-dual, and dgx-2 for now. -single '
'is used for a system with a single storage '
'NIC, and -dual is used for a system with two'
' storage NICs', choices=SYSTEMS.keys())
commands_parent.add_argument('--stg-extra-flags', help='Experimental - '
'add extra flags to stg tests (currently '
'supported - stg-bw and stg-iops). If '
'providing more than one flag, wrap entire '
'set in quotes')
commands_parent.add_argument('--pause', help='Pause between tests for N '
'seconds to ensure any activity is finished '
'before the next test begins. Defaults to 0 '
'(no pause).', type=int, default=0)
# Create the test initiation commands with the general options above
commands.add_parser(RUN_ALL, help='Run all tests',
parents=[commands_parent])
commands.add_parser(RUN_DALI, help='Run DALI tests only',
parents=[commands_parent])
commands.add_parser(RUN_NCCL, help='Run NCCL tests only',
parents=[commands_parent])
commands.add_parser(RUN_STG_BW, help='Run storage bandwidth test only',
parents=[commands_parent])
commands.add_parser(RUN_STG_125K, help='Run storage 125 IO size test only',
parents=[commands_parent])
commands.add_parser(RUN_STG_IOPS, help='Run storage IOPS test only',
parents=[commands_parent])
commands.add_parser(RUN_STG_META, help='Run storage metadata test only',
parents=[commands_parent])
# Options specific to exporting the containers
export = commands.add_parser(EXPORT, help='Export the container for '
'multisystem tests')
# Options specific to parsing the results
parse = commands.add_parser(PARSE_RESULTS, help='Parse and display results'
'from the log files')
parse.add_argument('log_path', metavar='log-path', help='Path to saved '
'logfile location')
parse.add_argument('--json-filename', help='Specify the filename to use '
'for saving the JSON data. If not specified, the JSON '
'data will not be saved.', default=None, type=str)
parse.add_argument('--override-version-check', help='Optionally skip the '
'version check to ensure the same version of Bobber '
'was used for all tests.', action='store_true')
parse.add_argument('--compare-baseline', help='Compare the values produced'
' by a test run against a pre-defined baseline to '
'verify performance meets an acceptable threshold. '
'This command is ignored if the --custom-baseline flag '
'is used.',
choices=BASELINES)
parse.add_argument('--custom-baseline', help='Compare against a custom '
'baseline to verify performance meets an acceptable '
'threshold. This command overrides the '
'--compare-baseline flag.', type=str)
parse.add_argument('--baseline-tolerance', help='The percentage of '
'tolerance to include while comparing results against '
'a baseline. For example, if the desire is to allow '
'results to be within 5%% of the baseline and still '
'pass, enter "5" for the tolerance. This will only '
'measure tolerance below the result and will not punish'
' if numbers are higher than the baseline above the '
'tolerance level. This value is ignored if not running '
'the baseline comparison. Defaults to 0 tolerance.',
type=int, default=0)
parse.add_argument('--verbose', help='Display text-based information for '
'each system count in addition to the table.',
action='store_true')
# Options specific to building the containers
build = commands.add_parser(BUILD, help='Build the container')
# Options specific to casting the containers
cast = commands.add_parser(CAST, help='Start the container')
cast.add_argument('storage_path', metavar='storage-path', help='Path at '
'which the filesystem under test is mounted')
cast.add_argument('--ignore-gpu', help='Start the Bobber container '
'without GPUs', action='store_true')
# Options specific to loading a Docker image from a local binary
load = commands.add_parser(LOAD, help='Load a container from a local '
'binary')
load.add_argument('filename', help='Filename of local *.tar file of '
'the image to load')
return parser.parse_args() | 20cbacbb611d9495fcd6ad444b258a5588c1bddb | 9,126 |
def grid_reference_to_northing_easting(grid_reference):
"""
Needs to include reference
:param grid_reference:
:return:
"""
grid_reference = grid_reference.strip().replace(' ', '')
if len(grid_reference) == 0 or len(grid_reference) % 2 == 1 or len(grid_reference) > 12:
return None, None
grid_reference = grid_reference.upper()
if grid_reference[0] not in 'STNOH' or grid_reference[1] == 'I':
return None, None
e = n = 0
c = grid_reference[0]
if c == 'T':
e = 500000
elif c == 'N':
n = 500000
elif c == 'O':
e = 500000
n = 500000
elif c == 'H':
n = 1000000
c = ord(grid_reference[1]) - 66
if c < 8: # J
c += 1
e += (c % 5) * 100000
n += (4 - c/5) * 100000
c = grid_reference[2:]
try:
s = c[:int(len(c)/2)]
while len(s) < 5:
s += '0'
e += int(s)
s = c[int(-len(c)/2):]
while len(s) < 5:
s += '0'
n += int(s)
except Exception as error:
print("Caught exception during conversion. Issue: {}".format(error))
return None, None
# Data is converted into integers
return int(e), int(n) | 3da96e36f9be1e369d0425f2b9c34e432eb5ca77 | 9,127 |
import select
def tflite_copts_warnings():
"""Defines common warning flags used primarily by internal TFLite libraries."""
# TODO(b/155906820): Include with `tflite_copts()` after validating clients.
return select({
clean_dep("//tensorflow:windows"): [
# We run into trouble on Windows toolchains with warning flags,
# as mentioned in the comments below on each flag.
# We could be more aggressive in enabling supported warnings on each
# Windows toolchain, but we compromise with keeping BUILD files simple
# by limiting the number of config_setting's.
],
"//conditions:default": [
"-Wall",
],
}) | c65035d82801cad374db6dfb8f129ff55afff606 | 9,128 |
def sn_random_numbers(shape, antithetic=True, moment_matching=True,
fixed_seed=False):
"""Returns an ndarray object of shape with (pseudo)random numbers
that are standard normally distributed.
Parameters
----------
shape : tuple (o, n, m)
Generation of array with shape (o, n, m).
antithetic : bool, default=True
Generation of antithetic variates.
moment_matching : bool, default=True
Matching of first and second moments.
fixed_seed : bool, default=False
Flag to fix the seed.
Returns
-------
ran: numpy.ndarray
(o, n, m) array of (pseudo)random numbers.
"""
if fixed_seed:
np.random.seed(1000)
if antithetic:
ran = np.random.standard_normal(
(shape[0], shape[1], shape[2] // 2))
ran = np.concatenate((ran, -ran), axis=2)
else:
ran = np.random.standard_normal(shape)
if moment_matching:
ran = ran - np.mean(ran)
ran = ran / np.std(ran)
if shape[0] == 1:
return ran[0]
else:
return ran | ca173cf02f51a8bb6cd976fc84f42597497cd426 | 9,129 |
def blue(N: int) -> np.ndarray:
"""
Blue noise.
* N: Amount of samples.
Power increases with 6 dB per octave.
Power density increases with 3 dB per octave.
https://github.com/python-acoustics
"""
x = white(N)
X = rfft(x) / N
S = np.sqrt(np.arange(X.size)) # Filter
y = irfft(X*S).real[:N]
return normalise(y) | 80e0c449f6548b19546a4e58fa3b3e108f21d6df | 9,130 |
from typing import Dict
def _remove_attribute(note_dict: Dict, attribute: str) -> Dict:
""" Create a copy of the note where a single attribute is removed """
d = dict(note_dict)
d[attribute] = None
return d | d2659b887c1a2a7c67f6785889db2aa2039f9627 | 9,131 |
from pathlib import Path
import yaml
def get_config(path: str) -> config_schema:
"""Load the config from the path, validate and return the dcitionary
Args:
path (str): Path the config.yaml
Returns:
config_schema: The configuration dictionary
"""
config_path = Path(path)
config = yaml.full_load(open(config_path))
return Schema(config_schema).validate(config) | bf355508b52192eb78857eadedde923b623ecc56 | 9,132 |
def compare_chars(first, second):
"""
Returns the greater of the two characters
:param first:
:param second:
:return: char
"""
return chr(max(ord(first), ord(second))) | aee1e5767d6ab767bc8da27d382acc105f62d9f5 | 9,133 |
from pathlib import Path
import os
def get_file_path(filename):
"""Find filename in the relative directory `../data/` .
Args:
filename (str): file we're looking for in the ./data/ directory.
Returns:
str: absolute path to file "filename" in ./data/ dir.
"""
root_dir = Path(__file__).parent.parent
file_dir = os.path.join(str(root_dir), "data", filename)
return file_dir | 7ea5185017f89e0780f4a796ecafd4908b9753ce | 9,134 |
import typing
import argparse
def parse_arguments() -> typing.Dict[typing.Any, typing.Any]:
"""Parses command line parameters."""
argument_parser = argparse.ArgumentParser(
usage=f"Database transfer tool for Cloud Composer v.{SCRIPT_VERSION}.\n\n"
+ USAGE
+ "\n"
)
argument_parser.add_argument("operation", type=str, choices=["import", "export"])
argument_parser.add_argument("--project", type=str, required=True)
argument_parser.add_argument("--environment", type=str, required=True)
argument_parser.add_argument("--location", type=str, required=True)
argument_parser.add_argument("--fernet-key-file", type=str, required=True)
return argument_parser.parse_args() | 05a649c95042965fb1e7d12ad759423c3ca89383 | 9,135 |
import re
def find_author():
"""This returns 'The NeuroKit's development team'"""
result = re.search(
r'{}\s*=\s*[\'"]([^\'"]*)[\'"]'.format("__author__"),
open("../neurokit2/__init__.py").read(),
)
return str(result.group(1)) | bcf7fb52021cd23ef48b57aae9444676bc26a862 | 9,136 |
from ecpy.utils.util import is_enable_native, _native
from ecpy.fields.Zmod import ZmodElement
from ecpy.fields.ExtendedFiniteField import ExtendedFiniteFieldElement
def tate_pairing(E, P, Q, m, k=2):
"""
Calculate Tate Pairing
Args:
E: The Elliptic Curve
P: A point over E which has order m
Q: A point over E which has order m
m: The order of P, Q on E
k: [Optional] The Embedding Degree of m on E
"""
if is_enable_native:
P = _native.EC_elem(E.ec, tuple(P.x), tuple(P.y), tuple(P.z))
Q = _native.EC_elem(E.ec, tuple(Q.x), tuple(Q.y), tuple(Q.z))
if E.ec.type == 1:
t = _native.FF_elem(0)
elif E.ec.type == 2:
t = _native.EF_elem(0, 0)
_native.tate_pairing(t, E.ec, P, Q, m, k)
if E.ec.type == 1:
return ZmodElement(E.field, t.to_python())
elif E.ec.type == 2:
t = t.to_python()
return ExtendedFiniteFieldElement(E.field, t[0], t[1])
else:
f = miller(E, P, Q, m)
return f ** (((E.field.p ** k) - 1) // m) | 804f8d9730df010f690b363b658ba59361e87f47 | 9,137 |
def kl_loss(img,decoded_img,encoder_log_var,encoder_mu):
"""
LK loss for VAEs
"""
kl_loss = -0.5 * tf.reduce_sum( (1+encoder_log_var-tf.exp(encoder_log_var)-encoder_mu**2), axis=[1,2,3],name='klloss' )
return tf.reduce_mean(kl_loss,axis=0) | bd6f644bea86fbc2e5c4426e0e556a432256bb07 | 9,138 |
import warnings
def steady(L, maxiter=10, tol=1e-6, itertol=1e-5, method='solve',
use_umfpack=True, use_precond=False):
"""
Deprecated. See steadystate instead.
"""
message = "steady has been deprecated, use steadystate instead"
warnings.warn(message, DeprecationWarning)
return steadystate(L, [], maxiter=maxiter, tol=tol,
use_umfpack=use_umfpack, use_precond=use_precond) | 36cf008c0b2c773359df5f2251282a2eb12dc613 | 9,139 |
def and_intersection(map_list):
"""
Bitwise or a list of HealSparseMaps as an intersection. Only pixels that
are valid in all the input maps will have valid values in the output.
Only works on integer maps.
Parameters
----------
map_list : `list` of `HealSparseMap`
Input list of maps to bitwise and
Returns
-------
result : `HealSparseMap`
Bitwise and of maps
"""
filler = map_list[0]._sparse_map.dtype.type(-1)
return _apply_operation(map_list, np.bitwise_and, filler, union=False, int_only=True) | 183df05210cdd29bf5dd0a5654ca08297cb9f72a | 9,140 |
import re
def parse(url):
"""Parses a cache URL."""
config = {}
url = urlparse.urlparse(url)
# Handle python 2.6 broken url parsing
path, query = url.path, url.query
if '?' in path and query == '':
path, query = path.split('?', 1)
cache_args = dict([(key.upper(), ';'.join(val)) for key, val in
urlparse.parse_qs(query).items()])
# Update with environment configuration.
backend = BACKENDS.get(url.scheme)
if not backend:
raise Exception('Unknown backend: "{0}"'.format(url.scheme))
config['BACKEND'] = BACKENDS[url.scheme]
redis_options = {}
if url.scheme == 'hiredis':
redis_options['PARSER_CLASS'] = 'redis.connection.HiredisParser'
# File based
if not url.netloc:
if url.scheme in ('memcached', 'pymemcached', 'djangopylibmc'):
config['LOCATION'] = 'unix:' + path
elif url.scheme in ('redis', 'hiredis'):
match = re.match(r'.+?(?P<db>\d+)', path)
if match:
db = match.group('db')
path = path[:path.rfind('/')]
else:
db = '0'
config['LOCATION'] = 'unix:%s?db=%s' % (path, db)
else:
config['LOCATION'] = path
# URL based
else:
# Handle multiple hosts
config['LOCATION'] = ';'.join(url.netloc.split(','))
if url.scheme in ('redis', 'hiredis'):
if url.password:
redis_options['PASSWORD'] = url.password
# Specifying the database is optional, use db 0 if not specified.
db = path[1:] or '0'
port = url.port if url.port else 6379
config['LOCATION'] = "redis://%s:%s/%s" % (url.hostname, port, db)
if redis_options:
config.setdefault('OPTIONS', {}).update(redis_options)
if url.scheme == 'uwsgicache':
config['LOCATION'] = config.get('LOCATION', 'default') or 'default'
# Pop special options from cache_args
# https://docs.djangoproject.com/en/1.10/topics/cache/#cache-arguments
options = {}
for key in ['MAX_ENTRIES', 'CULL_FREQUENCY']:
val = cache_args.pop(key, None)
if val is not None:
options[key] = int(val)
if options:
config.setdefault('OPTIONS', {}).update(options)
config.update(cache_args)
return config | 48328a0863272f17c8ad1e848af0bb29e0118545 | 9,141 |
def states_state(id=""):
""" displays a HTML page with a list of cities by states """
states = storage.all(State).values()
states = sorted(states, key=lambda k: k.name)
found = 0
state = ""
cities = []
for i in states:
if id == i.id:
state = i
found = 1
break
if found:
states = sorted(state.cities, key=lambda k: k.name)
state = state.name
if id and not found:
found = 2
return render_template('9-states.html',
state=state,
array=states,
found=found) | b00bd67a8242a2a21f32226b34df69e214db8856 | 9,142 |
def make_tree_item(parent, text, icon, first_col_text=None, second_col_text=None):
"""
构造树的子项
:param parent: 要构造子项的父节点元素
:param text: 构造的子节点信息
:param icon: 图标，该元素的展示图标对象
:param first_col_text: 第一列隐藏信息
:param second_col_text: 第二列隐藏信息
"""
item = MyTreeWidgetItem(parent)
item.setIcon(0, icon)
item.setText(0, text)
if first_col_text:
# 作为隐藏属性，写于指定列
item.setText(1, first_col_text)
if second_col_text:
item.setText(2, second_col_text)
return item | a93e9d75ac9841c27fa472575054f00e6d1b1cb4 | 9,143 |
def get_boundary_condition(name):
"""
Return a boundary condition by name
"""
try:
return _BOUNDARY_CONDITIONS[name]
except KeyError:
ocellaris_error(
'Boundary condition "%s" not found' % name,
'Available boundary conditions:\n'
+ '\n'.join(
' %-20s - %s' % (n, s.description)
for n, s in sorted(_BOUNDARY_CONDITIONS.items())
),
)
raise | 29ba4d456452cb33cf48c44cace337683d1feab8 | 9,144 |
from datetime import datetime
import json
def run(ts):
""" Actually do the hard work of getting the USDM in geojson """
pgconn = get_dbconn('postgis')
cursor = pgconn.cursor(cursor_factory=psycopg2.extras.DictCursor)
# Look for polygons into the future as well as we now have Flood products
# with a start time in the future
cursor.execute("""
SELECT ST_asGeoJson(geom) as geojson, dm, valid
from usdm WHERE valid = %s ORDER by dm ASC
""", (ts, ))
if cursor.rowcount == 0:
# go back one week
cursor.execute("""
SELECT ST_asGeoJson(geom) as geojson, dm, valid
from usdm WHERE valid = %s ORDER by dm ASC
""", (ts - datetime.timedelta(days=7), ))
utcnow = datetime.datetime.utcnow()
res = {'type': 'FeatureCollection',
'features': [],
'generation_time': utcnow.strftime("%Y-%m-%dT%H:%M:%SZ"),
'count': cursor.rowcount}
for row in cursor:
res['features'].append(dict(type="Feature",
id=row['dm'],
properties=dict(
date=row['valid'].strftime("%Y-%m-%d"),
dm=row['dm']),
geometry=json.loads(row['geojson'])
))
return json.dumps(res) | b9e8f853f5d039fa8bb5fdc70a9f281ea94d7e37 | 9,145 |
def mtxslv_user_ratings(user_id, dataset):
"""
Receives user_id and dataset. Look for all
occurences of user_id in dataset and returns
such subset.
If no user_id is found, return an empty
numpy array.
"""
subset = [] # the same thing as I_i (set of item user_id has voted)
for it in range(0,np.shape(dataset)[0]):
if (dataset[it,user_column] == user_id):
subset.append(dataset[it,:].tolist())
return np.array(subset) | 7b494b95af316d93e6f9b0a20a351179eb2906b9 | 9,146 |
def random_rotation(min, max, prng=DEFAULT_PRNG):
""" Construct a random rotation between -max and max.
Args
min: a scalar for the minimum absolute angle in radians
max: a scalar for the maximum absolute angle in radians
prng: the pseudo-random number generator to use.
Returns
a homogeneous 3 by 3 rotation matrix
"""
return rotation(prng.uniform(min, max)) | 58ae95edf57886164e0e123a89534000ef2f8182 | 9,147 |
def country_code_from_name(country_names,l3=False):
"""2 letter ['BE'] or 3 letter codes ['BEL'] from country names
Accepts string or list of strings e.g, 'Serbia' or ['Belgium','Slovakia']
Update 3/1/2022: also accepts non uppercase titles, e.g. ['united Kingdom', 'hungary']
Arguments:
*country_names* (string or list of strings) : country names
*l3* (Boolean) : return 3l-code; default = False -> returns 2l-code
Returns
*sel* (string or list of strings) : 2l or 3l codes
"""
if True:
data = config['paths']['data']
df = pd.read_csv((data / 'country_codes.csv'), delimiter=';')
df_3l = df['country']
if l3:
code_col = 'code3' #return 3l code
else:
code_col = 'code2' #return 2l code
unpack = False
if not isinstance(country_names, list):
country_names = [country_names]
unpack = True
capitalized_names = [name.title() for name in country_names]
sel = list(df.loc[df.country.isin(capitalized_names)][code_col])
if unpack: sel = sel[0]
return sel | d45a48b4f11de383def2817609c6682157de4443 | 9,148 |
def steem_amount(value):
"""Returns a decimal amount, asserting units are STEEM"""
return parse_amount(value, 'STEEM') | 12ce78e0c9002dd8cd0b136563ad81ab05817ff7 | 9,149 |
def get_edge_angle(fx,fy):
"""エッジ強度と勾配を計算する関数
"""
# np.power : 行列のn乗を計算
# np.sqrt : 各要素の平方根を計算
edge = np.sqrt(np.power(fx.astype(np.float32),2)+np.power(fy.astype(np.float32),2))
edge = np.clip(edge, 0, 255)
fx = np.maximum(fx, 1e-5)
angle = np.arctan(fy/fx)
return edge,angle | 80c7acc05867b6443aa7b4643d75d4fb79e792a9 | 9,150 |
def write_site_pair_score_data_to_file(sorted_data_list, output_file_path, algorithm_used, max_iterations=None, num_threads=None):
"""Since site indices are starting from zero within python we add one to
each of them when they are being written to output file.
"""
formater = '#' + '='*100
formater += '\n'
with open(output_file_path, 'w') as fh:
fh.write(formater)
fh.write('# This result is computed using {}\n'.format(algorithm_used))
if max_iterations is not None:
fh.write('# maximum number of gradient decent iterations: {}\n'.format(max_iterations))
if num_threads is not None:
fh.write('# Number of threads used: {}\n'.format(num_threads))
fh.write('# The first and second columns are site pairs. The third column represents interaction score\n')
fh.write(formater)
for site_pair, score in sorted_data_list:
i, j = site_pair[0] + 1, site_pair[1] + 1
fh.write('{}\t{}\t{}\n'.format(i, j, score))
return None | 5ee4ec97fbc1b6f86e36946ee6d925604858b063 | 9,151 |
def cs_2tuple_list(value):
"""
Parses a comma separated 2-tuple strings into a python list of tuples
>>> cs_2tuple_list('')
[]
>>> cs_2tuple_list('(foobar, "test")')
[('foobar', 'test')]
>>> cs_2tuple_list('(foobar, "test"), ('"'barfoo', "' lalala) ')
[('foobar', 'test'), ('barfoo', 'lalala')]
>>> cs_2tuple_list('(foobar, "test"), ("(barfoo", "lalala)")')
[('foobar', 'test'), ('(barfoo', 'lalala)')]
"""
res = ['']
in_tuple = False
quote_char = None
for char in value:
if in_tuple:
if not quote_char and char in ["'", '"']:
quote_char = char
elif char == quote_char:
quote_char = None
elif not quote_char and char == ")":
res[-1] = tuple(cs_string_list(res[-1]))
in_tuple = False
else:
res[-1] += char
elif char == " ":
continue
elif char == ",":
res.append('')
elif char == "(":
in_tuple = True
else:
raise ValueError("Unexpected character '{}' after '{}'"
.format(char, res))
if in_tuple or quote_char:
raise ValueError("Unterminated tuple {}".format(res[-1]))
# remove empty string stored as state
if not isinstance(res[-1], tuple):
del res[-1]
if any(not isinstance(e, tuple) or len(e) != 2 for e in res):
raise ValueError("Unexpected value in {}".format(res))
return res | f6d5b5d440ef524c9c2f2c79f410c432229a8099 | 9,152 |
def expectatedCapacityFactorFromDistribution( powerCurve, windspeedValues, windspeedCounts):
"""Computes the expected capacity factor of a wind turbine based on an explicitly-provided wind speed distribution
"""
windspeedValues = np.array(windspeedValues)
windspeedCounts = np.array(windspeedCounts)
if not len(windspeedValues.shape) == 1: raise ResError("windspeedValues must be 1-dimensional")
# Handle 2 dimensional counts with 1 dimensional wind speeds
if len(windspeedCounts.shape) > 1:
if not windspeedCounts.shape[0] == windspeedValues.shape[0]:
raise ResError("Dimensional incompatability")
windspeedValues = np.reshape(windspeedValues, (windspeedCounts.shape[0],1))
# Estimate generation distribution
gen = np.interp(windspeedValues, powerCurve.ws, powerCurve.cf, left=0, right=0) * windspeedCounts
meanGen = gen.sum(0)/windspeedCounts.sum(0)
# Done
return meanGen | fbcea908265cfbfcd9eb49632ac1027538417bfe | 9,153 |
import os
def check_icon_arg(src, default):
"""
Checks if icon arguments are valid: either a URL or an absolute path.
:param src: Source of the icon
:param default: default value of the icon
:return: src (possibly pre-pended with "file://")
"""
if src != default:
# check if URl
if not src.startswith('https://') and not src.startswith('http://'):
# Either a file or incorrect input
if os.path.isabs(src):
src = "file://" + src
else:
raise IOError(
f"Please provide a valid URL or valid *absolute* path to icon: {src}"
)
return src | 33db8c760df0bdf5e26474cdc281e4d6504cca27 | 9,154 |
def setup_2d_em_pic():
"""
Returns a 2D electromagnetic PIC for testing
"""
params = {
"length": [2 * np.pi, 2 * np.pi],
"cells": [32, 32],
"dimensions": 2,
"nppc": 10,
"single_stream": { # defaults for single stream instability
"stream_v": 3,
"stream_frac": 0.8,
"stream_width": 1
},
"landau": { # defaults for Landau damping
"amplitude": 0.8,
"mode": 3
},
"two_stream": { # defaults for two stream instability
"vpos": 2,
"vneg": -2,
"stream_frac": 1,
"stream_width": 0.8
},
}
sim_params = plat.params.Parameters(2)
sim_params.set_from_dict(params)
pic = plat.pic_2d_em.PIC_2D_EM(sim_params)
return pic | 136e8e83b63329866dc4c547075dcfd603279de6 | 9,155 |
def young_laplace(Bo,nPoints,L):
"""
Bo = float - Bond number
nPoints = int - number of integration points desired
L = float - final arc length for range of integration
"""
#integration range and number of integration points
s1=L
N=nPoints
#set initial values
s0 = 0
y0 = [0.00001,0.00001,0.00001]
sVec = np.linspace(s0,s1,N)
bond=Bo
sol = odeint(ode_system,y0,sVec,args=(bond,))
r = sol[:,1]
z = sol[:,2]
fi = sol[:,0]
return r,z,fi | 80ceaf8d66e4c309a9f0c16e329c90a26a9b43a0 | 9,156 |
import torch
def get_uncertain_point_coords_on_grid(uncertainty_map, num_points):
"""
Find `num_points` most uncertain points from `uncertainty_map` grid.
Args:
uncertainty_map (Tensor): A tensor of shape (N, 1, H, W) that contains uncertainty
values for a set of points on a regular H x W grid.
num_points (int): The number of points P to select.
Returns:
point_indices (Tensor): A tensor of shape (N, P) that contains indices from
[0, H x W) of the most uncertain points.
point_coords (Tensor): A tensor of shape (N, P, 2) that contains [0, 1] x [0, 1] normalized
coordinates of the most uncertain points from the H x W grid.
"""
R, _, H, W = uncertainty_map.shape
h_step = 1.0 / float(H)
w_step = 1.0 / float(W)
num_points = min(H * W, num_points)
point_indices = torch.topk(uncertainty_map.view(R, H * W), k=num_points, dim=1)[1]
point_coords = torch.zeros(R, num_points, 2, dtype=torch.float, device=uncertainty_map.device)
point_coords[:, :, 0] = w_step / 2.0 + (point_indices % W).to(torch.float) * w_step
point_coords[:, :, 1] = h_step / 2.0 + (point_indices // W).to(torch.float) * h_step
return point_indices, point_coords | a9d622c232f22359ac030679a49ed6f36345623c | 9,157 |
def amex_credit_card(input_filename, month):
"""Format is just contents.
date, description, amount"""
test = _make_month_test(0, month)
def transform(xs):
return [xs[0], xs[1],
'-' + xs[2] if xs[2][0] != '-' else xs[2][1:]]
return _csv_transform(input_filename, test, transform,
None) | c60bedd7b0afeda40e1fe9a34e27b0fd796f25f2 | 9,158 |
def loadf(file_like, *args, attributes=None, **kwargs):
"""Read a data file and load it -- scaled -- in memory.
This function differs from `read` in several ways:
* The output data type should be a floating point type.
* If an affine scaling (slope, intercept) is defined in the
file, it is applied to the data.
* the default output data type is `torch.get_default_dtype()`.
Parameters
----------
file_like : str or file object
Path to file or file object (with methods `seek`, `read`)
dtype : dtype_like, optional
Output data type. By default, use `torch.get_default_dtype()`.
Should be a floating point type.
device : torch.device, default='cpu'
Output device.
rand : bool, default=False
If the on-disk dtype is not floating point, sample noise
in the uncertainty interval.
cutoff : float or (float, float), default=(0, 1)
Percentile cutoff. If only one value is provided, it is
assumed to relate to the upper percentile.
dim : int or list[int], optional
Dimensions along which to compute percentiles.
By default, they are computed on the flattened array.
numpy : bool, default=False
Return a numpy array rather than a torch tensor.
attributes : list[str]
List of attributes to return as well.
See `MappedArray` for the possible attributes.
Returns
-------
dat : array or tensor
The array loaded in memory
attributes : dict, if attributes is not None
Dictionary of attributes loaded as well
"""
file = map(file_like, permission='r', keep_open=False)
dat = file.fdata(*args, **kwargs)
if attributes:
attributes = {getattr(file, key) for key in attributes}
return dat, attributes
else:
return dat | 528c11132a83b7d341bb9688a75a4483aa59c155 | 9,159 |
import os
def download_if_not_exists(filename, url):
"""
Download a URL to a file if the file
does not exist already.
Returns
-------
True if the file was downloaded,
False if it already existed
"""
if not os.path.exists(filename):
down_load_file(filename, url)
return True
return False | 3954b8910248409fcfa1a41c1f28831e3a3fa210 | 9,160 |
from typing import List
def _backsubstitution(A: MatrixData, B: List[float]) -> List[float]:
""" Solve equation A . x = B for an upper triangular matrix A by backsubstitution.
Args:
A: row major matrix
B: vector of floats
"""
num = len(A)
x = [0.0] * num
for i in range(num - 1, -1, -1):
x[i] = B[i] / A[i][i]
for row in range(i - 1, -1, -1):
B[row] -= A[row][i] * x[i]
return x | 789c94842da2b751008e47a1ef661abeaded2da7 | 9,161 |
def deiterize(func):
"""The inverse of iterize.
Takes an "iterized" (a.k.a. "vectorized") function (i.e. a function that
works on iterables), and
That is, takes a func(X,...) function and returns a next(iter(func([X],
...))) function."""
return Pipe(wrap_first_arg_in_list(func), iter, next) | 7ef4786ec858f1cbd8fb79b8cfee0e4b03bcb33c | 9,162 |
def ecg_data(rdb, day, patient, time):
""" Returns DatFrame to plot ecg signal """
sql = """SELECT * FROM ECG where "Day"='{0}' and "Patient"='{1}' and "Date"::time='{2}' """.format(day, patient, time)
try:
df = pd.read_sql(sql, rdb)
except:
df = pd.DataFrame()
return df | 4a384f920c0fdf45e1818633d2ef125a29b4a562 | 9,163 |
def evaluate(data_set_file_or_name, data_format=None, data_directory=None,
map_features=None, feature_selection=None, example_filter=None,
noisy_preprocessing_methods=None, preprocessing_methods=None,
split_data_set=None, splitting_method=None,
splitting_fraction=None,
model_type=None, latent_size=None, hidden_sizes=None,
number_of_importance_samples=None,
number_of_monte_carlo_samples=None,
inference_architecture=None, latent_distribution=None,
number_of_classes=None, parameterise_latent_posterior=False,
prior_probabilities_method=None,
generative_architecture=None, reconstruction_distribution=None,
number_of_reconstruction_classes=None, count_sum=None,
proportion_of_free_nats_for_y_kl_divergence=None,
minibatch_normalisation=None, batch_correction=None,
dropout_keep_probabilities=None,
number_of_warm_up_epochs=None, kl_weight=None,
minibatch_size=None, run_id=None, models_directory=None,
included_analyses=None, analysis_level=None,
decomposition_methods=None, highlight_feature_indices=None,
export_options=None, analyses_directory=None,
evaluation_set_kind=None, sample_size=None,
prediction_method=None, prediction_training_set_kind=None,
model_versions=None, **keyword_arguments):
"""Evaluate model on data set."""
if split_data_set is None:
split_data_set = defaults["data"]["split_data_set"]
if splitting_method is None:
splitting_method = defaults["data"]["splitting_method"]
if splitting_fraction is None:
splitting_fraction = defaults["data"]["splitting_fraction"]
if models_directory is None:
models_directory = defaults["models"]["directory"]
if evaluation_set_kind is None:
evaluation_set_kind = defaults["evaluation"]["data_set_name"]
if sample_size is None:
sample_size = defaults["models"]["sample_size"]
if prediction_method is None:
prediction_method = defaults["evaluation"]["prediction_method"]
if prediction_training_set_kind is None:
prediction_training_set_kind = defaults["evaluation"][
"prediction_training_set_kind"]
if model_versions is None:
model_versions = defaults["evaluation"]["model_versions"]
if analyses_directory is None:
analyses_directory = defaults["analyses"]["directory"]
evaluation_set_kind = normalise_string(evaluation_set_kind)
prediction_training_set_kind = normalise_string(
prediction_training_set_kind)
model_versions = parse_model_versions(model_versions)
print(title("Data"))
binarise_values = False
if reconstruction_distribution == "bernoulli":
if noisy_preprocessing_methods:
if noisy_preprocessing_methods[-1] != "binarise":
noisy_preprocessing_methods.append("binarise")
else:
binarise_values = True
data_set = DataSet(
data_set_file_or_name,
data_format=data_format,
directory=data_directory,
map_features=map_features,
feature_selection=feature_selection,
example_filter=example_filter,
preprocessing_methods=preprocessing_methods,
binarise_values=binarise_values,
noisy_preprocessing_methods=noisy_preprocessing_methods
)
if not split_data_set or evaluation_set_kind == "full":
data_set.load()
if split_data_set:
training_set, validation_set, test_set = data_set.split(
method=splitting_method, fraction=splitting_fraction)
data_subsets = [data_set, training_set, validation_set, test_set]
for data_subset in data_subsets:
clear_data_subset = True
if data_subset.kind == evaluation_set_kind:
evaluation_set = data_subset
clear_data_subset = False
if data_subset.kind == prediction_training_set_kind:
prediction_training_set = data_subset
clear_data_subset = False
if clear_data_subset:
data_subset.clear()
else:
splitting_method = None
splitting_fraction = None
evaluation_set = data_set
prediction_training_set = data_set
evaluation_subset_indices = indices_for_evaluation_subset(
evaluation_set)
models_directory = build_directory_path(
models_directory,
data_set=evaluation_set,
splitting_method=splitting_method,
splitting_fraction=splitting_fraction
)
analyses_directory = build_directory_path(
analyses_directory,
data_set=evaluation_set,
splitting_method=splitting_method,
splitting_fraction=splitting_fraction
)
print(title("Model"))
if number_of_classes is None:
if evaluation_set.has_labels:
number_of_classes = (
evaluation_set.number_of_classes
- evaluation_set.number_of_excluded_classes)
model = _setup_model(
data_set=evaluation_set,
model_type=model_type,
latent_size=latent_size,
hidden_sizes=hidden_sizes,
number_of_importance_samples=number_of_importance_samples,
number_of_monte_carlo_samples=number_of_monte_carlo_samples,
inference_architecture=inference_architecture,
latent_distribution=latent_distribution,
number_of_classes=number_of_classes,
parameterise_latent_posterior=parameterise_latent_posterior,
prior_probabilities_method=prior_probabilities_method,
generative_architecture=generative_architecture,
reconstruction_distribution=reconstruction_distribution,
number_of_reconstruction_classes=number_of_reconstruction_classes,
count_sum=count_sum,
proportion_of_free_nats_for_y_kl_divergence=(
proportion_of_free_nats_for_y_kl_divergence),
minibatch_normalisation=minibatch_normalisation,
batch_correction=batch_correction,
dropout_keep_probabilities=dropout_keep_probabilities,
number_of_warm_up_epochs=number_of_warm_up_epochs,
kl_weight=kl_weight,
models_directory=models_directory
)
if not model.has_been_trained(run_id=run_id):
raise Exception(
"Model not found. Either it has not been trained or "
"scVAE is looking in the wrong directory. "
"The model directory resulting from the model specification is: "
"\"{}\"".format(model.log_directory())
)
if ("best_model" in model_versions
and not better_model_exists(model, run_id=run_id)):
model_versions.remove("best_model")
if ("early_stopping" in model_versions
and not model_stopped_early(model, run_id=run_id)):
model_versions.remove("early_stopping")
print(subtitle("Analysis"))
analyses.analyse_model(
model=model,
run_id=run_id,
included_analyses=included_analyses,
analysis_level=analysis_level,
export_options=export_options,
analyses_directory=analyses_directory
)
print(title("Results"))
print("Evaluation set: {} set.".format(evaluation_set.kind))
print("Model version{}: {}.".format(
"" if len(model_versions) == 1 else "s",
enumerate_strings(
[v.replace("_", " ") for v in model_versions], conjunction="and")))
if prediction_method:
prediction_specifications = PredictionSpecifications(
method=prediction_method,
number_of_clusters=number_of_classes,
training_set_kind=prediction_training_set.kind
)
print("Prediction method: {}.".format(
prediction_specifications.method))
print("Number of clusters: {}.".format(
prediction_specifications.number_of_clusters))
print("Prediction training set: {} set.".format(
prediction_specifications.training_set_kind))
print()
for model_version in model_versions:
use_best_model = False
use_early_stopping_model = False
if model_version == "best_model":
use_best_model = True
elif model_version == "early_stopping":
use_early_stopping_model = True
print(subtitle(model_version.replace("_", " ").capitalize()))
print(heading("{} evaluation".format(
model_version.replace("_", "-").capitalize())))
(
transformed_evaluation_set,
reconstructed_evaluation_set,
latent_evaluation_sets
) = model.evaluate(
evaluation_set=evaluation_set,
evaluation_subset_indices=evaluation_subset_indices,
minibatch_size=minibatch_size,
run_id=run_id,
use_best_model=use_best_model,
use_early_stopping_model=use_early_stopping_model,
output_versions="all"
)
print()
if sample_size:
print(heading("{} sampling".format(
model_version.replace("_", "-").capitalize())))
sample_reconstruction_set, __ = model.sample(
sample_size=sample_size,
minibatch_size=minibatch_size,
run_id=run_id,
use_best_model=use_best_model,
use_early_stopping_model=use_early_stopping_model
)
print()
else:
sample_reconstruction_set = None
if prediction_method:
print(heading("{} prediction".format(
model_version.replace("_", "-").capitalize())))
latent_prediction_training_sets = model.evaluate(
evaluation_set=prediction_training_set,
minibatch_size=minibatch_size,
run_id=run_id,
use_best_model=use_best_model,
use_early_stopping_model=use_early_stopping_model,
output_versions="latent",
log_results=False
)
print()
cluster_ids, predicted_labels, predicted_superset_labels = (
predict_labels(
training_set=latent_prediction_training_sets["z"],
evaluation_set=latent_evaluation_sets["z"],
specifications=prediction_specifications
)
)
evaluation_set_versions = [
transformed_evaluation_set, reconstructed_evaluation_set
] + list(latent_evaluation_sets.values())
for evaluation_set_version in evaluation_set_versions:
evaluation_set_version.update_predictions(
prediction_specifications=prediction_specifications,
predicted_cluster_ids=cluster_ids,
predicted_labels=predicted_labels,
predicted_superset_labels=predicted_superset_labels
)
print()
print(heading("{} analysis".format(
model_version.replace("_", "-").capitalize())))
analyses.analyse_results(
evaluation_set=transformed_evaluation_set,
reconstructed_evaluation_set=reconstructed_evaluation_set,
latent_evaluation_sets=latent_evaluation_sets,
model=model,
run_id=run_id,
sample_reconstruction_set=sample_reconstruction_set,
decomposition_methods=decomposition_methods,
evaluation_subset_indices=evaluation_subset_indices,
highlight_feature_indices=highlight_feature_indices,
best_model=use_best_model,
early_stopping=use_early_stopping_model,
included_analyses=included_analyses,
analysis_level=analysis_level,
export_options=export_options,
analyses_directory=analyses_directory
)
return 0 | 399411ca9560d9e48e73846c9fb70898f028f90a | 9,164 |
def deploy_new_company(company_id):
"""
Deploy new company contract
:param company_id: Company off chain id for deploy
:return: True in case of successful, false otherwise
"""
try:
instance = Company.objects.get(pk=company_id)
except Company.DoesNotExist:
logger.error('Company with id {} not found, contract will bot be deployed.'.format(company_id))
return False
else:
oracle = OracleHandler()
w3 = utils.get_w3()
contract_file = 'dapp/contracts/Company.sol'
compile_sol = compile_files([contract_file, ],
output_values=("abi", "ast", "bin", "bin-runtime",))
create_abi(compile_sol[contract_file + ':Company']['abi'], 'Company')
obj = w3.eth.contract(
abi=compile_sol[contract_file + ':Company']['abi'],
bytecode=compile_sol[contract_file + ':Company']['bin'],
bytecode_runtime=compile_sol[contract_file + ':Company']['bin-runtime'],
)
args = [settings.VERA_COIN_CONTRACT_ADDRESS, settings.VERA_ORACLE_CONTRACT_ADDRESS, ]
logger.info('Try to unlock account: {}.'.format(oracle.unlockAccount()))
try:
txn_hash = obj.deploy(transaction={'from': oracle.account}, args=args)
except Exception as e:
logger.warning('Error while deploy new company contract. Company {}: {}'.format(company_id, e))
else:
logger.info('Lock account: {}'.format(oracle.lockAccount()))
save_txn.delay(txn_hash.hex(), 'NewCompany', instance.created_by.id, company_id)
save_txn_to_history.delay(instance.created_by.id, txn_hash.hex(),
'Creation of a new Company contract') | 3871f2ae9948001a1fe24a4c4d2791b7d12f79d7 | 9,165 |
import random
def MEMB(G,rb,cycle=0):
"""
It returns a dictionary with {box_id:subgraph_generated_by_the_nodes_in_this_box}
The box_id is the center of the box.
cycle: Ignore this parameter. Use the default cycle=0.
"""
adj = G.adj
number_of_nodes = G.number_of_nodes()
covered_nodes = set()
center_nodes = set()
non_center_nodes = G.nodes()
center_node_found = 0
boxes={} #this will be "box_id:[nodes in box]"
central_distance_of_node = {} #"node:central_distance"
node_box_id = {} #"node:box_id"
nodes_sorted_by_central_distance={} #Dict with {central_distance:[nodes]}
excluded_mass_of_non_centers_rb = {} #This contains [(node:excluded_mass)] for rb
excluded_mass_of_non_centers_rb2 = {} #This contains [(node:excluded_mass)] for rb+1
rb2 = rb + 1
for node in non_center_nodes:
#if node in [5000,10000,20000,30000]: print "node", node
level=0 # the current level
nextlevel={node:1} # list of nodes to check at next level
paths_rb=None
paths_rb2={node:[node]} # paths dictionary (paths to key from source)
while nextlevel:
paths_rb = deepcopy(paths_rb2)
thislevel=nextlevel
nextlevel={}
for v in thislevel:
for w in G.neighbors(v):
if not paths_rb2.has_key(w):
paths_rb2[w]=paths_rb2[v]+[w]
nextlevel[w]=1
level=level+1
if (rb2 <= level): break
excluded_mass_of_node = len(paths_rb2)
try:
excluded_mass_of_non_centers_rb2[excluded_mass_of_node].append(node)
except KeyError:
excluded_mass_of_non_centers_rb2[excluded_mass_of_node] = [node]
excluded_mass_of_node = len(paths_rb)
try:
excluded_mass_of_non_centers_rb[excluded_mass_of_node].append(node)
except KeyError:
excluded_mass_of_non_centers_rb[excluded_mass_of_node] = [node]
maximum_excluded_mass = 0
nodes_with_maximum_excluded_mass=[]
new_covered_nodes = {}
center_node_and_mass = []
cycle_index = 0
while len(covered_nodes) < number_of_nodes:
#print len(covered_nodes),number_of_nodes
cycle_index += 1
if cycle_index == cycle:
rb2 = rb+1
cycle_index = 0
else:
rb2 = rb
while 1:
if rb2 == rb+1:
#t1=time.time()
while 1:
maximum_key = max(excluded_mass_of_non_centers_rb2.keys())
node = random.choice(excluded_mass_of_non_centers_rb2[maximum_key])
if node in center_nodes:
excluded_mass_of_non_centers_rb2[maximum_key].remove(node)
if not excluded_mass_of_non_centers_rb2[maximum_key]: del excluded_mass_of_non_centers_rb2[maximum_key]
else:
break
nodes_visited = {}
bfs = single_source_shortest_path(G,node,cutoff=rb2)
for i in bfs:
nodes_visited[i] = len(bfs[i])-1
excluded_mass_of_node = len(set(nodes_visited.keys()).difference(covered_nodes))
if excluded_mass_of_node == maximum_key:
center_node_and_mass = (node,maximum_key)
excluded_mass_of_non_centers_rb2[maximum_key].remove(node)
if not excluded_mass_of_non_centers_rb2[maximum_key]: del excluded_mass_of_non_centers_rb2[maximum_key]
new_covered_nodes = nodes_visited
break
else:
excluded_mass_of_non_centers_rb2[maximum_key].remove(node)
if not excluded_mass_of_non_centers_rb2[maximum_key]: del excluded_mass_of_non_centers_rb2[maximum_key]
try:
excluded_mass_of_non_centers_rb2[excluded_mass_of_node].append(node)
except KeyError:
excluded_mass_of_non_centers_rb2[excluded_mass_of_node] = [node]
#print "time", time.time()-t1
else:
#t1=time.time()
while 1:
maximum_key = max(excluded_mass_of_non_centers_rb.keys())
node = random.choice(excluded_mass_of_non_centers_rb[maximum_key])
if node in center_nodes:
excluded_mass_of_non_centers_rb[maximum_key].remove(node)
if not excluded_mass_of_non_centers_rb[maximum_key]: del excluded_mass_of_non_centers_rb[maximum_key]
else:
break
nodes_visited = {}
bfs = single_source_shortest_path(G,node,cutoff=rb)
for i in bfs:
nodes_visited[i] = len(bfs[i])-1
excluded_mass_of_node = len(set(nodes_visited.keys()).difference(covered_nodes))
if excluded_mass_of_node == maximum_key:
center_node_and_mass = (node,maximum_key)
excluded_mass_of_non_centers_rb[maximum_key].remove(node)
if not excluded_mass_of_non_centers_rb[maximum_key]: del excluded_mass_of_non_centers_rb[maximum_key]
new_covered_nodes = nodes_visited
break
else:
excluded_mass_of_non_centers_rb[maximum_key].remove(node)
if not excluded_mass_of_non_centers_rb[maximum_key]: del excluded_mass_of_non_centers_rb[maximum_key]
try:
excluded_mass_of_non_centers_rb[excluded_mass_of_node].append(node)
except KeyError:
excluded_mass_of_non_centers_rb[excluded_mass_of_node] = [node]
#print "time", time.time()-t1
center_node_found = center_node_and_mass[0]
boxes[center_node_found] = [center_node_found]
node_box_id[center_node_found] = center_node_found
non_center_nodes.remove(center_node_found)
center_nodes.add(center_node_found)
covered_nodes = covered_nodes.union(set(new_covered_nodes.keys()))
#print len(covered_nodes)
for i in new_covered_nodes:
try:
if central_distance_of_node[i] > new_covered_nodes[i]:
nodes_sorted_by_central_distance[central_distance_of_node[i]].remove(i)
if not nodes_sorted_by_central_distance[central_distance_of_node[i]]:
del nodes_sorted_by_central_distance[central_distance_of_node[i]]
try:
nodes_sorted_by_central_distance[new_covered_nodes[i]].append(i)
except KeyError:
nodes_sorted_by_central_distance[new_covered_nodes[i]] = [i]
central_distance_of_node[i] = new_covered_nodes[i]
except KeyError:
central_distance_of_node[i] = new_covered_nodes[i]
try:
nodes_sorted_by_central_distance[new_covered_nodes[i]].append(i)
except:
nodes_sorted_by_central_distance[new_covered_nodes[i]] = [i]
max_distance = max(nodes_sorted_by_central_distance.keys())
for i in range(1,max_distance+1):
for j in nodes_sorted_by_central_distance[i]:
targets = list(set(adj[j].iterkeys()).intersection(set(nodes_sorted_by_central_distance[i-1])))
node_box_id[j] = node_box_id[random.choice(targets)]
boxes[node_box_id[j]].append(j)
boxes_subgraphs={}
for i in boxes:
boxes_subgraphs[i] = subgraph(G,boxes[i])
return boxes_subgraphs | dfe522aa1e6140e98d32d2eee039aec366d76a8d | 9,166 |
import os
from pathlib import Path
from getpass import getuser
def set_app_path(required=False):
"""Find app directory and set value to environment variable."""
matched_path = None
config_paths = (Path.home() / "hyperglass-agent", Path("/etc/hyperglass-agent/"))
for path in config_paths:
try:
if path.exists():
tmp = path / "test.tmp"
tmp.touch()
if tmp.exists():
matched_path = path
tmp.unlink()
break
except Exception:
matched_path = None
if required and matched_path is None:
# Only raise an error if required is True
raise RuntimeError(
"""
No configuration directories were determined to both exist and be readable
by hyperglass. hyperglass is running as user '{un}' (UID '{uid}'), and tried
to access the following directories:
{dir}""".format(
un=getuser(),
uid=os.getuid(),
dir="\n".join([" - " + str(p) for p in config_paths]),
)
)
if matched_path is not None:
os.environ["hyperglass_agent_directory"] = str(matched_path)
return True | 15298cb0a745ee8a4f4b4be8623df0dab08c685a | 9,167 |
def shownames(namespace, **args):
"""helper method to generate a template keyword for a namespace"""
ctx = args['ctx']
repo = ctx.repo()
ns = repo.names[namespace]
names = ns.names(repo, ctx.node())
return showlist(ns.templatename, names, plural=namespace, **args) | 29105570ad822975c69c7b1d30b94e368d554873 | 9,168 |
def only_half_radius(
subsampled_radius: float, full_diameter: float, radius_constraint: float
):
"""
Check if radius is smaller than fraction of full radius.
"""
assert 0.0 <= radius_constraint <= 1.0
return subsampled_radius <= ((full_diameter / 2) * radius_constraint) | 565c301932d5445e8bbb594085e65df63814663a | 9,169 |
def complete_from_man(context: CommandContext):
"""
Completes an option name, based on the contents of the associated man
page.
"""
if context.arg_index == 0 or not context.prefix.startswith("-"):
return
cmd = context.args[0].value
def completions():
for desc, opts in _parse_man_page_options(cmd).items():
yield RichCompletion(
value=opts[-1], display=", ".join(opts), description=desc
)
return completions(), False | 4312ff8323a72a405737a8476cb7ad541dbff718 | 9,170 |
def sanitise_description(original: str) -> str:
"""
Remove newlines from ticket descriptions.
:param original: the string to sanitise
:return: the same string, with newlines as spaces
"""
return original.replace("\n", " ") | 741aa7df758fb342a0d9a0fa182d24a643f5dbbc | 9,171 |
def dnsdomain_get_all(context):
"""Get a list of all dnsdomains in our database."""
return IMPL.dnsdomain_get_all(context) | fc7bde05cdb35f60c30943f1ebebdb4217af9467 | 9,172 |
def mockselect(r, w, x, timeout=0): # pylint: disable=W0613
"""Simple mock for select()
"""
readable = [s for s in r if s.ready_for_read]
return readable, w[:], [] | 920810aea2f7813885805011d646ddaabfd1901c | 9,173 |
import os
def load_imgs(path):
"""Given a path load image(s).
The input path can either be (i) a directory in which case all the JPG-images will be loaded into a dictionary,
or (ii) an image file.
Returns:
imgs: A dictionary of of n-dim images. Keys are the original filenames
"""
## Get filenames
filenames = []
if os.path.isdir(path):
'Images in {} will be loaded'.format(path)
for file in os.listdir(path):
if file.endswith(".jpg"):
filenames.append(os.path.basename(file))
imagepath = path
else:
filenames.append(os.path.basename(path))
imagepath = os.path.dirname(path)
'{} images found in {}'.format(len(filenames), path)
## Load images
imgs = dict()
for file in filenames:
#print '\nImage: {}'.format(file)
imgs[file]=imread(os.path.join(imagepath, file))
return imgs | 149df70018133d29dcc9089a9c7f2fff064a5e44 | 9,174 |
def solve_5c2c9af4(x):
"""
Required Transformation: The input contains 3 cells with non-zero value. The non-zero valued cells are diagonally
positioned with some amount of gap between each non-zero valued cells. The program should identify the colour and
their position in the grid and form a squared box around the centered non-zero valued cell. Each squared box should
be of equal width between the previous one.
Implementation: The solution is to identify the coloured cells in the grid and form a squared boxes around centered
cell (non-zero valued cell). The Width should be same between each squared box, where width is measured by the
difference between the number of rows or columns between 2 consecutive non-zero valued cells.
The non-zero valued cells can be arranged in 2 forms,
1. Up Slope
2. Down Slope
In the case of Up slope, once the first non-zero valued cell is identified, the pattern to fill the cells are as
follows,
RIGHT, DOWN, LEFT, UP
Whereas in the case of Down Slope, once the first non-zero valued cell is identified, the pattern to fill the cells
are as follows,
DOWN, LEFT, UP, RIGHT
After one full rotation, the row & column is recalculated based on the width.This process is repeated until the
row & column goes out of the grid.
Training & Test Grid: The solution works on all Training & Test cases
"""
non_zero_indexes = np.nonzero(x)
non_zero_row_array = non_zero_indexes[0]
non_zero_col_array = non_zero_indexes[1]
# Difference between the columns of first & second non-zero valued cell
width = non_zero_col_array[0] - non_zero_col_array[1]
row, col = non_zero_row_array[0], non_zero_col_array[0]
# Centered non-zero Valued cell. This cell will become the reference point for all the squared boxes in the grid
midpoint_loc = (non_zero_row_array[1], non_zero_col_array[1])
value = x[non_zero_row_array[1], non_zero_col_array[1]]
# Assign the initial width to Original Width because the width values increases as the size of the square increase.
original_width = width
while True:
if width > 0:
# Up Slope: down, left, up, right
row, col = travel_down(x, row, col, midpoint_loc[0], abs(width), value)
row, col = travel_left(x, row, col, midpoint_loc[1], abs(width), value)
row, col = travel_up(x, row, col, midpoint_loc[0], abs(width), value)
row, col = travel_right(x, row, col, midpoint_loc[1], abs(width), value)
# Recalculate the rows & column based on the original width. Because each square should have same width
row, col = row - abs(original_width), col + abs(original_width)
else:
# Down Slope: right, down, left, up
row, col = travel_right(x, row, col, midpoint_loc[1], abs(width), value)
row, col = travel_down(x, row, col, midpoint_loc[0], abs(width), value)
row, col = travel_left(x, row, col, midpoint_loc[1], abs(width), value)
row, col = travel_up(x, row, col, midpoint_loc[0], abs(width), value)
# Recalculate the rows & column based on the original width. Because each square should have same width
row, col = row - abs(original_width), col - abs(original_width)
width = width + original_width
# If the rows or columns exceed beyond the grid size terminate the loop.
if (row < -1 and col < -1) or (row < -1 and col > x[0].shape[0]):
break
return x | fcb9701c4bccabe237481ed2acd052b7501abd3f | 9,175 |
def kernel_primitive_zhao_vec(x, s0=0.08333, theta=0.242):
"""
Calculates the primitive of the Zhao kernel for given values.
Optimized using nd-arrays and vectorization.
:param x: points to evaluate, should be a nd-array
:param s0: initial reaction time
:param theta: empirically determined constant
:param c0: normalization constant
:return: primitives evaluated at given points
"""
c0 = 1.0 / s0 / (1 - 1.0 / -theta)
res = np.copy(x)
res[x < 0] = 0
res[(x <= s0) & (x >= 0)] = c0 * res[(x <= s0) & (x >= 0)]
res[x > s0] = c0 * (s0 + (s0 * (1 - (res[x > s0] / s0) ** -theta)) / theta)
return res | 26cd9230e23f4217ec5a7eee2e8522bef0a40c4e | 9,176 |
from io import StringIO
import sys
def capture_output(function, *args):
""" captures the printed output from a function """
@contextmanager
def captured_output():
new_out, new_err = StringIO(), StringIO()
old_out, old_err = sys.stdout, sys.stderr
try:
sys.stdout, sys.stderr = new_out, new_err
yield sys.stdout, sys.stderr
finally:
sys.stdout, sys.stderr = old_out, old_err
with captured_output() as (out, err):
function(*args)
if err.errors:
return False
return out.getvalue() | d740030ff3678aed247bb8fb29e636e0fd32b3a6 | 9,177 |
def scaled_dot_product_attention(q, k, v, mask):
"""Calculate the attention weights.
q, k, v must have matching leading dimensions.
k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.
The mask has different shapes depending on its type(padding or look ahead)
but it must be broadcastable for addition.
Args:
q: query shape == (..., seq_len_q, depth)
k: key shape == (..., seq_len_k, depth)
v: value shape == (..., seq_len_v, depth_v)
mask: Float tensor with shape broadcastable to (..., seq_len_q, seq_len_k). Defaults to None.
Returns:
output, attention_weights
"""
matmul_qk = tf.matmul(q, k, transpose_b=True) # (..., seq_len_q, seq_len_k)
# scale matmul_qk
dk = tf.cast(tf.shape(k)[-1], tf.float32)
scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)
# add the mask to the scaled tensor.
if mask is not None:
scaled_attention_logits += (mask * -1e9)
# softmax is normalized on the last axis (seq_len_k) so that the scores
# add up to 1.
attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1) # (..., seq_len_q, seq_len_k)
output = tf.matmul(attention_weights, v) # (..., seq_len_q, depth_v)
return output, attention_weights | 94498a5fd499a09e24a964a6ac975420d702c536 | 9,178 |
import sys
import re
def cvCascades(argv=sys.argv[1:]):
"""Control the OpenCV cascade Examples.
Please see :meth:`cv2ArgumentParser <pycharmers.utils.argparse_utils.cv2ArgumentParser>` for arguments.
Note:
When you run from the command line, execute as follows::
$ cv-cascades --cam 0 --radio-width 200
"""
parser = cv2ArgumentParser(prog="cv-cascades", description="OpenCV cascade examples", add_help=True)
args = parser.parse_args(argv)
# Collect All cascades.
cascade_names, cascades, states = [],[],[]
for name,value in OPENCV_CASCADES.items():
m = re.match(pattern=r"^haarcascades:haarcascade_(.+)$", string=name)
if m is not None:
try:
cascade = cascade_creator(cascade=name)
cascades.append(cascade)
states.append(len(states)==0)
cascade_names.append(m.group(1))
except Exception as e:
print(name, e)
project = cv2Project(args=args, cascade_names=cascade_names)
def func(frame, monitor, gui_x, frame_height, cascade_names, **kwargs):
cvui.text(where=monitor, x=gui_x+20, y=5, text="[Cascade List]")
idx = cvui.radiobox(where=monitor, x=gui_x, y=25, labels=cascade_names, states=states)
cascade = cascades[idx]
name = cascade_names[idx]
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
for bbox in cascade.detectMultiScale(gray):
draw_bboxes_xywh(frame=frame, bboxes=bbox, infos=[{"color":cv2GREEN, "text": name}])
return frame
project.wrap(func=func) | e28a03386e2b38e0f8e9984bac3e4946ea2598dc | 9,179 |
from typing import List
from typing import Any
from datetime import datetime
def extract_data(state: str, data) -> List[List[Any]]:
"""
Collects
"""
try:
extracted = []
for sample in data['_return']['traces']:
for obs in sample['trace']:
# TODO-Detail - put detail re the purpose of obs['q'] - I don't know what/why this
# logic exists, it's obviously to sanitise data but unclear on what/why
# TODO-idiosyncratic: was < 999 prior to refactor, this means that 998 is the max
# accepted number, this would presumably be 999, but I can't say for sure
if int(obs['q']) >= 999:
continue
obsdate = datetime.datetime.strptime(str(obs['t']), '%Y%m%d%H%M%S').date()
objRow = [state, sample['site'], 'WATER', obsdate, obs['v'], obs['q']]
extracted.append(objRow)
except KeyError:
extracted = []
return extracted | eab79571c4dea5d97790031251862d389260c7bf | 9,180 |
from typing import List
def merge(input_list: List, low: int, mid: int, high: int) -> List:
"""
sorting left-half and right-half individually
then merging them into result
"""
result = []
left, right = input_list[low:mid], input_list[mid : high + 1]
while left and right:
result.append((left if left[0] <= right[0] else right).pop(0))
input_list[low : high + 1] = result + left + right
return input_list | 0d53b0670899b4853563c9dda0eb47a8c66bae00 | 9,181 |
def fc_caps(activation_in,
pose_in,
ncaps_out,
name='class_caps',
weights_regularizer=None):
"""Fully connected capsule layer.
"The last layer of convolutional capsules is connected to the final capsule
layer which has one capsule per output class." We call this layer 'fully
connected' because it fits these characteristics, although Hinton et al. do
not use this teminology in the paper.
See Hinton et al. "Matrix Capsules with EM Routing" for detailed description.
Author:
Ashley Gritzman 27/11/2018
Args:
activation_in:
(batch_size, child_space, child_space, child_caps, 1)
(64, 7, 7, 8, 1)
pose_in:
(batch_size, child_space, child_space, child_caps, 16)
(64, 7, 7, 8, 16)
ncaps_out: number of class capsules
name:
weights_regularizer:
Returns:
activation_out:
score for each output class
(batch_size, ncaps_out)
(64, 5)
pose_out:
pose for each output class capsule
(batch_size, ncaps_out, 16)
(64, 5, 16)
"""
with tf.variable_scope(name) as scope:
# Get shapes
shape = pose_in.get_shape().as_list()
batch_size = shape[0]
child_space = shape[1]
child_caps = shape[3]
with tf.variable_scope('v') as scope:
# In the class_caps layer, we apply same multiplication to every spatial
# location, so we unroll along the batch and spatial dimensions
# (64, 5, 5, 32, 16) -> (64*5*5, 32, 16)
pose = tf.reshape(
pose_in,
shape=[batch_size * child_space * child_space, child_caps, 16])
activation = tf.reshape(
activation_in,
shape=[batch_size * child_space * child_space, child_caps, 1],
name="activation")
# (64*5*5, 32, 16) -> (65*5*5, 32, 5, 16)
votes = utl.compute_votes(pose, ncaps_out, weights_regularizer)
# (65*5*5, 32, 5, 16)
assert (
votes.get_shape() ==
[batch_size * child_space * child_space, child_caps, ncaps_out, 16])
logger.info('class_caps votes original shape: {}'
.format(votes.get_shape()))
with tf.variable_scope('coord_add') as scope:
# (64*5*5, 32, 5, 16)
votes = tf.reshape(
votes,
[batch_size, child_space, child_space, child_caps, ncaps_out,
votes.shape[-1]])
votes = coord_addition(votes)
with tf.variable_scope('routing') as scope:
# Flatten the votes:
# Combine the 4 x 4 spacial dimensions to appear as one spacial dimension # with many capsules.
# [64*5*5, 16, 5, 16] -> [64, 5*5*16, 5, 16]
votes_flat = tf.reshape(
votes,
shape=[batch_size, child_space * child_space * child_caps,
ncaps_out, votes.shape[-1]])
activation_flat = tf.reshape(
activation,
shape=[batch_size, child_space * child_space * child_caps, 1])
spatial_routing_matrix = utl.create_routing_map(child_space=1, k=1, s=1)
logger.info('class_caps votes in to routing shape: {}'
.format(votes_flat.get_shape()))
pose_out, activation_out = em.em_routing(votes_flat,
activation_flat,
batch_size,
spatial_routing_matrix)
activation_out = tf.squeeze(activation_out, name="activation_out")
pose_out = tf.squeeze(pose_out, name="pose_out")
logger.info('class_caps activation shape: {}'
.format(activation_out.get_shape()))
logger.info('class_caps pose shape: {}'.format(pose_out.get_shape()))
tf.summary.histogram("activation_out", activation_out)
return activation_out, pose_out | eb190d36c718d0c518b12c172e2a13b49d7ba012 | 9,182 |
def get_optional_relations():
"""Return a dictionary of optional relations.
@returns {relation: relation_name}
"""
optional_interfaces = {}
if relation_ids('ceph'):
optional_interfaces['storage-backend'] = ['ceph']
if relation_ids('neutron-plugin'):
optional_interfaces['neutron-plugin'] = ['neutron-plugin']
if relation_ids('shared-db') or relation_ids('pgsql-db'):
optional_interfaces['database'] = ['shared-db', 'pgsql-db']
return optional_interfaces | bdb1dcd04cfd31130e5463772d3d31f8aac7d894 | 9,183 |
def splitmod(n, k):
"""
Split n into k lists containing the elements of n in positions i (mod k).
Return the heads of the lists and the tails.
"""
heads = [None]*k
tails = [None]*k
i = 0
while n is not None:
if heads[i] is None:
heads[i] = n
if tails[i] is not None:
tails[i].next = n
tails[i] = n
n.next, n = None, n.next
i = (i+1)%k
return heads, tails | a4a1885ce0c9541c534145d0236996a511cbdd00 | 9,184 |
import os
def dirname_to_prefix(dirname):
"""Return filename prefix from dirname"""
return os.path.basename(dirname.strip('/')).split("-", maxsplit=1)[1] | 8e1124e66669dd051987c55812052d36c78bdc4a | 9,185 |
def find_flats(flats, flat2_finder=find_flat2):
"""Find flat pairs."""
file1s = sorted([item.strip() for item in flats
if item.find('flat1') != -1])
return [(f1, flat2_finder(f1)) for f1 in file1s] | 7003bc35ef0ed6a4fe71b1d686b7c46b99e6d8ca | 9,186 |
def binary_accuracy(a,b):
"""
Calculate the binary acc.
"""
return ((a.argmax(dim=1) == b).sum().item()) / a.size(0) | 5f9b09199b2e88169a0cbe9ee7cb4bb351c09e4a | 9,187 |
def add_ice_post_arrow_hq_lq_arguments2(parser):
"""Add quiver QV threshold to mark an isoform as high-quality or low-quality."""
# if isinstance(parser, PbParser):
# #parser = _wrap_parser(parser)
# arg_parser = parser.arg_parser.parser
# tcp = parser.tool_contract_parser
# tcp.add_float(BaseConstants.HQ_ARROW_MIN_ACCURACY_ID, "hq_arrow_min_accuracy",
# default=BaseConstants.HQ_ARROW_MIN_ACCURACY_DEFAULT,
# name="Minimum Quiver|Arrow Accuracy", description=BaseConstants.HQ_ARROW_MIN_ACCURACY_DESC)
# tcp.add_int(BaseConstants.QV_TRIM_FIVEPRIME_ID, "qv_trim_5",
# default=BaseConstants.QV_TRIM_FIVEPRIME_DEFAULT,
# name="Trim QVs 5'", description=BaseConstants.QV_TRIM_FIVEPRIME_DESC)
# tcp.add_int(BaseConstants.QV_TRIM_THREEPRIME_ID, "qv_trim_3",
# default=BaseConstants.QV_TRIM_THREEPRIME_DEFAULT,
# name="Trim QVs 3'", description=BaseConstants.QV_TRIM_THREEPRIME_DESC)
# else:
# assert isinstance(parser, argparse.ArgumentParser)
# arg_parser = parser
arg_parser = parser
icq_gp = arg_parser.add_argument_group("IceArrow High QV/Low QV arguments")
icq_gp.add_argument("--hq_arrow_min_accuracy",
type=float,
default=BaseConstants.HQ_ARROW_MIN_ACCURACY_DEFAULT,
dest="hq_arrow_min_accuracy",
help=BaseConstants.HQ_ARROW_MIN_ACCURACY_DESC)
icq_gp.add_argument("--qv_trim_5",
type=int,
default=BaseConstants.QV_TRIM_FIVEPRIME_DEFAULT,
dest="qv_trim_5",
help=BaseConstants.QV_TRIM_FIVEPRIME_DESC)
icq_gp.add_argument("--qv_trim_3",
type=int,
default=BaseConstants.QV_TRIM_THREEPRIME_DEFAULT,
dest="qv_trim_3",
help=BaseConstants.QV_TRIM_THREEPRIME_DESC)
icq_gp.add_argument("--hq_min_full_length_reads",
type=int,
default=2,
help="Minimum number of FL support to be an HQ isoform (default: 2)")
icq_gp = arg_parser.add_argument_group("IceArrow2 HQ/LQ IO arguments")
icq_gp.add_argument("--hq_isoforms_fa",
default=None,
type=str,
dest="hq_isoforms_fa",
help="Arrow polished, high quality isoforms " +
"in FASTA, default: root_dir/output/all_arrowed_hq.fasta")
icq_gp.add_argument("--hq_isoforms_fq",
default=None,
type=str,
dest="hq_isoforms_fq",
help="Arrow polished, high quality isoforms " +
"in FASTQ, default: root_dir/output/all_arrowed_hq.fastq")
icq_gp.add_argument("--lq_isoforms_fa",
default=None,
type=str,
dest="lq_isoforms_fa",
help="Arrow polished, low quality isoforms " +
"in FASTA, default: root_dir/output/all_arrowed_lq.fasta")
icq_gp.add_argument("--lq_isoforms_fq",
default=None,
type=str,
dest="lq_isoforms_fq",
help="Arrow polished, low quality isoforms " +
"in FASTQ, default: root_dir/output/all_arrowed_lq.fastq")
return parser | f2fabe409df095be26b4085ccbd635e4ab6ce88a | 9,188 |
def dev_step(tset, train_m, test_m, net, dataset, args, nd_possible_rating_values):
"""
Evaluates model on a dev set
"""
batch_size = 256
#print("tset:",tset)
user_te = np.array(list(tset.keys()))
#print("user_te:",user_te)
user_te2 = user_te[:, np.newaxis]
#user_te2 = user_te
ll = int(len(user_te) / batch_size) + 1
recall50 = []
recall100 = []
recall200 = []
ndcg50 = []
ndcg100 = []
ndcg200 = []
for batch_num in range(int(ll)):
print(batch_num/ll*100,"%")
start_index = batch_num * batch_size
end_index = min((batch_num + 1) * batch_size, len(user_te))
# u_batch 是每个batch中的一个对user的一个list
u_batch = user_te2[start_index:end_index]
# batch_users 是这个batch中user的个数
batch_users = end_index - start_index
num_user = train_m.shape[0]#user总数
num_movie = train_m.shape[1]#item总数
user_list = user_te[start_index:end_index]
batch_rating_pairs = generate_pair(user_list, num_movie)
batch_dec_graph = generate_dec_graph(batch_rating_pairs, num_user, num_movie).to(args.device)
Two_Stage = False
pred_ratings, reg_loss, user_out, movie_out, W = net(dataset.train_enc_graph, batch_dec_graph, dataset.user_feature, dataset.movie_feature, Two_Stage)
#pred_ratings = th.softmax(pred_ratings, dim=1)
#print("pred_rating",pred_ratings.shape)
pred_ratings = pred_ratings.cpu().detach().numpy()
#pred_argmax = np.argmax(pred_ratings, axis=1)
pred_index = np.zeros_like(pred_ratings[:,0])
for j in range(len(pred_index)):
#pred_index[j][pred_argmax[j]] = 1
pred_index[j] = pred_ratings[j][1]
#print("pred_rating",pred_index[0:10])
#real_pred_ratings = (th.softmax(pred_ratings, dim=1) * nd_possible_rating_values.view(1, -1)).sum(dim=1)
#real_pred_ratings = (th.from_numpy(pred_index).to(args.device) * nd_possible_rating_values.view(1, -1)).sum(dim=1)
real_pred_ratings = th.from_numpy(pred_index).to(args.device)
print("real_pred_ratings", th.sum(real_pred_ratings>=1))
u_b = user_te[start_index:end_index]
real_pred_ratings = real_pred_ratings.cpu()
#print("pred_shape:", real_pred_ratings.shape)
pre = real_pred_ratings.reshape(batch_users, -1)
#print("pred_shape:", pre.shape)
#pre = np.reshape(real_pred_ratings, (batch_users, num_movie))
pre = pre.detach().numpy()
idx = np.zeros_like(pre, dtype=bool)
idx[train_m[u_b].nonzero()] = True
pre[idx] = -np.inf
recall = []
for kj in [50, 100, 200]:
idx_topk_part = np.argpartition(-pre, kj, 1)
# print pre[np.arange(batch_users)[:, np.newaxis], idx_topk_part[:, :kj]]
# print idx_topk_part
pre_bin = np.zeros_like(pre, dtype=bool)
pre_bin[np.arange(batch_users)[:, np.newaxis], idx_topk_part[:, :kj]] = True
# print pre_bin
true_bin = np.zeros_like(pre, dtype=bool)
true_bin[test_m[u_b].nonzero()] = True
tmp = (np.logical_and(true_bin, pre_bin).sum(axis=1)).astype(np.float32)
#print("tmp:",tmp)
recall.append(tmp / np.minimum(kj, true_bin.sum(axis=1)))
#print("recall:",tmp / np.minimum(kj, true_bin.sum(axis=1)))
# print tmp
#print("recall:",recall)
ndcg = []
for kj in [50, 100, 200]:
# 获取前20个元素的大致序号
idx_topk_part = np.argpartition(-pre, kj, 1)
#print("pre:",pre.shape)
#
#print("idx_topk_part[:, :kj]:",idx_topk_part[:, :kj])
#获取每个用户对应的前20个预测的index
topk_part = pre[np.arange(batch_users)[:, np.newaxis], idx_topk_part[:, :kj]]
#print("topk_part:",topk_part[0:2])
idx_part = np.argsort(-topk_part, axis=1)
# 将预测分数进行排序，从大到校输出index的值
#print("idx_part:",idx_part[0:2])
idx_topk = idx_topk_part[np.arange(end_index - start_index)[:, np.newaxis], idx_part]
# 得到原来的序列中的对应index
#print("idx_topk:",idx_topk[0:2])
tp = np.log(2) / np.log(np.arange(2, kj + 2))
test_batch = test_m[u_b]
#print("test_batch:",test_batch)
DCG = (test_batch[np.arange(batch_users)[:, np.newaxis], idx_topk].toarray() * tp).sum(axis=1)
# 就只计算真实结果在预测结果中的第几号的dcg
#print("tp:",tp)
#print("DCG:",DCG)
IDCG = np.array([(tp[:min(n, kj)]).sum()
for n in test_batch.getnnz(axis=1)])
#print("IDCG:",np.array([(tp[:min(n, kj)]).sum()
# for n in test_batch.getnnz(axis=1)]))
ndcg.append(DCG / IDCG)
#print("ndcg:",ndcg)
recall50.append(recall[0])
recall100.append(recall[1])
recall200.append(recall[2])
ndcg50.append(ndcg[0])
ndcg100.append(ndcg[1])
ndcg200.append(ndcg[2])
recall50 = np.hstack(recall50)
recall100 = np.hstack(recall100)
recall200 = np.hstack(recall200)
ndcg50 = np.hstack(ndcg50)
ndcg100 = np.hstack(ndcg100)
ndcg200 = np.hstack(ndcg200)
print("recall50:",recall50[0:10])
print("ndcg50:", ndcg50.shape)
print("recall50:", np.mean(recall50), "ndcg50:",np.mean(ndcg50))
print("recall100:",np.mean(recall100),"ndcg100:", np.mean(ndcg100))
print("recall200:",np.mean(recall200), "ndcg200:",np.mean(ndcg200))
#f1.write(str(np.mean(recall100)) + ' ' + str(np.mean(ndcg100)) + '\n')
#f1.flush()
return np.mean(recall50), np.mean(recall100), np.mean(recall200), np.mean(ndcg50), np.mean(ndcg100), np.mean(ndcg200) | 73c77d15d4221a0116454e06f3d7823ffc66a323 | 9,189 |
def email_change_view(request, extra_context={},
success_url='email_verification_sent',
template_name='email_change/email_change_form.html',
email_message_template_name='email_change_request',
form_class=EmailChangeForm):
"""Allow a user to change the email address associated with the
user account.
"""
if request.method == 'POST':
form = form_class(username=request.user.username,
data=request.POST,
files=request.FILES)
if form.is_valid():
email = form.cleaned_data.get('email')
# First clean all email change requests made by this user
# Except subscription email validation
qs = EmailChangeRequest.objects.filter(user=request.user) \
.exclude(email=request.user.email)
qs.delete()
# Create an email change request
email_request = EmailChangeRequest.objects.create(
user=request.user,
email=email
)
email_request.send(email_message_template_name)
return redirect(success_url)
else:
form = form_class(username=request.user.username)
context = RequestContext(request, extra_context)
context['form'] = form
return render_to_response(template_name, context_instance=context) | 1b54394a04d07bea0d121574b71ba6a1a840f401 | 9,190 |
def check_is_pair(record1, record2):
"""Check if the two sequence records belong to the same fragment.
In an matching pair the records are left and right pairs
of each other, respectively. Returns True or False as appropriate.
Handles both Casava formats: seq/1 and seq/2, and 'seq::... 1::...'
and 'seq::... 2::...'.
"""
if hasattr(record1, 'quality') or hasattr(record2, 'quality'):
if not (hasattr(record1, 'quality') and hasattr(record2, 'quality')):
raise ValueError("both records must be same type (FASTA or FASTQ)")
lhs1, rhs1 = _split_left_right(record1.name)
lhs2, rhs2 = _split_left_right(record2.name)
# handle 'name/1'
if lhs1.endswith('/1') and lhs2.endswith('/2'):
subpart1 = lhs1.split('/', 1)[0]
subpart2 = lhs2.split('/', 1)[0]
assert subpart1
if subpart1 == subpart2:
return True
# handle '@name 1:rst'
elif lhs1 == lhs2 and rhs1.startswith('1:') and rhs2.startswith('2:'):
return True
return False | 225cd65d8c33968556c04a67ba304ebbc65ad4f2 | 9,191 |
import bz2
def decompress_bzip2_from_hdu(hdu):
"""Decompress data in a PyFits HDU object using libz2.
"""
data = hdu.data.field(0)
source_type = np.dtype(hdu.header['PCSRCTP'])
return (np.fromstring(bz2.decompress(data.tostring()),
dtype=source_type),
numpy_type_to_fits_type(source_type)) | 0fb99decefdc70ae082728c2d5b1228f79d13264 | 9,192 |
def grid_values(grid):
"""
Convert grid into a dict of {square: char} with '123456789' for empties.
Args:
grid : string
A grid in string form.
Returns:
grid : dict
Keys are the boxes (e.g., 'A1').
Values are the values in each box (e.g., '8').
If the box has no value, then the value will be '123456789'.
"""
# Change assertion for different-sized grids
assert len(grid) == 81
digits = '123456789'
values = []
for c in grid:
if c == '.':
values.append(digits)
elif c in digits:
values.append(c)
# Sanity check that values is size it should be
assert len(values) == 81
return dict(zip(boxes, values)) | 560fb700d6fc91b3ab94c2a5573a82d92ac4eb9d | 9,193 |
from typing import List
import re
def get_ftp_files(build_type, tag_name, config) -> List[ReleaseFile] :
"""!
@brief Gets file metadata for nightlies hosted on FTP, as determined by config["ftp"] attributes
@param [in] `build_type` Unknown str
@param [in] `tag_name` Github tag name of the release
@param [in] `config` config metadata set in main.py
"""
tag_regex = re.compile("nightly_(.*)")
build_group_regex = re.compile("nightly_.*-builds-([^.]+).*")
files = []
try:
with FTP(config["ftp"]["host"], config["ftp"]["user"], config["ftp"]["pass"]) as ftp:
# extract version
version_str = tag_regex.match(tag_name).group(1)
# extract filepath w/ version
# then list all ftp hits with that path
path_template = config["ftp"]["path"]
path = path_template.format(type=build_type, version=version_str)
file_entries = list(ftp.mlsd(path, ["type"]))
# get all ftp hits of type file
for entry in file_entries:
if entry[1]["type"] == "file":
files.append(entry[0])
except error_perm:
print("Received permanent FTP error!")
return []
out_data = []
for file in files:
# from the file list, extract only nightly files
file_match = build_group_regex.match(file)
if file_match is None:
print("Ignoring non nightly file '{}'".format(file))
continue
group_match = file_match.group(1)
primary_url = None
mirrors = []
# x64 is the name Visual Studio uses but Win64 works better for us since that gets displayed in the nightly post
if "x64" in group_match:
group_match = group_match.replace("x64", "Win64")
# construct the download URL list for all mirrors. The first listed ftp location is taken as the Primary
for mirror in config["ftp"]["mirrors"]:
download_url = mirror.format(type=build_type, version=version_str, file=file)
if primary_url is None:
primary_url = download_url
else:
mirrors.append(download_url)
# Form the List[ReleaseFile] list with the download URL links
out_data.append(ReleaseFile(file, primary_url, group_match, None, mirrors))
return out_data | f56bc55df5a7880f215c3ebd0a1eeb6796840798 | 9,194 |
def variables(i, o):
""" WRITEME
:type i: list
:param i: input L{Variable}s
:type o: list
:param o: output L{Variable}s
:returns:
the set of Variables that are involved in the subgraph that lies between i and o. This
includes i, o, orphans(i, o) and all values of all intermediary steps from i to o.
"""
return variables_and_orphans(i, o)[0] | 18f07280dae8471cd9c4f447061342d733e7b3c7 | 9,195 |
def new_instance(): # display_callback=None):
"""
Create a new instance of Ghostscript
This instance is passed to most other API functions.
"""
# :todo: The caller_handle will be provided to callback functions.
display_callback=None
instance = gs_main_instance()
rc = libgs.gsapi_new_instance(pointer(instance), display_callback)
if rc != 0:
raise GhostscriptError(rc)
return instance | abc87b413f26366ae91c7f30b84332e81f55c095 | 9,196 |
def ldns_resolver_dnssec_cd(*args):
"""LDNS buffer."""
return _ldns.ldns_resolver_dnssec_cd(*args) | eeaa2f7e7d385d64c575926f93247ad44594d09e | 9,197 |
def spf_record_for(hostname, bypass_cache=True):
"""Retrieves SPF record for a given hostname.
According to the standard, domain must not have multiple SPF records, so
if it's the case then an empty string is returned.
"""
try:
primary_ns = None
if bypass_cache:
primary_ns = get_primary_nameserver(hostname)
txt_records = query_dns(hostname, 'txt', primary_ns)
spf_records = [r for r in txt_records if r.strip().startswith('v=spf')]
if len(spf_records) == 1:
return spf_records[0]
except Exception as e:
log.exception(e)
return '' | 5013285bb291a22d8ce2565dd605b16b9c730bba | 9,198 |
import os
def raw_to_df(
rawfile: os.PathLike,
n_channels: int = 2048,
fmt: np.dtype = ">i8",
order: str = "F",
) -> pd.DataFrame:
"""Read a binary raw data file, and returns a dataframe."""
bin_raw = read_file(rawfile, "rb")
dt = np.dtype(fmt)
np_data = np.frombuffer(bin_raw, dtype=dt)
bytes_per_data = dt.alignment
total_bytes = len(bin_raw)
n_records = int(total_bytes / n_channels / bytes_per_data)
np_data = np_data.reshape(n_channels, n_records, order=order)
return pd.DataFrame(np_data) | 56abdf1e3e1aedaa3d2f3ef3f8e87dff05740f29 | 9,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.