content
stringlengths 35
416k
| sha1
stringlengths 40
40
| id
int64 0
710k
|
|---|---|---|
import yaml
def from_yml(yml_string: str) -> dict:
"""Load the given YAML string into a dict
:param yml_string: YAML string to work on
:type yml_string: str
:return: dict representation of the given YAML string
:rtype: dict
"""
config: dict = yaml.safe_load(yml_string)
return config
|
28868d568fa519e795df4a32ecae8608da6465d6
| 697,750
|
import string
import random
def generator(length):
"""Generate a random sequence of bytes
Args:
length (int): length
Returns:
bytes: random sequence of bytes
"""
letters = string.printable
return ''.join(random.choice(letters) for i in range(length)).encode()
|
e7a7f22ec3470e9bf45b0084fdc9da917c1f18fb
| 697,751
|
import math
def latlng_index(lat, lng, mult=1 / 15):
"""Convert latitude and longitude to 'indexes'.
"""
# 'mult' = 1 / approx-bucket-size-in-deg
ilat = int(round((lat + 90.0) * mult))
mult = mult * math.cos(abs(lat) * math.pi / 180.0)
ilng = int(round((lng + 180.0) * mult))
return {'latIndex': ilat, 'lngIndex': ilng}
|
bd297216545dca725ec10c1a301251acd929fecf
| 697,752
|
import logging
def get_loglevel(loglevel):
""" Check valid log level supplied and return numeric log level """
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError("Invalid log level: %s" % loglevel)
return numeric_level
|
017bc0be3e5feb890ccd7477bedb87d1077f1ef5
| 697,753
|
def count_marked_as_done(idx):
"""
:param idx:
:return:
"""
return idx
|
1ffd0a3831ac80b2ba955bdb0b2f922b5375c84b
| 697,754
|
def get_nan_audio():
"""
returns list of audio files to test in test_for_nan_values
"""
audio_files = [
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/6689/64286/6689-64286-0001.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/1760/143006/1760-143006-0080.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/1579/128155/1579-128155-0012.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/25/123319/25-123319-0055.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/1579/128155/1579-128155-0012.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/4484/37119/4484-37119-0018.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/3433/135988/3433-135988-0038.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-clean-100/887/123289/887-123289-0001.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-clean-100/4137/11701/4137-11701-0029.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/937/148985/937-148985-0022.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/4931/28257/4931-28257-0042.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-clean-100/8312/279790/8312-279790-0043.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/4741/27757/4741-27757-0051.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/8302/281331/8302-281331-0012.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-clean-100/32/21631/32-21631-0012.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/2541/159352/2541-159352-0044.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-clean-100/2092/145706/2092-145706-0022.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/5045/1197/5045-1197-0002.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/3871/692/3871-692-0025.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/1690/142293/1690-142293-0035.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-clean-100/7078/271888/7078-271888-0058.wav",
"/mnt/disks/data_disk/home/dzubke/awni_speech/data/LibriSpeech/train-other-500/5220/112590/5220-112590-0002.wav"
]
return audio_files
|
16ffd9457749044bf1f2d68069ec0e3d98116800
| 697,755
|
def safe_column_name(name):
"""Generate SQL friendly column name"""
return '"{}"'.format(name).upper()
|
495b54a94c4350a8f20df5a1416a5c8c10d7a559
| 697,756
|
import re
def name_validalidation(name, context):
"""Function used to validate various names"""
if len(name.strip()) == 0 or not re.match("^[-a-zA-Z0-9_\\s]*$", name):
message = "Name shouldn't be empty. No special characters"
response = {
"message": message + " for " + context + " names",
context: "null"
}
return response, 400
|
56e759d40f1b6bb3a99437c1f976fbb9232ce6bf
| 697,757
|
import os
def load_random_test_dir():
"""
Relies on being run from test_docker.py (not ideal)
"""
loc = os.path.join(str(os.getcwd()),
'test_backend/testdir/')
return loc
|
bdbc7c3454b40cd9eabeeb7627f78a13b97f9af1
| 697,758
|
def column_name_list(columns):
"""
Gets a comma-separated list of column names.
:param columns: The list of columns.
:returns: A comma-separated list of column names.
"""
if not columns:
return ''
return ', '.join([column.name for column in columns])
|
7c40e420e55368454768d84229f959a11b5c00dd
| 697,759
|
def make_0032():
"""World Server Addr Request(start)(s0031)"""
return ""
|
17a166822b9d083c104c652abfc6a5c20cf1743c
| 697,760
|
import os
def file_list(root, file_type):
"""
:param root: root directory
:param file_type: .xml in our app
:return: complete list of file paths
"""
return [os.path.join(directory_path, f) for directory_path, directory_name,
files in os.walk(root) for f in files if f.endswith(file_type)]
|
dd51a70cb4f6d9736d8a59de97ee2bfed67f85eb
| 697,761
|
def positiveaxis(axis, ndim):
"""Positive axis
Args:
axis(num): dimension index
ndim(num): number of dimensions
Returns:
num
"""
if axis < 0:
axis += ndim
if axis < 0 or axis >= ndim:
raise IndexError("axis out of range")
return axis
|
3075c06cf5843027bc45e04e032798250924f8fd
| 697,763
|
def add_schema_ownerships(spec, dbcontext):
"""
Add schema ownerships to an existing spec
One set of assumptions is made here: if a schema's name is the same as its owner and that
owner can login, then the schema is assumed to be a personal schema. This is an assumption
though, and ithe implication is that when `pgbedrock configure` is run, if there are any
objects in that schema that are not owned by the schema owner they will have their ownership
changed (to be the same as the schema owner).
Returns:
dict: The input spec with schema ownerships added
"""
personal_schemas = dbcontext.get_all_personal_schemas()
schemas_and_owners = dbcontext.get_all_schemas_and_owners()
for schema, owner in schemas_and_owners.items():
if schema in personal_schemas:
# Any schema where the owner is the same as the schema's name and the owner can
# log in is assumed to be a personal schema. See docstring for implications
spec[owner]['has_personal_schema'] = True
else:
if 'owns' not in spec[owner]:
spec[owner]['owns'] = {'schemas': []}
elif 'schemas' not in spec[owner]['owns']:
spec[owner]['owns']['schemas'] = []
spec[owner]['owns']['schemas'].append(schema)
return spec
|
c4551c22760b3ec837b7f3cb2a83840c2bd46481
| 697,764
|
def is_desired_workflow(run_json):
"""
Checks if this run is for the "Presubmit Checks" workflow.
"""
# Each workflow has a fixed ID.
# For the "Persubmit Checks" workflow, it is:
# https://api.github.com/repos/taichi-dev/taichi/actions/workflows/1291024
DESIRED_ID = 1291024
return run_json['workflow_id'] == DESIRED_ID
|
fc5d915fd3e7b8a62075b29fc9dbe8525fc4da0a
| 697,765
|
def format_codepoint(codepoint):
"""Format a codepoint (integer) to a USV (at least 4 hex digits)"""
usv = ''
if codepoint:
usv = f'{codepoint:04X}'
return usv
|
c3ac63ab0218ad90f7191507a825e95a4f4ab80c
| 697,766
|
def ipv4_addr_to_reverse(addr):
"""
Returns the string in reverse, dot as delemiter
1.2.3.4 returns 4.3.2.1
"""
ip = addr.split(".")
return ".".join(reversed(ip))
|
f471e5181082e27018a3239614f7b7ec4f6719a4
| 697,767
|
def get_dim_coord_names(cube):
"""
Returns an ordered list of dimension coordinate names on the cube
Args:
cube (iris.cube.Cube)
Returns:
list of str
"""
return [coord.name() for coord in cube.coords(dim_coords=True)]
|
ec742b197f02d13e067a250685438f0ed88615e5
| 697,768
|
def _noisepeak(amp, npk1):
"""
Private function intended to insert a new RR interval in the buffer.
----------
Parameters
----------
amp : int
Amplitude of the peak under analysis.
npk1 : int
Actual value of NPK1 parameter defined in Pan-Tompkins real-time R peak detection algorithm
(named noise peak).
Returns
-------
npk1 : float
Updated value of NPK1 parameter.
"""
npk1 = 0.125 * amp + 0.875 * npk1 # npk1 is the running estimate of the noise peak
return npk1
|
76d2fef2a78b0af4c6478d3f520784d427991e06
| 697,769
|
def get_center_of_mass(centers_of_mass, masses):
"""Determine the center of mass of a set of objects
Args
centers_of_mass [*shape, num_objects, 2]
masses [*shape, num_objects]
Returns [*shape, 2]
"""
return (centers_of_mass * masses[..., None]).sum(-2) / masses.sum(-1)[..., None]
|
22c95024120579ed8471f093ddedd9da75b4ed0f
| 697,770
|
def printPath(path):
"""Assumes path is a list of nodes"""
result = ''
for i in range(len(path)):
result += str(path[i])
if i != len(path) - 1:
result += '->'
return result
|
1974c31df44e89a69f8e59d3f81288fb054ae9e5
| 697,771
|
import copy
def start_board(solution_board):
"""Generates an empty board from a solution board"""
empty_board = copy.deepcopy(solution_board)
for row in empty_board:
for index in range(len(row)):
row[index] = '-'
return empty_board
|
fafa73da5867bf7ae324a0531c64c16ae5789f0d
| 697,772
|
def safe_get(list, index, fallback_value):
"""Similar to dict's .get(key, fallback) function but for lists. Returns a fallback/default value if the index is not valid for the list, otherwise returns the value at that index.
Args:
list (_type_): a list-like object
index (_type_): an index into the list
fallback_value (_type_): any value to be returned when the indexing fails
Returns:
_type_: the value in the list, or the fallback_value is the index is not valid for the list.
"""
try:
return list[index]
except IndexError:
return fallback_value
|
bf799f45a04335adc7673aff155b301333ff8e26
| 697,773
|
def clusters_to_labels(clusters):
"""
:param clusters: List of lists, each sublist contains doc ids in that cluster
:return labels: Dict of [doc_id, cluster_label] where cluster_label are assigned from positive ints starting at 1
"""
labels = dict()
for label, cluster in enumerate(clusters):
for doc_id in cluster:
labels[doc_id] = label
return labels
|
4a443b729965d4632dc3ff68cb0828bcc2f4f2ff
| 697,774
|
import time
def execute_in_hammer_mode(func):
"""
A decorator for automation of reconnecting.
"""
n_trials = 3
sleep_time = 1
sleep_factor = 1
def wrapper(*args, **kwargs):
for i in range(n_trials):
try:
return func(*args, **kwargs)
except Exception as e:
if i == n_trials - 1:
raise RuntimeError(e)
else:
time.sleep((1 + sleep_factor * i) * sleep_time)
# `args[0]` is an instance of `InMemoryStorage`
args[0].close_connection()
args[0].connect()
continue
return wrapper
|
dbbbc1031181ed49587914299ba412ef40b15417
| 697,775
|
def binarySearch(arr, x):
"""Returns the lowest index of the element equal to `x` or NaN if not found."""
if len(arr) == 0:
return 0
m = len(arr) // 2
if arr[m] < x:
return m + 1 + binarySearch(arr[m + 1:], x)
elif x < arr[m] or (0 < m and arr[m - 1] == x):
return binarySearch(arr[:m], x)
else:
return m
|
4b2511f5e74c25c7f027281a16be703ec352fe19
| 697,776
|
def to_bytes(value, encoding='utf8'):
"""
cast string to bytes() like object, but for python2 support it's bytearray copy
"""
if isinstance(value, bytes):
return value
if isinstance(value, str):
return value.encode(encoding)
elif isinstance(value, bytearray):
return bytes(value)
else:
raise TypeError("Not a string or bytes like object")
|
6c42f9787c485ab7043665f806a9e6c728b5835a
| 697,777
|
import subprocess
def clear_screen():
"""Clear the terminal screen."""
subprocess.call(["reset"])
return None
|
2cb77e499abe4f4c930b66b12bb543fb6f8726e2
| 697,778
|
import ftplib
def connectToFTP(host, usern, passw,verb):
"""
Creates an FTP Connection with the given details using FTPLib.
:param host: Hostname (e.g. IP address) of the connection
:param usern: Username to login with
:param passw: password
:param verb: print errors or not.
:return: FTP Connection object. Success:1, Failure:0
"""
try:
ftp = ftplib.FTP(host, usern, passw)
ftp.encoding = "utf-8"
ftp.set_pasv(False)
except Exception as e:
if verb:
print(e)
print("\nERROR while creating FTP Connection \n")
return None,0
return ftp,1
|
f6c4dabedbc400204d85cf699a7c592b38704d7d
| 697,779
|
import yaml
import json
def render_yaml(value):
"""
Render a dictionary as formatted YAML. This filter is invoked as "yaml":
{{ data_dict|yaml }}
"""
return yaml.dump(json.loads(json.dumps(value)))
|
dc90315ebc6271eec12531095214ecc24d0df9e8
| 697,780
|
def getHosts(args):
"""
Reads CSV file in
"""
if args.file:
with open(args.file) as f:
return f.read().splitlines()
return args.list.split(',')
|
20e2150a5ac294671a7ad8cf1c47fd1b205d0de7
| 697,781
|
def call_instance_method(instance, name, args, kwargs):
"""indirect caller for instance methods for multiprocessing
Args:
instance: the instance to call method with
name (str): method name to call
args (tuple or None): arguments to be passed to getattr(instance, name)
kwargs (dict or None): kwargs to be passed to getattr(instance, name)
Returns:
the returned values of getattr(instance, name)
"""
if args is None:
args = ()
if kwargs is None:
kwargs = {}
return getattr(instance, name)(*args, **kwargs)
|
30831cafeab2a4f3310a21c41a03e8d3ec9a43ec
| 697,782
|
import numpy
def fdstencil(z, x, nderiv=None):
"""Compute finite difference weights using recurrences for Lagrange polynomials (see Fornberg 1998)"""
if nderiv is None:
nderiv = len(x)
x = numpy.array(x) - z
k = numpy.arange(nderiv+1)
c = numpy.outer(0.*k, x)
c[0,0] = 1
prod = 1
for j in range(1,len(x)):
dx = x[j] - x[:j]
c[1:,j] = x[j-1]*c[1:,j-1] - k[1:]*c[:-1,j-1]
c[0,j] = x[j-1]*c[0,j-1]
c[:,j] *= -prod
prod = numpy.prod(dx)
c[:,j] /= prod
c[1:,:j] = (x[j]*c[1:,:j] - k[1:,None]*c[:-1,:j]) / dx
c[0,:j] = x[j]*c[0,:j] / dx
return c
|
1e350dfefb15fc82596164d23909b027d9e14b3e
| 697,783
|
def is_iterable(obj):
"""is_empty: Check if object is iterable.
:obj:
:returns: Bool
"""
try:
return bool(iter(obj))
except TypeError as e:
return False
|
793846dbb1503b477115cbb4debfadd65c72a70c
| 697,784
|
def refactorize(arr, first_na, na_sentinel=-1):
"""
Modify `arr` *inplace* to match pandas' factorization rules.
This detects the code missing values were assigned, sets
those to `na_sentinel`, and shifts codes above that value
down by 1 to fill the hole.
Parameters
----------
arr : ndarray
First return value from :meth:`pandas.factorize`
first_na : int
The index location of the first missing value
na_sentinel : int, default -1
Value to set for missing values.
"""
# A naive benchmark shows that this gets ~285x speedup
# with numba on a 10,000 element array.
na_code = arr[first_na]
for i in range(len(arr)):
val = arr[i]
if val == na_code:
arr[i] = na_sentinel
elif val > na_code:
arr[i] -= 1
return arr
|
31d5e07650bb0ec6f93d59d453d8de859ab0c621
| 697,785
|
import time
import hashlib
def generate_file_name(filename):
"""
@brief generate file name
@return new file name
"""
i = filename.rfind('.')
ext = filename[i:]
tmp = filename + str(int(time.time()))
hash_md5 = hashlib.md5(tmp)
return hash_md5.hexdigest() + ext
|
c4b3aebbaecafd85087769c179e33fdbd77a2b17
| 697,786
|
def get_file_id(service, file_name, mime_type=None, parent_id=None):
"""Return the ID of a Google Drive file
:param service: A Google Drive API service object
:param file_name: A string, the name of the file
:param mime_type: A string, optional MIME type of file to search for
:param parent_id: A string, optional id of a parent folder to search in
:return file_id: A string, file ID of the first found result
"""
file_id = None
query = """name='{}'
and trashed=False
""".format(file_name)
if parent_id:
query += "and parents in '{}'".format(parent_id)
if mime_type:
query += "and mimeType in '{}'".format(mime_type)
try:
results = service.files().list(
q=query,
fields='files(name, id)').execute()
if len(results['files']) > 1:
print('Multiple files found, retrieving first from list')
file_id = results['files'][0]['id']
except Exception as e:
print('An error occurred: {}'.format(e))
return file_id
|
e8e371ea740ca4be55b35baa74c28207ca6b7b4d
| 697,787
|
def get_section(f, first_delim, second_delim):
"""
Some open-source indicator downloads contain multiple sections.
This will return the section of the file f that is between the first_delim and second_delim
:param f: The file containing the section to be processed
:type f: file
:param first_delim: A string representing the beginning of the section
:type first_delim: str
:param second_delim: A string representing the terminator of the section
:type second_delim: str
:returns: list
"""
g = []
line = f.readline()
while line.find(first_delim) == -1:
line = f.readline()
if not line: return(None)
line = f.readline()
if second_delim != "":
while line.find(second_delim) == -1:
g.append(line)
line = f.readline()
else:
for line in f:
g.append(line)
return(g)
|
d0d08cf5fc157b7361c4ff5e20fe466de76d93fb
| 697,788
|
from typing import Dict
def number_topics_and_clusters(model, level: int) -> Dict[str, int]:
"""Get the number of topics and clusters for a level of the model hierarchy."""
model.get_groups(level)
return {
"n_topics": model.groups[level]["Bw"],
"n_clusters": model.groups[level]["Bd"],
}
|
ff587450e06bb6ce7ce97bd454c310a7b8d9e4b1
| 697,790
|
import re
def get_year_from_date_str(date_str):
"""
Retrieve only the year from a text string.
"""
return re.findall(r'\d{4}', date_str) if date_str else None
|
b2b02e97963d12236f20dad5d6b5337404a0dfc7
| 697,791
|
from typing import Any
from typing import Dict
def split_bool(param: Any) -> Dict[str, Any]:
""" Split query parameter into filter-bool parameters """
if not param:
return {}
if type(param) == bool:
return dict(value=param)
value = param.lower() in ["true", "yes", "on", "1"]
return dict(value=value)
|
1323eb2ccb1c54957470e8f51ffe8e594d76cabc
| 697,792
|
def limit(value, min_val, max_val):
"""Returns value clipped to the range [min_val, max_val]"""
return max(min_val, min(value, max_val))
|
8005e5cc9b6947e265f93eed1aa19f4e2abcc5ab
| 697,794
|
def int2tap(x):
"""Convert integer to tap position."""
if x[0] == "-":
res = "pre" + x[1:]
else:
res = "post" + x
return res
|
2af5e1b98258dfb921005a454689d862bdf3d9fe
| 697,795
|
def generate_list(start, stop, step):
"""
>>> generate_list(0, 5, 1)
[0, 1, 2, 3, 4]
>>> generate_list(0, 0, 1)
[]
>>> generate_list(5, 10, 2)
[5, 7, 9]
>>> generate_list(10, 5, -2)
[10, 8, 6]
"""
idx = start
lst = []
if idx < stop:
while idx < stop:
lst.append(idx)
idx += step
else:
while idx > stop:
lst.append(idx)
idx += step
return lst
|
51082bd4acf65abdaacbb98b429d79dcb718d9f7
| 697,796
|
def blocksearch(block, name):
""" Recursive search for name in block (inner blocks)
Args:
name (str): search term
Returns:
Block OR False
"""
if hasattr(block, 'tokens'):
for b in block.tokens[1]:
b = (b if hasattr(b, 'raw') and b.raw() == name else blocksearch(
b, name))
if b:
return b
return False
|
da9f762dddabe762dbabd80addebc0a957b04135
| 697,798
|
import hashlib
def get_hash_of_file(fname, algo="sha512"):
"""Returns the hexdigest of the SHA512 checksum of the
file found at fname.
"""
block_size = 65536
if algo.lower() == "md5":
_hash = hashlib.md5()
else:
_hash = hashlib.sha512()
with open(fname, "rb") as f:
fb = f.read(block_size)
while fb:
_hash.update(fb)
fb = f.read(block_size)
return _hash.hexdigest()
|
db435d55256c787285948975d9e1ed3807cacef4
| 697,799
|
def get_provenance_record(ancestor_files):
"""Create a provenance record describing the diagnostic data and plot."""
record = {
'caption':
('(a) Zonally averaged sea surface temperature (SST) error in CMIP5 '
'models. (b) Equatorial SST error in CMIP5 models. (c) Zonally '
'averaged multi-model mean SST error for CMIP5 (red line) together '
'with inter-model standard deviation (shading). (d) Equatorial '
'multi-model mean SST in CMIP5(red line) together with inter-model '
'standard deviation (shading) and observations (black). Model '
'climatologies are derived from the 1979-1999 mean of the historical '
'simulations. The Hadley Centre Sea Ice and Sea Surface Temperature '
'(HadISST)(Rayner et al., 2003) observational climatology for '
'1979-1999 is used as reference for the error calculation (a), (b), '
'and (c); and for observations in (d).'),
'statistics': ['anomaly', 'mean', 'stddev', 'clim'],
'domains': ['eq', 'global'],
'plot_types': ['geo', 'sect', 'zonal'],
'authors': ['zimmermann_klaus'],
'projects': ['crescendo'],
'references': ['flato13ipcc', 'hadisst'],
'realms': ['ocean'],
'themes': ['phys'],
'ancestors':
ancestor_files,
}
return record
|
d0c68eb45dd0a9cee0746294b4fd3202dc1003de
| 697,800
|
def getAverageCoords ( allAtomsList, atomsIndList ):
"""
Oblicz srednie wspolrzedne x, y, z wybranych atomow
Wejscie:
allAtomsList - lista obiektow Atom (cala czasteczka)
atomsIndList - lista indeksow atomow, ktorych usrednione polozenie
ma byc obliczone
Wyjscie:
averageCoords - 3-elementowa lista zawierajaca usrednione wspolrzedne
x, y, z wybranych atomow
"""
averageCoords = [ 0. , 0. , 0. ]
for atomInd in atomsIndList:
new_coords = allAtomsList[atomInd].get_coord()
for coord in range(3):
averageCoords[coord] += new_coords[coord]
atomsNo = float(len(atomsIndList))
for coord in range(3):
averageCoords[coord] /= atomsNo
return averageCoords
|
076fb6e06972c1de2d4d461ab888bc57f2e4643e
| 697,801
|
def write(file_path, new_contents):
""" Write the contents of a file. """
with open(file_path, "wb") as f:
return f.write(new_contents)
|
023d90686d4d7033d9421b58df8f1de2cacd5338
| 697,802
|
def compute_statistics(datasetKaggle):
"""
Outputs various statistics of the Kaggle dataset
:param datasetKaggle: the input dataset formatted as a dictionary
:type datasetKaggle: dict
:return: dictionary with the processed information
:rtype: dict
"""
yesNoAnswer = 0
annotationsMax = 0
averageLength = 0
totalExamples = len(datasetKaggle)
for example in datasetKaggle:
annotationsMax = max(len(example['annotations']), annotationsMax) # check for the maximum number of annotations
if example['annotations'][0]['yes_no_answer'] != 'NONE':
yesNoAnswer += 1
averageLength = len(example['document_text']) / totalExamples
output = {'annotationsMax': annotationsMax, 'num_yesNo': yesNoAnswer, 'text_avgLength': averageLength}
return output
|
5d41592f45daa252d2a55c71193c1f022f4f53a2
| 697,803
|
def second_half():
"""
second half solver:
"""
# Generator A starts with 591 ; generator A uses 16807
# Generator B starts with 393 ; ; generator B uses 48271
# 2147483647
A, B = 591, 393
count = 0
for x in range (5000000):
while A % 4 != 0:
A = (A * 16807) % 2147483647
while B % 8 != 0:
B = (B * 48271) % 2147483647
if A & 65535 == B & 65535:
count += 1
A = (A * 16807) % 2147483647
B = (B * 48271) % 2147483647
return count
|
88f2ce5eb85c3e7d3207d021488eca920e00c29b
| 697,804
|
def label(field):
"""Render foundation label."""
return {'field': field}
|
8c9f9f8623b3e30a6d43220b7931354de5d42828
| 697,805
|
def filter_ice_border(ice_thick):
"""Sets the ice thickness at the border of the domain to zero."""
ice_thick[0, :] = 0
ice_thick[-1, :] = 0
ice_thick[:, 0] = 0
ice_thick[:, -1] = 0
return ice_thick
|
cbe448c2659cab832cb499765fb0d4ae8f95d751
| 697,806
|
import re
def split_with_offset(line, _len=len):
""" split string to tokens with offset """
words = re.split('[ ,.:!"|(){}\t\n]', line)
index = line.index
offsets = []
append = offsets.append
running_offset = 0
for word in words:
word_offset = index(word, running_offset)
word_len = _len(word)
running_offset = word_offset + word_len
append((word, word_offset, running_offset - 1))
return offsets
|
6299b4af840c5a7a2fe67ca00bc113fbdca982ec
| 697,807
|
def is_missing(column):
"""
Determines whether the specified column has missing values.
:param column: The column
:type column: { pandas.series | list | tuple }
:return boolean: True | False
Usage:
======
>> is_missing(data['population'])
>> True
"""
try:
return bool(True) if column.isnull().values.any() == bool(True) else bool(False)
except AttributeError:
print("Method only supported pandas.cores.series")
|
a4cadb501fc7f66dc8680ba40fe4ee292815f53c
| 697,808
|
def get_uniq_chars_list(num: int) -> list:
"""Creates a list of uniq characters"""
if num > 60:
raise Exception("Only up to 60 uniq characters supported, you provided:", str(num))
ret = []
for i in range(65, 65 + num):
ret.append(chr(i))
return ret
|
35ed7c6af106c1d2864f188b9e2df5a6dc22d717
| 697,809
|
def column_names_from_cursor(cur):
"""returns column names as a list when provided cx_Oracle Cursor"""
column_names = []
for column_info in cur.description:
column_names.append(column_info[0])
return column_names
|
f5b1606bec5d32a67438c15c7d655079d189e512
| 697,810
|
from typing import Callable
import functools
def compose(*function: Callable) -> Callable:
"""Compose functions.
I.e::
``lambda x: f(g(x))``
can be written:
``compose(f, g)``
Args:
*function (Callable):
Any number of functions to compose together.
Output type of function N must be the input type of function N+1.
Returns:
Callable:
A composed function with input type same as the firs function, and output
type same as the last function.
"""
return functools.reduce(lambda f, g: lambda x: f(g(x)), function, lambda x: x)
|
8c3b04ffeb03303a49c006fa347e150f94700d40
| 697,812
|
def calls():
"""Fixture to record calls."""
return []
|
5044c9aa34415ff7bb97a243c2f0b5cdc33960b0
| 697,813
|
import subprocess
import logging
def checkVMs(VMs):
"""
checks if clients can be pinged
"""
for VM in VMs:
p = subprocess.Popen(['ping', '-n', '1', VM], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
if stdout != b'':
logging.info(stdout.decode('utf-8'))
if stderr != b'':
logging.info(stderr.decode('utf-8'))
if p.returncode != 0:
print('Computer: ' +VM+ ' cant be pinged.')
logging.error('Computer: ' +VM+ ' cant be pinged.')
return 1
return 0
|
1d2ac765fbcf65d57bd2bd343343d887d115c063
| 697,814
|
def oxford_join(words):
"""Concatenate words with commas and a final 'and' between."""
assert len(words) > 0
if len(words) == 1:
return words[0]
if len(words) == 2:
return words[0] + ' and ' + words[1]
return ' '.join(map(lambda x: x + ',', words[0:-1])) + ' and ' + words[-1]
|
e880d3c42d93f521b5c80591ead907318976c271
| 697,815
|
def echo(value: str):
"""Test Celery task to echo a string.
Args:
value (str): string to return.
Returns:
str, the input argument string.
"""
return value
|
cc96b1f80147950cd0a084f45d379e5be0156c36
| 697,816
|
import os
import ctypes
def load_lib():
"""
Register the stonne connection library into TVM
"""
# Find library based on relative paths
stonne_conv2d = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"stonne_lib/stonne_lib.so")
# load in as global so the global extern symbol is visible to other dll.
lib = ctypes.CDLL(stonne_conv2d, ctypes.RTLD_GLOBAL)
return lib
|
b3c1eab0160b69a08e6e62dc09a01b5f777c9e70
| 697,817
|
import struct
def wordswap(data):
""" Swap byte order in each DWORD """
fmt = '%dL' % ((len(data)+3)/4)
pad = len(data) % 4
if pad:
pad = 4-pad
data += b'\x00' * pad
return struct.pack('<'+fmt, *struct.unpack('>'+fmt, data))
|
559883d3929f3f521dd8878a2582681651e8d122
| 697,818
|
def distance(x1, y1, x2, y2):
"""
Distance between two points (x1, y1), (x2, y2).
"""
return pow((pow(x1 - x2, 2) + pow(y1 - y2, 2)), 0.5)
|
2bd9c1c8be018481998cff594f08c98d29be04de
| 697,821
|
def combine_english_defs(senses, separator=u', '):
"""Combines the English definitions in senses.
Args:
senses: An array with dict elements with English info.
Returns:
A string of English definitions separated by the separator.
"""
# Each sense contains a list of English definitions. e.g. [[], [], []]
eng_defs_lists = [sense['english_definitions'] for sense in senses
if 'english_definitions' in sense]
# Combine the inner lists of English definitions into one list.
combined_eng_defs = [eng_def for eng_def_list in eng_defs_lists for eng_def in eng_def_list]
return separator.join(combined_eng_defs)
|
c4dd5b732e198dc4381ebfd5b133c226a3094be7
| 697,822
|
def add_or_get_merge_anchor_index(lane, pos):
"""
Add a merge anchor at pos if needed, return the index of the merge anchor
"""
if not hasattr(lane, "merge_anchors"):
lane.merge_anchors = []
for ind, e in enumerate(lane.merge_anchors):
if (e[1] is None and pos == lane.start) or e[1] == pos:
return ind
lane.merge_anchors.append([lane.anchor, None if pos == lane.start else pos])
return len(lane.merge_anchors) - 1
|
ee52833b37d84ca765f8e5c56ec9e8f52691451a
| 697,823
|
def is_hovering(rect, mouse_pos):
"""Checks if a mouse is hovering over a rect"""
if (
rect.left <= mouse_pos[0] <= rect.right
and rect.top <= mouse_pos[1] <= rect.bottom
):
return True
return False
|
e17f4b8ee6e0b5f174473aa88388ff81ab67ea66
| 697,824
|
import math
def compass_bearing(pointA, pointB):
"""
Calculates the bearing between two points.
The formulae used is the following:
θ = atan2(sin(Δlong).cos(lat2),
cos(lat1).sin(lat2) − sin(lat1).cos(lat2).cos(Δlong))
:Parameters:
- `pointA: The tuple representing the latitude/longitude for the
first point. Latitude and longitude must be in decimal degrees
- `pointB: The tuple representing the latitude/longitude for the
second point. Latitude and longitude must be in decimal degrees
:Returns:
The bearing in degrees
:Returns Type:
float
"""
if (type(pointA) != tuple) or (type(pointB) != tuple):
raise TypeError("Only tuples are supported as arguments")
lat1 = math.radians(pointA[0])
lat2 = math.radians(pointB[0])
diffLong = math.radians(pointB[1] - pointA[1])
x = math.sin(diffLong) * math.cos(lat2)
y = math.cos(lat1) * math.sin(lat2) - (math.sin(lat1)
* math.cos(lat2) * math.cos(diffLong))
initial_bearing = math.atan2(x, y)
# Now we have the initial bearing but math.atan2 return values
# from -180° to + 180° which is not what we want for a compass bearing
# The solution is to normalize the initial bearing as shown below
initial_bearing = math.degrees(initial_bearing)
compass_bearing = (initial_bearing + 360) % 360
return compass_bearing
|
4ef715ab9519e306a12c42ab87f0a624d7e0589c
| 697,825
|
def knapsack_dp(items, capacity):
"""Return the maximum value that can be stored in the knapsack."""
rows = len(items) + 1
cols = capacity + 1
dp_table = [[0 for j in range(cols)] for i in range(rows)]
for i in range(rows):
for j in range(cols):
if i is 0 or j is 0:
dp_table[i][j] = 0
item = items[i]
capacity = j
value_without = dp_table[i-1][capacity]
if item[1] < capacity:
value_with = dp_table[i-1][capacity-item[1]] + item[2]
dp_table[i][j] = max(value_with, value_without)
else:
dp_table[i][j] = value_without
return dp_table[rows-1][cols-1]
|
6beae17041d1922725ccc2641d86594ede7f8bf6
| 697,826
|
def optimize(s, probability, loBound, hiBound):
""" Optimiere auf die max. mögliche Entnahme bei einer vorgegebenen Fehlerquote
Returns:
widthdrawal: max. mögliche prozentuale Entnahme
"""
n_ret_months = s.simulation['n_ret_years'] * 12
accuracy = 0.005 # Genauigkeit der Optimierung
# Vorbereitung der Optimierung
deltaWidthdrawal = (hiBound - loBound) / 2
percWidthdrawal = loBound + deltaWidthdrawal
cnt = 0
curProb = 0
# Optimization by successiv approximation
while (deltaWidthdrawal > accuracy) or (curProb > probability):
cnt += 1
s.withdrawal['fixed_pct'] = percWidthdrawal
s.init_simulation()
s.simulate()
survival = [trial_dict['exhaustion'] for trial_dict in s.latest_simulation]
curProb = 100 * (len(survival) - survival.count(n_ret_months)) / len(survival)
if s.visualization['textoutput'] == True:
print(cnt, '. Entnahme: ', percWidthdrawal, ' Ausfallwahrscheinlichkeit: ', curProb, '%')
deltaWidthdrawal /= 2
if deltaWidthdrawal <= accuracy / 5:
break
if curProb > probability:
percWidthdrawal -= deltaWidthdrawal
else:
percWidthdrawal += deltaWidthdrawal
return percWidthdrawal
|
1ad98336a531a8fd149f9351cb6f450c836d67a0
| 697,827
|
import functools
def wraps_set_expire(func):
"""
装饰器， 设置key默认过期时间
"""
@functools.wraps(func)
def wrapper_func(self, keyname, *args, **kwargs):
ret_func = func(self, keyname, *args, **kwargs)
# 设置key的过期时间
if ret_func is not None:
self.set_expire(keyname)
return ret_func
return wrapper_func
|
4b2f06cce1c598097514963a5280029d515f63f1
| 697,828
|
def copy_dict(other_dict):
"""
Returns a copy of the dictionary, separate from the original.
This separation is only at the top-level keys.
If you delete a key in the original, it will not change the copy.
>>> d1 = dict(a=1, b=2)
>>> d2 = dict(**d1)
>>> del d1['a']
>>> 'a' in d1
False
>>> 'a' in d2
True
If any of the top-level values are mutable (list, dict) then changes
to the original will appear in the copy.
>>> d1 = dict(a=[1, 2], b=[3, 4])
>>> d2 = dict(**d1)
>>> d1['a'].pop()
2
>>> d1['a']
[1]
>>> d1['a'] == d2['a']
True
Tested in Python 3.4.
"""
new_dict = dict(**other_dict)
return new_dict
|
a8d25212b2bf0524a5f434fd590c1ac3ec8b8810
| 697,829
|
def box_tuple(c, typ, val):
"""
Convert native array or structure *val* to a tuple object.
"""
tuple_val = c.pyapi.tuple_new(typ.count)
for i, dtype in enumerate(typ):
item = c.builder.extract_value(val, i)
obj = c.box(dtype, item)
c.pyapi.tuple_setitem(tuple_val, i, obj)
return tuple_val
|
45e277406d904060afb1e5d22469fcf104a12b32
| 697,830
|
import glob
import os
def get_files(input_dir):
"""return a list of .TXT files from a directory"""
fns = []
fns += glob.glob(os.path.join(input_dir, '*/*/*.txt'))
if not fns:
raise RuntimeError('Error selscting files')
return fns
|
248b7b4660fae67b55e5197ad0ed0825b096f22d
| 697,832
|
def filter_all_persons(queryset, name, all_persons):
"""Filter only trainees when all_persons==False."""
if all_persons:
return queryset
else:
return queryset.filter(
task__role__name='learner',
task__event__tags__name='TTT').distinct()
|
f64e4fcdf770e8003319ca1c19b089fa090d4984
| 697,834
|
import shlex
def make_commit_msg(pairs, no_verify):
"""Return a commit message to explain what was replaced by the provided
arguments.
"""
script = ["./scripts/maint/rename_c_identifier.py"]
for id1, id2 in pairs:
qid1 = shlex.quote(id1)
qid2 = shlex.quote(id2)
script.append(" {} {}".format(qid1, qid2))
script = " \\\n".join(script)
if len(pairs) == 1:
line1 = "Rename {} to {}".format(*pairs[0])
else:
line1 = "Replace several C identifiers."
msg = """\
{}
This is an automated commit, generated by this command:
{}
""".format(line1, script)
if no_verify:
msg += """
It was generated with --no-verify, so it probably breaks some commit hooks.
The committer should be sure to fix them up in a subsequent commit.
"""
return msg
|
4757c9200dc25d97bdf8a3de0954d0e373adc07c
| 697,835
|
import numpy
def _bootstrap_cost(observed_labels, forecast_probabilities, cost_function,
num_replicates):
"""Uses bootstrapping to estimate cost.
E = number of examples
:param observed_labels: length-E numpy array of true classes (integers in
0...1).
:param forecast_probabilities: length-E numpy array of event probabilities
(probabilities of class = 1).
:param cost_function: Cost function. Must be negatively oriented (i.e.,
lower is better), with the following inputs and outputs.
Input: observed_labels: See above.
Input: forecast_probabilities: See above.
Output: cost: Scalar value.
:param num_replicates: Number of bootstrap replicates (i.e., number of times
to estimate cost).
:return: cost_estimates: length-B numpy array of cost estimates, where B =
number of bootstrap replicates.
"""
cost_estimates = numpy.full(num_replicates, numpy.nan)
if num_replicates == 1:
cost_estimates[0] = cost_function(
observed_labels, forecast_probabilities
)
else:
num_examples = len(observed_labels)
example_indices = numpy.linspace(
0, num_examples - 1, num=num_examples, dtype=int
)
for k in range(num_replicates):
these_indices = numpy.random.choice(
example_indices, size=num_examples, replace=True
)
cost_estimates[k] = cost_function(
observed_labels[these_indices],
forecast_probabilities[these_indices]
)
print('Average cost estimate over {0:d} replicates = {1:f}'.format(
num_replicates, numpy.mean(cost_estimates)
))
return cost_estimates
|
473613c7b16876d8b4467e68a119309f35793f90
| 697,836
|
import random
def remove_edge_random_stochastic(G, p, random_seed=None, copy=True):
"""
Recieves a Graph and p (uniform probability of failure).
Returns a degraded Graph
"""
if copy:
G_ = G.copy()
else:
G_ = G
if random_seed is not None:
random.seed(random_seed)
for edge in list(G.edges):
if random.random()<=p:
G_.remove_edge(*edge)
return(G_)
|
6591c79ccf14513adf58b0f59e569c6586d85d5f
| 697,837
|
def list_services(config_dict):
"""
List available services
Args:
config_dict (dict): configuration dictionary
Returns:
list: list of available services
"""
return list(config_dict.keys())
|
a3226589405292f0bcef99aabaec71722aaeb1db
| 697,838
|
def actions_by_behavior(actions):
"""
Gather a dictionary grouping the actions by behavior (not SubBehaviors). The actions in each
list are still sorted by order of their execution in the script.
@param actions (list) of Action objects
@return (dict) where the keys are behaviors and the values are lists of actions
"""
split = {}
for action in actions:
for behavior in action.behaviors:
if behavior.name not in split:
split[behavior.name] = []
split[behavior.name].append(action)
return split
|
ebf97a5837a8d7de735207c5df5e19af2438510a
| 697,839
|
import decimal
def decimal_round(val, prec=1e-4):
"""wrapper for rounding according to precision
"""
DD = decimal.Decimal
val_ = DD(val).quantize(DD(f'{prec}'), rounding=decimal.ROUND_DOWN)
return float(val_)
|
d0e37277df94ddbd95a60c1380cf3eb93531c6a7
| 697,840
|
def plugin_reconfigure(handle, new_config):
""" Reconfigures the plugin, it should be called when the configuration of the plugin is changed during the
operation of the device service.
The new configuration category should be passed.
Args:
handle: handle returned by the plugin initialisation call
new_config: JSON object representing the new configuration category for the category
Returns:
new_handle: new handle to be used in the future calls
Raises:
"""
new_handle = new_config['gpiopin']['value']
return new_handle
|
b65c246d90e8ab6740c0481849ab2da22a90b872
| 697,841
|
import logging
def get_loglevel(loglevel):
""" Check whether a valid log level has been supplied, and return the numeric log level that
corresponds to the given string level.
Parameters
----------
loglevel: str
The loglevel that has been requested
Returns
-------
int
The numeric representation of the given loglevel
"""
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError("Invalid log level: %s" % loglevel)
return numeric_level
|
a662e00caa21bf5632b28f26cbb604229db9705a
| 697,842
|
import logging
import time
def is_valid_date(strdate):
"""
判断是否是一个有效的日期字符串
:param strdate:
:return:
"""
logging.info('is_valid_date')
try:
if ":" in strdate:
time.strptime(strdate, "%Y-%m-%d %H:%M:%S")
else:
time.strptime(strdate, "%Y-%m-%d")
return True
except Exception as e:
return False
|
7dd157a3bf970057233066faa563dee627a61dbf
| 697,843
|
import base64
import requests
import json
def retrieve_appdevtools_access_token(username, password, auth_endpoint):
"""
Retrieve access token for appdev tools
Args:
username: username
password: password
auth_endpoint: authorization endpoint
Returns: token
"""
# Form credentials request
credentials = "{0}:{1}".format(username, password)
base_encoded_credential = base64.b64encode(bytes(credentials, "utf-8")).decode().replace('\n', '')
# Form application headers
headers = {
"content-type": "application/json",
"Authorization": "Basic {}".format(base_encoded_credential)
}
# Form login request
login_request = {
"username": username,
"password": password
}
# Issue request, skip SSL validation
response = requests.post(url=auth_endpoint, json=login_request,
headers=headers, verify=True)
# Get access token
return json.loads(response.text)["token"]
|
8f08f4be45998199aa9db151fec26722a13eb060
| 697,844
|
def struct(typename, attrnames):
"""
Generate simple and fast data class
"""
attrnames = tuple(attrnames.replace(',', ' ').split())
reprfmt = '(' + ', '.join(name + '=%r' for name in attrnames) + ')'
def __init__(self, *args, **kwargs):
if len(args) > len(attrnames):
msg = "__init__() takes %d positional arguments but %d were given" \
% (len(attrnames) + 1, len(args) + 1)
raise AttributeError(msg)
for name, value in zip(attrnames, args):
setattr(self, name, value)
for name, value in kwargs.items():
if name not in attrnames:
msg = "__init__() got an unexpected keyword argument '%s'" % name
raise TypeError(msg)
setattr(self, name, value)
def __repr__(self):
""" Return a nicely formatted representation string """
return self.__class__.__name__ + \
reprfmt % tuple(getattr(self, x) for x in attrnames)
def __getattr__(self, name):
"""
It will only get called for undefined attributes
and exists here mostly to mute pylint 'no-member' warning
"""
raise self.__getattribute__(name)
namespace = {
'__doc__' : '%s(%s)' % (typename, attrnames),
'__slots__' : attrnames,
'__init__' : __init__,
'__repr__' : __repr__,
'__getattr__': __getattr__,
}
result = type(typename, (object,), namespace)
return result
|
9e4789e8960e48cd3a80c8907321d23013d29b87
| 697,845
|
from typing import List
import os
def write_shell_script(dir: str, name: str, content: List[str]) -> str:
"""
Creates and writes a bash script in the specified dir with the given name.
The contents of the script are taken from the ``content`` parameter
where each item in the list is written as a line in the script.
Example: ``write_shell_script("/tmp", "foobar", ["sleep 10", "echo hello world"])
::
# creates /tmp/foobar with content below
#! bin/bash
sleep 10
echo hello world
"""
script_path = os.path.join(dir, name)
with open(script_path, "w") as f:
f.write("#! /bin/bash\n")
for line in content:
f.write(f"{line}\n")
f.write("\n")
os.chmod(script_path, 0o755)
return script_path
|
49ba8c0f3630b88d7c6acc2487956ed211ec7f4a
| 697,846
|
def count_literals(term):
"""
Counts the number of literals in a term
Args:
term : A string containing literals
Returns:
The number of literals in term
"""
count = 0
for char in term:
if char != "_":
count+=1
return count
|
48bb0066f09994627a4b7c2b04a657df1106a1c3
| 697,847
|
def BmV_to_gmr( BmV ):
"""Relation from Cook+2014 (2014MNRAS.445..890C) to transform
galaxy B-V color to g-r.
"""
ii_bad = [i for i in range(len(BmV)) if BmV[i] == -99.0]
gmr = 1.12*BmV - 0.18
gmr[ii_bad] = -99.0
return gmr
|
e5b4d1748d403e206cfb74f640d5e04e5b84f5a1
| 697,848
|
import json
def get_json_from_file(filename, warn = False):
"""Loads json from a file.
Optionally specify warn = True to warn, rather than
fail if file not found."""
f = open(filename, 'r')
return json.loads(f.read())
|
6916e0239067b977d0671e1e38006f457da94ae7
| 697,849
|
import subprocess
def tail(filename, n):
"""
Get last n lines from file as string
Args:
filename:``str``
filename of log file
n:``int``
number of lines
Return:
lines form file as string
"""
p=subprocess.Popen(['tail','-n',str(n),filename], stdout=subprocess.PIPE)
soutput, _=p.communicate()
lines = soutput.decode('utf8').split('\r')
return lines
|
7e398b7d5806149555f4b2bb70292e17f0f916c7
| 697,850
|
import itertools
def take_while(collection, predicate):
""":yaql:takeWhile
Returns elements from the collection as long as the predicate is true.
:signature: collection.takeWhile(predicate)
:receiverArg collection: input collection
:argType collection: iterable
:arg predicate: function of one argument to apply to every
collection value
:argType predicate: lambda
:returnType: iterable
.. code::
yaql> [1, 2, 3, 4, 5].takeWhile($ < 4)
[1, 2, 3]
"""
return itertools.takewhile(predicate, collection)
|
dd1fe4f97db991d1323b814ddd1f7c2e0fe52c88
| 697,851
|
def ip_has_digit(matched_str):
"""Checks to make sure the PII span is not just :: or whatever that may
accidentally be picked up by making sure there are digits."""
return any(map(str.isdigit, matched_str))
|
3ed765a04c1b920addc7e3ab538575ac4edc7651
| 697,852
|
def list_frequencies(list_of_items):
""" Determine frequency of items in list_of_items. """
itemfreq = [list_of_items.count(p) for p in list_of_items]
return dict(zip(list_of_items,itemfreq))
|
8772e64d0abd400dfe333747e7fce0d816a0f59f
| 697,854
|
import typing
import subprocess
import re
def search_output_from_cmd(cmd: str,
find_regex: typing.Pattern) -> typing.Match:
"""
Run a shell command and search a given regex object in stdout.
If the regex object is not found, a RuntimeError exception is raised.
:param cmd: command to run
:param find_regex: regular expression object to search for
:return: result of re.search()
"""
# Run the given command in a shell
out = subprocess.run(cmd, shell=True, check=True,
stdout=subprocess.PIPE).stdout.decode("utf-8")
# Search for the object
content = re.search(find_regex, out)
# If the result is not None, return it
if content:
return content
raise RuntimeError("Could not find '%s' in output for '%s'" %
(find_regex.pattern, cmd))
|
c05503a856652f637f694b6ac712018378a8097a
| 697,855
|
import numpy
def maxDist(src, dst):
"""
Src and dst are both matrices of the same size with each column representing a
different position
"""
diff = dst - src
max_dist = 0
for entry in range(diff.shape[1]):
dist = numpy.linalg.norm(diff[:, entry])
if dist > max_dist:
max_dist = dist
return max_dist
|
f943ebf703fe57cc79b03efa8100e8d8c3cb947a
| 697,856
|
def edit_distance(list1, list2):
# To compute the Levenshtein distance between two entries,
# say entries 92 and 94,
# try this in interactive mode after running this script:
# edit_distance(results_list[92].split(',')[1:], results_list[94].split(',')[1:])
"""Ref: https://bit.ly/2Pf4a6Z"""
#print(f"Comparing:\n{list1}{list2}")
if len(list1) > len(list2):
difference = len(list1) - len(list2)
list1[:difference]
elif len(list2) > len(list1):
difference = len(list2) - len(list1)
list2[:difference]
else:
difference = 0
for i in range(len(list1)):
try:
if list1[i] != list2[i]:
difference += 1
except IndexError:
break
return difference
|
15b1d1e495bbbfa39c07043fe97735da0a495222
| 697,857
|
import math
def normStdevMask(img,mask):
"""
normalize an image with mean = 0 and stddev = 1.0 only inside a mask
"""
n1 = mask.sum()
if n1 == 0:
return img
sum1 = (img*mask).sum()
sumsq1 = (img*img*mask).sum()
avg1 = sum1/n1
std1 = math.sqrt((sumsq1 - sum1*sum1/n1)/(n1-1))
std2 = img.std()
return (img - avg1) / std1
|
b5493d1e8a0f6594badb97c9376777117263eb0b
| 697,858
|
import os
def theme_path():
"""Return the path of the theme directory"""
return os.path.dirname("{}/../themes/".format(os.path.dirname(os.path.realpath(__file__))))
|
82caeb651809ef926516f95d2d1e2a1de15347df
| 697,859
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.