content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def equalize_array(array):
""" Expand all rows of 2D array to the same length """
if len(array) == 0:
return array
max_length = max([len(i) for i in array])
for row in array:
diff = max_length - len(row)
row.extend([""] * diff)
return array | 120dd2282f5f32342d66dba2916b269ef7d38f41 | 280,986 |
def read_file(file):
"""
Reads a file line by line and stores them in a list.
Parameters
----------
file : The file to read. Each line in the file represents an element to be
stored in a list.
Returns
-------
content : A list with the lines of the file as elements.
"""
co... | 9c2dfd5ee180be6c54914b9c5165da1756562416 | 78,445 |
import re
def _db_regex_func(expr, item):
"""
REGEXP search function for SQLite.
:param expr:
:type expr: str
:param item:
:type item:
:return: True if a match is found.
:rtype: bool
"""
reg = re.compile(expr, re.I)
return reg.search(item) is not None | 009faba2ab950ee37f3cbc10ff6519e90099d9c4 | 535,103 |
def rotate90_point(x, y, rotate90origin=()):
"""Rotates a point 90 degrees CCW in the x-y plane.
Args:
x, y (float): Coordinates.
rotate90origin (tuple): x, y origin for 90 degree CCW rotation in x-y plane.
Returns:
xrot, yrot (float): Rotated coordinates.
"""
# Translate ... | 172b74f4aaa5453520ed9669d1f76d3103c51b06 | 681,201 |
from typing import Dict
from typing import Tuple
def format_dimensions(dimensions: Dict[str, int]) -> Tuple[int, int]:
"""Slightly simplify 'dimensions' response attribute into ``(width, height)`` tuple"""
return dimensions.get("width", 0), dimensions.get("height", 0) | 627b1ec13887923c8ff41465e4e5652f5b4aea76 | 402,352 |
import click
def prompt_access_token(exporter):
"""Prompt user for an access token for a provider.
:return: The new access token
"""
text_prompt = ('You must configure an access token\n')
text_prompt += 'Create one at: {0}\n'.format(exporter.access_token_url())
text_prompt += 'Access token'
... | cff9e4239921b5f7360935e48f0ee6afeba450a1 | 350,052 |
def get_gcd(num1, num2):
"""
Gets the greatest common divisor of two numbers.
:param num1: The first number.
:param num2: The second number.
:return: The GCD.
"""
if (num2 == 0):
return num1
return get_gcd(num2, num1 % num2) | f1fbf359af9c7ec2ab04b9cedc7719fd7923f4ea | 358,133 |
def path_in_cc(path, cc):
"""Determines whether all vertices of a given path belong to a given
connected component.
:param path:
:param cc: list of vertices representing a connected component in a graph
:return: True if the path vertices are found in the connected component,
False otherwise... | 9d549234f2a1294380a3e416fea93cdf7944d8b2 | 26,181 |
def flatten(s, accepted_types=(list, tuple)):
"""flatten lists and tuples to a single list, ignore empty
Parameters
----------
s : Sequence
accepted_types : Tuple (acceptable sequence types, default (list,tuple)
Return
------
l : Flat sequence
Exa... | 8a25a2f3f0b4963dcfb689026b9d5644ccf2591e | 240,466 |
def _colnames(elements):
"""Generate column names for output text file.
Args:
elements (list): List of output element abbreviations (str).
Returns:
str: header line that describes columns.
"""
time = ['{:8}'.format('Time')]
sfr = ['{:8}'.format('SFR')]
survivors = ['{:10}'.... | 3104562aa59872e0dfd1a229056eb6c48e5ac56a | 333,001 |
from pathlib import Path
from typing import List
def parse_dependency(filepath: Path) -> List[str]:
"""Parse python dependencies from a file.
The list of dependencies is used by `setup.py` files. Lines starting
with "#" are ingored (useful for writing comments). In case the
dependnecy is host using g... | 6c030a81c834f815e30ca0e586713b282f4b89f0 | 325,183 |
import io
def read_bytes(n: int, reader: io.IOBase) -> bytes:
"""
Reads the specified number of bytes from the reader. It raises an
`EOFError` if the specified number of bytes is not available.
Parameters:
- `n`: The number of bytes to read;
- `reader`: The reader;
Returns the bytes rea... | bb3d00fc7667839864f4104a94a26e682f058fdc | 6,287 |
import pickle
def loadData(file_model):
"""
Load object from (pk) dump file
:param file_model: object file
:return: reconstructed object file
"""
object_file = None
try:
object_file = open(file_model, 'rb')
object_model = pickle.load(object_file)
object_file.close()... | 5715e6343b0ab12370ce3821089d3dc9f4b150a1 | 646,701 |
def calculate_spendings(queryResult):
"""
calculate_spendings(queryResult): Takes 1 argument for processing - queryResult
which is the query result from the display total function in the same file.
It parses the query result and turns it into a form suitable for display on the UI by the user.
"""
... | a80fb8068ceabb690d7e9aec12b160323b2a061d | 434,850 |
import struct
def from_big_endian(bytestring):
""" Convert big-endian bytestring to int """
bytestring = bytestring.rjust(4, b'\x00')
return struct.unpack(">L", bytestring)[0] | 02ba7eae7180b43339d0e278ce633ab414ca397b | 467,583 |
from typing import List
from typing import Dict
def _tags_as_dict(tags: List[Dict]) -> Dict[str, str]:
"""
Convert a list of tags to a dictionary
:param tags: the list of tags
:return: the dictionary of tags
"""
return {tag["Key"]: tag.get("Value", "") for tag in tags} | f909f1f4fb6773cf3b1e32067d963738b6e7023d | 39,196 |
import random
def choose_from_string(string: str, n: int):
""" Choose a card from a string. Returns the choice and what remains after choosing. """
assert len(string) >= n
choices = []
for _ in range(n):
char = random.choice(string)
string = string.replace(char, '', 1)
choice... | e8605428d046456311333f73c66465319803dc13 | 627,918 |
def count_nodes(d:dict) -> int:
"""Count the number of nodes (leaves included) in a nested dictionary.
"""
n = len(d.keys())
for k,v in d.items():
if type(v) is dict:
n += count_nodes(v)
return n | d8253cab1cbf85692be82307d85ac441ba56ec86 | 535,578 |
def deepgetattr(obj, attr, default = None):
"""
Get a named attribute from an object; multi_getattr(x, 'a.b.c.d') is
equivalent to x.a.b.c.d. When a default argument is given, it is
returned when any attribute in the chain doesn't exist; without
it, an exception is raised when a missing attribute is... | fb3363d362f198e1ad4037f18b8c514be5742c49 | 664,938 |
def convert_x1y1x2y2_to_XcYcWH(box):
"""
Convert box from dictionary of {"x1":,"y1":,"x2":,"y2"} to {"x_centre":,"y_centre":,"width":,"height":}
Assumption 1: point 1 is the top left and point 2 is the bottom right hand corner
"""
assert box["x1"] <= box["x2"]
assert box["y1"] <= box["y2... | e7da7353b64b969b4c51dc7ece06729b05bad31e | 12,691 |
def RGBtoHSB( nRed, nGreen, nBlue ):
"""RGB to HSB color space conversion routine.
nRed, nGreen and nBlue are all numbers from 0 to 255.
This routine returns three floating point numbers, nHue, nSaturation, nBrightness.
nHue, nSaturation and nBrightness are all from 0.0 to 1.0.
"""
nMin = min( n... | 5e698f58c0f01fade4bc4c4cea7b7838239c7caf | 102,567 |
def get_nearest_point(kdtree, the_pt, dist_thresh_in_km=0.005):
"""
Get the nearest point to "the_pt" using the the kd=tree index
Arguments:
kd {[KDTree]} -- The KD-tree of all the points
the_pt {list} -- [x,y] of the point
Keyword Arguments:
dist_thresh_in_km {float} -- The ma... | 418e7aeb37f19e6e7dd71fef160fb4ea3159baaf | 539,399 |
def parse_port_id (parameters, port_id = "portno"):
"""
Parse command parameters to get the socket port ID for the command.
:param parameters: The list of parameters provided to the command.
:param port_id: The name of the port ID parameter.
:return The socket port ID to use for the comman... | f77c35ade0b80deea7b2632534f0181e300c831c | 419,082 |
def get_number_available(product_information_table: list) -> str:
"""Return number of books available."""
number = product_information_table[5].text
return "".join([character for character in number if character.isdigit()]) | ab39cd19b36d53997e22485fbebfab63cd8202eb | 85,358 |
from typing import List
from typing import OrderedDict
def dict_list_to_request_params(param_name: str, values: List[dict]) -> dict:
"""
Returns dict to be used by request params from dict list
Expected Airtable Url Params is:
`?sort[0][field]=FieldOne&sort[0][direction]=asc`
>>> objects = [... | 74efd49357d972c59ab0cf5ea53cb02802283358 | 378,013 |
def field(field_var):
""" Render a field based on template
https://docs.djangoproject.com/en/1.8/howto/custom-template-tags/#inclusion-tags
Possibly add parameter for custom classes
:param field_var: the field variable
:return: the template context
"""
return {'field': field_var} | 7b48d67f83098cf8d3e4ec004bfdccc25c2565e6 | 590,120 |
import math
def bearing(obj_pos):
"""
Return bearing of an object:
https://en.wikipedia.org/wiki/Bearing_(navigation). Used to determine
an objects center in x-direction (more to the left or right in the image)
"""
angle = math.atan2(obj_pos[0], -obj_pos[2])
return math.degrees(angle) | 1f98504fe5f64d8fe6619eef307ba1d3a68908cd | 442,632 |
def filtrar_entre(valores, menor, maior):
"""
Cria uma lista com os números de 'valores' que estejam no intervalo
['menor', 'maior') (o primeiro intervalo é fechado e o segundo é aberto).
Parâmetros: lista de floats e os limites.
Retorna: a lista filtrada.
"""
nova_lista = []
for valo... | d237a40fc82b9cec4bc9052a20cc0064c5dabcf1 | 118,144 |
def parse_german_float(s):
"""
Parse a German float string.
German uses a dot for the thousands separator and a comma for the
decimal mark.
"""
return float(s.replace('.', '').replace(',', '.')) | 7092676b3356fd43a2acd3049231e08eb8898f0b | 402,519 |
def isInList(node, alist: list):
"""
Determine if a node is within a list
"""
for temp in alist:
if temp.position == node.position:
return True
return False | 979b58647b88142d29a93a339e520416adfd78f9 | 64,498 |
import json
def read_json(file_name):
"""Read and parse JSON file
:param file_name: JSON file name
"""
with open(file_name) as f:
data = f.read()
return json.loads(data) | 49384f20deaeedef58b1358de1f5924eb3ac82a8 | 193,014 |
def number_to_name(number):
"""Take integer number as input (0-1-2-3-4) and returns string (rock-spock-paper-lizard-scissor)
"""
if number == 0:
return "rock"
elif number == 1:
return "spock"
elif number == 2:
return "paper"
elif number == 3:
return "lizard"
... | e0a5dd4ceb35ee0d7c2f86f95fb34f4bf1fe2da3 | 73,849 |
from typing import Tuple
from typing import List
from typing import Dict
from typing import Any
def info() -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
"""
Get input and output schemas
:return: OpenAPI specifications. Each specification is assigned as (input / output)
"""
input_sample = ... | 282f60cacac69865736c58712c4bfbdb2f5e2c24 | 7,180 |
def get_groups(groups_collection):
"""Returns a list of group names
:param groups_collection: Mongo collection that maintains groups
:return: List of group names
"""
groups = groups_collection.find()
return list(groups) | 75ff224e383eaf2f4fd9e4d345231aa4a7ea587f | 27,617 |
def rgb2hex(rgb) -> str:
"""Convert an RGB sequence to a hexadecimal color.
The values of the sequence need to be in ``range(256)``.
>>> rgb2hex([0, 255, 255])
'#00ffff'
"""
return '#%02x%02x%02x' % tuple(rgb) | 7b7240bbd260d8c0d17484f24eb96fdee4223974 | 619,258 |
def create_alias(name):
"""
Clean an alias to be an acceptable Python variable
"""
return name.replace(' ', '_').replace('.', '_').lower() | 111640d2a063e027b3c823f396cc27defcb6fd5d | 252,624 |
def get_rare_elements_number(d, n):
"""
Count the number of rare elements
:param d: dictionary to use
:param n: the threshold for rarity
:return: the number of rare elements as a string
"""
i = 0
for k, v in d.items():
if v < n:
i += 1
return str(i) | 367aab5fdf4efb945cccfb9dffd95573cbd72a3c | 662,405 |
def nbsp(value):
"""
Avoid text wrapping in the middle of a phrase by adding non-breaking
spaces where there previously were normal spaces.
"""
return value.replace(" ", "\xa0") | 6ef5586da6c03c84db1acef0597ecb449d527eca | 66,584 |
def _readlines(fname, fpointer1=open, fpointer2=open):
"""Read all lines from file."""
# fpointer1, fpointer2 arguments to ease testing
try: # pragma: no cover
with fpointer1(fname, "r") as fobj:
return fobj.readlines()
except UnicodeDecodeError: # pragma: no cover
with fpo... | 142432f9f650f4da1ac878f34b7736181c0d2424 | 471,198 |
def pybb_moderated_by(topic, user):
"""
Check if user is moderator of topic's forum.
"""
return user.is_superuser or user in topic.forum.moderators.all() | 8dd6370f9bd0fa87c0acce1f9b6aec6a0f434888 | 555,302 |
def _is_macos(repository_ctx):
"""Determines if the host is running MacOS.
Args:
repository_ctx: A `repository_ctx` instance.
Returns:
A `bool` indicating whether the host is running MacOS.
"""
os_name = repository_ctx.os.name.lower()
return os_name.startswith("mac os") | 35d12c32243ebe6e7253cc863280dbe53d99b0e2 | 618,969 |
def render_paper_images(paper_soup):
"""
Renders paper uploaded images with default visual styles.
"""
images = paper_soup.find_all('img')
for image_tag in images:
image_tag['style'] = ''
image_tag['class'] = 'img-fluid my-3 hover-translate-y-n3 hover-shadow-lg'
return paper_... | 34caf9ec1efdae0ab4f713d57fb8e52eb31a6ef9 | 504,302 |
def load_polymer(filename):
""" Return the polymer string from FILENAME. """
polymer = None
with open(filename) as f:
for line in f:
polymer = line.rstrip()
break
return polymer | f961a095137390e0a50f83121da4acb34c3e1a4d | 587,125 |
def urlpath2(url:bytes) -> bytes:
""" Get url's path(strip params) """
return url.split(b'?', 1)[0] | b5464b3617cbd6303f4438c92fd8f5271f6906e1 | 46,949 |
def __gen_t(dt: float, num_timesteps: int) -> list:
"""generate time vector, starting at 0
Args:
dt (float): time between saved timesteps
num_timesteps (int): number of total timesteps
Returns:
t (list): list of times
"""
t = [float(x) * dt for x in range(0, num_timesteps)... | 9ba58dfb2ec2963b48503b3f28582230b169c19f | 150,068 |
def exif_values_to_list(value):
"""Convert a value returned by ExifTool to a list if it is not already and filter out bad data"""
if isinstance(value, list):
value = [v for v in value if not str(v).startswith("(Binary data ")]
return [str(v) for v in value]
elif not str(value).startswith("(B... | 794d0daad4cfada5a0e92062fcbd6676341e050c | 529,035 |
def case_safe_sf_id(id_15):
"""
Equivalent to Salesforce CASESAFEID()
Convert a 15 char case-sensitive Id to 18 char case-insensitive Salesforce Id
or check the long 18 char ID.
Long 18 char Id are from SFDC API and from Apex. They are recommended by SF.
Short 15 char Id are from SFDC formula... | e70f4cfe2e03b269d8c1f31e3d903de48c63c000 | 369,080 |
def clean_up_feature_sets(*feature_sets, earliest_date: dict, last_date: dict) -> list:
"""Leave only features from inside the observation window."""
results = []
for feats in feature_sets:
results.append(feats[(feats.DATE < feats.SUBJECT_ID.map(last_date))
& (feats.DATE... | 06e4ac3713dce63a4237694fa6b6b0ed850216f6 | 48,233 |
def inverse(pattern):
""" gets the inverse pattern of a pattern """
new_pattern = ''
for item in pattern:
if item == '0':
new_pattern += '1'
elif item == '1':
new_pattern += '0'
else:
new_pattern += item
return new_pattern | 7c7e63833cae343e5dd155f868f6b3da5c656133 | 244,187 |
def age_window_hit(by_predicted, by_truth, m=lambda x: -0.1*x+202.8):
"""
calculates the window for a given truth and checks if the prediction lies within that window
:param by_predicted: the predicted birth year
:param by_truth: the true birth year
:param m: function giving the window size when giv... | 141ab8467fbef19fadce8cdce62657cd158ae391 | 304,942 |
def gen_v_stmt(q1n, q2n):
"""
return a string of verify statement.
"""
return "verify {} {};\n".format(q1n, q2n) | 5fd8c56b97a001934601427a1e36754cb41f8830 | 547,943 |
import six
def make_bytes(dictionary):
"""Encodes all Unicode strings in the dictionary to UTF-8 bytes. Converts
all other objects to regular bytes.
Returns a copy of the dictionary, doesn't touch the original.
"""
result = {}
for (key, value) in six.iteritems(dictionary):
# Keep bi... | 07dae3ce26a97203b7f1bd067f34e88b18522c06 | 98,115 |
def expand_by_device(original_parallelism, device_parallelism, data):
"""Opposite of reduce_by_device().
Args:
original_parallelism: a expert_utils.Parallelism object.
device_parallelism: a expert_utils.Parallelism object.
data: a list of tensors with length device_parallelism.n
Returns:
a list ... | 6dff03ffeccbba896213f49b0848e436bddb88ae | 553,065 |
import json
def load_dicefile(file):
""" Load the dicewords file from disk. """
with open(file) as f:
dicewords_dict = json.load(f)
return dicewords_dict | 42da982410dfc1ac39a1f40766ba6f7a2824d088 | 672,333 |
def splitparticle(s):
"""Extracts number, particle/element type and mass number of particle string
(e.g. 1Cs133, Cs133, 1e).
Parameters
----------
s : str
Input particle string.
Returns
-------
tuple of (int, str, int)
Tuple of signature (number of particles, element sy... | 5bebda09b0695d6c027245d9ad44ed7bb148cca8 | 544,019 |
def gridIndicesToMatIndices(i,j, maxI, maxJ):
"""
converts grid coordinates to numpy array coordiantes
grid has (0,0) at bottom left corner, numpy has (0,0)
at top left corner.
:param i: x - column index
:param j: y - row index
:param maxI: number of columns in grid
:param maxJ: number o... | de988d3405feeda0e85f28dc0b858f7ea951d75e | 504,324 |
import re
def normalize_ssh_url(url):
"""Convert a SSH-like url to a RFC1738-compliant url
>>> normalize_ssh_url('user@host.xz:/path/to/repo.git/') == 'ssh://user@host.xz/path/to/repo.git/'
True
>>> normalize_ssh_url('user@host.xz:path/to/repo.git/') == 'ssh://user@host.xz/path/to/repo.git/'
True... | 950ee9a4eb56926ad7c7f2c0712a77af89c84639 | 222,513 |
def deals_summary_statistics(shelves):
"""
Given a list of shelves, returns a query to return summary statistics for all deals belonging to those shelves.
:param shelves: An array of strings representing the Bloomberg deal names of the shelves to be included
:return: Summary statistics for all deals in ... | fec001aeafe17a34a158e3c38b57c461eb6792a2 | 543,115 |
from typing import List
def extract_fields(rec: str, pos: List[int]) -> List[str]:
""" Extract fields from a delimited record """
fields = []
if length := len(rec):
for i in pos:
if i < length:
fields.append(rec[i])
return fields | 8f5e8b15da4509b2cc7d9bae0d96f548c835d38e | 285,151 |
from pathlib import Path
def get_live_toml_file(toml_file: Path) -> Path:
"""
Check to see if the TOML file path exists already
Parameters
----------
toml_file: Path
Pathlib Path holding the user provided path to the toml file.
Returns
-------
Path
path to the live tom... | df852bfffebf9055a9e0ebc565755866e2bf1f25 | 116,538 |
def fix_imessage_date(seconds):
"""
Convert seconds to unix epoch time.
iMessage dates are not standard unix time. They begin at midnight on
2001-01-01, instead of the usual 1970-01-01.
To convert to unix time, add 978,307,200 seconds!
Source: http://d.hatena.ne.jp/sak_65536/201... | fefc32c1489048e9d2ca5532bf00a2867eff2d1d | 253,332 |
def get_filepaths_from_data_dir(data_dir, file_extension="*.txt"):
"""Creates a list containing paths to filenames in a data directoryl
Args:
data_dir (PosixPath): PosixPath to the data directory.
file_extension (str): A string with the given file extension you want to extract.
"""
fil... | e03d01040e8b11e1b701864004225445ef4127ee | 319,119 |
import json
def loadjson(fp):
"""Convenience wrapper to load json data."""
with open(fp, 'r') as fin:
dat = json.load(fin)
return dat | 4254e1d187ed72f1436152692a001c1466d35303 | 449,244 |
def calc_median(nums):
"""Calculate the median of a number list."""
N = len(nums)
nums.sort()
if N % 2 == 0:
m1 = N / 2
m2 = (N / 2) + 1
m1 = int(m1) - 1
m2 = int(m2) - 1
median = (nums[m1] + nums[m2]) / 2
else:
m = N / 2
m = int(m) - 1
... | 3755d4436fe66c5e56d5297c2e2b2e59763caa90 | 89,252 |
def _check_for_item(lst, name):
"""Search list for item with given name."""
filtered = [item for item in lst if item.name == name]
if not filtered:
return None
else:
return filtered[0] | b820fa63e952fb9e0d5007811588e74071d18140 | 485,030 |
def unstack_and_count(da, dims):
""" Unstacks provided xarray object and returns the total number of elements along dims """
try:
unstacked = da.unstack(da.dims[0])
except ValueError:
unstacked = da
if dims is None:
return ((0 * unstacked) + 1)
else:
return ((0 ... | e60879b140934b67d9684ab3ff71dfe8a9fd31bb | 578,863 |
def compile_unmatched(unmatched, applicants):
"""
Compile list of unmatched applicants after allocation, using the
output unmatched IDs from allocate.
"""
return [a for a in applicants if a["id"] in unmatched] | 3ead63f58e90c2b4b70c12f2f9970a539af8fd8a | 563,017 |
def get_list_scafs(file_in):
"""
Return a list of scaffolds to walk through. Expects each scaffold on its own
line in the input file.
"""
scaf_ls = []
with open(file_in, 'r') as infile:
for line in infile:
scaf_ls.append(line.strip())
return scaf_ls | bab93ee2cd070517fe3946d481acac5ac675e525 | 500,506 |
def bit_flip(array):
"""Given a binary array, find the maximum number zeros in an array with one
flip of a subarray allowed. A flip operation switches all 0s to 1s and 1s
to 0s."""
original_zeroes = 0
current_sum, max_sum = 0, 0
for value in array:
if not value:
value = -1
... | aeed191e9d30816492a6f45c889e20e1435e094d | 197,011 |
import torch
def remove_bbx_abnormal_z(bbx_3d):
"""
Remove bounding box that has negative z axis.
Parameters
----------
bbx_3d : torch.Tensor
Predcited 3d bounding box, shape:(N,8,3)
Returns
-------
index : torch.Tensor
The keep index.
"""
bbx_z_min = torch.mi... | b598da809600ef50c84c14b42554490c3b0131bf | 575,526 |
def enum_name(name):
"""Shorten an enumeration name."""
assert name.startswith('GL_')
return name[3:] | f428d90c43ff674910e4e7195143497a6338d976 | 512,905 |
def scalar_prod(n,a):
"""
This function takes a scalar, n, and multiplies it by every
element in a vector.
"""
c = [n*a[0],n*a[1],n*a[2]]
return(c) | ca4756599eeabefc4a0b7b22357bb22bf5348a28 | 475,140 |
import random
def build_batches(sentences, batch_size, num_chunks_in_batch=1):
"""
Randomize batches sequences along sentences if dataset indexes.
https://gist.github.com/pommedeterresautee/1a334b665710bec9bb65965f662c94c8#file-trainer-py-L181
https://wandb.ai/pommedeterresautee/speed_training/reports... | 66da330776532fd29807cdf00e3ec22d6ee7abf1 | 219,608 |
def find_bounds(f, y):
"""
Find approximate bounds for binomial search.
"""
x = 1
while((f(x) < y) and (x<1000483646) ):
x = x * 2
lo = -100
if (x ==1):
lo = -100
else:
lo = x/2
if(x > 1000):
x = min(x,2047483646)
return lo, x | c0cbf9f9867d028f8d83da5ae05860613946e987 | 618,870 |
import re
def is_s3_file_url(file_url):
"""
Match the s3 file regex match.
"""
return re.match(
r"^(https:|/api/method/frappe_s3_attachment.controller.generate_file)",
file_url,
) | b9dbc7eda61d53177509fc2a3e306c60c9f4bf24 | 527,064 |
def flatnonzero(a):
"""
Return indices that are non-zero in the flattened version of a.
This is equivalent to a.ravel().nonzero()[0].
Parameters
----------
a : ndarray
Input array.
Returns
-------
res : ndarray
Output array, containing the indices of the elements o... | de4d3367251ce17188e3e07901a711ccaeb7c994 | 242,974 |
def deepcopy_nested_dict(nested_dict_to_deepcopy: dict):
"""
Deepcopy of a nested dictionary of two levels, e.g. {k1:{...}, k2:{...}, ..., kN:{...}}
:param nested_dict_to_deepcopy: The nested dictionary to return a deepcopy of
:return: A deepcopy of a nested dictionary
"""
# Copy the upper level... | 09e3c0d4eecf88613b25a7344ad3ca9f4ea8c23b | 108,605 |
def uniq(l: list) -> list:
"""Return unique elements from l"""
return list(dict.fromkeys(l)) | d96171b0eff66180222e1b48ee553aec4dda40da | 575,671 |
from bs4 import BeautifulSoup
def extract_internal_links(HTML):
"""
Looks through HTML and extracts internal hyperlinks
"""
soup = BeautifulSoup(HTML)
link_list = [link.get('href') for link in soup.find_all('a')]
return link_list | 32150de06eb796572c3651ca2399d74a5bcae643 | 376,910 |
def cutlabel(s, cuts):
"""Cuts a string s using a set of (n, label) cuts.
Returns a list of (sub, label) pairs.
If there was an initial part before the first cut, then it has a label of None.
If there are no cuts, returns s as a single element, with label None.
"""
cuts = sorted(cuts)
# no c... | 2f81a64d24dc0d31ff6671f2cc8459a38e3af51c | 668,956 |
def formatIntervalSeconds(cSeconds):
""" Format a seconds interval into a nice 01h 00m 22s string """
# Two simple special cases.
if cSeconds < 60:
return '%ss' % (cSeconds,);
if cSeconds < 3600:
cMins = cSeconds / 60;
cSecs = cSeconds % 60;
if cSecs == 0:
re... | eca067323d84cd3d6ea72dffe4d0658c86e896af | 465,028 |
def time_str_to_int(s: str) -> int:
"""
Convert 24-hour or 12-hour time string to int hour of the day
Parameters
----------
s : str
24-hour or 12-hour time string
Returns
-------
int
Hour of the day between [0,24)
"""
if ":" in s:
# this is a 24-hour str... | aa9d653e2caff24cb06b8f9761f0a5436689f711 | 404,868 |
def find_diff(g, start):
"""
g -> Graph of states of nibbles
start -> Starting configuration
Find all possible differentials given a start configuration. The function
returns a tuple containing:
1. the number of rounds
2. a list of all possible end states (second-last round)
3. a list o... | 74f24be96f057e2810fed6de6bb7753be31092d5 | 691,450 |
def filter_dicom(dcmdata):
"""Return True if a DICOM dataset should be filtered out, else False"""
comments = getattr(dcmdata, 'ImageComments', '')
if len(comments):
if 'reference volume' in comments.lower():
print("Filter out image with comment '%s'" % comments)
return True
... | 6b38e3dd12e032e9f56c07717c7296c276cbb01a | 196,100 |
def first(iterable, default=None, key=None):
"""Return first element of *iterable* that evaluates to ``True``, else
return ``None`` or optional *default*. Similar to :func:`one`.
>>> first([0, False, None, [], (), 42])
42
>>> first([0, False, None, [], ()]) is None
True
>>> first([0, False,... | 2b389efbb7b3630f9e21613b3ba62f8ea44d8f7f | 395,860 |
def frags_in_cutoff(fragList, cutoff, center_ip_id):
"""Return list of indices of frags within cutoff from central ion pair excluding central ion pair."""
indexes = []
for i in range(len(fragList)):
if fragList[i]["dist"] < cutoff and i != center_ip_id:
indexes.append(i)
return inde... | 40a20823eb30b3c6a2b91a5802bbe1d94e6a37db | 118,488 |
def transcribe(seq: str) -> str:
"""
transcribes DNA to RNA by replacing
all `T` to `U`
"""
#.replace() function iterates through letters of seq & replaces "T" with "U" (effectively transcribing the DNA sequence)
transcript = seq.replace("T", "U")
return transcript | 5c1af98f5ff76c9d3ac670471843dd8abe6bde4b | 259,393 |
def pictures(listing):
"""Score by number of images."""
nimages = len(listing.images)
if nimages == 0:
return -500
elif nimages == 1:
return -200
elif nimages < 4:
return 0
else:
return 200 | c9a9a2cf089a1f2a9b0e00c104c5ccdb46e79260 | 579,991 |
import math
def vector_angle(x, y):
"""
A method which returns the angle of a vector.
Parameter(s):
-------------
x : Integer/Float
x-axis value of vector.
y : Integer/Float
y-axis value of vector.
Returns:
--------
theta : ... | 691303f63741c159e6a588294e7b41cdfb96fd83 | 449,433 |
def get_target(model, observation):
"""Get target from observation."""
if model.model_kind == "dynamics":
target = observation.next_state
elif model.model_kind == "rewards":
target = observation.reward
elif model.model_kind == "termination":
target = observation.done
else:
... | fc5f6ba3af330279172d2adb3f35f1079cd60e40 | 544,889 |
from typing import Sequence
from typing import List
def indent_iterable(elems: Sequence[str], num: int = 2) -> List[str]:
"""Indent an iterable."""
return [" " * num + elem for elem in elems] | efb7ca21051aa798ec853ed2544df5ca1f3e24b0 | 557,274 |
import pickle
def load_data(file):
"""Load (preprocessed) data from file."""
with open(file, 'rb') as dr:
X = pickle.load(dr)
gene_names = pickle.load(dr)
return X, gene_names | 8e1729e2cf9b76ce47ae4fcbbecda97f235cdb8e | 657,700 |
import math
def _2d_rotate(position, angle_degrees):
"""rotate a 2d vector around an angle (in degrees)"""
radians = math.radians(angle_degrees)
# take the negative of the angle because the orientation circle works clockwise in this world
cos = math.cos(-radians)
sin = math.sin(-radians)
x, y ... | cd031deef2ed1be59ffa03214055ede3277d7912 | 632,154 |
import torch
def normalize_0_1(input: torch.Tensor) -> torch.Tensor:
"""
Normalize a given tensor to a range of [0, 1]
:param input: (Torch tensor) Input tensor
:param inplace: (bool) If true normalization is performed inplace
:return: (Torch tensor) Normalized output tensor
"""
# Perform ... | 45c70dde803b05b1afe2ce52fdf9cdd12dbe0cfb | 409,402 |
def volpiano_characters(*groups):
"""Returns accepted Volpiano characters
The characters are organized in several groups: bars, clefs, liquescents,
naturals, notes, flats, spaces and others. You can pass these group
names as optional arguments to return only those subsets:
>>> volpiano_characters(... | af361f302fc531828655e1274e7c0868969c2fdc | 60,839 |
import csv
def read_csv_metrics(path):
""" Read a metrics summary file produced by superpmi, and return the single row containing the information as a dictionary.
Args:
path (str) : path to .csv file
Returns:
A dictionary with each metric
"""
with open(path) as csv_file:
... | a397333fac6e591012cacc35274cfc8a3686f91e | 170,033 |
import fnmatch
def in_list(patterns, name):
"""
Return true if name matches at least one pattern in the list.
"""
for pattern in patterns:
if fnmatch.fnmatch(name, pattern):
return True
return False | a05b78c6d879580683ebf617f889290cb1fa98b0 | 179,877 |
def normalizeExpression(licsConcluded):
"""
Combine array of license expressions into one AND'd expression,
adding parens where needed.
Arguments:
- licsConcluded: array of license expressions
Returns: string with single AND'd expression.
"""
# return appropriate for simple cases
... | d65d60ed5dc24e4220b2cfac87ab9e5ce4abd794 | 360,065 |
def reverse_enumerate(l):
"""Like enumerate but in the other direction
Usage::
>>> a = ['a', 'b', 'c']
>>> it = reverse_enumerate(a)
>>> it.next()
(2, 'c')
>>> it.next()
(1, 'b')
>>> it.next()
(0, 'a')
>>> it.next()
Traceback (most recent call last):
File "<stdin>"... | 14cb2d145d0f23c7bed626f6eb5b2af878acec30 | 130,073 |
def convert_to_float(lst, purpose):
"""
Returns list of all float-convertable values of `lst`,
along with length of new list
"""
float_times = []
len_times = 0
for t in lst:
if (str(t)[:3] != 'DNF') and (t != '') and (str(t)[-1] != '+'):
float_times.append(float(t))
... | 83ad621eccb38fab848533c2ea8f61846b8bad1e | 235,253 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.