content stringlengths 39 14.9k | sha1 stringlengths 40 40 | id int64 0 710k |
|---|---|---|
def dict_subtract(d1, d2):
"""Subtract one dictionary from another.
Args:
d1 (dict): First dictionary.
d2 (dict): Second dictionary.
Returns:
dict: `d1 - d2`.
"""
if set(d1.keys()) != set(d2.keys()):
raise ValueError("Dictionaries have different keys.")
return {... | a8098f66ce1ca85803c90d9cfc058ae96b3f8123 | 28,369 |
import re
def clean_name(name: str) -> str:
"""
Bring the name into a standard format by replacing multiple spaces and characters
specific for German language
"""
result = re.sub(r"\s+", " ", name)
return (
result.replace("ß", "ss")
.lower()
.replace("ä", "ae")
... | 8cb8ba45fcec1dcc0e04ccfcd4263ae3e82e9fb5 | 28,370 |
import json
def json_from_file(file_path):
"""
Read a file and convert it into a json object
:param file_path: path of file
:return: A json object
"""
file = open(file_path, "r")
return json.loads(file.read()) | 3342c083e64254a271b31b1c7a6747ac448f4078 | 28,381 |
import torch
def batch_audio(audios, max_frames=2048):
"""Merge audio captions. Truncate to max_frames. Pad with 0s."""
mfcc_lengths = [len(cap[:max_frames, :]) for cap in audios]
mfcc = torch.zeros(len(audios), max(mfcc_lengths), audios[0].size(1))
for i, cap in enumerate(audios):
end = mfcc_... | 79ea2a9e8459dda945f00e4f9a4edb22a445da93 | 28,382 |
def get(node, name):
"""
Given a KML Document Object Model (DOM) node, return a list of its sub-nodes that have the given tag name.
"""
return node.getElementsByTagName(name) | 84c48b9e1ec1e71ee615357a10586950f995c991 | 28,384 |
def int_to_bitstring(x: int) -> str:
""" Function to convert an integer to AT LEAST a 32-bit binary string.
For integer less than 32 bits, it will pad the integer with extra bits of 0s until it is of size 32bit.
If the integer is greater than 32-bits, then return the binary representation with the minimum ... | 34c022eedf5d73d68cac56f296bd53cc62b2be24 | 28,394 |
def get_best_hits(matches, evalue_cutoff):
"""
get the best hit: one with smallest evalue and highest score.
if at least two hits have same evalue and score, report them all
"""
best_hits = []
evalue_sorted = sorted(matches, key=lambda x: x[2])
best_evalue = evalue_sorted[0][2]
if be... | 9bf21eecc896d29fb888ec772fc7dbab8a6913cc | 28,396 |
import re
def find_coords_string(file_path):
"""
Parse a file path using a regular expresion to find a substring
that looks like a set of coordinates,
and return that.
"""
match = re.search(
"([-]?[\d]{1,3}\.[\d]{1,3}[_,][-]?[\d]{1,3}\.[\d]{1,3})", file_path
)
if not match:
... | 2d6fd569122222d3600aea5500bd515dea8b8596 | 28,397 |
import requests
def load_inspect_api(url):
""" Load inspect API and return Json response """
r = requests.get(url)
if r.status_code != 200:
raise RuntimeError(
'Failed to read inspect API. Error %d.' % (r.status_code))
return r.json() | 6a3a722a6a5e9752fd3f9ef5806cca3209392bbe | 28,398 |
def can_edit_address(user, address):
"""Determine whether the user can edit the given address.
This method assumes that an address can be edited by:
- users with proper permission (staff)
- customers who "own" the given address.
"""
has_perm = user.has_perm("account.manage_users")
belongs_t... | 724be0e3023a4776604f869b506a35f216c3461e | 28,399 |
def parse_input(inp, options):
"""Parses user-provided input
Check if the given input can be seen as an index of the options list.
Parameters
----------
inp : str
User input
options : list
List of option strings
Returns
----------
parsed_choice
... | fcb63ce473d08363373af3488b87b49a19c782e0 | 28,401 |
def filename_segment(value):
"""Check that the string is valid for use as part of a filename."""
for character in value:
if not character.isalnum() and character not in '-_. ':
raise ValueError(f"invalid value: '{value}'")
return value | 44f9e0b26501accf7facb0c766938865648a5121 | 28,404 |
def _early_stop(args, eval_history):
"""
Determines early stopping conditions. If the evaluation loss has
not improved after `args.early_stop` epoch(s), then training
is ended prematurely.
Args:
args: `argparse` object.
eval_history: List of booleans that indicate whether an epoch ... | 5e8d698703750a2f4be2564b4905c5e7d42815ed | 28,409 |
def _line_to_array(agile_line):
"""convert the weird AGILEPack weights output to an array of floats"""
entries = agile_line.split(',')[1:]
return [float(x) for x in entries] | 0693a75ecce5dc105aedf9fa44d16e1e6959befa | 28,412 |
def is_dialog_complete(handler_input):
"""
Checks whether the dialog is complete according to the dialog model
:param handler_input: (HandlerInput)
:return: (boolean)
"""
if not hasattr(handler_input.get_request(), "dialogState"):
return False
return handler_input.get_request().di... | c9137b497bf472e88f05f8395166db5b18fe5f51 | 28,429 |
def log_call(call_next, *args, **kwargs):
"""Decorator to log the call signature"""
arg_items = [str(a) for a in args] + [
f"{k}={v}" for k,v in kwargs.items()
]
arg_string = ",".join(arg_items)
print(f"Calling {call_next}({arg_string})")
return call_next(*args, **kwargs) | 4c6becf8731944b2c2e80c51a16fe62034d81102 | 28,435 |
def tags_to_text(tags):
"""Return a text of sorted tags"""
str_tags = [str(t) for t in tags]
sorted_tags = sorted(str_tags)
return '\n'.join(sorted_tags) | a4bf2111517e3b8f616e84490bd37e9f197c698a | 28,436 |
def protocol_stage_settings(settings):
""""Load settings for each milling stage, overwriting default values.
Parameters
----------
settings : Dictionary of user input argument settings.
Returns
-------
protocol_stages
List containing a dictionary of settings for each protocol stag... | fd2b65ffcf71ea674e32eb80a69faec27ff9b66d | 28,441 |
def evaluate(env, policy, num_episodes = 10):
"""Evaluates the policy.
Args:
env: Environment to evaluate the policy on.
policy: Policy to evaluate.
num_episodes: A number of episodes to average the policy on.
Returns:
Averaged reward and a total number of steps.
"""
total_timesteps = 0
to... | 8ebac5d9862662b45395c8cbdacace2cb4058b47 | 28,444 |
import shlex
def _join(split_command: list[str]) -> str:
"""Concatenate the tokens of the list split_command and return a string."""
return " ".join(shlex.quote(arg) for arg in split_command) | 127cd1a7366c843c328b1e29632811e964de0542 | 28,445 |
from pathlib import Path
def check_file_exists(sub_dir: Path, file: Path):
"""Check if the supplied `file` arg exists.
Args:
sub_dir (Path): the fully qualified subdirectory
file (Path): the file to check
Returns:
Path: if valid, the file
Raises:
Exception: if save f... | e421dc28adb49291fc4740c5163604e772d6aa2e | 28,447 |
def uploaded_file_extension(filename: str) -> str:
"""
Returns the extension from a file name
:param filename: Name of the file with its extension
:type filename: str
:return: The extension of the file
:rtype: str
"""
extension = filename.rsplit('.', 1)[1].lower()
return "%s%s" % (... | 03d62a28997d535427fded44d0df1ffc8a646f6f | 28,449 |
def load_fragment(soup, fragment, cache):
"""
Load and cache a BNC fragment, given the id `fragment`.
"""
if fragment in cache:
return cache[fragment]
fragment_xml = soup.find('text', {'xml:id': fragment})
cache[fragment] = fragment_xml
return fragment_xml | 56333e7736d501f0cef66f1b956cefd1d8c3071b | 28,453 |
def may_change_leading_case(text):
"""
Checks whether the string `text` can
change the letter case of its leading letter.
"""
for c in text:
if c.isalpha():
return True
if c.isspace():
continue
return False
return False | ba3b30c4e5a65104671f25970a65b93e6d4d7dcf | 28,454 |
def sinum_frmt(x):
"""
Generate SIunitx style formatted number output for plotting tables to TeX.
This function can be used as a formatter for printing DataFrames to Latex
tabes when using the Latex package SIunitx.
Parameters
----------
x : int, float
Value to format.
Returns... | 3ed5311d242b99c946e1ea1d514187a5823b2be0 | 28,457 |
def vprint(verbose: bool):
"""
Utility function for optional printing.
Parameters
----------
verbose: bool
If True, returns print function, else False
Returns
-------
callable
"""
return print if verbose else lambda *a, **k: None | 5295914f2fc9b8aaa146b74c8b5ff3ec7b501cab | 28,458 |
import json
def get_top_python_packages(top_n=100):
"""
Generate list of most downloaded python packages
Args:
top_n: the number of most downloaded packages to return
Returns:
(list) Names of most downloaded packages
"""
# JSON file containing top 4000 packages
# found he... | d19136a5ee21fe65c33ef4a5336f46863bf2c6b0 | 28,459 |
def get_arrhythmia_type(fields):
"""Returns type of arrhythmia based on fields of the sample
Arguments
---------
fields: fields of sample read from wfdb.rdsamp
Returns
-------
Type of arrhythmia
'a': asystole
'b': bradycardia
't': tachycardia
'f': ventricula... | 4772acc3612492a4f41acac0619435774f11cdff | 28,463 |
def chain_3(d3f_dg3, dg_dx, d2f_dg2, d2g_dx2, df_dg, d3g_dx3):
"""
Generic chaining function for third derivative
.. math::
\\frac{d^{3}(f . g)}{dx^{3}} = \\frac{d^{3}f}{dg^{3}}(\\frac{dg}{dx})^{3} + 3\\frac{d^{2}f}{dg^{2}}\\frac{dg}{dx}\\frac{d^{2}g}{dx^{2}} + \\frac{df}{dg}\\frac{d^{3}g}{dx^{3}}
... | 90c7563821a30fe0ff0b7e2431122d4754d52210 | 28,464 |
import warnings
def ditto(request):
"""
Deprecated.
"""
warnings.warn("The ditto context_processor is no longer used.", DeprecationWarning)
return {} | 7250488bf5d94aa14dec7ba64974642542149e59 | 28,469 |
def createProperMovieDictionary(raw_dict):
"""
Takes the dictionary provided by the request (full of strings)
and formats it where some variables need to have other types (e.g int, float)
also escapes all the single quotes characters in strings
:param raw_dict: the raw dictionary with the movie inf... | ac30cbff86bfd9659c9363d31acacbd3c76b6f0f | 28,472 |
def get_phred_query(sample_id, gt_ll, genotype, prefix=" and ", invert=False):
"""Default is to test < where a low value phred-scale is high
confidence for that genotype
>>> get_phred_query(2, 22, "het")
' and gt_phred_ll_het[1] < 22'
>>> get_phred_query(2, 22, "het", prefix="")
'gt_phred_ll_he... | 3b913725bafec554c105173fb4ff720324aa8ae7 | 28,475 |
def _command_to_string(cmd):
"""Convert a list with command raw bytes to string."""
return ' '.join(cmd) | e8c39aa287f64099358e420b63b507f6f3f68c7a | 28,477 |
def get_racecar_camera_topics(racecar_name):
""" The camera topics where the racecar publishes the frames
Arguments:
racecar_name (str): The name of the racecar
"""
return [
"/{}/main_camera/zed/rgb/image_rect_color".format(racecar_name),
"/sub_camera/zed/rgb/image_rect_color"
... | 7d535d2e6f9e9d056dec8604dc856901b30b2c20 | 28,478 |
from pathlib import Path
def find_modules(x):
"""Get all python files given a path
Args:
x (string): file path
Returns:
(list): recursive list of python files including sub-directories
"""
return Path(x).rglob('*.py') | 1b8b84087c3de476c8e2b96b8f09001755ebabac | 28,488 |
def medium_file(file_path):
"""Open a medium file (headerless tsv, 2 columns (str, float))
Return a generator of (str, float) tuples
This function is used by argparse for type validation."""
def row_generator(file_path):
with open(file_path, "r") as fh:
for line in fh:
... | eba4c372a1c07feab28634d65dcbd148f9dfa995 | 28,489 |
def score(board):
"""
This function takes a nested list of numbers representing a Reversi
board and returns the score of player 1 and 2 out of that board.
:param board: nested list of integers that represent a Reversi board
:returns: a tuple (s1, s2) representing the points of player 1 ... | e8545cd43924849aae39c355eecf23607311593d | 28,491 |
def rules_cidrs_and_security_groups(rules):
"""
Return a dict with keys "cidrs" and "sgids"
from a list of security group rules.
:param rules: list of security group rules
:type rules: list
:return: Dict with keys "cidrs" and "sgids"
:rtype: dict
"""
cidrs = set(
ip_range["... | 7da621f59543ae929856c78c69d101b234c4540c | 28,493 |
def dimer_true(dataframe, col_num, dimer_list):
"""
Boolean masks to let us know which primers from original df
form dimers. If so they are dropped.
Args:
dataframe (pd.DataFrame): the primer dataframe
col_num (int): the column number to check for primer match
dimer_list (list): ... | 138bcbaf01ed93bfb195e89900b37ab682bd6dea | 28,496 |
def child_dir_name(parent, child):
"""return the child directory name truncated under the parent"""
if parent == '' or child == '': return child
plen = len(parent)
clen = len(child)
if child[0:plen] != parent: return child # not a proper child
# return everything after separator
if clen < ple... | 85b003ee346580dda2647a64b31a93f7ada25d25 | 28,497 |
from typing import Dict
from typing import Any
from typing import Union
def get_cluster_mode(
cycle_config: Dict[str, Any],
) -> Union[None, str]:
"""
Decode the cluster mode from the cycle configuration. Currently only a
`slurm`, `local`, or None mode are available.
Parameters
----------... | 6ac157e812dfbe3627d1f3bf363b774f083801f8 | 28,499 |
def _select_last_iteration_only(jobs):
"""
Looks through a list of jobs and removes duplicates (only keeps last iteration of a particular job)
"""
jobs_by_name = {}
for job in jobs:
if job.name in jobs_by_name:
jobs_by_name[job.name].append(job)
else:
jobs... | cd00f51ec3be8349538daf7470552b735eda2902 | 28,501 |
def extract_hashtags(hashtags_string):
"""
Split the string of hashtags into a list of hashtags
:param hashtags_string: hashtags as a single string
:return: list of hashtags
"""
hashtags = hashtags_string.split()
return hashtags | 9ead711230f55b8a2ba3ab29a3c3c09ffb86184c | 28,507 |
def sampleFunction2(x2: int, y2: float) -> float:
"""
Multiply int and float sample.
:param x2: x value
:type x2: int
:param y2: y value
:type y2: float
:return: result
:return type: float
"""
return x2 * y2 | 554707befa81313f7ca084afbb39b5a75f44040e | 28,509 |
def midi2freq(midi_number):
"""
Given a MIDI pitch number, returns its frequency in Hz.
Source from lazy_midi.
"""
midi_a4 = 69 # MIDI Pitch number
freq_a4 = 440. # Hz
return freq_a4 * 2 ** ((midi_number - midi_a4) * (1. / 12.)) | 995453032f5280e5b8a28a2265ef2c4de8f83b8e | 28,510 |
import json
def format_str(str_value, is_json):
"""
Returns a formatted string with break lines; if is_json True, pretty format the output
:param str_value: plain text or json value
:param is_json: Boolean
:return: str
"""
str_value = json.dumps(str_value, indent=4, sort_keys=True) if is_j... | 3840a355b44404a0c0022f0297453023a2eb698a | 28,513 |
def default_empty(default):
"""Check an input against its falsy value or return a default."""
def get_value(test_value):
if test_value:
return test_value
else:
return default
return get_value | b3ff34d8fb5d46a62ad11a439dad7d03fb4425f2 | 28,515 |
def _find_error_code(e):
"""Gets the approriate error code for an exception e, see
http://tldp.org/LDP/abs/html/exitcodes.html for exit codes.
"""
if isinstance(e, PermissionError):
code = 126
elif isinstance(e, FileNotFoundError):
code = 127
else:
code = 1
return cod... | a9e14ec1cf01f0eba65b231aa7a40afaf4712535 | 28,516 |
def make_behaving(ary, dtype=None):
""" Make sure that `ary` is a "behaving" bohrium array of type `dtype`.
Requirements for a behaving array:
* Is a bohrium array
* Points to the first element in the underlying base array (no offset)
* Has the same total length as its base
Parameters
-... | e74c3c276ef2f5eb0ddb3d9b7870af0035cdaab4 | 28,521 |
from pathlib import Path
def file_exists(filename):
""" Returns true if file exists
:param filename: The file name to check
:type filename: str
:returns: True if file exists
:rtype: bool
"""
file_handle = Path(filename)
if file_handle.is_file():
return True
else:
r... | 5800f9b15aa869993e8bc0decea0ea1bf4a449e6 | 28,523 |
def center_y(display_height: int) -> int:
"""
Find the vertical center position of given screen/space/display
Parameters:
display_width (int) : The character height of the screen/space/display
Returns:
(int): Vertical character number
"""
return display_height // 2 | b59a325ef4fb84d306f22c7c5717b1d9a155ed45 | 28,527 |
def parse_syntax(line):
"""
>>> parse_syntax('syntax: glob')
'glob'
>>> parse_syntax('syntax: regexp')
'regexp'
>>> parse_syntax('syntax: none')
Traceback (most recent call last):
...
Exception: Unknown syntax "none"
"""
line = line.replace(':', ' ')
_, syntax = line.spli... | 8f619b216ede8cc9bdd8198f6433add997c87768 | 28,528 |
def boundCreator(mus, sigmas, c=3):
"""
Creates interval around the mean
Parameters
----------
mus : array of shape [Num flights, time-steps, num of features]
the mean temporal values to be used.
sigmas : array of shape [Num flights, time-steps, num of features]
the temporal sta... | 5ec6af891a0c39fd6f51e961de13a0db946a20cc | 28,531 |
def coerce_to_bool(x: str) -> bool:
"""Convert string to bool value."""
if x.lower() in ('true', 'yes', 'on', '1', 'false', 'no', 'off', '0'):
return x.lower() in ('true', 'yes', 'on', '1')
raise ValueError() | d8da41c00ad94e75fd20f3c4a4aaaf8fb04cbb08 | 28,532 |
def get_ua_platform(user_agent):
"""Get platform (mobile, tablet, pc)."""
if user_agent.is_mobile:
return "mobile"
elif user_agent.is_tablet:
return "tablet"
elif user_agent.is_pc:
return "pc"
else:
return "unknown" | be735fa118fd09a25f3120dda8bdb1c45943b859 | 28,538 |
def create_deterministic_delayer(delay):
"""
Create a deterministic delayer that always returns the same delay value
Args:
delay (float): Delay value to return
Returns:
function: delayer
"""
assert delay >= 0, "Inputted delay must be non-negative!"
return lambda: delay | 8d25603dc273b631eef2e270753dbb6ae4c7d959 | 28,545 |
def check_bounds(position, size):
"""
Checks whether a coordinate is within the indices of a grid.
Parameters
----------
position: list
the coordinate to check for within the grid
size: int
the size of the grid to compare the coordinate values to
Return
--------... | f93721e2b852df8e2e52d0e8fb7157f60bda7536 | 28,548 |
def field_validator(value, validators: set) -> bool:
"""
Execute a set of validator functions (the _is_x) against a value.
Return True if any of the validators are True.
"""
return any([True for validator in validators if validator(value)]) | d8331dac68e85b1725280af9df6b71f8f0c46465 | 28,549 |
def line_filter(regexp, lines):
"""
Filter each line of input by a regular expression.
If the regular expression is not matched, then the line is not output.
"""
output = []
for line in lines:
match = regexp.match(line)
if match:
output.append(line)
return outpu... | 8b3ed6abde04a0278fa98d618117bb5ee686baf8 | 28,556 |
def get_nonblocking(queue):
""" Get without blocking from multiprocessing queue"""
try:
resp = queue.get(block=False)
except Exception as e:
resp = None
return resp | 8cb190f8652a8ea54b6f469cac4204b1706b4d6e | 28,558 |
def move(password, position_x, position_y):
"""Move letter from position_x to position_y.
Letter should be removed from password and inserted at position_y.
"""
to_move = password.pop(position_x)
password.insert(position_y, to_move)
return password | a63124adeb25aeec1e31469d808725f5654b3928 | 28,561 |
def predict_raw(model, periods):
"""Returns the raw output of a Prophet model.
Paramaters
----------
model : dict
A trained Prophet model created with init_fit.
periods : int
The number of periods to forecast.
cap : float
An upper limit for the case of logistic growt... | 709fbf4757b968d7b6cc882ccea1c6be222d418c | 28,564 |
def compss_wait_on(obj):
"""
Dummy compss_wait_on
:param obj: The object to wait on.
:return: The same object defined as parameter
"""
return obj | cb433878c460a507d98c1c3a8880626f804b201f | 28,565 |
def get_dict_dot(d: dict, key: str, default=None):
""" Gets an entry from a dictionary using dot notation key, eg: this.that.something """
try:
if isinstance(d, dict) and key:
split = key.split(".")
value = d.get(split[0], None)
if value is not None:
i... | 2e179f81ee7d05554150fad2fd8363d44c4b3a88 | 28,568 |
def edge_list_get_tail_index(edge_list, tail_index):
"""
Takes a list of edges and returns an edge if the tail_index matches the
given index, or None otherwise.
"""
for edge in edge_list :
if edge.tail_index == tail_index :
return edge
return None | 1d7f55afec3fb9da269d1c45dd111ce05cb10bd5 | 28,575 |
import math
def _fraction2str(num, decimals=2):
"""
Helper method to pretty print percentages.
Args:
num: A number in the range [0,1].
"""
if isinstance(num, str):
return num
mult = math.pow(10, decimals)
if num < 0.5/mult:
return "0"
ret = str(int(num*mult+.5)/... | 5b2483fb5c2fe3ec4c543c4d6e1186491bb348dc | 28,576 |
def all_lines_at_idx(mm, idx_list):
""" return a list of lines given a list of memory locations
follow up on all_lines_with_tag
e.g. all_lines_at_idx(mm, all_lines_with_tag(mm, 'Atom') )
reads '''
Atom 0 0 0 0
Atom 1 1 1 1
Atom 2 2 2 2
'''
Args:
mm (mmap.mmap): memory map to file
idx_list (li... | 2ca06a01773bdf1ab0f94cf5a60405c5f85ca772 | 28,577 |
def _get_attrs_items(obj):
"""Returns a list of (name, value) pairs from an attrs instance.
The list will be sorted by name.
Args:
obj: an object.
Returns:
A list of (attr_name, attr_value) pairs.
"""
return [(attr.name, getattr(obj, attr.name))
for attr in obj.__class__.__attrs_attrs__... | 6e1ac65ea2b9a136581dfdddf8e789fc8fa9da90 | 28,580 |
def safe_col_name(args_pair):
"""Ensure that the column name is safe for SQL (unique value, no spaces, no trailing punctuation).
Typically called with `df.columns = [*map(safe_col_name, enumerate(df.columns.to_list()))]`
Args:
args_pair: tuple of arguments from map function in `(idx, col)`
Re... | 51256b15ee2fcc55cbc77dbdc2aa03408a6f1e26 | 28,585 |
def format_sec_fixed(sec):
"""Format seconds in a fixed format."""
return '%d:%02d:%02d' % (int(sec / 3600), int(sec % 3600 / 60), int(round(sec % 60))) | d6fb346e3a83b451e65277a6301f49b0f91e5efb | 28,591 |
def temp_column_name(*dataframes):
"""Gets a temp column name that isn't included in columns of any dataframes
Parameters
----------
dataframes : list of Pandas.DataFrame
The DataFrames to create a temporary column name for
Returns
-------
str
String column name that looks ... | 307d6d1778ac550c1a0ba468e2fd81206d9c0cb9 | 28,597 |
def get_func_and_script_url_from_initiator(initiator):
"""Remove line number and column number from the initiator."""
if initiator:
return initiator.rsplit(":", 2)[0].split(" line")[0]
else:
return "" | 9029050bdc567e02dceca9a3967f289fc21324ab | 28,600 |
def format_array(arr, precision=4):
""" Create a string representation of a numpy array with less precision
than the default.
Parameters
----------
arr : array
Array to be converted to a string
precision : int
Number of significant digit to display each value.
Returns
... | fb97da91c88a769aa95454666f734a6bc68ef4f5 | 28,601 |
def black_percentage(rgb):
"""
rgb: rgb tuple of a pixel
returns: pixel percentage of black
"""
if isinstance(rgb, int):
return 100 - rgb
return 100 - (int((((rgb[0] + rgb[1] + rgb[2])/3)*100)/255)) | 916f2c61e0af68509ba6fa45fe187c5144ba5337 | 28,608 |
def _align(value, alignment):
"""Find the smallest multiple of `alignment` that is at least as large as `value`."""
return ((value - 1) // alignment + 1) * alignment | 9bbe11caf6221b73778caf9f2583ed3829d22942 | 28,609 |
def to_full_year(two_digit_year, threshold=80):
"""Converts a year given by two digits to a full
year number.
Input params:
threshold: up to which ending the year should be thought
of as 1900s.
"""
ending = int(two_digit_year)
return (1900+ending) if ending > threshold else (2000+ending) | 346654e1106795fa3d64d0d05ede16074c8a181e | 28,615 |
def identityfunc(arg):
"""Single argument identity function.
>>> identityfunc('arg')
'arg'
"""
return arg | 6987908c3229623fcd5201978aa33f2362caa54d | 28,619 |
def is_mixed_case(string: str) -> bool:
"""Check whether a string contains uppercase and lowercase characters."""
return not string.islower() and not string.isupper() | 230a452a2690fda4a90f59e8aaede8f8233c78a7 | 28,621 |
def get_timestamp(integer):
"""
Parses integer timestamp from csv into correctly formatted string for xml
:param integer: input integer formatted hhmm
:return: output string formatted to hh:mm:ss
"""
string = str(integer)
if len(string) == 1:
return '00:0{}:00'.format(string)
eli... | 81b4fa1e9237ee37abfe067b76b2e8656b409473 | 28,623 |
from bs4 import BeautifulSoup
import re
def _parse_table(html, id, include_headers=True):
"""
Parse HTML table with given ID.
Keyword arguments:
html -- the HTML to parse
id -- the ID of the table to parse
include_headers -- whether to include the headers in the output (default True)
Ret... | e4317f657645f9de4a9055b1b4dc23ca7b75c56c | 28,635 |
def using_append_to_construct_a_list(n):
""" Constructs [1, 2, 3, ... n] by using the append list method. """
new = []
for k in range(1, n + 1):
new.append(k)
return new | 529946ad34ec3c4b86a2decabffc052fd74e7cbe | 28,636 |
def is_single_bool(val):
"""Check whether a variable is a ``bool``.
Parameters
----------
val
The variable to check.
Returns
-------
bool
``True`` if the variable is a ``bool``. Otherwise ``False``.
"""
# pylint: disable=unidiomatic-typecheck
return type(val) =... | 24a18577e08d43c36bdb89a196eb1406608528a5 | 28,637 |
import configparser
def config_parser(config_file):
"""
Configuration file parsing.
Returns dictionary with configuration parameters:
'one_auth_file' - Opennebula sessions credential file path,
'key_file' - AES key file path,
'workers_quantity' - ZMQ workers quantity,
'server_ip' - IP addr... | 8847d8344caeed24b6673dc34712430b8892d18b | 28,641 |
def always_true(*args, **kwargs):
"""Always returns True, no matter the arguments."""
return True | 94d8e3845fecf0ea2d991bbd09a03c5fd14c4ca8 | 28,642 |
def average_error(state_edges_predicted, state_edges_actual):
"""
Given predicted state edges and actual state edges, returns
the average error of the prediction.
"""
total=0
for key in state_edges_predicted.keys():
#print(key)
total+=abs(state_edges_predicted[key]-state_edges_... | 40d132682e49b556e8cc0fc71015947202b9cf08 | 28,643 |
import re
def remove_bracketed_text(s):
"""
Removes text in brackets from string :s: .
"""
s = re.sub(r'\([^\()]+?\)', '', s)
s = re.sub(r'\[[^\[]]+?\]', '', s)
s = re.sub(r'\[[^\[]]+?\]', '', s)
return s.strip() | 13290df1b16eae86dca8f9cc00be93660b25b741 | 28,644 |
def expand_dims_as(x, y):
"""Expand the shape of ``x`` with extra singular dimensions.
The result is broadcastable to the shape of ``y``.
Args:
x (Tensor): source tensor
y (Tensor): target tensor. Only its shape will be used.
Returns:
``x`` with extra singular dimensions.
"... | b914d4cc47916dc98ff535ff964b80d943f88d87 | 28,649 |
import re
def get_branches(aliases):
"""Get unique branch names from an alias dictionary."""
ignore = ['pow', 'log10', 'sqrt', 'max']
branches = []
for k, v in aliases.items():
tokens = re.sub('[\(\)\+\*\/\,\=\<\>\&\!\-\|]', ' ', v).split()
for t in tokens:
if bool(re.s... | 25cd6ed33275229d1124b6dfbec503840104dd26 | 28,650 |
def get_waze_navigation_link(xy_tuple):
"""
Create a navigation link from a tuple containing an x and y tuple for Waze.
:param xy_tuple: Tuple of (x,y) coordinates.
:return: String url opening directly in waze for navigation.
"""
return 'waze://?ll={lat},{lon}&navigate=yes'.format(lat=xy_tuple[1... | cd6e08453b84856e55922ee9ba7b042bc55d5901 | 28,667 |
import yaml
def load_yaml(yml_path):
"""Load parameter from yaml configuration file.
Args:
yml_path (string): Path to yaml configuration file
Returns:
A dictionary with parameters for cluster.
"""
with open(yml_path, 'r') as stream:
data_loaded = yaml.safe_load(stream... | b123f1084c28dc6624d56036bac8d20278d5acea | 28,669 |
def format_list(str_list):
""" convert a list of strings to a string with square brackets "[\"something\", \"something\"]"
which is suitable for subprocess.run
"""
list_repr = ['\"{}\"'.format(item).replace("\"", "\\\"") for item in str_list]
joint_str = ",".join(list_repr)
return joint_str | e4e9ff96445413d7cfc4251ecbc1dca9a64339bb | 28,670 |
def format_percentile(q):
"""Format percentile as a string."""
if 0 <= q <= 1.0:
q = 100.0 * q
return '{:3.1f}%'.format(q) | 7451f8bb53b47a72e20c4cb94402922d497dff43 | 28,671 |
def find_in_list(list_one, list_two):
"""
Function to find an element from list_one that is in list_two
and returns it. Returns None if nothing is found.
Function taken from A3
Inputs:
list, list
Outputs:
string or None
"""
for element in list_one:
if ele... | f6fbd1ce96ee2e9cb4fed130dd2aa35a19fa68e1 | 28,674 |
def ternary_expr(printer, ast):
"""Prints a ternary expression."""
cond_str = printer.ast_to_string(ast["left"]) # printer.ast_to_string(ast["cond"])
then_expr_str = printer.ast_to_string(ast["middle"]) # printer.ast_to_string(ast["thenExpr"])
else_expr_str = printer.ast_to_string(ast["right"]) # pri... | f88fc65b684bff7ad61e0bc64d17b65bbe7735e5 | 28,675 |
def defaultify(value,default):
"""Return `default` if `value` is `None`. Otherwise, return `value`"""
if None == value:
return default
else:
return value | f13b30e0ccc06d09d5be6fe9f82d8d99495f5b32 | 28,677 |
def my_contains(elem, lst):
"""Returns True if and only if the element is in the list"""
return elem in lst | d859f1a26d7f87deef9e11b8d3f3e8648ecc141d | 28,678 |
def repr_author(Author):
"""
Get string representation an Author namedtuple in the format:
von Last, jr., First.
Parameters
----------
Author: An Author() namedtuple
An author name.
Examples
--------
>>> from bibmanager.utils import repr_author, parse_name
>>> names = ['Last', 'First Last', '... | f15bba99a1c6466a6b3e0fbd30ac32109f6447b5 | 28,679 |
def getFirstPlist(textString):
"""Gets the next plist from a set of concatenated text-style plists.
Returns a tuple - the first plist (if any) and the remaining
string"""
plistStart = textString.find('<?xml version')
if plistStart == -1:
# not found
return ("", textString)
plistE... | 19de59d42661488ad254a7afa8aded4f3f17bf1a | 28,682 |
def _ibp_add(lhs, rhs):
"""Propagation of IBP bounds through an addition.
Args:
lhs: Lefthand side of addition.
rhs: Righthand side of addition.
Returns:
out_bounds: IntervalBound.
"""
return lhs + rhs | b63b538cc1d412932bec86285077f786e5a9cd4e | 28,687 |
def train_model_and_get_test_results(model, x_train, y_train, x_test, y_test, **kwargs):
"""
Train the model on given training data and evaluate its performance on test set
Args:
model: various ML models
x_train: Training data
y_train: Training targets
x_test: Testing data
... | f3f8de07874796045a1268fd415d822c004a87aa | 28,691 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.