content stringlengths 39 9.28k | sha1 stringlengths 40 40 | id int64 8 710k |
|---|---|---|
def calc_s11_s22_s33(s2211, s1133):
"""Calculates s11, s22, s33 based on s22-s11 and s11-s33 using
the constraint s11+s22+s33=0
"""
s22 = 2.0*(s2211)/3.0 + s1133/3.0
s11 = s22 - s2211
s33 = s11 - s1133
return s11, s22, s33 | 0f65bb93ad6faf518435ebac6808152ca0e43a6f | 401,870 |
def rank_as_string(list1, alphanum_index):
"""
Convert a ranked list of items into a string of characters
based on a given dictionary `alph` of the format that contains
the ranked items and a random alphanumeric to represent it.
Parameters
----------
list1 : list
A lis... | c3de9118abe5ead47e9e84e1682b9a16ead0b5fc | 661,495 |
def is_version_string(string):
"""
Check if a string is version string like 3.0.4-7 or 4.0.37-dev.
Only digits are allowed for version part.
Non-digits are allowed for the revision part, like 4.0.37-dev.
"""
if not string:
return False
tokens = string.split("-")
if len(tokens) > ... | 96f0a75e6012b5670bc907f1d2447aaeed520bed | 482,313 |
def function_label(fxn):
"""Return a (filename, first_lineno, func_name) tuple for a given code object.
This is the same labelling as used by the cProfile module in Python 2.5.
"""
code = fxn.__code__
if isinstance(code, str):
return ('~', 0, code) # built-in functions ('~' sorts at the en... | f120da27fa4aea12155c6dbfaf5d49937122c7a5 | 307,618 |
import logging
def verify_mention_index(original, reconstructed):
"""Verify that reconstruction succeeded relative to original mention_index."""
def df_to_strings(df):
"""Returns unique IDs for the mentions in df."""
return df.apply(
lambda r: "{}:{}-{}".format(r["docid"], r["mention"], r["positi... | 8a73c15345d696fe8a94a3e2c0a7fad10104fbec | 221,818 |
def rfind(s, *args):
"""rfind(s, sub [,start [,end]]) -> int
Return the highest index in s where substring sub is found,
such that sub is contained within s[start,end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return s.rfind(*args) | c420af29df12f62feffad367ae03c500ced04561 | 597,361 |
def get_weekday_occurrence(day):
"""Calculate how often this weekday has already occurred in a given month.
:type day: datetime.date
:returns: weekday (0=Monday, ..., 6=Sunday), occurrence
:rtype: tuple(int, int)
"""
xthday = 1 + (day.day - 1) // 7
return day.weekday(), xthday | 7b22eefe629cd51312d7a8be0908438ab7fef7d6 | 115,929 |
def make_mmvt_boundary_definitions(cv, milestone):
"""
Take a Collective_variable object and a particular milestone and
return an OpenMM Force() object that the plugin can use to monitor
crossings.
Parameters
----------
cv : Collective_variable()
A Collective_variable object whi... | 45baaaa70ea24cb564c529cd885597415561a25d | 704,283 |
def class_to_path(cls):
"""Turn Class (Class or instance) into module path"""
return '%s.%s' % (cls.__module__, cls.__name__) | 9d16346d50a8e3116790d88a7670ad8568b40edb | 347,438 |
def uniqued(iterable):
"""Return list of unique hashable elements preserving order.
>>> uniqued('spamham')
['s', 'p', 'a', 'm', 'h']
"""
seen = set()
return [i for i in iterable if i not in seen and not seen.add(i)] | 3b2bd1d793a4786d7c31da2e21f30b45b9782f64 | 555,696 |
def get_license_link_for_filename(filename, urls):
"""
Return a link for `filename` found in the `links` list of URLs or paths. Raise an
exception if no link is found or if there are more than one link for that
file name.
"""
path_or_url = [l for l in urls if l.endswith(f"/{filename}")]
if n... | 60a445209988214e402fa8612ac1bc371eb01c2c | 97,682 |
def longest_loc_length(book):
"""
Return the length of the longest location key string.
"""
loc_length = 0
for loc_string in book.keys():
if len(loc_string) > loc_length: loc_length = len(loc_string)
return loc_length | 99878c70d91608688d19fc974f86e401ade800cc | 89,153 |
def collapse(values):
"""Collapse multiple values to a colon-separated list of values"""
if isinstance(values, str):
return values
if values is None:
return 'all'
if isinstance(values, list):
return ';'.join([collapse(v) for v in values])
return str(values) | 2b3896ede1d989f6bb303e1b46823751724c8d01 | 309,865 |
from typing import List
def sum_of_multiples(limit: int, factors: List[int]) -> int:
"""Sum of Multiples
Args:
limit: the limit
factors: a list of numbers to find multiples of
Returns:
the sum of all multiples of the factors up to, but not including the limit
"""
# set comprehension... | 92a524c388e88f33ae113fd1a649b622388e1763 | 169,445 |
def read_block(data, startrow):
"""
The function returns a block of rows with some data in a row.
A blank line separates the block.
:param data: Data is a list of tuples, where each tuple represents a row.
The element for tuple is Cell.
:param startrow: Starting row, where function finding bloc... | f9008594d762718c894627a9ba0edd688e7a9bb0 | 514,955 |
def get_tld_from_domain(domain):
"""Get the top level domain from a domain string.
Args:
domain: string with a full domain, eg. www.google.com
Returns:
string: TLD or a top level domain extracted from the domain,
eg: google.com
"""
return '.'.join(domain.split('.')[-2:]) | 9de0680731430a7895a5e62adc9720f3f5c19512 | 505,631 |
def search_tag(resource_info, tag_key):
"""Search tag in tag list by given tag key."""
return next(
(tag["Value"] for tag in resource_info.get("Tags", []) if tag["Key"] == tag_key),
None,
) | 5945631a3de7032c62c493369e82dd330ef2bc47 | 704,483 |
def import_from(import_string):
"""
Imports a function from python module import string
"""
fn_name = import_string.split('.')[-1]
module_name = '.'.join(import_string.split('.')[:-1])
module = __import__(module_name, fromlist=[fn_name])
return getattr(module, fn_name) | 805ea07b9cc387754a4436dae2587944cdea25d2 | 106,571 |
import torch
from typing import List
def reconstruct_encoding_constraints(
x: torch.Tensor, feature_pos: List[int], binary_cat: bool
) -> torch.Tensor:
"""
Reconstructing one-hot-encoded data, such that its values are either 0 or 1,
and features do not contradict (e.g., sex_female = 1, sex_male = 1)
... | b960ecf246e6df92eed90ae2183d274e571c1cd9 | 165,382 |
def dedent(doc_string):
"""Remove any common leading whitespace from every line in text.
This functionality is similar to python's `textwrap.dedent` functionality
https://docs.python.org/3/library/textwrap.html#textwrap.dedent
Args:
doc_string (str): A docstring style string
Returns:
... | 6ed6aecc4736c6f6b3a7bf19501cf691cdcccfd2 | 325,260 |
def prob_mass_green_from_ndvi(ndvi, old_min=0.3, old_max=0.9):
"""
Calculate probability mass for greenness from NDVI values
:param ndvi:
:param old_min:
:param old_max:
:return:
"""
if ndvi < old_min:
return 0
elif ndvi >= old_max:
return 1
else:
new_max ... | cba7ac7679d79d8b6d997c63fe7f9a406a00f023 | 658,700 |
from bs4 import BeautifulSoup
def extract_math_envs(file):
"""
Extract the math environments that are contained in the file (e.g. within '$...$').
:return: A list of the math environments as strings.
"""
soup = BeautifulSoup(file)
def remove_special_chars(math_env):
math_env = math_env... | cfb77d1b380c01ccaf8cdcfee5528555a2631570 | 182,903 |
def assert_equal_length(psg, hyp, sample_rate):
""" Return True if the PSG and HYP have equal lengths in seconds """
return psg.shape[0] / sample_rate == hyp.total_duration | 968776dee6058b137c3c4445e0e8e87b4223e96c | 679,172 |
import torch
import re
def dtype_byte_size(dtype: torch.dtype):
"""
Returns the size (in bytes) occupied by one parameter of type `dtype`.
Example:
```py
>>> dtype_byte_size(torch.float32)
4
```
"""
if dtype == torch.bool:
return 1 / 8
bit_search = re.search("[^\d](\d... | 12a30fb0ce1dbec998a3ac48d3196886e0f477b0 | 484,953 |
def emtpy_cols(cols, rows, plas, model):
"""
Helper function for shrink_dict.
Iterates over the given model and removes all numbers of the coordinates
from the items in the model. this way there will be remaining lists of
empty cols, rows and plas. Returns a list of the 3 lists.
"""
for (x_c... | 410b13b0b0d527237c794be04f708e31cf39293f | 651,196 |
def q_liq_top(rho_top_liq, L_septum, L_top):
"""
Calculates the specific flow rate of the liquid for 1 m of drain septum
Parameters
----------
rho_top_liq : float
The destiny of liquid at top of column, [kg/m**3]
L_top : float
The flow rate of liquid at top of column, [kg/s]
... | 5aaf515f2c932ddec67c20734f7bf711b67025b8 | 618,892 |
def dot(a, b, out=None):
"""
Dot product of two arrays. Specifically,
- If both `a` and `b` are 1-D arrays, it is inner product of vectors
(without complex conjugation).
- If both `a` and `b` are 2-D arrays, it is matrix multiplication,
but using ``a @ b`` is preferred.
- If either `a... | 266ea378f94e668355e3a58d1beb9ab6c7d65210 | 626,421 |
def x2bool(s):
"""Helper function to convert strings from the config to bool"""
if isinstance(s, bool):
return s
elif isinstance(s, str):
return s.lower() in ["1", "true"]
raise ValueError() | 2850c3ab0421619a087d88181f3b6e2c6ffa9e9a | 16,718 |
def int2fixed(i):
"""Convert an integer to fixed point"""
return i << 16 | 7505fa97238dd2440b4aaf46483fc452a145e68a | 49,707 |
import re
def remove_comments(contents):
"""
Remove the comments from the contents
"""
contents = re.sub(re.compile(r"#.*?\n", re.DOTALL), "",
contents) # remove all occurrences of #COMMENT from line
return contents | 26dce5172c16b68b1ab5a1b64b1dd2f4d49b0aaf | 95,679 |
from typing import Mapping
def update_nested(original_dict, update_dict):
"""Update a nested dictionary with another nested dictionary.
Has equivalent behaviour to :obj:`dict.update(self, update_dict)`.
Args:
original_dict (dict): The original dictionary to update.
update_dict (dict): The... | a1a372ac4d26066c3fe32cd4ee1a49fff6972cd9 | 701,714 |
def __to_unsigned(val):
"""
convert signed (2 complement) value to unsigned
"""
if val < 0:
val = ~(-val - 1)
return val | 95815e89c11f547f0b56d35f89321a9323cd16f8 | 293,270 |
def minify_graphql_call(call: str) -> str:
"""
Minify GraphQL call.
Right now this just strips leading whitespace from all lines
which is enough to reduce size by ~50%.
"""
return "\n".join(line.lstrip() for line in call.strip().splitlines()) | 157fbc7a2072a19aae9a11bf8de37c7aa0d9fbeb | 476,108 |
from typing import List
from typing import Dict
import json
def load_umls_kb(umls_path: str) -> List[Dict]:
"""
Reads a UMLS json release and return it as a list of concepts.
Each concept is a dictionary.
"""
with open(umls_path) as f:
print(f'Loading umls concepts from {umls_path}')
... | d53a1948a35f05d1afb856e18cc770b99b4960c2 | 398,437 |
def get_direction(ball_vector: list) -> int:
"""Get direction to navigate robot to face the ball
Args:
ball_vector (list of floats): Current vector of the ball with respect
to the robot.
Returns:
int: 0 = forward, -1 = right, 1 = left
"""
if -0.13 <= ball_vector[1] <= 0... | d21f350a6a9ff7339874b0bba3d4ba3897c17195 | 292,513 |
def is_in(sequence, part):
""" returns true if 2-item list 'part' is in list 'sequence'
"""
assert len(part) == 2
for i in range(0, len(sequence) - 1):
if sequence[i: i + 2] == part:
return True
return False | bfded09ef7905381c07d0bb54b6cdf898160165c | 243,311 |
def parse_keys(keys):
"""
Parse keys for complex __getitem__ and __setitem__
Parameters
----------
keys : string | tuple
key or key and slice to extract
Returns
-------
key : string
key to extract
key_slice : slice | tuple
Slice or tuple of slices of key to ... | a2b56095fa8fdd2a7433b03958dd8e2dee4475a6 | 182,582 |
def is_scoped_package(name):
"""
Return True if name contains a namespace.
For example::
>>> is_scoped_package('@angular')
True
>>> is_scoped_package('some@angular')
False
>>> is_scoped_package('linq')
False
>>> is_scoped_package('%40angular')
True
"""
return name.st... | 22d54aaf967f8556686a023f296f70d38a864496 | 632,161 |
def rotmol(numpoints, coor, lrot):
"""Rotate a molecule
:param numpoints: the number of points in the list
:type numpoints: int
:param coor: the input coordinates
:type coor: [[float, float, float]]
:param lrot: the left rotation matrix
:type lrot: [[float, float, float]]
:return:... | 54ea0ff42e6a97ba9f94b2e366e880eef697b39d | 317,929 |
def split_cubic_into_two(p0, p1, p2, p3):
"""Split a cubic Bezier into two equal parts.
Splits the curve into two equal parts at t = 0.5
Args:
p0 (complex): Start point of curve.
p1 (complex): First handle of curve.
p2 (complex): Second handle of curve.
p3 (complex): End po... | 064465614c96c769bd585e7fd0238180ac306de4 | 483,568 |
def unroll_rids(rids):
"""Recursively unroll rid id ranges into individual rids."""
if not rids:
return []
m = rids[0]
if m[1]:
return ['R%d' % r for r in range(int(m[0]),
int(m[1])+1)] + unroll_rids(rids[1:])
return ['R%s' % m[0]] + unroll_r... | f8dea8f8ffd69315a48f7fdb22eac49390214ea7 | 129,209 |
def sort_points_by_X(points):
"""
Sort a list of points by their X coordinate
Args:
points: List of points [(p1_x, p1_y), (p2_x, p2_y), ...]
Returns:
List of points sorted by X coordinate
"""
points.sort()
return points
pass | 5445cce3467dd026c66a694b725e7185248184b5 | 512,537 |
import requests
from bs4 import BeautifulSoup
def scrape_reviews(isbn):
"""
Scrape reviews from book's Goodreads webpage using BeautifulSoup 4.
Return a list of tuples (names,rating,reviews)
"""
book_page_url = f"https://www.goodreads.com/api/reviews_widget_iframe?did=0&format=html&hide_last_page... | cf387e368c7c97cee1f8bced4551e40d5fa9a3ee | 666,574 |
import operator
def filtered_join (sep, strings, pred = None) :
"""Return a string which is the concatenation of the items in the
iterable `strings` for which `pred` is true, separated by `sep`.
>>> filtered_join ("-", ["", "abc", "ced"])
'abc-ced'
>>> filtered_join ("-", [" ", "abc",... | f2062339413c5572646284112df7856039f7c35e | 643,658 |
import re
def to_alnum(string: str) -> str:
"""Returns a string that is a copy of `string` with all non-alphanumeric
characters removed."""
return re.sub(r'\W+', '', string) | 4e2d228d8ced764b021ab3840980225201e3ec02 | 479,651 |
def get_info(information):
"""
Retrieves title of the source
For example, from the information below,
HYPERLINK("https://drive.google.com/open?id=0B9q-Bz2y-5byRWZwRHptZmk0eU0","Baby And Her Health")
Returns `Baby And Her Health`
"""
information = information.lower()
if information.starts... | ff3576efd3cd32cdfbe8c844971021381d5cea93 | 608,394 |
def verify_row_contains_rating(sheet_row: tuple, window=None) -> bool:
"""
Função que retorna apenas as linhas onde o campo de `avaliação
concreta` é marcado com `SIM`.
Arguments:
sheet_row (tuple): tupla de valores guardados na linha
Return:
bool: indica se a linha contém ou n... | 419b8a9bcc86629416e5686762f2c65513237fec | 517,623 |
def get_or_default(arr, index, default_value=None):
"""
Get value at index from list. Return default value if index out of bound
:type arr: list
:param arr: List to get value from
:type index: int
:param index: Index to get value for
:type default_value: Any
:param default_value: Defaul... | 09d93323d29920fa34521feb6fcb66870a8342fa | 210,528 |
def get_range(context, range_str):
"""Should be given a range_str like '<start_index>:<end_index', e.g. '1:4'
returns a string: e.g. 1,2,3
"""
rargs = [int(s) for s in range_str.split(':')]
return ','.join([str(d) for d in range(*rargs)]) | 879ad99e2c35d18efb1a565caa800231deb17968 | 602,550 |
def sub2indSH (m,n):
"""
i = sub2indSH(m,n)
Convert Spherical Harmonic (m,n) indices to array index i
Assumes that i iterates from 0 (Python style)
"""
i = n**2 + n + m
return i | 9700b78c8a06e58d207307e6b00f3948ba88e02b | 630,607 |
from typing import Dict
from typing import List
def dict_to_list(d: Dict) -> List:
""" Converts a dictionary to a list
Args:
d: Input dictionary
Returns:
Outputs list
"""
ret = []
for i in d.items():
ret.append(i[1])
return ret | 4970433803a84b754c5c1237e671fa155d5f14f8 | 272,668 |
def get_rectangle_in_an_image(np_array, bounding_rectangle_of_polygon):
"""
:param np_array: a numpy array
:type np_array: numpy.ndarray (https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html)
:param bounding_rectangle_of_polygon: tuple or list with coordinates of the start point of th... | ba01aad5e2b34f16b3736e352ae9feac2965ad60 | 183,423 |
def intToBitString(a, bit = 256):
"""
Converts an integer to a binary string representation (without '0b')
:param a: The integer to convert (integer)
:param bit: The size of the representation in bit (integer)
:return: Binary string representation (String)
"""
str = bin(a)[2:]
return (bi... | 288f9b77063ca23f544ae561780e47c9f5bac684 | 604,514 |
from typing import Any
import inspect
def istype(obj: Any) -> bool:
"""Return True if object is a class, function, or method type"""
return inspect.isclass(obj) or inspect.isfunction(obj) or inspect.ismethod(obj) | 5ca59d323afbd80ca9c08c54b9a66da38bc2df79 | 138,701 |
def _test_case_status(test_case) -> str:
"""Get the status of a test case based on an etree node."""
if test_case.find('failure') is not None:
return 'fail'
if test_case.find('skipped') is not None:
return 'skip'
return 'pass' | fb07b69bb61e2140bc2c894c7942de1c0e37f233 | 208,043 |
def parse_domain_directive(directive):
"""Parse a domain directive (i.e. from CLI).
Args:
directive (str): Domain directive of the form name,dx,lat_min,lat_max,lon_min,lon_max
Returns:
dict : Domain dictionary
Raises:
ValueError : If the domain cannot be parsed.
""... | b614c1c69d4a660fdac8f1bb0987d2b8a1efecfc | 558,419 |
def remove_prefix(text, prefix):
"""Removes the prefix `prefix` from string `text` in case it is present."""
return text[len(prefix):] if text.startswith(prefix) else text | e7d5b43b36e6e58cba5ce74eeca003e5354fa364 | 94,175 |
def get_variable_parent_name(var):
"""Get the name of the parent if it exists or return the variable name otherwise."""
if hasattr(var, "parent") and var.parent is not None:
return var.parent.name
else:
return var.name | e16421d9cc94b1260133068eb6a2933702857dc5 | 376,898 |
import functools
import signal
def reset_signal_handlers(func):
"""
Decorator that resets signal handlers from the decorated function. Useful
for workers where we actively want handlers defined on the supervisor to be
removed, because they wouldn't work on the worker process.
"""
@functools.w... | ed367e7f93e3694e41b55ded867d710569e724c0 | 171,786 |
def isInt(x) -> bool:
"""Decide whether or not something is either an integer, or is castable to integer.
:param x: The object to type-check
:return: True if x is an integer or if x can be casted to integer. False otherwise
:rtype: bool
"""
try:
int(x)
except (TypeError, ValueError)... | 90ef72722ecea1b45c3961a5247945a80bd2df47 | 406,056 |
def sort_matrix(mat):
"""Sorts a 2D matrix, first by its rows and then by its columns.
Parameters
----------
mat : pd.DataFrame
Matrix to sort.
Returns
-------
pd.DataFrame
Sorted matrix.
"""
freqs = (mat > 0).sum(axis=1)
order = list(freqs.sort_values(ascendi... | 91b96670ca2b2e791b33ce1294e647994e021c22 | 503,249 |
import string
import random
def random_string_generator(size=6, chars=string.ascii_uppercase + string.digits):
"""
Generate random string
Args:
size: length of the string
chars: sequence of chars to use
Returns: random string of length "size"
"""
return ''.join(random.choice(c... | 4b9e9ef10664c57b6839f549f6ca9aac9fa78fdc | 651,449 |
def tree_similarity_ratio(ted, t1, t2):
"""
Return the similarity ratio from 0 to 1 between two trees given their edit distance
`ratio` idea from [DiffLib](https://fossies.org/dox/Python-3.5.1/difflib_8py_source.html)
"""
# print(ted)
# import networkx as nx
# empty_tree = nx.DiGraph()
... | 5ed52f83aaafeaa64e9597ed628cf83c8fd9a454 | 639,373 |
def parse_maddr_str(maddr_str):
"""
The following line parses a row like:
{/ip6/::/tcp/37374,/ip4/151.252.13.181/tcp/37374}
into
['/ip6/::/tcp/37374', '/ip4/151.252.13.181/tcp/37374']
"""
return maddr_str.replace("{", "").replace("}", "").split(",") | 1a1ca1d846c650a3c01dca04a3debf921186d1a7 | 79,392 |
def str_in_list(l1, l2):
"""Check if one element of l1 is in l2 and if yes, returns the name of
that element in a list (could be more than one.
Examples
--------
>>> print(str_in_list(['time', 'lon'], ['temp','time','prcp']))
['time']
>>> print(str_in_list(['time', 'lon'], ['temp','time','p... | 3fa5c4394108179192162e1974497e3004d7494f | 195,983 |
def get_cleaned_text(text):
"""Returns cleaned text (convert to string, change to lowercase, etc)"""
cleaned_text = str(text)
cleaned_text = cleaned_text.lower()
return cleaned_text | 24fa5c1392107256a4d4d5fe47014361fbcc623d | 523,071 |
def assets_keys(scope='module'):
"""Mock keys fixture."""
return ['result', 'allowance'] | c02b9d214ef48f169679698544081eeecf44fe42 | 515,208 |
import typing
def part2(func: typing.Callable[[str, typing.Any], None]):
"""
Decorator to wrap around the solution method for Part 2.
The first positional argument is the puzzle input. The second argument is
the return value from Part 1's solution function.
Example;
```
@utils.part2
... | 9a2689dd625c6ed953e7da60396a5742a06071df | 614,165 |
import math
def deg2rad(deg):
"""Convert degrees to radians"""
return deg / (180 / math.pi) | 8c203eded49e36ad829b8bba0ae5ce4064cf35ee | 144,431 |
import itertools
def chunk(it, n):
"""Yield successive n-sized chunks from it.
>>> l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(chunk(l, 3))
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
>>> list(chunk(l, 2))
[(1, 2), (3, 4), (5, 6), (7, 8), (9,)]
"""
it = iter(it)
return iter(lambda: tuple(itert... | e9264dfcc124e001ce55845731d4e64b21a3eba2 | 227,763 |
import re
def clean(l):
"""
Removes nan and personal pronouns from l
and returns a list of NER uniques.
"""
non_nan = [re.sub(r'(?:^|, |s|S|)(?:h|H)(?:e|i).?(?:, |$)', '', str(item)) for item in l]
non_nan = [item for item in non_nan
if item != 'nan' and item != '']
return l... | 841f67bc6c7dad57e779fa175b61f16954d1f533 | 151,509 |
def FormatKeyValue(data):
"""Formats a dictionary as "key=value" parameters.
The keys are sorted to have a stable order.
@type data: dict
@rtype: list of string
"""
return ["%s=%s" % (key, value) for (key, value) in sorted(data.items())] | 4e6e4d1aeaed3c2b2f12feede3a8ef9cc9402574 | 225,788 |
from datetime import datetime
def convert_to_git_timestamp(timestamp: str) -> str:
"""
Converts the timestamp to a git timestamp.
:param timestamp: The timestamp to convert.
:return: The git timestamp.
"""
date = datetime.strptime(str(timestamp), '%Y%m%d%H%M')
return date.strftime("%Y-%m-... | cd9155502b6f56412ebfdc0ca07a7faa23d58d27 | 415,176 |
def avg(values):
"""Return the average of a set of values."""
return sum(values) / len(values) | 624a11e4bf43f07c13d00a5a4f18a46114b7f65e | 248,136 |
def area_slice(cube, start_longitude, end_longitude, start_latitude,
end_latitude):
"""
Subset a cube on area.
Function that subsets a cube on a box (start_longitude, end_longitude,
start_latitude, end_latitude)
This function is a restriction of masked_cube_lonlat();
Arguments
... | 5b81baf1ccc511637b8045b995c005e8a69d6910 | 497,123 |
def _limit_grouped_results(results, limit):
"""Limit a grouped set of results
"""
return results[:limit] if limit else results | a28997163161db21f788b125e14877189c976b46 | 292,071 |
def tau(x, k):
"""Calculate tau_i^k = x_i/x_{k-1}.
:raise
ValueError if matrix is not LU decomposable.
"""
if x[k - 1] == 0:
raise ValueError('Matrix isn\'t LU decomposable.')
t = x / x[k - 1]
t[:k] = 0
return t.reshape((x.shape[0], 1)) | 7ea1ace717fab4e39461e3b5034b5dd9caca3e79 | 277,396 |
def median(numbers):
"""
Return the median of the list of numbers.
see: http://mail.python.org/pipermail/python-list/2004-December/294990.html
"""
# Sort the list and take the middle element.
n = len(numbers)
copy = sorted(numbers)
if n & 1: # There is an odd number of elements
... | fabda42b2bfeb8ff893ef82e4178bc351d7454b3 | 252,810 |
def mean(x, old_mean, old_num_samples):
"""
Incremental update (using unbiased formula) of sample mean.
Parameters
----------
x : numpy.ndarray, shape=(1, n)
New point.
old_mean : numpy.ndarray, shape=(1, n)
Old sample mean.
old_num_samples : int
Old number of samp... | ef4442e52de988a6275fff85161518f86d37dac5 | 131,490 |
def newPlayer(name, password):
"""Create player dict"""
player = {'name':name,'password':password,'stats':{},'vars':{},'exp':0}
player['stats']['health'] = 10
player['vars']['health'] = 10
player['stats']['attack'] = 1
player['stats']['defense'] = 1
player['vars']['defense'] = 0
retu... | 679a52b836ddbeb5dc757fa430ecc9083dbe1589 | 405,073 |
def quarticCoefficients_ellipse_to_Quarticipynb(a, b, x, y, r):
""" Calculates coefficients of the quartic expression solving for the intersection between a circle with radius r and ellipse with semi-major axis a
semi-minor axis b, and the center of the circle at x and y.
Coefficients for the quartic of for... | 4f3e4e44e5bb7f3ffc3130990c98be7f0c98df5e | 565,882 |
def getCurrentTournament(c):
""" Returns the current Tournament ID"""
c.execute("SELECT * FROM CurrentTournament;")
tournament = c.fetchone()[0]
return tournament | 1357ce964fc0fd2f037e3d42857e5d9cfc725f27 | 565,500 |
def to_int(text):
"""
extract digits from text
"""
return ''.join([char for char in text if char.isdigit()]) | c791dd4d2057d658ad96beeafd31e7e9767324ea | 655,727 |
from typing import Any
def optional(**kwargs: Any) -> dict:
"""
Take a set of keyword arguments and return a dict with only the not-None values.
Returns:
dict
"""
return {key: value for key, value in kwargs.items() if value is not None} | 97b50729f2749088b189f2aeddae96d00bc9163e | 607,044 |
def is_after(t1, t2):
"""Takes 2 time objects, returns True if t1 follows t2 chronologically, otherwise False
"""
t1_seconds = t1.second + t1.minute*60 + t1.hour*3600
t2_seconds = t2.second + t2.minute*60 + t2.hour*3600
return t1_seconds > t2_seconds | 76278acd2443264a8145981351b1c67a2b6b4876 | 90,002 |
import re
def _redact_volatile(output: str) -> str:
"""
Replace some volatile values, like temp paths & memory locations.
>>> _redact_volatile("<__main__.A at 0x10b80ce50>")
'<__main__.A at 0x...>'
>>> _redact_volatile("/tmp/abcd234/pytest-accept-test-temp-file-0.py")
'/tmp/.../pytest-accept... | 6a53bf858618c255134c54707550afa4b3934d3b | 591,293 |
def fahrenheit2celcius(F):
"""
Convert Fahrenheit to Celcius
:param F: Temperature in Fahrenheit
:return: Temperature in Celcius
"""
return 5.0 / 9.0 * (F - 32) | c51d4eaeb456bcffc58e74d7cc0b61ce6c8ee1f8 | 266,793 |
def cf_record_prob_lose2(winrate, numwins, maxwins=5):
"""Probability of winning `numwins` game in an event that stops at two losses.
>>> pct(cf_record_prob_lose2(0.6, 5))
23.3
>>> pct(cf_record_prob_lose2(0.45, 3))
11.0
"""
if numwins == maxwins:
return pow(winrate, numwins) + numw... | d8338833eae0088532ff71681f7fed958fd8a565 | 340,748 |
def to_absolute_path_for_docker_volumes(context, path):
"""
Return absolute path to use in docker volume command
:param context: test context
:param path: relative path
:return: absoulte path to use in docker -v
"""
host_pwd = context.config.userdata['host_pwd']
return "%s/%s" % (host_pw... | 8ec0013d61e62b2aadb2aec048569a0454aeabac | 248,858 |
def readline_skip_comments(f):
"""
Read a new line while skipping comments.
"""
l = f.readline().strip()
while len(l) > 0 and l[0] == '#':
l = f.readline().strip()
return l | c4b36af14cc48b1ed4cd72b06845e131015da6c6 | 823 |
def offsets_to_cell_num(y_offset, x_offset):
"""
:param y_offset: The y_offset inside a block. Precondition: 0 <= y_offset < 3
:param x_offset: The x_offset inside a block. Precondition: 0 <= x_offset < 3
:return: The cell number inside a block
"""
return 3 * y_offset + x_offset | 44b4a20533c9531d40e999bfda022ba649a994ce | 376,856 |
def has_target_log_prob(kernel_results):
"""Returns `True` if `target_log_prob` is a member of input."""
return getattr(kernel_results, 'target_log_prob', None) is not None | fc462b768a16f98ff97d6bd697ecbbdbb01960b0 | 517,037 |
def v(n,d):
"""Maximum e such that d^e divides n."""
if n<1 or d<2:
return -1
count=0
while n%d==0:
n//=d
count+=1
return count | 2348ad188cb386c0ca7a612139b962a1f1d77010 | 510,758 |
def get_matching_paren(exp: str) -> int:
""" Returns the index of the right parenthesis which matches the first left parenthesis.
exp[0] should be a left parenthesis
"""
if exp[0] != '(':
raise ValueError('Given string must begin with \'(\' character')
left = 1
right = 0
i = 1
... | 2d6a3cc4bca6981b7545fdfb4446718d7a6e1e16 | 528,831 |
def get_error_res(eval_id):
"""Creates a default error response based on the policy_evaluation_result structure
Parameters:
eval_id (String): Unique identifier for evaluation policy
Returns:
PolicyEvalResultStructure object: with the error state with the given id
"""
return {
... | ebb80435b6f0c590dc30a9095559cbbbd1da5662 | 688,883 |
def get_lr_run_identifier(lrs):
"""Computes the run identifier for the given learning rates. Search identifier will not contain w_eval.
Args:
lrs (dict): That that contains the learning rate for every searched learning rate.
Returns:
str: String that uniquely represents a run with the give... | 35f6e8cfd00eef98f22da00df299f9ca6f8c909d | 338,743 |
import logging
def load_joint_order(handle):
"""
Loads a joint order from the given handle.
:param io.file handle
:rtype list[str]
"""
logging.info('Loading joint order')
result = [line.strip() for line in handle]
logging.info('Loaded {} joints'.format(len(result)))
return re... | 608eecefd17a2ea2c04aae3faa3b008e87a813ac | 126,686 |
def lemmatise(tokens):
"""
Lemmatise nested list of tokens
Parameters
----------
tokens: list
a nested list containing lists of tokens or a list of spacy dcs
Returns
-------
lemmas: list
a nested list of lemmas
"""
lemmas = [[word.lemma_ for word in comment] f... | 292c53c066da41911bc2d7e77cec120581c7c7ad | 105,332 |
def confirm(name, really=False):
"""
Helper function to deal with user confirming
:param String name: Value we are deleting
:param boolean really: Are you sure you want to delete this?
:return: Flag to indicate if they confirmed
:rtype: boolean
"""
if not really:
confirm = input... | b4fa7fea8484b4c63551ebafa2af13c0a5a4e89c | 404,823 |
import re
def trailing_whitespace(source):
"""
Checks each item in source list for a trailing whitespace
:param source: list of lines to check for trailing whitespace
:return: List of offending line numbers with trailing whitespace, otherwise None
"""
lines = []
for counter, line in enume... | 308ab4afca8d30b2923f3f42cf765739be8a0403 | 491,183 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.