content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def gather(x, indices):
"""
Return the sequence [x[i] for i in indices].
>>> gather([8, 16, 32, 64, 128], [3, 0, 2])
[64, 8, 32]
>>> gather([8, 16, 32, 64, 128], [])
[]
"""
return [x[i] for i in indices] | 821a28ddae859fb60e0228eef16622691a83dbd0 | 198,336 |
from typing import Sequence
from typing import Union
from typing import List
from typing import Tuple
def scale_with_abs_strides(seq: Sequence[float],
strides: Sequence[Union[Sequence[Union[int, float]], Union[int, float]]],
dim_idx: int,
... | a191ef66508e81681cc90c98f60d4e7f2a12445f | 512,425 |
from typing import List
def load_words(file: str) -> List[str]:
"""
Loads words from input file where there is a word in every line.
:param file: path to file
:return: List of words
"""
with open(file) as f:
words: List[str] = f.readlines()
return words | ced5398f3232f1a55d8c44d2f362fbb06366df3b | 570,585 |
import torch
def AbsDepthError_metrics(depth_est: torch.Tensor, depth_gt: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
"""Calculate average absolute depth error
Args:
depth_est: estimated depth map
depth_gt: ground truth depth map
mask: mask
"""
depth_est, depth_gt = dep... | 9a65c5c089ad1c43035ac01c1ca91885328c22a7 | 296,442 |
import random
def SimpleRandomSample(sample_set, sample_size):
"""
A simple random sample is a sample in which every member of the population has an equal chance of being chosen.
:param sample_set: set of values to select from
:param sample_size: number of values to select
:return: result sample
... | 946da14fbeec5fb79ab005e9a2ecbd0f1fbbb89b | 325,878 |
def clean_xml_attribute(element, attribute, default=None):
"""
Get an XML attribute value and ensure it is legal in XML
:param element:
:param attribute:
:param default:
:return:
"""
value = element.attrib.get(attribute, default)
if value:
value = value.encode("utf-8", error... | c236a33b124b697cad35a17977b711b2f799737c | 311,984 |
def bisection_search(arr, x, lo=0, hi=None):
"""
Assmues arr is sorted in *ascending* order.
Returns
if x in arr,
x
else:
the index where x should go if we insert by
moving everything after idx to the right
This is the same as bisect.bisect_left(arr, x)
"""
if not hi:
hi = len(arr)
while lo < ... | 6fe894920f24734b69fad4186f9d89c817a1ab88 | 482,905 |
from pathlib import Path
import secrets
def _get_download_token() -> str:
"""Return a download token from ~/.deeppavlov/token file.
If token file does not exists, creates the file and writes to it a random URL-safe text string
containing 32 random bytes.
Returns:
32 byte URL-safe text string... | 357edba8297b5aae8ee9f176911fdd55455320f0 | 553,361 |
import socket
import struct
def int_to_ip_address(i):
"""
Convert an integer to an IP address
:param i: The number to convert
:return: The IP address in octet notation
"""
return socket.inet_ntoa(struct.pack('!L', i)) | 6647cadbc2c17d093abf6be68975947a37417b16 | 374,293 |
def get_module_names(thread):
"""
Returns a sequence of module names from the stack frames of this thread.
"""
def GetModuleName(i):
return thread.GetFrameAtIndex(
i).GetModule().GetFileSpec().GetFilename()
return list(map(GetModuleName, list(range(thread.GetNumFrames())))) | 101470cb441acf445c1d084d13698564d7d858a3 | 582,159 |
import random
def probability(p):
"""Return true with probability p."""
return p > random.uniform(0.0, 1.0) | 010f68e2aed25e24bdf9d24f737c1bd5d1da3da0 | 461,220 |
import torch
def split(value, num_or_size_splits, axis=0):
"""
Splits a tensor into sub tensors.
Parameters
----------
value : tensor
The Tensor to split.
num_or_size_splits : list
Either an integer indicating the number of splits along split_dim or a 1-D integer Tensor or
... | b997285da46db1e20ca92916f46ebc51b8840786 | 31,366 |
def get_len_of_range(start, stop, step):
"""Get the length of a (start, stop, step) range."""
if start < stop:
return ((stop - start - 1) // step + 1)
return 0 | 7335a322a2c4d7d56e5e0cec2264f57235c0c6a9 | 156,035 |
def flatten_path(path):
"""Returns the file name in the path without the directory before"""
return path.split("/")[-1] | 05863693d1bc0dc46671de55d7d9d0842d282fae | 173,011 |
from pathlib import Path
import tempfile
def tmp_file(**kwargs) -> Path:
"""
Creates NamedTemporaryFile and returns associated pathlib.Path
:param kwargs: NamedTemporaryFile arguments
:return: pathlib.Path(temp_file)
"""
kwargs['delete'] = kwargs.get('delete', False)
return Path(tempfile.N... | 9be1934f68e6c5510e7e1b0591149ec3e83d5cb5 | 460,581 |
import re
def find_values_in_quote(question):
"""
We try find all values in quotas, as this are almost always values we need later.
We support a variety of different quota utf-8 characters.
"""
matches = re.findall(r"\s[\"'‘“’](.+?)[\"'’”]", question)
return [m for m in matches] | 80052f0b8f85cd432d73146f3a9a680b87abc8e7 | 390,591 |
from typing import Callable
from typing import Any
from typing import Sequence
def foldl(fun: Callable[[Any, Any], Any], acc: Any, seq: Sequence[Any]) -> Any:
"""Implementation of foldl in Python3.
This is an implementation of the left-handed
fold function from functional programming.
If the list is... | b21d0dd4ee203f913987809eb438fad668260ef1 | 420,629 |
def calculate_pos_deviation_square(error, sl):
"""
Calculate the square deviation between a given error value and a significance level
if the deviation is positive (>0)
Parameters
----------
error : error
sl : significance level
Returns
-------
square deviation or 0
... | cfa327207202e23db855daa17fd48ee29648ce50 | 312,473 |
def mpi_isend_object(comm, data, dest_rank):
"""
Send Python object to another MPI rank in a non-blocking way.
Parameters
----------
comm : object
MPI communicator object.
data : object
Data to send.
dest_rank : int
Target MPI process to transfer data.
Returns
... | 9831fceb8164bd6591ab01f6891f965272a3bbf9 | 429,976 |
def _diff_dict(orig, new):
"""Return a dict describing how to change orig to new. The keys
correspond to values that have changed; the value will be a list
of one or two elements. The first element of the list will be
either '+' or '-', indicating whether the key was updated or
deleted; if the key... | 72626d30b81333486d919045604262c9e6c7fb11 | 543,982 |
def datetime_format(datetime_obj, fmtstring = '%Y-%m-%d'):
"""
A function to string format a datetime.datetime object.
"""
return datetime_obj.strftime(fmtstring) | a64ce81cb28c59489bff3d57751feebb818e04c5 | 694,658 |
def create_html_link(url, text):
"""Wrap a text into an html anchor element with a specified url."""
line = f"<a href='{url}'>{text}</a>"
return line | 43d0085a826b23b8441bb3e6ccf8035268be9ae8 | 320,696 |
from datetime import datetime
def format_t(t):
"""
Formats the date strings of a Wikidata entry
"""
if t is not None:
return datetime.strptime(t[1:11].replace("-00", "-01"), "%Y-%m-%d").date()
else:
return t | e230aee8999edf63f88ca64e2cac03a709a6e931 | 433,488 |
def union_probability(p_a, p_b, p_intersection):
"""Compute the probability of P(A or B) given P(A), P(B) and P(A and B)"""
return p_a + p_b - p_intersection | a280e62008a2bf3dfeb4b7df5d31f5eb531f9341 | 574,219 |
import re
def regstrip(string, char_to_remove=None):
"""Does the same thing as the strip() method using regex:
- without 2nd argument it removes all the whitespace characters
- 2nd argument provides possibility to remove custom characters,
must be given as a string"""
if char_to_remove:
pattern = str('[' + c... | 77f86d650325710c06b126eff482632a898092f7 | 607,364 |
def calc_suma_recursiva(n:int=10) -> int:
"""
Calcula la suma recursiva de los n primeros números
Valor predefinido: 10
:param n: número de números a sumar
:type n: int
:return: suma de los n primeros números
:rtype: int
"""
if n == 0:
return 0
else:
return n + c... | d17b92531270160601981f0c8683a8e324fa8a3d | 49,800 |
import platform
def get_command(command):
"""
@brief Ensures command can be executed on each platform
@param command The commands name
@return A platform appropriate command
"""
if platform.system() == "Windows":
command += ".exe"
return command | e761078dcf70216283fcab4967fde42393d3d699 | 611,143 |
import re
def parse_python_func_imports(func_str):
"""Get a list of import statement lines from a (string) Python function."""
import_lines = func_str.split('def ')[0].strip()
match = re.search(r'((?:import|from)[\S\s]*)', import_lines)
out = []
if match:
out = match.group(1).splitlines()... | bfe6966cf090642a057f3a9e135c3bdca30adf1e | 405,473 |
def get_pk_column(self):
"""
Gets the primary key column.
"""
return self.query.get_meta().pk.column | 143d0cd7383186631f615eeaf4d9c67579c7067e | 61,112 |
def fromname(self,name):
"""Return the particle data given the PDG name. Returns None if not found."""
for id in self.ids():
if self[id].name == name: return self.get(id)
return None | 266631bd84ad0b59c56f5aa5032ec3bfcb5c0fbe | 103,520 |
def _filter_chain(accumulated, additional):
"""
Given two functions that take a block_key and return a boolean, yield
a function that takes a block key, and 'ands' the functions together
"""
return lambda block_key: accumulated(block_key) and additional(block_key) | 70479841e85eaf2cee40a5e48232eafb8592324c | 365,965 |
def is_same_week( date1, date2 ):
"""Checks whether two dates are within the same week"""
return date1.year == date2.year and date1.strftime( '%W' ) == date2.strftime( '%W' ) | 96706989bc6912c1e1d079013af28f5f2828499f | 494,278 |
def hr_bytes(n):
"""
Human readable bytes value
Notes:
http://code.activestate.com/recipes/578019
Args:
n (int): bytes
Returns:
string: human readable bytes value
"""
symbols = (u'K', u'M', u'G', u'T', u'P', u'E', u'Z', u'Y')
prefix = {}
for i, s in enu... | 3f84e4b19b153cf40da7893e1bb80a89621606d6 | 84,217 |
import re
def FillParagraph(text,width=70,indentLinesBy=0):
"""
>>> txt = "123 567 90 123\\n456 89\\n"
>>> print FillParagraph(txt,width=10)
123 567 90
123 456 89
>>> print FillParagraph(txt,width=10,indentLinesBy=3)
123 567 90
123 456
89
>>> txt = '123 567 \\n'
>>> print FillParagraph... | d5cbc05c090ecca5f64fa519e2772b2154b029bd | 671,646 |
def num_periods(period_duration, last_fixed_date, current_date):
"""Return the number of periods in a date range.
Arguments:
period_duration - the timedelta of a period.
last_fixed_date - the date that the daystate was last specified.
current_date - the date in question.
"""
ret... | 4a6233d66a4928383ceeaf91c0066959188de409 | 327,498 |
def min_shape(args):
"""Returns the minimum shape that encompasses the shape of all *args*."""
args = tuple(args)
if len(args) <= 0:
raise ValueError("args must not be empty.")
elif not all(len(a) == len(args[0]) for a in args):
raise ValueError("All shapes must have the same number of d... | d1494a6a8f00f8dab84c57fea44bb91dac7df805 | 609,560 |
def _int(data):
"""Convert byte data to big-endian int."""
return int.from_bytes(data, byteorder="big") | cba161951138486a8bbe8ef21a7de4a15cc9cc5b | 484,113 |
def is_start_of_new_sequence_item(line):
"""
Checks whether line is the first line of sequence item data
"""
return line[0] == '>' | f9b3a43bac52b4333b5d4bba24e266351fa807a9 | 163,463 |
import operator
def get_operator_function(op_sign):
"""
Get operator function from sign
Args:
op_sign (str): operator sign
Returns:
operator function
"""
return {
'>': operator.gt,
'<': operator.lt,
'>=': operator.ge,
'<=': operator.le,
... | 6b3a3f23335d499400e12071b421a4f34b1acffc | 673,595 |
def hex_rotate_60(x, y, z, n=1):
"""Rotates the given hex n * 60 degrees counter clockwise around the origin,
and returns the co-ordinates of the new hex."""
n = n % 6
if n == 0:
return x, y, z
if n == 1:
return -y, -z, -x
if n == 2:
return z, x, y
if n == 3:
... | 247e3d47877003e4ad260e74f8cbc7451f5ac168 | 172,765 |
def exp_lr_scheduler(optimizer, epoch, init_lr=0.001, lr_decay_epoch=7):
"""Decay learning rate by a factor of 0.1 every lr_decay_epoch epochs."""
lr = init_lr * (0.1**(epoch // lr_decay_epoch))
#if epoch % lr_decay_epoch == 0:
#print('LR is set to {}'.format(lr))
for param_group in optimizer.... | ba61d1cef53971a5cad0b9187e7e405c6338e43d | 353,187 |
from typing import Union
def count_occurrences(lst: list, value: Union[bool, str, int, float]) -> int:
"""Function to count occurrences of value in a list"""
return len([x for x in lst if x == value and type(x) == type(value)]) | 498df555356bb08d3c01eac29892e54334bb22ef | 226,598 |
def income1(households):
"""
Dummy for for income group 1
"""
return (households['income_category'] == 'income group 1').astype(int) | 26f4c5f9f1cb6c56bfc4d5bb8410d4b31516d628 | 658,288 |
def fibonacci(i):
"""
This function finds the ith number in the Fibonaci series, -1 otherwise.
"""
if i <= 0:
return -1
#Fixing the code to see if test cases go through
if i <= 2:
return 1
prev = 1
curr = 1
for k in range(i-2):
temp = curr
curr += prev
prev = temp
return curr | 223b5cdeea2e94623317304ae1fafd8921772e13 | 618,718 |
def same_base_index(a, b):
"""Check if the base parts of two index names are the same."""
return a.split("_")[:-1] == b.split("_")[:-1] | 6186230a9cb982be4cd113c2e8098e8ab472159b | 38,776 |
def format_hex(row_hash, col_hash, size=8):
"""Format dhash integers as hex string of size*size//2 total hex digits
(row_hash and col_hash concatenated).
>>> format_hex(19409, 14959, size=4)
'4bd13a6f'
>>> format_hex(1, 2, size=4)
'00010002'
"""
hex_length = size * size // 4
return ... | c0b6ad3ba0967e13f48eb2a7d7cfd82be6574834 | 363,139 |
import torch
def adj_to_seq(adj, device='cpu'):
"""
Convert a dense adjacency matrix into a sequence.
Parameters
----------
adj : torch.Tensor
The dense adjacency tensor.
device : str, optional
The device onto which to put the data. The default is 'cpu'.
Returns
-----... | 6b967962d5ba61a0ad45d5197ca23a7278fccca9 | 17,145 |
def is_comp_node(graph, node):
"""Returns True for Component or PseudoComponent nodes."""
return 'comp' in graph.node.get(node, '') | 2f6abcb41a54b07a4a6cb1de4637db3d0ac7fa07 | 581,315 |
from typing import Tuple
def new_location(location: Tuple[int, int], offset: Tuple[int, int]) -> Tuple[int, int]:
"""
Performs the offset move on the given location and returns the new position.
:param location: the location of the piece
:param offset: the direction to move piece in
:return: the ... | 8f89d32db7b1162c39d5ddfac4ded3c784b0ab2f | 486,499 |
def get_sig(pval):
"""Returns asterisk depending on the magnitude of significance"""
if pval < 0.001:
sig = '***'
elif pval < 0.01:
sig = '**'
elif pval < 0.05:
sig = '*'
else:
sig = 'ns' # non-significant
return sig | 99ccf5b4d4c78e21d8b0d7179e0143eee4bd5736 | 399,414 |
import json
def to_json_string(my_obj):
"""Returns the JSON representation of an object (string).
Arguments:
my_obj {obj} -- object
Returns:
str -- Serialize obj to a JSON formatted str
"""
return json.dumps(my_obj) | 17aa3155454c0a5e957bd0ad9cd3a14752fc0378 | 460,156 |
def create_document1(args):
""" Creates document 1 -- an html document"""
return f"""
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
</head>
<body style="font-family:sans-serif;margin-left:2em;">
<h1 style="font-family: 'Trebuchet MS', Helvetica, sans-ser... | 9f75267e13440cfbf98b0bdc94bdc86f50ffda92 | 647,841 |
def find_parent_fnames(var):
"""
Find full names of parents, recursively.
These names will be forbidden in the subsequent resolution to make sure
there's no back branch in the constructed DAG.
"""
names = [var.fname] # No self-referential
if var.parent:
names.append(var.parent.fnam... | e0b32984275a80b14851bba9ecb357a4628d1d54 | 665,206 |
import re
def ParseErrorDetail(e):
"""Parse <Message> and/or <Details> text from XML content.
Args:
e: The GSResponseError that includes XML to be parsed.
Returns:
(exception_name, m, d), where m is <Message> text or None,
and d is <Details> text or None.
"""
exc_name_p... | 071e7d2388b7d4538103556e4badaa4902b65a2e | 429,591 |
from collections import Counter
def most_common(words, n=10):
"""
Returnes the most common words in a document
Args:
words (list): list of words in a document
n (int, optional): Top n common words. Defaults to 10.
Returns:
list: list of Top n common terms
"""
bow = Co... | c4f0adecdec09cb3b2a83e9edbd39eb1789ad592 | 688,948 |
def option_name(path, delimiter="--"):
"""
Returns a cli option name from attribute path
**Arguments**
- path (`list`): attribute path
- delimiter (`str`): delimiter for nested attributes
**Returns**
cli option name (`str`)
"""
return "--{}".format(delimiter.join(path).replace("... | 0beab1b60f5ec479e70a4e12af799ca5efe0230a | 679,656 |
def get_scale_at_res(base_scale, res, iso=False):
"""Returns voxel resolution at a given resolution of precomptued volume
res=0 is base resolution
Raises: ValueError if any element in base_scale < 1
"""
try:
assert all([s >= 1 for s in base_scale])
except AssertionError:
raise V... | bf1fd19e6ef4ef542a7388a548485c084fbafa33 | 382,387 |
def text_to_string(filename):
"""Read a text file and return a string."""
with open(filename) as infile:
return infile.read() | dbd79e78c84c3374c0252544086885b909ae9bd9 | 4,590 |
def ptfhost(testbed_devices):
"""
Shortcut fixture for getting PTF host
"""
return testbed_devices["ptf"] | 25fdbc9520c4cda9719887ff213ccb2b88918dcc | 11,397 |
def convert(dataset: str) -> str:
"""Translates the CLI argument name into the Metadata value for the ISIC archive."""
return {
"bcn_20000": "BCN_20000",
"bcn_2020_challenge": "BCN_2020_Challenge",
"brisbane_isic_challenge_2020": "Brisbane ISIC Challenge 2020",
"dermoscopedia_cc_... | cb5114817d1fa7a195156b75c699865cabac7432 | 257,737 |
def __get_target(flag_iterator, details):
"""
This function consumes --target or -target flag which is followed by the
compilation target architecture.
This target might be different from the default compilation target
collected from the compiler if cross compilation is done for
another target.
... | f71fef6ab0987c371a217f7702bf097233f32034 | 162,575 |
def all_same(items):
"""Quick check if all items are the same.
Identical to a check like len(set(items)) == 1 but
should be more efficient while working on generators, since would
return False as soon as any difference detected thus possibly avoiding
unnecessary evaluations
"""
first = True... | c78007ade57a1e1cdec42a41e76cd9b1b4830287 | 526,942 |
def create_stop_poll_text() -> str:
"""Returns message for stopping a poll."""
return 'Вы прервали прохождение опроса.' | d3bedcdd77801f507aade01ecac42c739ddb3e15 | 377,940 |
import unicodedata
def remove_diacritics(input_str: str) -> str:
"""Remove diacritics and typographical ligatures from the string.
- All diacritics (i.e. accents) will be removed.
- Typographical ligatures (e.g. ffi) are broken into separated characters.
- True linguistic ligatures (e.g. œ) will remain... | 23c3e9ce0029704f0012a825460f10f370e3c681 | 5,099 |
import torch
def _jitable_shape(tensor):
"""Gets shape of ``tensor`` as ``torch.Tensor`` type for jit compiler
.. note::
Returning ``tensor.shape`` of ``tensor.size()`` directly is not torchscript
compatible as return type would not be supported.
Args:
tensor (torch.Tensor): Tensor... | 1e639002da90c1890a52db99947e728aaa6d184e | 375,729 |
def parse_software_uuid(s):
"""parses '/software/lalala/' or '/software/lalala' into 'lalala'
if input is already 'lalala', returns 'lalala' as well.
if something else, returns None
"""
ss = s.split('/')
if len(ss) == 4 or len(ss) == 3:
return(ss[2])
elif len(ss) == 1:
return... | 56e7a06daededa4294a8181992cef1562dbda069 | 526,452 |
def split_feature_targets(train_df, test_df):
"""
Splits the training dataframe and test dataframe into X_train, y_train & X_test, y_test
Parameters:
train_df (pandas DataFrame object): the training dataframe
test_df (pandas DataFrame object): the test dataframe
Returns:
X_train (pandas Da... | b6a609414c481a66b65f7c6ac26b7363c59bab85 | 466,685 |
def n_fib(n):
"""
Find the nth Fibonacci Number.
:param n: Nth element in the fibonacci series.
:return: returns None if n is 0 otherwise returns the nth Fibonacci Number.
"""
if n == 0:
return None
if n == 1 or n == 2:
return n - 1
a, b = 0, 1
for i in range(2, n)... | 542cb2dec18f4bd418a412c3255900e784b99f31 | 144,721 |
import time
import requests
import uuid
import webbrowser
def _check_for_api(port: int = 10000, launch_browser: bool = False, timeout: int = 5):
"""Check for the API to be live for up to `timeout` seconds, then optionally launch a browser window
Args:
port(int): port the server is running on
... | e63a499b556d4b67331b4bb6fa4c8078a6f59b11 | 426,259 |
def rename_datetimes(df):
"""Renaming tpep_pickup_datetime and tpep_dropoff_datetime into pickup_datetime, dropoff_datetime"""
print("renaming datetimes")
df = df.rename(columns={'tpep_pickup_datetime': 'pickup_datetime',
'tpep_dropoff_datetime': 'dropoff_datetime'})
... | 40a42343aa6cb915b7f35ac8b11d237702941e0e | 155,384 |
def human_string(text: str) -> str:
"""
Transform text to human string
Args:
text: string to be converted
Returns:
converted string
Examples:
>>> human_string('test_str')
'Test Str'
>>> human_string("")
''
"""
if not text:
return ""
... | 5bc851e88228345ad67334b7405c765d34a01aff | 370,438 |
def nearest(geom, gdf):
"""Find the element of a GeoDataFrame nearest a shapely geometry"""
matches_idx = gdf.sindex.nearest(geom.bounds)
nearest_geom = min(
[gdf.iloc[match_idx] for match_idx in matches_idx],
key=lambda match: geom.distance(match.geometry),
)
return nearest_geom | f7354c81b2e4f6e46e4841bc906bd36be7910397 | 395,288 |
def set_tr_te(nifti_image, repetition_time, echo_time):
"""
Set the tr and te in the nifti headers
:param echo_time: echo time
:param repetition_time: repetition time
:param nifti_image: nifti image to set the info to
"""
# set the repetition time in pixdim
nifti_image.header.structarr[... | 78ea174f9b234fbe248b5205bab604fefbb944fc | 376,331 |
def _request_cache(request, key):
"""
Returns (or create) a linked object dictionary usable past as cache with
visibility equal to that of the request.
"""
try:
return request._conf_cache[key]
except KeyError:
request._conf_cache[key] = {}
except AttributeError:
reque... | e2a12ebff2e3d4d7ff9326581def48a042df1df0 | 364,719 |
def return_period_from_string(arg):
"""
Takes a string such as "days=1,seconds=30" and strips the quotes
and returns a dictionary with the key/value pairs
"""
period = {}
if arg[0] == '"' and arg[-1] == '"':
opt = arg[1:-1] # remove quotes
else:
opt = arg
for o in opt... | f3f70df82c1567d0b2f329c5add15d64b9b8b115 | 120,440 |
def aic(k,lnL):
"""
Akaike Information Criterion -- the lowest value is preferred.
INPUT:
k - number of parameters in the model
lnL - log likelihood
NOTES:
The relative likelihood is definied as exp(Delta AIC/2) Grunblatt et al. 2015
https://en.wikipedia.org/wiki/Akaike_in... | 8720aeebdd0827533a3c523a19cca93e30abc945 | 354,114 |
def error_tex_in_output(output: str) -> bool:
"""parses tex output looking for fatal errors"""
return ("Fatal error" in output) or ("no output PDF" in output) | a853257ec2f47b467ab486b7838e0ed6ec7803d7 | 392,790 |
import glob
def get_unprocessed_cves(directory: str) -> list:
"""Returns a list of CSV files to upload and process.
Args:
directory (str): Directory to look in for CSVs.
Returns:
cve_files (list): List of files to be processed and uploaded.
"""
cve_files = []
paths = glob.g... | bc026f21456d15a20b7fab9df5f7bc47f648b4ae | 303,006 |
def top_nucs(df, top_n):
"""
loops through the rows of a dataframe and keeps a list of the top_n
nuclides (by concentration) from each row
Parameters
----------
df : dataframe of nuclide concentrations
top_n : number of nuclides to sort and filter by
Returns
-------
nuc_se... | fd30d66be6dc93db28f5c92ade6fcfff254f0331 | 500,912 |
def string(value: str = ''):
"""
A constant string.
Parameters
----------
value : str
The string value.
"""
return value | 67237062f7f13a978aadb6256504ff45db40fbd0 | 419,844 |
import math
def translate_random_number(number, start, stop):
"""
Helper function to translate a random number 0 <= x <= 1 to integer
between start <= x <= stop
"""
return int(math.floor(number * (stop - start) + start)) | 0302bb9c02cbc1a51b4b3411ded9e3c51c44055c | 489,265 |
def db2lin(value):
"""Convert logarithimic units to linear
>>> round(db2lin(10.0), 2)
10.0
>>> round(db2lin(20.0), 2)
100.0
>>> round(db2lin(1.0), 2)
1.26
>>> round(db2lin(0.0), 2)
1.0
>>> round(db2lin(-10.0), 2)
0.1
"""
return 10**(value / 10) | 8840989dc365eee46e7836749d3fc8fff14dc048 | 627,850 |
def login_to_dict(login):
"""Creates a Python dict for a Login database entity.
This is not a method of the Login model because it is not normally needed
by the Liblio server. It's admin-only, so it can be considered private to
this controller.
Note: This does expose user email addresses, so use w... | f623f1a8724140c7be0b11d613ae422dc94d63d1 | 261,698 |
import time
def yearmonthday(t):
"""
Returns a tuple (year, month, day) with 1 <= month <= 12
and 1 <= day <= 31
"""
return tuple(int(x) for x in time.strftime("%Y %m %d", time.gmtime(t)).split()) | 18df233c98ba7c530e8d73b8f61752432cc5cc66 | 548,594 |
def count_lines_exception(filename):
"""
Count the number of lines in a file.
If file can't be opened, treated the same as if it was empty
"""
try:
return len(open(filename, 'r').readlines())
except (EnvironmentError, TypeError):
print('Exception error')
return 0 | cce821eacd535235165301aa23126bf93b8b49ff | 488,316 |
def rreplace(s, old, new, occurrence=-1):
"""
Replace old with new starting from end of the string
:param s: The string to be transformed
:param old: Search string
:param new: Replacement string
:param occurrence: Number of replacements to do
:return:
"""
li = s.rsplit(old, occurrenc... | 132a2b376f623726bb06dad48c8598a208b1d5c1 | 264,182 |
def _fetch_json(sess, url):
"""\
Fetches the provided url and returns the JSON result as dict.
:param sess: requests.Session
:param url: The URL to fetch.
:rtype: dict
"""
res = sess.get(url)
dct = res.json()
if dct['status'] != 'OK':
raise Exception('Unexpected result "%s"'... | fa4bcb4ed052031bb37611db46c722015c3f4685 | 532,454 |
def list_index(ls, indices):
"""numpy-style creation of new list based on a list of elements and another
list of indices
Parameters
----------
ls: list
List of elements
indices: list
List of indices
Returns
-------
list
"""
return [ls[i] for i in indices] | 7e5e35674f48208ae3e0befbf05b2a2e608bcdf0 | 703,770 |
def _merge_sequences(inp):
"""Merge a list of input sequence patterns for use in a regular expression.
Order by lengthyness (full sequence set precedent over subset),
and exclude any empty (u'') sequences.
"""
return sorted(list(filter(None, inp)), key=len, reverse=True) | 681adecf257c08d1080915832d79d4cbd46cdadb | 403,961 |
def convert_kg_to_target_units(data_kg, target_units, kg_to_kgC):
"""
Converts a data array from kg to one of several types of target units.
Args:
data_kg: numpy ndarray
Input data array, in units of kg.
target_units: str
String containing the name of the units ... | c39022c862b48cd8f8bd47da2b9e004828fd7994 | 183,831 |
import torch
def get_last_conv(m):
"""
Get the last conv layer in an Module.
"""
convs = filter(lambda k: isinstance(k, torch.nn.Conv2d), m.modules())
# print('convs:', convs)
# print('list(convs)[-1]:', list(convs)[-1])
return list(convs)[-1] | 1a8c7fa6f37fd7dabd766f7ad9f78eab2f7401a2 | 575,387 |
def format_timestamp(dt):
"""
Format the given timestamp.
:param datetime.datetime dt: A datetime.datetime object to be formatted.
"""
return dt.strftime('%Y-%m-%dT%H:%M:%S.999-05:00') | 62fb92acb57d7a2c4c1b89630a42859f52d44784 | 507,506 |
def parse_rank_specification(s):
"""
Parses info about rank specification, used to filter games by player's ranks.
Returns None (all ranks allowed),
or a set of possible values
(None as a possible value in the set means that we should include games without rank info)
# returns None, all ranks ... | ff7ce2b9940b6cd55bf0fab7bd2f633637fd7cc8 | 651,409 |
def _find_child_node(node, name):
"""Return child with given name from parent node"""
for c in node.children:
if c.frame.get("name") == name:
return c
return None | 455148bb38225fe3e83c182503c48b7189fb3eed | 572,401 |
def get_ext_info(hdu):
"""
Returns name, type and size of a specified HDU extension
:param hdu: a single extension of a multiextension HDU item
:type hdu: astropy.io.fits.hdu.image class
:return: 3- element dictionary with text values for extension name, extension type, and extension size.
"""
... | 67b98d488ee4b2fabc05856c60049356d8586df1 | 113,726 |
def split_by_whitespace(text):
"""Runs basic whitespace cleaning and splitting on a piece of text.
Examples:
>>> _text = '我爱python，我爱编程；I love python, I like programming.'
>>> split_by_whitespace(_text)
['我爱python，我爱编程；I', 'love', 'python,', 'I', 'like', 'programming.']
"""
text... | 4ede92215545aab7a55eac5b0733b91497340c60 | 614,624 |
def convert_metadata_1_0_to_1_1(metadata):
"""
Convert 1.0 to 1.1 metadata format
:arg metadata: The old metadata
:returns: The new metadata
Changes from 1.0 to 1.1:
* ``supported_by`` field value ``curated`` has been removed
* ``supported_by`` field value ``certified`` has been added
... | 16fa60107c36897141d1db490869a20807cbedc2 | 437,585 |
def ReadBlackList(path):
"""Read a blacklist of forbidden directories and files.
Ignore lines starting with a # so we can comment the datafile.
Args:
path: file to load the blacklist from.
Returns:
dictionary of path:True mappings
"""
blacklist_file = open(path, 'r')
catalog = []
for entry in ... | 694b9bd8c09385677d49e8563ac8f08b923cadb0 | 7,018 |
def unit(aClass, value):
""" Calls the 'unit' method of `aClass` with `value`. """
return aClass.unit(value) | 35189da86beb1fc584ff41a5ead63aec6351633f | 592,037 |
import click
def get_help_msg(command):
"""
Print full help message of click def <function>
Ex: print_help_msg(testcmd)
:param command: function that has the click command decorator and help option
:return: a string containting the @click.command() <function> help message
"""
with click.... | a477d3641c52657df18880d2490ff94ff2ebd422 | 238,260 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.