content stringlengths 39 14.9k | sha1 stringlengths 40 40 | id int64 0 710k |
|---|---|---|
def guard(f, *args, **kwargs):
"""
Run a function.
Return (is_error, result), where ``is_error`` is a boolean indicating whether
it raised an exception. In that case, ``result`` will be an exception.
"""
try:
return (False, f(*args, **kwargs))
except Exception as e:
return (... | 7b612dbc88a098c50a5f3b9cc2d2e8eeb617b160 | 34,919 |
def get_kind_and_id(thing_id):
"""
Args:
thing_id (str): a reddit thing id in the form t#_#+
Returns:
(str, str): a tuple of kind and id
"""
return thing_id.split("_", 1) | 7b487b3a79c92104a938dfb9370c4092265c36f3 | 34,925 |
def rescale_eigenfunctions(eigenfunctions, scale_factor=1.0):
""" Scale eigenfunctions by a `scale_factor` """
return scale_factor * eigenfunctions | 5a15aeb0eecd5eb161a66c4c0844191d0426f26f | 34,927 |
def sample_cov(r, **kwargs):
"""
Returns the sample covariance of the supplied returns
"""
return r.cov() | 971b98d9f951ed4c0dc3c9fca33098441f93cbf3 | 34,930 |
def street_not_in_use(street, items):
"""
Check if elements of street are not in use already.
For example [[(2, 'black'), (3, 'black'), (4, 'black'),(5, 'black)],[(3, 'black'), (4, 'black'), (5, 'black')]]
would return false, because 3, 4 and 5 are already used
:param street: List of elements that w... | 6ba82838ca0b49c59c20cb6b47ec593c1fe43454 | 34,944 |
def both_set_and_different(first, second):
"""
If any of both arguments are unset (=``None``), return ``False``. Otherwise
return result of unequality comparsion.
Returns:
bool: True if both arguments are set and different.
"""
if first is None:
return False
if second is No... | e5313d79ec434ef79c2b054fbdf0f80458f223a8 | 34,945 |
def CtoF(t):
"""Conversion: Celcius to Fahrenheit."""
return (t*9)/5+32 | 7453fb09a8cda84a1ae32748e3ffc36cccfdf59d | 34,947 |
def l2_norm_sqr(w):
"""
Returns square of L2 norm of the given matrix (w).
square of L2 norm of a matrix is simply the sum of square of elements of the matrix.
@input: w, a theano shared variable.
@output: L2 norm of w
"""
return (w ** 2).sum() | 3573d004e4e545f4f6fba4bf44ed8bb39badaba7 | 34,948 |
def load_external_ids(path):
"""
load file of ids to list
"""
with open(path) as f:
return [int(line.strip()) for line in f] | d430ed6541f390e03928beea1f4caa04cb244bd3 | 34,953 |
def second_to_human(time_in_sec):#{{{
"""
Returns a humanized string given the time in seconds
The output rounds up to days, hours, minutes, or seconds.
4 days 5 hours returns '4 days 5 hours'
0 days 4 hours 3 minutes returns '4 hours 3 mins', etc...
"""
days = int(time_in_sec)/3600/24
... | f1f480f5ccbd05f3413f562f33beb7865e1a6d86 | 34,955 |
import warnings
def is_equal(v1, v2):
"""
Function for basic comparison compare.
Parameters
----------
v1: Any
first value
v2: Any
second value
Returns
-------
result : bool
Returns ``True`` if ``v1`` and ``v2`` are equivalent.
If an exception is r... | 3955602d046e16c0488c288bc7d942e69042ab46 | 34,958 |
def rows_to_dict(
rows,
main_key_position=0,
null_value="delete",
header_line=0,
contains_open_ends=False,
):
"""
Convert a row of rows (e.g. csv) to dictionary
Parameters
----------
rows : list
the row based data to convert to `dict`
main_key_position : int, optiona... | 346f759464c1e4b9cd8f7b54387c10b4dc46453d | 34,961 |
def trimHighscores(arr):
"""Returns 5 greatest scores from 'arr'."""
arr = sorted(arr, key=lambda record: -int(record[1]))
return arr[:5] | 91f3ba4318104ec6a265b336cd2959fb78978864 | 34,963 |
def moeda(preco=0, moeda="R$"):
"""
-> Faz a formatação de um determinado preço.
:param preco: o preço a ser formatado.
:param moeda: determina o formato a ser aplicado.
:return: o valor formato
"""
return f'{moeda} {preco:.2f}'.replace('.', ',') | c9567ac6a205d8f37001188ade6ac3281d6f870f | 34,965 |
def set_transformer_in_out(transformer, inputCol, outputCol):
"""Set input and output column(s) of a transformer instance."""
transformer = transformer.copy()
try:
transformer.setInputCol(inputCol)
except AttributeError:
try:
transformer.setInputCols([inputCol])
excep... | 4bf9bd4abeaa6435df5316c9201d62dd97645cd5 | 34,970 |
def join_bpe(lst:list, s:str):
"""Join words together that are prefaced with '##'. To be used with `reduce` """
if s[:2] == "##":
# How to handle situation where first term is double hashed?
base = lst.pop() # Remove from last position
new_term = base + s.strip("#")
return lst +... | 53d8891adcbced80bbded95bcd32c1aaa292fd25 | 34,971 |
def convert_date(date):
"""
Converts the date from the DD/MM/YYYY format to YYYY-MM-DD
>>> convert_date("13/04/2018")
'2018-04-13'
"""
tokens = date.split("/")
return f"{tokens[2]}-{tokens[1]}-{tokens[0]}" | dd7eb20f73412565285887fa8f9ec19bcde2b3dc | 34,973 |
import functools
import logging
import time
def RetryOnException(exc_type, retries):
"""Decorator to retry running a function if an exception is raised.
Implements exponential backoff to wait between each retry attempt, starting
with 1 second.
Note: the default number of retries is defined on the decorator,... | ea87117cd202cbc6ce5bc4fc9fb25a5b8a324e1f | 34,974 |
import csv
def read_csv(csv_path):
"""Assume that csv file is formatted as:
name1,label1
name2,label2
...
"""
with open(csv_path) as to_read:
csv_reader = csv.reader(to_read)
ret_list = [(name, int(label)) for name, label in csv_reader]
return ret_list | 182afc58b826079adee5e74ab07e4aa77febdb03 | 34,975 |
from typing import Any
from typing import Set
def get_all_subclasses(cls: Any) -> Set[Any]:
"""Get all subclasses of the given class."""
return set(cls.__subclasses__()).union(
[s for c in cls.__subclasses__() for s in get_all_subclasses(c)]) | 0f1c93b3db6834b1596df4d403a438b1c5597219 | 34,976 |
def gcd(x: int, y: int) -> int:
"""Greatest common divisor."""
while x % y != 0:
r = x % y
x = y
y = r
return abs(y) | e076707c26a63af1ce8e993163b4c165b361d074 | 34,980 |
def _resnames_match(resnames, allowed_resnames):
"""
Return true if one element in resnames matches
one element in allowed_resnames.
Parameters
----------
resnames: `abc.iterable`
allowed_resnames: `abc.iterable`
"""
for resname in resnames:
if resname in allowed_resnames:
... | 4078b7baae89a7c8c0d5edbba78235704825ee29 | 34,983 |
def is_pandigital(x):
"""
Checks if x contains all digits between 1 and 9 (inclusive) exactly once
"""
digits = [int(i) for i in str(x)]
digits.sort()
return(digits == list(range(1, 10))) | 2024b596888e93d2ec91e2be60c0cde5ac30fce7 | 34,985 |
def __edge_exists__(i, j, g):
"""
Checks if the edge i --> j exists in the graph, g.
:param i: Index of a node.
:param j: Index of a node.
:param g: Graph.
:return: A boolean indicating if j is a successor of i.
"""
return j in list(g.successors(i)) | 00cb1fb0bb6f2fffb1f6359c9a8fdd2afd939652 | 34,987 |
def iteritems(d):
"""Python 2, 3 compatibility."""
try:
return d.items()
except AttributeError:
return d.iteritems() | 8848c1efbddb1f4a1a404b8fa3ae800aeb5a0770 | 34,990 |
from typing import Callable
from typing import Dict
import uuid
def _guid_replacer() -> Callable[[str], str]:
"""
Closure for replace_guid.
Returns
-------
Callable[[str], str]
replace_guid function
"""
guid_map: Dict[str, str] = {}
def _replace_guid(guid: str) -> str:
... | 87c4b6553fb4dee1b588ce3f2eefde9723c9b28f | 34,996 |
def query_phantom(view, pid):
"""Query phantom."""
return view.query_phantom(pid) | 50d7c921264d924a38145af7b37086f8e750bd66 | 35,000 |
from pathlib import Path
def filename(filepath):
"""Returns the filename at the end of filepath.
Args:
filepath (str): A path to a file
Returns:
str: The filename
"""
return Path(filepath).name | 49aa2e76f7ce4749796d1870d55ff58a2a435b65 | 35,002 |
def clean_labels(_labels, keep=1):
"""An input list of string numeric labels is split and casted to int
Args:
_labels (list): List of strings to be processed
keep (int, optional): [description]. Defaults to 1. Tells the function
if either the labels or the value is to be kept
R... | 806da913dfdef53a04bb3b8d601feb9027be00a0 | 35,004 |
def getTypesWithName(types, names):
"""function returns all types that have a specific name
Keyword arguments:
types -- list of model.Type instances
names -- list of strings with names
"""
typesWithName = []
for type in types:
for name in names:
if type.name == name:
... | 8219b1df233d1aea21c5efe80c3c621d30a8d595 | 35,009 |
def getCenter(x, y, blockSize):
"""
Determines center of a block with x, y as top left corner coordinates and blockSize as blockSize
:return: x, y coordinates of center of a block
"""
return (int(x + blockSize/2), int(y + blockSize/2)) | 9398aa6438b5921c625381898a7666b4203d2e73 | 35,010 |
import csv
def read_objects_csv(filename):
"""Takes a CSV with headings and converts each row to a dict. Useful for populating create_network()
:param filename: Full filename of the CSV
:type filename: str
:return: A list of dicts, each dict is a row from the CSV, with the heading as key and column a... | 2782bb833e39c361338976f264b796f5231fc584 | 35,012 |
def threshold(pred, param):
"""
Takes the predicted image "pred", thresholds it with the determined
param, returns binary image.
Parameters
----------
pred : np.array
Prediction image
param : float
Threshold for the input image
Returns
-------
np.ndarray
... | e38ab2683d48fc069782d0a18ffad51cce944aec | 35,015 |
from functools import reduce
def PostUploadHook(cl, change, output_api):
"""git cl upload will call this hook after the issue is created/modified.
This will add extra trybot coverage for non-default Android architectures
that have a history of breaking with Seccomp changes.
"""
def affects_seccomp(f):
... | 1923453354990d037a8c0b5f7af9026974905a7b | 35,017 |
async def read_until(socket, messages):
"""
Reads from socket until all messages from the list are received
Returns the list of messages read
"""
messages = messages.copy()
res = []
while messages:
data = await socket.receive_json()
res += [data]
if data in messages:
... | 0dc807b23b6b65fc2952da56abef442a742fc85d | 35,018 |
def _DefaultRunnable(test_runner):
"""A default runnable for a PythonTestRunner.
Args:
test_runner: A PythonTestRunner which will run tests.
Returns:
The test results.
"""
return test_runner.RunTests() | 7b86682211924848c7ebb9bdc70a36c08bc63cbe | 35,020 |
def rekey_dict(d, key_map):
"""
Renames the keys in `d` based on `key_map`.
`d` is a dictionary whose keys are a superset of the keys in `key_map`.
`key_map` is a dictionary whose keys match at least some of the keys in `d` and whose values
are the new key names for `d`.
For example:
... | 1e88b6ca14d94f3fbbc73a2760833a5514264667 | 35,022 |
def markdown_paragraph(text: str) -> str:
"""Return the text as Markdown paragraph."""
return f"\n{text}\n\n" | 38f2a790f565e6417d73a2b2430cc0c5efabc27a | 35,027 |
from torch.nn.modules.instancenorm import _InstanceNorm
from torch.nn.modules.batchnorm import _BatchNorm
from torch.nn import GroupNorm, LayerNorm
def assert_is_norm_layer(module) -> bool:
"""Check if the module is a norm layer.
Args:
module (nn.Module): The module to be checked.
Returns:
... | 2698640b36b6b08068b4276fc725aa84d950ace7 | 35,036 |
import six
def is_integer(obj):
"""Helper to determine if the provided ``obj`` is an integer type or not"""
# DEV: We have to make sure it is an integer and not a boolean
# >>> type(True)
# <class 'bool'>
# >>> isinstance(True, int)
# True
return isinstance(obj, six.integer_types) and not ... | 4b17b11fd0a86b900f21191522b636b1f63e5015 | 35,037 |
def confirm(msg):
"""Simple confirmation through user input
msg(str): Message expecting a yes or no answer
Returns True if answer is "yes" and False otherwise.
"""
question = f'{msg} (y/n) '
answer = ''
while answer not in ('y', 'n'):
answer = input(question).lower()
return answ... | 50913505396ce8df87084da70c6886d90a0b1714 | 35,039 |
def MakePartition(block_dev, part):
"""Helper function to build Linux device path for storage partition."""
return '%s%s%s' % (block_dev, 'p' if block_dev[-1].isdigit() else '', part) | 3e21c773a69b7c49bb4aad4210b9d168099565ef | 35,041 |
def apl_singleton(ip: str) -> str:
"""
Convert a single IP or net/mask to APL item form
"""
try:
ind = ip.find(":") # IPv6?
except Exception:
ind = -1
if ind >= 0:
prefix = "2:"
else:
prefix = "1:"
try:
ind = ip.index("/") # mask included?
ex... | 32f4886bf7e55f7d15b916e6321454db7948f536 | 35,042 |
def getDigit(num, n, base=10):
"""
return nth least-significant digit of integer num (n=0 returns ones place)
in specified base
"""
return int(num / base**n) % base | 1f63850ffb5f138056aa3111e3f472753edaf822 | 35,049 |
import requests
def query_bulk_games_endpoint(username, year, month):
"""
Get data from the chess.com bulk game API endpoint.
Args:
username (str): A valid chess.com username.
year (str): Year in a YYYY format.
month (str): Month in a MM format.
Returns:
requests.resp... | ece7d261ef574b45d4fe6f9ac0170362ac44ae6f | 35,058 |
def cols_by_type(df, dtype):
""" Return all column names in `df` with data type `dtype`
"""
return [col for col, dtype in zip(df.columns, df.dtypes) if dtype == dtype] | 8f33bb8624895c3cfd3793ee72554587ca202adb | 35,065 |
def ceilsius_to_kelvin(t: float) -> float:
"""Converts the temperature from Ceilsius to Kelvin
Args:
t (float): Air temperatue [°C].
Returns:
float: Air temperature [K].
"""
t += 273.16
return t | a6310e213bfa699ce31d96782075de4fcc28ff20 | 35,066 |
import struct
def _pack_uint32(val):
""" Integer to 32-bit little-end bytes """
return struct.pack("<I", val) | 32f4e6d74d572a716d723af4f7b7a6911a38b17c | 35,069 |
def indent(s, indentation=" "):
"""
helper function to indent text
@param s the text (a string)
@param indentation the desired indentation
@return indented text
"""
return [indentation + _ for _ in s] | 59ec5d6751f906b84c2d46a51777f0831116082a | 35,074 |
def insert(base_seq, positions, sub_seq):
"""
Inserts a subsequence into a base sequence
"""
new_seq = list(base_seq)
for i, p in enumerate(positions):
new_seq[p-1] = sub_seq[i]
return "".join(new_seq) | 6234b55e82edf69efe9e31bf9fa35b46c51019a2 | 35,079 |
import json
def open_file(file: str) -> dict:
"""Open the file, if present, if not, return an empty dict."""
try:
with open(file) as f:
return json.load(f)
except FileNotFoundError:
return {} | 435462a2a7a4d40d7980dce80562f9ab231c8ac0 | 35,081 |
def get_node_text(nodes):
"""Recursively read text from a node tree."""
text = []
format_tags = {"literal": "`", "strong": "**", "emphasis": "*"}
for node in nodes:
# Handle inline formatting elements.
if node.nodeType == node.ELEMENT_NODE and node.tagName in format_tags:
wra... | fdd0345472c4a01069f1c05cbeb9cd946405f552 | 35,088 |
def normalized(z):
"""Returns the complex number with the same argument/phase
but with a magnitude of 1."""
try:
return z/abs(z)
except ZeroDivisionError:
raise ZeroDivisionError("Cannot normalize 0.") | 441cbe83fbd88319830231d62822b85fcffc6ce3 | 35,089 |
def hamming(list_sequences):
"""Compute Hamming distance of two DNA strings"""
string_a, string_b = list_sequences
hamm = 0
for nt_a, nt_b in list(zip(string_a, string_b)):
if nt_a != nt_b:
hamm += 1
return hamm | df80a89927a604d8d88879165bf41b3bf9a1096e | 35,091 |
def reformat_acs_vars(col):
"""Convert variable names to the same format used by the Census Detailed Tables API.
See <https://api.census.gov/data/2019/acs/acs5/variables.html> for variable descriptions
Parameters
----------
col : str
column name to adjust
Returns
-------
str
... | 535a42bef9da5ade2afe87abab59578cf60e0ba6 | 35,095 |
from typing import Union
from datetime import datetime
def _new_name(seq_type: str) -> Union[str, None]:
"""
Creates a new file name based on the sequence type.
"""
tstamp = datetime.now().strftime("%Y_%m_%d-%I-%M-%S_%p")
if seq_type.lower() == "dna":
return f"dna_sequence_{tstamp}.txt"... | 2ed107900bc936472894cb40ee44cc887e9f8201 | 35,097 |
def parse_and_validate_latitude(request):
"""Extract and Check the validity of latitude.
Args:
request: HTTP request.
Returns:
latitude(float) if valid.
Raises:
ValueError: if latitude is not float, or outside range [-90, 90].
"""
lat = float(request.rel_url.query.get(... | 3bde916112e0c24cd989275dba389826e56a4e5f | 35,103 |
def get_key(my_dict, val):
"""
This function finds the key of a value in a dictionary.
:param my_dict: The dictionary object to look for key
:param val: the value of the target key
:return: the first target key corresponding to the given value
or string saying "key doesn't exist"
""... | 3ad9ed2a0ee65aaf232fc941a6ee94739b980880 | 35,105 |
from typing import Optional
from pathlib import Path
def find_user_library() -> Optional[Path]:
"""Attempts to retrieve the path to the user's default music library folder."""
expected_path = Path('~/Music').expanduser()
if expected_path.exists():
return expected_path | d94e4cfbb48a06a4e870633c7be2fcea4597437e | 35,109 |
def translate_key(key):
"""
Function to return the correct configuration key.
If not found return the key itself.
Returns a string.
"""
mapping = {
'user': 'User',
'identityfile': 'IdentityFile',
'proxycommand': 'ProxyCommand',
'ip': 'Hostname',
... | 9c7b9b32d1b341946a9c66120c7b32c9c304c754 | 35,110 |
import hashlib
def file_md5(file_content):
"""Checksum of content."""
m = hashlib.md5()
m.update(file_content)
return str(m.hexdigest()) | 8c68b2ab87dccf1605593942b3abc1e495a0c8f7 | 35,112 |
def get_target_ids(node_field_values):
"""Get the target IDs of all entities in a field.
"""
target_ids = []
for target in node_field_values:
target_ids.append(target['target_id'])
return target_ids | 68e811b86d246cc0070934ce2a6dc940603e39f8 | 35,113 |
def match_rules(txt, rules):
"""Find rule that first matches in txt"""
# Find first begin tag
first_begin_loc = 10e100
matching_rule = None
for rule in rules:
begin_tag, end_tag, func = rule
loc = txt.find(begin_tag)
if loc > -1 and loc < first_begin_loc:
first_be... | 35a89b274d06e21bc3d03dd5a7c2ece532030303 | 35,114 |
def get_embedding(word, model):
"""
Method to get embedding of given word
parameters
-----------
:param word: str
:param model: object
Word embedding model
:return: vector
"""
if word in model.wv.vocab:
return model.wv[word]
else:
raise KeyError | d77fd6b03bea62859bbce8388bc0961c9fe6d449 | 35,115 |
def estimate_evacuate_timeout(session, host):
""" Rough estimation of the evacuate uplimit based on live VMs memory """
mref = session.xenapi.host.get_metrics(host)
metrics = session.xenapi.host_metrics.get_record(mref)
memory_used = int(metrics['memory_total']) - int(metrics['memory_free'])
# Conse... | 508b1c4df6549b30366c623640fce258163adc8b | 35,117 |
def parse_group_name(group_name):
""" Return an ((int, int), prefix) tuple from group name.
Expects group to be in the form {prefix}/{x}_{y}
raises ValueError if group_name is not in the expected format.
"""
idx = group_name.rfind('/')
if idx < 0:
raise ValueError('Bad group n... | b3151a19cd3b6cdd5028ded0967a637e592764a5 | 35,118 |
import json
def getConfig(configFileName='config.json'):
"""Reads config from file
Parameters
----------
configFileName: str
name of the file to be readed
Returns
-------
json: dict
data structure defining parameters describing application and stored externally
"""
... | c430b50f4c5cc342e328b8555fa48c8cd2a7fe17 | 35,120 |
def get_ca_id_from_ref(ca_ref):
"""Parse a ca_ref and return the CA ID
:param ca_ref: HHTO reference of the CA
:return: a string containing the ID of the CA
"""
ca_id = ca_ref.rsplit('/', 1)[1]
return ca_id | ece01d4566d6317e70c320eb86a52c2a7766b415 | 35,125 |
def cache_master_key(config):
"""Create a string determined by any cache-invalidating config elements."""
return (
"str{use_string}_"
"vocab{vocab_size}_"
"pg{use_page}_"
"geom{use_geom}_"
"amt{use_amount}_"
"pad{pad_windows}_"
"len{window_len}"
).form... | adf39851298b0c15afdb2e3645ef91df6df11376 | 35,126 |
def clean_multiple_coordsets(protein):
"""
Deletes all but the first coordinate set of a protein.
"""
if len(protein.getCoordsets()) > 1:
for i in range(len(protein.getCoordsets())):
if i == 0:
pass
else:
protein.delCoordset(-1)
return ... | 70e0c9355394b78331b802c40369b98c74ed75f1 | 35,127 |
def hash_series(series):
"""Fast series hash"""
# hash(series.to_string())
# 112 ms
# hash(tuple(series.items()))
# 2.24 ms
# hash((tuple(series.values), tuple(series.index.values)))
# 1.77 ms
# chosen solution: 82.3 µs
return hash((
hash(series.index.values.data.tobytes(... | 252fe3ea429cecef88e376a19a189e3b3d45d3cf | 35,133 |
def format_string(x: int, frame: str) -> str:
"""Helper function to format individual time frames.
:param x: Integer
:param frame: Time frame
:return: Formatted time string
"""
return '' if x == 0 else f' {x} {frame} ' if x == 1 else f' {x} {frame}s ' | adccee40ba89d012c7ae75d07a6912cac0c8d7d0 | 35,134 |
import time
def datetime_to_seconds_since_epoch(dt):
"""Converts a Python datetime to seconds since the epoch."""
return time.mktime(dt.timetuple()) | 7f9b48591c0199aa1c1882fe84ecea3a7bd9526f | 35,138 |
def luma(col):
"""Calculates ITU-R 601-2 luma value for a given RGB color. This is the same formula used by `PIL.Image.Image.convert` when converting RGB to L."""
r, g, b = col
return r * 299/1000 + g * 587/1000 + b * 114/1000 | e57a11476205a0b9dc287c1239e8064762161544 | 35,140 |
def build_ranking(teams):
"""
Assigns rankings to the teams based on their winrates. If teams are tied,
they will be assigned the same ranking as each other.
:param teams: A list of teams, where each element is a list containing a team's name
and winrate (among potentially other data). This lis... | 7046e385bda56fd995fd261c253035b1ebb049a9 | 35,141 |
def net_income(ebt, tax):
"""
Computes net income.
Parameters
----------
ebt : int or float
Earnings before tax
tax : int or float
Tax expense
Returns
-------
out : int or float
Net income
"""
return ebt - tax | 7d72f10d98d3646837ad3f5eccb6c19d2900ea38 | 35,142 |
def sanity_check_iob(naive_tokens, tag_texts):
"""
Check if the IOB tags are valid.
* Args:
naive_tokens: tokens split by .split()
tag_texts: list of tags in IOB format
"""
def prefix(tag):
if tag == "O":
return tag
return tag.split("-")[0]
def body(... | 4fb16ed2bd7a623a7dad331d8b7c8a5033a382ea | 35,148 |
def rank_permutation(r, n):
"""Given r and n find the permutation of {0,..,n-1} with rank according to lexicographical order equal to r
:param r n: integers with 0 ≤ r < n!
:returns: permutation p as a list of n integers
:beware: computation with big numbers
:complexity: `O(n^2)`
""... | 6a8ec6e3a2165796a17b69f2f8cb26bc4e0d7489 | 35,150 |
def isclassattr(a, cls):
""" Test if an attribute is a class attribute. """
for c in cls.__mro__:
if a in c.__dict__:
return True
return False | 114c84f575d1b59a78cfa4d32b8c04da7006b7ae | 35,151 |
def list_s3_keys_in_bucket(s3client,
bucket,
prefix=''):
"""
Returns a list of the keys situated at the given prefix in the given bucket
:s3client: boto3.session.Session.client that represents a connection with s3
:bucket: string representing the s3... | dd39b7f7074315458a200b34f8bf4acf385442e6 | 35,153 |
def split_name(a_name):
"""
If only one word given, return it as last.
If more than two words given, return all but last as first.
examples = {
'ok simple': ('ok', 'simple'),
'solo': ('', 'solo'),
'three part name': ('three part', 'name'),
'name with-hyphen': ('name', 'wi... | c4b735c723152bde677c9f85d5a6b0fe90deac1f | 35,156 |
def fitsum(list):
"""Sum of fitnesses in the list, needed to build
wheel of fortune."""
sum=0.0
for i in range(0,len(list)):
sum+=list[i]
return sum | ced8f524f16f7174417eb3f9ce9effcab84a65ae | 35,162 |
from datetime import datetime
def get_timestamp_id(year: bool = True, month: bool = True, date: datetime = datetime.utcnow()) -> str:
"""
Returns timestamp id (tp_id) in format '2021-01', '2021' or '01'.
"""
if not year:
return date.strftime('%m')
elif not month:
return date.strfti... | ccf9fbaae3b93b239b422e15f633cf1347fc47b9 | 35,164 |
def _select_best_indel(indels):
"""Select the highest quality indel, based on the quality,
prefering low earlier positions above later positions in
case of ties."""
def _indel_by_quality_and_position(indel):
# The negative position is used to select the first
# of equally quality indels
... | fcee293103c86d7683d54ea030f5b6d0c4b31a21 | 35,170 |
def temporal_affine_backward(dout, cache):
"""
Backward pass for temporal affine layer.
Input:
- dout: Upstream gradients of shape (N, T, M)
- cache: Values from forward pass
Returns a tuple of:
- dx: Gradient of input, of shape (N, T, D)
- dw: Gradient of weights, of shape (D, M)
... | e43b1ada3db1cac4189f1c4dbc9aa4e7a9c40b64 | 35,173 |
from typing import Tuple
from typing import List
from typing import Dict
def selection(triple: Tuple[str, str, str], variables: List[str]) -> Dict[str, str]:
"""Apply a selection on a RDF triple, producing a set of solution mappings.
Args:
* triple: RDF triple on which the selection is applied.
*... | fee52583e62d589863214e74e99fc427a0b6577d | 35,175 |
import re
def parse_firewall_rule(rule_str):
"""
Transforms a string of multiple inputes to a dictionary list
parameter: (string) rules
A firewall rule in the specified project
Return firewall rules as dictionary list
"""
rules = []
regex = re.compile(r'ipprotocol=([\w\d_:.-]+),por... | 4b3f364f9d102b664ca6f7dab4956ad96be810ae | 35,178 |
def recvall(sock, size: int):
"""Receive data of a specific size from socket.
If 'size' number of bytes are not received, None is returned.
"""
buf = b""
while size:
newbuf = sock.recv(size)
if not newbuf:
return None
buf += newbuf
size -= len(newbuf)
... | 6a0f6814cdaf6847d467f4c5620c3897b1ff2ac8 | 35,183 |
def is_IPv4(ip_string):
"""Returns true if the string is an IPv4: 4 digits < 255, separated by dots"""
digit_list = ip_string.split(".")
if len(digit_list) != 4:
return False
for d in digit_list:
if int(d) > 255:
return False
return True | 1a0b20b4b366e8f4e19e225d32b7a887aed3fe17 | 35,189 |
def extractValue(indexString, content):
"""
Extracts an integer value after the indexString from the given content.
Searched for the given string, then moves over that string + 1 pos (new line),
then reads the numbers until a '<' is found
indexString - The string to search for.
content - T... | 30daae4a53a4d898e5d8a9a1272cf7f0c3e170d2 | 35,191 |
import time
def wait_for_ego_vehicle(world):
"""Loops until a hero vehicle is spawned.
Note: The loop ticks the simulation.
"""
# Connect to the ego-vehicle spawned by the scenario runner.
while True:
time.sleep(1)
possible_actors = world.get_actors().filter('vehicle.*')
f... | 22b584ef02a4db6f6c856ef7e69cf1a17e7bb150 | 35,192 |
def parse_context_table_records_list(records_list: list, fmt: str, is_delete: bool = False):
""" Parses records list given as an argument in context tables management commands.
Args:
records_list: The list of records
fmt: The format of each record, e.g. id:key:value
is_delete: Whether o... | f03b077cfa421688a7e4e58058c0c4ef7d9e619b | 35,193 |
def thr_half(tensor):
"""Get the middle between min/max over batch dimension."""
m = tensor.min(0, keepdim=True).values
M = tensor.max(0, keepdim=True).values
return m, (M - m) / 2.0 | 7d403d048f9c4f914474e4639be7ec1a1a012020 | 35,194 |
def _get_all_shortcuts(directories):
"""
Args:
directories (deque of str objects): All directories up to but excluding the function folder
Returns:
list: All possible shortcuts to the mcfunction path
str: The mcfunction path as specified by minecraft
Examples:
>>> i = I... | ad8912b1f5ea58ae14ec8fd139b009d745f38bf5 | 35,195 |
def quote_path(path: str) -> str:
"""
Quote a file path if it contains whitespace.
"""
if " " in path or "\t" in path:
return f'"{path}"'
else:
return path | fae1dc338fe672871c08ef4b5aa2160dacbba650 | 35,197 |
import re
def remove_comments(tex_source):
"""Delete latex comments from TeX source.
Parameters
----------
tex_source : str
TeX source content.
Returns
-------
tex_source : str
TeX source without comments.
"""
# Expression via http://stackoverflow.com/a/13365453
... | efad4eba12e93af92ca55b6c926d0acf14b653c4 | 35,198 |
from datetime import datetime
import pytz
def from_unixtime(unixtime_, timezone_="UTC"):
"""
Convert a unixtime int, *unixtime_*, into python datetime object
Parameters
----------
`unixtime_` : int
Unixtime i.e. seconds since epoch
`timezone_` : string
The timezone of the outp... | e23c795dd83c45eae376d70af7ea8632b844af43 | 35,199 |
def add_dimention(tensor):
"""[Function that allows a single tensor to be processed by the neural networks that use Sequential function]
Args:
tensor ([type]): [single tensor whitout the batch dimention]
Returns:
tensor[type]: [returns a tensor with extra dimention so it can be prosseced by Sequential in pytor... | 03191db56a073f0a06b1358fe05719e57c8d9bec | 35,205 |
def get_number_rows(ai_settings, ship_height, alien_height):
"""calculate how many row can the screen hold"""
available_space_y = ai_settings.screen_height-3*alien_height-ship_height
number_rows = int(available_space_y/(2*alien_height))
return number_rows | 4cd769a162bc47447293d0ac34ff86298e9beb65 | 35,206 |
def valid_pt(pt, shape):
"""
Determine if a point (indices) is valid for a given shaped
"""
for i, j in zip(pt, shape):
if i < 0: # index is not negative
return False
if i >= j: # index is less than j
return False
return True | 8d2ff4de6666bf60f128493b4a41859ba0a79a32 | 35,207 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.