content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def _broadcast_shapes(shape1, shape2):
"""
Given two shapes (i.e. tuples of integers), return the shape
that would result from broadcasting two arrays with the given
shapes.
Examples
--------
>>> _broadcast_shapes((2, 1), (4, 1, 3))
(4, 2, 3)
"""
d = len(shape1) - len(shape2)
... | 965854e8463022f3ff8d1f6400f93afd29ca16ea | 309,767 |
def to_names(indices, g):
"""
converts vertex indices indices to vertex names
:param indices: list of indices
:param g: graph (with named nodes)
:return: list of vertex names
"""
name_list = g.vs["name"]
name_sorted = [name_list[i] for i in indices]
return name_sorted | 2934cccac0282f63bda26ec7d0cf00c58a85b35f | 242,105 |
import re
import zipfile
def instance_name_from_zip(path):
"""Determines the instance filename within a SEC EDGAR zip archive."""
re_instance_name = re.compile(r'.+-\d{8}\.xml')
for name in zipfile.ZipFile(path).namelist():
if re_instance_name.fullmatch(name):
return name
raise Run... | 59b2154d433e500e9b0cdf39ee70d4c058da1d06 | 7,475 |
def bottom_k(seq, k, kmer_len, stride_len=1):
"""
Return bottom-k minhash sketch fingerprint of sequence.
Parameters
----------
seq : string sequence to perform bottom-k sketch on
k : number of hash value representatives in bottom-k sketch
kmer_len : int the length of the k-mers of the sequence
... | 6811c2ca61eb27ca2fc680aa798e339e63fd38e8 | 611,757 |
def non_exclusive_completer(func):
"""Decorator for a non-exclusive completer
This is used to mark completers that will be collected with other completer's results.
"""
func.non_exclusive = True # type: ignore
return func | 4763f5b0dbdde7837dbfb77562cd2a63da711b30 | 398,444 |
from typing import List
def load_numbers_sorted(txt: str) -> List[int]:
"""ファイルから番号を読み込みソートしてリストを返す
Args:
txt (str): ファイルのパス
Returns:
List[int]: 番号のリスト
"""
numbers = []
with open(txt) as f:
numbers = sorted(map(lambda e: int(e), f))
return numbers | 6f10badd417a2ceefefa9f28a5c40583ea077d43 | 2,501 |
def make_column_names_numbered(base = "base", times = 1):
"""create an array of numbered instances of a base string"""
return ["%s%d" % (base, i) for i in range(times)] | 9cd66d1aa32ff30175c6a1c7f04d3d084f0c221c | 554,430 |
def find_first_visited_twice(visited_order):
"""Find first position that repeats in visited_order."""
visited = set()
for location in visited_order:
if location in visited:
return location
visited.add(location)
return None | a588666ba9a16bd5f6c09bc585fbade92be64278 | 324,513 |
def smart_encode(content: str, encoding: str) -> bytes:
"""Encode `content` using the given `encoding`.
Unicode errors are replaced.
"""
return content.encode(encoding, 'replace') | 4e51aee004b2646f6f907335b883eb2fa5acbd59 | 76,436 |
def l_relu(z):
"""ReLU activation function"""
a = 0.01*z
a[z >= 0] = z[z >= 0]
return a | 45234ab63776463ae4f72ceed879bf035dcd2078 | 256,679 |
def reverse_list_dictionary(to_reverse, keys):
"""Transforms a list of dictionaries into a dictionary of lists.
Additionally, if the initial list contains None instead of dictionaries,
the dictionnary will contain lists of None.
Mainly used in the measure.py file.
Args:
to_reverse (list): ... | 8953372d5ba4bfe99d9e04e7e3d4a8b8432bff69 | 554,551 |
from typing import Optional
import re
def _filename_from_content_disposition(
content_disposition: str,
) -> Optional[str]:
"""Extract the filename from the content disposition.
Parse the content_definition as defined in:
https://tools.ietf.org/html/rfc2616
Note:
* If both encoded (`filename*=`) and... | 4ad1607cf627a0d6b4b696f73f0dd6d77bd20ee0 | 179,581 |
def chars_in_dict(seqdict):
"""Return ordered list of characters in dictionary of sequences."""
# Initialize set of characters
characters = set([])
# Iterate over sequences
for seqid in seqdict.keys():
# Update the set of characters with those in the current sequence
characters.updat... | 57f62ccafbcb984e67ea0092b2e5793e5b0876f0 | 458,992 |
def kurtosis(N,N2,N3,N4,**kwargs):
"""Calculate kurtosis in data N from averages <N^4>, <N^3>, <N^2>, and <N>."""
return (-3*(N**4) + 6*(N**2)*N2 - 4*N*N3 + N4)/((N2 - (N**2))**2) | 23973a27d371beb23c6f942b0258f77fda9e1de4 | 114,502 |
def _FirewallSourceRangesToCell(firewall):
"""Comma-joins the source ranges of the given firewall rule."""
return ','.join(firewall.get('sourceRanges', [])) | 8a99ae68a8891e97a817a893d5897e7a3c1d2cf7 | 546,178 |
from typing import Callable
import inspect
def accepts_kwargs(func: Callable) -> bool:
"""Check if ``func`` accepts kwargs.
"""
return any(
True
for param in inspect.signature(func).parameters.values()
if param.kind == param.VAR_KEYWORD
) | c0e5328382d6019f7bb288ac62e70858ea276388 | 383,823 |
def get_object_xy_in_layer(cur,cell,layer):
"""
Returns (object_num,x,y) coordinates of cell object in layer
Parameters
----------
cur : MySQLdb cursor
cell : str
Name of cell
layer : str
Layer/image name
"""
sql = ("select OBJ_Name,OBJ_X,OBJ_Y "
"from object... | c286e6bb70eea28f48bf832e822a08a4b0689980 | 320,545 |
def rescale(arr, vmin, vmax):
""" Rescale uniform values
Rescale the sampled values between 0 and 1 towards the real boundaries
of the parameter.
Parameters
-----------
arr : array
array of the sampled values
vmin : float
minimal value to rescale to
vmax : float
... | d6debc0eeccd9fe19ed72d869d0de270559c9ce8 | 11,298 |
def is_runtime_parameter(argument):
"""Return True if the directive argument defines a runtime parameter, and False otherwise."""
return argument.startswith('$') | 60dce287302ccbfb0cbc32e31c6485951d1e861c | 255,717 |
def all_repeated_digits(num: int) -> bool:
"""
Tell if the number is made of all repeated digits.
"""
s_num = str(num)
if len(s_num) > 1:
return all([ch == s_num[0] for ch in s_num[1:]])
else:
return False | c3d07b5dce967438482a2e37af244580114564a4 | 584,213 |
def process_latitude(cell):
"""Return the latitude from a cell."""
lat = cell.strip().split("/")[0].strip()
return float(
int(
str(lat[0]) + str(lat[1]),
)
+ int(
str(lat[2]) + str(lat[3]),
) / 60
+ int(
str(lat[4]) + str(lat[5]),
... | eec5f7d80a38794ef9e300c2ffb540f0d1d11bf2 | 129,442 |
def get_target_indice_from_leaves(targets, sent):
"""
Find the indice of the target words in the terminal sequence of a parsed sentence.
"""
target_indice = []
idx = 0
current_target = targets[idx]
for k, w in enumerate(sent):
if w == current_target:
target_indice.append(... | b02a0173c33faae687a91b09e99d7ef5b54168d1 | 60,864 |
def romi(total_revenue, total_marketing_costs):
"""Return the Return on Marketing Investment (ROMI).
Args:
total_revenue (float): Total revenue generated.
total_marketing_costs (float): Total marketing costs
Returns:
Return on Marketing Investment (float) or (ROMI).
"""
re... | 975670e85f9673b89a3defd87f54665b37d0c3ee | 207,503 |
def split_string(input_str):
"""
Parse input string and returns last comma separated element.
In case no comma found, all string is returned.
Args:
input_str(str): input string that will be parsed
Returns:
str: last comma separated element,
or all string in case no c... | 3bae9da5fcdab9706bcfcb9c0036f60f22420ef8 | 127,015 |
import torch
def calc_dihedral(a_coord: torch.Tensor, b_coord: torch.Tensor,
c_coord: torch.Tensor,
d_coord: torch.Tensor) -> torch.Tensor:
"""
Calculate a dihedral between tensors of coords
"""
b1 = a_coord - b_coord
b2 = b_coord - c_coord
b3 = c_coord - d_... | 5028707cd0e2377279a3d77f435db5c0898b9bf3 | 405,704 |
def frequency(gdf, col_kwds='kwds', normalized=False):
"""Computes the frequency of keywords in the provided GeoDataFrame (function adapted from LOCI).
Args:
gdf (GeoDataFrame): A GeoDataFrame with a keywords column.
col_kwds (string) : The column containing the list of keywords (default: `kwds... | 36507c84768a95f78a1f2e0c69f473c98733743e | 441,476 |
def generate_annotation_dict(annotation_file):
""" Creates a dictionary where the key is a file name
and the value is a list containing the
- start time
- end time
- bird class.
for each annotation in that file.
"""
annotation_dict = dict()
for line i... | f40f210075e65f3dbe68bb8a594deb060a23ad8b | 395 |
from typing import List
def keys_exists(multi_dict: dict, keys: List[str]) -> bool:
"""Check if multi-level dict has specific keys"""
_multi_dict = multi_dict
for key in keys:
try:
_multi_dict = _multi_dict[key]
except KeyError:
return False
return True | 1de1ef0060a6f0953335e7968de824e6880bcda6 | 631,355 |
import torch
def tensor_prepend_zero(x):
"""Prepending tensor with zeros.
Args:
x (Tensor): tensor to be extended
Returns:
the prepended tensor. Its shape is (x.shape[0]+1, x.shape[1:])
"""
return torch.cat((torch.zeros(1, *x.shape[1:], dtype=x.dtype), x)) | 5da6c31ce67df5db47382d4dadaf7202ea2afbca | 525,916 |
def create_levels(levels, base_factory):
"""Create a multidimensional array
:param levels: An Iterable if ints representing the size of each level
:param base_factory: A nullary function that returns a new instance of the basic unit of the array
:return: Nested lists
"""
def loop(current, rest... | 6d0c6414e1127114b32cade3ab11a2150d1691c0 | 453,556 |
def find_in_list(query, _list):
"""
From a list, returns the first element that satisfies the query
"""
item = list(filter(query, _list))
return item[0] if item else None | d4f3d8c147230990179695bfb722583b63f0fcae | 297,552 |
import re
def roles_of_function(role):
"""
Separate a function into a set of roles.
In the SEED a function associated with a PEG can have more than one role. This is denoted by joining roles
with either ' / ' (a multi-domain, multifunctional gene), ' ; ' (an ambiguous function), or ' @ '
(a Singl... | 775a70c9c40f4abc6443965229b450a961180964 | 461,521 |
def count_unique_ids(id_dict):
"""
Helper functions to count the number of unique task ids returned by
generate_local_task_ids
"""
return len(set(id_dict.values())) | b1935d543f6f9b5543bd560b046e554d39c0c398 | 480,902 |
def list_diff(l1: list, l2: list):
""" Return a list of elements that are present in l1
or in l2 but not in both l1 & l2.
IE: list_diff([1, 2, 3, 4], [2,4]) => [1, 3]
"""
return [i for i in l1 + l2 if i not in l1 or i not in l2] | dd5c2ebecddec8b3a95cde30dae28cac6b996c51 | 679,494 |
def get_first_second_usernames(user_name_list):
"""
prompt for two user names sperated by comma
check if input is valid and exists in list of user names
if its not reprompt
:param user_name_list - list of usernames in twitter data:
:return first username, second username - strings of both us... | d90b396cbedc6d1cb1ac8ff13b79cc224ef8d54d | 255,358 |
def variance(values):
"""
Returns the variance of a set of variables
"""
average=sum(values)/len(values)
def square(x):
return x*x
return sum([square(x-average) for x in values])/len(values) | 0fe5503b48626b58c210bf13f222d8b946c7ce83 | 452,950 |
def _count_dupes_ahead(string, index):
"""
Counts the number of repeated characters in 'string', starting at 'index'
"""
ret = 0
i = index
end = len(string) - 1
while (i < end) and (string[i + 1] == string[i]):
i += 1
ret += 1
return ret | 70871b0185f1a1224879b9942fbe7a0632f26e9e | 221,847 |
def get_full_action_name(service, action_name):
"""
Gets the proper formatting for an action - the service, plus colon, plus action name.
:param service: service name, like s3
:param action_name: action name, like createbucket
:return: the resulting string
"""
action = service + ':' + action... | f69eb13000fe92cd13783148c8ee340c45bd6591 | 613,464 |
import math
def APR(n,m,alpha=0.08,s=0.20):
"""
Return number of (equal-sized) precincts to audit.
Use Aslam/Popa/Rivest (nearly exact) approximation formula
n = number of precincts
m = margin of victory as a fraction of total votes cast
alpha = significance level desired = 1 - confid... | 943d21acc849671737971fd148f5ae799b4b0af6 | 145,350 |
def usage(err=''):
""" Prints the Usage() statement for the program """
m = '%s\n' %err
m += ' Default usage is to seach the Scan library tree for your branch.\n'
m += ' '
m += ' walklib \n'
m += ' or\n'
m += ' walklib -w tech_rules \n'
m += ' or\n'
return m | 63468270bc890eb9715b6f4bccbad4babf404cb5 | 474,757 |
import yaml
import six
def get_file_configuration(configuration_schema, config_content):
"""Get configuration, based on the configuration file.
Args:
configuration_schema (dict): a match between each target option to its
sources.
config_content (str): content of the configuration ... | 29b5344978c1930d79e316b2423c3862fbf8c45b | 558,659 |
def is_non_html(response):
"""
Returns True if the response has no Content-type set or is not `text/html`
or not `application/xhtml+xml`.
"""
content_type = response.get('Content-Type', None)
if content_type is None or content_type.split(';')[0] not in ('text/html', 'application/xhtml+xml'):
... | abfe0a0f516d8c0a71955caf179ca08da265123f | 226,215 |
def sum_n(n):
"""
Sum of first n natural numbers
>>> sum_n(10)
55
"""
if n == 0:
return 0
else:
return n + sum_n(n-1) | ea158d34aa1d628b2347d038eb588e85a078de06 | 285,082 |
def partial_difference_quotient(f, v, i, h):
"""
Compute the ith partial difference quotient of f at v
"""
w = [v_j + (h if j== i else 0) # add h to just the ith element of h
for j, v_j in enumerate(v)]
return (f(w) - f(v)) / h | 0cdf808f865b21be0e45894b46059e20d182b614 | 125,786 |
def add(a, b):
"""A dummy function to add two variables"""
return a + b | 4914b8d73e6808d93e8e8ee98902ad3b093f1ce6 | 704,031 |
import torch
def generate_struct_mask(features, missing_rate):
"""
Parameters
----------
features : torch.tensor
missing_rate : float
Returns
-------
mask : torch.tensor
mask[i][j] is True if features[i][j] is missing.
"""
node_mask = torch.rand(size=(features.size(0... | d9abe11cf4b42b3289ffa39d21d2212000e6e464 | 530,147 |
def area_bbox(bbox):
"""Return the area of a bounding box."""
if bbox[2] <= 0 or bbox[3] <= 0:
return 0.0
return float(bbox[2]) * float(bbox[3]) | 3e2da08a7756b43a406c3a88fbc402cfac93409c | 517,069 |
def strip_hydrogen(atoms, bonds):
"""
Remove hydrogens from the atom and bond tables.
"""
atoms = atoms[atoms['element'] != 'H']
bonds = bonds[bonds['start'].isin(atoms['atom']) &
bonds['end'].isin(atoms['atom'])]
return (atoms, bonds) | 0117122d92dc260ac3136603b9af1daa39a36593 | 639,941 |
from typing import List
def get_required_cols(geom_type: str, columns: List[str]) -> List[str]:
"""Get the required columns for a given geometry type."""
req_cols = ["id", geom_type, "dates", "region"]
for var in ["time_scale", "pet", "alpha"]:
if var in columns:
req_cols.append(var)
... | 8861004e54a4d741c9727b268164c87e9a091f12 | 665,712 |
def fixed(seconds):
"""Waits for a fixed number of ``seconds`` before each retry."""
def wait_iterator():
while True:
yield seconds
return wait_iterator | f5fe0c8164d3b566c0066142463a08df77ec2a33 | 246,783 |
def decode_literal(packet):
"""Decode a literal packet"""
i = 0
value = ''
while True:
group = packet[i:i+5] # each group has 5 bits
value += group[1:] # the value is contained in the last 4 bits
i += 5
if group[0] == '0':
break # the last section is prefix... | cecb1996f860b993f90e61f5a3adc097653cebda | 260,878 |
def listSum(SumList):
"""
递归求和函数
:param SumList: 求和列表
:return:求和之后的值
"""
if len(SumList) == 1:
return SumList[0]
else:
return SumList[0] + listSum(SumList[1:]) | 6e4a5f9fe0a66251ca4b044e9b45bfab8c167112 | 658,296 |
import torch
def huber_loss(x, delta=1.):
""" Standard Huber loss of parameter delta
https://en.wikipedia.org/wiki/Huber_loss
returns 0.5 * x^2 if |a| <= \delta
\delta * (|a| - 0.5 * \delta) o.w.
"""
if torch.abs(x) <= delta:
return 0.5 * (x ** 2)
else:
return del... | b3493eb9d4e38fa36f92db80dc52a47c32caf3c9 | 2,143 |
def contains_incorrect_symbols(test_expr, target_expr):
"""Test if the entered expression contains exactly the same symbols as the target.
Sometimes expressions can be mathematically identical to one another, but
contain different symbols. From a pure maths standpoint, this is fine; but
in que... | cb6fd60437bd41211d6aa18baeb9ef6d47e5cf7c | 587,257 |
def zpn(z, c, n=2):
"""
nth order polynomial generating a beautiful set
Parameters
----------
z: Complex
scalar, vector or matrix to evaluate the function on elementwise
c: Complex
scalar, vector or matrix, the starting value(s)
"""
return z**n + c | 01cd6b19c5c8d62985ed6f06d4cc748635ef1602 | 114,664 |
from random import randint
def make_tuples(number_of_items: int, max_storage: int) -> list:
"""
This function will generate all of the possible tuples that the person
will be dealing with when trying to solve this challenge.
:param number_of_items: How many items we should generate.
:param max_storage: The maxi... | d8303ab679fb8d045f1f8d276edbf02807f7e01a | 281,841 |
import math
def image_rms_diff(src, dest):
"""Calculate the difference between two images using normalized RMS"""
total = 0
width, height = src.size
for x in range(width):
for y in range(height):
s_r, s_g, s_b, s_a = src.getpixel((x, y))
d_r, d_g, d_b, d_a = dest.getpix... | 71083659153ddd7f6c2ece0a985c413b3c95fed1 | 484,552 |
def get_headers_dict(base_headers: list[str]):
"""Set headers for the request"""
headers_dict = {}
for line in base_headers:
parts = line.split(':')
headers_dict[parts[0]] = parts[1].strip()
return headers_dict | a22a5f1cd5a6c47115ccd89a7d0165a9b262eda3 | 617,814 |
def dbdisconnect(connection) -> bool:
"""Close connection to SQLite-Database
:param connection:
:return: Result of success (true/false)
"""
if connection:
connection.close()
return True
return False | 6c5d17d14e898696885730ef86fad9eab03af02f | 14,889 |
def dict_to_scalamap(jvm, d):
"""
Convert python dictionary to scala type map
:param jvm: sc._jvm
:param d: python type dictionary
"""
if d is None:
return None
sm = jvm.scala.Predef.Map().empty()
for k, v in d.items():
sm = sm.updated(k, v)
return sm | 53319bc347f3a60ed36d6a74542ea7639725f6a3 | 195,966 |
def filter(question, answer):
"""Takes in tokenized question and answer and decides whether to skip."""
if len(answer) == 1:
if answer[0].text.lower() in ['true', 'false', 'yes', 'no']:
return True
return False | 662c24ecf450900f61629cdd2478e710224648dd | 529,130 |
def terminate(n,params):
"""Decide on whether to terminate current algo run or not
Parameters
----------
n: number of total evaluations have been conducted in current run
params: Params Class
parameters for moea/d
Returns
-------
boolean expression
True if ... | 39908fc2b53a078efdd27fab13dfb1121b262bd1 | 560,687 |
def get_attr_in_gmeta_class(model, config_name, default_value=None):
"""获取指定模型 GMeta 类中指定的属性
Params:
model class django 模型类
config_name string GMeta 类中配置项的名称
default_value 任何数据类型 默认数据
"""
gmeta_class = getattr(model, "GMeta", None)
if not gmeta_class:
return default... | 755a8cc5aeb5304106a940929e133be9d163797f | 571,714 |
def _format_data(data):
"""Return a list of strings given input data and formats."""
def to_str(x, fmt):
x = "" if x is None or x == "" else x
if isinstance(x, str):
return fmt.replace("g", "").replace("e", "").format(x)
else:
return fmt.format(x)
return [to... | d5ccc45d8f9411279d9ce0836060b938fc49456e | 438,715 |
def center_crop(img, dim):
"""
Crops the input `img` from center to a specific dimention specified
Args:
img (numpy.ndarray): Image which needs to be cropped
dim (tuple): Shape of the output image
Returns:
[numpy.ndarray]: Image croppepd to dim shape
"""
width, height ... | 04dfdbe14f3c9aaf9a97453448f2202cfa695eba | 352,821 |
def get_role(row):
"""
Extracts the role from a given row
:param row: Row to look at
:return: The role
"""
role = row[6]
# Normalize roles Lead Link and Rep Link, as they contain the circle name as well
if "Lead Link" in role:
role = "Lead Link"
if "Rep Link" in role:
... | 1bae4639eb70c362aa2577afc6cfac99bdfca847 | 213,703 |
def format_iso8601(obj):
"""Format a datetime object for iso8601"""
return obj.strftime('%Y-%m-%dT%H:%M:%SZ') | cc19062781e279a98392cb81b7f7826d0fbcda36 | 350,323 |
def get_file_name(path):
"""Get the file name without .csv postfix.
Args:
path: A string for the absolute path to the file.
Returns:
A string for the path without .csv postfix
"""
filename = path.strip('\n').strip('.csv')
return filename | d17a091b97c26fa9023a7e339301da4ab65c6d10 | 248,239 |
import re
def validate_account_to_int(account):
"""
Validates the the provided string is in valid AdWords account format and converts it to integer format.
:param (str, int) account: AdWords Account
:return: Account ID as integer
"""
account = str(account).strip().replace('... | e4ae287efde10a00d133fb0260acd06701abac0c | 171,189 |
def bucket_policy_document(bucket):
"""Return the policy document to access an S3 bucket
Parameters
----------
bucket: string
An Amazon S3 bucket name
Returns
-------
s3_policy_doc: dict
A dictionary containing the AWS policy document
"""
# Add policy statements to ... | 576cc838c89479b93d80e2348ef22cb53c63f751 | 253,456 |
from typing import List
import re
def extract_regex_pattern(section_list: List[str], pattern: str):
"""
Extract list of section names that match the specified regex pattern.
:param section_list: list of section names to search in
:param pattern: regex pattern to search for
:return: List of extrac... | 2ebbabb2c5004dcba25336a98b791487aaa6f369 | 470,772 |
def _geo_to_feature(ob):
"""
Return a GeoJSON Feature from an object that implements
__geo_interface__
If the object's type is a geometry, return a Feature with empty
properties and the object's mapping as the feature geometry. If the
object's type is a Feature, then return it.
"""
map... | cfa3ffb5cf5b3b75cb3a0cef770f9030fd068f74 | 524,191 |
def clamp(n, range):
"""
Given a number and a range, return the number, or the extreme it is closest to.
:param n: number
:param range: tuple with min and max
:return: number
"""
minn, maxn = range
return max(min(maxn, n), minn) | 57ad33151784f8f58fe35ea1e662dc4c2661d8aa | 497,772 |
import re
def text_preprocess(document):
"""
Basic text preprocessing
:param document: string containing input text
:return: updated text
"""
# Remove all the special characters
document = re.sub(r'\W', ' ', str(document))
# Substitute multiple spaces with single space
document = r... | a23dd541f66aae3de39c7624b916b6a7b5c0e1e7 | 613,892 |
def extrapolate_correlation(correlation_energies, cardinals, beta):
"""Extrapolates the correlation energy.
For more information, see Equation 2 in DOI: 10.1021/ct100396y.
Parameters
----------
correlation_energies : :obj:`tuple` (:obj:`float`)
The small (X) to large (Y) basis set correlat... | 4eaef76106628d31efb5e83bf354bc41610fdd8a | 468,916 |
def expense_by_store(transactions_and_receipt_metadata):
"""Takes a transaction df of expenses and receipt metadata and groups on receipt id, in addition to year, month and cat
input:
df (pd.DataFrame): dataframe of transactions to group and filter
returns:
df (pd.DataFrame): grouped datafra... | 59f5c00326dd5f91024557b57e82af5ad1a0bd92 | 667,220 |
def _get_vm_extension_list(vm_iv):
"""Iterate over a list of virtual machine extensions.
Arguments:
vm_iv (dict): Raw virtual machine instance view record.
Returns:
dict: List of names of installed extensions
"""
extensions = {}
extension_list = []
for e in vm_iv.get('exte... | bc70949091a1a463cf789f62f63dd89d19c7c7c6 | 349,176 |
def translate_topo_name(topo):
"""Translate the name of a topology as given by
the benchmarks into a meaningful printable variant.
"""
if 'adaptivetree-shuffle-sort' in topo:
return 'adaptivetree-optimized'
else:
return topo | ee1ec9123b8875ca0deb9ab159009b1bb4ba9590 | 584,951 |
def convert_text_to_tokens(data, base_vocab, tokenize_fn, custom_vocab={}):
"""
Converts sequences of text to sequences of token ids per the provided vocabulary
Arguments:
data (arr) : sequences of text
base_vocab (torchtext.vocab) : vocabulary object
... | d6930adc42ddecdfdf5ae8932c0202967a43ee7e | 426,062 |
def _match_to_tuple_index(x, tuple_list):
"""Apply function to see if passed fields are in the tuple_list"""
sid, ncesid, home_away = x
return (sid, ncesid, home_away) in tuple_list | 73a33bd357ee490db5f2fbf791d44acd8f93d9f7 | 522,225 |
import signal
def _signal_exit_code(signum: signal.Signals) -> int:
"""
Return the exit code corresponding to a received signal.
Conventionally, when a program exits due to a signal its exit code is 128
plus the signal number.
"""
return 128 + int(signum) | 050eee98632216fddcbd71e4eb6b0c973f6d4144 | 2,645 |
from datetime import datetime
def get_month(date):
"""
Converts string representation of date in form of 2018-11-10 as Nov-18
"""
return datetime.strptime(date, '%Y-%m-%d').strftime('%b-%y') | 5475c0a94aeb357b30553754deb42d2e7f30fc3c | 355,933 |
def jsonify(dataset, variable):
"""
Extract a time series from a THREDDS dataset at the given location.
Args:
dataset(xarray.Dataset): an xarray dataset.
variable(str): Name of the variable to query.
Returns:
dict: JSON-compatible Python Dict.
"""
str_time_da = dataset.... | 43205368dc364198fbe0bd7d888c47d6627906cd | 591,275 |
import re
def get_name_slug(name: str) -> str:
"""Get the stub of the organization's name.
Arguments:
name {str} -- Organization name.
Returns:
str -- Organization name stub.
"""
return '-'.join(re.split(r'\W', name.lower())) | ef3fce6346a7aabfcebcc6a6e72d1e718e0ed4d2 | 23,049 |
def dummy_lambda_event_get() -> dict:
"""
Return dummy GET request data.
"""
event_get = {
'year': '2011',
'month': '11',
'http_method': 'GET'
}
return event_get | 4c580fc7bf69686af0916afb57c501d4d70ef892 | 114,865 |
def get_maximum_overview_level(src_dst, minsize=512):
"""
Calculate the maximum overview level.
Attributes
----------
src_dst : rasterio.io.DatasetReader
Rasterio io.DatasetReader object.
minsize : int (default: 512)
Minimum overview size.
Returns
-------
nlevel: in... | 3166291ede393cf6682babccc2fc03c47e80c2f0 | 425,420 |
def difference_with(f, xs, ys):
"""Finds the set (i.e. no duplicates) of all elements in the first list not
contained in the second list. Duplication is determined according to the
value returned by applying the supplied predicate to two list elements"""
out = []
for x in xs:
if x in out:
... | 13304fc3b0a7335c5c30b7c16d35bec1e37ae7bd | 646,829 |
def args_with_source(frame_info, *args):
"""
Returns a list of pairs of:
- the source code of the argument
- the value of the argument
for each argument.
For example:
args_with_source(foo(), 1+2)
is the same as:
[
("foo()", foo()),
("1+2", ... | 9f966b1132a1677ccfa3e8c117f84b2f898adc46 | 317,847 |
def not_in_list(x,args,y):
"""
Check whether a string is in a list of hashtags
"""
list = x['caption'].split(' #')
return not (args in list[1:]) | 6c5dc0b2e1c8616220af8925525395cdf9515cd8 | 239,057 |
import itertools
def nwise(iterable, n):
"""
Iterate through a sequence with a defined length window
>>> list(nwise(range(8), 3))
[(0, 1, 2), (1, 2, 3), (2, 3, 4), (3, 4, 5), (5, 6, 7)]
>>> list(nwise(range(3), 5))
[]
Parameters
----------
iterable
n : length of each sequen... | 3481e3aa600ab9e561beafa670a652e4afc7b3cf | 345,740 |
def clean_label(label: str) -> str:
"""
Return a label without spaces or parenthesis
"""
for c in "()":
label = label.replace(c, "")
for c in " ":
label = label.replace(c, "_")
return label.strip("_") | 28178742069e56d991b49d6b254b1fdd6a87ea71 | 552,530 |
def GetInfobarIndexByType(test, infobar_type, windex=0, tab_index=0):
"""Returns the index of the infobar of the given type.
Args:
test: Derived from pyauto.PyUITest - base class for UI test cases.
infobar_type: The infobar type to look for.
windex: Window index.
tab_index: Tab index.
Returns:
... | b752ed26af54f373c00ce70cf0abd600a9bbac34 | 464,678 |
from typing import Tuple
def grid_cell_to_xy(pos: int, grid_size: int = 5) -> Tuple[int, int]:
"""Converts an integer from 0-24 into an (x, y) position."""
num_cells = grid_size * grid_size - 1
if not 0 <= pos <= num_cells:
raise ValueError(f'Grid cell does not exist in grid of size {grid_size}')
x = pos ... | cc0f2d57a5c119cc5a3184642f539e69f594ecc3 | 618,028 |
def _alloc_key(name):
"""Constructs allocation key based on app name/pattern."""
if '@' in name:
key = name[name.find('@') + 1:name.find('.')]
else:
key = name[0:name.find('.')]
return key | ca3182f52d780f94a6a18c51ad0b7d841ead20d1 | 700,778 |
def getAsciiFileExtension(proxyType):
"""
The file extension used for ASCII (non-compiled) proxy source files
for the proxies of specified type.
"""
return '.proxy' if proxyType == 'Proxymeshes' else '.mhclo' | cb2b27956b3066d58c7b39efb511b6335b7f2ad6 | 706,310 |
def _replace_match(text, match, replacement):
"""Expands a regexp match in the text with its replacement.
Args:
text: str. The text in which to perform the replacement.
match: re.MatchObject. A match object that applies to "text".
replacement: str. The string to replace the match wit... | a813704d4ed2d77d0f8150abe5e2917f22b93cb9 | 652,054 |
def create_dict_node_enode(set_proj_nodes, neighbors_dict, H, node, dict_node_enode, dict_enode_node):
"""
A function to create useful dictionaries to represent connections between nodes that are in the embedding and
nodes that are not in the embedding.
:param set_proj_nodes: Set of the nodes that are i... | da2b05648dd200f98e03d3483fd3e80b225a1ee9 | 677,191 |
def validate_item_name(name, prefix, suffix):
"""Verifies that ``name`` starts with ``prefix`` and ends with ``suffix``.
Returns ``True`` or ``False``"""
return name[: len(prefix)] == prefix and name[-len(suffix) :] == suffix | ce61dfc9ec97bceac6662f5bc26c758bfbc0d139 | 333,575 |
def indent_text(text: str, level: int = 0) -> str:
"""Indent each line of ``text`` by ``level`` spaces."""
return "\n".join([" " * level + line for line in text.split('\n')]) | aed5d814770836d062af1ddc0fae070e0dd0a611 | 291,233 |
from pathlib import Path
from warnings import warn
def git_rev(repo):
"""
Get the git revision for the repo in the path *repo*.
Returns the commit id of the current head.
Note: this function parses the files in the git repository directory
without using the git application. It may break if the ... | 877fa58bfeaadefc42920c2695af03117fe80fd3 | 616,431 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.