content stringlengths 39 14.9k | sha1 stringlengths 40 40 | id int64 0 710k |
|---|---|---|
def removecommongaps(s1, s2):
"""Remove common gap characters between the two sequences.
Return s1, s2 with these characters removed.
"""
if len(s1) != len(s2):
raise ValueError('Sequences must be same length')
return (
''.join(b1 for b1, b2 in zip(s1, s2) if b1 != '-' or b2 != '-'),... | a73c4227b00203033d0aacebc5d8f378fd5ce009 | 75,664 |
def add_position_clsite(modseq, clpos):
"""
Adjusts the position of the Cl site with modifications
"""
# determine the position of the cross-link with modifications in the string
add_pos = 0
for modi in modseq:
# print (cl_pos1, modi[0])
# -1 is needed since we also subtract it f... | 48c0ae8bae6cc353ea5ecd344c5c64c983dba8e8 | 75,665 |
def warmup_lr(init_lr, step, iter_num):
"""
Warm up learning rate
"""
return step/iter_num*init_lr | 2dfb2fc82d63052bf84f9815c5ed9acf09f0fb71 | 75,669 |
import re
def escape_html_syntax_characters(string):
"""
Escape the three HTML syntax characters &, <, >.
& becomes &
< becomes <
> becomes >
"""
string = re.sub('&', '&', string)
string = re.sub('<', '<', string)
string = re.sub('>', '>', string)
return string | 2e07a45c8aa30ca3a7ef0e4a5296d9205de634c6 | 75,674 |
def Measurement_timeofday_method_diff(self,probe):
"""
Computes diff between time values and caches last time.
"""
delta = 0
if hasattr(self,'_last'):
delta = probe.microsecondsSinceEpoch - self._last;
self._last = probe.microsecondsSinceEpoch
return delta | 2b4b4985249af7030de651d55d4a873b310417b1 | 75,677 |
def read_embeddings(args, graph):
"""Read embeddings from an external file."""
with open(args.emb_filename) as f:
# Ignore the first line (# of nodes, # of dimensions).
emb = f.read().splitlines()[1:]
emb = [e.split() for e in emb] # Split with whitespace.
node_names = list(graph.nod... | e32e0323c8ea0156a220e0cd143a490871a3061b | 75,679 |
from typing import Tuple
def _parse_manifest_file(manifest_file_path: str) -> Tuple[list, list]:
""" Parsing manifest file """
audio_paths = list()
transcripts = list()
with open(manifest_file_path) as f:
for idx, line in enumerate(f.readlines()):
audio_path, _, transcript = line.... | 98aeebbb0a3a47f67635aa3ac85b59542c31a14f | 75,680 |
def makeNgramModel(tokenlist, n, fp={}):
"""This function generates an N-gram model as a dictionary data-structure.
"""
for start in range( len(tokenlist) - (n - 1) ):
tokenslice = tokenlist[start : start + n]
#print("Token-slice:", tokenslice)
stringngram = " ".join(tokenslice)
#print... | 1d5f1c36adb36c52d9bbd479c8f328259095f6c8 | 75,681 |
import re
def count(item, string, case_sensitive=False):
"""Returns the exact number of how many times `item` is found in `string`.
:param item: item to count the occurrences of in `string`
:param string: string to count occurrences of `item` in.
:param case_sensitive: if set to `True`, the search af... | 5e4e25fc066dbc0a743560484984b22bc52fe0e6 | 75,686 |
def as_learning_rate_by_sample(learning_rate_per_minibatch, minibatch_size, momentum=0, momentum_as_unit_gain=False):
"""
Compute the scale parameter for the learning rate to match the learning rate
definition used in other deep learning frameworks.
In CNTK, gradients are calculated as follows:
... | 2a07ea0c2541cc29f89c7ab7fe43299aee8ee5fa | 75,694 |
def read_data(data_file):
"""
Reads in whitespace delimited data points
of the form:
2.345 0.87
3.141 6.77
where the last column is the dependent variable
and all columns before are indepndent variables.
param str data_file: path to training data
returns: list of training data insta... | 678f596138676728d921ee254e35fc513eeeefa4 | 75,698 |
import importlib
def import_modules(modules):
"""
Utility function to import an iterator of module names as a list.
Skips over modules that are not importable.
"""
module_objects = []
for module_name in modules:
try:
module_objects.append(importlib.import_module(module_nam... | ea236dc7e62abda22a88691b4fa1caba55684803 | 75,699 |
def suqeuclidean(x, y):
"""Square euclidean distance.
"""
result = 0.0
for i in range(x.shape[0]):
result += (x[i] - y[i]) ** 2
return result | 9be6d56e3dc4629f17b04a31bb1c69033b1bd237 | 75,703 |
import threading
def StrptimeRun(strptime, patched):
"""Checks the given strptime function runs without raising an Exception.
Returns:
True on success, False on failure.
"""
if patched:
import _strptime # pylint: disable=unused-import
def Target(fn):
global error # pylint: disable=global-sta... | ab29a3dced94eeef3c30fe5bfe6f9e125c17d301 | 75,704 |
def filter_columns_by_prefix(columns, prefixes):
"""Filter columns by prefix."""
filtered_columns = {column for column in columns
if True in (column.startswith(prefix)
for prefix in prefixes)}
return filtered_columns | 5757a4d1cd9312e42e9bf9e3e17d4358c546a155 | 75,705 |
def non_negative_validation(value):
"""
Validate if value is negative and raise Validation error
"""
if isinstance(value, list):
if any(v < 0 for v in value):
raise ValueError("The Values in the list must not be negative")
else:
return value
else:
if ... | 9cdb18a781819d856b3ae44bea9a030bac941059 | 75,706 |
def _recompute_best(results):
"""_recompute_best.
Internal helper function for the AnnealResults class. Computes the best
AnnealResult in an AnnealResults object.
Parameters
----------
results : AnnealResults object.
Returns
-------
res : AnnealResult object.
The AnnealRes... | 3d2dd370663c3395bc09dfa3fc864c7f7b2f87c4 | 75,714 |
def func_bool(x):
"""Implementation of `func_bool`."""
return True | 42d6ee553390c8eff1b3194b4b888a1397aee237 | 75,715 |
def inv_mod(n: int, p: int):
"""
Find a inverse of n mod p.
:param n: Value of n where nx === 1 (mod p)
:param p: Value of p where nx === 1 (mod p)
:returns: Value of x where nx === 1 (mod p)
"""
return pow(n, -1, p) | 30847b0869ed8cd4fa425404561233078105eeaf | 75,716 |
import statistics
def smooth(data_in, window_size):
"""Smooths the data, which should be a list, by averaging with the given window size."""
data_in_len = len(data_in)
data_out_len = data_in_len - window_size + 1
if data_out_len <= 0:
return data_in
data_out = []
for i in range(0, dat... | 4ec6eff2e40d2c1804a153d5724b7f241126b844 | 75,719 |
def groupBy(keyFn, row_data):
"""Group rows in row_data by the result of keyFn.
Arguments:
keyFn -- A function that returns the cell data of the column to group by.
Needs to be tailored to the structure of row_data.
row_data -- A table organized as a list of row data structures.
Retur... | 5a6b4fa6bb7a81884c7ecd72c8599f0850e52c11 | 75,720 |
def compose_name(hidden_units, learning_rate, epsilon, lmbda, lr_decay, search_plies=1):
"""Return name for parameter save file based on the hyperparameters."""
name = f'N{hidden_units:d}'
name += f'-alpha{learning_rate:.3f}'
name += f'-lambda{lmbda:.2f}'
name += f'-epsilon{epsilon:.5f}'
name +=... | 671346332a7e4c63ef0038d43eed3acc6d5cc485 | 75,721 |
def get_down_str(down):
"""Converts an integer down to a string.
:param down:
:return:
"""
if down == 1:
return "1st"
elif down == 2:
return "2nd"
elif down == 3:
return "3rd"
else:
return "" | 964dd05a5c4e384e00c0d5ea2be6be52cb44bc36 | 75,723 |
def drop(num):
"""Produce a sequence with the same elements as the input sequence,
but omitting the first num elements.
"""
def dropper(input):
p = num
for elt in input:
if p > 0:
p -= 1
else:
yield elt
return dropper | 97f89a47382475f81265405c2d7024ad22d3ff3f | 75,725 |
def build_geometry(self):
"""Compute the curve (Line) needed to plot the Slot.
The ending point of a curve is the starting point of the next curve in
the list
Parameters
----------
self : SlotW15
A SlotW15 object
Returns
-------
curve_list: list
A list of 6 Segment ... | ad5a09221a623e8a03cf138ae73abb3cb4c20d37 | 75,728 |
def each(xs:list, f) -> list:
"""each(xs, f) e.g. xs >> each >> f
Answers [f(x) for x in xs]"""
return [f(x) for x in xs] | cf601609e17949f8c5ef96688ac76176fb0a647c | 75,729 |
def dict_subset(x, include=[]):
"""Subset a dict."""
return dict((k, v) for k, v in x.items() if k in include) | f278b30d48d623e00bdc669bb08b62ed263f036e | 75,730 |
def zscore_normalize_array(array, mean, std_dev):
"""
Zscore normalize the numpy array based on the genomic mean and standard deviation
:param std_dev:
:param mean:
:param array: Input array of bigwig values
:return: Zscore normalized array
"""
return (array - mean) / std_dev | 2b4f19be7311b1e997f982f82b64c5dd50cf6e8b | 75,731 |
def get_final_pop(dict_gen):
"""
Returns final population of results dict
Parameters
----------
dict_gen : dict
Dict holding generation number as key and population object as value
Returns
-------
tup_res : tuple
Results tuple (final_pop, list_ann, list_co2)
"""
... | dac5abdfe1099abd8d2393aa2c158329f4cf33f4 | 75,733 |
def simplify_logger_name(logger_name: str):
"""Simple function to reduce the size of the loggers name.
Parameters:
logger_name (str): Name of the logger to simplify.
e.g path.to.my_module
Examples:
simplify_logger_name('path.to.my_module') = 'p.t.mm'
"""
modules = [... | eb67b1002dac4feaeae07803a75531d36f7fcceb | 75,737 |
def parse_wire(line):
"""Parse line to directions with steps creating wire."""
wire = []
for instruction in line.split(','):
direction, *steps = instruction
wire.append((direction, int(''.join(steps))))
return wire | 74ec6e11b739093c52687f6e1bfed6854c53c607 | 75,738 |
def ema(df, n, m): #exponential moving average
"""
Wrapper function to estimate EMA.
:param df: a pandas DataFrame.
:return: ema_{t}=(m/n)*a_{t}+((n-m)/n)*ema_{t-1}
"""
result = df.copy()
for i in range(1,len(df)):
result.iloc[i]= (m*df.iloc[i-1] + (n-m)*result[i-1]) / n
retur... | 854593e971036f3a4465948583d4ab21215ac942 | 75,742 |
import typing
import requests
import time
def get_response(
url: str, *, max_attempts=5, **request_kwargs
) -> typing.Union[requests.Response, None]:
"""Return the response.
Tries to get response max_attempts number of times, otherwise return None
Args:
url (str): url string to be retrieved
... | 03a98a3b6fad18bd821418b51997135d1f5683f6 | 75,743 |
import asyncio
def create_task(coroutine):
"""Schedules a coroutine to be run."""
return asyncio.get_event_loop().create_task(coroutine) | f830613139e7e0e65271f12770a13ec03caac83b | 75,744 |
def get_style(format):
"""Infer style from output format."""
if format == 'simple-html':
style = 'html'
elif format in ('tex', 'latex', 'pdf'):
style = 'markdown_tex'
else:
style = 'markdown'
return style | d3ac2bdc64bc76cd689b8de5cc824aed9a2e282c | 75,747 |
def normalise_to_max(xarray,yarray):
"""Given x and y arrays returns a y array which is normailsed to 100% at the maximum value of the original y array"""
ymax=max(yarray)
ynorm = (yarray/ymax)*100
return ynorm | 123bbcb3879389f34cd5f4aba9efc7ee01d310a0 | 75,749 |
def ProfileCurve(type=0, a=0.25, b=0.25):
"""
ProfileCurve( type=0, a=0.25, b=0.25 )
Create profile curve
Parameters:
type - select profile type, L, H, T, U, Z
(type=int)
a - a scaling parameter
(type=float)
b - b scaling parameter
(type=floa... | aafc553eaa9bed3e00187a074e102c86b3851656 | 75,750 |
from pathlib import Path
def path(s):
"""
Returns a :class:`Path` object for the given string.
:param str s: The string containing the path to parse
:returns: A :class:`Path` object representing the path
"""
i = s.rfind('/') + 1
dirname, basename = s[:i], s[i:]
if dirname and dirname ... | bb4af71ec534f59e6376d903472eae8ffdba0498 | 75,754 |
def filter_by_device_name(items, device_names, target_device_name):
"""Filter a list of items by device name.
Args:
items: A list of items to be filtered according to their corresponding
device names.
device_names: A list of the device names. Must have the same legnth
as `items`.
target_dev... | 7beca323c953a59650392f60fa38e73fbc62e4b4 | 75,761 |
import struct
def read_crc(file):
"""Read a crc32 from a file."""
return struct.unpack('<i',file.read(4))[0] | 49bafb0512c224fa458c16c549dd0a3274d5f328 | 75,762 |
import math
def isPointEqual(point1, point2, tol=1e-4):
"""Determins if a Point3D is almost-equal to a Point3D in a list
Args:
point1: (Point3D) The Point to be checked
point2: (Point3D) The Points to check agains
tol: (float) Tollerance for almost-equality
Returns:
bool:... | d103fd3a676b34afac0eaba9aec6b15172c3ff63 | 75,767 |
import time
from datetime import datetime
def format_date(timestamp, precision=0):
"""
Construct an ISO 8601 time from a timestamp.
There are several possible sources for *timestamp*.
- time.time() returns a floating point number of seconds since the
UNIX epoch of Jan 1, 1970 UTC.
- time.... | 305e001bef5aa91d2524e152552073413d974577 | 75,768 |
def joinf(sep, seq):
"""sep.join(seq), omitting None, null or so."""
return sep.join([s for s in filter(bool, seq)]) or None | 42f0cae4d624367c1943955d9dfa3b74d102232d | 75,771 |
from datetime import datetime
import pytz
def now() -> datetime:
"""
Returns the current datetime with the correct timezone information
>>> isinstance(now(), datetime)
True
"""
return datetime.utcnow().replace(tzinfo=pytz.utc) | 3a1966468cf597050750d94627e4f89c75d1b886 | 75,772 |
def is_file_genpath(genpath):
"""
Determine whether the genpath is a file (e.g., '/stdout') or not (e.g., 'command')
:param genpath: a generalized path
:return: a boolean value indicating if the genpath is a file.
"""
return genpath.startswith('/') | 41e6f19a0cedb52de761a5efdbf770aaae373f7d | 75,783 |
def filter_interpolations(base: str, *args) -> str:
"""Filter the interpolations from a string
Args:
base (str): The text to filter
*args: The interpolations (Memory objects) to filter
"""
for memspace in args:
base = str(base).replace(memspace.repr, str(memspace.value))
ret... | 4a27707853f32be1a703497a91d21784ee2f2dc4 | 75,786 |
def request_value(request, key, default=None):
"""
Returns first found value, using this order: POST, GET, default.
:param request:
:param key:
:param default:
:return:
"""
value = request.POST.get(key, None) or request.GET.get(key, None)
if value is not None:
return value
... | 28cc13be18632bee1c1ad43558470bdbaa5100ad | 75,787 |
def get_fitness_score(subject, goal):
"""
In this case, subject and goal is a list of 5 numbers.
Return a score that is the total difference between the subject and the goal.
"""
total = 0
for i in range(len(subject)):
total += abs(goal[i] - subject[i])
return total | 24cd6283d141affd7edff579956274c9c9aee6a4 | 75,788 |
def SearchTFProfNode(node, name):
"""Search a node in the tree."""
if node.name == name:
return node
for c in node.children:
r = SearchTFProfNode(c, name)
if r: return r
return None | dd24c7a299dcc7adab7b8bb0409659bb2623f2cc | 75,790 |
import decimal
def round(val, digits, mode = decimal.ROUND_HALF_UP):
"""
Round a decimal value to the given number of decimal places,
using the given rounding mode, or the standard ROUND_HALF_UP
if not specified
"""
return val.quantize(decimal.Decimal("10") ** -digits, mode) | b9500218759328543eff4cd285b04cf6062d8686 | 75,791 |
def get_available_resources(threshold, usage, total):
"""Get a map of the available resource capacity.
:param threshold: A threshold on the maximum allowed resource usage.
:param usage: A map of hosts to the resource usage.
:param total: A map of hosts to the total resource capacity.
:return: A map... | e5eca0a5eb6977d580f74ae6592b13211ac04f37 | 75,792 |
def remove_response(stream, pre_filt=(0.01, 0.02, 8.0, 10.0),
response_output="DISP"):
"""
Removes the instrument response.
Assumes stream.attach_response has been called before.
"""
stream.remove_response(pre_filt=pre_filt,
output=response_output,
... | a312a30e0c9c45eca2c41118192df5bbdd95c53a | 75,794 |
import hashlib
def sha256(msg):
""" return the hex digest for a givent msg """
return hashlib.sha256(msg).hexdigest() | 0597475f92e1183fbcede6ca7d20d89092bff6a6 | 75,796 |
def read_messages(message_file):
"""(file open for reading) -> list of str
Read and return the message_file, with each line separated into a different
item in a list and the newline character removed.
"""
returned_message = []
contents = message_file.readlines()
for item in contents:
... | c3c6a58ed1a85979165d9a71923fe1911f9a4fe2 | 75,797 |
def concatenate_qa(prev_qns_text_list, prev_ans_text_list):
"""
Concatenates two lists of questions and answers.
"""
qa = ""
for q, a in zip(prev_qns_text_list, prev_ans_text_list):
qa += q + " | " + a + " || "
return qa | 0dc6bca0cc84e5b6a06b67304142369c596624cc | 75,809 |
def is_feat_in_sentence(sentence, features):
"""
Parameters
----------
sentence: str,
One sentence from the info text of a mushroom species
features: list of strs
List of possible features as in dataset_categories.features_list
Return
------
bool,
True if sentence contains a... | 5094edcbcad15ea7b1aaa77a32b5aa758f0ac2d6 | 75,812 |
import re
def add_asic_arg(format_str, cmds_list, asic_num):
"""
Add ASIC specific arg using the supplied string formatter
New commands are added for each ASIC. In case of a regex
paramter, new regex is created for each ASIC.
"""
updated_cmds = []
for cmd in cmds_list:
if isinst... | 652d7b4439e4ad68dee4f125b6b7a7ebe26467c5 | 75,817 |
def set_intersect(variable1, variable2, d):
"""
Expand both variables, interpret them as lists of strings, and return the
intersection as a flattened string.
For example:
s1 = "a b c"
s2 = "b c d"
s3 = set_intersect(s1, s2)
=> s3 = "b c"
"""
val1 = set(d.getVar(variable1).split(... | db68885a18f52bdc439ee0cdbd3f756b9e3dc1cb | 75,824 |
from typing import OrderedDict
def read_dat_file(dat_file):
""" Read an ASCII ".dat" file from JXP format 'database'
Parameters
----------
dat_file : str
filename
Returns
-------
dat_dict : OrderedDict
A dict containing the info in the .dat file
"""
# Define
datdic... | 37df8d16eeb9e45123c14f11ec5aaa2abfcb7b7a | 75,828 |
from typing import Tuple
def _gray_code_comparator(k1: Tuple[int, ...], k2: Tuple[int, ...], flip: bool = False) -> int:
"""Compares two Gray-encoded binary numbers.
Args:
k1: A tuple of ints, representing the bits that are one. For example, 6 would be (1, 2).
k2: The second number, represent... | ba8a23a949b0a92d69574cd525639e83442999c1 | 75,830 |
def reinforce_grad(loss):
"""
A closure to modify the gradient of a nn module.
Use to implement REINFORCE gradient. Gradients will
be multiplied by loss.
Arguments:
- loss: Gradients are multiplied by loss, should be a scalar
"""
def hook(module, grad_input, grad_output):
new_g... | c1dfcf5079e2516785867dd6677ece04b831fcb4 | 75,834 |
def build_array(text):
"""Returns an array of parsed lines from the input text
Array elements are in the format:
(min, max, character, string)
"""
array = []
with open(text, 'r') as f:
for line in f:
_range, char, s = line.strip().split()
n, m = _range.split('... | 2a46b5f09bb08bc146c56d94b175a9c0fbc407ab | 75,837 |
def transpose(matrix):
"""
transposes a 2-dimensional list
"""
return [[matrix[r][c] for r in range(len(matrix))] for c in range(len(matrix[0]))] | 7566e59b976cf17f31884d717ce8e1f634f918ce | 75,839 |
def flip_data_str_signs(data):
"""Flip the signs of data string, e.g. '1 2 3' --> '-1 -2 -3'
"""
return ' '.join([str(-float(i)) for i in data.split()]) | 071509863c8e9616df9eeb20e56b6f52ea090ad2 | 75,843 |
def f90float(s):
"""Convert string repr of Fortran floating point to Python double"""
return float(s.lower().replace('d', 'e')) | 567e7302bd4f28dc252bd75af3851fd7ad3293d7 | 75,847 |
import requests
import pickle
def api_request(file, thresh=0.5):
"""
Post request to serverless backend api where our model is lcoated
Receives a csv with the classes and polygons classified by our model
Parameters
----------
file: .tiff file
Tiff file to be classified by our model
... | 717302d8c8144cb65953298eeef74efa5324a7c0 | 75,849 |
def dep_parenreduce(mysplit, mypos=0):
"""Accepts a list of strings, and converts '(' and ')' surrounded items to sub-lists:
>>> dep_parenreduce([''])
['']
>>> dep_parenreduce(['1', '2', '3'])
['1', '2', '3']
>>> dep_parenreduce(['1', '(', '2', '3', ')', '4'])
['1', ['2', '3'], '4']
"""... | 2d40980bd43cf0902cc7a4fe0fbfff35fdac9e8f | 75,852 |
def imdb_iM_table(imodulon_table, cat_order=None):
"""
Reformats the iModulon table according
Parameters
----------
imodulon_table : ~pandas.DataFrame
Table formatted similar to IcaData.imodulon_table
cat_order : list, optional
List of categories in imodulon_table.category, orde... | d8140b4642961879cbc0601b812aaac302873c24 | 75,856 |
def uint_size(value):
"""Returns number of bytes (power of two) to represent unsigned value."""
assert value >= 0
n = 8
while not value < (1 << n):
n *= 2
return n // 8 | 73ef3be70f3a9af28e45f0f0ed57830508cb756b | 75,858 |
import re
def github_to_markdown_body(body: str) -> str:
"""
Generate a markdown body from the GitHub provided one.
:param body: The markdown body provided by the GitHub Releases.
:returns: A markdown body.
"""
body = re.sub(
r"#(\d{1,5})", r"[#\1](https://github.com/rucio/rucio/issu... | 6a738960f202a805de1a01a2821c6178ec388f54 | 75,866 |
def poly_np(x, *coefs):
"""
f(x) = a * x + b * x**2 + c * x**3 + ...
*args = (x, a, b, ...)
"""
# Add a warning for something potentially incorrect
if len(coefs) == 0:
raise Exception("You have not provided any polynomial coefficients.")
# Calculate using a loop
result = x * 0... | 4e77a0841478c817ce1904cb1f41c8bbf9238e53 | 75,871 |
def symbols_gen(N): # генерация списка из символов для красивого вывода матрицы.
"""
Функция, которая генерирует символы для уравнений
:params N: количество переменных
:return symbols: сгенерированные символы, список
"""
symbols = []
for i in range(65, 65 + N):
symbols.a... | 4874d66082473cc02dd10d3f9e5c3c17aed995fd | 75,873 |
def _neighbors(point):
"""
Get left, right, upper, lower neighbors of this point.
"""
i, j = point
return {(i-1, j), (i+1, j), (i, j-1), (i, j+1)} | fd90d5c270c68c38a2ac352b0f1f064c1df377da | 75,876 |
def compute_out_degrees(digraph):
""" dict -> dict
Takes a directed graph represented as a dictionary, and returns a dictionary
in which the keys are the nodes and the values are the nodes' outdegree
value.
"""
out_degrees = {}
for node in digraph:
out_degrees[node] = len(digraph[nod... | f50050974a4e053ec4273e63b45f70a90c65d0f5 | 75,877 |
def overlaps_v(text_proposals, index1, index2):
"""
Calculate vertical overlap ratio.
Args:
text_proposals(numpy.array): Text proposlas.
index1(int): First text proposal.
index2(int): Second text proposal.
Return:
overlap(float32): vertical overlap.
"""
h1 = tex... | 7c8f1167e2334b80356db2f3d099a9081ddda6b9 | 75,878 |
def getIstioServiceName(service_name, project_id, zone):
""" Returns the Istio service name of a certain service. """
return "ist:{}-zone-{}-cloud-ops-sandbox-default-{}".format(project_id, zone, service_name) | c1dde7fb92d8415df1eec6343986cc4f152289fc | 75,882 |
import torch
import math
def gaussian(window_size, sigma):
"""
Generates a list of Tensor values drawn from a gaussian distribution with standard
diviation = sigma and sum of all elements = 1.
Length of list = window_size
"""
gauss = torch.Tensor([math.exp(-(x - window_size//2)**2/float(2*sig... | 424ead50a8283b57f96f851d4c85be63636f98bd | 75,883 |
import random
def randBytes(b: int = 2) -> bytes:
"""
Get a random number of bytes
:param b: number of bytes generate
:return: random number of bytes requested
"""
return bytes([random.getrandbits(8) for _ in range(b)]) | 51af4722e9710f0cff315a09bb9ce2f6e956ee6a | 75,884 |
from typing import List
from typing import Any
def sort_file_summary_content(data: List[Any]) -> List[Any]:
"""sorts the summary file contents"""
return sorted(
data,
key=lambda x: x["branch"]
+ x["host"]
+ x["compiler"]
+ x["c_version"]
+ x["mpi"]
+ x["... | dbcc135bafdb097e00ea25e9cd6172599d5faa43 | 75,885 |
import copy
def badmatch(match, badfn):
"""Make a copy of the given matcher, replacing its bad method with the given
one.
"""
m = copy.copy(match)
m.bad = badfn
return m | f9937a4076ede88b25735a0b095e63d7082da620 | 75,889 |
import yaml
def update_config(config, updates):
"""Modifies the YAML configurations, given a list of YAML updates.
"""
if isinstance(updates, str):
updates = [updates]
for update in updates:
edits = yaml.safe_load(update)
for k, v in edits.items():
node = config
... | f9c66068226fc44d8fe8f35bb1f21a6d8648b3fb | 75,891 |
from typing import List
from typing import Union
from pathlib import Path
def cli_args(tmpdir) -> List[Union[Path, str]]:
"""
Fixture simulating a set of CLI arguments.
Returns:
List of args.
"""
in_folder = Path("requirements.in")
assert in_folder.exists()
out_folder = Path(tmpd... | bbfdc585289dbbdb5cd532b2791bf695cb2f5a91 | 75,892 |
def sentinel(name):
"""Return a named value to use as a sentinel."""
class Sentinel(object):
def __repr__(self):
return name
return Sentinel() | 9e7d7dd333e7e0544c37744c603eccbbf36a9eea | 75,896 |
import math
def event_prediction(alpha, var, r_t):
"""
predict the total number of retweets
:param alpha: a parameter of linear regression (alpha)
:param var: a parameter of linear regression (variance)
:param r_t: the total number of tweet at the observation time
:return: predicted number o... | 96b2c6f96f150856ef6de7be70b618095bc069ca | 75,897 |
def create_snapshot_repo(els, reponame, body, verify=True):
"""Function: create_snapshot_repo
Description: Creates a repository in Elasticsearch cluster.
Arguments:
(input) els -> ElasticSearch instance.
(input) reponame -> Name of repository.
(input) body -> Contains arguments ... | 6a7bf809bfc7c9654a1779d45e65634a8266060a | 75,898 |
def calculate_dir(start, target):
"""
Calculate the direction in which to go to get from start to target.
start: a tuple representing an (x,y) point
target: a tuple representing an (x,y) point
as_coord: whether you want a coordinate (-1,0) or a direction (S, NW, etc.)
"""
dx = target[0] - st... | f728b0bbb80c3726218a73fd54d050eab25408e3 | 75,900 |
def rectified_linear_unit(x):
""" Returns the ReLU of x, or the maximum between 0 and x."""
return x*(x > 0) | b59c8baae1cc997ae17188b08117776683c28ba7 | 75,905 |
def get_meta_value(meta, *keys, default=None):
"""
Return value from metadata.
Given keys can define a path in the document tree.
"""
try:
for key in keys:
if not meta:
raise KeyError(key)
meta = meta[key]
return meta
except KeyError:
... | 89dfbe8ca157e51848a311c49a99de657f9238af | 75,906 |
def as_words(string):
"""Split the string into words
>>> as_words('\tfred was here ') == ['fred', 'was', 'here']
True
"""
return string.strip().split() | 543472e536da2024d118a22575348bbb263abcaf | 75,907 |
def getChildIndex(parent, toFind):
"""
Return the index of the given child in the given parent.
This performs a linear search.
"""
count = 0
child = parent.firstChild
while child:
if child == toFind:
return count
if child.nodeType == 1:
count += 1
... | abea7fd879a675d8e14a7d163518c3cc7fe33198 | 75,912 |
import itertools
def pairwise(iterable):
"""For a list ``s``, return pairs for consecutive entries. For example,
a list ``s0``, ``s1``, etc. will produce ``(s0,s1), (s1,s2), ...`` and so
on.
See: https://docs.python.org/3/library/itertools.html#recipes."""
a, b = itertools.tee(iterable)
next(... | 8e0a3dd02db27c547870b8ada2e848be128690b6 | 75,915 |
import torch
def clip_tensor(x, lb=0., ub=1.):
"""
Clip a tensor to be within lb and ub
:param x:
:param lb: lower bound (scalar)
:param ub: upper bound (scalar)
:return: clipped version of x
"""
return torch.clamp(x, min=lb, max=ub) | ce6d53080285bf53c118f6f3cc9cc22830d792d1 | 75,918 |
def between(data, delim1, delim2):
"""Extracts text between two delimiters.
Parameters
----------
data : str
Text to analyse
delim1 : str
First delimiter.
delim2 : str
Second delimiter.
Returns
-------
str
Text between delimiters.
"""
return ... | 781c62d3a925449f9d5bfce1fc744f366e61767f | 75,925 |
import getpass
def ask_user_password(prompt: str) -> str:
"""
Read a password from the console.
"""
return getpass.getpass(prompt + ": ") | e0ea187d3f92e02d27d5bba7ad0feba3f8ee12a3 | 75,930 |
def decode(minterm,n_variables):
"""
输入最小项编号，输出最小项的01串
:param minterm: 待转化成string的
:param n_variables: 变元数量
:return: 最小项的01串
:rtype: str
"""
result=['0']*n_variables
for i in reversed(range(n_variables)):
result[i]=str(minterm%2)
minterm=minterm//2
return ''.join(... | 7cd014c293859f18e9e59fa992054df762cd77df | 75,933 |
def lisp_string(python_string):
"""
Convert a string to a Lisp string literal.
"""
return '"%s"' % python_string.replace('\\', '\\\\').replace('"', '\\"') | e50d21f9c2b8e5438679f680773a7a18fd951e7d | 75,937 |
import bisect
def findClosest(a, x):
"""
Returns index of value closest to `x` in sorted sequence `a`.
"""
idx = bisect.bisect_left(a, x)
if idx == 0:
return a[0]
if idx == len(a):
return a[-1]
if a[idx] - x < x - a[idx - 1]:
return idx
else:
return idx ... | a5d33f353324fafc6fde07b88832e96c9f97e0bb | 75,938 |
def choose(n, k):
"""
return the binomial coefficient of n over k
"""
def rangeprod(k, n):
"""
returns the product of all the integers in {k,k+1,...,n}
"""
res = 1
for t in range(k, n+1):
res *= t
return res
if (n < k):
... | e76f01a39c0c5c731799cb02ead5ae096bd55e02 | 75,943 |
def tsv(infile, comment=None):
""" Returns a generator for tab-delmited file.
Args:
infile: Input file as a file-like object
comment (str): Rows beginning with this string will be ignored.
Returns:
generator: A generator that yields each row in the file as a list.
"""
if c... | 1588c5fb67cdeda424a3ea76de7d013e68b116f3 | 75,951 |
def fix(s: str) -> str:
""" This function capitalise the first letter of the first word of each sentence. """
my_s = [i.capitalize() for i in s.split('. ')]
return '. '.join(map(str, my_s)) | 2ceb5ea948f47771e259b3f895d49b0689a9e263 | 75,959 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.