content stringlengths 42 6.51k |
|---|
def delete_from_list(head, tail, elem):
"""Delete an element from the list"""
if head is None or tail is None:
return -1, -1
if head.data == elem:
if head == tail:
head = tail = None
return -1, -1
curr = head
head = head.next
head.prev = None... |
def build_entry_ui_url(ice_base_url, entry_id):
"""
Builds the URL for client access to an ICE entry via ICE's user interface.
:param ice_base_url: the base URL of the ICE instance (assumed to NOT end with a slash)
:param entry_id: an ICE identifier for the part. This can be any of 1) The UUID (prefer... |
def split_multiplier(string):
"""
Split a string of "1k" in number and letter.
:param string: number with character multiplier as string
:return: number, char
"""
nr = ''
tx = ''
for char in string:
if char.isdigit() or char == '-' or char == '.':
nr += char
... |
def mutate_polymer(polymer, pattern_mapper):
"""
Sequence new polymer based on the previous polymer (slow for large polymers)
"""
polymer_list = [polymer[0]] + [None] * (len(polymer) * 2 - 2)
for position in range(1, len(polymer)):
polymer_list[position * 2 - 1] = pattern_mapper.get(polymer[... |
def ether_to_wei(ether):
"""Convert ether to wei
"""
return int(ether * 10**18) |
def run_autoregression_analysis(*args, **kwargs):
"""Side effect of mock regression analysis"""
return "result.csv", "result.png" |
def sum_of_factorial(number: int) -> int:
"""
>>> sum_of_factorial(0)
0
>>> sum_of_factorial(1)
1
>>> sum_of_factorial(2)
3
>>> sum_of_factorial(5)
153
"""
sum_factorial = 0
factorial = 1
for i in range(1, number + 1):
factorial *= i
sum_factorial = su... |
def odd_occurences_in_array(a):
"""
Finds the odd number of occurences of an element in an array.
XOR of all elements gives us odd occurring element.
Note that XOR of two elements is 0 if both elements are same and XOR of a number x with 0 is x
:param a
"""
result = 0
for number in a:
... |
def list_to_dict(graph_list):
"""
Convert a graph in list mode to a dictionary and by put value 1 at each edge
Only used to convert external graphs.
Example: {0:(1,2), 1:(0,2)} --> {0: {1: 1, 2: 1}, 1: {0: 1, 2: 1}}
:param graph_list:
"""
graph_dict = {}
for i in graph_list:
e... |
def get_option(spot: float, num: int = 0, step: float = 100.0) -> float:
"""
Get the option price given number of strikes
spot
spot price of the instrument
num
number of strikes farther
step
step size of the option
Note
----
1. By default, the ATM option is fetche... |
def fibo2(n):
"""Return F_{n-1}, F_n"""
if (n == 0): # Base case.
return 1, 0 # F_{-1}, F_0
else: # Recurrency.
f_k_1, f_k = fibo2(n // 2) # F_{k-1}, F_k when k = n/2
f2_k = f_k ** 2 # F_k^2
if n % 2 == 0: # n is even
return (f2_k + f_k_1 ** 2,
... |
def trp(l, n):
""" Truncate or pad a list """
r = l[:n]
if len(r) < n:
r.extend(list([0]) * (n - len(r)))
return r |
def repr_0(value, basecolor=''):
"""Represent binary data by replacing \0 with a colored underscore"""
return basecolor + repr(value).replace('\\x00', '\033[36m_\033[m' + basecolor) + '\033[m' |
def unchecked_dfs_toposort(adj):
"""Topological sort by recursive DFS. Assumes the graph is acyclic."""
vis = [False] * len(adj)
out = []
def dfs(src):
if vis[src]:
return
vis[src] = True
for dest in adj[src]:
dfs(dest)
out.append(src)
... |
def median(series):
"""
finds the median of the series from scratch
you may need to sort your values and use
modular division
this number should be the same as calling .median() on your data
See numpy documenation for implementation details:
https://docs.scipy.org/doc/numpy/reference/generat... |
def get_analysis_runner_metadata(
timestamp,
dataset,
user,
access_level,
repo,
commit,
script,
description,
output_suffix,
driver_image,
cwd,
**kwargs,
):
"""
Get well-formed analysis-runner metadata, requiring the core listed keys
with some flexibility to pr... |
def unflatten_list_of_dicts(list_of_dicts):
"""Returns list of `input` dicts as unflattened dictionaries for keys with the special character `/`"""
result = []
for single_dict in list_of_dicts:
result_dict = {}
for key, value in single_dict.items():
key_parts = key.split("/")
... |
def args_to_str(*args, **kwargs):
"""Convert the given args to a string command."""
text = ''
if len(args) > 0:
text += ' '.join((str(arg) for arg in args))
if len(kwargs) > 0:
if len(args) > 0:
text += ' '
text += ' '.join(('--{} {}'.format(k, v) for k, v in kwargs.i... |
def set_limit_margins(limit_margin):
"""
set the limit margins for testing
:param limit_margin: limit margin value used for the initialization
:return:
"""
if type(limit_margin) is tuple:
limit_margin_low = limit_margin[0]
limit_margin_high = limit_margin[1]
else:
lim... |
def scale(val, src, dst):
"""
Scale the given value from the scale of src to the scale of dst.
val: float or int
src: tuple
dst: tuple
example: print(scale(99, (0.0, 99.0), (-1.0, +1.0)))
"""
return (float(val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0] |
def find_sub_list(sl, l):
"""
Returns the start and end positions of sublist sl in l
"""
sll = len(sl)
for ind in (i for i, e in enumerate(l) if e == sl[0]):
if l[ind:ind + sll] == sl:
return ind, ind + sll |
def luminance_ASTM_D1535_08(V, **kwargs):
"""
Returns the *luminance* :math:`Y` of given *Munsell* value :math:`V` using
*ASTM D1535-08e1 (2008)* method.
Parameters
----------
V : numeric
*Munsell* value :math:`V`.
\*\*kwargs : \*\*, optional
Unused parameter provided for si... |
def parse_geometry(geometry):
"""
GeoJSON order is [longitude, latitude, elevation].
:param geometry: Is a list of coordinates in latLng order
:type geometry: list
:return: returns a list of coordinates in lngLat order for geojson
:type: list
"""
geom = []
for coords in geometry:
... |
def _terriberry(data):
"""Terriberry's algorithm for a single pass estimate of skew and kurtosis.
This is (currently) completely untested and unsupported.
This calculates the second, third and fourth moments
M2 = sum( (x-m)**2 )
M3 = sum( (x-m)**3 )
M4 = sum( (x-m)**4 )
where m... |
def get_module_version(module_name):
"""Return module version or None if version can't be retrieved."""
mod = __import__(module_name,
fromlist=[module_name.rpartition('.')[-1]])
return getattr(mod, '__version__', getattr(mod, 'VERSION', None)) |
def drop(n, xs):
"""Returns all but the first n elements of the given list, string, or
transducer/transformer (or object with a drop method).
Dispatches to the drop method of the second argument, if present"""
return xs[n::] |
def is_integer(s):
""" Returns True if `s` is an integer """
try:
int(s)
return True
except:
return False |
def noneFunc(thing):
"""
Function checks if nothing is supplied
Returns True if nothing it is "null"
Returns False if it haves stuff
"""
if thing == None or thing == " " or thing == "":
return True
else:
return False |
def _get_batch_size(x1_shape, x2_shape, prim_name=None):
"""
Get batch sizes from two inputs
"""
msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
if len(x1_shape) < 2 or len(x2_shape) < 2:
raise ValueError(f"{msg_prefix} inputs x1, x2 should have 'dimension >= 2', "
... |
def popular_authors_query(limit=None):
"""Return an SQL string to query for popular article authors.
Args:
limit (int): The maximum number of results to query for. If
ommited, query for all matching results.
Returns:
str: An SQL string. When used in a query, the resu... |
def tflite_ios_lab_runner(version):
"""This is a no-op outside of Google."""
# Can switch back to None when https://github.com/bazelbuild/rules_apple/pull/757 is fixed
return "@build_bazel_rules_apple//apple/testing/default_runner:ios_default_runner" |
def show_result(pg_version, es_version, name, output):
""" Show the result of a test """
success, error = output
print(
"PostgreSQL {pg_version} with Elasticsearch {es_version}: Test {name} - {result}".format(
pg_version=pg_version,
es_version=es_version,
name=na... |
def quick_sort(items, index=-1):
"""
the quick sort algorithm takes in an unsorted list of numbers.
returns a list in ascending order.
Parameters
----------
items : list
list of unordered numbers
index: int, optional
index number at which to choose the split value
de... |
def get_attr_val(request, obj, attr, default=None, **kwargs):
"""
This function attempts to get a value from the 'obj' through 'attr' (either a callable or a variable).
If 'attr' is not defined on 'obj' then we attempt to fall back to the default.
"""
if hasattr(obj, attr):
attr_holder = ge... |
def inside_image(x, y, im_info):
"""
check if a point is in the image
"""
return x >= 0 and y >= 0 and x < im_info[1] and y < im_info[0] |
def get_empty_eks_nodegroup(name: str) -> dict:
"""
Gets an empty nodegroup in EKS-dict format that only has the Cortex nodegroup name filled out.
"""
return {"name": name} |
def levenshtein(a, b):
"""Compute the Levenshtein distance between two strings a and b.
Args:
a (str): 1st string
b (str): 2nd string
Returns:
int: the levenshtein distance between a and b
Note:
See https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_... |
def SexoFP_(kin_RE,kout_RE,Vspine):
"""Returns the fixed point of the exocytosis event size Sexo, i.e. the number of AMPARs delivered to the spine membrane during one exocytosis event.
Parameters
----------
kin_RE : float
Rate at which AMPAR containing endosomes enter the spine (dynamics of exo... |
def next_label(label):
"""
Returns the next label char by cycling through ASCII chars
'0' through '}'.
"""
return chr(((ord(label) - 48 + 1) % 78) + 48) |
def tts_version(version):
"""Convert a version string to something the TTS will pronounce correctly.
Args:
version (str): The version string, e.g. '1.1.2'
Returns:
str: A pronounceable version string, e.g. '1 point 1 point 2'
"""
return version.replace('.', ' punto ') |
def binomial_coefficient(m, n):
""" Given the equation (x+1)^n, return the coefficing of x^m.
Use as reference the triangle of Pascal:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
Params:
m, int
n, int
Returns:
int
"""... |
def find_Aend(seq, min_a_len=8):
"""
Given a sequence, find the likely beginning and end of polyA tail
"""
Aseq = 'A'*min_a_len
# will search for only the last 200 bp of the sequence
x = seq[-200:]
j = x.rfind(Aseq)
if j >= 0:
# now find the beginning
end = len(seq)-200+... |
def process_test_result(passed, info, is_verbose, exit):
"""
Process and print test results to the console.
"""
# if the environment does not contain necessary programs, exit early.
if passed is False and "merlin: command not found" in info["stderr"]:
print(f"\nMissing from environment:\n\t{... |
def dai_presence(tree, context):
"""Return 1 for all DAIs in the given context.
@rtype: dict
@return: dictionary with keys composed of DAIs and values equal to 1
"""
ret = {}
for dai in context['da']:
ret[str(dai)] = 1
return ret |
def color(fg=None, bg=None, style=None):
"""
Returns an ANSI color code. If no arguments are specified,
the reset code is returned.
"""
fmt_list = [style, fg, bg]
fmt_list = [str(x) for x in fmt_list if x is not None]
if len(fmt_list) == 0:
fmt = "0"
else:
fmt = ";".join(... |
def format_address(parts):
"""
Format a parsed email address for sending
:param parts: a tuple of the name and email
:return: a properly formatted email
"""
if parts[0] == "":
return parts[1]
return f"{parts[0]} <{parts[1]}>" |
def _processLGkwargs(className, **LGkwargs):
"""
Pre-processes the launch_gateway arguments.
Arguments:
----------
className : str
name of the class that made the call
LGkwargs : dict, optional
dictionary with a user set arguments
Returns:
----------
LGkwargs: dict
... |
def FindBlockIndex(filename, format, num_blocks):
"""Returns true if the filename matches the format with an
index in the range [1, num_blocks]."""
for block in range(1, num_blocks+1):
suffix = format % block
if filename.endswith(suffix):
return block
raise Exception("Can't find block index: %s... |
def valid_passwords_1(passwords):
"""
Takes a list of password strings, and returns the number of passwords in
the list meeting the following criteria:
- Passwords are six digit numbers
- In each password two adjacent digits must be the same
- In each password, going... |
def _assess_fit_method(ktp_dct, inp_fit_method):
""" Assess if there are any rates to fit and if so, check if
the input fit method should be used, or just simple Arrhenius
fits will suffice because there is only one pressure for which
rates exist to be fit.
"""
if ktp_dct:
p... |
def utf_8_encoder(unicode_csv_data):
"""Converts every unicode string in an array into a UTF8-encoded string"""
return [line.encode('utf-8') for line in unicode_csv_data] |
def _nck(n, k):
"""
n choose k
"""
if 0 <= k <= n:
ntok = 1
ktok = 1
for t in range(1, min(k, n - k) + 1):
ntok *= n
ktok *= t
n -= 1
return ntok // ktok
else:
return 0 |
def absall(lst):
"""Makes all values of a list into the absolute value of that number"""
return [abs(i) for i in list(lst)] |
def merge_complex_dictionaries(d1, d2):
"""
Merges two dictionaries where the values can be lists, sets or other dictionaries with the same behaviour.
If values are not list, set or dict then d2 values prevail
:param d1:
:param d2:
:return:
"""
clashing_keys = set(d1) & set(d2)
for k... |
def collect_params(model_list, exclude_bias_and_bn=True):
"""
exclude_bias_and bn: exclude bias and bn from both weight decay and LARS adaptation
in the PyTorch implementation of ResNet, `downsample.1` are bn layers
"""
param_list = []
for model in model_list:
for name, param in mode... |
def in_namespace(uri, base_uri):
"""
Check if given URI is in the "namespace" of the given base URI
"""
if any((
base_uri.endswith("#"),
base_uri.endswith("/")
)):
# We chop off last character of base uri as that typically can include a
# backslash (/) or a fragment ... |
def unscramble(sol: int, y: int, shift: int, bit_mask: int, r: int = 0, dir: str = 'right'):
"""
This function recursively unscrambles the tempering done by the mersenne twister. It works like this:
scrambling is off the form:
yn+1 = yn ^ ((yn << shift) & bit_mask)
and since xorring is it's own inve... |
def is_pass_act(board_size, action):
"""Check if the action is pass."""
return action == board_size ** 2 + 1 |
def search_dicts(k, v, data):
"""
Search a list of dicts by key
"""
match = []
for row in data:
if k in row:
if v == row[k]:
match.append(row)
if len(match) == 1:
# If we only get one result: return just it as a dictr
return match[0]
else:... |
def pick_not(L,c):
""" computes L(~c)"""
x = []
for i in range(len(L)):
if not i in c:
x = x + [L[i]]
return x |
def split_real_imag(array):
"""
takes a complex array and returns the real and the imaginary part
"""
return array.real, array.imag |
def pipe_dimension_table(pipelist):
"""Print pipe dimensions in a tabular text format
Args:
pipelist ([dict]): List of dicts containing pipe data
Returns:
(str): Text table of pipe dimensions"""
result = 'Pipe Diameter Length CHW\n'
for currpipe in pipelist:
... |
def _clean_response(response):
"""Allow for `ext` or `.ext` format.
The user can, for example, use either `.csv` or `csv` in the response kwarg.
"""
return response.lstrip(".") |
def InterpolateDosePlanes(uplane, lplane, fz):
"""Interpolates a dose plane between two bounding planes at the given relative location."""
# uplane and lplane are the upper and lower dose plane, between which the new dose plane
# will be interpolated.
# fz is the fractional distance from the bottom t... |
def booleanformat(value):
"""
Format a boolean value
"""
if isinstance(value, bool):
if value is True:
return "true"
elif value is False:
return "false"
elif value in ("true", "false"):
return value
else:
raise ValueError(f"A boolean value ... |
def copy_dict(d: dict) -> dict:
"""
Return an exact copy of dictionary <d>. The dictionary has to have all
keys referring to values that are arrays such as tuples, lists, etc.
"""
new_dict = {}
for key in d:
new_dict[key] = d[key]
return new_dict |
def _process_coords(img_size, wm_size, coord_spec):
"""
Given the dimensions of the image and the watermark as (x,y) tuples and a
location specification, return the coordinates where the watermark should
be placed according to the specification in a (x,y) tuple.
Specification can use pixels, percent... |
def set_story_url(item):
"""Sets the story url."""
urls = []
if 'video_versions' in item:
urls.append(item['video_versions'][0]['url'])
if 'image_versions2' in item:
urls.append(item['image_versions2']['candidates'][0]['url'].split('?')[0])
item['urls'] = urls
return item |
def boto_instance_to_dict(boto_instance):
"""
Create a pared-down representation of an RDS instance from the full boto
dictionary.
"""
instance = {
'identifier': boto_instance['DBInstanceIdentifier'],
'engine': boto_instance['Engine'],
'status': boto_instance['DBInstanceStatu... |
def improvedeuleriteration(xi, yi, h, f):
"""Performs one iteration of Improved Euler's method.
Args:
xi (float): The previous x value
yi (float): The previous y value
h (float): The step size
f (function): The derivative of y at That is, y' = f(x,y). f must be a defined before ... |
def parse_movie(line, sep='::'):
"""
Parses a movie line
Returns: tuple of (movie_id, title)
"""
fields = line.strip().split(sep)
movie_id = int(fields[0]) # convert movie_id to int
title = fields[1]
return movie_id, title |
def get_article(user_input):
"""Determine which article to use"""
# vowels = ['a', 'e', 'i', 'o', 'u']
if user_input[0] in 'aeiouAEIOU':
solution = "an"
else:
solution = "a"
return solution |
def make_bool(token_string):
"""
Converts a token string to a boolean.
"""
if token_string in ('yes', 'true'): return True
elif token_string in ('no', 'false'): return False
else: raise ValueError('Invalid token string %s for bool.' % token_string) |
def get_leading_ws(s):
"""Returns the leading whitespace of 's'."""
i = 0; n = len(s)
while i < n and s[i] in (' ', '\t'):
i += 1
return s[0: i] |
def MK_FP(seg, off):
"""
Return value of expression: ((seg<<4) + off)
"""
return (seg << 4) + off |
def compute_string_properties(string):
"""Given a string of lowercase letters, returns a tuple containing the
following three elements:
0. The length of the string
1. A list of all the characters in the string (including duplicates, if
any), sorted in REVERSE alphabetical order
... |
def convert_column(col, table=None, quote_open="`", quote_close="`"):
"""Turns foo.id into foo.c.id. If a table is given, then id becomes
<table>.c.id"""
col = col.replace(quote_open, "").replace(quote_close, "")
if "." in col and table and not col.startswith(table.name):
raise Exception("field ... |
def filter_sentences(sentences, max_words=25, src=False):
"""
Filter sentences to satisfy maxWords.
If src, keep the last sentences
If tgt, keep only the first sentences
"""
if src:
sentences = reversed(list(sentences))
lines = []
word_count = 0
for sentence in sentences:
... |
def _flat_top(close, low, open, high):
"""
do we have a flat top
:param close:
:param low:
:param open:
:param high:
:return: 1 if flat and green candle
0 if no flat top
-1 of flat top and red candle
"""
if high == close:
return 1
elif high == o... |
def majority_element(num_list):
"""
Find the element which shows up the most in a list
:param num_list:
:return:
"""
index, control = 0, 1
for i in range(1, len(num_list)):
if num_list[index] == num_list[i]:
control += 1
else:
control -= 1
... |
def binarySearch(v,n):
"""binary search in an ordered vector
Arguments:
v {vector} -- vector with ordered elements
n {integer} -- search number
Returns:
boolean -- true if element exist in list
"""
l = len(v)
if l >= 1:
mid = l//2
if v[mid]==n:
... |
def treat_tunnel(tunnel_model, ts_sadpt, ts_nobarrier, radrad):
""" decide to treat tunneling
"""
treat = True
if tunnel_model != 'none':
if radrad:
if ts_nobarrier in ('pst', 'rpvtst', 'vrctst'):
treat = False
else:
if ts_sadpt == ('pst', 'vrctst'... |
def multiply2by2Matricies(A, B):
"""This performs matrix multiplication in only 7 multiplies."""
##Thank you the internet and Strassen...
M_1 = (A[0][0]+A[1][1])*(B[0][0]+B[1][1])
M_2 = (A[1][0]+A[1][1])*B[0][0]
M_3 = A[0][0]*(B[0][1]-B[1][1])
M_4 = A[1][1]*(B[1][0]-B[0][0])
M_5 = (A[0][0]+A... |
def color_from_code(code):
"""Generate a color based on a simple code
Args:
code (int): an integer going from 1 to 999
Returns:
[tuple]: the rgb color code
"""
if code == 0:
return (255, 255, 255)
assert code < 1000
color = [0, 0, 0]
for i,... |
def join_ctype_and_name(ctype, name):
"""
Utility method that joins a C type and a variable name into
a single string
>>> join_ctype_and_name('void*', 'foo')
'void *foo'
>>> join_ctype_and_name('void *', 'foo')
'void *foo'
>>> join_ctype_and_name("void**", "foo")
'void **foo'
>>... |
def get_kan_builder_version(params):
"""Return builder docker image version."""
return "{minikan_version}_{zookeeper_version}".format(**params) |
def isEmptyStr(v):
""" check for any empty string """
return False if v is not None and v != '' and not v.isspace() else True |
def dict_compare(ref_dict, compare_dict):
"""Returns True if key-value pairs in ref_dict are same as compare_dict"""
for k, v in ref_dict.items():
if compare_dict[k] != v:
return False
return True |
def wild2regex(string):
"""Convert a Unix wildcard glob into a regular expression"""
return string.replace('.','\.').replace('*','.*').replace('?','.').replace('!','^') |
def recursive_update(default, custom):
"""
https://github.com/Maples7/dict-recursive-update/blob/master/dict_recursive_update/__init__.py
"""
if not isinstance(default, dict) or not isinstance(custom, dict):
raise TypeError('Params of recursive_update should be dicts')
for key in custom:
... |
def inverte_string(s):
"""
inverte_string: string --> string
inverte_string(string) recebe uma string e inverte-a, ou seja, devolve a
mesma string, lida da direita para esquerda.
"""
nova_string = ''
for i in range(len(s)-1,-1,-1):
nova_string = nova_string + s[i]
return nova_str... |
def sum_two_smallest_numbers(numbers):
"""
Create a function that returns the sum of the two lowest positive numbers given an array of minimum 4 positive
integers. No floats or non-positive integers will be passed.
:param numbers: an array of 4 or more positive numbers.
:return: the sum of the two s... |
def authenticate(username, password):
"""
:param username:
:param password:
:return:
"""
# server_url = "https://yourloginservice.com"
# auth_url = '%s/auth' % server_url
# param_dict = dict(login=username, password=password)
# headers = "prepare your data"
# """
# # this is an example of real world case
#... |
def curve_q(x, y, p, n):
"""Find curve parameter q mod n having point (x, y) and parameter p"""
return ((x * x - p) * x - y * y) % n |
def num_desc_prime_seq_given_total_and_head(total, head, list_of_primes, set_of_primes):
"""
Subproblem in dynamic programming.
Using a pre-computed list & set of primes, count the number of descending prime sequences given a total and the head.
Note that a one-term sequence is also considered a sequenc... |
def length_more_than_one(x):
"""creating a function for checking the length of word is greater than 1"""
if(len(x[0])>1):
return(x) |
def isinitialized(register: str, register_copy: dict) -> bool:
"""
Check if a given register is already initialized.
:param register: Register to check.
:param register_copy: Dictionary of existing registers.
:return: True if register is already initialized.
"""
try:
register_copy[re... |
def clean_acl(name, value):
"""
Returns a cleaned ACL header value, validating that it meets the formatting
requirements for standard Swift ACL strings.
The ACL format is::
[item[,item...]]
Each item can be a group name to give access to or a referrer designation
to grant or deny base... |
def compute_iou(rect1, rect2):
"""
computing IoU
:param rec1: (y0, x0, y1, x1), which reflects
(top, left, bottom, right)
:param rec2: (y0, x0, y1, x1)
:return: scala value of IoU
"""
rec1 = [rect1[1], rect1[0], rect1[3], rect1[2]]
rec2 = [rect2[1], rect2[0], rect2[3], rect2[... |
def ERR_YOUWILLBEBANNED(sender, receipient, message):
""" Error Code 466 """
return "ERROR from <" + sender + ">: " + message |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.