content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def get_subnode(node, key):
"""Returns the requested value from a dictionary, while ignoring null values"""
if node != None and key in node:
return node[key]
return None | 2377bcfc374882e53b169b5e5978e1248000a779 | 363,528 |
def sensor_error(raw_sensor_value):
"""Actual sensor error derived from field tests."""
return (raw_sensor_value + 2.5) / 1.32 | bc9cf40071198d38d638326c647c482a49f75a0d | 652,885 |
def remove_coord(cube, coord):
"""Remove a coordinate from a cube (when the Iris built-in fails).
Args:
cube (iris.cube.Cube) : Cube of data
coord (str) : Name of the coordinate
Returns:
iris.cube.Cube : Updated cube, sans coordinate
"""
if coord in [c.standard_name for c i... | 2556d4f87a423a6313b03e1a43d120e6b960b2a5 | 152,398 |
import glob
def get_photos() -> list:
""" Returns a list of paths to photos. """
path = "static/img/conklin/"
return list(map(lambda x: "/".join(x.split("/")[1:]), glob.glob("{}*.jpg".format(path)) + glob.glob("{}*.JPG".format(path)))) | f43186f0a2439364607c1c24e71d31efc0dcec5c | 264,372 |
def unit_propagate(clauses, cascade=True):
"""Divide a collection of clauses into a set of satisfied literals and a
new collection of clauses with satisfied literals removed.
Args:
clauses (:obj:`iter` of :obj:`iter` of :obj:`int`): A collection of clauses.
cascade (:obj:`bool`, optional): Whether to recursivel... | 5314e2b87cc9765791b6d02ee40105d747c9d7ce | 260,386 |
def trigger_dict(ts_epoch):
"""A dictionary representing a date trigger."""
return {"run_date": ts_epoch, "timezone": "utc"} | c14ab8144cb38391c91581487e594c7492b2615d | 401,219 |
def backward_propagation_l2_regularization(m,W,lambd):
"""
computes the l2 regularization term for backpropagation of a single layer
Arguments:
m -- number of examples
W -- weights of the layer
lamdb -- regularization term for scaling of "ssmoothing"
Returns:
L2_regularization_backpropagation - value of the r... | cc10405d6bc45ee629da14cbce1fca5f3381c8b6 | 457,334 |
import torch
def quaternion_to_matrix(quaternions: torch.Tensor) -> torch.Tensor:
"""
Convert rotations given as quaternions to rotation matrices.
Args:
quaternions: quaternions with real part first,
as tensor of shape (..., 4).
Returns:
Rotation matrices as tensor of shape... | 025a3559e96997a986c89151a9ec08d8e33cf991 | 270,472 |
def startswith(prefix):
"""
Create a function that checks if the argument
that is passed in starts with string
:param str prefix: string to check the start for
:return func startswith_function: a function that checks if the
argument starts with the specified string
"""
def string_starts_... | 47e0967ce9864743f412070ba1e016f83fe708ed | 639,990 |
def format_time( t ):
""" format seconds as mm:ss """
m,s = divmod(t,60)
if m > 59:
h,m = divmod(m,60)
return "%d:%02d:%02d"%(h,m,s)
else:
return "%d:%02d"%(m,s) | d8e79bd86183d2b5466d09add2d893392829c5f3 | 264,367 |
def modular_geometric_sum(x, n, mod):
""" Compute a_n = (1 + a^1 + ... + a^{n-1}) % mod
using that
a_{2n} = ((x_n + 1) * a_n) % mod
a_{2n+1} = (x^{2n} + a_{2n}) % mod
"""
if n == 1:
return 1 % mod
elif n % 2 == 0:
return ((pow(x, n // 2, mod) + 1) * modular_geometri... | 5ec1af73ec6229679c1075a49c21bdb0eccc53f8 | 657,175 |
def validate_numeric_range_parameter(parameter, default_val, min_val=None, max_val=None):
"""Validates the range-type parameter, e.g. angle in Random Rotation.
Parameters
----------
parameter : tuple or None
The value of the parameter
default_val : object
Default value of the parame... | 0db74e17b68b4c3cc8965b7a6d7d644dbc87fd81 | 447,397 |
import json
def parse_logs(file_name):
"""Read the timing logs out of the log file."""
data = []
with open(file_name) as f:
for line in f:
entry = json.loads(line)
if 'phase' in entry and entry['phase'] == 'Test':
continue
if 'time' in entry:
... | 2ce6ee1022f7ce733537bfc6555356afeb7c721b | 258,849 |
def toList(buffer):
"""
Takes a list, bytes object or string and converts it to a list
of integers.
Args:
buffer: A list, bytes object or string.
Returns:
A list of integers.
"""
if isinstance(buffer, str):
return [ord(ch) for ch in buffer]
else:
return ... | 68e682351672d5d002e94b2e668284bd5f999751 | 258,512 |
def monthdelta(date, delta):
"""because we wish datetime.timedelta had a month kwarg.
Courtesy of: http://stackoverflow.com/a/3425124/3916180
Parameters
----------
date : datetime.date
Date object
delta : int
Month delta
Returns
-------
datetime.date
New Da... | d79afe2bf8d86a86caa01f88bed16814c27fcdda | 128,468 |
def generate_sas_url(
account_name: str,
account_domain: str,
container_name: str,
blob_name: str,
sas_token: str
) -> str:
"""
Generates and returns a sas url for accessing blob storage
"""
return f"https://{account_name}.{account_domain}/{container_name}/{blob_name}?{sas_token}" | 6fedfb9cacc08fddc8e6912bb6cd5c0c2d929e9b | 49,784 |
def get_color(pict, x, y):
""" (Cimpl.Image, int, int) -> Cimpl.Color
Return a Color containing the RGB components of the pixel at
location (x, y) in Image pict.
"""
return pict.get_color(x, y) | dde7f8106d6cfd04f195f5075197f01aa7b55201 | 163,421 |
from typing import List
def most_frequent(list_: List):
"""
Return most frequent element of a list if not empty elase return empty string
:param l: list with element
:return: item in list with most occurrence
"""
if not list_:
return ""
else:
return max(set(list_), key=list... | f1790b42fa66f509c4cda361dc9ac8986c9d8ed5 | 373,208 |
def compute_error_vector(y, tx, w):
"""
Computes the error vector that is defined as y - tx . w
Args:
y: labels
tx: features
w: weight vector
Returns:
error_vector: the error vector defined as y - tx.dot(w)
"""
return y - tx.dot(w) | 104998f9ae1b88463ac7eef09cf0337ffb91a691 | 139,073 |
def build_factorized(factorized: dict) -> int:
"""
Build integer from its factorized form, (reverse function of factorization)
:param factorized: factorized integer dict
:return: integer
"""
num = 1
for factor in factorized:
num *= factor ** factorized[factor]
return int(num) | 73db0c09db2c7644f4f95c76dbe21b64f54d7641 | 22,798 |
def find_author(name, authors):
""" Find the author with the provided name, in the list of authors"""
for author in authors:
if author.name == name: return author
raise ValueError('Author', name, 'not found.') | dd47f0ecf8574d68a0ce9b5e94dff19b58f5887a | 8,584 |
def _get_ad_description(soup_body):
"""
Helper function that fetches Diva's advert description from page
Returns:
dict: dict containing `description` key and description text
"""
desc_container = soup_body.find('div', attrs={'id': 'anons_content'}).find(
'div', attrs={'id': 'tre... | e137793a9b34b246782e224a029291a73dea5c11 | 202,952 |
def get_pars(ts, coors, mode=None, region=None, ig=None):
"""
We can define the coefficient `load.val` as a function of space.
For scalar parameters, the shape has to be set to `(coors.shape[0], 1, 1)`.
"""
if mode == 'qp':
x = coors[:,0]
val = 55.0 * (x - 0.05)
... | 00ea9705a9f59388d1d3ab1c97796da687da6686 | 622,238 |
def sumsequences(N,K):
"""
All sequences of length N with numbers adding up to K;
The number of such is sequences is given by the multiset number:
N+K-1 over K.
"""
seqs = [ [] ]
for i in range(N-1):
new_seqs = []
for s in seqs:
for j in range(K - sum(s) + 1):
... | 4d957edaa5ef35b6d4ae5b5041efcd8f501bfad2 | 593,719 |
def remove_des(name):
"""
remove 'Class A Common Stock' and 'Common Stock' from listing names
"""
if name.endswith("Class A Common Stock"):
name = name[:-21]
if name.endswith("Common Stock"):
name = name[:-13]
return name | 3f4fb80d42c029e85b5354f226206df511911cc1 | 616,507 |
def mk_falls_description(data_id, data): # measurement group 8
"""
transforms a h-falls-description.json form into the triples used by insertMeasurementGroup to
store each measurement that is in the form
:param data_id: unique id from the json form
:param data: data array from the json form
... | 1e0c304538159b9bb01d677bdacdfa9a0b3b4e4d | 23,428 |
def read_labels(file_name):
"""
Read list of labels from file like this:
label1
label2
label3
...
"""
labels_tmp = []
try:
with open(file_name, 'r') as f:
labels_tmp = f.readlines()
labels_tmp = [(i.rstrip(), 0) for i in labels_tmp]
... | 247807c6a7a5e452b7bdb8a3874aabc889ef1ec9 | 667,768 |
import base64
def encodebase64(inputStr, encodeFlag=True):
""" Encode str to base64 """
if encodeFlag and inputStr:
return base64.b64encode(inputStr)
return inputStr | 17b190d9cae37df336820398e5a46b75e0199740 | 178,177 |
def _function_wrapper(args_tuple):
"""Function wrapper to call from multiprocessing."""
function, args = args_tuple
return function(*args) | 05eee157304eec7570be3d10ab9d77830a307749 | 338,667 |
def process(proc_data):
"""
Final processing to conform to the schema.
Parameters:
proc_data: (dictionary) raw structured data to process
Returns:
List of dictionaries. Structured data with the following schema:
[
{
"state": string, ... | 059495d483be437692a888e75a1406f506a8c689 | 497,258 |
def v12_add(*matrices):
"""Add corresponding numbers in given 2-D matrices."""
matrix_shapes = {
tuple(len(r) for r in matrix)
for matrix in matrices
}
if len(set(matrix_shapes)) > 1:
raise ValueError("Given matrices are not the same size.")
return [
[sum(values) for ... | 934dbd82be527f113eeb2eaad01f8c867100a869 | 650,152 |
def xeval(sexpr):
"""
>>> xeval('')
0
>>> xeval('1234567')
1234567
>>> xeval('+1234567')
1234567
>>> xeval('-1234567')
-1234567
>>> xeval('2+3')
5
>>> xeval('2-3')
-1
>>> xeval('2-23+4')
-17
>>> xeval('2-01+3-1')
3
>>> xeval('1-2-3-4-5')
-13
... | 9e7f8120b9f546fdc94c08ab0ee9978d528309f2 | 647,646 |
def contingency_table(ys, yhats, positive=True):
"""Computes a contingency table for given predictions.
:param ys: true labels
:type ys: iterable
:param yhats: predicted labels
:type yhats: iterable
:param positive: the positive label
:return: TP, FP, TN, FN
>>> ys = [True, True, T... | 83efd6b17654dc6424d933723c84fb162dc04263 | 603,348 |
def number_of_component_generated_from_default_template(location):
"""
Return number of component generated from the default template.
"""
lines = []
with open(location) as f:
lines = f.readlines()
count = 0
for line in lines:
if '<h3 class="component-name">' in line:
... | 6d9342ebcb5f24129440421b0369fa2222df7e71 | 234,864 |
def conjugate(x: complex) -> complex:
"""
Returns the conjugate of a complex number
"""
return x.real - x.imag * 1j | 6cacee436e7ca74d586364a4f578b745c08768d2 | 46,146 |
def truncation_replacement(random, population, parents, offspring, args):
"""Replaces population with the best of the population and offspring.
This function performs truncation replacement, which means that
the entire existing population is replaced by the best from among
the current population an... | eede329cdecee7fd980666a0253fba77120fe0ed | 459,880 |
from typing import OrderedDict
import torch
def filter_state_dict(
state_dict: "OrderedDict[str, torch.Tensor]", name: str
) -> "OrderedDict[str, torch.Tensor]":
"""
Filters state dict for keys that start with provided name.
Strips provided name from beginning of key in the resulting state dict.
... | c032f9d838cfc9f04cde0094aade9f8e9ae80e8a | 228,702 |
import click
def command_line_timelines_options(f):
"""
Decorator for common timelines command line options
"""
f = click.option(
"--exclude-replies",
is_flag=True,
default=False,
help="Exclude replies from timeline",
)(f)
f = click.option(
"--exclude-re... | a42a95b6bc34a35419929eba546121e8c6c5ccb5 | 595,809 |
def joblib_log_level(level: str) -> int:
"""
Convert python log level to joblib int verbosity.
"""
if level == 'INFO':
return 0
else:
return 60 | 82798af0bf8bbbe5b653f22aaf66216579ca85bd | 477,061 |
def listdict2dictlist(list_dict, flatten=False):
"""Function that takes a list of dict and converts it into a dict of lists
Args:
list_dict ([list]): The original list of dicts
Returns:
[dict]: A dict of lists
"""
keys = {key for tmp_dict in list_dict for key in tmp_dict}
res =... | 2d615bd5c0869c487bcc19677db26f85ccd6487b | 246,348 |
from typing import Iterable
def remove_nones(sequence: Iterable) -> list:
"""Removes elements where bool(x) evaluates to False.
Examples
--------
Normal usage::
remove_nones(['m', '', 'l', 0, 42, False, True])
# ['m', 'l', 42, True]
"""
# Note this is redundant with it.chain
... | 975c0104b3cc05bb82fa211c1b85b49c7d3cb174 | 1,619 |
import socket
def client_connect(host, port):
"""
Wrapper function to connect to client
"""
try:
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((host, port))
return client
except socket.error as err:
print("Unable to connect to the client... | 65832b574e45f545c90481a25e037075552d1e93 | 234,952 |
def find(predicate, iterable, default=None):
"""Return the first item matching `predicate` in `iterable`, or `default` if no match.
If you need all matching items, just use the builtin `filter` or a comprehension;
this is a convenience utility to get the first match only.
"""
return next(filter(pre... | 70d0d4265d7ef70e3ff041794712990b2dfc10c6 | 660,928 |
def breakLine(line):
"""Breaks a file line into it's command/instruction components.
Most lines in tuflow files are in the form::
Read Command == ..\some\path.ext ! comment
This separates the command from the rest.
Args:
line(str): the line as read from the file.
Returns:
Tup... | 40078fb197880b073c0cb8f0e4d4a989cdc4fe48 | 340,745 |
def scale_image(img):
"""Scale image to 1920 by 1080"""
height, width = 1080, 1920 # Desired resolution
# height, width = 720, 1280 # Desired resolution
scale_y = min(img.height, height) / max(img.height, height)
scale_x = min(width, img.width) / max(width, img.width)
if img.height < height ... | 1ba636d874c5853b239b51b9f238591773ccc98f | 283,657 |
def read_file(file):
""" Open given file and returns the content as a string. """
with open(file) as f:
wall = f.read()
return wall | bcfb29a31ac2cfcdf5b733a0bfd3019889a30fba | 691,992 |
def kpoint_path(ikpt):
""" construct path to kpoint
e.g. electrons/kpoint_0/spin_0/state_0
Args:
ikpt (int): kpoint index
Returns:
str: path in hdf5 file
"""
path = 'electrons/kpoint_%d' % (ikpt)
return path | bcda4c4d6f6bd1e9d09c592277d69a34d158a16f | 322,502 |
def find_point_in_path(path, sub):
"""Find a point in a path.
Parameters
----------
path : tuple of array_like
Tuple of arrays of int that represent indices into a matrix.
sub : tuple in int
Indices to search *path* for.
Returns
-------
int or None
Index into *p... | 09cd23b8e55239033fa82f697aaf8445768d9c51 | 239,928 |
def address_column_split(a):
"""
Extracts city and state in an address and provides separate columns for each
"""
asplit = a.split(",")
city = asplit[0].split()[-1]
state = asplit[1].split()[0]
return city, state | 539123969beb28f2623466db193077f4351d04cb | 30,502 |
from typing import List
from typing import Union
def shortest_name(names: List[str]) -> Union[str, None]:
"""Find the shortest name in a list of names that shares at least one
character with every other name in the list. For example in the list:
['add', 'dog', 'tree', 'house', 'gave'], 'gave' is the word... | ee13af0bc7ca1c7a98bb3e4d7a50074ba0d85131 | 384,190 |
def sum_divisors(n):
"""
Returns a sum of numbers proper divisors.
For exsample sum_divisors(28) = 1 + 2 + 4 + 7 + 14 = 28
"""
s = 1
limit = int(n ** 0.5)
if limit ** 2 == n:
s += limit
limit -= 1
for i in range(2, limit + 1):
if n % i == 0:
s += (i + ... | 75acad72444c514bc946ce1bac34c5190032654e | 350,294 |
def _round_up(a: int, b: int) -> int:
"""Round up to a multiple of b"""
return ((a + b - 1) // b) * b | 005ecb28637f88d6c76c5ec5133706e8a787d5d8 | 543,872 |
def rpartition(text, sep):
"""
Splits ``text`` at the last occurrence of ``sep``, returning the result as 3-tuple.
If the separator is not found, this function a 3-tuple containing two empty strings,
followed by the string itself.
:return: a 3-tuple containing the part before the separato... | b0e2c30d5a2f91dd2d75c6688278a2c82b1071a7 | 440,328 |
def unique_routes(routes):
"""
Returns an list with unique routes for all nodes.
This function achieves this by removing simetrical
routes (A, B, C) == (C, B, A).
Args:
routes - a list of routes, as sequences of nodes
Returns: An list with unique routes.
"""
# Iterate ... | 2e67aefcb1ec10f30fbfba7f148bd207b68e8082 | 428,633 |
def date_remove_dashes(std_date):
"""STD_DATE is a date in string form with dashes. Removes dashes for storage in JSON."""
return std_date[0:4] + std_date[5:7] + std_date[8:] | 67e6337a90d6d966325cdd96f4b1844da540fa2e | 692,016 |
def get_concat_peptide(front_coord_pair, back_coord_pair, front_peptide, back_peptide, strand, k=None):
"""
Get the concatenated peptide from possible match peptide.
Parameters
----------
front_coord_pair: str. coordinate string for the front exon pair.
back_coord_pair: str. coordinate string fo... | 704f0d364493233a1a95538844ef92e16838337e | 569,659 |
def is_palindrome(n):
""" Check whether the passed number is a palindrome.
Args:
n: An int to be checked.
Returns:
A bool.
Used by:
004, 055
"""
word_n = str(n)
return word_n == word_n[::-1] | 53b9798958ec97eb47a3ef90264f898e1dd4d546 | 335,724 |
import collections
def sort_dict(dictionary):
"""
Return a dictionary as an OrderedDict sorted by keys.
"""
items = sorted(dictionary.items())
return collections.OrderedDict(items) | 2e7e7be0e94ead309cb6ae7194f2172e94371e40 | 594,501 |
import re
def is_timestamp(string):
"""Tests if the input string is formatted as -yyyy-mm-dd hh:mm:ss"""
reg_exp = re.compile(r'-\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}')
if reg_exp.match(string) is not None:
return True
return False | 6a8927fffef991e2eb45b376e0491b3fb7bd941f | 218,993 |
import math
def round_gb_size_up(gb_size, dp=2):
"""Rounds a GB disk size (as a decimal float) up to suit the platform.
Use this method to ensure that new vdisks, LUs, etc. are big enough, as the
platform generally rounds inputs to the nearest [whatever]. For example, a
disk of size 4.321GB may wind... | 3e65412f461e8ab2f7bb11ef19102879b9e5782b | 32,542 |
def symmetric_mass_ratio_to_mass_ratio(symmetric_mass_ratio):
"""
Convert the symmetric mass ratio to the normal mass ratio.
Parameters
----------
symmetric_mass_ratio: float
Symmetric mass ratio of the binary
Return
------
mass_ratio: float
Mass ratio of the binary
... | 9fea10403726f4f86e0a90004e23958afee43488 | 515,550 |
def fix_macro_int(lines, key, value):
"""
Fix lines to have new value for a given key
lines: array of strings
where key to be found
key: string
key
value: int
set to be for a given key
returns: bool
True on success, False otherwise
"""
l = -1
k = ... | 3490b533bc0941c249753ac8dd4c916048fe97f1 | 249,187 |
from typing import Type
from typing import List
from typing import Tuple
def get_required_class_field(class_type: Type) -> List[Tuple[str, Type]]:
"""Gets all the (valid) class fields which are mandatory.
Args:
class_type (Type): [description]
Returns:
List[Tuple[str, Type]]: [descriptio... | 6ff5878238877b011b7366dbfa4e530547c01d2c | 671,871 |
def encode(data):
"""
Encode string to byte in utf-8
:param data: Byte or str
:return: Encoded byte data
:raises: TypeError
"""
if isinstance(data, bytes):
return data
elif isinstance(data, str):
return str.encode(data)
else:
return bytes(data) | 77b2a070f6b436671e6d6074f37fe0e10ebff98d | 659,824 |
import hashlib
def validate_file(file_obj, hash_value, hash_type="sha256"):
"""Validate a given file object with its hash.
Args:
file_obj: File object to read from.
hash_value (str): Hash for url.
hash_type (str, optional): Hash type, among "sha256" and "md5" (Default: ``"sha256"``).
... | 9e1468cc44b204cbdb0d7c73b0bb943eeb7eaedf | 375,120 |
import csv
def ConvertCSVStringToList(csv_string):
"""Helper to convert a csv string to a list."""
reader = csv.reader([csv_string])
return list(reader)[0] | fa244d2a1c8c50b2b097883f964f1b5bb7ccf393 | 709,119 |
def eqir(registers, opcodes):
"""eqir (equal immediate/register) sets register C to 1 if value A is
equal to register B. Otherwise, register C is set to 0."""
test_result = int(opcodes[1] == registers[opcodes[2]])
return test_result | 0c2d23c1f1377cebb8d658edf8b764891c748094 | 590,237 |
def get_vcond(lambdam, taum):
"""Return conductance velocity in m/s
lambda -- electronic length in m
taum -- membrane time constant
"""
return 2*lambdam/taum | f13a3599a54f1eb85b3e8526f5f3ee764c9a43f3 | 522,224 |
def create_sequence(padding_mask, idx, pad_id=None):
"""
Create a sequence filled with an index
Args:
padding_mask: padding mask of target sequence
idx: filled value
pad_id: index of pad
Returns:
- a long tensor that is of the same shape as padding_mask and filled with ... | 939894b8a8ed1a08d35c2d92744fec5eca42d369 | 168,782 |
def split_opts(seq):
"""Splits a name from its list of options."""
parts = seq.split('::')
name, opts = parts[0], dict()
for x in map(lambda x: x.split(':'), parts[1:]):
for y in x:
try:
opt, val = y.split('=')
except ValueError:
opt, val =... | aa7e103aaae21e6cdb5e97fdb902cec9af4da4f4 | 376,721 |
def index_power(array, n):
"""
Find Nth power of the element with index N.
"""
if n > len(array) - 1:
return -1
return array[n] ** n | b7b1b78f8f3e5ad079670dcf63290cad83196395 | 499,860 |
def mean(data):
"""
Compute the mean value of a sequence of numbers.
"""
if not hasattr(data, '__iter__'):
data = [data]
avg = float(sum(data)) / len(data)
# Done
return avg | 1718655e7bb0012f164c2579107e282f0593bb75 | 412,502 |
import csv
def read_csv(filepath, encoding='utf-8'):
"""
This function reads in a csv and returns its contents as a list
Parameters:
filepath (str): A str representing the filepath for the file to be read
encoding (str): A str representing the character encoding of the file
Returns:
... | aee38a14ca7194c7040b6e8652ad9d43b10e0144 | 688,544 |
def _get_mix_filepath(coverage_datum):
""" Extracts mix file path from a coverage datum.
"""
return coverage_datum.mix_file.short_path | 82a4e0dc8aab0fe6b520a4d7c11e94575157944d | 492,928 |
def mndwi(b3, b11):
"""
Modified Normalized Difference Water Index (Xu, 2006).
.. math:: MNDWI = (b3 - b11) / (b3 + b11)
:param b3: Green.
:type b3: numpy.ndarray or float
:param b11: SWIR 1.
:type b11: numpy.ndarray or float
:returns MNDWI: Index value
.. Tip::
Xu, H. (... | 957ad51dee7942000f826ed144c3aabb94613f9c | 185,672 |
import socket
def _lookup_host(loop, host, family):
"""Look up IPv4 or IPv6 addresses of a host name"""
try:
addrinfo = yield from loop.getaddrinfo(host, 0, family=family,
type=socket.SOCK_STREAM)
except socket.gaierror:
return []
return... | b7827e342166c31b50fd536e8eb930c3b9598a14 | 145,110 |
def get_surfaces_per_volume(my_core, entityset_ranges):
"""
Get the number of surfaces that each volume in a given file contains
inputs
------
my_core : a MOAB core instance
entity_ranges : a dictionary of the entityset ranges of each tag in a file
outputs
-------
s_p_v : a... | 309c86226484bf5485ed46d2f399c8a4c25bc9c7 | 499,537 |
def get_github_path(owner: str, repo: str) -> str:
"""Get github path from owner and repo name"""
return "%s/%s" % (owner, repo) | 189cae1d577ccb32ed5fa0c6f0a0a98fb74768c4 | 634,708 |
def bin_to_str(bin_str_arr):
"""
Convert binary number in string to string
:param bin_str_arr: str, whose length must be a multiple of 8
:return: str
"""
res = ''
for i in range(0, len(bin_str_arr), 8):
res += chr(int(bin_str_arr[i:i+8], 2))
return res | 4da23c7f6261f4f5da7a8bd830ad474855bce811 | 171,049 |
def line_count(node, file):
"""Return the line count of file on node"""
out = [line for line in node.account.ssh_capture("wc -l %s" % file)]
if len(out) != 1:
raise Exception("Expected single line of output from wc -l")
return int(out[0].strip().split(" ")[0]) | 60afe65d0e4a6c731ed5c0ea87370818aa0733ab | 562,557 |
def map_to_docs(solr_response):
"""
Response mapper that only returns the list of result documents.
"""
return solr_response['response']['docs'] | 2661b9075c05a91c241342151d713702973b9c12 | 6,246 |
import base64
def generate_http_basic_token(username, password):
"""
Generates a HTTP basic token from username and password
Returns a token string (not a byte)
"""
token = base64.b64encode("{}:{}".format(username, password).encode("utf-8")).decode(
"utf-8"
)
return token | ce0fafa49b55e7692be5b55b0bb4543a6038e158 | 459,551 |
def read_file(filename):
"""Function reads contents of file
Args:
filename (str): Filename to read
Returns:
list: List with lines of text in file
"""
with open(filename, "r", encoding="utf-8") as fp:
return fp.readlines() | 23924d0c86712b14be7d3cf0c1faec186f8cc726 | 114,169 |
def split_file_name(file_absolute_name):
"""
Splits a file name into: [directory, name, extension]
:param full_name_template:
:return:
"""
split_template = file_absolute_name.split('/')
[name, extension] = split_template[-1].split('.')
directory = "/".join(split_template[0: len(split_te... | f3144b0f75cbde26c8a8244cb8d8eda712e8edfa | 635,306 |
import time
def get_close_string(time_to_close):
"""
Given a time in seconds, this will format it as a string like 03h:12m
"""
time_to_close = time.gmtime(time_to_close)
close_string = time.strftime('%Hh:%Mm', time_to_close)
return close_string | f7c678bf2b5ef0b0db4e3e50e10adb977a869ff7 | 248,680 |
def VERSION(parent, r):
"""Return the current version of PyBot library"""
return parent.robot._get_pybot_version() | beac216fb3f5b861cea328c7f481887c312acf7b | 282,455 |
def extract_id(url):
"""
:param url like http://data.finlex.fi/ecli/kko/1998/138:
:return: 1998_138
"""
splitted = url.split('/')
return splitted[-2] + '_' + splitted[-1] | 3b788be247bb7039b419a79fa0216459b078e552 | 608,561 |
import re
def contains_chinese(text):
"""Returns whether the given text contains any chinese characters."""
return re.search(u'[\u4e00-\u9fff]', text) | a2ea77109b3af46cae1f99f8c7fb20fc6f1ab4b1 | 642,535 |
def german_X(german_data):
"""Process German to remove categorical columns."""
outcome_name = german_data.columns[0]
return german_data.drop([outcome_name, 'Gender', 'PurposeOfLoan', 'OtherLoansAtStore'], axis=1) | fb178f96bbef53628d7dcd26d0f86c864cb370f8 | 453,975 |
def fix_ext_py(filename):
"""Given a .pyc filename converts it to the appropriate .py"""
if filename.endswith('.pyc'):
filename = filename[:-1]
return filename | c978f86af22b6833e681de8a040a8718aeaa4bfc | 543,971 |
def player_value_to_string(text):
"""
Parses the player's value from a string.
Args:
text: The standard string of a player's value from Transfermarkt.
Returns:
A float representing the player's value. If the value cannot be parsed,
returns None.
"""
# Free transfer
... | 642de7e7d67409c3cb288286806530068f2ac602 | 229,854 |
def load_user_id_whitelist(fw):
"""
Load user IDs from a FW-group-defined whitelist.
"""
# Group name is intentionally not configurable.
group_name = 'hpc-whitelist'
group_perms = fw.get_group(group_name)['permissions']
return list(map(lambda x: x.id, group_perms)) | 645388df94d00944feaef07b14ff11f40b1dc40d | 435,624 |
import re
def parse_freq_err_resp(resp):
""" Parse the frequency error response
@param resp: response from ATECPS
@return: frequency error in Hz
"""
pattern = '\[(.+)\]'
freqerr = re.search(pattern, resp)
if freqerr:
return int(freqerr.group(1))
else:
return 0 | 7eff65d3b91299d3c1954d104baee3a29ca9ff84 | 431,121 |
import re
def validate_hostname(hostname):
"""
Validate a hostname string. This allows standard hostnames and IPv4
addresses.
:param hostname: The hostname to validate.
:return: Boolean: True if valid, False if invalid
"""
# Hostname length is limited.
if len(hostname) > 255:
... | 70a2f2c8367af5480f0c9daca0ce4f02af50c786 | 536,289 |
def get_is_active(language, order):
"""
Checks if order is active or no and creates response in appropriate language
:param language: language of conversation
:param order: client order
:return: string with info about if order is active or no
"""
output_string = ""
if language == 'pl':
... | 15e065cc545cf6aa9c471b36c73400317d43b4bc | 607,042 |
def fix_text_note(text):
"""Wrap CHS document text."""
if not text:
return ""
else:
return """* CHS "Chicago Streets" Document:\n> «{}»""".format(text) | 56cbcbad7e8b3eee6bb527a240ad96701c4eea2f | 6,412 |
def intervals_overlap(i1, i2):
"""Returns True if Interval i1 overlaps Interval i2. The intervals are considered to be closed, so the intervals
still overlap if i1.end == i2.begin or i2.end == i1.begin.
"""
return not (i1.end < i2.begin or i2.end < i1.begin) | 4ab6cea8e869739eed369f6be348db233f64f6e8 | 119,945 |
import pickle
def get_plankton(path, *plankton_sets):
"""Returns plankton training sets converted from serialised pickle objects
into Pandas dataframes.
Args:
path ([path]): Path to pickled training sets
plankton_sets (*[pkl]): Four * pkl objects
Returns:
[pd.DataFrames]: T... | 97dfdb58d8737ded321943c5185ec12c98561000 | 252,894 |
def allowed_file(filename, allowed_set):
"""Checks if filename extension is one of the allowed filename extensions for upload.
Args:
filename: filename of the uploaded file to be checked.
allowed_set: set containing the valid image file extensions.
Returns:
check: boolean value ... | 199e43b124ba92da6d9b644b3c9564ee86f7d69d | 291,518 |
async def _get_post_id(db, author, permlink):
"""Get post_id from hive db."""
sql = "SELECT id FROM hive_posts WHERE author = :a AND permlink = :p"
return await db.query_one(sql, a=author, p=permlink) | be64e63c81ebf9e70c5e8f97b1d57256ed756cd5 | 643,543 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.