content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def unique_fitnesses(population: list) -> int:
""" Calculates the number of unique fitnesses in the population
Args:
population (list): The list of individual candidate solutions
Returns:
int: The number of unique fitnesses in the population
"""
fitnesses = [individual.fitness for ... | c0057c4e2874ca6ea586e999922ebcc633efb225 | 668,907 |
def YCoCgtoRGB(Y, Co, Cg):
""" convert YCoCg to RGB color
The YCoCg color model was developed to increase the effectiveness of the image compression.
This color model comprises the luminance (Y) and two color difference components
(Co - offset orange, Cg - offset green).
:param Y: Y value (0;255)
... | e73b7506b97da2112bf420ce20a988e20ef4628f | 235,344 |
import itertools
def nwise(iter, n):
"""
Like pairwise, except returns n-tuples of adjacent items.
s -> (s0,s1,...,sn), (s1,s2,...,s(n+1)), ...
"""
iterset = [iter]
while len(iterset) < n:
iterset[-1:] = itertools.tee(iterset[-1])
next(iterset[-1], None)
return zip(*iterset... | 30d781c3c07e68de5949d977f1e967b46096ed74 | 327,453 |
def generate_sorted_movie_vocab(movies_df, movie_counts):
"""Generate vocabulary for movies, and sort by usage count."""
vocab_movies = []
for movie_id, title, genres in movies_df.values:
count = movie_counts[movie_id] if movie_id in movie_counts else 0
vocab_movies.append([movie_id, title, genres, count]... | 17b325ad36cbbf73ef2cc4f7b1d5e9f1fbf7c4cc | 314,757 |
def del_fake_nums(intList, step): #8
"""
Delete fake numbers added by the fake_nums function (only used in decryption)
"""
placeToDelNum = []
for index in range(0, len(intList), step+1):
placeToDelNum.append(index)
newIntList = [item for item in intList]
for index in reversed(placeTo... | a8bc781b60bfef5441bb69046f3b3db5196767a5 | 685,315 |
def rgb_to_hex(r, g, b): # pylint: disable=invalid-name
"""
Convert numeric r, g, b color channels to a hex standard #RRGGBBAA color format.
Arguments:
- r - red channel in (0, 255).
- g - green channel in (0, 255).
- b - blue channel in (0, 255).
"""
return "#%02X%02X%02XFF" % (r, g, ... | d595eb60ad6b6ea9fd9db8afed3bd111acb6255c | 99,845 |
def get_normal_points(cx, cy, cos_t, sin_t, length):
"""
For a line passing through (*cx*, *cy*) and having a angle *t*,
return locations of the two points located along its perpendicular line at the distance of *length*.
"""
if length == 0.:
return cx, cy, cx, cy
cos_t1, sin_t1 = sin_... | 1f3188946d2ae9f7e50ec984b4135ac684ad7e7f | 519,654 |
def _parse_list_file(path):
"""
Parses files with lists of items into a list of strings.
Files should contain one item per line.
"""
with open(path, 'r') as f:
items = [i for i in f.read().split('\n') if i != '']
return items | 2c1203cd76e6b4382d8407d5d4197a2b8489f92a | 672,804 |
def is_int(data):
"""Checks if data is an integer."""
return isinstance(data, int) | f9cd4f0f5b3cd35573caf3bc86fc1f92cf6fa4a7 | 471,411 |
def psd_matern_12(omega, lam, lam_t):
"""Spectral density of Matern-1/2 process.
Args:
omega (tensor): Frequency.
lam (tensor): Decay.
lam_t (tensor): Scale.
Returns:
tensor: Spectral density.
"""
return 2 * lam_t * lam / (lam ** 2 + omega ** 2) | e348e116c84a43e6f70c7ff72e6f82487cf0e497 | 399,702 |
import re
def parse_AFINN(afinnfile_name):
"""
Parse the AFIN-111 sentiment file
Input: afinnfile_name: the [path/] file name of AFIN-111.txt
Output: dicts of:
sentiment_words: score
sentiment_phrases: score
Usage: from twitter_functions import p... | 2111252c62457811a6b178045e536b679ae0ac1f | 484,028 |
def filter_matching_fields(fields, other_fields):
"""return fields which are same as in other_fields list, ignoring the case"""
other_fields_lowercase = set([f.lower() for f in other_fields])
return [f for f in fields if f.lower() in other_fields_lowercase] | f8b0909e4872c0bc6b1212b8bd658debb38da922 | 646,802 |
import math
def get_points_distance(point1, point2):
"""
Gets the distance between two points
:param point1: tuple with point 1
:param point2: tuple with point 2
:return: int distance
"""
return int(math.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2)) | 40af84836715b49ba531fe5113e40230110d49b9 | 28,971 |
from functools import reduce
def solve(k, lim):
"""Find the <lim>th term of a Van Eck's sequence with initial values
<k>. """
seq = [*k]
nums = reduce(lambda a, b: a | b, [{n: i} for i,n in enumerate(seq)])
for i in range(len(k) - 1, lim):
res = nums.get(seq[i], i)
seq.append(i... | e9cf26c77d113e31ba21c90d8d482dcf8f66a4de | 540,532 |
def __find_service_account_in_message(message):
"""
The command "gcloud logging sinks create", communicates a service account Id as part of its message.
Knowing the message format, this function extracts the service account Id and returns it to the caller,
which will grant it with BQ per... | e791c81d62dae49b6298874dc194eda712e99857 | 50,967 |
def _create_element(parent, selenium_webelement):
"""Create an element from a Selenium webelement.
Parameters
----------
parent : browser or element
The browser or element.
selenium_webelement : Selenium webelement
The Selenium webelement.
Returns
-------
element
... | a5c80dfa8be8cea2b204f6961cb9ddaf24fd1713 | 397,650 |
import re
def _remove_environment(text, environment):
"""Removes '\\begin{environment}*\\end{environment}' from 'text'."""
return re.sub(
r'\\begin\{' + environment + r'\}[\s\S]*?\\end\{' + environment + r'\}',
'', text) | 2e77f53fa482b78252a53c5c7a9764ae6991646a | 525,437 |
def erase(string_letters: str, string_index: int) -> str:
"""Return the string_letters with the character at the string_index removed
if the string_index is between range 0 and the last string_index.
Otherwise return the original string_letters unchanged.
>>> erase('assignment', 4)
'assinment'
... | 030a08f4131562b7eb3d5d640a0f5172bc4a2ec2 | 407,646 |
def get_units_title(unit_type):
"""
Get the title for units
"""
units_title = "m"
if unit_type == 'english':
units_title = "ft"
return units_title | d032f50661ad42aed97aff7f2b19ebb9d8ebc366 | 639,060 |
def validate_request(raw):
"""Checking for exists of 'action' and 'time' in request."""
return True if 'action' in raw and 'time' in raw else False | a8d612508e8f97b15186b2265e029c67711d106a | 590,124 |
def to_base(n, base):
"""Transforms an integer to another defined base."""
len_base = len(base)
if n < len_base:
return base[n]
else:
return to_base(n // len_base, base) + base[n % len_base] | dfca71b16c1ed468345b096a720674c1277b0d77 | 421,020 |
def compound_inv_query(query, rel, dst):
"""
Create a compound inverse query, similar to
:meth:``compound_fw_query`` but only selects the
source nodes given a destination node.
:param query: The SQL subquery.
:param rel: The relation.
:param dst: The destination node.
"""
smt = 'SEL... | 459175805de1e3a35e3c6af5cdec6090c4df9618 | 378,335 |
def sos_gradient(params):
"""Calculate the gradient of the sum of squares function."""
return 2 * params["value"].to_numpy() | 7a16dde8638b397c8caabd0f359bc6ca0e477216 | 679,186 |
def coord_to_index(width, x, y):
"""Return the 1D index which corresponds to 2D position (x, y).
Examples:
If we have a 2D grid like this:
0 1 2
3 4 5
6 7 8
We can assert that element 8 is of the coordinate (2, 2):
>>> 8 == coord_to_index(3, 2, 2)
True
"""
... | b816f83dd21ffed44cbffbf6f26da55b702c5c62 | 339,401 |
from typing import List
def _parse_online_cpus_string(raw_string) -> List[int]:
"""
Parses string returned by /sys/devices/system/cpu/online
and returns a list of online cores
"""
parsed_cpus_info = []
for nr in raw_string.split(','):
if '-' not in nr:
parsed_cpus_info.appe... | d0932b855a6211cab6ef032d4ade8661fd23e3ee | 631,086 |
def is_odd(number):
"""
*Determine if the number is odd or not*
**Key Arguments:**
- ``number`` -- number to be tested for 'odd'ness
Returns:
- True or False -- depending on whether the arugment is odd or even
"""
if number % 2 == 0:
return False
else:
return True | 13357aa168317785833fb2183c7361fe943fda02 | 330,686 |
def get_category_name(text: str) -> str:
"""
Generate a category name.
Capitalise the first letter of every word.
Replace any `-` with a space.
Args:
text {str} The text value to parse
Returns:
{str} The parsed text
"""
return text.title().replace('-', ' ') | e9f2bd0bfe83e3594231408b61e59d5142688fd4 | 311,335 |
def format(dt):
"""Returns date in YYYYMMDD format."""
return dt.strftime('%Y%m%d') | 06c0823dfc593be0ed5b441640c82aa1eb3edea7 | 575,522 |
def get_form_choices(registration_question):
"""Takes a RegistrationQuestion object and returns a list of
properly formatted choices for a ChoiceField. Namely, a list of
tuples.
"""
raw_choices = registration_question.question_choice_set.all()
return [(str(rc.id), rc.choice) for rc in raw_choice... | 486c41e70c4cfb639180b51a789e638a0ddee3f8 | 446,856 |
def fafn2fqfn(fafn):
"""return a FASTQ file name which corresponds to a FASTA file."""
if fafn.find('.') != -1:
return fafn[:fafn.rfind('.')] + ".fastq"
else:
return fafn + ".fastq" | 13c18005b38b0686c3bca690f974d4547bba50ac | 217,979 |
def is_hex_string(string):
"""Check if a string represents a hex value"""
if not string.startswith("0x"):
return False
try:
int(string, 16)
return True
except ValueError as _:
return False | ad237a1add58e93abcb65a0048a2e28c56ac2e9d | 557,360 |
from typing import List
def centered_average(lst: List[int]) -> float:
"""Returns a centered average, an average that excludes the largest and
smallest number in a list, of a user-input list.
>>> centered_average([-145, 2, 2, 145])
2
>>> centered_average([1, 3, 8, 2, 25])
3
"""
avg = ... | 9b55970e32eeeb764912945b9a0103b4f6ceae08 | 493,740 |
def sort_by_length(arr):
"""
Takes an array of strings as an argument and returns a sorted array containing the same strings, ordered from
shortest to longest.
:param arr: an array of strings.
:return: array sorted from shortest to longest.
"""
return sorted(arr, key=len) | f25b631cc4444d0f05567ab72094618e0a1c5b8d | 494,533 |
import six
def column_info(df):
"""Returns a list of columns and their datatypes
Args:
df (`pandas.DataFrame`): The dataframe to get info for
Returns:
:type:`list` of :type:`dict`: A list of dicts containing column ids and their
Dtypes
"""
column_info = []
for co... | ea1652133b976d529e6440cdcb2f397c1b3109bc | 671,936 |
import six
def quote_cmd(cmd):
"""
Takes a shell command *cmd* given as a list and returns a single string representation of that
command with proper quoting. To denote nested commands (such as shown below), *cmd* can also
contain nested lists. Example:
.. code-block:: python
print(quote... | 63ad2441376cac43aa7e4865a6832ee42b485e3d | 296,561 |
def read_add_mos_args(add_mos_result, get_opt_args=False):
"""
:param add_mos_result: result from add_mos
:param get_opt_args: if there is opt_args_function, an array of opt_args will be return as well
:return: array of key_args and opt_args
"""
key_args = []
opt_args = []
for i in add_m... | db8926315eb4b01e5d154d0c742cc488f16f0f3b | 128,291 |
def add_collapse_mapped_isoforms_io_arguments(arg_parser):
"""Add arguments for collapse isoforms."""
helpstr = "Input uncollapsed isoforms in a FASTA, FASTQ or ContigSet file."
arg_parser.add_argument("input_isoforms", type=str, help=helpstr)
helpstr = "Input SORTED SAM file mapping uncollapsed isofor... | 8c882bbbce8ce593c4665242af12a12011c358cf | 539,825 |
def threshold_mean(img, thresh_multiplier=0.95, color1=255, color2=0):
"""Threshold a greyscale image using mean thresholding."""
mean = img.mean()
ret = mean * thresh_multiplier
img[img > ret] = color1
img[img < ret] = color2
return img | 65a4779264bcd068dd1661431f70a6d7f3402eef | 100,575 |
import re
def __camel_to_snake(string):
"""Turn a CamelCase string to a snake_case string"""
string = re.sub(r'(?<!^)(?=[A-Z])', '_', string).lower()
return string | 2d17191228ab5124d2370a9637f9a7356afbd9b5 | 204,200 |
def _wildcard_dih(atoms, idxs):
"""
Given atoms and idxs which define a
pattern return a tuple consisting of
a entry from atoms if the pattern is
an int and else the value in idxs.
"""
atom_key = []
for idx in idxs:
if type(idx) is int:
atom_key.append(atoms[idx])
... | 44d1849de43c6b35e13e7c8da7bba746cb4d2910 | 473,736 |
def get_key_from_dimensions(dimensions):
"""
Get a key for DERIVED_UNI or DERIVED_ENT.
Translate dimensionality into key for DERIVED_UNI and DERIVED_ENT
dictionaries.
"""
return tuple(tuple(i.items()) for i in dimensions) | c1eb93fa2dcd7783328581d808dde1a12e7a539f | 406,477 |
def ach(structure, fields):
"""Get field from achievements structure."""
field = fields.pop(0)
if structure:
if hasattr(structure, field):
structure = getattr(structure, field)
if not fields:
return structure
return ach(structure, fields)
retur... | d9b90f240cd3bee890831e4af43139c94ebc00b3 | 446,956 |
def parts(sequence, n):
"""Split a sequence into parts with size n."""
return [sequence[i : i + n] for i in iter(range(0, len(sequence), n))] | 7d42f6a36d3975431aa40c2dfcb5e7e2cb036081 | 199,502 |
import re
def space_to_dash(text):
"""Replace spaces with dashes."""
return re.sub("\s+", "-", text) | ba1191a6f7470ceb53d14f7d5e5775fe54c031ea | 502,573 |
def chunked(xs, chunk_size):
""" Splits a list into `chunk_size`-sized pieces. """
xs = list(xs)
return [
xs[i:i + chunk_size]
for i in range(0, len(xs), chunk_size)
] | 57f5379edfda7f4b7ae63412d13deb19e611cbc1 | 227,587 |
def to_pass(line):
# The MIT License (MIT)
#
# Copyright (c) 2019 Michael Dawson-Haggerty
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the "Software"), to deal in the Software without restriction,
... | f7210ea18fa44d6e1e801ab7909f48e2a0e9a2cd | 55,698 |
import json
def read_instance(filename):
"""Function to read an instance file from test data
Args:
filename (str): Path to file for instance
"""
with open(filename) as f:
data = json.load(f)
network_data = data["graph"]
num_vehicles = data["numVehicles"]
return ne... | e16a1cf9c8905031785005420ae399823ab91a64 | 545,863 |
def calculate_mag(raw_val):
"""
Converts the raw value read from the magnetometer.
Currently does not take calibration into consideration.
"""
result = raw_val * 2 / ((2**15) - 1)
return result | 1ca9fe469bd0921426f316356fb203868351ed0c | 302,883 |
from re import X
def compVertical(p1, p2):
"""Compare according to X coordinate for vertical partitioning."""
return p1[X] - p2[X] | 3e218925c0289f0c2d011208ce0f0f2a1c46e8b4 | 342,247 |
def polynomial5(x, p0, p1, p2, p3, p4):
"""
5th order polynomial
"""
return p0 * x + p1 * x ** 2 + p2 * x ** 3 + p3 * x ** 4 + p4 * x ** 5 | 3ef7a2e0ba57567b6a18202478c2d5befc200a67 | 221,448 |
import shutil
def check_space_requirements(new_files, changed_files, remove_files, output_path):
"""
Given lists of new files, changed files, and files to delete, this checks that the drive these file changes
will be made on will be able to hold all the new files.
:param new_files: A list of new files... | 784b16aa816bee4f40780482bb529c4024f8c2ee | 336,756 |
def get_num_labels(labels_or_logits):
"""Returns the number of labels inferred from labels_or_logits."""
if labels_or_logits.get_shape().ndims <= 1:
return 1
return labels_or_logits.get_shape()[1].value | 21f3067250f88d1b6ed50fe043cb873b57c13491 | 508,134 |
from typing import Dict
from typing import List
def annotation_inside_slice(annotation: Dict, slice_bbox: List[int]) -> bool:
"""Check whether annotation coordinates lie inside slice coordinates.
Args:
annotation (dict): Single annotation entry in COCO format.
slice_bbox (List[int]): Generate... | 01168edc86c436ce878df4fc551094ab03f1b30a | 195,446 |
def PresentValue(future_amount, interest_rate, periods):
"""Returns the present value of some future value.
interest rate: as a value (ie, 0.02 is the value for 2% per period)
periods: total number of interest payments which will be made
For more, see https://en.wikipedia.org/wiki/Present_value
"""
return... | 8943c84df58194d590e2cd5c7fd2f257346c072a | 146,820 |
from pathlib import Path
def find_files(src_path: Path, glob_pattern: str) -> list[Path]:
"""
Returns a list of path objects to the files matching the glob pattern.
Searches in `src_path`
"""
files = src_path.glob(glob_pattern)
paths = [Path(file) for file in files]
return paths | 32a1428a33f4a98a46c4a21a64b2653bdf673657 | 590,882 |
def calc_peak(motion):
"""Calculates the peak absolute response"""
return max(abs(min(motion)), max(motion)) | 2a49b2c454c204ab27097eae4617c000c6fea7df | 372,784 |
def as_stars(value):
"""
Convert a float rating between 0 and 5 to a CSS class
The CSS class name is the number of stars to be displayed.
* Rounds to the nearest integer
* Maps no rating to 0 stars
* Fails quietly
"""
num_stars_to_class = {
0: '',
1: 'One',
2: '... | 4572a7e580154d6c382e67e97bb3f47b3c8d505c | 432,708 |
from bs4 import BeautifulSoup
def strip_html(html):
"""Returns the text only out of any potential HTML content."""
if not html:
return html
soup = BeautifulSoup(html, "html5lib")
return soup.text.strip() | ca08a9e102a440a783dddfc78e2ca19c5a6ae20e | 217,112 |
def details(client, domain_id):
"""
Get domain details by reference.
"""
return client.domain.details(uuid=domain_id) | a41b45c7a343277fe5fa9345976b5d5d21964415 | 384,239 |
def components_contain_id(components_data, component_id):
"""
Tests whether component_id is id of component.
:param components_data: list of components
:param component_id: id of component
:return: True if component_id is component
"""
for component in components_data:
if component_... | 2ec77f1a5502d90b899475a94924daf5e57d9c15 | 476,048 |
def _scale_to_fit(width, height, max_width, max_height):
"""scales input dimensions to fit within max dimensions"""
height_scale = height/max_height
width_scale = width/max_width
scale = max(height_scale, width_scale)
if scale > 1:
height /= scale
width /= scale
return width, hei... | 6c604b291882101d00c98f9410a318f6eb32383a | 472,688 |
def to_list(argument):
"""
Gets and converts the argument to list type if it's not the type of list.
Args:
argument (str/list): String or list of string.
Returns:
list: A list of strings.
"""
if type(argument) is not list:
return [argument]
... | af984c6f146a6d84e7c38d09b1434aa2e5300ba3 | 265,258 |
def make_filebody(number_of_lines: int) -> str:
""" Return a string representing the contents of a file with a given number of lines.
Only used for testing purposes.
"""
body = ''
for i in range(0, number_of_lines):
body += '{n}/{c}: line\n'.format(n=i, c=number_of_lines)
return ... | 928429e745495d9cbc407e24ce84c59a45596f53 | 240,815 |
def stmt_from_rule(rule_name, model, stmts):
"""Return the source INDRA Statement corresponding to a rule in a model.
Parameters
----------
rule_name : str
The name of a rule in the given PySB model.
model : pysb.core.Model
A PySB model which contains the given rule.
stmts : lis... | 1defd6b6f4f013c3ae5fc41bbda6e271fb6b4d0d | 670,400 |
def concatenateToken(tokens):
"""
Concatenate the n-grams into a single string taking
into account the number of occurrences.
It is needed because the models works on String only.
:param tokens: Map of n-grams occurrences
:type tokens: {Int:{String:Int}}
:return: Co... | df3132faf095bdb187248e9f0d275b8599e861d3 | 512,836 |
from warnings import warn
def deprecated(message):
""" Decorator for deprecating functions and methods.
::
@deprecated("'foo' has been deprecated in favour of 'bar'")
def foo(x):
pass
"""
def f__(f):
def f_(*args, **kwargs):
warn(message, category=Dep... | 9ef7c6757556d7b41684e9cf908104924397c561 | 361,297 |
def file_to_dataset(file):
"""Example function to derive datasets from file names"""
if "ZJet" in file:
return "Z"
elif "WJet" in file:
return "W"
elif "HToInvisible" in file:
return "Hinv" | 4e759054df3889e3d6f1ca1b0d3ed080f035d233 | 32,303 |
def gettext(element):
"""Returns the atcual content of a leaf element as a text string."""
return '.'.join([node.data for node in element.childNodes
if node.nodeType == node.TEXT_NODE]) | 9124ff6f478c0d297d74c985124a06f895dc2874 | 183,856 |
def split_factory2(delimiter: str = ',', cast_to: type = list):
"""
Separates a text by a specific delimiter into separate sub-lists.
Returns a FUNCTION that can then process the text accordingly.
It DOES NOT ignore whitespaces.
*-------------------------------------------------------------*
E... | 3e5683a751ecde8768d6b8b0ecb3ad37c0effe60 | 75,304 |
import logging
def process_covid_csv_data(covid_csv_data:list) -> tuple:
"""Returns cases in last 7 days, current hospitalisations,
and total deaths from parsed covid csv data"""
if not covid_csv_data:
logging.error("No csv data was inputted")
return 0, 0, 0
#Builds a 2D list of the ... | a9705af0877e112f0830daeb7fad17ba7832a640 | 526,060 |
def one_text_header(response, header_name):
"""
Retrieve one text header from the given HTTP response.
"""
return response.headers.getRawHeaders(header_name)[0].decode("utf-8") | afc4b3bba143a092173a935ede77ff8ecec6d7e3 | 18,303 |
def Claret_LD_law(mu, c1, c2, c3, c4):
"""
Claret 4-parameter limb-darkening law.
"""
I = (1 - c1*(1 - mu**0.5) - c2*(1 - mu) - c3*(1 - mu**1.5) - c4*(1 - mu**2)) * mu
return I | 535136e560dba26da012b9d13d7edcc3b507ec54 | 38,933 |
def get_times(dt):
"""
Converts seconds into hours, minutes and seconds
:param dt: The time in seconds
:type dt: float
:return: hours, minutes and seconds
:rtype: int, int, float
"""
mins = (dt - dt % 60) / 60
dt = dt - 60 * mins
hours = (mins - mins % 60) / 60
mins = mins - ... | 0ed7e1582e5c6366e827a434dd900abe6fadd254 | 144,810 |
def format_attachments(attachments=[]):
""" Return formatted_attachments for volume config """
formatted_attachments = []
for attachment in attachments:
formatted_attachment = {
'attach_time': str(attachment.get('AttachTime')),
'instance_id': attachment.get('InstanceId'),
... | 0b2b292ceb8a7273eda2ba8a2297929d8030d7bf | 513,716 |
import torch
def complex_multiplication(a, b):
""" Computes element-wise complex-tensor multiplication.
Args:
a and b: multiplication operands (tensors of complex numbers). Each
tensor is in (batch x channel x height x width x complex_channel) format,
where complex_channel contains the real and i... | c0a67750e7e0d0d53317f5736ede637e658e28fb | 173,212 |
def create_annotation(args, imname, pred_mask, class_id, score, classes, is_valid = True):
"""Creates annotation object following the COCO API ground truth format"""
ann = dict()
ann['image_id'] = imname
ann['category_id'] = class_id
ann['category_name'] = classes[class_id]
# if the mask is al... | e16f626af65a84a844df19aeff2c6710fc98d204 | 192,267 |
import struct
def binary_format(encoding_size):
"""
Return a Struct instance with the binary format of the encodings.
The binary format string can be understood as:
- "!" Use network byte order (big-endian).
- "I" store the entity ID as an unsigned int
- "<encoding size>s" Store the n (e.g. 1... | 6ad6613ac1b62b69ff74a75f0181f5db9a4791fa | 141,712 |
def mock_email_backend(mocker, backend_settings):
"""Fixture that returns a fake EmailAuth backend object"""
backend = mocker.Mock()
backend.name = "email"
backend.setting.side_effect = lambda key, default, **kwargs: backend_settings.get(
key, default
)
return backend | adfddf86713418255690a15b6a2b28ed88585b82 | 424,624 |
def _calculate_cut(lemmawords, stems):
"""Count understemmed and overstemmed pairs for (lemma, stem) pair with common words.
:param lemmawords: Set or list of words corresponding to certain lemma.
:param stems: A dictionary where keys are stems and values are sets
or lists of words corresponding to tha... | a0d2bc7709237f425516e7930e6d34dc1cff4de5 | 213,870 |
def proba_func(threshold):
"""To associate an alpha to an empirical distribution function.
Parameters
----------
threshold : float
The threshold of the target probability.
Returns
-------
p_func : callable
The probability function.
"""
def p_func(x, axis=1):
... | 4e8a079d8cd8157de82afc3b2dc40227090209e6 | 249,859 |
import random
def qty_discrimination(list_of_numbers):
"""Choose which value, "a" or "b", is greater.
Pass in a list of int values to compare.
:param list_of_numbers: List of ints to compare,
usually provided as range()
:return: String of "correct" or "incorrect" to be use... | 0ea7daebf75e6ea63f8ec9cc96650d870c0f0303 | 191,349 |
import re
def is_valid_version(v):
""" Check if a string is a valid version
>>> is_valid_version('20180525-1202')
True
>>> is_valid_version('20180525')
False
>>> is_valid_version('201805251221')
False
"""
if re.match('\A\d{8}-\d{4}\Z', v):
return True
return False | 7dfd30de4e4d67c81bf9cf788df26839938ef88e | 193,570 |
def has_replication_policy(sysmeta_pyxb):
"""Check if SystemMetadata has ReplicationPolicy section.
Args:
sysmeta_pyxb: SystemMetadata PyXB object
Returns: bool
``True`` if SystemMetadata includes the optional ReplicationPolicy section.
"""
return bool(getattr(sysmeta_pyxb, "repli... | 870e1abed4905842d13ddef6e8fd26729dc762b7 | 590,637 |
def _read_file(filename: str) -> str:
"""
读取文件的内容，并将文件中的制表符、换行符以及中文换行符替换为空字符。
:param filename:
:return:
"""
with open(filename, mode="r", encoding="UTF-8") as reader:
"""
1.不间断空格\u00A0,主要用在office中,让一个单词在结尾处不会换行显示,快捷键ctrl+shift+space ;
2.半角空格(英文符号)\u0020,代码中常用的;
3.... | bf73a087e350972d30cc38b249affed935794b4c | 205,634 |
def _ss(data):
"""
MicroPy doesn't have statistics library, so we need this
Return sum of square deviations of sequence data.
"""
c = sum(data) / len(data)
ss = sum((x - c) ** 2 for x in data)
return ss | 3a5e833fbbbc4a64f06fd30d3464331d308d7609 | 203,061 |
def lazy_property(func):
"""Decorator that makes a property lazy-evaluated"""
attr_name = "_lazy_" + func.__name__
@property
def _lazy_property(self):
"""Function for property lazy-evaluate decorator"""
if not hasattr(self, attr_name):
# The attr doesn't exist yet, so call t... | 04b5262135a075441f32dff186a785574b4cad55 | 142,191 |
def rpad(ls, size, val):
"""Right-pads a list with a prescribed value to a set length."""
return ls + (size - len(ls))*[val] | 9cbc1a2e925efd90c75ead2a108ff19436441682 | 685,809 |
def fix_ncesid(ncesid, mode):
"""
Applies standard formatting (zero padding and typecasting) to
both schools' and districts' NCES IDs.
Args:
ncesid (int): Target NCES ID to fix (e.g. 100005).
mode (str): Should be either "school" or "district".
Returns:
str: Standardi... | 02d0db477039ef30beefff5470ec3781de9fc052 | 684,766 |
import calendar
def get_timestamps(series):
"""
Create a timestamp for every created_at date and set the seconds to zero.
"""
return [1000 * calendar.timegm(d.created_at.replace(second=0).timetuple()) for d in series] | 5f7149568c8183bee85b5588c3a925adcbbaf4d5 | 267,611 |
def drop(n, xs):
"""
drop :: Int -> [a] -> [a]
drop(n, xs) returns the suffix of xs after the first n elements, or [] if n >
length xs
"""
return xs[n:] | e9261686022f5419edade3b47e82c68bd52b5cd8 | 697,737 |
from typing import Tuple
def split_off_address(line: str) -> Tuple[str, str]:
"""Split e.g. 'beqz $r0,1f0' into 'beqz $r0,' and '1f0'."""
parts = line.split(",")
if len(parts) < 2:
parts = line.split(None, 1)
if len(parts) < 2:
parts.append("")
off = len(line) - len(parts[-... | 8c86eb4f02f0cb51e583099a1d37a86ec748cac8 | 279,979 |
def zzx_neg(f):
"""Negate a polynomial in Z[x]. """
return [ -coeff for coeff in f ] | c813597dc9540c8d85221352da10db894de4aa4c | 18,877 |
def filter_packages(packages: list, key: str) -> list:
"""Filter out packages based on the given category."""
return [p for p in packages if p["category"] == key] | 46f11f5a8269eceb9665ae99bdddfef8c62295a2 | 705,075 |
import re
def removeHex(text):
"""Remove hex from a string"""
text = text.encode().decode('unicode_escape')
return re.sub(r'[^\x00-\x7f]',r'', text) | bc3c779143171b1f0fb121181c029fd04978fd2a | 195,031 |
def nearest_point_on_line(point, line):
"""Return the nearest point on a line
"""
return line.interpolate(line.project(point)) | e100855ea775c43d54bc9e4256c9757386444ee6 | 572,228 |
def group_names(groups, group_id):
"""
Return English and Arabic names of group (either Office or Subconstituency) with matching id,
or None if not found.
"""
for g in groups:
if g['code'] == group_id:
return g['english_name'], g['arabic_name'] | 8f26f641c9f99a6d813e550751735eaf36f563f3 | 232,575 |
def analyze_headers(headers):
"""Gets the list of TMT channel headers."""
# look for reporter ion channels
channels = [c for c in headers if c.startswith('Abundance')]
if not channels:
channels = [c for c in headers if (c.startswith('12') or c.startswith('13'))]
if not channels:
prin... | 71898d9e6c07b429bea38339962ff489581f1c24 | 463,506 |
def load_file(filepath):
"""Helper function to read a file and return the data."""
with open(filepath, "r") as resume_file_handler:
return resume_file_handler.read().lower().split() | 878755a9897daf5ea24322f84c992fb08cb91524 | 329,366 |
def format_str_to_nba_response_header(s: str):
"""
Formats a string into NBA response column header format.
stats.nba response columns are made into ANGRY_SNAKE_CASE
format when they are parsed from json.
>>> format_str_to_nba_response_header('game_date')
'GAME_DATE'
>>> format_str_to_nba_... | 43d246668e940b208e36b631434b04e33358641e | 455,441 |
import re
def extract_regexp_groups(regexp,string):
"""
returns all matched groups from string usign given regular expression
NB: regexp must be provided with group names (?P<group>)
"""
valid = re.match(regexp, string)
if valid:
return valid.groupdict() | aa6cb38eb3eb2e4616ecd85a6a85c2ad0c7e3c36 | 278,452 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.