content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
import re
def request_url_to_fixture(url: str):
"""Convert a URL path to a fixtures filename ('/account/events' -> 'account_events')"""
params = url.split('?')
return '_'.join([param for param in re.split('/|-', params[0]) if param != '']) | 0b20c02cf804c55de6697f58e61ab5390dad9125 | 574,211 |
def match_inner(x, y, i, j):
"""
Match whether the token is inside the entity
:param x: The start of the entity
:param y: The end of the entity
:param i: The start of the token
:param j: The end of the token
"""
return x <= i and y >= j | 9119e26aab7780f85e4881728c1c2419edd04b00 | 345,703 |
def rad_to_deg(theta_rad):
""" Convert radians to degrees. """
return theta_rad * 57.2957795 | abee5d77b9d0e9d3bf1c2a103b33e684a25a4ee2 | 133,594 |
def ctx(app, request):
"""Push a new application context and closes it automatically
when the test goes out of scope.
This helps to avoid creating application contexts manually
either by calling app.app_context() with python `with` statement or
by pushing or popping manually.
"""
ctx = app.... | 49292e4a56d89828101a9c6f675dff67c610f531 | 329,422 |
def inpath(entry, pathvar):
"""Check if entry is in pathvar. pathvar is a string of the form
`entry1:entry2:entry3`."""
return entry in set(pathvar.split(':')) | 911c168d8bfab913e000f0286571b7e16813e970 | 109,853 |
def dont_give_me_five(start: int, end: int) -> int:
"""This function returns the count of all numbers except numbers with a 5."""
count = 0
for item in range(start, end+1):
if '5' not in str(item):
#print (item)
count += 1
return count | 83d1fe6bebba342df608b51e2a59476c0978f0d2 | 604,440 |
def format_bool(boolean: bool) -> str:
"""Convert a boolean to a string."""
return "\N{BALLOT BOX WITH CHECK}" if boolean else "" | 7d2b792430cebd1240664911a4a18757973fca0d | 372,313 |
def _Lentz_Dn(z, N):
"""
Compute the logarithmic derivative of the Ricatti-Bessel function.
Args:
z: function argument
N: order of Ricatti-Bessel function
Returns:
This returns the Ricatti-Bessel function of order N with argument z
using the continued fraction technique... | c34905103535b5c84a8c8df543f47ad838fe1cf1 | 97,715 |
def equivalent(list1, list2):
"""Ensures that two lists are equivalent, i.e., contain the same items."""
if len(list1) != len(list2):
return False
set1 = set(list1)
for item in list2:
if item not in set1:
return False
return True | 2a14eab905143bd7549e5e8edc6242ea78351c46 | 277,878 |
def geo2pix(geo_transform, xcoord, ycoord):
"""
Computes the indexes of the pixel in the image array corresponding to a point with given coordinates in the
spatial reference system.
"""
xpix = int((xcoord-geo_transform[0])/geo_transform[1])
ypix = int((ycoord - geo_transform[3]) / geo_transform... | baecc3894621168c7bd201495795530779fab840 | 315,712 |
def add_dict(field, dict_of_values):
"""
Add a given dict of values to a given array field.
"""
def transform(element):
assert isinstance(element[field], dict), \
"add_dict called on a non-dict object. type(element[%s]) = %s" % (field, type(element[field]))
element[field].upd... | b565263578750845ae2a423141078783cd99b05c | 588,982 |
def d11_2_A11(d11, SRM_ratio=4.04367):
"""
Convert Delta to Abundance notation.
Default SRM_ratio is NIST951 11B/10B
"""
return SRM_ratio * (d11 / 1000 + 1) / (SRM_ratio * (d11 / 1000 + 1) + 1) | 04f3a1a58356d27328e315494a04c78b8ddae9ec | 369,170 |
def accuracy(letters, target_string):
""" Comparing accuracy to the correct answer.
Args:
letters(np.array): (num_chars, )
target_string(str)
Return:
float: accuracy.
"""
count = 0
assert len(letters) == len(target_string)
for i in range(len(target_string)):
... | 5898a086997d3b9ff9f9bcf84b747dd553a0e4cb | 703,404 |
def is_comment(line, comments):
"""
A utility method to tell if the provided line is
a comment or not
Parameters
----------
str line: The line string in a file
list comments: A list of potential comment keywords
"""
return line.lstrip(' ')[0] in comments | 7c4dc2fdd6efad35a216562e9655db42cc1f9d7b | 353,753 |
def is_in_interval(num1: float, num2: float, frac: float = 0.1) -> bool:
"""Check that the num1 is in the interval defined by num2 and its fraction."""
num2_frac = num2 * frac
_min = num2 - num2_frac
_max = num2 + num2_frac
return _min <= num1 <= _max | b11e00be2d2346ddeea08b5fe789db4f09ee568a | 590,002 |
def decipher(
ciphertext: str,
key: list[int],
/,
) -> str:
"""
Decrypts ciphertext encrypted by columnar transposition cipher using supplied key.
IMPORTANT: We assume that the text is padded so that length of ciphertext is a multiple of key length
"""
if len(ciphertext) % l... | 4c818a68e4d60103a91ac3e8d7ab15a0b11bab09 | 524,501 |
def encode_special_characters(string: str) -> str:
"""Make string safe for urls as required by REST APIs"""
char_mapping = {"#": ";23", "&": ";26", "/": "|", "*": ";2A"}
for char, encoded_char in char_mapping.items():
string = string.replace(char, encoded_char)
return string | 0d016c5fdb6013bbcb8b8e3ff1dbfb3205298590 | 89,478 |
def get_params(model, only_trainable=False):
"""
Get the parameter number of the model.
If only_trainable is true, only trainable parameters will be counted.
"""
if not only_trainable:
return sum(p.numel() for p in model.parameters())
else:
return sum(p.numel() for p in model.pa... | b6c3b92b5ed32a1a38149669c43ae74127945c9f | 521,461 |
from pathlib import Path
def find_parent_directory_containing(filename, path=None):
"""Find a directory, on the path to 'path' containing filename
if no 'path' - path from cwd
Returns None if no such found, pathlib's Path to the directory if found
"""
if not path:
path = Path.cwd()
el... | f5fa21d6a03710bdd050aa14266fdc84ab84ca58 | 345,974 |
import asyncio
async def measure_response_time(session, url):
"""
Fetching an url by performing GET request. Measure the response time.
:param aiohttp.ClientSession session: All requests in one session, for connection pooling.
:param str url: Full URL for request.
:return dict: Dict containing mea... | 7442b4cb16df8eef25169558af9f3a779f0ccc98 | 571,460 |
def contrasting_text_color(hex_str: str) -> str:
"""Get a contrasting foreground text color for specified background hex color
:param hext_str: A hex string color ('#XXXXXX') for which to determine a black-or-white
foreground color.
:return: '#FFF' or '#000'.
"""
r, g, b = (hex_str[1:3], he... | f9901a07e29bd1a55fedfc9cf4035670b88b8609 | 322,530 |
def GMLPointList(point):
"""Translates the list of coordinates of one point to a string representation (GML)."""
x = point[0]
y = point[1]
z = point[2]
return "%s %s %s" % (x, y, z) | bc17b41e74ae42db8bb1475376c352a39e1d946d | 401,739 |
from datetime import datetime
def new_returntime(value=None):
"""Convert the value to datetime."""
if value is None: return None
return datetime.fromtimestamp(value) | aa5aa995c1e78f8e7002651fe5e15da776750185 | 256,940 |
def _atomReprAsInt(s: str) -> int:
"""Translate CLVM atom repr to int."""
if s.startswith("0x"):
return int(s, base=16)
elif s.startswith('"'):
return int.from_bytes(s[1:-1].encode("ascii"), "big")
return int(s) | 0fc8cf80b719e38b0d520fc415331978f036afa0 | 105,077 |
def d_sig(f): # pragma: no cover
"""
Calculates the derivative of a sigmoid function
"""
return f * (1 - f) | 73809554d0f854c5b21147e6e9ae57be1636d05c | 130,863 |
def get_primary_uri_field(fields):
"""Find the first field name containing URI"""
for f in fields:
if "URI" in f.field_name:
return f
return None | 696ea1b15dad3c377585674100a12c128518c4c0 | 625,921 |
def standardize_role(role):
"""Convert role text into standardized form."""
role = role.lower()
if any(c in role for c in {'synthesis', 'give', 'yield', 'afford', 'product', 'preparation of'}):
return 'product'
return role | 2bc4f972f5aa7836c541d7304880222d3d2e7930 | 230,900 |
def read_torrent_file(filepath):
"""Reads torrent file from filesystem and returns its contents."""
f = open(filepath, 'rb')
contents = f.read()
f.close()
return contents | 644c7e0c3b39957a3eba54bd8455768c290d4795 | 619,141 |
def inclusion_explicit_no_context(arg):
"""Expected inclusion_explicit_no_context __doc__"""
return {"result": "inclusion_explicit_no_context - Expected result: %s" % arg} | 2e0880d3940c961f6ccc2715e7fa300f9b969787 | 644,403 |
def _strip_cutouts_ztf(alert_dict: dict) -> dict:
"""Drop the cutouts from the alert dictionary.
Args:
alert_dict: ZTF alert formated as a dict
Returns:
`alert_data` with the cutouts (postage stamps) removed
"""
cutouts = ["cutoutScience", "cutoutTemplate", "cutoutDifference"]
a... | 4906e5e24980c16e058f4b577a4ba7fdf4a07cbd | 560,192 |
def recall(target, prediction):
"""Recall = TP/(TP + FN)"""
if len(target) == 0:
return 0
tp = sum(1 for p in prediction if p in target)
return tp / len(target) | ee0e45a8353690cdd878c20869ebfc3e62211987 | 280,873 |
def get_dict_from_result(db_result):
"""
Returns a list of dictionaries where each dictionary is {field:value} pairs for one row.
"""
d, a = {}, []
for rowproxy in db_result:
# rowproxy.items() returns an array like [(field0, value0), (field1, value1)]
for column, value in rowpr... | 7045f560d85381cfc3c0a7a64dd6a28874a1bdfc | 617,998 |
def filter_value(entry, values=None):
"""
Returns True if it should be filtered.
Only take calls with filter values in the list provided
if None provided, assume that filter_value must be PASS or blank '.'
"""
if values is None:
return len(entry.filter) != 0 and 'PASS' not in entry.filte... | 57ee5ab67fa07cb8c1379d303e9d636718025f45 | 703,303 |
def getCharacterFromGame(gtitle: str) -> str:
"""Return a query to get characters with lower Ryu Number to a game.
The query will retrieve the name and Ryu Number of a character whose Ryu
Number is exactly one less than the Ryu Number of the game whose title
is passed. This is used primarily for p... | 299919a60e1d9a24c67d1efd200e9f2f804c2309 | 681,450 |
def isStorageFirewallEnabled(self, storageAccount):
"""Returns True if the given "storageAccount" is storage firewall enabled"""
if storageAccount.network_rule_set.virtual_network_rules:
return True
return False | eb0ff2fb9457ed4e5049e34e6568b9f5cb5a5be8 | 400,847 |
def get_mackowiak_id(object_id, seqname, start, end, strand):
""" This function creates a "Mackowiak"-style identifier for, e.g., open
reading frames. The form of the identifier is:
<object_id>_<seqname>:<start>-<end>:<strand>
example: ENSMUST00000033123_7:46175479-46179843:-
... | a32290388e8d9f84ad84f2b5218bd54ff67e3bba | 314,328 |
def newline_list_of_strings(result_key, data, option_value=None):
"""Return a string from a list of strings while appending newline"""
return "\n".join(data) | b9086af7d95ec01586baa3ecbf63930860029a9e | 194,493 |
def getVal(x, y, M):
"""
Returns the value of the element (x,y) in M.
"""
if (x,y) in M:
return M[(x,y)]
elif (y,x) in M:
return M[(y,x)]
else:
return 0
pass | 3a260b1b8501b7501a456a8146ad5f1fb5f3b771 | 606,012 |
import hashlib
def hash_file(filepath):
"""
Hashes the contents of a file. SHA1 algorithm is used.
:param filepath: Path to file to hash.
:type filepath: ``str``
:return: Hashed value as a string
:rtype: ``str``
"""
HASH_BLOCKSIZE = 65536
hasher = hashlib.sha1()
with open(fil... | c9a374ec7aa471c3f226431be55770d108145f41 | 658,560 |
def _cast_value_to_type(value, cast_type_string):
"""Return the value casted to the type specified by the cast_type_string,
as defined in the type maps in the ReferenceGenome object's variant_key_map field
"""
if cast_type_string == 'Integer':
return int(value)
elif cast_type_string == 'Floa... | d01a83c465703c66134ece06df7f67deb366525a | 631,416 |
import pathlib
def get_full_img_path(img_root_path, csv_path):
"""Merge csv root path and image name."""
root_dir = pathlib.Path(csv_path).parent
img_path = root_dir / pathlib.Path(img_root_path)
return str(img_path) | 582c86466cfd886099b34736c40d440195434396 | 82,206 |
def read_file(filename):
""" Return the content of a file as a list of strings, each corresponding to a line
:param filename: string: location and name of the file
:return: content of filename
"""
with open(filename, 'r') as ofile:
content = ofile.read().splitlines()
return content | 58a2718265fef848e484178e407aee6f7017a52a | 700,897 |
import re
def escape_property_name_for_id(property_name: str) -> str:
"""Filter. Escape unsafe characters in a property name so that it can be used in a HTML id"""
escaped = re.sub("[^0-9a-zA-Z_,.-]", "_", str(property_name))
if not escaped[0].isalpha():
escaped = "a" + escaped
return escaped | 95f3e6bf077d3de733fbd1521f30132e71da6e6e | 340,051 |
import math
def primes_in_range(n):
"""Use Sieve of Eratosthenes find all primes in range 1..n"""
is_prime = [True] * n # is_prime[i] tells if i + 1 is a prime number
is_prime[0] = False
for prime_candidate in range(2, int(math.sqrt(n)) + 1):
if is_prime[prime_candidate - 1]:
# m... | f3ee68546c12b9aeac39cc8ea60bdbf10350f8a4 | 150,056 |
import torch
def tfidf_transform(tfidf_vectorizer, corpus_data, cuda0):
"""
Apply TFIDF transformation to test data.
Args:
vectorizer_train (object): trained tfidf vectorizer
newsgroups_test (ndarray): corpus of all documents from all categories in test set
Returns:... | 6f18b7114579412e1442b1c6220f34b7f643a2ab | 701,849 |
def layer2namespace(layer):
"""
converts the name of a layer into the name of its namespace, e.g.
'mmax:token' --> 'mmax'
"""
return layer.split(':')[0] | 8706003d04243a26b963ff8c6855f49a9bc9ed94 | 565,727 |
def _str_to_bool(value: str) -> bool:
"""
Parse string into bool. It tries to match some predefined values.
If none is matches, python bool(value) is used.
:param value: string to be parsed into bool
:return: bool value of a given string
"""
if isinstance(value, str):
if value.lowe... | 5b16da2512018b34feaa20f82625ace6f4380ddd | 145,732 |
def _get_var_meta(cr, case_name, var):
"""
Return the metadata for the variable of the given name in the given case.
Parameters
----------
cr : CaseReader
The case reader housing the data.
case_name : str
The case from which the outputs with available metadata is to be returned.... | 7c16e474b9bbd3b5a83869a342793e35f2b252c1 | 601,739 |
def getFirstNonClippedPositionInRead(alignedSegment, readSeq):
"""Gets the coordinate of the first non-clipped position in the read relative to the
complete read sequence (including any hard clipped bases).
If the alignment is on the reverse strand the coordinate is negative, e.g. the reverse strand coordi... | 28dfba57e47de456ef9fefa9e344235a447e3b7f | 137,922 |
def replace_in_string(phrase: str, l_to_replace: str, replacement: str):
"""
Take the 'phrase' string and replace all the 'l_to_replace' occurrence whit 'replacement' string
:param phrase: string that will be modified
:param l_to_replace: string to be replaced
:param replacement: string that will re... | 8815b0bb69754ee739e0c2d8f5a0fd79e8ebe1b3 | 352,143 |
import ast
def _to_dict(contents):
"""Parse |contents| as a dict, returning None on failure or if it's not a
dict."""
try:
result = ast.literal_eval(contents)
if isinstance(result, dict):
return result
except (ValueError, TypeError):
pass
return None | 4e9acba2e247c72dc7927e37087415e5606d6b73 | 663,516 |
import zipfile
def read_data(filename):
"""Extract the first file enclosed in a zip file as a list of words"""
with zipfile.ZipFile(filename) as f:
data = f.read(f.namelist()[0]).split()
return data | 08d8844025e5bb10a66301e35b8bbe4f37b886c9 | 89,057 |
def arguments(*args):
"""A Decorator which you wrap around a function or a method to indicate
which magical objects you want passed to your functions which are
embedded in a Resource's template.
The magical values you can pass are:
LOCATION
REQUEST
SITE
RESOURCE
... | debcfe4e7ca05150f8a29fc7455ae788a58d1d36 | 262,065 |
def _add(a, b):
"""
Simple function that adds two things.
Will be decorated for testing.
"""
output = a + b
return output | 4ce7c27c3fe362934b96f5867013b9f1432da17c | 341,147 |
from typing import Callable
from typing import Any
from typing import Sequence
import functools
def apply_middlewares(
func: Callable[..., Any], middlewares: Sequence[Callable[..., Any]]
) -> Callable[..., Any]:
"""
Apply a list of middlewares to a source function.
- Middlewares must be structured as... | 04685a34f401eb884e8bc352a8be285fb3b9a53e | 65,560 |
def ishexdigit(c):
"""
>>> ishexdigit('0')
True
>>> ishexdigit('9')
True
>>> ishexdigit('/')
False
>>> ishexdigit(':')
False
>>> ishexdigit('a')
True
>>> ishexdigit('f')
True
>>> ishexdigit('g')
False
>>> ishexdigit('A')
True
>>> ishexdigit('F')
... | b450b243bc40ea4f5c84ddfdeddcd8022839def3 | 46,959 |
def get_confirmation(question: str, default_yes: bool = True) -> bool:
"""Retrieve y/n answer from user, with default."""
question = question + (" ([y]/n): " if default_yes else " (y/[n]): ")
resp = input(question)
while resp not in ["y", "n", ""]:
resp = input(question)
if (resp == "" and n... | 365bfe72001429e09f0cec40595025f399d40488 | 147,022 |
def is_uvular(sound):
"""
Check if a sound is uvular or not.
"""
return sound.obj.place == "uvular" | 97e2d08975624576dd8b6c375a2a4241fdc48162 | 616,802 |
def translate(point, offset):
"""
Translate a point by an offset.
Arguments:
point: a point, e.g., (x, y)
offset: an offset, e.g., (x, y)
Returns: a translated point
"""
return (point[0] + offset[0], point[1] + offset[1]) | 6d8256459cf5c6c150762d13fe8b3c80f90cf9e8 | 366,556 |
def _invert_and_aggregate(the_dict):
"""
Transform a dictionary like this:
{ key1: value1,
key2: value2,
key3: value2 }
Into a dictionary of lists like this:
{ value1: [ key1 ],
value2: [ key2, key3 ] }
See tests.py for an example:
"""
_ = {}
# invert it
for... | 64bf7275398d862965ce1825c953ede29a175e8d | 284,399 |
def otsu_segmentation(image, k, mask=None):
"""
Otsu image segmentation
This is a very fast segmentation algorithm good for quick explortation,
but does not return probability maps.
ANTsR function: `thresholdImage(image, 'Otsu', k)`
Arguments
---------
image : ANTsImage
... | 0ea5175b1458731503569c789925168537f5d42d | 207,157 |
def find_max_time_overlap(hypseg, reflist):
"""Find reference segment which encompasses the maximum time of the hypothesis segment."""
hbeg, hend = hypseg[0], hypseg[2]
times = []
for [rlbl, rseg] in reflist:
b = max(hbeg, rseg[0])
e = min(hend, rseg[2])
times.append(e - b)
r... | 7f73b07bb9a5e88578ce3b444ad894c2dd210653 | 242,913 |
def convert_green(string):
"""Return green text"""
return f"{string}" | 3b0f86ec22e5959fa2545138615757b6c808abf3 | 575,179 |
def annotate(msg, geoc, filter_region=None):
"""
Annotate message with geocountry info
Params:
msg - dict object
geoc - GeoCountry object
filter_region - region to be filtered
"""
content = geoc.annotate(msg)
content_region = content.get("embersGeoCodeCountry", {}).get("region", None... | edf2b926436d64a9eb350e30efe0ca590de82b46 | 286,309 |
import yaml
def gen_lookup(file):
""" Generating the lookup table between api-endpoints and elasticsearch
instances from the configuration of the lod-api.
lookup table is of the form:
{"/api/endpoint": "http://elasticsearchhost:port/index/doctype",
"/resource": "http://el... | a007a0be1c18b585b9ebf66b194e55458f764146 | 684,398 |
def lc(value):
"""Lower case and remove any periods to normalize for comparison."""
if not value:
return u''
return value.lower().replace('.','') | 7f1c0e703f632931e7117f198ba4592c3b174e0f | 598,868 |
def _get_not_none(meta, key, none_subst=dict):
"""
Return meta[key] if key is in meta and its value is not None, otherwise
return none_subst().
Some recipes have an empty build section, so it'll be None and we can't
do a chained get.
"""
ret = meta.get(key)
return ret if (ret is not Non... | 52e7d2efd48009e549f800dda1922e2d344b19f7 | 280,384 |
def _parse_description(metadata_field):
"""
Parse the description field from the metadata if available.
Limit to the first 2000 characters.
"""
try:
if 'description' in metadata_field:
return metadata_field['description'][:2000]
except TypeError:
return None | f32a2c01330a15dc82c5b9c34235ae96ff030e50 | 355,284 |
import typing
import struct
def read_uint24(stream: typing.BinaryIO) -> int:
"""Reads a Uint24 from stream"""
return struct.unpack("<I", stream.read(3) + b"\x00")[0] | e6c044b210fd8a3b3100f9f1258f66c8ccef3edc | 148,694 |
def response_creator(text, card):
"""
Builds a response with speech part and Alexa appcard contents
:param text: text to be spoken
:param card: text for the app card
:return: JSON object to be returned
"""
text_item = {"type": "PlainText", "text": text}
card_item = {"type": "Simple", "ti... | cc1ce310616fc7de60b636698e3d288403db8af6 | 59,070 |
import re
def escape_description(desc):
""" Escape a string for use as an argument description.
:param str desc: the description
:returns: esacped description
:rtype: str
"""
desc = desc.replace('\n', ' ')
desc = desc.replace('\'', '')
# Special meaning in zsh optspec, so substitute ... | b1d7e377a41a59109549a194dbb6f225deb218c2 | 556,764 |
def leiaint(msg):
"""
--> Função que faz a validação da entrada de dados do tipo inteiro (int)
:param msg: Mensagem para entrada de dados do usuário
:return: retorna o valor digitado, caso este tenha sido um número inteiro
:print: Escreve uma mensagem de erro na tela, caso o valor digitado não seja ... | 29b96b26055d965e987bf1e39a96b1924751f56c | 45,996 |
def unzip(seq):
"""
The inverse of the builtin ``zip`` function, this method transposes groups of elements into new
groups composed of elements from each group at their corresponding indexes.
Examples:
>>> list(unzip([(1, 4, 7), (2, 5, 8), (3, 6, 9)]))
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
... | 2aff6f3d9e79e52f1e0ce16c1080eab102c1b512 | 115,062 |
def kvp_string_to_rec(string):
"""Take an input string 'a=b,c=d,e=f' and return the record
{'a':'b','c':'d','e':'f'}"""
rec = {}
for kvp in string.split(','):
arr = kvp.split('=')
if len(arr) > 2:
raise Exception("Cannot convert %s to KVP" % string)
rec[arr[0]] = arr[... | 1161b84ca2e929b4b8c00e68c7ed8ed4fb424f5e | 246,613 |
def _get_bbox_feature(image_size, feature_map, x_min, x_max, y_min, y_max):
"""Get bounding box features.
The feature is the center pixel of a bounding box.
Args:
image_size (tuple): Size of an image in [x, y].
feature_map (numpy.ndarray(numpy.float)): Feature map of size [x, y, n_features... | a5e61183686661015ee6c401b7661ee6c39d7d5e | 637,042 |
def compute_ema(df, column_source, column_target_ema, time_periods):
"""
Compute Exponential Moving Average (EMA).
:param df: dataframe (sorted in ascending time order)
:param column_source: name of source column in dataframe with values to compute EMA (e.g. close price)
:param column_target_ema: p... | 95fc2db10f3ba8abe8e790ac9698d024175f6485 | 441,397 |
def bin2hexstring(bin_str):
"""
二进制串转十六进制串，按照 4：1 比例转换
:param bin_str: 二进制串
:return: 十六进制串
"""
bin_len = len(bin_str)
left = 0
right = 4
re_str = hex(int(bin_str[left:right], 2))[2:]
for i in range(right, bin_len, 4):
left = right
right += 4
re_str += hex(... | 823ba4ef86ebcf7e30a29c3718768c6a654acad5 | 708,040 |
def adapt_dbm_reset_ast(dbm_reset_ast):
"""Transforms the expression ast of a reset into a clock reset ast.
Args:
dbm_reset_ast: The reset expression ast.
Returns:
The clock reset ast.
"""
clock = dbm_reset_ast["expr"]["left"]
val = dbm_reset_ast["expr"]["right"]
return {"c... | 7614c2a4edfa3c6c4b7b728de1604f8ca6e81553 | 63,148 |
def bottomupsegment(sequence, create_segment, compute_error, max_error):
"""
Return a list of line segments that approximate the sequence.
The list is computed using the bottom-up technique.
Parameters
----------
sequence : sequence to segment
create_segment : a function of two arg... | bb656a1413d643cc4b6fc1aa42b62bfbf796cdcd | 372,175 |
def from_ell_to_index(ell):
"""
Returns the range of column values assuming a matrix with columns ordered
with the m multipole , m ranging from -ell to +ell
"""
return ell ** 2, ell ** 2 + 2 * ell + 1 | aef533a7e3c149a61a803c037d8a9d96c59cb87e | 375,671 |
def is_ascii(some_string):
"""Check if a string only contains ascii characters"""
try:
some_string.encode('ascii')
except UnicodeEncodeError:
return False
else:
return True | dac0db05037c588f553d445a1e4f756f07db1ee7 | 151,773 |
def input_prompt(prompt):
"""
Get user input
"""
return input(prompt) | 76724d278cf68ef2b16b7aa35ee61336a373f9ca | 683,497 |
def excel_column_number(raw_column_name, index=1):
"""Given a column name, give me the column number
A=1
Z=26
AA=27
AZ=52
BA=53 etc"""
def char_value(c):
return ord(c)-64
value = 0
for char in raw_column_name.upper():
value = value * 26
value = v... | 129bd81b75c9aa04756fac24c36c7d86bb3c9148 | 139,444 |
def exists_in_perso(perso, asn):
"""
:param perso: personal AS
:param asn: These ASn exist in AS_rank dataset
:return: True if an ASn from AS_rank dataset exists in personal dataset else returns False
"""
return asn in perso.asn.values | 701760e9d0bbf3317a0bbc8e4da3811b20cdc4b8 | 85,264 |
import time
def create_time_string(time_format='%Y%m%d%H%M%S'):
"""Returns current time formatted as `time_format`
Parameters
----------
time_format : str
Refer https://docs.python.org/3/library/time.html#time.strftime for options
Returns
-------
str
time as string in req... | bae261dd0fb5473129a58d2d996cce44cbe494b3 | 309,723 |
def parse_int(int_str):
"""Parse an int or return None."""
try:
return int(int_str)
except (TypeError, ValueError):
return None | ce5b2c24afaad834e9513bffa423a96df1b39d57 | 279,108 |
import aiohttp
async def download_file(slack_api_token, file):
"""Downloads a file from slack into memory and returns the raw bytes."""
headers = {'Authorization': 'Bearer {}'.format(slack_api_token)}
async with aiohttp.ClientSession() as session:
async with session.get(file["url_private"], header... | 3d9890ea6e1b9601be2d1000a44ea92203af5d2e | 240,819 |
import requests
import pickle
def api_request(file, thresh=0.5):
"""
Post request to serverless backend api where our model is lcoated
Receives a csv with the classes and polygons classified by our model
Parameters
----------
file: .tiff file
Tiff file to be classified by our model
... | 717302d8c8144cb65953298eeef74efa5324a7c0 | 75,849 |
def get_mean_accuracy(n):
"""
Get the mean accuracy from a confusion matrix n.
Parameters
----------
n : dict
Confusion matrix which has integer keys 0, ..., nb_classes - 1;
an entry n[i][j] is the count how often class i was classified as
class j.
Returns
-------
... | 8c505f3cd660f3a5096c00bb04ee0d996aa974cb | 601,326 |
def get_train_validate(full_df, features, split):
"""Generate training and validation sets with features."""
X = full_df[features + ['demand']]
print('[dtypes of features (including demand):]')
print(X.dtypes.value_counts())
print('\nSplit train and validation sets on day', split)
X_train = X[X... | e6186cd902840a5cbd4ba25af79a8c1497311313 | 185,106 |
def kwargs_to_ctypes_array(argument, kwargs, dtype):
"""
Convert an iterable argument from kwargs into a ctypes array variable.
If the argument is not present in kwargs, returns ``None``.
Parameters
----------
argument : str
The name of the argument.
kwargs : dict
Dictionar... | 715c8cd1d0fd6cbb526e32f9f83e01178742bf42 | 562,954 |
import pathlib
def click_convert_to_path(ctx, param, value):
"""
Callback function for click.option to ensure all pathes are PosixPathes.
"""
assert value is not None
if isinstance(value, str):
value = pathlib.Path(value)
return value | ec0cd8c97f7bbac4fbbca1e897fe41fb10444ac0 | 144,964 |
import re
import json
def _load(body):
"""This function cleans Google's response and coverts
it to JSON.
Args:
body (str): HTTP body
Returns:
dict
"""
clean = re.sub(r'^[^\[]*\n\[', '[', body)
return json.loads(clean) | 2174586923af0f63a65eb58fed3aa5b6edb0f8b4 | 437,517 |
def find_bad_sitezero(X):
"""Returns indices of bad rows from the early days of Site 0 (UCF)."""
return X[(X.timestamp < 3378) & (X.site_id == 0) & (X.meter == 0)].index | 65bd43455879ed74228bbc1c6224229b14c647aa | 208,954 |
def parse_signed_url_for_bot_uid(url: str):
"""Parses a bot UID from a signed URL.
Assumes the signed URL follows the following scheme:
[...]/{bot_uid}.zip?[...]
:param url:
:return:
"""
endpoint = url.split("?", maxsplit=1)[0]
file_name = endpoint.split("/")[-1]
bot_uid = file... | dd5fbf078405e5c18cdaeca6df36f143792d8105 | 177,139 |
def _find_image_object(images_list, image_name):
"""
Find and return an image object from images_list with a name that matches image_name
:param images_list: <list> List of <DockerImage> objects
:param image_name: <str> Name of image as per buildspec
:return: <DockerImage> Object with image_name as ... | 7b868c5e3f58a4a318d873eb9c64a0f6b16d104a | 197,450 |
import re
def humansort_key(strng):
"""Human/natural sort key-gathering function for sorted()
Source: http://stackoverflow.com/a/1940105
"""
if isinstance(strng, tuple):
strng = strng[0]
return [w.isdigit() and int(w) or w.lower()
for w in re.split(r'(\d+)', strng)] | f633a05d9a599a0ec8e85782118dca47c06bba41 | 603,603 |
def z_score(val, v_mean, v_std):
"""Calculate a z-score given a value, mean, and standard deviation.
NOTE: The z_score() of a constant vector is 0
"""
score = 0 if v_std == 0 else (val - v_mean) / v_std
return score | 1381041fc2edca12fc4ece8df0d3e80a7347ed62 | 221,043 |
from datetime import datetime
def times(fields):
"""Return a starting and ending datetime, given `fields` like:
[u'CLOCK:', u'[2013-03-08', u'Fri', u'14:24]--[2013-03-08', u'Fri',
u'15:41]', u'=>', u'1:17']
"""
return (datetime.strptime(fields[1] + fields[3][:5], u'[%Y-%m-%d%H:%M'),
... | 8a1fb78e893e71c96dc2a04c1897bfc4b7a1d367 | 51,949 |
def gatt_procedure_write_handle_async(stack_connection, connection_handle, handle, data, timeout=15 * 1000):
"""
Writes data to target attribute handle and returns a GATTRequest object that contains either
a GATTResponse for a GATTError. This is an asynchronous function that issues the request
and retur... | 4a5d316d2cc0cdfec31d64e66e7c7dcf2026dc58 | 407,032 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.