content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def to_camel_case(snake_case):
""" convert a snake_case string to camelCase """
components = snake_case.split('_')
return components[0] + "".join(x.title() for x in components[1:]) | e7433ec546cc93700bd67bd4e559795a9add31ed | 686,144 |
def elite_selection(population, elite_num):
"""
Uses elite selection to pick elite_num units from population
:param population: population to be picked from
:param elite_num: number of units to be selected
:return: array of selected units
"""
return population[:elite_num] | e4fc4e42b49014e64d4f79547c99264b56e4bf02 | 202,356 |
def get_keys_from_val(dic, val):
"""Get all keys from a value in a dictionnary"""
toreturn = list()
for key in dic:
if dic[key] == val:
toreturn.append(key)
return toreturn | 3e6217af28b2192c63c4dfb220550535abc2eb5d | 445,962 |
def is_tuple_starting_with(tuple_1, tuple_2):
"""
Returns whether `tuple_1` starts with `tuple_2`.
Parameters
----------
tuple_1 : `tuple`
The first tuple which should start with the second one.
tuple_2 : `tuple`
The second tuple.
Returns
-------
is_tuple_st... | 1c69bd0033c2535212f22af74ae783af25959ec0 | 526,131 |
def is_in_file(file_path, text):
"""
Looks for text appearing in a file.
:param str file_path: Path to the source file
:param str text: Text to find in the file
:raises OSError: If the file does not exist
:returns bool: True is text is in file, False otherwise
"""
with open(file_path, 'r... | 3b5b482a9bec8d211dbe6631f888fed19376ecde | 396,560 |
def IntToRGB(intValue):
""" Convert an FL Studio Color Value (Int) to RGB """
blue = intValue & 255
green = (intValue >> 8) & 255
red = (intValue >> 16) & 255
return (red, green, blue) | 5ba1735c73a2b0c51f67b8b4f0ae67dfcae8a5ea | 64,726 |
import pkg_resources
def get_package_version(pkg_name):
"""Get the version of the given package"""
return pkg_resources.get_distribution(pkg_name).version | c72e1d09cf50cbcf2a9f1f4dd0f462c1e0cdac6c | 224,462 |
def arr2str(arr):
"""Convert numpy 1D array into single string of spaced numbers."""
return " ".join(map(str, list(arr))) | 44d9fb4ce0513945bf61da525bda8faed738d223 | 540,177 |
def clean_strains_with_bad_dates(ird_df):
"""
Removes strains that have bad dates (i.e. only MM-YYYY or YYYY).
"""
ird_df['date_length'] = ird_df['Collection Date'].str.split('/').str.len()
ird_df = ird_df[ird_df['date_length'] == 3]
return ird_df | 9cda8c0d50cff313614170035f8fdf2c88cd7ce9 | 587,879 |
def mapped_ipv6_to_ipv4(hex):
"""
For converting ipv4 addresses mapped to ipv6 back to ipv4
:param hex: ipv6 address without the '00000000:00000000:0000FFFF:' prefix
:return: String containing the ipv4 address
"""
grouped = [hex[i:i + 2] for i in range(0, len(hex), 2)]
return '.'.join(list(m... | a79a5de9b7900dc5834b8e7eb27e9fd25aa9873d | 378,861 |
def update_analyze_button(disabled):
"""
Updates the color of the analyze button depending on
its disabled status
:param disabled: if the button is disabled
"""
if not disabled:
style = {"width": "100%", "text-transform": "uppercase",
"font-weight": "700", "background":... | 5a0056879fd5ecde05b7b4fbadbeb7e3aeb1d679 | 46,228 |
def is_simple_requires(requires):
"""
Return True if ``requires`` is a sequence of strings.
"""
return (
requires
and isinstance(requires, list)
and all(isinstance(i, str) for i in requires)
) | d13c9fe631c32677fbf2be55fd7c048ed566f950 | 635,956 |
def publication_to_md(publication: dict) -> str:
"""
This function outputs a Markdown string for a publication
({"title": ..., "author": ..., "title": ...})
"""
title = publication["title"]
year = publication["year"]
authors = publication["authors"]
md = f"- **{title}** ({year})\n"
m... | 7af0b0fd718525abd7250e27d39dc9e2fc8495c8 | 214,936 |
def letters_swap(word1: str, word2: str) -> bool:
"""Returns True if two words have only two letters swapped.
"""
counter = 0
for i in range(len(word1)):
if word1[i] != word2[i]:
counter += 1
if counter != 2:
return False
else:
return True | c191541ad4f542595aada52d789458b99ba4a083 | 481,786 |
def append_locations_work_orders(config):
"""
Append multiple work location points to each work order
"""
work_orders = config["work_orders_signs"]["records"]
spec_actuals = config["work_orders_signs_asset_spec_actuals"]["records"]
join_field = config["work_orders_signs_asset_spec_actuals"]["wor... | 13d41972a9889a19889cf47d1c7889c952fd9512 | 447,909 |
import math
def floor(value):
"""Rounds a number down to the nearest whole number."""
return math.floor(value) | ae79c659bbdb157c2d79e7bb7ba1747ef19ada1c | 643,823 |
def _get_01_coords(x):
""" Returns the coordinates normalised to (0,1). """
x1 = x[0][0]
x2 = x[0][1]
x3 = float(x[1]) / (194.0 - 103.0)
x4 = x[2] - 10.0
return [x1, x2, x3, x4] | eb44417d3510638fda02d3612f2eca4eac37d25e | 445,354 |
def series_sum(n):
"""Sum of first nth term in series and return float value."""
total_series = 0.00
for x in range(n):
total_series += float(1) / (1 + (x * 3))
total_series_decimal = ('{0:.2f}'.format(total_series))
return total_series_decimal | d383b32638ef113d581cac6e30e619956e181961 | 651,297 |
def test_create_dataframe(data, columns, types, rows_allowed):
"""
Tests whether the data in a dataframe match the column name, data type,
and row count constraints.
Extended description of function.
Parameters:
data (pandas.dataframe): Data loaded from a publicdata source (911 CSV
from da... | 1e27efc5e31fb933763e1ee3d64d35537e34c283 | 585,152 |
def exception_message(exc):
"""
Take an exception and return an error message.
The message includes the type of the exception.
"""
return '{exc.__class__.__name__}: {exc}'.format(exc=exc) | f8ec26ba3fc82e436f32f6c527deb2d8da9b90dc | 233,182 |
def column(matrix, i):
"""
Gets column of matrix.
INPUTS:
Matrix, Int of column to look at
RETURNS:
Array of the column
"""
return [row[i] for row in matrix] | ab7fba90b5f87486a7f52ba3f8aad5c0047ecad9 | 685,172 |
import json
def dict_to_binary(json_dict: dict) -> bytes:
"""
Encode the json file to utf-8
:param json_dict: dict
:return: json
"""
return json.dumps(json_dict).encode('utf-8') | dfb5c64342fa232379ebbbd9d7a69b1b7b93cf32 | 128,443 |
import socket
import errno
def mock_server_receive(sock, length):
"""Receive `length` bytes from a socket object."""
msg = b''
while length:
chunk = sock.recv(length)
if chunk == b'':
raise socket.error(errno.ECONNRESET, 'closed')
length -= len(chunk)
msg += ch... | 1f9071e453ac617754b8b09cc36293a6d9e51dcb | 611,807 |
def quaternion_multiply(r, q):
"""Multiplies two quaternions.
Parameters
----------
r : list
Quaternion as a list of four real values ``[rw, rx, ry, rz]``.
q : list
Quaternion as a list of four real values ``[qw, qx, qy, qz]``.
Returns
-------
list
Quaternion :m... | da51aa780e90e46844086e06ff6b9e44c005a66c | 220,621 |
def build_dataset_attributes_json_object(output_files, container_name, num_files, num_multi_page,
percentage_multi_page):
"""
:param output_files: The files to output
:param container_name: The storage container name
:param num_files: The number of files process... | f49a1f4dbd15d49aea228c9689de4cd3a053b0a1 | 594,248 |
def get_float(fields, key):
"""Convert a string value to a float, handling blank values."""
value = fields[key]
try:
value = float(value)
except ValueError:
value = 0.0
return value | 53629f5d8fa2c23ed19d97612e9adb3dc7299496 | 503,718 |
from typing import Any
from typing import Optional
import textwrap
def add_prompt_alt(prompt: str, value: Any, max_width: Optional[int] = None, indent: str = ' ') -> str:
"""
Returns the ``str()`` of a value with a prompt prepended. This uses a different style from `add_prompt`:
- If the value's string ... | ad68efda5033e82b3da2873a06a68f7689712983 | 237,147 |
def find_project_dir(runpath):
"""
Scans up directories until it finds the project folder.
:param runpath: pathlib.Path, where summit_core is called from.
:return: pathlib.Path, the base project directory
"""
runpath = runpath.resolve()
if runpath.name == "Summit" or runpath.name == 'summit... | bb77ab81d5b3c08baa06fdabbae6afad5b120b59 | 110,025 |
def interpolate(a, b, v, doRound=False):
"""Answers the interpolated value of factor v between a and b. If doRound
is True (default is False), then round the result before answering it."""
i = a + (b-a) * v
if doRound:
i = int(round(i))
return i | b385bece155f2b16dbb88b8c0f1a72e53e83ea9f | 430,199 |
import socket
def get_local_ip(target=None):
"""
Get the "public" IP address without sending any packets.
:param target: Since the host might have different interfaces,
we want to know the IP address that will be used to connect to "target",
not just the "default gateway" IP address.
:return... | 9fcac8ae9c8b6f93c4ec7878d9fd9d3016b0f174 | 326,738 |
import re
def any_char_matches(substring: str, mainString: str):
"""Scans the string for any matches a certain pattern.
Parameters
----------
substring : str
The string that is used to find matches from `mainString`.
mainString : str
The `mainstring` which contains the original s... | b0db76f9f7ed34cd45ba118c758944afbb7b0090 | 47,681 |
def text_color(message='{}', color_code='\033[0;37m'):
"""Set text to a color, default color is White"""
no_color = '\033[0m'
return f'{color_code}{message}{no_color}' | bede08b771b33ce26bbb0ee4fd42f3712d224cc1 | 10,301 |
def HamSN1D_Hamiltonian(t, u):
"""
Returns Hamiltonian for the 1DoF saddle-node model.
Functional form: H = y**2/2 + x**3/3 + x**2/2, with u = (x, y).
Parameters
----------
t : float
Time. (This Hamiltonian is independent of time.)
u : ndarray, shape(n,)
Points in phase spa... | ca29fb9b7d470b112a2337b084232a61ab190c8e | 445,826 |
def str2bool(string):
""" Convert string to corresponding boolean.
- string : str
"""
if string in ["True","true","1"]:
return True
elif string in ["False","false","0"]:
return False
else :
return False | 87ef46e919aa40d656df16a5df6c2ce9932c9058 | 141,532 |
def unnest_lists(lists):
"""
[[0,1], [2]] -> [0,1,2]
"""
return [entrie for sublist in lists for entrie in sublist] | 4f2554bec87bc885de8cc1bda8e710855c6a2105 | 491,301 |
def get_plural(val_list):
""" Get Plural: Helper function to return 's' if a list has more than one (1)
element, otherwise returns ''.
Returns:
str: String of 's' if the length of val_list is greater than 1, otherwise ''.
"""
return 's' if len(val_list) > 1 else '' | b86387cb2abd3c5176f5dcefbf7bc3e1a49a346c | 17,535 |
from typing import List
def str2ngrams(string: str) -> List[str]:
"""Converts a string to a list of ngrams (monogram, bigram, trigram)."""
ngrams = string.split() # monograms
token_list = string.split()
if len(token_list) > 2:
ngrams += [
w1 + " " + w2 + " " + w3
for w... | 9f4e85766553fcef21222a849507dfea38b471dd | 525,033 |
def validMoves(b):
"""Create a list of valid moves."""
return [i for i, v in enumerate(b) if v == ' '] | 577899dc17af340d3000609f59954966e26da3d8 | 226,194 |
def lookUpGeometry(geom_type):
""" converts ArcRest API geometry name to Python names
Input:
geom_type - string - name of geometry
Output:
name of python geometry type for create feature class function
"""
if geom_type == "esriGeometryPoint":
return "POINT"
... | eb4308894de3550602fcf4310d0e2ae701b0f86d | 521,772 |
def find_nth(string, substring, n):
"""Finds the index of the nth instance of the given substring from the given string"""
location = string.index(substring)
while n > 1:
location = string.index(substring, location+len(substring))
n -= 1
return location | 8e590bc657172f7e526d225fe64adebf24be742a | 516,604 |
def range_data_nomerge(main_data, added_data):
"""
Take main data and then update clusters with the added data only if they do
not already exist. Return only the valid clusters (not full set)
"""
ret_data = {}
for cluster in added_data:
if main_data.get(cluster) is None:
ret_data[cluster] = added... | 336b0a54524962bb00c8b82f4ebfae42da013698 | 121,859 |
def flip(axis):
"""Returns the opposite axis value to the one passed."""
return axis ^ 1 | 72dbe4fdc8f0d203b56bddc50c59ade23f37a7a0 | 64,819 |
def process_covid_json_data(local_json: dict, national_json: dict) -> dict:
"""Returns a dictionary of specified metrics based on the JSON files of local and national COVID data
The specified metrics are: total cumulative deaths, current hospital cases, the 7-day infection rate for the
national data set, a... | 0940f0ed82a9b0df39c7d32c0156ac3cd7a058f0 | 70,478 |
def rasterFromDataset(dataset):
"""
Reads all raster bands from a dataset and returns them as a NumPy ndarray of shape (h,w[,c])
"""
raster = dataset.ReadAsArray()
if len(raster.shape) > 2:
raster = raster.transpose((1, 2, 0))
return raster | 96163658b836c5da4cd97004bdf2564b1c0b44b5 | 280,875 |
def is_int(number):
"""Return if a number can be represented as an integer."""
return int(number) == number | 7e32fa9e07d6b88aec386f598d47f90b7077d3a6 | 537,792 |
def unscale_coordinates(point, M):
"""
Unscale coordinates by M
:param point: Point
:param M: Scaling factor
:return: Unscaled points
"""
return point * M | b528625c7a7d1f9ef135609d1d22fd7b2faeb756 | 622,859 |
def ConstantAddition(s, t, scheme):
"""
ConstantAddition function from LowMC spec.
:params s: state
:params bs: round constants
:params t: round
:param scheme: lowmc parametrization + constants
"""
return [s[i] ^ scheme['b'][t-1][i] for i in range(scheme['blocksize'])] | d9774db5e5c1ded9b5166e03b62154a806bd637d | 325,477 |
def get_spatial_cell_id(dataset_uuid:str, tile_id:str, mask_index:int)->str:
"""Takes a dataset uuid, a tile_id within that dataset, and a mask_index number within that tile to prodduce a unique cell ID"""
return "-".join([dataset_uuid, tile_id, str(mask_index)]) | 58e5bc01f973d38de831ec4f54c782c57e3ea825 | 469,779 |
def combine_prediction_metadata_batches(metadata_list):
"""Combines a list of dicts with the same keys and lists as values into a single dict with concatenated lists
for each corresponding key
Args:
metadata_list (list): list of dicts with matching keys and lists for values
Returns:
... | 28fd647b19e5affa3f04c7909a4ba7ff17993da1 | 615,866 |
import json
def get_json_key(filepath: str, keyname: str):
"""
Gets a json file key from specified filepath and keyname
"""
with open(filepath, "r") as f:
data: dict = json.load(f)
return data.get(keyname) | c0bbca6bcdc039cdec26a9a8e655b56e5dab1637 | 178,494 |
def clean_word(word: str) -> str:
"""Return all alphanumeric characters from word, in the same order as
they appear in word, converted to lowercase.
>>> clean_word('')
''
>>> clean_word('AlreadyClean?')
'alreadyclean'
>>> clean_word('very123mes$_sy?')
'very123messy'
"""
cleane... | 552731e601ff7dca2f9d6f71cfb15cc252e1b616 | 167,658 |
def factorial_iter(num: int) -> int:
"""
Return the factorial of an integer non-negative number.
Parameters
----------
num : int
Raises
------
TypeError
if num is not integer.
ValueError
if num is less than zero.
Returns
-------
int
"""
if not ... | 36ec433bf02bdef0770f9f9b86feff9afa995eb3 | 702,663 |
def __partition2way__(arr, lo, hi):
"""
Function to achieve 2-way partitioning for quicksort
1. Start with 2 pointers lt and gt, choose first element (lo) as pivot
2. Invariant: everything to the left of lt is less than pivot, right of gt is larger than pivot
3. In each iteration, do the following i... | 2177bea6e30273ea5bb04d77e8df03516938217b | 407,634 |
def page_type(content):
"""
Evaluate the request content and identify the type of the page.
Args:
content (str): page content to analyse.
Returns:
"album" if a track list was detected.
"discography" if a set of albums and tracks was found.
"track" if the above do not ap... | 15cc73db157aaf3f86111a011e50704742f3a1b6 | 159,226 |
def cast_logo(instance, filename: str) -> str:
"""
Generate cast logo filename from cast slug
"""
return f"casts/{instance.slug}/logo.{filename.split('.')[-1]}" | 99fb2860cc9ea8d7f4cd3d15afd1ba76d2abe56f | 474,215 |
def count_params(model):
"""Count the number of parameters in the model"""
param_count = sum([p.numel() for p in model.parameters()])
return param_count | bdaaed08a9d4f8bc265b3f0063ea7d1271c260b1 | 514,813 |
import hashlib
def blake2b(filename: str) -> str:
"""Get blake2b digest for a file.
Args:
filename (str): The file to get a blake2b digest of.
Returns:
str: A blake2b hexdigest.
"""
with open(filename, "rb") as f:
file_hash = hashlib.blake2b()
while chunk := f.rea... | a6dfca323324ce1f77bb086a7617e6a3eceb3d98 | 341,879 |
def camelCaseIt(snake_str):
""" transform a snake string into camelCase
Parameters:
snake_str (str): snake_case style string
Returns
camelCaseStr (str): camelCase style of the input string.
"""
first, *others = snake_str.split('_')
return ''.join([first.lower(), *map(str.title, ... | 691bbcaa12c8065e363e8b7c430f25bc44d370c5 | 549,481 |
def get_table_list(dbconn):
"""
Get a list of tables that exist in dbconn
:param dbconn: database connection
:return: List of table names
"""
cur = dbconn.cursor()
cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
try:
return [item[0] for item in cur.fetchall()]
... | fb1f4cac07b7260852c3c8387f702bc7b3b4f423 | 331,789 |
def dict2conll(data, predict):
"""Writes conll string in file"""
with open(predict, 'w') as CoNLL:
CoNLL.write(data['conll_str'])
CoNLL.close()
return None | 3fee99010656052597dc1f1ea34d04c20d053f53 | 398,898 |
from typing import Optional
def _term_converter(term: Optional[int]) -> Optional[int]:
"""
Converter function for ``term`` in :class:`~.BaseProduct``.
:param term: The number of months that a product lasts for if it is fixed length.
"""
if term is None:
return None
else:
return int(term) | 65277a31fe4666d410c9aa46a8b01fe59dbcb4fc | 31,322 |
import re
def tokenize(xs, pattern="([\s'\-\.\,\!])"):
"""Splits sentences into tokens by regex over punctuation: ( -.,!])["""
return [x for x in re.split(pattern, xs)
if not re.match("\s", x) and x != ""] | 10e9eae492f4ca6993e22fe7b567c934f33b6d8b | 489,500 |
def ramp_function(t_list, start_value, end_value):
"""
Returns a function that implements a linear ramp from start_value to end_value over
the time domain present in (an ordered) t_list
"""
rate = (end_value - start_value) / (t_list[-1] - t_list[0])
ftn = lambda t: start_value + (t - t_list[0]) ... | 64699a93a14609ebc00e6d1b215c3096ad636b3c | 413,233 |
import csv
def _load_params(file_path):
"""
Loading the hyperparameters from specific file.
Parameters
----------
file_path : str
File path of config files
Returns
-------
List of parameter dict
"""
config_list = []
exp_name = file_path.split("/")[-1].replace... | eb9a816c927b174ed3a0c35aa1ac2b367353f950 | 279,888 |
def table_with_9999_columns_10_rows(bigquery_client, project_id, dataset_id):
"""Generate a table of maximum width via CREATE TABLE AS SELECT.
The first column is named 'rowval', and has a value from 1..rowcount
Subsequent columns are named col_<N> and contain the value N*rowval, where
N is between 1 a... | a37d5bf66cf5cf0e300c1d1209aabc0b0cf2e670 | 113,337 |
def dimension(x):
"""
Return the dimension of ``x``.
EXAMPLES::
sage: V = VectorSpace(QQ,3)
sage: S = V.subspace([[1,2,0],[2,2,-1]])
sage: dimension(S)
2
"""
return x.dimension() | e2ebc115b88d83e6ea1ec81a6f27fece0df4f9be | 204,558 |
import uuid
def get_random_string(length: int = 32) -> str:
"""
This function returns an alphanumeric string of the requested length.
:param int length: the length of the random string. Max of 32 characters
:returns: a random string
:rtype: str
"""
if length > 32:
length = 32
... | 62e5682d01bef4bba86498a073c5942e5f0ee96c | 424,791 |
import re
def _parse_lambda(text):
"""Parse the definition of a lambda function in to a readable string."""
text = text.split('lambda')[1]
param, rest = text.split(':')
param = param.strip()
# There are three things that could terminate a lambda: an (unparenthesized)
# comma, a new line and an... | 7f026e685fdb1f5f72c4a5195acf46f22c42cb44 | 196,260 |
import re
from typing import Tuple
def parse_version_string(name: str) -> Tuple[str, str]:
"""Parse a version string (name ID 5) and return (major, minor) strings.
Example of the expected format: 'Version 01.003; Comments'. Version
strings like "Version 1.3" will be post-processed into ("1", "300").
The pars... | 0680cd64e28c7ddb5c0aeae5cb868387c8bd5a35 | 663,011 |
import time
def task_symbols(storage):
"""
Task that prints first character of contents of storage["symbol"] forever.
"""
sym = storage.get("symbol", ".")
print(sym[0], sep=" ", end="", flush=True)
time.sleep(.25)
return True | 11982a69cd318d98b122350df3044fad7a6b87c5 | 330,412 |
def gcdr(a, b):
"""Recursive Greatest Common Divisor algorithm."""
if b == 0:
return a
if a<b:
a,b = b,a
print(a,b)
return gcdr(b, a%b) | 7edd0742f2f57dbed839b345067df734ec5e4544 | 645,120 |
from typing import List
import random
def _get_random_values(n_instants: int, items_per_instant: int) -> List[List[float]]:
"""Generates the list of items values randomly.
"""
return [[random.random() for _ in range(items_per_instant)]
for _ in range(n_instants)] | 7efcf657e8038de5f12c32d277a8da05b0264ad5 | 196,994 |
def yrotate(p, theta):
"""Return a new vector after performing a rotation on p around
the y axis"""
p = p.copy()
return p.yrotate(theta) | 2d32bb35aae8d69fc7767c60926d39ffa926553e | 453,478 |
def toggles_block_quote(line):
"""Returns true if line toggles block quotes on or off
(i.e. finds odd number of ```)"""
n_block_quote = line.count("```")
return n_block_quote > 0 and line.count("```") % 2 != 0 | 0223c487cfc0139aa6c96ecbd2559c45ad0b2fd5 | 495,877 |
import re
def normalize(string):
"""Replace all invalid characters with "_"
:param string string: A string to normalize.
:return string: Normalized string
"""
string = str(string)
if re.match("^[0-9]", string):
string = "_" + string
return re.sub("[^A-Za-z0-9_-]", "_", str(stri... | a67ed717daad92f500582bcde7abc3344c281a32 | 428,893 |
def make_unique(qs, unique_var):
"""Make the queryset unique by unique_var, sort by unique_var"""
if hasattr(qs, "distinct"): # Need to check so that this does not break in Preview mode in Wagtail
distinct_pks = qs.distinct(unique_var).order_by(unique_var).values_list('pk', flat=True)
return qs... | 62b1bb9453d6eba885906ec3c67851a75a5f781d | 127,736 |
def query_transform(request, **kwargs):
"""Alter parameters in a query string while keeping the rest."""
updated = request.GET.copy()
for field, value in kwargs.items():
updated[field] = value
return updated.urlencode() | c7745875944aecae6afbda81646f3cf5b1a21e1e | 379,347 |
def is_ugly(num, factors=(2, 3, 5)):
"""
Check whether a given number is an ugly number
:param num: given number
:type num: int
:param factors: prime factors for ugly number
:type factors: list[int] or tuple[int]
:return: whether a given number is an ugly number
:rtype: bool
"""
... | 8f343ef6b9d382cbea778acc7d55c95ffcbdd4c1 | 108,304 |
import re
import itertools
import random
def generate_spintax(text, single=True):
"""Return a list of unique spins of a Spintax text string.
Args:
text (string): Spintax text (i.e. I am the {President|King|Ambassador} of Nigeria.)
single (bool, optional): Optional boolean to return a list or ... | a3635958fad90ace9592f3e32c4d0a2b3c29a152 | 77,912 |
def h(params, sample):
"""This evaluates a generic linear function h(x) with current parameters. h stands for hypothesis
Args:
params (lst) a list containing the corresponding parameter for each element x of the sample
sample (lst) a list containing the values of a sample
Returns:
Evaluation of h(x)
"""
ac... | 4267ba1499eb6863cdc32a9b3572afd196599105 | 621,196 |
def make_uniform(planes_dict, uniques, padding):
""" Ensure each section has the same number of images
This function makes the output collection uniform in
the sense that it preserves same number of planes across
sections. It also captures additional planes based
on the value of the padding variab... | 8f67f7226dcf8846707f9d190eb9b15ccb1b27e9 | 695,700 |
import re
def hex_to_rgb(hx, hsl=False):
"""Converts a HEX code into RGB or HSL.
Args:
hx (str): Takes both short as well as long HEX codes.
hsl (bool): Converts the given HEX code into HSL value if True.
Return:
Tuple of length 3 consisting of either int or float values.
Raise... | f0c197be38e93d8c0afe528ba40a5a6b74b7adb6 | 226,263 |
def get_reactions_producing(complexes, reactions):
""" dict: maps complexes to lists of reactions where they appear as a product. """
return {c: [r for r in reactions if (c in r.products)] for c in complexes} | a695141f35190abd6248d112f0b7bc2f1a89770f | 286,893 |
def get_default_simulation_kwargs(amp=None, model=None):
"""
Returns default keyword arguments to set up a basic stimulus in a simulations
Doesn't include amp as this usually needs to calculated (e.g. to find rheobase)
or set to a specific value.
"""
default_kwargs = {
'dur':500.,
... | 066f676321fd5fecb9e84e3359dc2c976fb9ad67 | 434,232 |
def neighbors(lines, of):
"""Find the indices in a list of LineStrings that touch a given LineString.
Args:
lines: list of LineStrings in which to search for neighbors
of: the LineString which must be touched
Returns:
list of indices, so that all lines[indices] touch th... | 37aabaab8686911baf0ef6f93170a8b3422c6f09 | 443,425 |
def add_key(udict, key, value):
"""Add a new key:value combo to dict
"""
cdict = dict(udict)
cdict[key] = value
return cdict | 6dfca9df39056d24ce51187ca89eb8e3f2bd5857 | 138,662 |
def take(arr: list, n: int) -> list:
"""
Accepts a list/array and a number n,
and returns a list/array array of the
first n elements from the list/array.
:param arr:
:param n:
:return:
"""
return arr[:n] | b23d5c169934b52647c77a9fb7b8c9c0cfb48bd2 | 276,634 |
def nmiles_to_km(N):
"""convert nautical miles to km"""
N = N * 1.852
return N | fc8fe240f179bd1166c6e2a6fe05679831a75a81 | 203,438 |
import re
def extract_path(path_string):
"""Convert a path string to a list of names"""
return re.findall(r"[^/\\]+", path_string) | 85f6894688f458aaa4d8bf168f9a667c8ef2cc01 | 636,357 |
import inspect
def _filter_class_attributes(path, parent, children):
"""Filter out class attirubtes that are part of the PTransform API."""
del path
skip_class_attributes = {
"expand", "label", "from_runner_api", "register_urn", "side_inputs"
}
if inspect.isclass(parent):
children = [(name, child)... | b9911c076dc7aafcfbda0f7dcf197982ed8067a3 | 646,662 |
def compute_start_end(dataset_str, thread):
"""
calculate start and end points for multi_threading
"""
individuals_number = dataset_str.shape[0]
number_each_thread = int(individuals_number/thread)
start = [number_each_thread * i for i in range(thread)]
end = start[1:]
end.append(individu... | cc1fcebc71b2e82876b98db33a80954306f4526b | 74,172 |
def total_length(neurite):
"""Neurite length. For a morphology it will be a sum of all neurite lengths."""
return sum(s.length for s in neurite.iter_sections()) | 854429e073eaea49c168fb0f9e381c71d7a7038a | 708,330 |
import json
def load_default(key):
"""
Load default configuration.
Args:
key (str): Find credentials for this key
Raises:
None
Returns:
cred (dict): Default configuration
"""
path = 'securetea.conf'
with open(path) as f:
creds = json.load(f)
r... | 27ba2d56863a33f9f7f8946349d55002e0d9324b | 295,968 |
def get_season(cube):
"""Return a climatological season time string."""
season = cube.coord('clim_season').points
return season[0].upper() | f129cd01f17d8e6f55e1c621ca4a37e70b0ad410 | 191,863 |
from typing import Any
def make_safe(value: Any) -> str:
"""
Transform an arbitrary value into a string
Parameters
----------
value: Any
Value to make safe
Returns
-------
str
Safe value
"""
if isinstance(value, bool):
return str(value).lower()
ret... | 4b342105d26458ddffd20712c777c5bc8e221c81 | 16,831 |
def getPositions(mask):
"""
Get a list of positions where the specified
mask has the bit set
"""
# XXX I don't exactly love this implementation,
# but it works.
binaryString = bin(mask)[2:]
result = []
for index, c in enumerate(binaryString[::-1]):
if int(c):
resu... | f4976a7c900e82e62c7d067d337c6f5db7d269a9 | 591,997 |
def select_all(_):
"""
Returns True for all particles.
"""
return True | 34e277c1ae59a9032e5d09e45cf27732185d9c49 | 692,810 |
def run(df, docs):
"""
drops all rows of the dataframe that contains at least one null
:param df:
:return:
"""
for doc in docs:
doc.start("t05 - Drop null", df)
df.dropna(inplace=True)
for doc in docs:
doc.end(df)
return df | d544b7cbe1d7c0f216d189dd68690b581d3dde1a | 413,691 |
def cell_width(cell_name):
""" Set the width of the cells from the pdf report file."""
if cell_name == "No":
table_cell_width = 6
elif cell_name == "Phrase":
table_cell_width = 73
elif cell_name == "Question":
table_cell_width = 57
else:
table_cell_width = 25
retu... | fac9e9dc0f8ad3cac09ed3054a798e7d832cdcc6 | 36,396 |
def ff(items, targets):
"""First-Fit
This is perhaps the simplest packing heuristic;
it simply packs items in the next available bin.
Complexity O(n^2)
"""
bins = [(target, []) for target in targets]
skip = []
for item in items:
for target, content in bins:
if item... | 3649d9b7704f36871f320a236cff0115b75689f3 | 48,071 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.