content stringlengths 42 6.51k |
|---|
def transform_s1zs2z_chi_eff_chi_a(mass1, mass2, spin1z, spin2z):
#Copied from pycbc https://github.com/gwastro/pycbc/blob/master/pycbc/conversions.py
""" Returns the aligned mass-weighted spin difference from mass1, mass2,
spin1z, and spin2z.
"""
chi_eff = (spin1z * mass1 + spin2z * mass2) / (mass1... |
def compute_average(values):
""" Given a set of values compute the average.
Args:
values: Set of values for which average is to be computed.
Returns:
Average of all values.
"""
return float(sum(values)) / len(values) |
def getattribute_value(obj: object, attribute: str) -> object:
"""Return value of the attribute from given object"""
if hasattr(obj, attribute):
return getattr(obj, attribute)
else:
raise Exception(f"{attribute} not found within {obj}") |
def fizzbuzz(a, b, n):
"""Takes integers a, b, and n. Returns a string respective to the fizzbuzz
specification listed in the header.
"""
if n % (a*b) == 0:
return 'FB'
elif n%a == 0:
return 'F'
elif n%b == 0:
return 'B'
else: return str(n) |
def parseEtreeTag(tag):
"""Return namespace, tagname pair.
>>> parseEtreeTag('{DAV:}prop')
['DAV:', 'prop']
>>> parseEtreeTag('{}prop')
['', 'prop']
>>> parseEtreeTag('prop')
(None, 'prop')
"""
if tag[0] == "{":
return tag[1:].split("}")
return None, tag |
def _split_diff(diff_out):
"""Splits the diff output into the diff header and body."""
first_non_header_line = 0
for line in diff_out:
if line.startswith('@@'):
break
first_non_header_line += 1
return diff_out[:first_non_header_line], diff_out[first_non_header_line:] |
def counter_clockwise(p1, p2, p3):
"""Is the turn counter-clockwise?"""
return (p3[1] - p1[1]) * (p2[0] - p1[0]) >= (p2[1] - p1[1]) * (p3[0] - p1[0]) |
def get_question_type(question_id, questions):
"""
Return 'Number' or 'Boolean' depending on the question's type.
"""
question = questions[question_id]
question_class = question[0]
if question_class in ('Y'):
return 'Boolean'
return 'Number' |
def moving_avg(xyw, avg_len):
"""
Calculate a moving average for a given averaging length
:param xyw: output from collapse_into_single_dates
:type xyw: dict
:param avg_len: average of these number of points, i.e., look-back window
:type avg_len: int
:return: list of x values, list of y value... |
def reverse_dict(my_dict, my_value):
"""
Tries to find which key corresponds to a given value in a dictionary - i.e.
reverses the dict lookup.
This code assumes no two keys share the same value - as is the case with
PSU-WOPWOP dicts used here.
"""
return {value: key for key, value in my_di... |
def wrap_commands_in_shell(ostype, commands):
"""Wrap commands in a shell
:param list commands: list of commands to wrap
:param str ostype: OS type, linux or windows
:rtype: str
:return: a shell wrapping commands
"""
if ostype.lower() == 'linux':
return '/bin/bash -c \'set -e; set -o... |
def get_input_artifacts(data):
"""Returns the inputArtifacts array in a given data object.
:type data: dict
:param data: data object in a CodePipeline event.
:rtype: dict
:return: inputArtifacts object in ``data``.
:raises KeyError: if ``data`` does not have ``inputArtifacts``.
"""
re... |
def get_id(md_string):
"""Uniprot ID extracted from detailed identifiers in fasta file
Parameters
-----------
md_string : str
input string from fasta file with detailed identifier for each protein
Returns
-------
id : str
extracted uniprot identifier
"""
try:
id... |
def depth_to_col_name(depth):
"""
Derives the proper name of the column for locations given a depth.
"""
if depth == 0:
return "location"
else:
return "sub_" * depth + "lctn" |
def _normalize_kernel(kernel):
"""Ensures a kernel string points to a repository rule, with bazel @ syntax."""
if not kernel.startswith("@"):
kernel = "@" + kernel
return kernel |
def vectormatrixmult(v, m):
"""
Premultiply matrix m by vector v
"""
rows = len(m)
if len(v) != rows:
raise ValueError('vectormatmult mismatched rows')
columns = len(m[0])
result = []
for c in range(0, columns):
result.append(sum(v[r] * m[r][c] for r in range(rows)))
... |
def extended_gcd(a, b):
"""gcd(a, b), s, r such that a * s + b * r == gcd(a, b)"""
s, old_s = 0, 1
r, old_r = b, a
while r:
quotient = old_r // r
old_r, r = r, old_r - quotient * r
old_s, s = s, old_s - quotient * s
return old_r, old_s, (old_r - old_s * a) // b if b else 0 |
def shell_sort(lst):
"""
An in-place sorting algorithm that sorts the list in increasing
order.
The algorithm starts by sorting pairs of elements far apart from each other,
then progressively reduces the gap between elements to be compared.
Starting with far apart elements, it can move some ou... |
def _make_args_kwargs(arg1, arg2, arg3, **kwargs):
"""Test utility for args and kwargs case"""
return arg1 + arg2 + arg3 + kwargs["x"] + kwargs["y"] |
def get_value(x):
"""Get numeric value from quantity or return object itself."""
return getattr(x, 'value', x) |
def scale_bar_values( bar, top, maxrow ):
"""
Return a list of bar values aliased to integer values of maxrow.
"""
return [maxrow - int(float(v) * maxrow / top + 0.5) for v in bar] |
def easeInOutQuad(t, b, c, d):
"""Robert Penner easing function examples at: http://gizma.com/easing/
t = current time in frames or whatever unit
b = beginning/start value
c = change in value
d = duration
"""
t /= d/2
if t < 1:
return c/2*t*t + b
t-=1
return -c/2 * (t*(t... |
def get_experiment_run_name(
mode: str,
msg: int,
msg_unit: str,
freq: int,
) -> str:
"""
Get name of data file for a specific run.
:param mode: the mode
:param msg: the msg size
:param msg_unit: the msg unit prefix
:param freq: the publishing frequency
:return: the file nam... |
def wikipedia_link(pred_lab):
"""
Return link to wikipedia webpage
"""
base_url = 'https://en.wikipedia.org/wiki/'
link = base_url + pred_lab.replace(' ', '_')
return link |
def xor(a: bytearray, b: bytearray, c=bytearray(0), d=bytearray(0), e=bytearray(0)) -> bytearray:
"""
:param a:
:param b:
:param c:
:param d:
:param e:
:return f: bit wise xor of a and b
:rtype bytearray
"""
l = max(len(a), len(b), len(c), len(d))
# do padding with 0 if the v... |
def format_memory_size(size):
"""
Returns formatted memory size.
:param size: Size in bytes
:type size: Number
:returns: Formatted size string.
:rtype: String
"""
if not size:
return 'N/A GB'
if size >= 1099511627776:
sizestr = '%.1f TB' % (float(size) / 109951162777... |
def definequote(quotechar):
"""Defines the global quote function, for wrapping identifiers with quotes.
Arguments:
- quotechar: If None, do not wrap identifier. If a string, prepend and
append quotechar to identifier. If a tuple of two strings, prepend with
first element and appen... |
def pad_sequence3(sequences,padding = 0):
"""
every element in sequence is a 2-d list
with shape [time_steps,dim]
the dim is fixed
"""
d2s = [len(seq) for seq in sequences]
d3 = sequences[0][0].__len__()
result = []
max_l = max(d2s)
for seq,l in zip(seque... |
def get_number(string: str) -> float:
"""This function returns the numbers of type float which appear in the given String. Lieferando.de uses the german format to represent point numbers, therefore "," will be transformed to ".".
Only works for the german format."""
# Get all digits with ','
result = ''.join(... |
def common_prefix_search(trie, key):
"""
>>> from pprint import pprint
>>> data = {
... 'test': 'data',
... 'text': 'string',
... 'tmp': 'file',
... }
>>> trie = {}
>>> for key, value in data.items():
... insert(trie, key, value)
>>> common_prefix_search(trie,... |
def key_of_min_value(d):
"""Returns the key in a dict d that corresponds to the minimum value of d.
>>> letters = {'a': 6, 'b': 5, 'c': 4, 'd': 5}
>>> min(letters)
'a'
>>> key_of_min_value(letters)
'c'
"""
# BEGIN Question 0
return min(d, key=d.get)
# END Question 0 |
def get_act_sent_len(head_indexes_2d):
""" Get actual sentence length (counting only head indexes) """
sent_len_list = [0] * len(head_indexes_2d)
for idx, head_list in enumerate(head_indexes_2d):
sent_len = 0
for item in head_list:
if item != 0:
sent_len += ... |
def _use_ssl(addr):
"""Decide if SSL should be used for the given server address."""
if isinstance(addr, str):
return addr.endswith(':993')
return len(addr) == 2 and addr[1] == 993 |
def rgb_to_hex(r: int, g: int, b: int) -> str:
"""Convert RGB (Red Green Blue) to hexadecimal color code.
:param r: Red (0 to 255 inclusive).
:param g: Green (0 to 255 inclusive).
:param b: Blue (0 to 255 inclusive).
:return: Hexadecimal color code.
"""
return f"{r:02x}{g:02x}{b:02x}".upper... |
def kgtk_unstringify(x):
"""If 'x' is surrounded by double quotes, remove them.
"""
# TO DO: this also needs to handle unescaping of some kind
if isinstance(x, str) and x.startswith('"') and x.endswith('"'):
return x[1:-1]
else:
return x |
def check_enemy_ub(time_count):
"""check enemy ub
Args
time_count (int): count up after ub
Returns
is_enemy_ub (boolean): enemy ub existence
"""
if time_count > 9:
return True
else:
return False |
def epoch_date_to_string(epoch):
"""
Convert a datetime object to a string with the format YYYYMMDD
Parameters
----------
epoch : datetime object or string
datetime object to convert to a string
Returns
-------
epoch_string : string
Epoch string in the format of YYYYMMD... |
def idx_to_a1(row, col):
"""Convert a row & column to A1 notation. Adapted from gspread.utils.
:param row: row index
:param col: column index
:return: A1 notation of row:column
"""
div = col
column_label = ""
while div:
(div, mod) = divmod(div, 26)
if mod == 0:
... |
def argument(parser, node, children):
"""
Removes parenthesis if exists and returns what was contained inside.
"""
print(children)
if len(children) == 1:
print(children[0])
return children[0]
sign = -1 if children[0] == '-' else 1
return sign * children[-1] |
def get_readable_page_title(sanitized_page_title):
"""Returns the human-readable page title from the sanitized page title.
Args:
page_title: The santized page title to make human-readable.
Returns:
The human-readable page title.
Examples:
"Notre_Dame_Fighting_Irish" => "Notre Dame Fighting Iris... |
def isPoint(pointlist):
""" Verify is a list is a list of points """
if len(pointlist) in [2, 3]:
if isinstance(pointlist[0], (int, float))\
and isinstance(pointlist[1], (int, float)):
return True
else:
return False
else:
return False |
def parse_type(attr):
"""
We need to pass all attr to identify the type.
There is a big mismatch between sparql and swagger
Returs a class of a type
"""
print(attr)
if "$ref" in attr:
ref = attr["$ref"].split("/")[-1]
return attr["$ref"].split("/")[-1]
if "type" not in a... |
def td_read_line(line):
"""Return x column"""
return float(line.split(',')[0]) |
def all_equal(arg1, arg2):
"""
Shortcut function to compute element-wise equality between two iterables
Parameters
----------
arg1 : iterable
Any iterable sequence
arg2 : iterable
Any iterable sequence that has the same length as arg1
Returns
-------
bool
Tr... |
def inventory_update(arr1, arr2):
"""Add the inventory from arr2 to arr1.
If an item exists in both arr1 and arr2, then
the quantity of the item is updated in arr1.
If an item exists in only arr2, then the item
is added to arr1. If an item only exists in
arr1, then that item remains unaffected.... |
def summation(lower, upper):
"""returns the sum of the numbers from lower through upper"""
#!base case
if lower > upper:
return 0
#!recursive case
return lower + summation(lower + 1, upper) |
def _get_cli_param_name(name: str) -> str:
"""
Convert parameter name back to cli format from pythonic version.
- Strips trailing underscore from keywords
- Converts remaining underscores to dashes
- Adds leading dashes
"""
if name[-1] == "_":
name = name[0:-1]
name = name.repla... |
def daysToYears(days):
"""
(number) -> float
convert input days to years; return years
>>> daysToYears(365)
1.0
>>> daysToYears(100)
0.27
>>>
daysToYears(0)
0.0
"""
years = days / 365
years = round(years, 2)
return years |
def _batch_aggregation(batch_loss_list, reduction=None):
"""Returns the aggregated loss."""
loss_sum = 0.
weight_sum = 0.
for loss, weight, count in batch_loss_list:
loss_sum += loss
if reduction == 'mean':
weight_sum += weight
else:
weight_sum += count
return loss_sum / weight_sum |
def selection_sort(data):
"""Sort a list of unique numbers in ascending order using selection sort. O(n^2).
The process includes repeatedly iterating through a list, finding the smallest element, and sorting that element.
Args:
data: data to sort (list of int)
Returns:
sorted l... |
def rscpFindTag(decodedMsg, tag):
"""Finds a submessage with a specific tag.
Args:
decodedMsg (list): the decoded message
tag (str): the RSCP Tag string to search for
Returns:
list: the found tag
"""
if decodedMsg is None:
return None
if decodedMsg[0] == tag:
re... |
def getRasterBands(datasource,bandids,bandMatchFunc):
"""
datasource: the loading meta data of raster datasource
bandIds: a list of band ids, each member of list can be a id or list of ids
batchMatchFunc: the function to check whether the band match the specified bandid
return the ranster band with... |
def copy_nested_list(l):
"""Return a copy of list l to one level of nesting"""
return [list(i) for i in l] |
def is_price_good_for_ps(price:float, ps:list)->bool:
"""
Decides if the given price can be used as the trading price for the given PS.
>>> is_price_good_for_ps(5, [9, -3])
True
>>> is_price_good_for_ps(5, [9, -7])
False
>>> is_price_good_for_ps(5, [4, -3])
False
"""
for i in ra... |
def get_standard_file(standard):
""" Map the standard to a file """
standard_files = {"C2004": "misra-c2004-guidelines.csv",
"C2012": "misra-c2012-guidelines.csv",
"CPP2008": "misra-cpp2008-guidelines.csv"}
if standard in standard_files.keys():
return st... |
def interpret_instruction(instruction, parameter):
""" Interprets an instruction and returns offset to next command and accumulator value.
:param instruction: acc, jmp or nop
:param parameter: signed integer
:return: (jump_offset, accumulator_offset)
"""
if instruction == 'acc':
return ... |
def is_power_of_two(number):
"""
Check if a number is a power of two or not
"""
# Returns None if number is set to None.
if number is None:
return None
# This is a fast method to check for a power of two.
#
# A power of two has this structure: 100000 (one or more zeroes)
#... |
def power_recursive(base, exp):
"""Funkce vypocita hodnotu base^exp pomoci rekurzivniho algoritmu
v O(exp). Staci se omezit na prirozene hodnoty exp.
"""
if exp == 0:
return 1
return base * power_recursive(base, exp - 1) |
def _get_plot_name(name):
"""Looks in the parameter and returns a plot name.
Expects the plot name to be identified by having "By Plot" embedded in the name.
The plot name is then surrounded by " - " characters. That valus is then returned.
Args:
name(iterable or string): An array/list of... |
def lcs(list1, list2):
"""
Longest common subsequence
:param list1:
:param list2:
:return: lcs
"""
if len(list1) == 0 or len(list2) == 0:
return []
if list1[-1] == list2[-1]:
return lcs(list1[:-1], list2[:-1]) + [list1[-1]]
else:
lcs1 = lcs(list1[:-1], list2[:... |
def first_truthy(*args): # type: ignore[no-untyped-def] # noqa: F811 # pylint: disable=missing-return-type-doc
"""Return the first *truthy* value from a list of values.
Args:
*args: variable length argument list
* If one positional argument is provided, it should be an iterable of the v... |
def is_track_header(line):
"""Returns if the line is a header line used in genome tracks/browsers."""
line = line.strip()
if line.startswith('#') or line.startswith('track') or line.startswith(
'browser'):
return True
else:
return False |
def likes(names):
"""Take string of names and let you know who likes 'it'."""
if len(names) == 0:
return "no one likes this"
elif len(names) == 1:
return "{} likes this".format(names[0])
elif len(names) > 3:
return "{}, {} and {} others like this".format(names[0], names[1],
... |
def write_uleb128(num: int) -> bytearray:
""" Write `num` into an unsigned LEB128. """
if num == 0:
return bytearray(b'\x00')
ret = bytearray()
length = 0
while num > 0:
ret.append(num & 0b01111111)
num >>= 7
if num != 0:
ret[length] |= 0b10000000
... |
def approx_eq(x, y, tolerance=1e-15):
"""Whether x is within tolerance of y."""
return abs(x - y) < tolerance |
def isEmpty(cadena):
"""retorna true si la cadena esta vacia"""
return len(cadena) == 0 |
def ordered(o):
"""deeply order o"""
if isinstance(o, dict):
return frozenset((k, ordered(v)) for k, v in o.items())
if isinstance(o, list):
return frozenset(ordered(x) for x in o)
else:
return o |
def _adjust_creg_sizes(creg_sizes, indices):
"""Helper to reduce creg_sizes to match indices"""
# Zero out creg_sizes list
new_creg_sizes = [[creg[0], 0] for creg in creg_sizes]
indices_sort = sorted(indices)
# Get creg num values and then convert to the cumulative last index per creg.
# e.g. ... |
def quantity_remover(my_thing):
"""
removes pint quantities to make json output happy
Parameters
----------
my_thing
Returns
-------
"""
if hasattr(my_thing, 'magnitude'):
return 'QUANTITY', my_thing.magnitude, my_thing.units.format_babel()
elif isinstance(my_thing, ... |
def list_frequencies(list_of_items):
""" Determine frequency of items in list_of_items. """
itemfreq = [list_of_items.count(p) for p in list_of_items]
return dict(zip(list_of_items,itemfreq)) |
def minimus(*args):
"""Find the smallest number"""
print(min(*args))
return min(*args) |
def output_list(masterlist):
"""
Helper function that removes the extra brackets when outputting a list of lists into a csv file.
Stackoverflow link: https://stackoverflow.com/questions/31587784/python-list-write-to-csv-without-the-square-brackets
Keywords:
masterList (list): input list of lists
... |
def calc_th_eff_with_el_eff(el_eff, eta_total):
"""
Returns thermal efficiency of CHP
Parameters
----------
el_eff : float
Electric efficiency (no unit)
eta_total : float
Total efficiency of CHP (no unit)
Returns
-------
th_eff : float
Thermal efficiency (no... |
def represents_int(s):
"""Return true if string represents an integer"""
try:
int(s)
return True
except ValueError:
return False |
def isValidSubset(subset, background):
"""
Checks if the gene subset of interest contains genes not present in the background set.
If there are additional genes they are removed.
Parameters
----------
subset : set of str
A subset of Uniprot ACs of interest.
background : set of str
... |
def optimal_weight(W, w):
"""Knapsack without repetitions.
It's given a set of bars of gold and the goal is to take as much gold as
possible into the bag. There is just one copy of each bar and for each bar
you can either take it or not (hence you cannot take a fraction of a bar).
Samples:
>>> o... |
def Qmultiply(q1, q2):
"""
Qmultiply
"""
w1, x1, y1, z1 = q1[0], q1[1], q1[2], q1[3]
w2, x2, y2, z2 = q2[0], q2[1], q2[2], q2[3]
return (w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2,
w1... |
def safe_int(string_, default=1):
"""Convert a string into a integer.
If the conversion fails, return the default value.
"""
try:
ret = int(float(string_))
except ValueError:
return default
else:
return ret |
def seabed2aliased(seabed, rlog, tpi, f, c=1500,
rmax={18:7000, 38:2800, 70:1100, 120:850, 200:550}):
"""
Estimate aliased seabed range, given the true seabed range. The answer will
be 'None' if true seabed occurs within the logging range or if it's beyond
the detection limit of the... |
def _resolve_name(name, package, level):
"""Return the absolute name of the module to be imported."""
if not hasattr(package, 'rindex'):
raise ValueError("'package' not set to a string")
dot = len(package)
for x in range(level, 1, -1):
try:
dot = package.rindex('.', 0, dot)
... |
def update_dictionaries(final_dict: dict, new_dict: dict) -> dict:
"""
Merges two dictionaries by including key/value pairs or adding values to corresponding keys from a dictionary
(new_dict) to a target dictionary (final_dict).
Parameters
----------
final_dict: Dictionary, which should be upda... |
def _WordScore(index, normalized_command_word,
canonical_command_word, canonical_command_length):
"""Returns the integer word match score for a command word.
Args:
index: The position of the word in the command.
normalized_command_word: The normalized command word.
canonical_command_word... |
def str_list_to_c2count(list_of_string):
"""
:param list_of_string: a list of str
:return: a dict mapping from each one-character substring of the argument to the count of occurrences of that character
"""
count = {}
for string in list_of_string:
for character in string:
if c... |
def parse_composed_of(value):
"""Parse composed_of option."""
if value is None:
return []
return [x.strip() for x in value.split()] |
def get_relevant_actions(all_actions, goals):
"""
Returns a subset of actions which have at least one of the goals
in their effects
"""
relevant = []
for a in all_actions:
if len(a.effects.intersection(goals)) > 0:
relevant.append(a)
return relevant |
def has_dict_changed(new_dict, old_dict):
"""
Check if new_dict has differences compared to old_dict while
ignoring keys in old_dict which are None in new_dict.
"""
if new_dict is None:
return False
if not new_dict and old_dict:
return True
if not old_dict and new_dict:
... |
def uses_only(word, allowed):
"""Predicate that asks whether word *only* uses letters allowed string.
word: string to be searched
allowed: string of allowed letters
"""
# This is a set intersection problem again, but I'll use string methods.
# Cycle through letters in word this time
for lett... |
def check_permisions(request, allowed_groups):
""" Return permissions."""
try:
profile = request.user.id
print('User', profile, allowed_groups)
is_allowed = True
except Exception:
return False
else:
return is_allowed |
def cisfun(text):
""" Receive string and print it"""
text = text.replace('_', ' ')
return 'C %s' % text |
def _objc_provider_framework_name(path):
"""Returns the name of the framework from an `objc` provider path.
Args:
path: A path that came from an `objc` provider.
Returns:
A string containing the name of the framework (e.g., `Foo` for `Foo.framework`).
"""
return path.rpartition("/"... |
def format_phone(phone):
"""
Format a string as a phone number.
"""
if len(phone) == 10:
return "(" + phone[:3] + ") " + phone[3:6] + "-" + phone[-4:]
else:
return phone |
def truncate_str(string):
"""
A useful function to make sure filename strings in the console don't become too unwieldy.
"""
return string[:50] + '...' + string[-25:] if len(string) > 80 else string |
def wikipedia(params):
"""'.wik' & term | Searches wikipedia for term"""
msg, user, channel, users = params
if msg.startswith('.wik'):
return "core/wikipedia.py"
else:
return None |
def fc( ndvi ):
"""Fraction of vegetation cover"""
ndvimin = 0.05
ndvimax = 0.95
return ( ( ndvi - ndvimin ) / ( ndvimax - ndvimin ) ) |
def circle_bounding_frame(x, y, w):
"""Returns the bounding frame with x_end > x_begin and y_end > y_begin."""
r = w/2
return x-r, x+r, y-r, y+r |
def get_named_value(elem, field):
"""Returns the string value of the named child element."""
try:
return elem.find(field).text
except AttributeError:
return None |
def getTempDir(relativePath=""):
"""Gets temporary directory for this running instance of Maven Repository Builder."""
return '/tmp/maven-repo-builder/' + str(3232) + "/" + relativePath |
def get_text_or_caption_from_turn_message(message: dict) -> str:
"""
Gets the text content of the message, or the caption if it's a media message, and
returns. Returns an empty string if no text content can be found.
"""
try:
return message["text"]["body"]
except KeyError:
pass
... |
def naiveAstToLLVM(jast):
"""
Convert the input json encoded AST to LLVM code, using a naive method for testing purposes
JSON jast: the AST in JSON form produced by the main Haskell routine
Returns a string containing the LLVM code matching the input json encoded AST
"""
# json indexing
func... |
def try_int(val):
"""Tries to convert val to int.
Raises ValueError upon failure.
In contrast to builtin.int this function returns 0 for an empty string.
"""
try:
return int(val)
except ValueError:
if len(val) == 0:
return 0
else:
raise ValueError... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.