content stringlengths 42 6.51k |
|---|
def cats_game(board):
"""Checks if the any of the values in the board list has not been used"""
if board[0][0] == 1 or board[0][1] == 2 or board[0][2] == 3 or \
board[1][0] == 4 or board[1][1] == 5 or board[1][2] == 6 or \
board[2][0] == 7 or board[2][1] == 8 or board[2][2] == 9:
... |
def interpretBoolean(s):
"""
Interpret string as a boolean value.
"0" and "False" are interpreted as False. All other strings result in
True. Technically, only "0" and "1" values should be seen in UCI files.
However, because of some string conversions in Python, we may encounter
"False".
... |
def filter_lambda(Input_Dict):
"""
Filter lambda parameter.
:param Input_Dict: input parameters dictionary
:type Input_Dict : dict
:return: modified dictionary
"""
try:
if Input_Dict["lambda"] > 23:
Input_Dict["lambda"] = 23
print(
"[Warning] ... |
def _int32_to_bytes(i):
# NOTE: This course is done on a Mac which is little-endian
"""Convert an integer to four bytes in little-endian format."""
# &: Bitwise 'and'
# >>: Right shift
return bytes((i & 0xff,
i >> 8 & 0xff,
i >> 16 & 0xff,
... |
def factorial(a: int, results={}):
"""
handle edge case
a == 0 or 1 or -ve number
"""
if a in results:
return results[a]
if a == 0 or a == 1:
return 1
if a < 0:
return "Negative Integer is not allowed"
# recursive call
result = a * factorial(a - 1)
# m... |
def get_variables(deployment_config: dict) -> dict:
"""Environment variables update to support the 2 level of definition
- ope for operational environment variables
- app for application level environment variables
"""
variables = deployment_config.get("variables", {})
app_variables = variables... |
def _process_size(dtype, data):
"""Returns the MPL encoding equivalent for Altair size channel
"""
if dtype == 'quantitative':
return ('s', data)
elif dtype == 'nominal':
raise NotImplementedError
elif dtype == 'ordinal':
return ('s', data)
elif dtype == 'temporal':
... |
def bucket_sort(array):
""" The function for bucket sort implementation assigning
array elements into corresponding buckets and then recombining
the buckets into a sorted array.
The implementation is simplified since the input is always
equally distributed in a range [0, max].
"""
# Creat... |
def brightness(value):
"""Brightness of the light. This is a scale from the minimum brightness the
light is capable of, 1, to the maximum capable brightness, 254."""
value = int(value)
if value < 1 or value > 254:
raise ValueError('Minimum brightness is 1, to the maximum 254')
return value |
def sieve_bam(configdict):
"""
helper function to check whether or not we use rule sieve_bam
"""
return (
configdict.get("min_mapping_quality", 0) > 0
or configdict.get("tn5_shift", False)
or configdict.get("remove_blacklist", False)
or configdict.get("remove_mito", False... |
def hypothesis(theta0, theta1, x):
"""Return our hypothesis, or guess, given the parameters and input value"""
return theta0 + (theta1 * x) |
def mult_sum(a, b, c):
"""
Multiply and sum operation.
:param a: First multiply operator.
:param b: Second multiply operator.
:param c: Sum operator.
"""
return a * b + c |
def factI(n):
"""Assumes that n is an int > 0
Returns n!"""
result = 1
while n > 1:
result = result * n
n -= 1
return result |
def read_text(file_name):
"""
Reads tweets from a text file
:param file_name:
:return: content of text file, line by line
"""
my_file = open(file_name, 'r')
file_lines = my_file.readlines()
my_file.close()
return file_lines |
def split_list2batches(lst, batch_size):
"""Split list of images to list of bacthes."""
return [lst[i:i+batch_size] for i in range(0, len(lst), batch_size)] |
def sieve5(n):
"""Return a list of the primes below n."""
"""from http://codereview.stackexchange.com/questions/42420/sieve-of-eratosthenes-python"""
prime = [True] * n
result = [2]
append = result.append
sqrt_n = (int(n ** .5) + 1) | 1 # ensure it's odd
for p in range(3, sqrt_n, 2):
... |
def update_Q(Qsa, Qsa_next, reward, alpha, gamma):
""" updates the action-value function estimate using the most recent time step """
return Qsa + (alpha * (reward + (gamma * Qsa_next) - Qsa)) |
def field_push(field, new):
"""
Return an updated array field with new data included. Does not take fields with duplicate entries.
"""
newList = list(field).copy()
newList.append(new)
return newList |
def makeInverseIndex(strlist):
"""
Input: a list of documents as strings
Output: a dictionary that maps each word in any document to the set consisting of the
document ids (ie, the index in the strlist) for all documents containing the word.
Distinguish between an occurence of a string (e.g.... |
def question_function(variable: int) -> int:
"""
The generating function u as specified in the question.
>>> question_function(0)
1
>>> question_function(1)
1
>>> question_function(5)
8138021
>>> question_function(10)
9090909091
"""
return (
1
... |
def num_to_time(num):
"""
Turn the num returned from method "time_to_num" back to the string form.
e.g. num_to_time(18) -> "9:00"
num_to_time(25) -> "12:30"
"""
return str(num//2) + ':00' if num % 2 == 0 else str(num//2) + ':30' |
def custom_error_name_func(func_name, kwargs):
"""Disregard `func` argument, use the error only."""
return '{func_name}__{error_type}'.format(
func_name=func_name,
error_type=kwargs['error'].__name__
) |
def _extract_from_quotes(s):
"""Given a string, returns the portion between the first and last
double quote (ASCII 34). If there aren't at least two quote characters,
the original string is returned."""
start = s.find('"')
end = s.rfind('"')
if (start != -1) and (end != -1):
s = s[start... |
def inverso(c):
"""(list) -> list
Inverso aditivo de un numero complejo"""
r = []
for i in c:
r = r + [-i]
return r |
def format_size(size):
"""
Auxiliary function to convert bytes to a more readable
human format.
"""
suffixes = ['B', 'KB', 'MB', 'GB']
i = 0
while size >= 1024 and i < len(suffixes) - 1:
size = size / 1024
i += 1
return f"{size:.2f} {suffixes[i]}" |
def norm2range(x, beta):
"""
normalize to [0,1], origin[-beta, beta]
:param x:
:param beta:
:return:
"""
return x/(2*beta) + 0.5 |
def AreNodesSame(node_data_1, node_data_2):
"""Compares if two nodes are the same.
Currently using a very basic algorithm: assume the nodes are the same if
either their XPaths are the same or their dimension/positions are the same.
Args:
node_data_1: A dictionary of values about a DOM node.
node_data_... |
def overlap(x1, x2, y1, y2):
""" Return True if x1-x2/y1-y2 ranges overlap. """
return (x2 >= y1) & (y2 >= x1) |
def bracket_level(text, open={'(', '[', '{'}, close={')', ']', '}'}):
"""Return 0 if string contains balanced brackets or no brackets."""
level = 0
for c in text:
if c in open:
level += 1
elif c in close:
level -= 1
return level |
def bisect_right(a, x, lo=0, hi=None):
"""Return the index where to insert item x in list a, assuming a is sorted.
The return value i is such that all e in a[:i] have e <= x, and all e in
a[i:] have e > x. So if x already appears in the list, i points just
beyond the rightmost x already there.
Op... |
def remove_protocol(path_without_protocol):
"""
Remove protocol from path
:param path_without_protocol:
:return: path without protocol
"""
protocols = ['file://', 'file:', 'file/']
for prot in protocols:
stripped_path = path_without_protocol.replace(prot, '')
if len(stripped_... |
def latex_float(f):
"""
http://stackoverflow.com/questions/13490292/
format-number-using-latex-notation-in-python
"""
float_str = "{0:.2g}".format(f)
if "e" in float_str:
base, exponent = float_str.split("e")
return r"{0} \times 10^{{{1}}}".format(base, int(exponent))
else:
... |
def middle(lst, size):
"""Return the middle fraction of a sorted list, removing outliers."""
mid_lst = sorted(list(lst))
l_mid_lst = len(mid_lst)
num_el = int(size * l_mid_lst)
start = (l_mid_lst - num_el) // 2
end = start + num_el
mid_lst = mid_lst[start:end]
return mid_lst |
def merge_properties(prop_sets):
""" Perform an inner join on a list of dictionaries """
inner_keys = set.intersection(*[set(p.keys()) for p in prop_sets])
data = {}
for key in inner_keys:
data[key] = [p[key] for p in prop_sets]
return data |
def line_is_comment(line: str) -> bool:
"""From FORTRAN Language Reference
(https://docs.oracle.com/cd/E19957-01/805-4939/z40007332024/index.html)
A line with a c, C, '*', d, D, or ! in column one is a comment line, except
that if the -xld option is set, then the lines starting with D or d are
comp... |
def human_point(column, row):
"""Return the human-readable version of the point."""
column_array = "ABCDEFGHJKLMNOPQRSTUVWXYZ"
return column_array[column] + str(row + 1) |
def register_argument_parser(add_parser, action):
"""Calls add_parser for the given sub-command (create or update) and returns the parser"""
sub_command = str(action)
return add_parser(sub_command,
help=f'{sub_command} token',
description=f'{sub_command.capitalize... |
def model_wave(time, period, width) -> float:
"""
Models a rise time of width/2 followed immediately by a fall time of width/2
Each wave is separated by (period - width) milliseconds
"""
cur_time = time % period
half_width = width//2
if cur_time < half_width:
return float(cur... |
def diff_list(l1, l2):
"""Returns side by side equality test"""
return [False if i1==i2 else True for (i1, i2) in zip(l1, l2)] |
def control_metric(name):
"""Returns the (mode, metric) pair in History for the given control."""
return ("train", "training/{}".format(name)) |
def is_not_blank_or_none(value: str):
"""
Returns True if the specified string is not whitespace, empty or None.
:param value: the string to check
:return: True if the specified string is not whitespace, empty or None
"""
try:
return not "".__eq__(value.strip())
except AttributeErro... |
def to_percentage(number, rounding=2):
"""Creates a percentage string representation from the given `number`. The
number is multiplied by 100 before adding a '%' character.
Raises `ValueError` if `number` cannot be converted to a number.
"""
number = float(number) * 100
number_as_int = int(numb... |
def _attr_key(attr):
"""Returns appropriate key for sorting attribute names
Attribute names are a tuple of ``(namespace, name)`` where namespace can be
``None`` or a string. These can't be compared in Python 3, so we conver the
``None`` to an empty string.
"""
key = (attr[0][0] or ""),... |
def extract_frequency(word, dictionary, return_as_binary_vector=False):
""" This function extracts frequencies for a given word from a dictionary of frequencies
Args:
word (str): Word
dictionary (dict): Dictionary with frequencies
return_as_binary_vector (bool): Returns ... |
def remove_unicode_identifiers(s_var):
"""
Removes the u infrount of a unicode string: u'string' -> 'string'
Note that this also removes a u at the end of string 'stru' -> 'str'
which is not intended.
@ In, s_var, string, string to remove characters from
@ Out, s_var, string, cleaned string
""... |
def get_hidden_word(hidden_word, used_letters):
"""Returns a string of the form __ad___ by filling in correct guesses"""
visible_word = ""
for letter in hidden_word:
if letter in used_letters:
visible_word += letter
else:
if len(visible_word) > 0 and visible_wo... |
def sig_key(s, order):
"""
Key for comparing two signatures.
s = (m, k), t = (n, l)
s < t iff [k > l] or [k == l and m < n]
s > t otherwise
"""
return (-s[1], order(s[0])) |
def arn_for(name: str) -> str:
"""Return the ARN that probably holds the named policy."""
return f"arn:aws:iam::aws:policy/{name}" |
def _translate_boudingBoxes(
xLeft: int,
yLeft: int,
width: int,
height: int
):
""" translate the annotation of the visdrone dataset into the one used in csv_generator
Args
xleft : The x coordinate of the top-left corner of the bounding box
yleft : Th... |
def fib(position):
""" Fibonacci sequence function using for loop"""
if position == 0:
return 0
elif position == 1:
return 1
else:
first, second = 0, 1
next = first + second
for index in range(2, position):
first = second
second = next
... |
def parse_records(database_records):
"""
A helper method for converting a list of database record objects into a list of dictionaries, so they can be returned as JSON
Param: database_records (a list of db.Model instances)
Example: parse_records(User.query.all())
Returns: a list of dictionaries, each... |
def map_range(x, in_min, in_max, out_min, out_max):
"""
Maps a value from one range to another. Values beyond the input minimum or
maximum will be limited to the minimum or maximum of the output range.
:return: Returns value mapped to new range
:rtype: float
"""
in_range = in_max - in_min
... |
def _get_attachment_keys(items: list) -> list:
"""Retrieves attachment keys of attachments in provided list of items.
Args:
items (list): List of Zotero items.
Returns:
list: List of attachment keys.
"""
attach = [x for x in items if x['data']['itemType'] == 'attachment']
if le... |
def set_source_display(
n_interval,
meas_triggered,
knob_val,
old_source_display_val,
swp_start,
swp_stop,
swp_step,
mode_val,
swp_on,
):
""""set the source value to the instrument"""
if mode_val == "single":
return knob_val
else:
if meas_triggered:
... |
def batch_cmd_create_irf(
cwd,
mc_gamma,
mc_proton,
mc_electron,
output_irf_file,
dl3_config
):
"""Create batch command to create IRF file with sbatch."""
return [
"sbatch",
"--parsable",
"--mem=6GB",
"--job-name=irf",
"-D",... |
def saturation_distance(mean_mu_squared, wavenumber, scale):
"""Saturation distance according to Wenzel.
:param mean_mu_squared: Mean mu squared.
:param wavenumber: Wavenumber.
:param scale: Outer length scale.
See Daigle, 1987: equation 5
.. math:: r_s = \\frac{1}{2 \\langle \mu^2 \\rangle k... |
def str2span(str):
"""
:param str: string representation of span: {start}_{end}
:return: span array representing [start, end]
"""
s, e = str.split('_')
return [int(s), int(e)] |
def is_syncable_file(file_str):
"""
Returns True if the given file is syncable to remote storage.
"""
return not file_str.startswith('.') and not file_str.startswith('_') |
def string_to_float(value):
"""custom version of float() that supports commas as decimal separators
when the input contains no periods"""
# if no periods (.) then assume commas are decimal separators
if '.' not in value:
value = value.replace(',', '.')
# if decimals exist then simply remove ... |
def split_dict_by_key_prefix(d, prefix):
"""
Returns two dictionaries, one containing all the items whose keys do not
start with a prefix and another containing all the items whose keys do start
with the prefix. Note that the prefix is not removed from the keys.
"""
no_prefix = dict()
with_p... |
def read_map(file_name):
"""This function opens a file with the name in 'file_name', reads the map it
contains. Stores each line of the file as strings in a list.
pre: none, as this function handles IOError for when the file is not there gracefully
post: Returns a list of strings."""
map_file_list_o... |
def get_pieces(text, plen, overlap):
""" Split a document into text pieces."""
words = text.split(' ')
s, e = 0, 0
chunks = []
while s < len(words):
e = s + plen
if len(words) - e < overlap:
e = len(words)
p = ' '.join(words[s:e])
chunks.append(p)
... |
def choose_permutation(permuts):
"""
Choose a random permutation, convert to set and return a sequence, sorted in an alphanumeric order
:param permuts: [[P_00, P_01, P_02, ...], [P_10, P_11, P_12, ...], ...]
:return: a list containing sorted true token IDs forming the sentence
"""
oracle_permut ... |
def read_graph_nodes(dict1,node_list):
"""
fname is the file name which contains nodes of the graph
node_list contains encrypted nodes from the pra
This function will convert encrypted node_list to humain readable form
return the converted list of nodes in the same order
if any node is not convertable,... |
def COL_DIST1(col1, col2):
"""
Computes 1-distance between two RGB vectors, i.e.
= abs(r) + abs(g) + abs(b)
"""
r, g, b = (col1[i] - col2[i] for i in range(0, 3))
return abs(r) + abs(g) + abs(b) |
def split_nth(seq, separator, n):
"""
Split sequence at the n-th occurence of separator
Args:
seq(str) : sequence to split
separator(str): separator to split on
n(int) : split at the n-th occurence
"""
pos = 0
for i in range(n):
pos = seq.index(separator, pos + 1... |
def transcribe(seq: str) -> str:
"""
transcribes DNA to RNA by generating
the complement sequence with T -> U replacement
"""
# rna dict
rna_dict = {'A': 'U', 'T': 'A',
'C': 'G', 'G': 'C'}
# seq to list
seq_list = list(seq)
# for each el in list get key
for i, ... |
def get_link_for_post(page):
"""
Search for link to post data in the page
:param page: The code of the page for search in it
:return: The link for post method or None
"""
page = str(page).replace("\\n", "\n")
# stage 1 - search for form-urlencoded
for line in page.strip().split('\n'):
... |
def extract_first_cell_text(notebook_data):
"""Extract MarkDown data from first cell."""
try:
first_cell = notebook_data["cells"][0]
except (AttributeError, IndexError):
return ""
if first_cell["cell_type"] != "markdown":
return ""
return first_cell["source"] |
def modulo(a, b, c):
"""
Calculates modulo
"""
return ((int(a) ** int(b)) % int(c)) |
def get_percent(key, row):
"""Reads a percentage from a row."""
if key in row and row[key]:
percent = row[key]
if '%' in percent:
return float(percent.replace('%', '')) / 100.0
else:
return float(percent)
else:
return None |
def psmid_to_charge(psmid):
"""
Extract charge from Percolator PSMId.
Expects the following formatted PSMId:
`run` _ `SII` _ `MSGFPlus spectrum index` _ `PSM rank` _ `scan number` _ `MSGFPlus-assigned charge` _ `rank`
See https://github.com/percolator/percolator/issues/147
"""
psmid = ... |
def _TpuCore(device):
"""Returns the TPU core represented by <device>, or -1 if not TPU."""
prefix = "device:TPU_REPLICATED_CORE:"
if prefix in device:
return int(device[len(prefix):])
return -1 |
def test_tuple(x, y):
"""Test multiple outputs."""
return (x + y, x - y, x * y, x / y) |
def next_skill_cost(cost: int) -> int:
"""Return the next higher skill cost after cost."""
if cost == 0:
return 1
elif cost == 1:
return 2
elif cost == 2:
return 4
else:
return cost + 4 |
def reduce(f, iterable, initializer=None):
""" Reduction Operation
>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
>>> reduce(lambda x, y: x + y, ['w', 'o', 'r', 'd'])
'word'
>>> x = [1, 2, [3, 4], 'aabb']
>>> reduce(lambda i, _: i + 1, [1] + x[1:])
4
... |
def getSubstrings(text, m):
""" Divide il testo in sottostringhe, ognuna di dimensione ceil(len(text)/m))
Il testo viene diviso scrivendo "per colonne"
:param text: testo da suddividere
:param m: numero di righe in cui suddividere il testo
:return: lista di sottostringhe scritte per colonna
"""
substrings = []
... |
def _name_groups(names, multi=False):
""" Build the list of names
"""
if not multi:
tors_names = tuple((name,) for name in names)
else:
tors_names = (tuple(name for name in names),)
return tors_names |
def getElementValue(elem, sep=';'):
"""This function returns the value of the element if it is not None, otherwise an empty string.
The function returns the 'text' value if there is one
>>> class Test: text = 'hello'
>>> obj = Test()
>>> getElementValue(obj)
'hello'
It returns nothing if there is no tex... |
def convert_bounding_box(bb_from_get):
"""Convert bounding box specified by by {'low': (x_min, y_min, z_min), 'high': (x_max, y_max,
z_max)} to {'xMin': x_min, 'yMin': y_min, ..., 'zMax': z_max}
Input typically comes from Abaqus' function getBoundingBox. Output, bb_to_get_by, can be used in
Abaqu... |
def confirm_intent(session_attrs, intent_name, slots, message):
"""
Confirm intent in Lex.
"""
return {
'sessionAttributes': session_attrs,
'dialogAction': {
'type': 'ConfirmIntent',
'intentName': intent_name,
'slots': slots,
'message': {'c... |
def get_cpubind(cpu_binding):
"""Convert aprun-style CPU binding to PALS-style"""
# First check for keywords
if not cpu_binding or cpu_binding == "cpu":
return "thread"
if cpu_binding == "depth":
return "depth"
if cpu_binding == "numa_node":
return "numa"
if cpu_binding =... |
def is_valid_description(description):
"""Check if description is a string"""
return isinstance(description, str) |
def lmap(func, iterable):
"""
returns list after applying map
:: list(map(func, iterable))
"""
return list(map(func, iterable)) |
def get_stack_id(x, y):
"""Get stack id.
Get the portainer stack id for a given
stack name.
Args:
x: Portainer stack name
y: Deployed portainer stacks
Return:
String portainer stack id
"""
return str(list(filter(lambda z: z['Name'] == x, y))[0]['Id']) |
def split_lines(data, newline, keep_ends=False):
"""Split data along newline boundaries.
This differs from :py:meth:`str.splitlines` in that it will split across
a specific newline boundary, rather than against any sequence of newline
characters.
Args:
data (bytes):
The data to... |
def is_valid_occurrence(password: str) -> bool:
"""
Check if given password is valid.
Example: '1-3 b: cdefg' means at cdefg must contain at least 1 b at most 3 b,
thus password is not valid because it contains no b.
:type password: str
:rtype: bool
"""
import re
min_occurrence, max... |
def _SuppressSensitiveParams(name, value):
"""Don't log passwords, and other sensitive information."""
if 'KeyPassphrase' in name or 'WEPKey' in name or 'Password' in name:
value = 'XXXXXXXX'
return (name, value) |
def make_qstr(t):
"""Returns the string representation of t.
Add outer double-quotes if the string has a space.
"""
if not isinstance(t, str):
t = str(t)
if " " in t:
t = f'"{t}"'
return t |
def ellipsize(text, limit, ellipsis=".."):
"""Returns text ellipsized if beyond limit."""
if limit <= 0 or len(text) < limit:
return text
return text[:max(0, limit - len(ellipsis))] + ellipsis |
def format_restrict_dist_string(sym1, sym2, name):
""" build string that has the distance comparison
"""
restrict_string = (
" if (r{0}{1}.lt.rAB) then\n" +
" {2}_corr = 100.0\n" +
" return\n" +
" endif"
).format(sym1, sym2, name)
return rest... |
def _unixypath_to_uri(path):
"""Converts a unix-style path to a file: URL."""
return "//" + path |
def bounds_tuple(start, stop):
"""
Standardize the given start/stop into a tuple-of-ints,
suitable for a dictionary key.
"""
start = tuple(int(x) if x is not None else None for x in start)
stop = tuple(int(x) if x is not None else None for x in stop)
return (start, stop) |
def unflatten(d: dict) -> dict:
"""Unpack tuple keys in `d` to a nested dictionary.
(Inverse of :func:`flatten`.)"""
result: dict = {}
for key_tuple, value in d.items():
assert isinstance(key_tuple, tuple)
target = result # where to add value
for key in key_tuple[:-1]:
... |
def average_hydrophobicity(sequence, window=1, span=None):
"""Takes a sequence, looks at the residues on either side of the upper case
binding residues, and works out the average of their hydrophobicities."""
scale = {
"A": 0.17, "R": 0.81, "N": 0.42, "D": 1.23, "C": -0.24, "E": 2.02,
"Q": ... |
def subsets(nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
def backtrack(first=0, curr = []):
if len(curr)==k:
output.append(curr[:])
return
for i in range(first, n):
curr.append(nums[i])
backtrack(i+1, curr)
#keep carrying over pops
curr.pop()
... |
def geom_to_tuple(geom):
"""
Takes a lat/long point (or geom) from KCMO style csvs.
Returns (lat, long) tuple
"""
geom = geom[6:]
geom = geom.replace(" ", ", ")
return eval(geom) |
def list_br_html_addition(l):
"""
Replace the /n by the <br> HTML tag throughout the list.
:param l: The list
:return: List
"""
for sublist in l:
for i in range(len(sublist)):
if type(sublist[i]) == type(''):
sublist[i] = sublist[i].replace('\n', '<br>')
r... |
def merge_diffs(d1, d2):
"""
Merge diffs `d1` and `d2`, returning a new diff which is
equivalent to applying both diffs in sequence. Do not modify `d1`
or `d2`.
"""
if not isinstance(d1, dict) or not isinstance(d2, dict):
return d2
diff = d1.copy()
for key, val in d2.items():
... |
def Bapplicable(bstate):
### YOUR CODE HERE
### YOUR CODE HERE
### YOUR CODE HERE
### YOUR CODE HERE
### YOUR CODE HERE
"""
bstate: set of belief states (State)
Return: list of applicable actions (Action)
"""
result = {action for s in bstate for action in s.applActions()}
for s in bstate:
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.