content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def nrhs(k: int) -> int:
"""Number of right-hand-sides of a linear system."""
return k | 6d761d433dc76d926c48c620235207c6c112c336 | 131,800 |
def get_tarball_valid_unpack_directory_name(package_name: str, version_number: str) -> str:
"""
get the name of the folder that should be obtained by unpacking the tarball
:param package_name: name of the package to check
:param version_number: version number
:return: the name of the folder that is ... | 3f0cd6ae0e11f6022340a45e2981fc72247cc04d | 462,917 |
def presence_of_element_located(locator):
""" An expectation for checking that an element is present on the DOM
of a page. This does not necessarily mean that the element is visible.
locator - used to find the element
returns the WebElement once it is located
"""
def _predicate(driver):
... | bf69ed7e58e5e6dd0181bba3d965a301798c8f8a | 366,032 |
import torch
def rotate_vec_by_axisangle(vec, aa_vec):
"""
This function rotates a 3D vector @vec by the direction and angle represented by @aa_vec.
See https://stackoverflow.com/questions/32485772/how-do-axis-angle-rotation-vectors-work-and-how-do-they-compare-to-rotation-matr
for more information.
... | 8ab749d7c26a94dfd9c0da80334c69e0e46702a2 | 81,938 |
def clean_text(x):
"""Helper function to clean a string."""
x = str(x)
x = x.lower()
x = x.strip()
x = " ".join(x.split()) # removes extra whitespace between words
return x | 74dbb5e07c42c668cdbe380670e87e81f4678407 | 19,439 |
def read(fname):
"""Return contents of fname"""
txt = None
with open(fname) as ftoken:
txt = ftoken.read()
return txt | 0568810d0c330e5b279b55d2ad7be949a9039088 | 304,672 |
import logging
def make_splits(args, dataset):
"""
Make train-test splits in time.
"""
total_hours = len(dataset['counts'])
if args.truncate:
total_hours = min(total_hours, args.truncate)
# Dataset starts on a Saturday.
assert dataset['start_date'][0].strftime('%A') == 'Saturday'
... | ee0791b2ea96f6bd60a5b6a23c818073082584d3 | 313,225 |
from pathlib import Path
import click
def validate_json_yaml_filename(ctx, param, value):
"""Validate the name of the file has the proper extension and add the extension to the file object"""
if value is None:
return value
if not hasattr(value, "name") or value.name == "<stdout>":
# stdin... | 2adf1053cd1c4326f8ba2de137ca4f3c81a1c4a6 | 637,115 |
from functools import reduce
def mac_aton(s):
"""Convert a Mac address to an integer."""
try:
mac = list(map(lambda x: int(x, 16), s.split(':')))
mac = reduce(lambda a,b: a+b, [mac[i] << (5-i)*8 for i in range(6)])
except (ValueError, IndexError):
raise ValueError('illegal Mac: {0}... | dd29c6e99998bfd0676ae9e7200f02500c2eed0d | 43,575 |
def len2bytes(payload: bytes) -> bytes:
"""
Generate payload length as 2 bytes, suitable for
constructing RTCM message transport.
:param bytes payload: message payload (i.e. _without_ header, length or CRC)
:return: payload length as 2 bytes padded with leading zeros
:rtype: bytes
"""
... | f7c94acc0de60de1e569b1e2cd4c5d091bd139cc | 296,599 |
def get_source(driver) -> str:
"""Returns the source code of the webpage"""
return driver.page_source | c887ef249aa88dd3216406207f7463718b22c092 | 161,446 |
def get_avg(items):
"""return avg of list items"""
length = len(items)
if length > 0:
return sum(items) / length
return 0 | 3747668ebbb1b84ec2d61314eb411c4b8358dc8b | 493,652 |
def orientation(p, q, r):
"""
Finds the orientation of an ordered set of vertices(p, q, r).
p: First vertex represented as a tuple.
q: Second vertex represented as a tuple.
r: Third vertex represented as a tuple.
returns:
0 : Collinear points
1 : Clockwise points
2 : Counterclockw... | 3651c0b6eee3550c427ad03d229d947337e7eed1 | 17,670 |
def map_data(keys: list, values: list, types: list) -> dict:
"""
Returns a dict that maps keys to their values and types
"""
data: dict = {}
for i, value in enumerate(values):
key = keys[i]
key_type = types[i]
data[key] = {
"value": value,
"type": ke... | 32774b33ff8710c8ec185c137f1b6d5dd2e6a575 | 434,551 |
def find_biggest_value_per_day(day_data):
"""
Take pressure data per day and find
biggest value.
If some systolic and other systolic equal,
compare by diastolic
"""
values = [(data[2], data[3]) for data in day_data]
systolic, diastolic = max(values)
return systolic, diastolic | f46a866809278b95851c8583a1682de58749a64f | 48,384 |
def taxid(entry):
"""
Gets the NCBI taxon id as an integer.
"""
base, tid = entry["taxonId"].split(":", 1)
assert base == "NCBITaxon"
return int(tid) | 00fe879444e9587132cfe697a949c77b9002672d | 86,634 |
def _get_currency_pair(currency, native):
"""
Format a crypto currency with a native one for the Coinbase API.
"""
return '{}-{}'.format(currency, native) | 92c3f43d1661f912a6bb63d14df1a7095eb784f3 | 24,891 |
def convert_metadata_pre_1_0_to_1_0(metadata):
"""
Convert pre-1.0 to 1.0 metadata format
:arg metadata: The old metadata
:returns: The new metadata
Changes from pre-1.0 to 1.0:
* ``version`` field renamed to ``metadata_version``
* ``supported_by`` field value ``unmaintained`` has been rem... | 81c67795aa27ae47dbc07c95d685c187f66e9258 | 306,525 |
def is_extrusion_line(line: str) -> bool:
"""Check if current line is a standard printing segment.
Args:
line (str): Gcode line
Returns:
bool: True if the line is a standard printing segment
"""
return "G1" in line and " X" in line and "Y" in line and "E" in line | 364dd589673dc6dd500c02167169a5c1d0daf010 | 151,538 |
from datetime import datetime
def convert_date_to_fns_format(date_db: datetime) -> str:
"""Convert datetime from database to FNS format."""
return date_db.strftime('%Y-%m-%dT%H:%M') | 60445e51032efe4548b6cd59fe53baf6c53c6f1c | 72,139 |
import hashlib
def url_to_hashkey(url):
"""Generate a 96 bit hash key from a URL string.
Args:
url: A URL string.
Returns:
A 96 bit hash key.
"""
return hashlib.sha512(url.encode()).hexdigest()[0:24] | 394ffa42cb995c260f7e5c1d0036a52268e641a2 | 518,696 |
def get_instance(module, name, config, **kwargs):
"""
A reflection function to get backbone/classifier/.
Args:
module ([type]): Package Name.
name (str): Top level value in config dict. (backbone, classifier, etc.)
config (dict): The parsed config dict.
Returns:
Corres... | 244810ae862527ef323781cb4ac7de144b183256 | 526,717 |
def td2fusec(td):
"""Convert datetime.timedelta to float microseconds"""
sec = td.total_seconds() # float
usec = sec * 1000000
return usec | 4aac8e0df2286623a512bc3ee2b61bc7607471fe | 326,192 |
def is_hilbert_number(n):
"""
Simply check whether n is positive and the remainder of n is equal to 1
modulus 4.
"""
return n > 0 and n % 4 == 1 | b55825b446282343cb87e3d6c83036a6bc9f1a6a | 687,556 |
def int_equals(a, b):
"""Small helper function, takes two objects and returns True if they are equal when cast to int.
This is mainly intended to facilitate checking two strings that may or may not be ints.
Most importantly, it will return False if either cannot be cast to int."""
try:
return int(a) == int(b)
ex... | 7ac9eee9ffc3f3efd2848276d08f36364631d580 | 263,638 |
import quopri
def decode_email(email):
"""
Decode email using quoted printable
:param email: The email to decode
:return: The decoded email content
"""
return quopri.decodestring(email.get_payload()) | 87e0c8f294d15cbd479640a43fa6eaf7f3450be2 | 112,018 |
def _bisect_blocks(web3, timestamp, use_left_bound=True):
"""
Perform a binary search on the blockchain for the block that matches the
given timestamp. The `use_left_bound` parameter determines whether to
return the block to the left or right of the timestamp in the event that no
block matches the ... | 9eb011ca488b7262e78efd29fe11f3c0136a5933 | 21,809 |
def get_chunks(t_start, t_stop, n_chunks):
"""Group frame indices into given number of 'chunks'.
Args:
t_start (int): Frame index to start at (inclusive)
t_stop (int): Frame index to stop at (exclusive)
n_chunks (int): Number of chunks
Returns:
List of 2-tuples containing (... | b7477723cd35753699fce913f966618b882cdf21 | 662,686 |
def xor(n1, n2):
"""XORs two numbers"""
return (int(n1) + int(n2)) % 2 | 7ead2d86d1faeaf71a4cb2b8964c7fc5e3b5b7c0 | 435,897 |
def clean_dict(dictionary: dict) -> dict:
"""Recursively removes `None` values from `dictionary`
Args:
dictionary (dict): subject dictionary
Returns:
dict: dictionary without None values
"""
for key, value in list(dictionary.items()):
if isinstance(value, dict):
... | 3968b6d354116cca299a01bf2c61d7b2d9610da9 | 703,773 |
def width_from_bitdefs(bitdefs):
"""
Determine how wide an binary value needs to be based on bitdefs used
to define it.
Args:
bitdefs (list(BitDef)): List of bitdefs to find max width of
Returns:
(int): Maximum width
"""
max_index = max([bitdef.end for bitdef in bitdefs])
... | 59503f335d6d427579be730806c738108091e9ed | 703,034 |
from pathlib import Path
def norm_abs_path(path, ref_path):
"""\
Convert `path` to absolute assuming it's relative to ref_path (file or dir).
"""
path, ref_path = Path(path), Path(ref_path).absolute()
ref_dir = ref_path if ref_path.is_dir() else ref_path.parent
return ref_dir / path | 91033a7cb3631616799c204259b5830c931035f0 | 683,288 |
def lower_first_letter(sentence):
"""Lowercase the first letter of a sentence."""
return sentence[:1].lower() + sentence[1:] if sentence else "" | de0f79548d42983093f65970464ca84eed032300 | 696,468 |
def _FollowedByFakeQuant(tensor):
"""Returns True if the tensor is followed by a FakeQuant."""
fake_quant_ops = set([
'FakeQuantWithMinMaxVars', 'FakeQuantWithMinMaxArgs',
'FakeQuantWithMinMaxVarsPerChannel'
])
pass_through_ops = set(['Reshape', 'Identity'])
consumers = tensor.consumers()
while ... | 3d3f3a189f04089e89a7d082ac388f6e1aee90ec | 188,613 |
def makeMapping(classes):
"""
Create a mapping between class name and actual classes.
"""
return {
cls.__name__: cls for cls in classes
} | dbe43c6e13aa502b4414934e773adfa355a38d24 | 354,797 |
def _transform(persistence_diagram):
"""Transform persistence diagram for persistence image calculation."""
persistence_diagram[:, 1] -= persistence_diagram[:, 0]
return persistence_diagram | 23c0e46fe3258345ddcaecb2d74fbb6218d48f33 | 534,280 |
def lucas(n):
"""Function that provides the nth term of lucas series."""
x, y = 2, 1
for i in range(n - 1):
x, y = y, x + y
return x | 6d40e67ce8dd682bb26f9bd16d2dd34d3d1bf541 | 30,381 |
def cmake_cache_option(name, boolean_value, comment=""):
"""Generate a string for a cmake configuration option"""
value = "ON" if boolean_value else "OFF"
return 'set(%s %s CACHE BOOL "%s")\n\n' % (name, value, comment) | b00e202d499b3faa9bc1623994f733456c542b40 | 594,528 |
def chunks(l: list, n: int):
"""
Split a list into evenly sized chunks
:param l: list
:param n: chunks
:return: list of lists
"""
return [l[i:i + n] for i in range(0, len(l), n)] | 0c1dd0fbb7461df98eff59b9cf9f74a2efdedbd4 | 530,318 |
from datetime import datetime
import pytz
def now_in_timezone(tz):
"""
tz should be tzdata identifier, e.g. America/New_York
"""
return datetime.now(pytz.timezone(tz)) | a25c2b8a10e56204e0e2129bf180afc261db0c9c | 606,669 |
import torch
def create_optimizer(optimizer_name, model, **kwargs):
"""
Create a torch optimizer of the specified type for the given model.
Args:
optimizer_name: The type of optimizer to create (as string), one of: 'SGD', 'NAG', 'Adam', 'RMSprop'.
model: The model to train with the optimi... | f239b1b878c0158b1cc289a116cd54ab86fcbdd0 | 245,642 |
def convert_to_x_y(texts, targets):
"""
Converts data into form x,y
Args:
texts (list): List of texts
targets (list): List of targets
Returns:
list: A tuple of form (x,y)
"""
data = [(texts[idx], targets[idx]) for idx in range(len(targets))]
return data | c195b84aa7e62717d3fe32b88c193fcd7ce7b889 | 477,818 |
def _set_group(tree, group):
"""Set the group for a tree of dependencies."""
grouped = {
"dependency": tree["dependency"],
"level": tree["level"],
"version": tree["version"],
"group": group,
"children": [],
}
if tree["children"]:
for child in tree["childr... | a0e10f3b26938637d281ca5e82f6da215fb4a7d5 | 565,201 |
import re
def getKeepAlive(response):
"""Extracts and returns the keep alive token from the response.
Extracts and returns the actual keep-alive token from within the response;
this token enables subsequent requests for CSV data.
Args:
response: The Python requests response object, typically correspon... | 0486def47c3b460cc775adba7772ee0ba264295d | 621,793 |
def column_choices_hidden(fields_selected):
"""Include column choices in request query as hidden fields"""
hidden = ''
for f in fields_selected:
hidden += "<input type='hidden' name='" + f + "' value='t'/>"
return hidden | cf80e6cceacc908b14d6b9ff86b9488a518505b8 | 336,951 |
def class_counts(rows, labels):
"""
Counts the number of each type of example in a dataset.
:param rows: array of samples
:param labels: rows data labels.
:return: a dictionary of label -> count.
"""
counts = {cls: 0 for cls in set(labels)} # a dictionary of label -> count.
for idx, x i... | 3e5b4c32885ce6ccdad8a842a2267e9d9dca62b2 | 132,866 |
import re
def format_email(address):
"""
Returns a correctly formatted and de-obfuscated email address
"""
address = re.sub(r"\s*", "", address)
address = re.sub(r"\(.t\)", "@", address)
address = re.sub(r"\(punkt\)", ".", address)
address = re.sub(r"\((strich|minus)\)", "-", address)
... | 49e1cdb843ce462a3444610a22d0faec9b215f5f | 347,325 |
def example_choices(field, arg=3):
"""
Returns a number (default: 3) of example choices for a ChoiceFiled (useful for CSV import forms).
"""
examples = []
if hasattr(field, 'queryset'):
choices = [(obj.pk, getattr(obj, field.to_field_name)) for obj in field.queryset[:arg + 1]]
else:
... | 5206254abc339b8941596ccb29538cd4fcc1e8a1 | 626,824 |
def readText(text_file)->str:
"""Read a text from a file."""
text = ""
with open(text_file,'r',encoding='utf8') as rtextFile:
text = rtextFile.read()
text = (text.replace("\n","").replace("\r", ""))
return text | e457638df4f47406abaaaa0682d0c0b8e1375a8d | 256,048 |
def find_smaller_streets(playable_items):
"""
Gets list of playable moves from find_streets and adds smaller possible streets to that list
For (3,4,5,6,7) this will add (3,4,5,6), (3,4,5), (4,5,6). The rest is already covered
:param playable_items: Possible moves, the user can do
:return: list of po... | 9860b87fcab0255fb93e9aad3f7a8b57ba658a8e | 177,224 |
def num_round(num, decimal=2):
"""Rounds a number to a specified number of decimal places.
Args:
num (float): The number to round.
decimal (int, optional): The number of decimal places to round. Defaults to 2.
Returns:
float: The number with the specified decimal places rounded.
... | a4ee87fa8724690aea611b2d95f884dd072e6511 | 195,819 |
def gq_get_vertex_user(user):
"""Create the gremlin query that returns a Vertex for a user given
its uuid
"""
query = "g.V().hasLabel('user').has('uuid', '{}')".format(user.uuid)
return query | 52509c27280a3e0fd4eb57b44fe5fbec8c0c3b20 | 685,483 |
def _loggables(self):
"""dict[str, str]: Return a name, category mapping of loggable quantities."""
return {name: quantity.category.name
for name, quantity in self._export_dict.items()} | e21e8295fce65ef4822854c2a2ece54bf6a1283b | 216,682 |
def split_user(user_at_host):
"""
break apart user@host fields into user and host.
"""
try:
user, host = user_at_host.rsplit('@', 1)
except ValueError:
user, host = None, user_at_host
assert user != '', \
"Bad input to split_user: {user_at_host!r}".format(user_at_host=use... | 16383930a7940236a3796151ffc37bd6485ab98a | 155,489 |
def isoforest_label_adjust(pred_func):
"""Adjusts isolation forest predictions to be 1 for outliers, 0 for inliers.
By default the scikit-learn isolation forest returns -1 for outliers and 1
for inliers, so this method is used to wrap fit_predict or predict methods
and return 0 for inliers, 1 for outli... | 11ac61f691404525a357a32e725c30dd2675a85a | 36,415 |
import string
import random
def strings(n, chars=string.ascii_letters):
""" Return random string of N characters, sampled at random from `chars`.
"""
return ''.join([random.choice(chars) for i in range(n)]) | bc7e2cab22b4d0a98b3e93a7199c1ec2b326ee68 | 23,043 |
def exclusive_in(in_list,master_list):
"""
Checks if every element in in_list is in masterlist
:in_list: (list of any type of object) elements
:master_list: (list of any type of object) elements
:returns: (bool) True if every element in in_list is in master_list and
False otherwise
"""
if in_list==[]:
re... | 799ca2314eac76afbadf33b4981d49b9872ec23c | 502,748 |
import re
def make_container_name(image: str, suffix: str = "") -> str:
"""
Make default container name for the given Docker image.
Args:
image: Docker image tag.
suffix: Suffix to append to the container name.
Returns:
Docker container name.
"""
name = re.sub(r"[^a-z... | 570e3f89a5c76b9b4383e19d462ec1ee04b5118c | 616,995 |
def create_new_column_with_difference_between_2(df, column1, column2):
"""
Return df with new delta column: column1 - column2
Parameters
----------
df: Pandas dataframe
column1: Column string
column2: Column string
Returns
-------
Df with added delta column
"""
df['de... | 4e4fe4637b378779534fb88387eb404edf0ac57e | 378,632 |
def get_natural_num(msg):
"""
Get a valid natural number from the user!
:param msg: message asking for a natural number
:return: a positive integer converted from the user enter.
"""
valid_enter = False
while not valid_enter:
given_number = input(msg).strip()
i... | 77bed94bf6d3e5ceb56d58eaf37e3e687e3c94ba | 381 |
def _parse_options_list(options):
"""
Args:
options: list of the BeautifulSoup objects
Returns:
list[dict]: list of parsed info about faculties
"""
faculties_list = []
for option in options:
faculties_list.append({
'name': option.text,
'code': int... | 19fbe248422728ace7133d23104025ddf1a90f96 | 599,845 |
def bold(s):
"""Returns the string s, bolded."""
return f'\x02{s}\x02' | a471ae9de5e222a07eeb3e2eb8e2a840820472a9 | 610,932 |
import re
def ProcessGitHubLinks(markup, github):
"""Replaces the GitHub local links by the external variants."""
markup = re.sub(
r'#(\d+)',
r'[#\1](https://github.com/%s/issues/\1)' % github,
markup)
markup = re.sub(
r'\[(.+?)\]\((wiki/.+?)\)',
r'[\1](https://github.com/%s/\2)' %... | 88284abc8fc76f4b24dd1d5040b0156e4eef0cf7 | 669,142 |
def clear_sentences(data):
"""
Cleaning sentences, removing special characters and articles
"""
sentences = list()
for record in data:
sentence = record['reviewText']
sentence = sentence.lower()
for char in "?.!/;:,":
sentence = sentence.replace(char, '')
... | 91afa65c70be9386a658d0c74f317f647110740b | 660,997 |
def _hamming_distance(x_param: int) -> int:
"""
Calculate the bit-wise Hamming distance of :code:`x_param` from 0.
The Hamming distance is the number 1s in the integer :code:`x_param`.
:param x_param: A non-negative integer.
:return: The hamming distance of :code:`x_param` from 0.
"""
tot ... | 9508826097c0a08b98d15363505d32ee0b6cc08b | 283,008 |
def get_shorter_move(move, size):
"""
Given one dimension move (x or y), return the shorter move comparing with opposite move.
The Board is actually round, ship can move to destination by any direction.
Example: Given board size = 5, move = 3, opposite_move = -2, return -2 since abs(-2) < abs(3).
""... | 635ee3038a4b78318658288f7876144f82333ebb | 38,568 |
def changelog2dict(changelog):
"""
Helper turning internal list-o-releases structure into a dict.
See `parse_changelog` docstring for return value details.
"""
return {r["obj"].number: r["entries"] for r in changelog} | 31bc860dc5e670d096b3895da99a9ab19be46af9 | 590,211 |
def a_return_and_reconnect(ctx):
"""Send new line and reconnect."""
ctx.ctrl.send("\r")
ctx.ctrl.connect(ctx.device)
return True | c861146efc2b2bfca01842489c0cb5e22adbfaa0 | 464,889 |
from datetime import datetime
def process_env_date(env_date) -> datetime:
"""Return the specified date. If the input is 'current', return the current date time.
Argument:
env_date - a string obtained from the ENV_DATE environmental variable. It should
contain the reporting dte.
"""
... | e1dc7626e9a0084bceaf1fe0e58fba79ac286d9a | 173,742 |
def remove_all(fs, path):
"""Remove everything in a directory. Returns True if successful.
:param fs: A filesystem
:param path: Path to a directory
"""
sub_fs = fs.opendir(path)
for sub_path in sub_fs.listdir():
if sub_fs.isdir(sub_path):
sub_fs.removedir(sub_path, force=Tr... | 6b5a5866eca0548ba61ef3787a61042de587b1f9 | 276,113 |
def removesuffix(string: str, suffix: str) -> str:
"""Remove suffix from string, if present."""
return string[: -len(suffix)] if suffix and string.endswith(suffix) else string | 3c375c633dc7e73fed5898a0886da9f9b545c045 | 407,444 |
def lint_codeblock(styleguide, tmp_path):
"""Fixture which runs the styleguide's `lint` subcommand when executed."""
def run_linter(
codeblock,
*styleguide_args,
# We ignore unused import warnings as most of the codeblocks which produce this warning
# are just demonstrations of ... | 67ad6ed2184c9d30de9d60491463c7ac18fe5690 | 633,983 |
def readMetadata(lines):
"""
Read metadata tags and values from a TNTP file, returning a dictionary whose
keys are the tags (strings between the <> characters) and corresponding values.
The last metadata line (reading <END OF METADATA>) is stored with a value giving
the line number this tag was found in.... | e4a93539ccb203b350d17c33fd0daa4cb9afbac9 | 674,327 |
def round_described(described, decimals):
""" For printing purposes the results should be rounded.
This is done with this function and the desired number of
decimals are passed per parameter as an argument.
Parameters
----------
described : DataFrame
The DataFrame you want to print
... | 87db2a4c29514af423686e1f3acf24ab14eb95ef | 603,999 |
def recur_dictify(frame):
"""
h/t: http://stackoverflow.com/a/19900276/843419
:param frame: a pandas data frame
:return: a nested dictionary with the columns as the keys and the final one
as the value. Best if the keys are arranged and sorted and there are no
duplicates.
"""
if len(frame... | ebbfa7ff5ccd578481a8466e8e6dd56b0baa93ba | 555,473 |
def build_trials_response(trials: list):
"""
Build the response representing a list of trials according to the API specification.
Parameters
----------
trials: list
A list of :class:`orion.core.worker.trial.Trial`.
Returns
-------
A JSON-serializable list of trials as defined i... | 2857a9b410f662d1d79ab25ce5dda007ea1e6c8a | 467,895 |
import html
def _unescape(text: str) -> str:
"""Unescape Html Script."""
if text and isinstance(text, str):
return html.unescape(text)
return text | 1d833c11d64052cf2c2b5dec33c35d47d904c73e | 244,514 |
def random_walk(game):
"""
Solves MasterMind by throwing out random codes.
On average takes about 5 time n guesses, where n
is the number of possible solutions of the Mastermind Game.
For 6\ :sup:`4`, this means about 6000 guesses.
Returns the solution translated back into t... | e108c821abf6ba54400c5170d006bd2948d5f7cd | 590,624 |
def find_publications_with_tmt(data):
"""
This function looks for publications with text mined terms.
It returns a list of tuples with the publication ID as the first value and the publication source as the second value.
"""
page = []
for publication in data['resultList']['result']:
if ... | 2fca61abc755651eda99039187c6c0a16b7ab981 | 604,599 |
def z(j, k):
"""Calculates equivalence scale. z(2,1) is the equivalence scale for a household with two adults and one child
Parameters
----------
j : float
the number of adults in the household.
k : float
the number of children (under 18 years old).
Returns
-------
type... | 23aa9b21d04e0f3a9f7e2494aa7c9187d80c3944 | 470,292 |
def run_unhovered(var):
"""
Calls the unhovered method on the variable, if it exists.
"""
if var is None:
return None
if isinstance(var, (list, tuple)):
for i in var:
run_unhovered(i)
return
f = getattr(var, "unhovered", None)
if f is not None:
... | d5bf9a1bc1cf25b5bf6ad606a71540f6e3864070 | 506,091 |
import pathlib
from typing import List
def parse_go_prot_map(go_prot_map_file: pathlib.Path) -> List[str]:
"""
Parses the go_prot_map file
Returns the list of uniprot protein ids associated with the GO term
Parameters
----------
go_prot_map_file : pathlib.Path
... | 0818dfc47d15d4247e1c47b44c46ecb7f042a395 | 303,895 |
def get_compiler_version(ctx):
"""Get the compiler version.
Args:
ctx: Rule context.
Returns:
String: Version string.
"""
return ctx.toolchains["@io_tweag_rules_haskell//haskell:toolchain"].version | 087b0740545e3c6e862122aaa125387ca6c598f1 | 568,200 |
def get_overtime(row):
"""
Whether or not the game was decided in overtime
"""
return ('OT' in row['Home Score']) or ('OT' in row['Away Score']) | c85592541c36f7db557d957b7c7babfd7666e01f | 59,139 |
from typing import Any
def call_if_func(f: Any, **kwargs) -> Any:
"""Calls function if it's a function
Useful to create objects from functions
if it's an object it just returns the object
"""
return f(**kwargs) if callable(f) else f | 0926c472b8b476c7a60d23e13dc87033fb7c2c17 | 546,734 |
def cleanup_test_name(name, strip_tags=True, strip_scenarios=False):
"""Clean up the test name for display.
By default we strip out the tags in the test because they don't help us
in identifying the test that is run to it's result.
Make it possible to strip out the testscenarios information (not to
... | 46427eeac8855fe8e77e8d2f77c32ccedc51283c | 579,188 |
def fix_indentation(text):
"""Replace tabs by spaces"""
return text.replace('\t', ' '*4) | 45012dd80215a54d7ed62923e1ab89e530fdd803 | 365,725 |
def column_not_auto_integer_pk(column):
"""
A check for whether a column is an auto incrementing integer used for a primary key.
"""
return not (
column.autoincrement == "auto"
and column.primary_key
and column.type.python_type is int
) | bc0b8dc7dafdc933fd08ea9a40ffbc0e6ce6f11c | 141,268 |
def date2str(dt, format_str=None):
"""
Convert list of datetime objects to legible strings
Parameters
----------
dt : datetime.datetime
Single or list of datetime object(s)
format_str : string
Timestamp string formatting, default: '%Y-%m-%d %H:%M:%S.%f'.
See datetime.st... | aee6ed28d3a23c02ae05885543170de0854a7e4a | 64,572 |
import json
def load(config_path: str):
"""
Loads in json data and returns to user, assuming it has already been validated.
:param config_path: the string path to load up
:return: json data (usually dict or list)
"""
with open(config_path, "r") as handle:
# print('load "{}" --> key "{}... | 786afa8a3ed1d83ee0ea95790211e9ad67fb0c28 | 557,371 |
import math
def degrees_to_radians(deg):
"""Converts degrees to radians.
Args:
deg: degrees
Returns:
radians
"""
return deg * math.pi / 180 | df10298108e85dd92d962351ad0d763821626759 | 60,198 |
import random
def class_colors(names):
"""
Create a dict with one random BGR color for each
class name
"""
return {name: (
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255)) for name in names} | a91f84aa1e3012fc553744e941abd5e9aeca9074 | 650,121 |
import csv
def read_raw_data(filename):
"""
Reads raw data from filename and returns it as
list of lists.
filename:
File to read from.
returns:
list of lists of data, where each sub list is
is a row, and each sub list item is a row value
"""
with open(filename, '... | 6a0b335333617156b4bb5c686b7f5d133cb96b67 | 183,199 |
def rare_species(df, frequency_threshold=10, target_column='species_id', filter_out=True):
"""Operation to filter rare species, i.e species with a frequency that is below a threshold."""
target_serie = df[target_column]
# get frequency of specie for every occurrence
counts = target_serie.map(target_seri... | bc0ab2025dd82cf2d1ca7d5e963caac37b24e4e0 | 292,790 |
def currency(amount):
"""
Returns the dollar amount in US currency format.
"""
if amount >= 0:
return '${:,.2f}'.format(amount)
else:
return '-${:,.2f}'.format(-amount) | 95fc422eca552a59aa144406d4b7c32cff4a8cff | 403,475 |
def parse_readelf_line(x):
"""Return the version from a readelf line that looks like:
0x00ec: Rev: 1 Flags: none Index: 8 Cnt: 2 Name: GLIBCXX_3.4.6
"""
return x.split(':')[-1].split('_')[-1].strip() | b92b473fd6d0591312c9a163aee94b55706df8c8 | 121,824 |
def format_messages(messages_dict):
""" Formats input messages in Polymer format to native Android format. This means replacing
hyphens with underscores in keys and escaping apostrophes in values. """
formatted_messages = {}
for k,v in messages_dict.items():
formatted_messages[k.replace("-", "_")] = v.r... | 00fe6bfb76ce8e146a16a3bc3f108fc2d1277908 | 34,372 |
def get_field(field_name, shapefile, case_sensitive = True):
"""Return the field in shapefile that corresponds to field_name,
None otherwise.
Inputs:
- field_name: string to look for.
- shapefile: where to look for the field.
- case_sensitive: indicates whether t... | 93af96efe4cee128d0b1e47fc0481a4c9f1240fa | 502,181 |
def _md_fix(text):
"""
sanitize text data that is to be displayed in a markdown code block
"""
return text.replace("```", "``[`][markdown parse fix]") | 2afcad61f4b29ae14c66e04c39413a9a94ae30f8 | 705,343 |
import re
def deal_with_punctuation(text: str = '',
punctuation_to_collapse_by: str = '',
punctuation_to_explode_by: str = '') -> str:
"""
Removes punctuation from a string
:param text: original text
:param punctuation_to_collapse_by: punctuation mar... | 99b9c8c7de680f35aa806f873c179bb11a676237 | 473,860 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.