content stringlengths 42 6.51k |
|---|
def mu_parameter_mapping(mu,scale_with_mu,**kwargs):
"""Parameters that are 'replaced' by mu should be fixed to
some nominal values using functools.partial, as should
the list 'scale_with_mu'"""
out_pars = {}
for parname, parval in kwargs.items():
if parname in scale_with_mu:
... |
def verify_user_prediction(user_inputs_dic: dict, correct_definition_dic: dict):
"""
Verifies user prediction json against correct json definition
returns true if correct format, false if not
"""
if user_inputs_dic.keys() != correct_definition_dic.keys():
return False
for user_key, use... |
def html_popup(title, comment, imgpath, data):
"""Format the image data into html.
:params title, comment, imgpath, data: strings"""
html = """
<h3>TITLE</h3>
<img
src = IMGPATH
style="width:180px;height:128px;"
>
<p>
"COMMENT"
</p>
<p>
DATA
</p>
... |
def convertVCFPhaseset(vcfPhaseset):
"""
Parses the VCF phaseset string
"""
if vcfPhaseset is not None and vcfPhaseset != ".":
phaseset = vcfPhaseset
else:
phaseset = "*"
return phaseset |
def _get_xls_cc_ir_generated_files(args):
"""Returns a list of filenames generated by the 'xls_cc_ir' rule found in 'args'.
Args:
args: A dictionary of arguments.
Returns:
Returns a list of files generated by the 'xls_cc_ir' rule found in 'args'.
"""
return [args.get("ir_file")] |
def income_tax(is_single, income):
"""
Returns a floating point for estimated income tax
:param is_single: boolean that describes filing status
:param income: total income in USD
:type is_single: bool
:type income: int
:return: estimated income tax
:rtype: float
"""
if is_single:... |
def remove_whitespace(string):
"""
Parse a string and remove all its whitespace
Parameters
string
Returns string without whitespaces
"""
return string.replace(" ", "") |
def define_mlp(n_classes, n_hidden, dropout_p, activation="relu", l1_reg=0, l2_reg=0):
"""Shortcut to create a multi-layer perceptron classifier
Parameters
----------
n_classes : int
Number of classes to calculate probabilities for
n_hidden : list of ints
Number of units in each hid... |
def _is_new_kegg_rec_group(prev, curr):
"""Check for irregular record group terminators"""
return curr[0].isupper() and not prev.endswith(';') and \
not curr.startswith('CoA biosynthesis') and not prev.endswith(' and') and \
not prev.endswith('-') and not prev.endswith(' in') and not \
... |
def _remove_empty_values(dictionary):
""" Remove None values from a dictionary. """
return {k: v for k, v in dictionary.items() if v is not None} |
def gcd(a, b):
"""Return the greatest common divisor of a and b.
>>> gcd(2, 10)
2
>>> gcd(6, 9)
3
>>> gcd(5, 22)
1
"""
if a % b == 0:
return b
return gcd(b, a % b) |
def ball_touch_intent(event_list, team):
"""Returns intentnional or unintentional if the event is a ball touch"""
intent = None
for e in event_list[:1]:
if e.type_id == 61 and e.outcome == 1 and e.team != team:
intent = "Oppo. Intentional Ball Touch"
elif e.type_id == 61 and e.outcome == 0 and e.team != team... |
def mul(a,b):
"""Multiply a vector either elementwise with another vector, or with a
scalar."""
if hasattr(b,'__iter__'):
if len(a)!=len(b):
raise RuntimeError('Vector dimensions not equal')
return [ai*bi for ai,bi in zip(a,b)]
else:
return [ai*b for ai in a] |
def circle(x, a = 1.0, b = 1.0, r = 1.0):
"""
Name: Generic circle.
"""
return (x[0] - a)**2 + (x[1] - b)**2 - r**2 |
def head_tail(iterable):
""" For python2 compatibility """
lst = list(iterable)
return lst[0], lst[1:] |
def ngrams(s, r, pad=False):
"""
Takes a list as input and returns all n-grams up to a certain range.
:param s: input list
:param r: range
:param pad: whether to return ngrams containing a "PAD" token
:return: dicttionary {id: ngram}
"""
# add padding
S = s + ["<PAD>"] * (r - 1)
... |
def filter_form_fields(prefix, form_data):
"""Creates a list of values from a dictionary where
keys start with prefix. Mainly used for gathering lists
from form data.
e.g. If a role form's permissions fields are prefixed
with "role-permission-<index>" passing in a prefix
if... |
def find_ignorespace(text, string):
"""Return (start, end) for string in start of text, ignoring space."""
ti, si = 0, 0
while ti < len(text) and si < len(string):
if text[ti] == string[si]:
ti += 1
si += 1
elif text[ti].isspace():
ti += 1
elif str... |
def parse_message(error_msg):
"""This function parses error messages when necessary to prepare them for translation.
:param error_msg: The original error message
:type error_msg: str
:returns: The prepared error message
"""
split_sequences = ['\n', '\r']
for sequence in split_sequences:
... |
def confidence_interval_for_regression_line(yhat, error):
"""
Get the confidence interval for the predicted value of outcome.
> `yhat`: the predicted value of y
> `error`: the standard error of estimate
Returns
-------
The confidence interval for the predicted value yhat.
"""
low = yhat - error
... |
def parseArnsString(arnsString=None):
"""
This function returns a list of arns from the
comma-separated arnsString string. If the string is empty
or None, an empty list is returned.
"""
if arnsString is None or arnsString is '':
return []
else:
return arnsString.split(',') |
def get_sym(pair):
"""
reformats a tuple of (team, rival) so that the first element is smaller than the other
(by convention, this is how we represent a match without home-away status).
"""
if pair[0] > pair[1]:
return pair[1], pair[0]
else:
return pair |
def remove_punctuation(s):
"""
Returns a string with all punctuation removed from input
:param s: Any string
:return: A string with no punctuation
"""
# modified from http://www.ict.ru.ac.za/Resources/cspw/thinkcspy3/thinkcspy3_latest/strings.html
punctuation = "!\"#$%&'()*+,-./:;<=>?@[\\]... |
def count_words(fl):
"""Reads a file-like and returns the word count.
"""
words = []
count = {}
for row in fl:
for word in row.rstrip().split():
word = word.lower()
if word not in count:
count[word] = 0
words.append(word)
... |
def make_label_index(link_display_label, entries):
"""Map entry IDs to human-readable labels.
:arg link_display_label: Marker, which contains the label.
:arg entries: Collection of entries.
"""
return {
entry.id: entry.get(link_display_label, entry.id)
for entry in entries} |
def dist(x, y):
""" Pure python implementation of euclidean distance formula. """
dist = 0.0
for i in range(len(x)):
dist += (x[i] - y[i])**2
return dist**0.5 |
def grid_traveler_rec(m: int, n: int) -> int:
"""Computes the number of ways of traveling from source to destination.
Args:
m: The total vertical distance.
n: The total horizontal distance.
Returns:
The number of ways ways you can travel to the goal on a grid
with dimension... |
def greatest(numbers: list) -> int:
"""
A function that calculate the largest number within the given list parameter
Parameters:
-----------
numbers: list
Returns:
--------
int
"""
largest_num = 0
# Edit this function so that it return the larg... |
def get_clustering_level(clustering):
"""
Returns the numbers of levels in the clustering.
Intended to be used as an upper bound for 1-based `max_level` in clustering preprocessing.
"""
levels = []
for el in clustering:
if isinstance(el, dict):
levels.append(get_clustering_le... |
def shortstr(obj, maxl=20) -> str:
"""Convert an object to string and truncate to a maximum length"""
s = str(obj)
return (s[:maxl] + "...") if len(s) > maxl else s |
def human_readable_stat(c):
"""
Transform a timedelta expressed in seconds into a human readable string
Parameters
----------
c
Timedelta expressed in seconds
Returns
----------
string
Human readable string
"""
c = int(float(c))
years = c // 31104000
mon... |
def get_default_bbbp_task_names():
"""Get that default bbbp task names and return the binary labels"""
return ['p_np'] |
def value_in_many_any(a, b):
"""return true if item 'a' is found
inside 'b': a list/tuple of many iterators
else return false
"""
for c in b:
if a in c:
return True
return False |
def _positive(index: int, size: int) -> int:
"""Convert a negative index to a non-negative integer.
The index is interpreted relative to the position after the last item. If
the index is smaller than ``-size``, IndexError is raised.
"""
assert index < 0 # noqa: S101
index += size
if index... |
def script_language(_path):
"""Returns the language a file is written in."""
if _path.endswith(".py"):
return "python"
elif _path.endswith(".js"):
return "node"
elif _path.endswith(".go"):
return "go run"
elif _path.endswith(".rb"):
return "ruby"
elif _path.endswith(".j... |
def fluid(x):
"""Function 3"""
rho_f = 0.890
rho_o = 0.120
r = 5
return (((rho_f / 3) * x**3) - (r * rho_f * x**2) + ((4 * r**3 * rho_o) / 3)) |
def init_list_args(*args):
"""Initialize default arguments with empty lists if necessary."""
return tuple([] if a is None else a for a in args) |
def is_range(parser, arg):
"""
Check if argument is min/max pair.
"""
if arg is not None and len(arg) != 2:
parser.error('Argument must be min/max pair.')
elif arg is not None and float(arg[0]) > float(arg[1]):
parser.error('Argument min must be lower than max.')
return arg |
def user_prompt(msg: str, sound: bool = False, timeout: int = -1):
"""Open user prompt."""
return f'B;UserPrompt("{msg}",{sound:d},{timeout});'.encode() |
def derive_mid(angle_start, angle_stop, norm):
"""Derive mid angle respectng closure via norm."""
angle = (angle_stop + angle_start) / 2.0
if angle_stop < angle_start:
angle = (angle_stop + norm + angle_start) / 2.0
return angle |
def prod(m, p):
""" Computes the product of matrix m and vector p """
return (p[0]*m[0] + p[1]*m[1], p[0]*m[2] + p[1]*m[3]) |
def stripfile(filedata, listofterms):
"""
Creates a list with lines starting with strings from a list
:param filedata: File Data in list form
:param listofterms: list of strings to use as search terms
:return: list of file lines starting with strings from list of terms
"""
datawithterms = []... |
def jsonify(records):
"""
Parse asyncpg record response into JSON format
"""
# print(records)
list_return = []
for r in records:
itens = r.items()
list_return.append({i[0]: i[1].rstrip() if type(
i[1]) == str else i[1] for i in itens})
return list_return |
def make_mt_exchange_name(namespace, endpoint):
"""
Method which generate MT name which based on MT namespace
and endpoint name. Better see MT documentation for known details
:param namespace: MT namespace
:param endpoint: MT endpoint name
:return: RabbitMQ exchange name needed for pika as stri... |
def valid_str(x: str) -> bool:
"""
Return ``True`` if ``x`` is a non-blank string;
otherwise return ``False``.
"""
if isinstance(x, str) and x.strip():
return True
else:
return False |
def vsbyValue(value):
"""Method to return a simple scalar as a string. Value from grid is multiplied by 100.0"""
try:
return str(int(round(value*100.)))
except:
return "999" |
def get_label(cplt):
"""
get cplt and return a label
Parameters
----------
cplt : str
name of the dimension of interest
Returns
-------
label : str
axis label
Examples
--------
None yet
"""
label = cplt
if cplt == 'T':
label += ' (K)'
... |
def remove_unknown(sentences, unknown_idx=1):
"""
remove sentences with unknown word in them
:param sentences: a list containing the orig sentences in formant of: [index, sentence indices as list]
:param unknown_idx: the index number of unknown word
:return: a new list of the filtered sentences... |
def print_scientific_double(value: float) -> str:
"""
Prints a value in 16-character scientific double precision.
Scientific Notation: 5.0E+1
Double Precision Scientific Notation: 5.0D+1
"""
if value < 0:
Format = "%16.9e"
else:
Format = "%16.10e"
sva... |
def get_data_length(data):
"""Gets the number of entries in the data from the result of a pushshift
api call.
Args:
data (dict): JSON object that is returned from the pushshift api.
Returns:
int: Length of the data.
"""
return len(data["data"]) |
def parse_line_2(bitmap):
"""converts 2 bytes into 1 byte. Used in 16-color modes"""
ba = bytearray()
for i in range(len(bitmap) // 2):
hi = bitmap[i * 2 + 0] & 0xf
lo = bitmap[i * 2 + 1] & 0xf
byte = hi << 4 | lo
ba.append(byte)
return ba |
def address_list2address_set(address_list):
"""
Helper function for parsing and converting address list to addres set
"""
address_set = set()
for address in address_list:
address = address.split("/")[2]
address_set.add(address)
return address_set |
def determinant(m):
"""Compute determinant."""
return (
m[0][0] * m[1][1] * m[2][2]
- m[0][0] * m[1][2] * m[2][1]
+ m[0][1] * m[1][2] * m[2][0]
- m[0][1] * m[1][0] * m[2][2]
+ m[0][2] * m[1][0] * m[2][1]
- m[0][2] * m[1][1] * m[2][0]
) |
def find_target_container(container_wrapper, container_name):
"""Search through a collection of containers and return the container
with the given name
:param container_wrapper: A collection of containers in the Google Tag Manager
List Response format
:type container_wrapp... |
def write_header(heading, level=1):
"""
- heading: string, the heading
- level: integer, level > 0, the markdown level
RETURN: string
"""
return ("#"*level) + " " + heading + "\n\n" |
def pathcombine(path1, path2):
"""
Note: This is copied from:
https://code.google.com/p/pyfilesystem/source/browse/trunk/fs/path.py
Joins two paths together.
This is faster than `pathjoin`, but only works when the second path is relative,
and there are no backreferences in either path.
>>... |
def get_pypi_urls(name, version):
"""
Return a mapping of computed Pypi URLs for this package
"""
api_data_url = None
if name and version:
api_data_url = f'https://pypi.org/pypi/{name}/{version}/json'
else:
api_data_url = name and f'https://pypi.org/pypi/{name}/json'
reposit... |
def is_none_or_int(obj):
"""Check if obj is None or an integer.
:param obj: Object to check.
:type obj: object
:return: True if object is None or an integer.
:rtype: bool
"""
return obj is None or (isinstance(obj, int) and obj >= 0) |
def _get_base_step(name: str):
"""Base image step for running bash commands.
Return a busybox base step for running bash commands.
Args:
name {str}: step name
Returns:
Dict[Text, Any]
"""
return {
'image': 'busybox',
'name': name,
'script': '#!/bin/sh\n... |
def frange(start, end, step, rnd = 5):
"""Generate a range with float values"""
result = []
# invert step and change start/end when positions are inverted
if start > end:
return(frange(end, start, step*-1))
if step > 0:
point = start
while point <= end:
result.a... |
def str2bool(s2b):
"""
Converts String to boolean
params:
s2b - a string parameter to be converted to boolean
Possible inputs:
True: true, t, yes, y, 1
False: false, f, no, n, 0
Note: Possible inputs are not case sensitive.
returns: True or False
"""
... |
def values_match(x, y):
""" Compare x and y. This needed because the types are unpredictable and sometimes
a ValueError is thrown when trying to compare.
"""
if x is y:
return True
# explicit checks for None used to prevent warnings like:
# FutureWarning: comparison to `None` will resul... |
def getCachedValue(cache, bits, generator):
""" Return and cache large (prime) numbers of specified number of bits """
if bits not in cache:
# populate with 2 numbers
cache[bits] = [generator(bits) for _ in range(2)]
# rotate, so each call will return a different number
a = cache[bits]
... |
def format_money(amnt, precision=2):
"""
Format output for money values
Finac doesn't use system locale, in the interactive mode all numbers are
formatted with this function. Override it to set the number format you wish
"""
# return '{:,.2f}'.format(amnt)
return ('{:,.' + str(precision) + ... |
def clean_record(raw_string: str) -> str:
"""
Removes all unnecessary signs from a raw_string and returns it
:param raw_string: folder or file name to manage
:return: clean value
"""
for sign in ("'", '(', ')', '"'):
raw_string = raw_string.replace(sign, '')
return raw_string.replace... |
def edit_diff(start, goal, limit):
"""A diff function that computes the edit distance from START to GOAL."""
if start == goal:
return 0
if limit == 0: #stop when reach the limit!
return 1
if not start:
return len(goal)
elif not goal:
return len(start)
elif start[0... |
def fmt(nbytes):
"""Format network byte amounts."""
nbytes = int(nbytes)
if nbytes >= 1000000:
nbytes /= 1000000
return f"{nbytes:.1f}MB"
if nbytes > 1000:
nbytes /= 1000
return f"{nbytes:.1f}kB"
return f"{nbytes}B" |
def raise_error(func, args , kwargs):
"""
This decorator help you to wrap any function to catch any error raised in the function body
## Snippet code
```python
>>> from easy_deco import raise_error
>>> @raise_error
>>> def func():
"Function body"
```
"""
try:
... |
def list_file_by_day(ws,day_list,row_index,patient_detail_row_index,day_number=0):
"""
Input all recorded file in the given day to the work sheet
:param ws: The patient list sheet
:param day_list: list of days having the recorded data
:param row_index: The current row of the cusor in the patient sum... |
def get_image_url_from_soup(soup):
"""
"""
try:
image_url = soup.find(id='comic').img['src']
except:
image_url = None
return image_url |
def remove_empty_entities(d):
"""
Recursively remove empty lists, empty dicts, or None elements from a dictionary.
Note. This is extended feature of CommonServerPython.py remove_empty_elements() method as it was not removing
empty character x == ''.
:param d: Input dictionary.
:return: Dictiona... |
def _symbol_count_from_symbols(symbols):
"""Reduce list of chemical symbols into compact VASP notation
args:
symbols (iterable of str)
returns:
list of pairs [(el1, c1), (el2, c2), ...]
"""
sc = []
psym = symbols[0]
count = 0
for sym in symbols:
if sym != psym:
... |
def lag_entry_table(lag_name):
"""
:param lag_name: given lag to cast.
:return: LAG_TABLE key.
"""
return b'LAG_TABLE:' + lag_name |
def convert_word_index_to_sentence(word_idx, vocab):
"""Convert word indices to sentence."""
s = ""
for ind in range(len(word_idx)):
w_idx = word_idx[ind]
if w_idx> 0:
s += vocab[w_idx-1]
if ind < len(word_idx)-1:
s+= " "
return s |
def str2hex(s):
"""
:param s: '303132'
:return: '123'
"""
return ''.join([chr(c) for c in bytearray.fromhex(s)]) |
def say_hello(subject:str) -> str:
"""Say hello to somebody.
Args:
subject: who to say hello to.
Returns:
A friendly greeting as a string.
"""
return f"Hello {subject}!" |
def sqrt(n):
"""http://stackoverflow.com/questions/15390807/integer-square-root-in-python
Find the square root of a number for the purpose of determining whether or not
it is a whole number."""
x = n
y = (x + 1) // 2
while y < x:
x = y
y = (x + n // x) // 2
return x |
def auto_int(int_arg):
"""Automatically format integer."""
return int(int_arg, 0) |
def _gen_alignment_table(sequence_left: str, sequence_right: str, scoring_matrix: dict, gap_penalty, floor=None, sub_constant_cost=-7, **kwargs):
"""
Common code to generate alignment table given a matrix
:param sequence_left:
:param sequence_right:
:param scoring_matrix:
:param gap_penalty:
... |
def epoch_to_timestamp(time_raw):
"""converts raw time (days since year 0) to unix timestamp
"""
offset = 719529 # offset between 1970-1-1 und 0000-1-1
time = (time_raw - offset) * 86400
return time |
def MAP(P, Y, metric=None):
"""
Sort solutions according to the MAP decision rule.
:param P: probabilities
:param Y: support
:return: sorted list of triplets (loss, probability, solution)
"""
return [1 - p for p in P] |
def analyse_sample_attributes(sample):
""" To find sample attributes
Attributes:
min_position_value - [index, value]
max_position_value - [index, value]
up_or_down - up
- down
- variates
"""
attributes = {
"min_position_value": [... |
def angryProfessor(k, a):
"""
Given the arrival time of each student and a threshold number of attendees, determine if the class is canceled.
:param k: int threshold for minimum on time student
:param a: array of arrival time of students
:return: Class cancel
"""
count = 0
# counting st... |
def _make_divisible(
v,
divisor,
min_value=None,
):
"""
This function is taken from the original tf repo.
It ensures that all layers have a channel number that is divisible by 8
It can be seen here:
https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.p... |
def encode_sequence(sequence: str, encoding_scheme: dict):
"""
Encodes a peptide sequence with values provided by the encoding table/scheme.
"""
encoded_sequence = []
for aa in sequence:
try:
value = encoding_scheme.get(aa)
except Exception as e:
msg = f'{e}'
... |
def _unbool(element, true=object(), false=object()):
"""A hack to make True and 1 and False and 0 unique for _uniq."""
if element is True:
return true
elif element is False:
return false
return element |
def make_bits(num, bits):
"""Constructs a bit string of length=bits for an integer num."""
assert num < (1 << bits)
if bits == 0:
return ''
return '{num:0{bits}b}'.format(num=num, bits=bits) |
def flatten(items):
"""Removes one level of nesting from items
Parameters
----------
items : iterable
list of items to flatten one level
Returns
-------
flattened_items : list
list of flattened items, items can be any sequence, but flatten always
returns a list.
... |
def clean_string(s):
"""
Get a string into a canonical form - no whitespace at either end,
no newlines, no double-spaces.
"""
s = s.strip().replace("\n", " ").replace(" ", " ")
while " " in s:
# If there were longer strings of spaces, need to iterate to replace...
# I guess.
... |
def count_ways(n):
"""
Parameters
----------
n : Dimension of chessboard (n x n)
Returns
----------
The number of ways to place n queens on the chessboard,
such that no pair of queens attack each other
"""
def backtrack(i, c, l, r):
if not i:
... |
def partial_match(first, second, places):
"""
Returns whether `second` is a marginal outcome at `places` of `first`.
Parameters
----------
first : iterable
The un-marginalized outcome.
second : iterable
The smaller, marginalized outcome.
places : list
The locations o... |
def merge_dicts(create_dict, iterable):
"""
Merges multiple dictionaries, which are created by the output of a function and
an iterable. The function is applied to the values of the iterable, that creates dictionaries
:param create_dict: function, that given a parameter, outputs a dictionary.
:param... |
def _DegreeDict(tris):
"""Return a dictionary mapping vertices in tris to the number of triangles
that they are touch."""
ans = dict()
for t in tris:
for v in t:
if v in ans:
ans[v] = ans[v] + 1
else:
ans[v] = 1
return ans |
def rgb_int2pct(rgbArr):
"""
converts RGB 255 values to a 0 to 1 scale
(255,255,255) --> (1,1,1)
"""
out = []
for rgb in rgbArr:
out.append((rgb[0]/255.0, rgb[1]/255.0, rgb[2]/255.0))
return out |
def extract_Heff_params(params, delta):
"""
Processes the VUMPS params into those specific to the
effective Hamiltonian eigensolver.
"""
keys = ["Heff_tol", "Heff_ncv", "Heff_neigs"]
Heff_params = {k: params[k] for k in keys}
if params["adaptive_Heff_tol"]:
Heff_params["Heff_tol"] =... |
def parse_port_pin(name_str):
"""Parses a string and returns a (port-num, pin-num) tuple."""
if len(name_str) < 4:
raise ValueError("Expecting pin name to be at least 5 charcters.")
if name_str[0] != 'P':
raise ValueError("Expecting pin name to start with P")
if name_str[1] not in ('0', ... |
def AzimuthToCompassDirection(azimuth):
"""
Compass is divided into 16 segments, mapped to
N, NNE, NE, NEE, E, SEE, SE, SSE, S, SSW, SW, SWW, W, NWW, NW, and NNW.
IMPORTANT: input azimuth must be in radians, NOT degrees.
"""
compassDirection = ""
if azimuth >= 0 and azimuth <= 0.1963350785:
compassDirect... |
def check_number_in_box(data, rect_diag_0, rect_diag_1, counter=0):
"""
function to retrieve how many points are in a given rectangle
:param data: data to check
:param rect_diag_0: coordinates of one side of the diagonal
:param rect_diag_1: coordinates of the other side of the diagonal
:param co... |
def unescape_path(path: str) -> str:
"""
Decodes a percent-encoded URL path.
@raise ValueError:
If the escaping is incorrect.
"""
idx = 0
while True:
idx = path.find("%", idx)
if idx == -1:
return path
# Percent escaping can be used for UTF-8 paths.
... |
def get_roi(shift, dim, gap=(0, 0, 0, 0)):
"""
find the over-lappying region of the image based on shift
top-left (0, 0), x(+) to the right, y(+) goes down
:param shift:
(shift_x, shift_y) positive integer
:param dim:
(w , h) positive integer
:param gap:
(left, right, t... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.