content stringlengths 42 6.51k |
|---|
def print_subheader(object_type):
"""
Print out a subheader for a text file.
"""
return """
#################################################################
# {0}
#################################################################
""".format(object_type) |
def selection_sort(arr):
"""
simple selection sort
time: O(n^2)
space: O(1)
"""
for i, _ in enumerate(arr):
min_idx = i
for j in range(i + 1, len(arr)):
# Select the smallest value
if arr[j] < arr[min_idx]:
min_idx = j
# swap the el... |
def add_branch(tree, vector, value):
"""Recursively update dictionary given a vector containing the path of
the branch. Useful for directly adding a value at a specified key path.
Source: https://stackoverflow.com/a/59634887/6654930
"""
key = vector[0]
if len(vector) == 1:
tree[key] = v... |
def get_display_name(record):
"""Get the display name for a record.
Args:
record
A record returned by AWS.
Returns:
A display name for the launch configuration.
"""
return record["LaunchConfigurationName"] |
def _get_query_parameters(module_params):
"""Builds query parameter
:returns: dictionary, which builds the query format
eg : {"$filter": "JobType/Id eq 8"}
"""
system_query_options_param = module_params.get("system_query_options")
query_parameter = {}
if system_query_options_param:
... |
def limit_alpha(word: str):
"""
word is not composed of pure alphas
word should have at last one alpha
word.isdigit() is a speedup for pure digits
:param word:
:return:
"""
return word.isalpha() or word.isdigit() or all([not c.isalpha() for c in word]) |
def get_transform_type(tile_id):
"""
Get the transform type specified in the tile id.
Parameters
----------
cooler_tile_id: str
A tile id for a 2D tile (cooler)
Returns
-------
transform_type: str
The transform type requested for this tile
"""
tile_id_parts = tile... |
def questionmark_amplification(text: str) -> float:
"""
Amplified the questions
"""
# check for added emphasis resulting from question marks (2 or 3+)
qm_count = text.count("?")
qm_amplifier = 0
if qm_count > 1:
if qm_count <= 3:
# (empirically derived mean sentiment inte... |
def get_by_uuid(uuid, dictionary):
"""
Get a specific UUID from a dictionary
:param uuid:
:param dictionary:
:return:
"""
for response in dictionary:
if response['uuid'] == uuid:
return response
return None |
def dict_merge2(*dicts):
""" Return a dict with all values of dicts.
If some key appears twice and contains iterable objects, the values
are merged (instead of overwritten).
"""
res = {}
for d in dicts:
for k in d.keys():
if k in res and isinstance(res[k], (list, tupl... |
def sum_bbox(bbox1, bbox2):
"""Summarizes two bounding boxes. The result will be bounding box which
contains both provided bboxes.
:type bbox1: list
:param bbox1: first bounding box
:type bbox2: list
:param bbox2: second bounding box
:rtype: list
:return: new bounding box
"""
if not bbox1 or not ... |
def _prune_dockerfile(string, comment_char="#"):
"""Remove comments, emptylines, and last layer (serialize to JSON)."""
json_removed = '\n\n'.join(string.split('\n\n')[:-1])
return '\n'.join(row for row in json_removed.split('\n')
if not row.startswith(comment_char) and row) |
def get_human_and_CNN_subjects(subjects):
"""Split subjects into 2 lists: human, CNNs subjects."""
assert type(subjects) is list
human_subjects = []
CNN_subjects = []
for s in subjects:
if s.startswith("subject-"):
human_subjects.append(s)
else:
CNN_subjects.... |
def add_0_str(number: int):
"""add 0 to the beginning to the string if integer is less than 10"""
if number < 10:
# add a zero
n_str = '0' + str(number)
else:
n_str = str(number)
return n_str |
def sent_convert(list_sent):
"""
Given a list of string sentences, return one unique string where
sentences are separated by newlines.
"""
return "\n".join(list_sent) |
def set_default_attr(obj, name, value):
"""Set the `name` attribute of `obj` to `value` if the attribute does not already exist
Parameters
----------
obj: Object
Object whose `name` attribute will be returned (after setting it to `value`, if necessary)
name: String
Name of the attri... |
def regex_or(*items):
"""
Format regular expression (or statement)
Args:
items (regex): Regular Expression
Returns:
capturing regex
"""
return '(?:' + '|'.join(items) + ')' |
def Z3IntDictKey(x, y, prefix):
"""Returns the Z3 variable name for a grid space created by Z3IntDict2D"""
fmt = prefix + '-{}-{}'
return fmt.format(x,y) |
def listify(config, key, sep=','):
""" Create a list from a string containing list elements separated by
sep.
"""
return [i.strip() for i in config[key].split(sep)] |
def fibonacci(n : int) -> int:
"""Returns the fibbonacci function at a specific point\n
** Uses the built in functool's module lru_cache decorator
"""
if n in (0,1):
return 1
return fibonacci(n-1) + fibonacci(n-2) |
def period_size (self, denominator):
""" This functions finds the size of the period
given a fraction 1/denominator """
size = 0
# numerador, denominador y resto
numerator = 1
step = (numerator,0)
stepList = []
stop = False
# Loop, while cant find the period
while stop == Fal... |
def tg_util_get_group_name(msg):
"""
:param msg: msg object from telepot
:return: if msg sent to a group, will return Groups name, return msg type otherwise
"""
title = msg['chat']['type']
# if title == 'group' or title == 'supergroup':
if title in ['group', 'supergroup']:
title = ms... |
def build_profile(first, last, **user_info):
"""Build a dictionary containing everything we know about a user."""
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():
profile[key] = value
return profile
user_profile = build_prof... |
def validate_file_name(input_str):
"""Validates that the filename is correct"""
ext = input_str.split('.')
if '.' in input_str and len(ext[-1]) == 3 and len(input_str) >= 5:
return True
elif '.' in input_str and len(ext[-1]) >= 3:
print('Enter filename in correct format. ie. "input.txt"... |
def get_class(obj):
""" Get the class of an object """
# Unfortunately for old-style classes, type(x) returns types.InstanceType.
# But x.__class__ gives us what we want.
return getattr(obj, "__class__", type(obj)) |
def get_key_value(var):
""" Returns first key value pair of the given dict. Use this only when the dict has one
key-value pair as python2 and python3 sort dicts in different ways.
Returns:
var, var: Tuple of key value pair
"""
key = next(iter(var))
value = var[key]
return key, value |
def fstat_to_wellek(f_stat, n_groups, nobs_mean):
"""Convert F statistic to wellek's effect size eps squared
This computes the following effect size :
es = f_stat * (n_groups - 1) / nobs_mean
Parameters
----------
f_stat : float or ndarray
Test statistic of an F-test.
n_groups ... |
def split_to_list_filter(s, delimiter=";"):
"""
Splits a string on delimiter and returns list
E.g. "a;b;c" => ['a', 'b', 'c']
"""
if isinstance(s, str):
return s.split(delimiter)
return s |
def lossy_prio_list(all_prio_list, lossless_prio_list):
"""
This fixture returns the list of lossu priorities
Args:
all_prio_list (pytest fixture) : all the priorities
lossless_prio_list (pytest fixture): lossless priorities
Returns:
Lossy priorities (list)
"""
result =... |
def center_coordinates(coords, size, binning=1):
"""
Given an XYZ tuple of particle coordinates and the reconstruction they came from, shift the
coordinates so that the origin is at the center of the tomogram
Args:
coords: the (x, y, z) coordinates for the particle
size: the reconst... |
def _set_kth_bit(x: int, k: int) -> int:
"""Sets the kth bit in the mask from the right.
"""
mask = 1 << k
return x | mask |
def IsEnum(type):
""" Check if a param type translates to an enum property """
return type == 'Combobox' |
def image_picker(context, request, image=None, images_json_endpoint=None, filters_form=None,
maxheight='800px', owner_choices=None, prefix_route='instance_create'):
""" Reusable Image picker widget (e.g. for Launch Instance page, step 1).
Usage example (in Chameleon template): ${panel('imag... |
def choice_to_number(choice):
"""Convert choice to number."""
# If choice is 'rock', give me 0
# If choice is 'paper', give me 1
# If choice is 'scissors', give me 2
random_dict = {'rock': 0, 'paper': 1, 'scissors': 2}
return random_dict[choice] |
def parse_all_path(nested_list_of_dir):
"""
Transforms this
[
['Landing', 'sub-anye', '180116_001_m_anye_land-001', 'source'],
['Landing', 'sub-enya', '180116_001_m_enya_land-001', 'source'],
['Landing', 'sub-enyo'],
['Landing', 'sub-enyo', '180116_001_m_enyo_land-001']
]... |
def table(name):
"""Return the parameter with foo_ in front of it."""
return f"foo_{name}" |
def GetZipPath(file, dir, dirname):
"""Given an absolute file path, an absolute directory path, and the dirname
of the directory, return a relative path to the file from the parent
directory of the given directory, with unix-style path separators.
"""
file = dirname + file[len(dir):]
return file... |
def get_language(raw):
"""
Extract language of the edition.
@param raw: json object of a Libris edition
@type raw: dictionary
"""
language = raw["mainEntity"]["instanceOf"].get("language")
if language:
return [x["code"] for x in language][0]
return None |
def plural(singular, plural, seq):
"""Selects a singular or plural word based on the length of a sequence.
Parameters
----------
singlular : str
The string to use when ``len(seq) == 1``.
plural : str
The string to use when ``len(seq) != 1``.
seq : sequence
The sequence t... |
def doBoundingBoxesIntersect(b1, b2):
"""
Check if bounding boxes do intersect. If one bounding box touches
the other, they do intersect.
"""
if b1['ll_x'] > b2['ur_x']:
return False
if b1['ur_x'] < b2['ll_x']:
return False
if b1['ll_y'] > b2['ur_y']:
return False
... |
def create_accounttax_sample(account_id, **overwrites):
"""Creates a sample accounttax resource object for the accounttax samples.
Args:
account_id: int, Merchant Center ID these tax settings are for.
**overwrites: dictionary, a set of accounttax attributes to overwrite
Returns:
A new accountt... |
def decode(e):
"""
Decode a run-length encoded list, returning the original time series (opposite of 'encode' function).
Parameters
----------
e : list
Encoded list consisting of 2-tuples of (length, element)
Returns
-------
list
Decoded time series.
"""
return ... |
def make_BIO_tag(ttag, ttype):
"""Inverse of parse_BIO_tag."""
if ttype is None:
return ttag
else:
return ttag+'-'+ttype |
def map_range(x, X_min, X_max, Y_min, Y_max):
"""
Linear mapping between two ranges of values
"""
X_range = X_max - X_min
Y_range = Y_max - Y_min
XY_ratio = X_range / Y_range
y = ((x - X_min) / XY_ratio + Y_min) // 1
return int(y) |
def remove_duplicate_objects(objects):
"""
Checks for duplicates in array properties containing dictionary elements.
Args:
objects: `list`.
Returns:
Deduplicated `list`.
"""
for item in reversed(objects):
if objects.count(item) > 1:
objects.remove(item)
... |
def quantile(values, p):
"""
Returns the pth-percentile value
>>> quantile([2, 4, 6, 8], 0.25)
4
>>> quantile([3, 2, 6, 4, 8, 5, 7, 1, 9, 11, 10], 0.5)
6
>>> quantile([3, 2, 6, 4, 8, 5, 7, 1, 9, 11, 10], 0.55)
7
>>> quantile([3, 2, 6, 4, 8, 5, 7, 1, 9, 11, 10], 0.75)
9
"""
... |
def ip_to_decimal(ip_address):
"""
Convert an ip address string to decimal.
"""
ip_list = ip_address.split(".")
ip_decimal = (256**3 * int(ip_list[0]) +
256**2 * int(ip_list[1]) +
256**1 * int(ip_list[2]) +
256**0 * int(ip_list[3])... |
def PLR_analysis(PLR):
"""
Analysis PLR(Positive likelihood ratio) with interpretation table.
:param PLR: positive likelihood ratio
:type PLR : float
:return: interpretation result as str
"""
try:
if PLR == "None":
return "None"
if PLR < 1:
return "N... |
def request_details(requests, command):
"""Return details for command in requests"""
for request in requests:
# Parse record format of "requestId|command|timestamp|target"
record = request.split("|")
if record[1] == command:
return {
"requestId": record[0],
... |
def flatten(x):
"""Flattens a nested list or tuple
Args:
x (list or tuple): nested list or tuple of lists or tuples to flatten
Returns:
x (list): flattened input
"""
if isinstance(x, list) or isinstance(x, tuple):
return [a for i in x for a in flatten(i)]
else:
... |
def snake_to_camel(word):
"""
Convert a word from snake_case to CamelCase
"""
return ''.join(x.capitalize() or '_' for x in word.split('_')) |
def new_sample_dict(sample, item, object_type):
"""Make a dict of the inventory objects.
:param sample:
:type sample: Sample
:param item:
:type item: Item
:param object_type:
:type object_type: ObjectType
:return: dict of inventory objects
:rtype: dict
"""
return {
"... |
def generate_optimized_y_move_down_x_SOL(y_dist):
""" move down y_dist, set x=0 """
# Optimization to move N lines and go to SOL in one command. Note that some terminals
# may not support this so we might have to remove this optimization or make it optional
# if that winds up mattering for terminals we... |
def multiply_even_numbers(nums):
"""Multiply the even numbers.
>>> multiply_even_numbers([2, 3, 4, 5, 6])
48
>>> multiply_even_numbers([3, 4, 5])
4
If there are no even numbers, return 1.
>>> multiply_even_numbers([1, 3, 5])
1
"""
... |
def select_keys( src_dict, keys_lst ):
"""Returns a new dict containing the specified keys (& values) from src_dict."""
result = {}
for key in keys_lst:
result[ key ] = src_dict[ key ]
return result |
def T0_T0star(M, gamma):
"""Total temperature ratio for flow with heat addition (eq. 3.89)
:param <float> M: Initial Mach #
:param <float> gamma: Specific heat ratio
:return <float> Total temperature ratio T0/T0star
"""
t1 = (gamma + 1) * M ** 2
t2 = (1.0 + gamma * M ** 2) ** 2
t3 = 2... |
def bool_to_yes_no(value, color_enabled=False, color_no=None, color_yes=None):
"""Convert a boolean (or ``None``) to a yes/no string.
:param value: The value to be converted.
:type value: bool
:param color_enabled: Whether to enable color callbacks. Useful for controlling color at run time.
:type ... |
def phony(params: dict) -> str:
"""
Build phony rules according to 42 rules
"""
phony = "all re clean fclean norm bonus"
if params["library_libft"]:
phony += " libft"
if params["library_mlx"] and params["compile_mlx"]:
phony += " minilibx"
return phony |
def build_license_url(license_code, version, jurisdiction_code, language_code):
"""
Return a URL to view the license specified by the inputs. Jurisdiction
and language are optional.
"""
# UGH. Is there any way we could do this with a simple url 'reverse'? The URL regex would
# be complicated, bu... |
def find_field(field_id, typeform_survey):
""" look up field_id in survey """
survey = typeform_survey
fields = [ field for field in survey.get('fields') if field.get('id') == field_id ]
field = None
if len(fields) == 1:
return fields[0]
# check if field is part of a group?
group_fi... |
def _get_name_fi(name, fi_index):
"""
Generate variable name taking into account fidelity level.
Parameters
----------
name : str
base name
fi_index : int
fidelity level
Returns
-------
str
variable name
"""
if fi_index > 0:
return "%s_fi%d" ... |
def create_request(cmd, **kwargs):
"""Creates a properly formatted request dictionary
Args:
cmd (str): command name
**kwargs (dict, optional): keyword arguments to specify for command
Returns:
dict: request formatted dictionary containing parameters
"""
req = {"name": cmd}
... |
def generate_theoretical_msd_normal(n_list, D, dt, dim):
"""
Function for generating msd of normal diffusion
:param n_list: number of points in msd
:param D: float, diffusion coefficient
:param dt: float, time between steps
:param dim: int, dimension (1,2,3)
:return: array of theoretical msd... |
def link_titles(soup):
"""Return list of titles of links to other pages."""
if soup is None:
return []
links = []
for link in soup.find_all('a'):
href = link.get('href')
if href and href.startswith('/wiki'):
links.append(link.get('title'))
return links |
def sort_fields(fields):
"""Sort fields by column_number but put together parents and children.
"""
fathers = [(key, val) for key, val in
sorted(list(fields.items()),
key=lambda k: k[1]['column_number'])
if not 'auto_generated' in val]
children = [(ke... |
def unsort(arr, idx):
"""unsort a list given idx: a list of each element's 'origin' index pre-sorting
"""
unsorted_arr = arr[:]
for i, origin in enumerate(idx):
unsorted_arr[origin] = arr[i]
return unsorted_arr |
def wrap(x, dim):
""" Wrap the boarder of the range image.
"""
value = x
if value >= dim:
value = (value - dim)
if value < 0:
value = (value + dim)
return value |
def determine_parllelism(num_tiles):
"""
Try to stay at a maximum of 140 tiles per partition; But don't go over 128 partitions.
Also, don't go below the default of 8
"""
num_partitions = max(min(num_tiles / 140, 128), 8)
return num_partitions |
def midpoint_two_points(point_one, point_two):
"""
Old function to support circular paths
"""
return (point_one[0]+point_two[0])/2, (point_one[1]+point_two[1])/2, (point_one[2]+point_two[2])/2 |
def fixed_annealer(gamma, step, iteration_threshold):
"""No annealing."""
del step, iteration_threshold
return gamma |
def validateLabel(value):
"""Validate descriptive label.
"""
if 0 == len(value):
raise ValueError("Descriptive label for material not specified.")
return value |
def crcJK232(byteData):
"""
Generate JK RS232 / RS485 CRC
- 2 bytes, the verification field is "command code + length byte + data segment content",
the verification method is thesum of the above fields and then the inverse plus 1, the high bit is in the front and the low bit is in the back.
"""
... |
def flatten_results(results, comparison_records, print_warning=False):
"""Flattens and extract a deep structure of results based on a list of
comparisons desired."""
# process the request comparisons into chunks
comparisons = [x.split('.') for x in comparison_records]
# store a nested tree structu... |
def remove_column_headers(player_data_list):
"""Remove column headers.
Args:
player_data_list: player data list
Returns:
player data list without column headers
"""
return player_data_list[1:] |
def euclidean_gcd(first, second):
"""
Calculates GCD of two numbers using Euclidean Iterative Algorithm
:param first: First number
:param second: Second number
:return: GCD of the numbers
"""
while second != 0: # Iterate till second becomes zero
temp = second # Temporary v... |
def create_mail_title(span, condition):
"""time to messages
Args:
span (int): cache check span
condition (str): server condition
Returns:
title (string): time and conditions to mail title
"""
span_hour = str(int(span / 3600))
return condition + " " + span_hour + "h" |
def check_categories(categories_str, category_list):
"""
Check if at least one entry in category_list is in the category string
:param categories_str: Comma-separated list of categories
:param category_list: List of categories to match
:return:
"""
req = False
if isinstance(categories_st... |
def _level_db_prefix(lang: str) -> bytes:
"""
Helper method to get the name of the prefix db of the current model.
:param lang: The language belonging to the current model.
:return: The name of the prefix db of the current model.
"""
return f'{lang}-'.encode() |
def convert_seconds_to_hours_mins_secs(seconds_in):
"""Converts seconds to HH:MM:SS format."""
temp_seconds = int(seconds_in)
seconds = temp_seconds % 60
minutes = temp_seconds / 60
hours = minutes / 60
minutes = minutes % 60
out_str = "{:0>2d}:{:0>2d}:{:0>2d}".format(int(hours), int(minutes... |
def rmax(a, e):
"""Max radius of ellipitical orbit."""
return a*(1+e) |
def _find_literal(s, start, level, parts, exprs):
"""Roughly Python/ast.c:fstring_find_literal"""
i = start
parse_expr = True
while i < len(s):
ch = s[i]
if ch in ('{', '}'):
if level == 0:
if i + 1 < len(s) and s[i + 1] == ch:
i += 2
... |
def parse_metadata(raw_metadata):
"""
Parse relevant metadata into a tabular format
:param raw_metadata: dict, raw metadata as returned by
Socrata.get_metadata()
:return: pd.DataFrame, queried metadata
"""
parsed_metadata = {
'field_name': [... |
def unquote(s):
"""Remove any enclosing quotes for S."""
if isinstance(s, str) and len(s) > 1:
if s[0] in ('"', "'") and s[-1] == s[0]:
q = s[0]
if len(s) >= 6 and s[0:3].count(q) == 3 and s[-3:].count(q) == 3:
count = 3
else:
count = 1... |
def get_values(iterables, key_to_find):
"""Get values for the child list."""
return list(filter(lambda z: key_to_find in z, iterables)) |
def forward_diff_x(sigma, x, y, dt):
"""
Update equation for coordinate :math:`x`:
:math:`x[n+1] = \\sigma(y[n]-x[n])t_{\\delta} + x[n]`
INPUT::
sigma : float
Prandtl number
x : float
Current value of coordinate x (x[n]).
y : float... |
def last_month_was(year, month):
"""
Short function to get the previous month given a particular month of interest
:param year: year of interest
:param month: month of interest
:type year: integer
:type month: integer
"""
last_year = year
last_month = month - 1
if last_month... |
def _convert_type_to_regex(argtype: type) -> str:
"""
Source of truth for getting regex strings to match different types
"""
regex_patterns = {int: r'\b[\+-]?(?<![\.\d])\d+(?!\.\d)\b',
float: r'[-\+]?(?:\d+(?<!\.)\.?(?!\.)\d*|\.?\d+)(?:[eE][-\+]?\d+)?',
str: r... |
def generate_modal(title, callback_id, blocks):
"""
Generate a modal view object using Slack's BlockKit
:param title: Title to display at the top of the modal view
:param callback_id: Identifier used to help determine the type of modal view in future responses
:param blocks: Blocks to add to the mo... |
def get_ver_component(ver_list, idx):
"""Get version component from components list.
Return 0 for components out of range as default.
"""
if idx < len(ver_list):
return ver_list[idx]
return 0 |
def metadataDecode(data):
"""Decode metadata"""
metadata = {}
p = 0
while p < (len(data)-3):
metaid = data[p:p+3]
p+=3
metalen = data[p]
metabb = data[p+1:p+1+metalen]
p = p + 1 + metalen
if metaid == b'FNM':
metadata["filename"] = metabb.d... |
def contains(text, pattern):
"""Return a boolean indicating whether pattern occurs in text."""
assert isinstance(text, str), 'text is not a string: {}'.format(text)
assert isinstance(pattern, str), 'pattern is not a string: {}'.format(text)
#funny storytime! initially did not pass because I falsely reme... |
def stride_size(image_len, crop_num, crop_size):
"""return stride size
Args :
image_len(int) : length of one size of image (width or height)
crop_num(int) : number of crop in certain direction
crop_size(int) : size of crop
Return :
stride_size(int) : stride size
"""
r... |
def coding_problem_26(not_a_linked_list, k):
"""
Given a singly linked list and an integer k, remove the kth last element from the list. k is guaranteed to be
smaller than the length of the list. The list is very long, so making more than one pass is prohibitively expensive.
Do this in constant space an... |
def invertDictMapping(d):
"""
Function for/to <short description of `netpyne.analysis.utils.invertDictMapping`>
Parameters
----------
d : <type>
<Short description of d>
**Default:** *required*
"""
inv_map = {}
for k, v in d.items():
inv_map[v] = inv_map.get(v, [])
... |
def _function_wrapper(args_tuple):
"""Function wrapper to call from multiprocessing."""
function, args = args_tuple
return function(*args) |
def generateParenthesis(n):
"""
:type n: int
:rtype: List[str]
"""
results = []
def helper(results, string, leftCount, rightCount):
#If we've reached the base case where no more brackets can be added, append the current string to our array
if not l... |
def _compute_nm_conf_filename(mac):
"""
Compute a filename from a mac address
- capitalized it
- replace ':' by '_'
- add .conf at the end
"""
return "%s.conf" % mac.replace(':', '_').upper() |
def remove_iam_binding(policy, member, role):
"""Removes binding from given policy.
Args:
policy: Policy.
member: Account, e.g. user:joe@doe.com, serviceAccount:..., etc.
role: Role
Returns:
True if binding was removed. False, if binding was not present in policy.
"""
# Check if member is al... |
def add_review(status):
"""
Adds the flags on the tracker document.
Input: tracker document.
Output: sum of the switches.
"""
cluster = status['cluster_switch']
classify = status['classify_switch']
replace = status['replace_switch']
final = status['final_switch']
finished = statu... |
def sparse_poly_to_str(degrees, coeffs, poly_var="x"):
"""
Convert list of polynomial degrees and coefficients into polynomial string representation.
Parameters
----------
degrees : array_like
List of degrees.
coeffs : array_like
List of coefficients.
poly_var : str, optiona... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.