content
stringlengths 35
762k
| sha1
stringlengths 40
40
| id
int64 0
3.66M
|
|---|---|---|
def atomic_coordinates_as_json(pk):
"""Get atomic coordinates from database."""
subset = models.Subset.objects.get(pk=pk)
vectors = models.NumericalValue.objects.filter(
datapoint__subset=subset).filter(
datapoint__symbols__isnull=True).order_by(
'datapoint_id', 'counter')
data = {'vectors':
[[x.formatted('.10g') for x in vectors[:3]],
[x.formatted('.10g') for x in vectors[3:6]],
[x.formatted('.10g') for x in vectors[6:9]]]}
# Here counter=1 filters out the first six entries
symbols = models.Symbol.objects.filter(
datapoint__subset=subset).filter(counter=1).order_by(
'datapoint_id').values_list('value', flat=True)
coords = models.NumericalValue.objects.filter(
datapoint__subset=subset).filter(
datapoint__symbols__counter=1).select_related('error').order_by(
'counter', 'datapoint_id')
tmp = models.Symbol.objects.filter(
datapoint__subset=subset).annotate(
num=models.models.Count('datapoint__symbols')).filter(
num=2).first()
if tmp:
data['coord-type'] = tmp.value
data['coordinates'] = []
N = int(len(coords)/3)
for symbol, coord_x, coord_y, coord_z in zip(
symbols, coords[:N], coords[N:2*N], coords[2*N:3*N]):
data['coordinates'].append((symbol,
coord_x.formatted('.9g'),
coord_y.formatted('.9g'),
coord_z.formatted('.9g')))
return data | 515854e789a15e845b0dbcd754e17bedfc0bcf69 | 11,000 |
def additional_bases():
""""Manually added bases that cannot be retrieved from the REST API"""
return [
{
"facility_name": "Koltyr Northern Warpgate",
"facility_id": 400014,
"facility_type_id": 7,
"facility_type": "Warpgate"
},
{
"facility_name": "Koltyr Eastern Warpgate",
"facility_id": 400015,
"facility_type_id": 7,
"facility_type": "Warpgate"
},
{
"facility_name": "Koltyr Southern Warpgate",
"facility_id": 400016,
"facility_type_id": 7,
"facility_type": "Warpgate"
},
{
"facility_name": "Zorja",
"facility_id": 400017,
"facility_type_id": 2,
"facility_type": "Amp Station"
},
{
"facility_name": "Xander",
"facility_id": 400018,
"facility_type_id": 3,
"facility_type": "Bio Lab"
},
{
"facility_name": "Svarog",
"facility_id": 400019,
"facility_type_id": 4,
"facility_type": "Tech Plant"
},
{
"facility_name": "Koltyr Tech Plant Outpost",
"facility_id": 400020,
"facility_type_id": 5,
"facility_type": "Large Outpost"
},
{
"facility_name": "Koltyr Biolab Outpost",
"facility_id": 400021,
"facility_type_id": 5,
"facility_type": "Large Outpost"
},
{
"facility_name": "Koltyr Amp Station Outpost",
"facility_id": 400022,
"facility_type_id": 5,
"facility_type": "Large Outpost"
}
] | e2a5ad97ca1b424466f5ebe340466eaf9f627e7e | 11,001 |
def get_all_label_values(dataset_info):
"""Retrieves possible values for modeled labels from a `Seq2LabelDatasetInfo`.
Args:
dataset_info: a `Seq2LabelDatasetInfo` message.
Returns:
A dictionary mapping each label name to a tuple of its permissible values.
"""
return {
label_info.name: tuple(label_info.values)
for label_info in dataset_info.labels
} | 929db286b3f7ee8917618e9f46feabdff630d3b2 | 11,002 |
def load_input(file: str) -> ArrayLike:
"""Load the puzzle input and duplicate 5 times in each direction,
adding 1 to the array for each copy.
"""
input = puzzle_1.load_input(file)
input_1x5 = np.copy(input)
for _ in range(4):
input = np.clip(np.mod(input + 1, 10), a_min=1, a_max=None)
input_1x5 = np.concatenate([input_1x5, input], axis=1)
input_5x5 = np.copy(input_1x5)
for _ in range(4):
input_1x5 = np.clip(np.mod(input_1x5 + 1, 10), a_min=1, a_max=None)
input_5x5 = np.concatenate([input_5x5, input_1x5], axis=0)
return input_5x5 | 91b2cd7854a793ebbbfee2400eddb22304fc18bd | 11,003 |
def _get_xvals(end, dx):
"""Returns a integer numpy array of x-values incrementing by "dx"
and ending with "end".
Args:
end (int)
dx (int)
"""
arange = np.arange(0, end-1+dx, dx, dtype=int)
xvals = arange[1:]
return xvals | 24a4d7b7c470abb881700a1775008d16c35c1fc3 | 11,004 |
import torch
def top_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k, top-p (nucleus) and/or threshold filtering
Args:
logits: logits distribution shape (vocabulary size)
top_k: <=0: no filtering, >0: keep only top k tokens with highest probability.
top_p: <=0.0: no filtering, >0.0: keep only a subset S of candidates, where S is the smallest subset
whose total probability mass is greater than or equal to the threshold top_p.
In practice, we select the highest probability tokens whose cumulative probability mass exceeds
the threshold top_p.
"""
# batch support!
if top_k > 0:
values, _ = torch.topk(logits, top_k)
min_values = values[:, -1].unsqueeze(1).repeat(1, logits.shape[-1])
logits = torch.where(logits < min_values,
torch.ones_like(logits, dtype=logits.dtype) * -float('Inf'),
logits)
if top_p > 0.0:
# Compute cumulative probabilities of sorted tokens
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probabilities = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probabilities > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
sorted_logits = sorted_logits.masked_fill_(sorted_indices_to_remove, filter_value)
logits = torch.zeros_like(logits).scatter(1, sorted_indices, sorted_logits)
return logits | 5cbbd9959a80e72364f098fe031e5e3c78485826 | 11,005 |
def get_reference_shift( self, seqID ):
"""Get a ``reference_shift`` attached to a particular ``seqID``.
If none was provided, it will return **1** as default.
:param str seqID: |seqID_param|.
:type shift: Union[:class:`int`, :class:`list`]
:raises:
:TypeError: |indf_error|.
.. rubric:: Example
.. ipython::
In [1]: from rstoolbox.io import parse_rosetta_file
...: import pandas as pd
...: pd.set_option('display.width', 1000)
...: pd.set_option('display.max_columns', 500)
...: df = parse_rosetta_file("../rstoolbox/tests/data/input_ssebig.minisilent.gz",
...: {'sequence': 'C', 'structure': 'C'})
...: df.add_reference_structure('C', df.iloc[0].get_structure('C'))
...: df.add_reference_shift('C', 3)
...: df.get_reference_shift('C')
"""
if not isinstance(self, (pd.DataFrame, pd.Series)):
raise TypeError("Data container has to be a DataFrame/Series or a derived class.")
if self._subtyp != "sequence_frame" and (seqID not in self.get_available_structures() and
seqID not in self.get_available_sequences()):
raise KeyError("Data container does not have data for structure {}".format(seqID))
if seqID in self._reference:
return self._reference[seqID]["sft"]
else:
return 1 | 4a8f9fe683c9cf0085754ca2ebb9132bbae427ea | 11,006 |
import os
import sys
def which(cmd, mode=os.F_OK | os.X_OK, path=None):
"""Given a command, mode, and a PATH string, return the path which
conforms to the given mode on the PATH, or None if there is no such
file.
`mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
of os.environ.get("PATH"), or can be overridden with a custom search
path.
"""
# Check that a given file can be accessed with the correct mode.
# Additionally check that `file` is not a directory, as on Windows
# directories pass the os.access check.
def _access_check(fn, mode):
return (os.path.exists(fn) and os.access(fn, mode) and
not os.path.isdir(fn))
# Short circuit. If we're given a full path which matches the mode
# and it exists, we're done here.
if _access_check(cmd, mode):
return cmd
path = (path or os.environ.get("PATH", os.defpath)).split(os.pathsep)
if sys.platform == "win32":
# The current directory takes precedence on Windows.
if os.curdir not in path:
os.sys.path.insert(0, os.curdir)
# PATHEXT is necessary to check on Windows.
pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
# See if the given file matches any of the expected path extensions.
# This will allow us to short circuit when given "python.exe".
matches = [cmd for ext in pathext if cmd.lower().endswith(ext.lower())]
# If it does match, only test that one, otherwise we have to try
# others.
files = [cmd] if matches else [cmd + ext.lower() for ext in pathext]
else:
# On other platforms you don't have things like PATHEXT to tell you
# what file suffixes are executable, so just pass on cmd as-is.
files = [cmd]
seen = set()
for dir in path:
dir = os.path.normcase(dir)
if dir not in seen:
seen.add(dir)
for thefile in files:
name = os.path.join(dir, thefile)
if _access_check(name, mode):
return name
return None | 31fff48dd7984de5008bedf8a1da9687111fcfbf | 11,007 |
def load_and_resolve_feature_metadata(eval_saved_model_path: Text,
graph: tf.Graph):
"""Get feature data (feature columns, feature) from EvalSavedModel metadata.
Like load_feature_metadata, but additionally resolves the Tensors in the given
graph.
Args:
eval_saved_model_path: Path to EvalSavedModel, for the purposes of loading
the feature_metadata file.
graph: tf.Graph to resolve the Tensors in.
Returns:
Same as load_feature_metadata, except associated_tensors and features
contain the Tensors resolved in the graph instead of TensorInfos.
"""
result = load_feature_metadata(eval_saved_model_path=eval_saved_model_path)
# Resolve Tensors in graph
result['associated_tensors'] = [
tf.compat.v1.saved_model.get_tensor_from_tensor_info(tensor_info, graph)
for tensor_info in result['associated_tensors']
]
result['features'] = {
k: tf.compat.v1.saved_model.get_tensor_from_tensor_info(v, graph)
for k, v in result['features'].items()
}
return result | 3377d66c962ccccab7b62abf563f88032a8a7b14 | 11,008 |
def greater_than_or_eq(quant1, quant2):
"""Binary function to call the operator"""
return quant1 >= quant2 | 920c28da125b567bc32a149aec6aaade3645ef87 | 11,009 |
def pr_define_role(pe_id,
role=None,
role_type=None,
entity_type=None,
sub_type=None):
"""
Back-end method to define a new affiliates-role for a person entity
@param pe_id: the person entity ID
@param role: the role name
@param role_type: the role type (from pr_role_types), default 9
@param entity_type: limit selection in CRUD forms to this entity type
@param sub_type: limit selection in CRUD forms to this entity sub-type
@return: the role ID
"""
if not pe_id:
return None
s3db = current.s3db
if role_type not in s3db.pr_role_types:
role_type = 9 # Other
data = {"pe_id": pe_id,
"role": role,
"role_type": role_type,
"entity_type": entity_type,
"sub_type": sub_type}
rtable = s3db.pr_role
if role:
query = (rtable.pe_id == pe_id) & \
(rtable.role == role)
duplicate = current.db(query).select(rtable.id,
rtable.role_type,
limitby=(0, 1)).first()
else:
duplicate = None
if duplicate:
if duplicate.role_type != role_type:
# Clear paths if this changes the role type
if str(role_type) != str(OU):
data["path"] = None
s3db.pr_role_rebuild_path(duplicate.id, clear=True)
duplicate.update_record(**data)
record_id = duplicate.id
else:
record_id = rtable.insert(**data)
return record_id | 3f09ac9eca47347b51069a20b7b08b2192e2d452 | 11,010 |
def inherently_superior(df):
"""
Find rows in a dataframe with all values 'inherently superior',
meaning that all values for certain metrics are as high or higher
then for all other rows.
Parameters
----------
df : DataFrame
Pandas dataframe containing the columns to be compared. The columns
should be in a format in which higher values are superior.
Returns
-------
DataFrame with index of best values and values compared.
"""
# Copy dataframe to prevent altering the columns.
df_copy = df.copy()
# Reset index to reference location of values. Also, convert to numpy.
df_copy.reset_index(inplace=True)
arr = df_copy.values
# Repeat and tile the array for comparison. Given indices [1, 2], arr1 is
# in format [1, 1, 2, 2], and arr2 is in format [1, 2, 1, 2].
arr1 = np.repeat(arr, arr.shape[0], axis=0)
arr2 = np.tile(arr, (arr.shape[0], 1))
# Check if any values are greater than for other rows.
any_arr = np.all(arr1[:, 1:] >= arr2[:, 1:], axis=1)
# Adjust array so that all points at which a row is being compared to itself
# are labeled as superior.
same_idx = np.array(range(0, len(any_arr), arr.shape[0])) + np.array(range(arr.shape[0]))
any_arr[same_idx] = 1
# Concatenate arr1 and array with superior labels.
arr1_any = np.concatenate([arr1, any_arr.reshape(-1, 1)], axis=1)
# Split data at unique indices. Used to check if greater than all other rows.
splits = np.array(np.split(arr1_any, np.unique(arr1[:, 0], return_index=True)[1][1:]))
perc_sup = np.mean(splits[:, :, -1], axis=1)
idx = np.all(splits[:, :, -1], axis=1)
# Choose superior data idx and create dataframe.
columns = df_copy.columns.tolist() + ['perc_sup', 'fully_sup']
data = np.concatenate([arr, perc_sup.reshape(-1, 1), idx.reshape(-1, 1)], axis=1)
arr_df = pd.DataFrame(data, columns=columns)
arr_df.drop('index', axis=1, inplace=True)
arr_df['fully_sup'] = arr_df['fully_sup'].astype(bool)
return arr_df | 02dd6db624efd4f1daa4c0ef4f126c6c60c0376e | 11,011 |
def LineColourArray():
"""Line colour options array"""
Colour = [
'Black',
'dimgrey',
'darkgrey',
'silver',
'lightgrey',
'maroon',
'darkred',
'firebrick',
'red',
'orangered',
'darkorange',
'orange',
'saddlebrown',
'darkgoldenrod',
'goldenrod',
'gold',
'darkolivegreen',
'olivedrab',
'olive',
'y',
'darkkhaki',
'khaki',
'darkgreen',
'Green',
'limegreen',
'lime',
'mediumspringgreen',
'palegreen',
'greenyellow',
'midnightblue',
'navy',
'darkblue',
'mediumblue',
'blue',
'slateblue',
'indigo',
'purple',
'darkmagenta',
'darkorchid',
'mediumorchid',
'orchid',
'plum',
'crimson',
'deeppink',
'magenta',
'hotpink',
'pink' ]
return Colour | 94f91d17c6e539983ab38ca7fdadd211e6268bfb | 11,012 |
import errno
def os_to_maestral_error(exc, dbx_path=None, local_path=None):
"""
Gets the OSError and tries to add a reasonably informative error message.
.. note::
The following exception types should not typically be raised during syncing:
InterruptedError: Python will automatically retry on interrupted connections.
NotADirectoryError: If raised, this likely is a Maestral bug.
IsADirectoryError: If raised, this likely is a Maestral bug.
:param OSError exc: Python Exception.
:param str dbx_path: Dropbox path of file which triggered the error.
:param str local_path: Local path of file which triggered the error.
:returns: :class:`MaestralApiError` instance or :class:`OSError` instance.
"""
title = 'Cannot upload or download file'
if isinstance(exc, PermissionError):
err_cls = InsufficientPermissionsError # subclass of SyncError
text = 'Insufficient read or write permissions for this location.'
elif isinstance(exc, FileNotFoundError):
err_cls = NotFoundError # subclass of SyncError
text = 'The given path does not exist.'
elif isinstance(exc, FileExistsError):
err_cls = ExistsError # subclass of SyncError
title = 'Could not download file'
text = 'There already is an item at the given path.'
elif isinstance(exc, IsADirectoryError):
err_cls = IsAFolderError # subclass of SyncError
text = 'The given path refers to a folder.'
elif isinstance(exc, NotADirectoryError):
err_cls = NotAFolderError # subclass of SyncError
text = 'The given path refers to a file.'
elif exc.errno == errno.ENAMETOOLONG:
err_cls = PathError # subclass of SyncError
title = 'Could not create local file'
text = 'The file name (including path) is too long.'
elif exc.errno == errno.EFBIG:
err_cls = FileSizeError # subclass of SyncError
title = 'Could not download file'
text = 'The file size too large.'
elif exc.errno == errno.ENOSPC:
err_cls = InsufficientSpaceError # subclass of SyncError
title = 'Could not download file'
text = 'There is not enough space left on the selected drive.'
elif exc.errno == errno.ENOMEM:
err_cls = OutOfMemoryError # subclass of MaestralApiError
text = 'Out of memory. Please reduce the number of memory consuming processes.'
else:
return exc
return err_cls(title, text, dbx_path=dbx_path, local_path=local_path) | 7a99ce147e2fbe0a3cc94535ee1d84c9337b3791 | 11,013 |
from typing import Any
def parse_ccu_sys_var(data: dict[str, Any]) -> tuple[str, Any]:
"""Helper to parse type of system variables of CCU."""
# pylint: disable=no-else-return
if data[ATTR_TYPE] == ATTR_HM_LOGIC:
return data[ATTR_NAME], data[ATTR_VALUE] == "true"
if data[ATTR_TYPE] == ATTR_HM_ALARM:
return data[ATTR_NAME], data[ATTR_VALUE] == "true"
elif data[ATTR_TYPE] == ATTR_HM_NUMBER:
return data[ATTR_NAME], float(data[ATTR_VALUE])
elif data[ATTR_TYPE] == ATTR_HM_LIST:
return data[ATTR_NAME], int(data[ATTR_VALUE])
return data[ATTR_NAME], data[ATTR_VALUE] | 8b77dbbaa93739457a2e92aad79ac5b6bd3a6af0 | 11,014 |
def one_time_log_fixture(request, workspace) -> Single_Use_Log:
"""
Pytest Fixture for setting up a single use log file
At test conclusion, runs the cleanup to delete the single use text file
:return: Single_Use_Log class
"""
log_class = Single_Use_Log(workspace)
request.addfinalizer(log_class.cleanup)
return log_class | 73332892ece76ee90c15d84294b70d935e8a2f4c | 11,015 |
import json
def details(request, path):
"""
Returns detailed information on the entity at path.
:param path: Path to the entity (namespaceName/.../.../.../)
:return: JSON Struct: {property1: value, property2: value, ...}
"""
item = CACHE.get(ENTITIES_DETAIL_CACHE_KEY)
# ENTITIES_DETAIL : {"namespaceName": {"name":"", "description": "", "stream":{}, "artifact":"", "dataset":"",
# "application":""}, {}...} Each part in path.split('/') matches the key name in ENTITIES_DETAIL
# The detailed information of entity at path stores in the last dict
for k in path.strip('/').split('/'):
item = item[k]
item["privileges"] = _get_privileges_for_path(request.user, path)
return HttpResponse(json.dumps(item), content_type='application/json') | b460dc76f18f35b48509a1b2d8daa104bc89fbb5 | 11,016 |
def ca_get_container_capability_set(slot, h_container):
"""
Get the container capabilities of the given slot.
:param int slot: target slot number
:param int h_container: target container handle
:return: result code, {id: val} dict of capabilities (None if command failed)
"""
slot_id = CK_SLOT_ID(slot)
cont_id = CK_ULONG(h_container)
cap_ids = AutoCArray()
cap_vals = AutoCArray()
@refresh_c_arrays(1)
def _get_container_caps():
"""Closer for retries to work w/ properties"""
return CA_GetContainerCapabilitySet(
slot_id, cont_id, cap_ids.array, cap_ids.size, cap_vals.array, cap_vals.size
)
ret = _get_container_caps()
return ret, dict(list(zip(cap_ids, cap_vals))) | cf97db8f201d0c5fce12902b92abdc3a819ac394 | 11,017 |
def load_pyfunc(model_file):
"""
Loads a Keras model as a PyFunc from the passed-in persisted Keras model file.
:param model_file: Path to Keras model file.
:return: PyFunc model.
"""
return _KerasModelWrapper(_load_model(model_file)) | eb21f47a55f35bf3707ba7c5cb56e72948d24866 | 11,018 |
def business_days(start, stop):
"""
Return business days between two datetimes (inclusive).
"""
return dt_business_days(start.date(), stop.date()) | 1fa8c38e6cceca448bc988cd0c1eb24a27508a78 | 11,019 |
def empty_nzb_document():
""" Creates xmldoc XML document for a NZB file. """
# http://stackoverflow.com/questions/1980380/how-to-render-a-doctype-with-pythons-xml-dom-minidom
imp = minidom.getDOMImplementation()
dt = imp.createDocumentType("nzb", "-//newzBin//DTD NZB 1.1//EN",
"http://www.newzbin.com/DTD/nzb/nzb-1.1.dtd")
doc = imp.createDocument("http://www.newzbin.com/DTD/2003/nzb", "nzb", dt)
# http://stackoverflow.com/questions/2306149/how-to-write-xml-elements-with-namespaces-in-python
doc.documentElement.setAttribute('xmlns',
'http://www.newzbin.com/DTD/2003/nzb')
return doc | 7cd8aa73f201b4f432aa6adaed18d133ec08fa48 | 11,020 |
def get_output_directory(create_statistics=None, undersample=None, oversample=None):
"""
Determines the output directory given the balance of the dataset as well as columns.
Parameters
----------
create_statistics: bool
Whether the std, min and max columns have been created
undersample: bool
Whether the data has been undersampled
oversample: bool
Whether the data has been oversampled
Returns
-------
Output directory
"""
if create_statistics is None:
create_statistics = AppConfig.create_statistics
if undersample is None:
undersample = AppConfig.balance_data
if oversample is None:
oversample = AppConfig.oversample
stat = 'st' if create_statistics else 'ns'
bal = 'us' if undersample else 'ub'
bal = 'os' if oversample else bal
return f'./output/{stat}_{bal}/' | c10859e1eba4afb61d967e56be8a8206f5202618 | 11,021 |
def removePrefixes(word, prefixes):
"""
Attempts to remove the given prefixes from the given word.
Args:
word (string): Word to remove prefixes from.
prefixes (collections.Iterable or string): Prefixes to remove from given word.
Returns:
(string): Word with prefixes removed.
"""
if isinstance(prefixes, str):
return word.split(prefixes)[-1]
for prefix in prefixes:
word = word.split(prefix)[-1]
return word | 6932e5605b11eee004a350c7f9be831d8bb7ca9d | 11,022 |
def isSol(res):
"""
Check if the string is of the type ai bj ck
"""
if not res or res[0] != 'a' or res[-1] != 'c':
return False
l = 0
r = len(res)-1
while res[l] == "a":
l+=1
while res[r] == "c":
r-=1
if r-l+1 <= 0:
return False
for x in res[l:r-l+1]:
if x != 'b':
return False
return True | 14030e52a588dc13029602e81a5f2068707bca17 | 11,023 |
import pandas
def _h1_to_dataframe(h1: Histogram1D) -> pandas.DataFrame:
"""Convert histogram to pandas DataFrame."""
return pandas.DataFrame(
{"frequency": h1.frequencies, "error": h1.errors},
index=binning_to_index(h1.binning, name=h1.name),
) | 28aa8cc36abd21a17e0a30f4bde2bb996753864b | 11,024 |
def wgt_area_sum(data, lat_wgt, lon_wgt):
"""wgt_area_sum() performas weighted area addition over a geographical area.
data: data of which last 2 dimensions are lat and lon. Strictly needs to be a masked array
lat_wgt: weights over latitude of area (usually cos(lat * pi/180))
lon_wgt: weights over longitude of area (usually 1)
Returns, Numpy array with 2 less dimensions (Masked array.
Mask is False if no mask was supplied with the input data.
Else mask is derived from the input data)"""
# Get data shape
shp = data.shape
ndims = data.ndim
if(isinstance(lat_wgt, float)):
lat_wgt = [lat_wgt] * shp[ndims - 2]
if(isinstance(lon_wgt, float)):
lon_wgt = [lon_wgt] * shp[ndims - 1]
lat_wgt = np.array(lat_wgt).reshape(len(lat_wgt), 1)
lon_wgt = np.array(lon_wgt)
# Make grid of lon_wgt, lat_wgt with lat and lon coordinates (last 2 axis of data)
wy = np.broadcast_to(lon_wgt, data.shape[ndims - 2:ndims])
wx = np.broadcast_to(lat_wgt, data.shape[ndims - 2:ndims])
# Mask the array
# Get 2D mask from the array
ds = data[0]
for el in shp[1:ndims-2]:
ds = ds[0]
if(isinstance(ds, np.ma.masked_array)):
msk = ds.mask
else:
msk = False
wy = np.ma.masked_array(wy, msk)
wx = np.ma.masked_array(wx, msk)
data_wgt = data * wy * wx
sm_wgt = data_wgt.sum(axis = (ndims - 2, ndims - 1))
# sm_wgt = sm_wgt/np.sum(wy * wx)
return sm_wgt | 725f7f199e634cf56afb846ebff2a0917a92c685 | 11,025 |
import os
def get_files_from_path(path, recurse=False, full_path=True):
"""
Get Files_Path From Input Path
:param full_path: Full path flag
:param path: Input Path
:param recurse: Whether Recursive
:return: List of Files_Path
"""
files_path_list = []
if not os.path.exists(path):
return []
dir_list = SimpleProgressBar(os.listdir(path))
dir_list.show_title("Processing")
for file_path in dir_list:
if full_path:
file_path = os.path.join(path, file_path)
if os.path.isdir(file_path):
if recurse:
files_path_list += get_files_from_path(file_path, recurse=True)
else:
pass
else:
files_path_list.append(file_path)
return files_path_list | 156088cd175a24bdb0bdd04c00fa6229470aab1f | 11,026 |
def load(filename):
"""Load the labels and scores for Hits at K evaluation.
Loads labels and model predictions from files of the format:
Query \t Example \t Label \t Score
:param filename: Filename to load.
:return: list_of_list_of_labels, list_of_list_of_scores
"""
result_labels = []
result_scores = []
current_block_name = ""
current_block_scores = []
current_block_labels = []
with open(filename,'r') as fin:
for line in fin:
splt = line.strip().split("\t")
block_name = splt[0]
block_example = splt[1]
example_label = int(splt[2])
example_score = float(splt[3])
if block_name != current_block_name and current_block_name != "":
result_labels.append(current_block_labels)
result_scores.append(current_block_scores)
current_block_labels = []
current_block_scores = []
current_block_labels.append(example_label)
current_block_scores.append(example_score)
current_block_name = block_name
result_labels.append(current_block_labels)
result_scores.append(current_block_scores)
return result_labels,result_scores | 8d9570d794ebf09eb393342f926a5536dd0c1a75 | 11,027 |
def expanding_sum(a, axis = 0, data = None, state = None):
"""
equivalent to pandas a.expanding().sum().
- works with np.arrays
- handles nan without forward filling.
- supports state parameters
:Parameters:
------------
a : array, pd.Series, pd.DataFrame or list/dict of these
timeseries
axis : int, optional
0/1/-1. The default is 0.
data: None
unused at the moment. Allow code such as func(live, **func_(history)) to work
state: dict, optional
state parameters used to instantiate the internal calculations, based on history prior to 'a' provided.
:Example: agreement with pandas
--------------------------------
>>> from pyg import *; import pandas as pd; import numpy as np
>>> a = pd.Series(np.random.normal(0,1,10000), drange(-9999))
>>> panda = a.expanding().sum(); ts = expanding_sum(a)
>>> assert eq(ts,panda)
:Example: nan handling
----------------------
Unlike pandas, timeseries does not forward fill the nans.
>>> a[a<0.1] = np.nan
>>> panda = a.expanding().sum(); ts = expanding_sum(a)
>>> pd.concat([panda,ts], axis=1)
>>> 0 1
>>> 1993-09-23 NaN NaN
>>> 1993-09-24 NaN NaN
>>> 1993-09-25 0.645944 0.645944
>>> 1993-09-26 2.816321 2.816321
>>> 1993-09-27 2.816321 NaN
>>> ... ...
>>> 2021-02-03 3976.911348 3976.911348
>>> 2021-02-04 3976.911348 NaN
>>> 2021-02-05 3976.911348 NaN
>>> 2021-02-06 3976.911348 NaN
>>> 2021-02-07 3976.911348 NaN
:Example: state management
--------------------------
One can split the calculation and run old and new data separately.
>>> old = a.iloc[:5000]
>>> new = a.iloc[5000:]
>>> ts = expanding_sum(a)
>>> old_ts = expanding_sum_(old)
>>> new_ts = expanding_sum(new, **old_ts)
>>> assert eq(new_ts, ts.iloc[5000:])
:Example: dict/list inputs
---------------------------
>>> assert eq(expanding_sum(dict(x = a, y = a**2)), dict(x = expanding_sum(a), y = expanding_sum(a**2)))
>>> assert eq(expanding_sum([a,a**2]), [expanding_sum(a), expanding_sum(a**2)])
"""
state = state or {}
return first_(_expanding_sum(a, axis = axis, **state)) | ec3fb41784f7ce5ef268ec8e7d8fe8e65f222157 | 11,028 |
def accuracy(output, target, top_k=(1,)):
"""Calculate classification accuracy between output and target.
:param output: output of classification network
:type output: pytorch tensor
:param target: ground truth from dataset
:type target: pytorch tensor
:param top_k: top k of metric, k is an interger
:type top_k: tuple of interger
:return: results of top k
:rtype: list
"""
max_k = max(top_k)
batch_size = target.size(0)
_, pred = output.topk(max_k, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in top_k:
correct_k = correct[:k].view(-1).float().sum(0)
res.append(correct_k.mul_(100.0 / batch_size))
return res | 68b7c48e5bd832a637e7a06353c48ffa09b449cd | 11,029 |
from typing import Dict
from typing import Any
import os
import json
def read_configuration_from_file(path: str) -> Dict[str, Any]:
"""
Read the JSON file and return a dict.
:param path: path on file system
:return: raw, unchanged dict
"""
if os.path.isfile(path):
with open(path) as json_file:
return json.load(json_file)
else:
raise ConfigNotFoundException | 57a8ea69507d4941b00e9ec2849084536eb7d44f | 11,030 |
import typing
import logging
def logwrap(
func: typing.Optional[typing.Callable] = None,
*,
log: logging.Logger = _log_wrap_shared.logger,
log_level: int = logging.DEBUG,
exc_level: int = logging.ERROR,
max_indent: int = 20,
spec: typing.Optional[typing.Callable] = None,
blacklisted_names: typing.Optional[typing.List[str]] = None,
blacklisted_exceptions: typing.Optional[typing.List[typing.Type[Exception]]] = None,
log_call_args: bool = True,
log_call_args_on_exc: bool = True,
log_result_obj: bool = True
) -> typing.Union[LogWrap, typing.Callable]:
"""Log function calls and return values. Python 3.4+ version.
:param func: function to wrap
:type func: typing.Optional[typing.Callable]
:param log: logger object for decorator, by default used 'logwrap'
:type log: logging.Logger
:param log_level: log level for successful calls
:type log_level: int
:param exc_level: log level for exception cases
:type exc_level: int
:param max_indent: maximum indent before classic `repr()` call.
:type max_indent: int
:param spec: callable object used as spec for arguments bind.
This is designed for the special cases only,
when impossible to change signature of target object,
but processed/redirected signature is accessible.
Note: this object should provide fully compatible signature
with decorated function, or arguments bind will be failed!
:type spec: typing.Optional[typing.Callable]
:param blacklisted_names: Blacklisted argument names. Arguments with this names will be skipped in log.
:type blacklisted_names: typing.Optional[typing.Iterable[str]]
:param blacklisted_exceptions: list of exceptions, which should be re-raised without producing log record.
:type blacklisted_exceptions: typing.Optional[typing.Iterable[typing.Type[Exception]]]
:param log_call_args: log call arguments before executing wrapped function.
:type log_call_args: bool
:param log_call_args_on_exc: log call arguments if exception raised.
:type log_call_args_on_exc: bool
:param log_result_obj: log result of function call.
:type log_result_obj: bool
:return: built real decorator.
:rtype: _log_wrap_shared.BaseLogWrap
.. versionchanged:: 3.3.0 Extract func from log and do not use Union.
.. versionchanged:: 3.3.0 Deprecation of *args
.. versionchanged:: 4.0.0 Drop of *args
"""
wrapper = LogWrap(
log=log,
log_level=log_level,
exc_level=exc_level,
max_indent=max_indent,
spec=spec,
blacklisted_names=blacklisted_names,
blacklisted_exceptions=blacklisted_exceptions,
log_call_args=log_call_args,
log_call_args_on_exc=log_call_args_on_exc,
log_result_obj=log_result_obj
)
if func is not None:
return wrapper(func)
return wrapper | 4c48dafc6c4f062fd1d165fd30bcc99209eabed3 | 11,031 |
def sum_digits(number):
"""
Write a function named sum_digits which takes a number as input and
returns the sum of the absolute value of each of the number's decimal digits.
"""
return sum(int(n) for n in str(number) if n.isdigit()) | b6d8083a78d67a268316716174723f47d84b2287 | 11,032 |
import numpy
def label(input, structure=None, output=None):
"""Labels features in an array.
Args:
input (cupy.ndarray): The input array.
structure (array_like or None): A structuring element that defines
feature connections. ```structure``` must be centersymmetric. If
None, structure is automatically generated with a squared
connectivity equal to one.
output (cupy.ndarray, dtype or None): The array in which to place the
output.
Returns:
label (cupy.ndarray): An integer array where each unique feature in
```input``` has a unique label in the array.
num_features (int): Number of features found.
.. warning::
This function may synchronize the device.
.. seealso:: :func:`scipy.ndimage.label`
"""
if not isinstance(input, cupy.ndarray):
raise TypeError('input must be cupy.ndarray')
if input.dtype.char in 'FD':
raise TypeError('Complex type not supported')
if structure is None:
structure = _generate_binary_structure(input.ndim, 1)
elif isinstance(structure, cupy.ndarray):
structure = cupy.asnumpy(structure)
structure = numpy.array(structure, dtype=bool)
if structure.ndim != input.ndim:
raise RuntimeError('structure and input must have equal rank')
for i in structure.shape:
if i != 3:
raise ValueError('structure dimensions must be equal to 3')
if isinstance(output, cupy.ndarray):
if output.shape != input.shape:
raise ValueError("output shape not correct")
caller_provided_output = True
else:
caller_provided_output = False
if output is None:
output = cupy.empty(input.shape, numpy.int32)
else:
output = cupy.empty(input.shape, output)
if input.size == 0:
# empty
maxlabel = 0
elif input.ndim == 0:
# 0-dim array
maxlabel = 0 if input.item() == 0 else 1
output[...] = maxlabel
else:
if output.dtype != numpy.int32:
y = cupy.empty(input.shape, numpy.int32)
else:
y = output
maxlabel = _label(input, structure, y)
if output.dtype != numpy.int32:
output[...] = y[...]
if caller_provided_output:
return maxlabel
else:
return output, maxlabel | fe3e4b7ee30f7dc1ae0541133f7db3d02c7d3157 | 11,033 |
import functools
def get_experiment_fn(nnObj,data_dir, num_gpus,variable_strategy,use_distortion_for_training=True):
"""Returns an Experiment function.
Experiments perform training on several workers in parallel,
in other words experiments know how to invoke train and eval in a sensible
fashion for distributed training. Arguments passed directly to this
function are not tunable, all other arguments should be passed within
tf.HParams, passed to the enclosed function.
Args:
data_dir: str. Location of the data for input_fns.
num_gpus: int. Number of GPUs on each worker.
variable_strategy: String. CPU to use CPU as the parameter server
and GPU to use the GPUs as the parameter server.
use_distortion_for_training: bool. See cifar10.Cifar10DataSet.
Returns:
A function (tf.estimator.RunConfig, tf.contrib.training.HParams) ->
tf.contrib.learn.Experiment.
Suitable for use by tf.contrib.learn.learn_runner, which will run various
methods on Experiment (train, evaluate) based on information
about the current runner in `run_config`.
"""
def _experiment_fn(run_config, hparams):
"""Returns an Experiment."""
# Create estimator.
train_input_fn = functools.partial(
cifar_main.input_fn,
data_dir,
subset='train',
num_shards=num_gpus,
batch_size=hparams.train_batch_size,
use_distortion_for_training=use_distortion_for_training)
eval_input_fn = functools.partial(
cifar_main.input_fn,
data_dir,
subset='eval',
batch_size=hparams.eval_batch_size,
num_shards=num_gpus)
num_eval_examples = cifar10.Cifar10DataSet.num_examples_per_epoch('eval')
if num_eval_examples % hparams.eval_batch_size != 0:
raise ValueError(
'validation set size must be multiple of eval_batch_size')
train_steps = hparams.train_steps
eval_steps = num_eval_examples // hparams.eval_batch_size
classifier = tf.estimator.Estimator(
model_fn=cifar_main.get_model_fn(nnObj,num_gpus, variable_strategy,
run_config.num_worker_replicas or 1),
config=run_config,
params=hparams)
vail_accuracy=[]
for loop in range(20):
classifier.train(train_input_fn,steps=train_steps)
vail_accuracy.append(classifier.evaluate(eval_input_fn,steps=eval_steps))
print("finished iter:"+str((loop+1)*train_steps))
print("accuracy:")
print(vail_accuracy)
# Create experiment.
return tf.contrib.learn.Experiment(
classifier,
train_input_fn=train_input_fn,
eval_input_fn=eval_input_fn,
train_steps=train_steps,
eval_steps=eval_steps)
return _experiment_fn | 07ddb4ebac493826127464f76fd79ea17e7bf474 | 11,034 |
def calc_psnr(tar_img, ref_img):
""" Compute the peak signal to noise ratio (PSNR) for an image.
Parameters
----------
tar_img : sitk
Test image.
ref_img : sitk
Ground-truth image.
Returns
-------
psnr : float
The PSNR metric.
References
----------
.. [1] https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
"""
tar_vol = tar_img
ref_vol = ref_img
ref_vol, tar_vol = _as_floats(ref_vol, tar_vol)
err = calc_mse(ref_img, tar_img)
return 10 * np.log10((256 ** 2) / err) | 61097170fb439b85583cd8aac8002c70d02c094b | 11,035 |
import networkx as nx
import os
def celegans(path):
"""Load the neural network of the worm C. Elegans [@watts1998collective].
The neural network consists of around 300 neurons. Each connection
between neurons is associated with a weight (positive integer)
capturing the strength of the connection.
Args:
path: str.
Path to directory which either stores file or otherwise file will
be downloaded and extracted there. Filename is `celegansneural.gml`.
Returns:
Adjacency matrix as a np.darray `x_train` with 297 rows and 297
columns.
"""
path = os.path.expanduser(path)
filename = 'celegansneural.gml'
if not os.path.exists(os.path.join(path, filename)):
url = 'http://www-personal.umich.edu/~mejn/netdata/celegansneural.zip'
maybe_download_and_extract(path, url)
graph = nx.read_gml(os.path.join(path, filename))
x_train = np.zeros([graph.number_of_nodes(), graph.number_of_nodes()],
dtype=np.int)
for i, j in graph.edges():
x_train[i, j] = int(graph[i][j][0]['value'])
return x_train | fc7f63af1b70c58fab7655d33f6d9630d4bd003e | 11,036 |
from typing import Callable
from typing import Dict
from typing import Any
import functools
def glacier_wrap(
f: Callable[..., None],
enum_map: Dict[str, Dict[str, Any]],
) -> Callable[..., None]:
"""
Return the new function which is click-compatible
(has no enum signature arguments) from the arbitrary glacier compatible
function
"""
# Implemented the argument convert logic
@functools.wraps(f)
def wrapped(*args: Any, **kwargs: Any) -> None:
# convert args and kwargs
converted_kwargs = {}
for name, value in kwargs.items():
if name in enum_map:
converted_kwargs[name] = enum_map[name][value]
else:
converted_kwargs[name] = value
return f(*args, **converted_kwargs)
return wrapped | 01f3a90179bb0dba29ffb0b2fa9d91be15e0ee7e | 11,037 |
def _cluster_spec_to_device_list(cluster_spec, num_gpus_per_worker):
"""Returns a device list given a cluster spec."""
cluster_spec = multi_worker_util.normalize_cluster_spec(cluster_spec)
devices = []
for task_type in ("chief", "worker"):
for task_id in range(len(cluster_spec.as_dict().get(task_type, []))):
if num_gpus_per_worker == 0:
devices.append("/job:%s/task:%d" % (task_type, task_id))
else:
devices.extend([
"/job:%s/task:%d/device:GPU:%i" % (task_type, task_id, gpu_id)
for gpu_id in range(num_gpus_per_worker)
])
return devices | 3032a28f80dbed1fd870e4fc2ea06d724fc529ce | 11,038 |
def group_by_time(df, col, by='day', fun='max', args=(), kwargs={}, index='categories'):
""" See <https://pandas.pydata.org/pandas-docs/stable/api.html#groupby>_ for the set of `fun` parameters
available. Examples are: 'count', 'max', 'min', 'median', etc
.. Tip:: Since Access inherits from TimeIntervalTable, the underlaying data format
is a `pandas.DataFrame`, not a `pandas.Series`. Consequently, only the groupby
functions of a generic GroupBy or DataFrameGroupBy are valid. Functions of SeriesGroupBy
are not allowed.
"""
if col == 'index':
t = df.index
else:
t = df.loc[:, col].dt
if by.lower() in ['y', 'year']:
group = df.groupby([t.year])
group = getattr(group, fun)(*args, **kwargs)
group.index.names = ['year']
elif by.lower() in ['m', 'month']:
group = df.groupby([t.year, t.month])
group = getattr(group, fun)(*args, **kwargs)
group.index.names = ['year', 'month']
elif by.lower() in ['d', 'day']:
group = df.groupby([t.year, t.month, t.day])
group = getattr(group, fun)(*args, **kwargs)
group.index.names = ['year', 'month', 'day']
elif by.lower() in ['h', 'hour']:
group = df.groupby([t.year, t.month, t.day, t.hour])
group = getattr(group, fun)(*args, **kwargs)
group.index.names = ['year', 'month', 'day', 'hour']
elif by.lower() in ['m', 'min', 'minute']:
group = df.groupby([t.year, t.month, t.day, t.hour, t.minute])
group = getattr(group, fun)(*args, **kwargs)
group.index.names = ['year', 'month', 'day', 'hour', 'min']
elif by.lower() in ['s', 'sec', 'second']:
group = df.groupby([t.year, t.month, t.day, t.hour, t.minute, t.second])
group = getattr(group, fun)(*args, **kwargs)
group.index.names = ['year', 'month', 'day', 'hour', 'min', 'sec']
else:
raise KeyError('Grouping can be by "year", "month", "day", "min" and "sec" only')
# Choose index
if index == 'categories':
return group
elif index == 'times':
group.index = pd.DatetimeIndex([pd.Timestamp(*i) for i, _ in group.iterrows()])
return group
else:
raise KeyError('Argument "index={}"" is not valid. Options are "categories" or "times"') | 6695d285b52757ee7dfd32ad5943aa433504322f | 11,039 |
def fetch(url, params=None, keepalive=False, requireValidCert=False,
debug=False):
"""
Fetches the desired @url using an HTTP GET request and appending and
@params provided in a dictionary.
If @keepalive is False, a fresh connection will be made for this request.
If @requireValidCert is True, then an exception is thrown if the remote
server cannot provide a valid TLS certificate.
If @keepalive is False, connections are closed and so subsequent connections
must make fresh (cold) HTTPS connections.
@returns the result as a dictionary, decoded from server-provided JSON.
@raises an exception if there are any problems connecting to the remote
server, receiving a valiud HTTP status 200 response, or decoding the
resulting JSON response.
"""
# Set the certificate verification flag
httpClient.disable_ssl_certificate_validation = not requireValidCert
# Assemble the URL
url = getUrl(url, params)
if debug:
print "Fetching " + url
# Fetch the URL with a GET request.
response, content = httpClient.request(url, "GET")
# Check the status code.
if response.status != 200:
m = "Remote service reported an error (status:{} {}) for "\
"URL {}".format(response.status, response.reason, url)
raise Exception(m)
# Close the connection if requested.
if not keepalive:
map(lambda (k,v): v.close(), httpClient.connections.iteritems())
# Parse the response
return json.loads(content) | 8edfa089e9ae40d32f4843e6c684b3a06783150a | 11,040 |
def param_rischDE(fa, fd, G, DE):
"""
Solve a Parametric Risch Differential Equation: Dy + f*y == Sum(ci*Gi, (i, 1, m)).
Given a derivation D in k(t), f in k(t), and G
= [G1, ..., Gm] in k(t)^m, return h = [h1, ..., hr] in k(t)^r and
a matrix A with m + r columns and entries in Const(k) such that
Dy + f*y = Sum(ci*Gi, (i, 1, m)) has a solution y
in k(t) with c1, ..., cm in Const(k) if and only if y = Sum(dj*hj,
(j, 1, r)) where d1, ..., dr are in Const(k) and (c1, ..., cm,
d1, ..., dr) is a solution of Ax == 0.
Elements of k(t) are tuples (a, d) with a and d in k[t].
"""
m = len(G)
q, (fa, fd) = weak_normalizer(fa, fd, DE)
# Solutions of the weakly normalized equation Dz + f*z = q*Sum(ci*Gi)
# correspond to solutions y = z/q of the original equation.
gamma = q
G = [(q*ga).cancel(gd, include=True) for ga, gd in G]
a, (ba, bd), G, hn = prde_normal_denom(fa, fd, G, DE)
# Solutions q in k<t> of a*Dq + b*q = Sum(ci*Gi) correspond
# to solutions z = q/hn of the weakly normalized equation.
gamma *= hn
A, B, G, hs = prde_special_denom(a, ba, bd, G, DE)
# Solutions p in k[t] of A*Dp + B*p = Sum(ci*Gi) correspond
# to solutions q = p/hs of the previous equation.
gamma *= hs
g = A.gcd(B)
a, b, g = A.quo(g), B.quo(g), [gia.cancel(gid*g, include=True) for
gia, gid in G]
# a*Dp + b*p = Sum(ci*gi) may have a polynomial solution
# only if the sum is in k[t].
q, M = prde_linear_constraints(a, b, g, DE)
# q = [q1, ..., qm] where qi in k[t] is the polynomial component
# of the partial fraction expansion of gi.
# M is a matrix with m columns and entries in k.
# Sum(fi*gi, (i, 1, m)), where f1, ..., fm are elements of k,
# is a polynomial if and only if M*Matrix([f1, ..., fm]) == 0,
# in which case the sum is equal to Sum(fi*qi).
M, _ = constant_system(M, zeros(M.rows, 1), DE)
# M is a matrix with m columns and entries in Const(k).
# Sum(ci*gi) is in k[t] for c1, ..., cm in Const(k)
# if and only if M*Matrix([c1, ..., cm]) == 0,
# in which case the sum is Sum(ci*qi).
## Reduce number of constants at this point
V = M.nullspace()
# V = [v1, ..., vu] where each vj is a column matrix with
# entries aj1, ..., ajm in Const(k).
# Sum(aji*gi) is in k[t] and equal to Sum(aji*qi) (j = 1, ..., u).
# Sum(ci*gi) is in k[t] if and only is ci = Sum(dj*aji)
# (i = 1, ..., m) for some d1, ..., du in Const(k).
# In that case,
# Sum(ci*gi) = Sum(ci*qi) = Sum(dj*Sum(aji*qi)) = Sum(dj*rj)
# where rj = Sum(aji*qi) (j = 1, ..., u) in k[t].
if not V: # No non-trivial solution
return [], eye(m)
Mq = Matrix([q]) # A single row.
r = [(Mq*vj)[0] for vj in V] # [r1, ..., ru]
# Solutions of a*Dp + b*p = Sum(dj*rj) correspond to solutions
# y = p/gamma of the initial equation with ci = Sum(dj*aji).
try:
# We try n=5. At least for prde_spde, it will always
# terminate no matter what n is.
n = bound_degree(a, b, r, DE, parametric=True)
except NotImplementedError:
# A temporary bound is set. Eventually, it will be removed.
# the currently added test case takes large time
# even with n=5, and much longer with large n's.
n = 5
h, B = param_poly_rischDE(a, b, r, n, DE)
# h = [h1, ..., hv] in k[t]^v and and B is a matrix with u + v
# columns and entries in Const(k) such that
# a*Dp + b*p = Sum(dj*rj) has a solution p of degree <= n
# in k[t] if and only if p = Sum(ek*hk) where e1, ..., ev are in
# Const(k) and B*Matrix([d1, ..., du, e1, ..., ev]) == 0.
# The solutions of the original equation for ci = Sum(dj*aji)
# (i = 1, ..., m) are then y = Sum(ek*hk, (k, 1, v))/gamma.
## Build combined relation matrix with m + u + v columns.
A = -eye(m)
for vj in V:
A = A.row_join(vj)
A = A.row_join(zeros(m, len(h)))
A = A.col_join(zeros(B.rows, m).row_join(B))
## Eliminate d1, ..., du.
W = A.nullspace()
# W = [w1, ..., wt] where each wl is a column matrix with
# entries blk (k = 1, ..., m + u + v) in Const(k).
# The vectors (bl1, ..., blm) generate the space of those
# constant families (c1, ..., cm) for which a solution of
# the equation Dy + f*y == Sum(ci*Gi) exists. They generate
# the space and form a basis except possibly when Dy + f*y == 0
# is solvable in k(t}. The corresponding solutions are
# y = Sum(blk'*hk, (k, 1, v))/gamma, where k' = k + m + u.
v = len(h)
M = Matrix([wl[:m] + wl[-v:] for wl in W]) # excise dj's.
N = M.nullspace()
# N = [n1, ..., ns] where the ni in Const(k)^(m + v) are column
# vectors generating the space of linear relations between
# c1, ..., cm, e1, ..., ev.
C = Matrix([ni[:] for ni in N]) # rows n1, ..., ns.
return [hk.cancel(gamma, include=True) for hk in h], C | afb910a9590195fa637be9c64382419c1c79a885 | 11,041 |
from sys import path
import yaml
def main(df: pyam.IamDataFrame) -> pyam.IamDataFrame:
"""Main function for validation and processing (for the ARIADNE-intern instance)"""
# load list of allowed scenario names
with open(path / "scenarios.yml", "r") as stream:
scenario_list = yaml.load(stream, Loader=yaml.FullLoader)
# validate list of submitted scenarios
illegal_scens = [s for s in df.scenario if s not in scenario_list]
if illegal_scens:
raise_error("scenarios", illegal_scens)
# call validation function for variables, regions and subannual time resolution
df = _validate(df)
# call validation function for meta indicators
df = _validate_meta(df, ALLOWED_META_ARIADNE)
return df | 8872d698e0e00baedfe24784b2db6b206ff32e04 | 11,042 |
import torch
def huber_loss(x, delta=1.):
""" Standard Huber loss of parameter delta
https://en.wikipedia.org/wiki/Huber_loss
returns 0.5 * x^2 if |a| <= \delta
\delta * (|a| - 0.5 * \delta) o.w.
"""
if torch.abs(x) <= delta:
return 0.5 * (x ** 2)
else:
return delta * (torch.abs(x) - 0.5 * delta) | b3493eb9d4e38fa36f92db80dc52a47c32caf3c9 | 11,043 |
def licenses_mapper(license, licenses, package): # NOQA
"""
Update package licensing and return package based on the `license` and
`licenses` values found in a package.
Licensing data structure has evolved over time and is a tad messy.
https://docs.npmjs.com/files/package.json#license
license(s) is either:
- a string with:
- an SPDX id or expression { "license" : "(ISC OR GPL-3.0)" }
- some license name or id
- "SEE LICENSE IN <filename>"
- (Deprecated) an array or a list of arrays of type, url.
- "license": "UNLICENSED" means this is proprietary
"""
declared_license = get_declared_licenses(license) or []
declared_license.extend(get_declared_licenses(licenses) or [])
package.declared_license = declared_license
return package | 5568c323b342cc09d966ddef3455381abdca1ccc | 11,044 |
def send_command(target, data):
"""sends a nudge api command"""
url = urljoin(settings.NUDGE_REMOTE_ADDRESS, target)
req = urllib2.Request(url, urllib.urlencode(data))
try:
return urllib2.urlopen(req)
except urllib2.HTTPError, e:
raise CommandException(
'An exception occurred while contacting %s: %s' %
(url, e), e) | fc6967f84568b755db7f132f5fc511ef9687369f | 11,045 |
def logistic_log_partial_ij(x_i, y_i, beta, j):
"""i is index of point and j is index of derivative"""
return (y_i - logistic(dot(x_i, beta))) * x_i[j] | a24f704bc3178c6f2d8b37ad075f1beea3666964 | 11,046 |
def expected_win(theirs, mine):
"""Compute the expected win rate of my strategy given theirs"""
assert abs(theirs.r + theirs.p + theirs.s - 1) < 0.001
assert abs(mine.r + mine.p + mine.s - 1) < 0.001
wins = theirs.r * mine.p + theirs.p * mine.s + theirs.s * mine.r
losses = theirs.r * mine.s + theirs.p * mine.r + theirs.s * mine.p
return wins - losses | 92de2010287e0c027cb18c3dd01d95353e4653c4 | 11,047 |
def get_first_where(data, compare):
"""
Gets first dictionary in list that fit to compare-dictionary.
:param data: List with dictionarys
:param compare: Dictionary with keys for comparison {'key';'expected value'}
:return: list with dictionarys that fit to compare
"""
l = get_all_where(data, compare)
if len(l) < 1:
raise Exception('Data not found! (' + str(compare) + ')')
return l[0] | fc961d7154aa265efd101a658f668ad2025c121f | 11,048 |
import numpy
def parse_megam_weights(s, features_count, explicit=True):
"""
Given the stdout output generated by ``megam`` when training a
model, return a ``numpy`` array containing the corresponding weight
vector. This function does not currently handle bias features.
"""
if numpy is None:
raise ValueError("This function requires that numpy be installed")
assert explicit, "non-explicit not supported yet"
lines = s.strip().split("\n")
weights = numpy.zeros(features_count, "d")
for line in lines:
if line.strip():
fid, weight = line.split()
weights[int(fid)] = float(weight)
return weights | db172935fe7af892b420d515391565ccc2b44c55 | 11,049 |
from typing import Counter
def project_statistics(contributions):
"""Returns a dictionary containing statistics about all projects."""
projects = {}
for contribution in contributions:
# Don't count unreviewed contributions
if contribution["status"] == "unreviewed":
continue
project = contribution["repository"]
utopian_vote = contribution["utopian_vote"]
# Set default in case category doesn't exist
projects.setdefault(
project, {
"project": project,
"average_score": [],
"average_without_0": [],
"voted": 0,
"not_voted": 0,
"unvoted": 0,
"task-requests": 0,
"moderators": [],
"average_payout": [],
"total_payout": 0,
"utopian_total": []
}
)
# Check if contribution was voted on or unvoted
if contribution["status"] == "unvoted":
projects[project]["unvoted"] += 1
projects[project]["not_voted"] += 1
elif contribution["voted_on"]:
projects[project]["voted"] += 1
else:
projects[project]["not_voted"] += 1
# If contribution was a task request count this
if "task" in contribution["category"]:
projects[project]["task-requests"] += 1
# Add moderator and score
projects[project]["moderators"].append(contribution["moderator"])
projects[project]["average_score"].append(contribution["score"])
projects[project]["total_payout"] += contribution["total_payout"]
projects[project]["utopian_total"].append(utopian_vote)
if contribution["score"] > 0:
projects[project]["average_without_0"].append(
contribution["score"])
project_list = []
for project, value in projects.items():
# Set new keys and append value to list
value["reviewed"] = value["voted"] + value["not_voted"]
value["average_score"] = average(value["average_score"])
value["average_without_0"] = average(value["average_without_0"])
value["average_payout"] = value["total_payout"] / value["reviewed"]
value["moderators"] = Counter(value["moderators"]).most_common()
value["pct_voted"] = percentage(value["reviewed"], value["voted"])
# Add Utopian.io's vote statistics
value["utopian_total"] = [vote for vote in value["utopian_total"]
if vote != 0]
value["average_utopian_vote"] = average(value["utopian_total"])
value["utopian_total"] = sum(value["utopian_total"])
project_list.append(value)
return {"projects": project_list} | 91c27b504fc974b26f4e76b8a3f78e3665a21efa | 11,050 |
def exportSDFVisual(visualobj, linkobj, visualdata, indentation, modelname):
"""Simple wrapper for visual data of links.
The visual object is required to determine the position (pose) of the
object.
If relative poses are used the data found in visualdata (key pose) is used.
Otherwise the pose of the visual object will be combined with all
collected links up to the rootobject (see
phobos.utils.editing.getCombinedTransform).
Args:
visualobj: object to be used for pose
visualdata: data as provided by dictionary (should contain name,
geometry)
indentation: indentation at current level
relative: True for usage of sdf relative pathing
modelname: the name of the model (required for geometry)
linkobj:
Returns:
: str -- writable xml line
"""
tagger = xmlTagger(initial=indentation)
tagger.descend('visual', attribs={'name': visualdata['name']})
# OPT: tagger.attrib('cast_shadows', ...)
# OPT: tagger.attrib('laser_retro', ...)
# OPT: tagger.attrib('transparency', ...)
# OPT: tagger.descend('meta')
# OPT: tagger.attrib('layer', ...)
# tagger.ascend()
# OPT: tagger.write(exportSDFFrame(..., tagger.get_indent()))
# Pose data of the visual is transformed by link --> use local matrix
matrix = visualobj.matrix_local
posedata = {
'rawmatrix': matrix,
'matrix': [list(vector) for vector in list(matrix)],
'translation': list(matrix.to_translation()),
'rotation_euler': list(matrix.to_euler()),
'rotation_quaternion': list(matrix.to_quaternion()),
}
# overwrite absolute position of the visual object
tagger.write(exportSDFPose(posedata, tagger.get_indent()))
# write material data if available
if 'material' in visualdata:
tagger.write(exportSDFMaterial(visualdata['material'], tagger.get_indent()))
tagger.write(exportSDFGeometry(visualdata['geometry'], tagger.get_indent(), modelname))
tagger.ascend()
return "".join(tagger.get_output()) | f556a1eb1cef42adfde28c481a3443f149219518 | 11,051 |
import resource
def register_module():
"""Callback for module registration. Sets up URL routes."""
global custom_module # pylint: disable=global-statement
permissions = [
roles.Permission(EDIT_STUDENT_GROUPS_PERMISSION,
messages.EDIT_STUDENT_GROUPS_PERMISSION_DESCRIPTION),
]
def permissions_callback(unused_application_context):
return permissions
def notify_module_enabled():
"""Callback at module-enable time, just after module registration.
Responsible for registering module's callbacks and other items with
core and other modules.
"""
model_caching.CacheFactory.build(
MODULE_NAME_AS_IDENTIFIER, MODULE_NAME + " Caching",
messages.ENABLE_GROUP_CACHING,
max_size_bytes=(
StudentGroupAvailabilityRestHandler.MAX_NUM_MEMBERS * 1024 * 4),
ttl_sec=60 * 60, dao_class=StudentGroupDAO)
# Tell permissioning system about permission for this module.
roles.Roles.register_permissions(custom_module, permissions_callback)
# Navigation sub-tab for showing list of student groups, and
# associated role-level permission.
dashboard.DashboardHandler.add_sub_nav_mapping(
'settings', MODULE_NAME_AS_IDENTIFIER, 'Student Groups',
action=StudentGroupListHandler.ACTION,
contents=StudentGroupListHandler.render_groups_view)
dashboard.DashboardHandler.map_get_action_to_permission(
StudentGroupListHandler.ACTION, custom_module,
EDIT_STUDENT_GROUPS_PERMISSION)
# Register action for add/edit/delete of student group.
dashboard.DashboardHandler.add_custom_get_action(
StudentGroupRestHandler.ACTION,
handler=StudentGroupRestHandler.edit_student_group,
in_action=StudentGroupListHandler.ACTION)
dashboard.DashboardHandler.map_get_action_to_permission(
StudentGroupRestHandler.ACTION, custom_module,
EDIT_STUDENT_GROUPS_PERMISSION)
# Override existing action for availability. For UX convenience,
# we want to have the same page modify overall course availability
# as well as per-group availability.
dashboard.DashboardHandler.add_custom_get_action(
availability.AvailabilityRESTHandler.ACTION,
StudentGroupAvailabilityRestHandler.get_form, overwrite=True)
# Register a callback to add the user's student group ID (if any) to
# recorded events.
models.EventEntity.EVENT_LISTENERS.append(
_add_student_group_to_event)
# Register a component with the student-aggregator data pump source
# so that student-aggregate records get marked with the group ID
# for that student.
student_aggregate.StudentAggregateComponentRegistry.register_component(
AddToStudentAggregate)
# Register a callback with models.models.StudentProfileDAO to let us
# know when a student registers. This allows us to move the
# Definitive Truth about group membership to the Student record.
models.StudentProfileDAO.STUDENT_CREATION_HOOKS.append(
StudentGroupMembership.user_added_callback)
# Register a callback with Course so that when anyone asks for the
# student-facing list of units and lessons we can modify them as
# appropriate.
courses.Course.COURSE_ELEMENT_STUDENT_VIEW_HOOKS.append(
modify_unit_and_lesson_attributes)
# Register a callback with Course so that when the environment is
# fetched, we can submit overwrite items.
courses.Course.COURSE_ENV_POST_COPY_HOOKS.append(
modify_course_environment)
# Register student group as a generically handle-able translatable
# resource.
resource.Registry.register(ResourceHandlerStudentGroup)
# Register student group as a translatable item; the title and
# description can appear on student profile pages.
i18n_dashboard.TranslatableResourceRegistry.register(
TranslatableResourceStudentGroups)
# Register a section on the student profile to add the current
# student's group - if any.
utils.StudentProfileHandler.EXTRA_PROFILE_SECTION_PROVIDERS.append(
_add_student_group_to_profile)
# Register with gradebook to add student group as a filterable
# item.
gradebook.RawAnswersDataSource.FILTERS.append(StudentGroupFilter)
# Register with generator feeding gradebook to add some handling to
# the map and reduce steps so we can generate our filter-able data
# column in the generator's output.
gradebook.RawAnswersGenerator.register_hook(
MODULE_NAME,
_add_student_group_to_map_result,
_add_student_group_to_kwargs)
# Add our types to the set of DB tables for download/upload of course.
courses.ADDITIONAL_ENTITIES_FOR_COURSE_IMPORT.add(StudentGroupEntity)
courses.ADDITIONAL_ENTITIES_FOR_COURSE_IMPORT.add(
StudentGroupMembership)
custom_module = custom_modules.Module(
MODULE_NAME, 'Define and manage groups of students.',
global_routes=[
(EmailToObfuscatedUserIdCleanup.URL,
EmailToObfuscatedUserIdCleanup),
], namespaced_routes=[
(StudentGroupRestHandler.URL,
StudentGroupRestHandler),
(StudentGroupAvailabilityRestHandler.URL,
StudentGroupAvailabilityRestHandler)
],
notify_module_enabled=notify_module_enabled)
return custom_module | 82e8d57c2b0f73ae21b460da61ce047b4a25ebe3 | 11,052 |
from sys import version_info
def build_texttable(events):
"""
value['date'], value["target"], value['module_name'], value['scan_unique_id'],
value['options'], value['event']
build a text table with generated event related to the scan
:param events: all events
:return:
array [text table, event_number]
"""
_table = texttable.Texttable()
table_headers = [
'target',
'module_name',
'scan_unique_id',
'options',
'event',
'date'
]
_table.add_rows(
[
table_headers
]
)
for event in events:
_table.add_rows(
[
table_headers,
[
event['target'],
event['module_name'],
event['scan_unique_id'],
event['options'],
event['event'],
event['date']
]
]
)
return _table.draw().encode('utf8') + b'\n\n' + messages("nettacker_version_details").format(
version_info()[0],
version_info()[1],
now()
).encode('utf8') + b"\n" | 477c40ce240aae8848d960c6c3bba1e52a4c6b67 | 11,053 |
def for_all_regions(get_client_func, catalog_entry, action_func, parsed_args):
"""
Run the provided function on all the available regions.
Available regions are determined based on the user service catalog entries.
"""
result = []
cache_key = 'todo'
cache_item = CACHE.get(cache_key, None)
if cache_item is None:
client = get_client_func(parsed_args)
CACHE[cache_key] = client
else:
client = cache_item
catalog = client.connection.get_service_catalog()
urls = catalog.get_public_urls(service_type=catalog_entry,
name=catalog_entry)
auth_connection = client.connection.get_auth_connection_instance()
driver_kwargs = {'ex_auth_connection': auth_connection}
def run_in_pool(client):
item = action_func(client)
result.extend(item)
for api_url in urls:
parsed_args.api_url = api_url
client = get_client_func(parsed_args, driver_kwargs=driver_kwargs)
run_function(pool, run_in_pool, client)
join_pool(pool)
return result | 9b1dfba7939aada8ca3c4c894d2ebbde08e757c6 | 11,054 |
import scipy
def KL_distance(image1, image2):
"""
Given two images, calculate the KL divergence between the two
2d array is not supported, so we have to flatten the array and compare each pixel in the image1 to the corresponding pixel in the image2.
"""
return scipy.stats.entropy(image1.ravel(), image2.ravel()) | 6419c2f6456365e027fc7eff6f4b171e5eb4fc5f | 11,055 |
def stop_all_bots():
"""
This function address RestAPI call to stop polling for all bots which
have ever started polling.
:return:
"""
bots_stopped = procedures.stop_all() # Stop all bots.
botapi_logger.info('Successfully stopped {count} bots for polling in '
'start_all api call.'.format(count=len(bots_stopped)))
if bots_stopped > 0:
return jsonify({
"result": "success",
"message": "Successfully stopped {count} previously running "
"bots.".format(count=len(bots_stopped)),
"ids": [bot_id for bot_id in bots_stopped]
}), 200
else:
return internal_server_error(
message="No to stop previously running bots.") | 7e0bdaa0ae631e631cfbc56966311e59fc510d52 | 11,056 |
def load_word_embedding_dict(embedding, embedding_path, normalize_digits=True):
"""
load word embeddings from file
:param embedding:
:param embedding_path:
:return: embedding dict, embedding dimention, caseless
"""
print "loading embedding: %s from %s" % (embedding, embedding_path)
if embedding == 'word2vec':
# loading word2vec
word2vec = Word2Vec.load_word2vec_format(embedding_path, binary=True)
embedd_dim = word2vec.vector_size
return word2vec, embedd_dim, False
elif embedding == 'glove':
# loading GloVe
embedd_dim = -1
embedd_dict = dict()
with gzip.open(embedding_path, 'r') as file:
for line in file:
line = line.strip()
line = line.decode('utf-8')
if len(line) == 0:
continue
tokens = line.split()
if len(tokens) <101:
continue
if embedd_dim < 0:
embedd_dim = len(tokens) - 1
else:
assert (embedd_dim + 1 == len(tokens))
embedd = np.empty([1, embedd_dim], dtype=theano.config.floatX)
embedd[:] = tokens[1:]
word = data_utils.DIGIT_RE.sub(b"0", tokens[0]) if normalize_digits else tokens[0]
embedd_dict[word] = embedd
return embedd_dict, embedd_dim, True
elif embedding == 'senna':
# loading Senna
embedd_dim = -1
embedd_dict = dict()
with gzip.open(embedding_path, 'r') as file:
for line in file:
line = line.strip()
line = line.decode('utf-8')
if len(line) == 0:
continue
tokens = line.split()
if embedd_dim < 0:
embedd_dim = len(tokens) - 1
else:
assert (embedd_dim + 1 == len(tokens))
embedd = np.empty([1, embedd_dim], dtype=theano.config.floatX)
embedd[:] = tokens[1:]
word = data_utils.DIGIT_RE.sub(b"0", tokens[0]) if normalize_digits else tokens[0]
embedd_dict[word] = embedd
return embedd_dict, embedd_dim, True
elif embedding == 'sskip':
embedd_dim = -1
embedd_dict = dict()
with gzip.open(embedding_path, 'r') as file:
# skip the first line
file.readline()
for line in file:
line = line.strip()
line = line.decode('utf-8')
if len(line) == 0:
continue
tokens = line.split()
if embedd_dim < 0:
embedd_dim = len(tokens) - 1
embedd = np.empty([1, embedd_dim], dtype=theano.config.floatX)
start = len(tokens) - embedd_dim
word = ' '.join(tokens[0:start])
embedd[:] = tokens[start:]
word = data_utils.DIGIT_RE.sub(b"0", word) if normalize_digits else word
embedd_dict[word] = embedd
return embedd_dict, embedd_dim, True
elif embedding == 'polyglot':
words, embeddings = pickle.load(open(embedding_path, 'rb'))
_, embedd_dim = embeddings.shape
embedd_dict = dict()
for i, word in enumerate(words):
embedd = np.empty([1, embedd_dim], dtype=theano.config.floatX)
embedd[:] = embeddings[i, :]
word = data_utils.DIGIT_RE.sub(b"0", word) if normalize_digits else word
embedd_dict[word] = embedd
return embedd_dict, embedd_dim, False
else:
raise ValueError("embedding should choose from [word2vec, senna]") | 98cda8061aa49c708bc6986a6ab036e8941967f6 | 11,057 |
import sys
def fibonacci(n: int) -> int:
"""Returns nth fib number, fib_0 = 0, fib_1 = 1, ..."""
print(sys.platform)
return nfibonacci(n + 1)[-1] | 4f6b0c61709ad76e0600c395495b5b94c03c15ae | 11,058 |
def random_exponential(shape=(40,60), a0=100, dtype=float) :
"""Returns numpy array of requested shape and type filled with exponential distribution for width a0.
"""
a = a0*np.random.standard_exponential(size=shape)
return a.astype(dtype) | 29d3e438145d4495191868c956942b9626b76918 | 11,059 |
import json
def get_mpi_components_from_files(fileList, threads=False):
"""
Given a list of files to read input data from, gets a percentage of time
spent in MPI, and a breakdown of that time in MPI
"""
percentDict = dict()
timeDict = dict()
for filename in fileList:
filename = filename.strip()
try:
# Open the file for reading
with open(filename, "r") as infile:
# Read the json
jsonDict = json.load(infile)
runtime = get_runtime(jsonDict)
numprocs = get_num_threads(jsonDict) if threads else get_num_processes(jsonDict)
# Read the overview data and get the percentage of overall time spent in mpi
subDict = get_overview_data(jsonDict)
mpiPercent = get_dict_field_val(subDict, ["mpi", "percent"]) #mpiTime = (percent / 100.) * runtime
# Now get the sub-percentage of the mpi time
mpiEntry = get_dict_field_val(jsonDict, ["data", "mpi"])
# Get all of the percentages (as a percentage of total time)
mpiSubPercent = [float(get_dict_field_val(mpiEntry, [field])) * mpiPercent / 100. for field in mpiSubPercentages]
mpiSubTime = [runtime * subpercent / 100. for subpercent in mpiSubPercent]
percentDict[numprocs] = mpiSubPercent
timeDict[numprocs] = mpiSubTime
except IOError:
print("File " + filename + " does not exist. Skipping.")
pass
return percentDict, timeDict | 34549198676b823cf9e02ec927cb1e5fc30de2b8 | 11,060 |
import urllib
def get_character_url(name):
"""Gets a character's tibia.com URL"""
return url_character + urllib.parse.quote(name.encode('iso-8859-1')) | 62dc27528b7b9b303367551b8cba0a02204d0eb6 | 11,061 |
def parse_input(lines):
"""Parse the input document, which contains validity rules for the various
ticket fields, a representation of my ticket, and representations of a
number of other observed tickets.
Return a tuple of (rules, ticket, nearby_tickets)
"""
section = parse_sections(lines)
rules = parse_rules(section[0])
my_ticket = parse_ticket(section[1][1])
tickets = [parse_ticket(line) for line in section[2][1:]]
return (rules, my_ticket, tickets) | cccf2a9b47768428b2004caab1b3cab15a369a68 | 11,062 |
from dateutil import tz
def _cnv_prioritize(data):
"""Perform confidence interval based prioritization for CNVs.
"""
supported = {"cnvkit": {"inputs": ["call_file", "segmetrics"], "fn": _cnvkit_prioritize}}
pcall = None
priority_files = None
for call in data.get("sv", []):
if call["variantcaller"] in supported:
priority_files = [call.get(x) for x in supported[call["variantcaller"]]["inputs"]]
priority_files = [x for x in priority_files if x is not None and utils.file_exists(x)]
if len(priority_files) == len(supported[call["variantcaller"]]["inputs"]):
pcall = call
break
prioritize_by = tz.get_in(["config", "algorithm", "svprioritize"], data)
if pcall and prioritize_by:
out_file = "%s-prioritize.tsv" % utils.splitext_plus(priority_files[0])[0]
gene_list = _find_gene_list_from_bed(prioritize_by, out_file, data)
if gene_list:
with open(gene_list) as in_handle:
genes = [x.strip() for x in in_handle]
args = [dd.get_sample_name(data), genes] + priority_files
df = supported[pcall["variantcaller"]]["fn"](*args)
with file_transaction(data, out_file) as tx_out_file:
df.to_csv(tx_out_file, sep="\t", index=False)
pcall["priority"] = out_file
return data | a35c8b1d1fb7f38fc23439bbe5b9778062fc6aa7 | 11,063 |
from typing import Optional
def maximum(
left_node: NodeInput,
right_node: NodeInput,
auto_broadcast: str = "NUMPY",
name: Optional[str] = None,
) -> Node:
"""Return node which applies the maximum operation to input nodes elementwise."""
return _get_node_factory_opset1().create(
"Maximum", [left_node, right_node], {"auto_broadcast": auto_broadcast.upper()}
) | 9ca2ac093059a9c7c2a1b310635c551d1982b1bb | 11,064 |
def create_template_error():
"""
Создает заготовку для генерации ошибок
"""
return {'response': False} | f15c27cc980cf1bda6b82353d01bbe7871fdbff1 | 11,065 |
from typing import Any
from typing import Tuple
import os
import logging
import sys
def download_and_extract_index(storage_bucket: Any, extract_destination_path: str) -> Tuple[str, Any, int]:
"""Downloads and extracts index zip from cloud storage.
Args:
storage_bucket (google.cloud.storage.bucket.Bucket): google storage bucket where index.zip is stored.
extract_destination_path (str): the full path of extract folder.
Returns:
str: extracted index folder full path.
Blob: google cloud storage object that represents index.zip blob.
str: downloaded index generation.
"""
if storage_bucket.name == GCPConfig.PRODUCTION_PRIVATE_BUCKET:
index_storage_path = os.path.join(GCPConfig.PRIVATE_BASE_PATH, f"{GCPConfig.INDEX_NAME}.zip")
else:
index_storage_path = os.path.join(GCPConfig.STORAGE_BASE_PATH, f"{GCPConfig.INDEX_NAME}.zip")
download_index_path = os.path.join(extract_destination_path, f"{GCPConfig.INDEX_NAME}.zip")
index_blob = storage_bucket.blob(index_storage_path)
index_folder_path = os.path.join(extract_destination_path, GCPConfig.INDEX_NAME)
index_generation = 0 # Setting to 0 makes the operation succeed only if there are no live versions of the blob
if not os.path.exists(extract_destination_path):
os.mkdir(extract_destination_path)
if not index_blob.exists():
os.mkdir(index_folder_path)
logging.error(f"{storage_bucket.name} index blob does not exists")
return index_folder_path, index_blob, index_generation
index_blob.reload()
index_generation = index_blob.generation
index_blob.download_to_filename(download_index_path, if_generation_match=index_generation)
if os.path.exists(download_index_path):
with ZipFile(download_index_path, 'r') as index_zip:
index_zip.extractall(extract_destination_path)
if not os.path.exists(index_folder_path):
logging.critical(f"Failed creating {GCPConfig.INDEX_NAME} folder with extracted data.")
sys.exit(1)
os.remove(download_index_path)
logging.success(f"Finished downloading and extracting {GCPConfig.INDEX_NAME} file to "
f"{extract_destination_path}")
return index_folder_path, index_blob, index_generation
else:
logging.critical(f"Failed to download {GCPConfig.INDEX_NAME}.zip file from cloud storage.")
sys.exit(1) | 6d4ab60f6c0e95a9b9a52afc58b510f03d32c8d1 | 11,066 |
def e_qest(model, m):
"""
Calculation of photocounting statistics estimation from
photon-number statistics estimation
Parameters
----------
model : InvPBaseModel
m : int
Photocount number.
"""
return quicksum(model.T[m, n] * model.PEST[n]
for n in model.PSET) | b4b5f9fb4ba1c142af3d91d170fdb90ae960dd0e | 11,067 |
def load_input(fname):
"""Read in the data, return as a list."""
data = [""]
with open(fname, "r") as f:
for line in f.readlines():
if line.strip("\n"):
data[-1] += line.strip("\n") + " "
else:
data[-1] = data[-1].strip(" ")
data.append("")
data [-1] = data[-1].strip(" ")
return data | f83021dd416e3a959996a16bb8d0a0e7352a471f | 11,068 |
import json
def parse_repo_layout_from_json(file_):
"""Parse the repo layout from a JSON file.
Args:
file_ (File): The source file.
Returns:
RepoLayout
Raises:
InvalidConfigFileError: The configuration file is invalid.
"""
def encode_dict(data):
new_data = {}
for key, value in data.items():
# Waf Node API requires String objects
if not isinstance(key, str):
new_data[key.encode('utf-8')] = [i.encode('utf-8')
for i in value]
else:
new_data[key] = value
return new_data
try:
loaded_dict = json.load(file_, object_hook=encode_dict)
except ValueError as e:
raise blderror.InvalidConfigFileError('Invalid .bdelayoutconfig: %s' %
e.message)
repo_layout = repolayout.RepoLayout()
for key in loaded_dict:
if key in repo_layout.__dict__:
setattr(repo_layout, key, loaded_dict[key])
else:
logutil.warn('Invalid field in .bdelayoutconfig: %s.' %
key)
return repo_layout | db1b7843c26ecc6796233e0cc193b41336fecf2d | 11,069 |
def SizeArray(input_matrix):
"""
Return the size of an array
"""
nrows=input_matrix.shape[0]
ncolumns=input_matrix.shape[1]
return nrows,ncolumns | 3ac45e126c1fea5a70d9d7b35e967896c5d3be0b | 11,070 |
def show_fun_elem_state_machine(fun_elem_str, xml_state_list, xml_transition_list,
xml_fun_elem_list):
"""Creates lists with desired objects for <functional_element> state, send them to
plantuml_adapter.py then returns url_diagram"""
new_fun_elem_list = set()
main_fun_elem = check_get_object(fun_elem_str, **{'xml_fun_elem_list': xml_fun_elem_list})
if not main_fun_elem:
return None
if not main_fun_elem.allocated_state_list:
print(f"No state allocated to {main_fun_elem.name} (no display)")
return None
new_fun_elem_list.add(main_fun_elem)
new_state_list = {s for s in xml_state_list if s.id in main_fun_elem.allocated_state_list}
new_transition_list = get_transitions(new_state_list, xml_transition_list)
_, url_diagram = plantuml_adapter.get_state_machine_diagram(new_state_list,
new_transition_list,
xml_fun_elem_list)
print("State Machine Diagram for " + fun_elem_str + " generated")
return url_diagram | 3d8b1426e791bcc40c9850723da9bf350bea361f | 11,071 |
def get_bank_account_rows(*args, **kwargs):
"""
获取列表
:param args:
:param kwargs:
:return:
"""
return db_instance.get_rows(BankAccount, *args, **kwargs) | 0599b2bbae3b7bb044789db6c18f47604c3c9171 | 11,072 |
import importlib
def load_class(class_name, module_name):
"""Dynamically load a class from strings or raise a helpful error."""
# TODO remove this nasty python 2 hack
try:
ModuleNotFoundError
except NameError:
ModuleNotFoundError = ImportError
try:
loaded_module = importlib.import_module(module_name)
class_ = getattr(loaded_module, class_name)
except ModuleNotFoundError as e:
raise PluginModuleNotFoundError(module_name=module_name)
except AttributeError as e:
raise PluginClassNotFoundError(
module_name=module_name,
class_name=class_name
)
return class_ | 02ce2988e45b30da7603acc41fea4846481a94e3 | 11,073 |
def pybo_mod(tokens, tag_codes=[]):
"""extract text/pos tuples from Token objects"""
txt_tags = []
for token in tokens:
tags = []
tags.append(token.text)
# Select and order the tags
for tag_code in tag_codes:
tags.append(get_tag(token, tag_code))
txt_tags.append(tags)
return txt_tags | e96bb6a4774a0e983f2288536921e98207aeaa4b | 11,074 |
def acf(
da: xr.DataArray, *, lag: int = 1, group: str | Grouper = "time.season"
) -> xr.DataArray:
"""Autocorrelation function.
Autocorrelation with a lag over a time resolution and averaged over all years.
Parameters
----------
da : xr.DataArray
Variable on which to calculate the diagnostic.
lag: int
Lag.
group : {'time.season', 'time.month'}
Grouping of the output.
E.g. If 'time.month', the autocorrelation is calculated over each month separately for all years.
Then, the autocorrelation for all Jan/Feb/... is averaged over all years, giving 12 outputs for each grid point.
Returns
-------
xr.DataArray
lag-{lag} autocorrelation of the variable over a {group.prop} and averaged over all years.
See Also
--------
statsmodels.tsa.stattools.acf
References
----------
Alavoine M., and Grenier P. (under review) The distinct problems of physical inconsistency and of multivariate bias potentially involved in the statistical adjustment of climate simulations. International Journal of Climatology, submitted on September 19th 2021. (Preprint: https://doi.org/10.31223/X5C34C)
Examples
--------
>>> from xclim.testing import open_dataset
>>> pr = open_dataset(path_to_pr_file).pr
>>> acf(da=pr, lag=3, group="time.season")
"""
attrs = da.attrs
def acf_last(x, nlags):
# noqa: D403
"""statsmodels acf calculates acf for lag 0 to nlags, this return only the last one."""
# As we resample + group, timeseries are quite short and fft=False seems more performant
out_last = stattools.acf(x, nlags=nlags, fft=False)
return out_last[-1]
@map_groups(out=[Grouper.PROP], main_only=True)
def _acf(ds, *, dim, lag, freq):
out = xr.apply_ufunc(
acf_last,
ds.dat.resample({dim: freq}),
input_core_dims=[[dim]],
vectorize=True,
kwargs={"nlags": lag},
)
out = out.mean("__resample_dim__")
return out.rename("out").to_dataset()
out = _acf(da.rename("dat").to_dataset(), group=group, lag=lag, freq=group.freq).out
out.attrs.update(attrs)
out.attrs["long_name"] = f"lag-{lag} autocorrelation"
out.attrs["units"] = ""
out.name = "acf"
return out | 630eb27574edb40f363f41656a23801f11cefb1c | 11,075 |
import requests
def username(UID: str) -> str:
"""
Get a users username from their user ID.
>>> username("zx7gd1yx")
'1'
>>> username("7j477kvj")
'AnInternetTroll'
>>> username("Sesame Street")
Traceback (most recent call last):
...
utils.UserError: User with uid 'Sesame Street' not found.
"""
R: dict = requests.get(f"{API}/users/{UID}").json()
try:
return R["data"]["names"]["international"]
except KeyError:
raise UserError(f"User with uid '{UID}' not found.") | c2d66af182a970783ef6e2236c1db3e5a3f80b50 | 11,076 |
import logging
def handle_exceptions(func):
"""Exception handler helper function."""
logging.basicConfig(level = logging.INFO)
def wrapper_func(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as e:
logging.error(f'{func.__name__} raised an error: {e}')#, exc_info = True)
return None
return wrapper_func | 2d5c428e65cfb823d1afbf2d2c77f98b8722d685 | 11,077 |
def apply_hamming_window(image):
"""Cross correlate after applying hamming window to compensate side effects"""
window_h = np.hamming(image.shape[0])
window_v = np.hamming(image.shape[1])
image = np.multiply(image.T, window_h).T
return np.multiply(image, window_v) | f319506e9a51350664683ede7411e677bbf96ab3 | 11,078 |
from typing import Tuple
from functools import reduce
def calc_ewald_sum(dielectric_tensor: np.ndarray,
real_lattice_set: np.ndarray,
reciprocal_lattice_set: np.ndarray,
mod_ewald_param: float,
root_det_epsilon: float,
volume: float,
) -> Tuple[float, float]:
"""Return real and reciprocal Ewald summations at given parameters"""
epsilon_inv = np.linalg.inv(dielectric_tensor)
real_sum = 0
# Skip the potential caused by the defect itself
for v in real_lattice_set:
root_r_inv_epsilon_r = np.sqrt(reduce(dot, [v.T, epsilon_inv, v]))
real_sum += \
erfc(mod_ewald_param * root_r_inv_epsilon_r) / root_r_inv_epsilon_r
real_part = real_sum / (4 * pi * root_det_epsilon)
# Ewald reciprocal part
# sum exp(-g * epsilon * g / (4 * ewald ** 2)) / g * epsilon * g [1/A]
reciprocal_sum = 0
for g in reciprocal_lattice_set:
g_epsilon_g = reduce(dot, [g.T, dielectric_tensor, g])
reciprocal_sum += \
(exp(- g_epsilon_g / 4.0 / mod_ewald_param ** 2)
/ g_epsilon_g * cos(dot(g, np.zeros(3)))) # [A^2]
reciprocal_part = reciprocal_sum / volume
return real_part, reciprocal_part | 5be08f833c8e44a4afeab48af0f5160278fbf88a | 11,079 |
import time
def proximal_descent(
x0, grad, prox, step_size, momentum='fista', restarting=None,
max_iter=100, early_stopping=True, eps=np.finfo(np.float64).eps,
obj=None, benchmark=False):
""" Proximal descent algorithm.
Parameters
----------
x0 : array, shape (n_length, ), initial variables
grad : func, gradient function
prox : func, proximal operator function
step_size : float, step-size for the gradient descent
momentum : str or None, (default='fista'), momentum to choose, possible
choice are ('fista', 'greedy', None)
restarting : str or None, (default=None), restarting to chosse, possible
choice are ('obj', 'descent', None), if restarting == 'obj', obj
function should be given
max_iter : int, (default=100), maximum number of iterations to perform the
analysis
early_stopping : bool, (default=True), whether to early stop the analysis
eps : float, (default=np.finfo(np.float64).eps), stoppping parameter w.r.t
evolution of the cost-function
obj : func, (default=None), cost-function function
benchmark : bool, (default=False), whether or not to save the cost-function
and the duration of computatio nof each iteration
Return
------
x : array, shape (n_atoms, n_voxels), the estimated variable
pobj : array or None, shape (n_iter,) or (3 * n_iter,), the saved
cost-function
times : array or None, shape (n_iter,) or(3 * n_iter,), the saved duration
per steps
"""
if benchmark and obj is None:
raise ValueError("If 'benchmark' is set True 'obj' should be given.")
if restarting == 'obj' and obj is None:
raise ValueError("If 'restarting' is set 'obj' 'obj' should be given.")
x_old, x, y, y_old = np.copy(x0), np.copy(x0), np.copy(x0), np.copy(x0)
t = t_old = 1
if benchmark:
pobj, times = [obj(y)], [0.0]
for ii in range(max_iter):
if benchmark:
t0 = time.process_time()
y -= step_size * grad(y)
x = prox(y, step_size)
if momentum == 'fista':
t = 0.5 * (1.0 + np.sqrt(1.0 + 4.0 * t_old**2))
y = x + (t_old - 1.0) / t * (x - x_old)
elif momentum == 'greedy':
y = x + (x - x_old)
elif momentum is None:
y = x
restarted = False
if restarting == 'obj' and (ii > 0) and (pobj[-1] > pobj[-2]):
if momentum == 'fista':
x = x_old
t = 1.0
elif momentum == 'greedy':
y = x
restarted = True
if restarting == 'descent':
angle = (y_old - x).ravel().dot((x - x_old).ravel())
if angle >= 0.0:
if momentum == 'fista':
x = x_old
t = 1.0
elif momentum == 'greedy':
y = x
restarted = True
if benchmark:
t1 = time.process_time()
pobj.append(obj(y))
converged = np.linalg.norm(x - x_old) < eps * np.linalg.norm(x_old)
if early_stopping and converged and not restarted:
break
t_old = t
x_old = x
y_old = y
if benchmark:
times.append(t1 - t0)
if benchmark:
return x, np.array(pobj), np.array(times)
else:
return x | e6a05c2ef4295b67e3bc3ac2b1608b16d43bc09e | 11,080 |
import json
def sign_tx(path,
multisig_address,
redeemscript,
utxo_file,
output_file,
testnet=False):
"""
Sign a spend of a bitcoin 2-of-3 P2SH-multisig address
using a Trezor One Hardware Wallet
Args:
path: BIP32 path of key with which to sign
multisig_address: Address that is being spent
redeemscript: redeem script corresponding to multisig_address
utxo_file: JSON file of UTXOs for multisig_address
(see get_utxo_set.py)
output_file: JSON file of destination addresses and amounts
(see generate_outputs.py)
testnet: Is this a testnet or mainnet address?
Returns:
Dictionary with two keys:
pubkey: public key corresponding to the private key used for signing
signatures: a list of signatures, one per utxo
Raises:
ValueError: If multisig_address is not correct for the given redeemscript
Example:
TODO
"""
with open(utxo_file, 'r') as f:
utxos = json.load(f)
with open(output_file, 'r') as f:
outputs = json.load(f)
# Verify that Pubkeys and Address match
check_address = generate_multisig_address(redeemscript, testnet)
parsed_redeem_script = btc_utils.parse_redeem_script(redeemscript)
if multisig_address != check_address:
raise ValueError("Incorrect Redeem Script")
if testnet:
coin = 'Testnet'
else:
coin = 'Bitcoin'
input_script_type = proto.InputScriptType.SPENDMULTISIG
output_script_type = proto.OutputScriptType.PAYTOADDRESS
tx_api = trezorlib.coins.tx_api[coin]
client = trezor_utils.get_trezor_client()
#client.set_tx_api(tx_api)
# Get signing node:
expanded_path = trezorlib.tools.parse_path(path)
signer = trezorbtc.get_public_node(client, expanded_path, show_display=True).node
# blank HDNodes with public_keys
nodes = [proto.HDNodePathType(node=proto.HDNodeType(public_key=bytes.fromhex(h),
depth=0,
fingerprint=0,
child_num=0,
chain_code=b'0'*32),
address_n=[]
) for h in parsed_redeem_script['pubkeys']]
trezor_inputs = []
for utxo in utxos:
multisig = proto.MultisigRedeemScriptType(
pubkeys=nodes,
m=parsed_redeem_script['m']
)
_input = proto.TxInputType(
prev_hash=bytes.fromhex(utxo['txid']),
prev_index=utxo['n'],
amount=utxo['amount'],
address_n=trezorlib.tools.parse_path(path),
script_type=input_script_type,
multisig=multisig
)
trezor_inputs.append(_input)
txes = {}
for tx in trezor_inputs:
tmptx = tx_api[tx.prev_hash]
txes[tx.prev_hash] = tmptx
# make this multi-output, probably from file
trezor_outputs = []
for output in outputs:
trezor_outputs.append(
proto.TxOutputType(
address=output['address'],
amount=output['amount'],
script_type=output_script_type,
)
)
output_signatures, serialized_tx = trezorbtc.sign_tx(client, coin, trezor_inputs, trezor_outputs, prev_txes=txes)
signature_blob = {"pubkey": signer.public_key.hex(),
"signatures": [s.hex() for s in output_signatures]
}
client.close()
return signature_blob | d9e16f5ce241b52f0cef0edb675936e52d3d2cf8 | 11,081 |
from stable_baselines_custom.common.atari_wrappers import wrap_deepmind
def wrap_atari_dqn(env):
"""
wrap the environment in atari wrappers for DQN
:param env: (Gym Environment) the environment
:return: (Gym Environment) the wrapped environment
"""
return wrap_deepmind(env, frame_stack=True, scale=False) | 6c47492fe412b5620f22db17a45aa42968ed9a62 | 11,082 |
def get_Theta_CR_i_d_t(pv_setup, Theta_A_d_t, I_s_i_d_t):
"""加重平均太陽電池モジュール温度 (6)
Args:
pv_setup(str): 太陽電池アレイ設置方式
Theta_A_d_t(ndarray): 日付dの時刻tにおける外気温度（℃）
I_s_i_d_t(ndarray): 日付dの時刻tにおける太陽電池アレイiの設置面の単位面積当たりの日射量（W/m2）
Returns:
ndarray: 日付dの時刻tにおける太陽電池アレイiの加重平均太陽電池モジュール温度
"""
# 係数 f_A, f_B
if pv_setup == '架台設置型':
f_A_i = get_table_6()[0][0]
f_B_i = get_table_6()[0][1]
elif pv_setup == '屋根置き型':
f_A_i = get_table_6()[1][0]
f_B_i = get_table_6()[1][1]
elif pv_setup == 'その他':
f_A_i = get_table_6()[2][0]
f_B_i = get_table_6()[2][1]
else:
raise NotImplementedError()
# 太陽電池アレイの接地面における風速
V_i_d_t = get_V_i_d_t()
return Theta_A_d_t + (f_A_i/(f_B_i * V_i_d_t**0.8 + 1)+2) * I_s_i_d_t * 10**(-3) - 2 | 6c96d9c4692de19909feccf647fd39126358b29c | 11,083 |
from typing import Set
def or_equality(input_1: Variable, input_2: Variable, output: Variable) -> Set[Clause]:
"""
Encode an OR-Gate into a CNF.
:param input_1: variable representing the first input of the OR-Gate
:param input_2: variable representing the second input of the OR-Gate
:param output: variable representing the output of the OR-Gate
:return: A set of clauses encoding the OR-Gate
"""
return {
frozenset([-input_1, output]),
frozenset([-input_2, output]),
frozenset([input_1, input_2, -output])
} | f101b1d7ae3d70e7849133562cd274275f8419a8 | 11,084 |
import math
def keyPosition_to_keyIndex(key_position: int, key: int) -> int:
"""
キーポジションからどのキーのノーツなのかを変換します
引数
----
key_position : int
-> キーポジション
key : int
-> 全体のキー数、4Kなら4と入力
戻り値
------
int
-> キーインデックス、指定したキーの0~キー-1の間の数
"""
return math.floor(key_position * key / 512) | e6edcc1711a283336da046e1f8f174cc7ff87760 | 11,085 |
import json
def load_file_recipes(fh, enabled_only=False, expensive=False, logger=logger):
"""
Load all the recipes from a given file handle.
:param enabled_only: Set True to limit to only enabled recipes.
:param expensive: Set True to use 'expensive' configurations.
:return: dict(name -> {recipe})
"""
logger.info("Loading recipes from %s", fh.name)
lua_text = fh.read().strip()
logger.debug("Loaded %d bytes", len(lua_text))
# Strip the non-table wrapper.
if not lua_text.startswith(RECIPE_PREFIX) or not lua_text.endswith(RECIPE_SUFFIX):
logger.warning("%s does not appear to be a recipe definition file.", fh.name)
return {}
lua_table = lua_text[len(RECIPE_PREFIX):-len(RECIPE_SUFFIX)].strip()
definitions = {}
for table in slpp.decode(lua_table):
own_version = {}
# Only handle 'recipe's.
if table.get('type') != "recipe":
logger.debug("Ignoring: %s", table)
continue
name = table.get('name').lower()
if not name:
logger.warning("Malformed entry: %s", table)
continue
own_version['name'] = name
# Check if we're skipping disabled recipes.
if enabled_only:
if table.get('enabled', True) is False:
logger.debug("Skipping %s: disabled" % name)
continue
own_version['enabled'] = table['enabled']
# Make sure it has a unique name.
if name in definitions:
raise ParseError("%s: Duplicated recipe: %s" % (fh.name, name))
inset = table.get('normal')
if expensive:
inset = table.get('expensive', inset)
if inset:
if enabled_only and inset.get('enabled', True) is False:
logger.debug("Skipping %s: inset dsabled" % name)
continue
if 'ingredients' in inset:
table = inset
ingredients = table.get('ingredients')
if not ingredients:
logger.warning("Entry with no ingredients: %s", table)
continue
own_version['ingredients'] = {}
for entry in ingredients:
if isinstance(entry, (tuple, list)):
assert len(entry) == 2
assert isinstance(entry[1], int)
own_version['ingredients'][entry[0]] = entry[1]
else:
assert isinstance(entry, dict)
assert len(entry) == 3
own_version['ingredients'][entry['name']] = int(entry['amount'])
if 'energy_required' in table:
own_version['energy_required'] = table['energy_required']
logger.debug("\"%s\": %s", name, json.dumps(own_version, sort_keys=True))
definitions[name] = own_version
return definitions | 8a372981da76f9dc060c79e6cf282612fec8a4b6 | 11,086 |
from masonite.routes import Patch
def patch(url, controller):
"""Shortcut for Patch HTTP class.
Arguments:
url {string} -- The url you want to use for the route
controller {string|object} -- This can be a string controller or a normal object controller
Returns:
masonite.routes.Patch -- The Masonite Patch class.
"""
return Patch().route(url, controller) | c267ca8c2e2c55369584a94cd07aaf26b0b7ae4b | 11,087 |
def get_user(message: discord.Message, username: str):
""" Get member by discord username or osu username. """
member = utils.find_member(guild=message.guild, name=username)
if not member:
for key, value in osu_tracking.items():
if value["new"]["username"].lower() == username.lower():
member = discord.utils.get(message.guild.members, id=int(key))
return member | 323ac71e24e4da516263df3a4683ed5fd87138ce | 11,088 |
import colorsys
def resaturate_color(color, amount=0.5):
"""
Saturates the given color by setting saturation to the given amount.
Input can be matplotlib color string, hex string, or RGB tuple.
"""
if not isinstance(color, np.ndarray) and color in matplotlib.colors.cnames:
color = matplotlib.colors.cnames[color]
hls = colorsys.rgb_to_hls(*matplotlib.colors.to_rgb(color))
new_hls = hls[0], hls[1], amount
new_color = colorsys.hls_to_rgb(*new_hls)
return tuple(np.minimum(np.maximum(0, new_color), 1)) | 2bd1b9b4d9e1d11390efc79f56a89bf7555cbe71 | 11,089 |
def create_reach_segment(upstream_point, downstream_point, polyline, identifier="HA",
junctionID=0, isEnd=False):
"""Returns a polyline based on two bounding vertices found on the line. """
part = polyline.getPart (0)
total_length = polyline.length
lineArray = arcpy.Array ()
#Identifies bounding vertices and associated distance along the line.
if isEnd:
last_point= polyline.lastPoint
upstream_point_dist = round (total_length - polyline.measureOnLine (downstream_point , False) , 2)
downstream_point_dist = round(total_length - polyline.measureOnLine (last_point , False), 2)
else:
upstream_point_dist = round (total_length - polyline.measureOnLine (upstream_point , False) , 2)
downstream_point_dist = round(total_length - polyline.measureOnLine (downstream_point , False), 2)
#Retrieves all vertices between bounding vertices of a polyline.
for pnt in part:
pnt_dist = round(total_length - polyline.measureOnLine (pnt , False), 2)
if pnt_dist <= upstream_point_dist and pnt_dist>=downstream_point_dist:
if lineArray.count == 0:
lineArray.add(upstream_point)
lineArray.add (pnt)
else:
lineArray.add (pnt)
#Makes ending downstream point is added to array
if lineArray[lineArray.count -1].X != downstream_point.X and lineArray[lineArray.count -1].Y != downstream_point.Y:
lineArray.add(downstream_point)
#Creates a new polyline from point array
new_polyline = arcpy.Polyline(lineArray)
identifier = str(identifier)
junc = identifier
if identifier.upper().find('J') == len(identifier)-1:
identifier =identifier.upper()[0:len(identifier)-1] + 'R'
else:
identifier = identifier.upper() + 'R'
return {'name':identifier,'polyline':new_polyline, 'DJunc':junc, 'JuncID':junctionID} | c378fb05c1eda5cde35d5caf60a9d732578ae6d8 | 11,090 |
def sample_recipe(user, **params):
""" Helper function for creating recipes """
""" for not writing every single time this fields """
defaults = {
'title': 'Sample recipe',
'time_minutes': 10,
'price': 5.00
}
"""
Override any field of the defaults dictionary.
Updating the keys:field from params to defaults
if params has any similar key.
If params has a new key, then it appends to defaults.
"""
defaults.update(params)
return Recipe.objects.create(user=user, **defaults) | 11fe56c88cc0c641b1c04b279b2346615b2257c9 | 11,091 |
def _unary_geo(op, left, *args, **kwargs):
# type: (str, np.array[geoms]) -> np.array[geoms]
"""Unary operation that returns new geometries"""
# ensure 1D output, see note above
data = np.empty(len(left), dtype=object)
data[:] = [getattr(geom, op, None) for geom in left]
return data | d302bdb41c74f7b127df4ccd24dd6bc56c694a56 | 11,092 |
def map_func(h, configs, args):
"""Polygons command line in parallel.
"""
if args.verbose:
cmd = "python {} -i {}/threshold{}.tif -o {}/threshold{}.shp -v".format(
configs["path"]["polygons"],
configs["path"]["output"],
h,
configs["path"]["output"],
h
)
print cmd
else:
cmd = "python {} -i {}/threshold{}.tif -o {}/threshold{}.shp".format(
configs["path"]["polygons"],
configs["path"]["output"],
h,
configs["path"]["output"],
h
)
cmd_args = shlex.split(cmd)
stdout,stderr = sp.Popen(
cmd_args,
stdin = sp.PIPE,
stdout = sp.PIPE,
stderr = sp.PIPE
).communicate()
if args.verbose:
print stdout, stderr
return True | 4ff4e961b2d0eb9a19b277a0b8e2ef165aa43819 | 11,093 |
import os
def _runopenssl(pem, *args):
"""
Run the command line openssl tool with the given arguments and write
the given PEM to its stdin. Not safe for quotes.
"""
if os.name == 'posix':
command = "openssl " + " ".join(["'%s'" % (arg.replace("'", "'\\''"),) for arg in args])
else:
command = "openssl " + quoteArguments(args)
write, read = popen2(command, "b")
write.write(pem)
write.close()
return read.read() | ce61d5855d73365d13b28c447566f6ebb75aa030 | 11,094 |
def check_health(request: HttpRequest) -> bool:
"""Check app health."""
return True | 20d572edd68e1518e51cbdbe331c17798bc850fe | 11,095 |
def return_galo_tarsilo(message):
"""Middle function for returning "gaucho" vídeo.
Parameters
----------
message : telebot.types.Message
The message object.
Returns
-------
msg : str
User/Chat alert list addition/removal.
"""
return 'https://www.youtube.com/watch?v=MVYEwZFixJ8' | 58307b763d139dc38220b9a93af15644ccd32959 | 11,096 |
def preimage_func(f, x):
"""Pre-image a funcation at a set of input points.
Parameters
----------
f : typing.Callable
The function we would like to pre-image. The output type must be hashable.
x : typing.Iterable
Input points we would like to evaluate `f`. `x` must be of a type acceptable by `f`.
Returns
-------
D : dict(object, list(object))
This dictionary maps the output of `f` to the list of `x` values that produce it.
"""
D = {}
for xx in x:
D.setdefault(f(xx), []).append(xx)
return D | 6ca0496aff52cff1ce07e327f845df4735e3266a | 11,097 |
import dbm
import sys
def get_spec_id(mat_quality, mat_faction=None):
"""
Get the material_spec id corresponding to the material quality and faction.
Args:
mat_quality (str): A material quality like Basic, Fine, Choice etc...
mat_faction (str): A material faction like Matis, Zoraï etc...
Returns:
int - The id of the corresponding material_spec.
Example:
>>> get_spec_id('Basic', 'Generic')
1
"""
if mat_faction:
dbm.query(
"SELECT id FROM material_spec WHERE quality = ? AND faction = ?",
(mat_quality, mat_faction)
)
else:
dbm.query(
"SELECT id FROM material_spec WHERE quality = ?",
(mat_quality,)
)
try:
return dbm.cur.fetchone()[0]
except TypeError:
print(
"Wrong quality: {} or faction: {}".format(
mat_quality, mat_faction),
file=sys.stderr
)
sys.exit() | dbabe3fb6fd042a3510272aa8c353efd161b5651 | 11,098 |
def print_raw_data(raw_data, start_index=0, limit=200, flavor='fei4b', index_offset=0, select=None, tdc_trig_dist=False, trigger_data_mode=0):
"""Printing FEI4 raw data array for debugging.
"""
if not select:
select = ['DH', 'TW', "AR", "VR", "SR", "DR", 'TDC', 'UNKNOWN FE WORD', 'UNKNOWN WORD']
total_words = 0
for index in range(start_index, raw_data.shape[0]):
dw = FEI4Record(raw_data[index], chip_flavor=flavor, tdc_trig_dist=tdc_trig_dist, trigger_data_mode=trigger_data_mode)
if dw in select:
print index + index_offset, '{0:12d} {1:08b} {2:08b} {3:08b} {4:08b}'.format(raw_data[index], (raw_data[index] & 0xFF000000) >> 24, (raw_data[index] & 0x00FF0000) >> 16, (raw_data[index] & 0x0000FF00) >> 8, (raw_data[index] & 0x000000FF) >> 0), dw
total_words += 1
if limit and total_words >= limit:
break
return total_words | 23464a46d5a3d05702fae3381e3d7623ad9017b5 | 11,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.