content stringlengths 42 6.51k |
|---|
def check_valid_password_2(minimum, maximum, letter, password):
"""PART TWO
Checks if a password is valid based on the criteria.
The min/max in this example are actually the indexes
(no index 0 here) of where the letter should occur.
Only one occurence of the letter is acceptable (an "a")
at bo... |
def parse_json(json_dict):
"""
@param json_dict: should have keys: plus_1, plus_2, output
@return: strings of plus_1, plus_2, output
"""
try:
return str(json_dict['plus_1']), str(json_dict['plus_2']), str(json_dict['output'])
except Exception:
raise KeyError('Error while paring: ... |
def celsius_to_fahrenheit(celsius: float) -> float:
"""Converts celsius to fahrenheit.
:param celsius: temperature in celsius.
:return: temperature in fahrenheit
"""
fahrenheit = celsius * 9 / 5 + 32
return fahrenheit |
def arg_preprocessing(arg_v):
"""Return the values of an argument after preprocessing"""
# check if arg is list and convert it to comma-separated string
if isinstance(arg_v, list):
arg_v = ','.join(arg_v)
# check if arg is boolean and convert it to string
elif isinstance(arg_v, bool)... |
def near_split(x, num_bins):
"""
Splits an integer number "x" into a list of "num_bins" bins while keeping the difference between values as small as possible.
E.g., for x = 50, num_bins = 3 the result will be [17, 17, 16]
A courtesy of https://stackoverflow.com/a/48918717
:param x: Integer number... |
def first_non_null(*args):
"""return the first non null value in the arguments supplied"""
for x in args:
if x != '':
return x
return '' |
def _get_column_index(i, inputs):
"""
Taken from https://github.com/onnx/sklearn-onnx/blob/9939c089a467676f4ffe9f3cb91098c4841f89d8/skl2onnx/common/utils.py#L50.
Returns a tuples (variable index, column index in that variable).
The function has two different behaviours, one when *i* (column index)
i... |
def make_weights_for_balanced_classes(images, nclasses):
"""
Function to obtain dataset dependent weights for the dataloader
:param images:
:param nclasses:
:return:
"""
count = [0] * nclasses
for item in images:
count[item] += 1
weight_per_class = [0.] * nclasses
N = flo... |
def transpose_pairs(tuple_list):
"""
For each tuple pair in the list, transpose. i.e. (a,b) => (b,a)
"""
a,b = [list(x) for x in zip(*tuple_list)]
return list(zip(b,a)) |
def flatten(lst):
"""Flattens a list of lists"""
return [subelem for elem in lst for subelem in elem] |
def formatDuration(context, totminutes):
""" Format a time period in a usable manner: eg. 3h24m
"""
mins = totminutes % 60
hours = (totminutes - mins) / 60
if mins:
mins_str = '%sm' % mins
else:
mins_str = ''
if hours:
hours_str = '%sh' % hours
else:
hou... |
def collect_vowels(s):
""" (str) -> str
Return the vowels (a, e, i, o, and u) from s.
>>> collect_vowels('Happy Anniversary!')
'aAiea'
>>> collect_vowels('xyz')
''
"""
vowels = ''
for char in s:
if char in 'aeiouAEIOU':
vowels = vowels + char
... |
def _title_to_snake(src_string):
"""Convert title case to snake_case."""
return src_string.lower().replace(" ", "_").replace("/", "-") |
def gamma_estimates_to_stable_partitions(gamma_estimates):
"""Computes the stable partitions (i.e. those whose gamma estimates are within their domains of optimality), given
domains of optimality and gamma estimates from :meth:`ranges_to_gamma_estimates`.
See **[CITATION FORTHCOMING]** for more details.
... |
def get_errors(response):
"""
Utility method to retrieve the list of errors (if any) from a
PayPal response.
"""
errors = response.get("error")
if errors:
return [e.get("message") for e in errors]
return None |
def split_chunks(bits, chunk_size):
"""Split the bitvector in groups of bits
:param bits: bitvector
:param chunk_size: number of bits per each chunk
"""
# pad to left with zero to match the chunk multiple bits
#bit_vector = '{{:0>{0}}}'.format(chunk_size).format('{:b}'.format(bits))
... |
def contains(list_1,list_2):
"""
Check if list_1 elements is in list_2
"""
boolean = True
for item in list_1:
if item not in list_2:
boolean = False
return boolean |
def index_fact(fact, index, negated=False):
"""
Returns a representation of 'fact' containing the step number and a
leading 'not-' if the fact is negated
"""
name = str(fact)
if negated:
name = 'not-' + name
return "%s-%d" % (name, index) |
def make_str(s):
"""Casts the input to string. If a string instance is Not given, Ikke gitt or None, return empty string."""
if s == 'Not given':
return ''
if s == 'Ikke gitt':
return ''
if s is None:
return ''
return str(s) |
def find_unit_clause(clauses, model):
"""Find a unit clause has only 1 variable that is not bound in the model.
Arguments are expected to be in integer representation.
>>> find_unit_clause([{1, 2, 3}, {2, -3}, {1, -2}], {1: True})
(2, False)
"""
bound = set(model) | {-sym for sym in model}
... |
def merge_dict_list(dict1, dict2):
"""
Merge two dictionaries and merge values of common keys to a list.
"""
dict3 = {**dict1, **dict2}
for key, value in dict3.items():
if key in dict1 and key in dict2:
dict3[key] = [value, dict1[key]]
return dict3 |
def gcd(a, b):
"""Greatest common divisor of a and b"""
return gcd(b, a % b) if b else a |
def sources_event(query_time_ms):
"""Format the properties of the ``sources`` event.
:param query_time_ms: duration of the query in milliseconds
:type query_time_ms: int
"""
return {
'query_time_ms': query_time_ms
} |
def make_grid(n_rows, n_cols, value):
"""Make a n_rows x n_cols grid filled with an initial value"""
return [[value for _ in range(n_cols)] for _ in range(n_rows)] |
def count_matches(list, item):
"""
Return the number of occurrences of the given item in the given
list.
"""
if list == ():
return 0
else:
head, tail = list
if head == item:
return 1 + count_matches(tail, item)
else:
return count_matches(ta... |
def euclid(a:int, b:int, Verbose=False):
"""Return the Greatest Common Divisor (GCD) of number a and b."""
# The GCD of two relative integers is equal to the GCD of their absolute values.
a, b=abs(a), abs(b)
# The largest of the two numbers is replaced by the remainder of the Euclidean div... |
def default_format(fmt=None):
"""Get or set the default ouptut format.
Include a fmt if and where you need to specify the output
precision. Defaults to %.*f, where the * stands for the
precision. Do nothing if fmt is None.
Returns: default format.
>>> print(mg(2, 'm2').sqrt())
1.4142 m
... |
def get_filedata_strings(data):
"""
Return a dictionary with comma-separated list of LFNs, guids, scopes, datasets, ddmendpoints, etc.
:param data: job [in|out]data (list of FileSpec objects).
:return: {'lfns': lfns, ..} (dictionary).
"""
lfns = ""
guids = ""
scopes = ""
datasets =... |
def lorentzian_1d(x, *p):
"""[summary]
Arguments:
x {[type]} -- [description]
Returns:
[type] -- [description]
"""
A, x0, sigma, C = p
x_shift = x - x0
return A * sigma**2 / (x_shift**2 + sigma**2) + C |
def average(*args):
"""
*args needs to be last positional parameters
:param args:
:return:
"""
print(type(args))
print("args is {}".format(args))
# *args is unpacked tuple
print("*args is ", *args)
mean = 0
for arg in args:
mean += arg
return mean / len(args) |
def get_attr_value(path, func, attrs):
"""Gets attribute value from 'attrs' by specified path
In case of nested list - list of found values will be returned
:param path: list of keys for accessing the attribute value
:param func: if not None - will be applied to the value
:param attrs: attributes ... |
def count_yes_in(answers: list) -> int:
"""Count distinctive 'yes' answers in group."""
return len(set("".join(answers))) |
def compile_optional_data(data):
"""Compile Optional input.
Args:
data (str): Input string from website.
Returns:
dict: An optional dict recording target parameters.
"""
optional_data=data.lower().replace(" ","").split(",")
return_dict={}
if len(optional_data) != 0... |
def net_in_sol_rad(sol_rad, albedo=0.23):
"""
Calculate net incoming solar (or shortwave) radiation from gross
incoming solar radiation, assuming a grass reference crop.
Net incoming solar radiation is the net shortwave radiation resulting
from the balance between incoming and reflected solar r... |
def get_rst_translation_text(rstfilename, english_spanish, text):
"""Given an rstfilename an a text returns the corresponding translated text if exists"""
for en, es in english_spanish:
if en.replace("!", "") == text.replace("!", ""):
return es |
def preprocess_dataset(input_dataset=None, pad_length=150):
"""
Pre-process the dataset.
Given a list of item names, prepend the <START> token,
then append the <END> token and <PAD> until the sequence
length is reached. The assumed length is 150 to fit the
short-form ... |
def parse_global_resource_mgr(global_resource_mgr):
"""! Parses --grm switch with global resource manager info
@details K64F:module_name:10.2.123.43:3334
@return tuple wity four elements from GRM or None if error
"""
try:
platform_name, module_name, ip_name, port_name = global_resource_mgr.s... |
def _ParseRepositoryHost(repository_name):
"""Parses a repository to an optional hostname and a list of path compoentes.
Args:
repository_name: (str) A name made up of slash-separated path name
components, optionally prefixed by a registry hostname.
Returns:
A (hostname, components) tuple represen... |
def parse_email(address):
"""
Returns "Marco Polo", "marco@polo.com" from "Marco Polo <marco@polo.com"
Returns "", "marco@polo.com" from "marco@polo.com"
"""
if ' ' in address.strip():
assert '<' in address and '>' in address, "Invalid address structure: %s" % (address,)
parts = addr... |
def sentence_tokenize(sentence, spec_chars='.,;!?'):
""" prepossess sentence, all as lower characters and remove special chars
:param str sentence:
:return [str]:
>>> s = 'Hi there, how are you?'
>>> sentence_tokenize(s)
['hi', 'there', 'how', 'are', 'you']
"""
for char in spec_chars:
... |
def delete_named_urlpattern(urlpatterns, name):
"""Delete the named urlpattern.
"""
found = False
ix = 0
while not found and ix < len(urlpatterns):
pattern = urlpatterns[ix]
if hasattr(pattern, 'url_patterns'):
found = delete_named_urlpattern(pattern.url_patterns, name)... |
def parse_int_token(token):
"""
Parses a string to convert it to an integer based on the format used:
:param token:
The string to convert to an integer.
:type token:
``str``
:return:
``int`` or raises ``ValueError`` exception.
Usage::
>>> parse_int_token("0x40"... |
def is_number(v):
"""Checks if a given variable is a number (int, float or complex).
Parameters
----------
v : int, float, complex
Variable to check.
"""
return (isinstance(v,int) or isinstance(v,float) or isinstance(v,complex)) |
def _remove_prefix(value: str, prefix: str) -> str:
"""Returns the value without the prefix.
Equivalent of str.removeprefix in python 3.9
"""
prefix_len = len(prefix)
if value[:prefix_len] == prefix:
return value[prefix_len:]
return value |
def generate_column_name(field_list: list) -> str:
"""
Description
-----------
Contatenate a list of column fields into a single column name.
Parameters
----------
field_list: list[str] of column names
Returns
-------
str: new column name
"""
return ''.join(sorted(fiel... |
def compareElements(s1, s2):
""" compare two particular elements """
# check if the matter is easy solvable:
if s1 == s2:
return 0
# try to compare as numeric values (but only if the first character is not 0):
if s1 and s2 and s1.isnumeric() and s2.isnumeric() and s1[0] != '0' and s2[0] != '... |
def _full_signature(kmer):
"""Generate a 2-letter alphabet signature of a full k-mer.
The transformations are A->G and C->T.
Args:
kmer: k-mer
Returns:
signature as a string
"""
return kmer.replace('A', 'G').replace('C', 'T') |
def profile_maker(profile, username, password):
"""
This method is similar to switch statement. It will render the dict with the given data and
returns the matched profile name
:param profile: Name of the profile to return.
:param username: Username to authenticate OpenStack.
:param passwo... |
def split_node_lists(num_jobs, total_node_list=None, ppn=24):
"""
Parse node list and processor list from nodefile contents
:param num_jobs: (int) number of sub jobs
:param total_node_list: (list of str) the node list of the whole large job
:param ppn: (int) number of procesors per node
:return... |
def is_by_step(raw):
"""If the password is alphabet step by step."""
# make sure it is unicode
delta = ord(raw[1]) - ord(raw[0])
for i in range(2, len(raw)):
if ord(raw[i]) - ord(raw[i-1]) != delta:
return False
return True |
def setDefaultLevel(level):
"""Set global default log level
:param level: Numeric log level
:type level: int
:return: value stored in global defaultLevel, useful for confirming value was actually stored
:rtype: int
"""
global _myDefaultLevel
if not isinstance(level,int):
... |
def object_properties(data):
"""Transform an Alvao object's properties into a dictionary."""
properties = {p['name']: p['value'] for p in data['properties']}
return properties |
def arg2slice(arg):
"""Convert string argument to a slice."""
# We want four cases for indexing: None, int, list of ints, slices.
# Use [] as default, so 'in' can be used.
if isinstance(arg, str):
arg = eval('np.s_['+arg+']')
return [arg] if isinstance(arg, int) else arg |
def extract_doi_suffix(protocol_doi):
"""
DOIs come in a format like 'dx.doi.org/10.17504/protocols.io.bazhif36'.
We just need the 'protocols.io.bazhif36' element to form our query url.
"""
return protocol_doi.split("/")[2] |
def is_9_pandigital(n: int) -> bool:
"""
Checks whether n is a 9-digit 1 to 9 pandigital number.
>>> is_9_pandigital(12345)
False
>>> is_9_pandigital(156284973)
True
>>> is_9_pandigital(1562849733)
False
"""
s = str(n)
return len(s) == 9 and set(s) == set("12345678... |
def cross_list(sequences):
"""
Code taken from the Python cookbook v.2 (19.9 - Looping through the cross-product of multiple iterators)
This is used to create all the variations associated with an product
"""
result =[[]]
for seq in sequences:
result = [sublist+[item] for sublist in resu... |
def parseAlgHeader(header, delimiter="|"):
"""
Use this instead of splitting on the "|" delimiter if the "|" character
shows up inside one of the fields.
Run this function on a single header, not all the headers returned in the
list from readAlg.
header_fields = readAlg(headers)
"""
h... |
def replace_get_resp(self, url, query_params={}, json=False):
"""
replaces call to shipyard client
:returns: dict with url and parameters
"""
return {'url': url, 'params': query_params} |
def return_antipode(latitude, longitude):
"""Return antipode latitude and longitude
Args:
latitude (float)
longitude (float)
"""
if longitude < 0:
return -1. * latitude, longitude + 180
elif longitude >= 0:
return -1. * latitude, longitude - 180 |
def difference(list, *lists):
"""construct a collection with values of first list argument which are not
present in any other list arguments provided to the function
"""
out = []
isPresent = False
for item in list:
isPresent = False
for list2 in lists:
if item in list... |
def status_reporter(server_name, status):
"""Produce a report for a server status dict"""
report = []
report.append(f"***{server_name}***")
for k, v in status.items():
report.append(f"{k}: {sorted(v)}")
report.append("\n")
return "\n".join(report) |
def filter_books_by_publication(years, books):
"""
Returns books with publication year between year range.
"""
new_books = []
year_start = min(years)
year_end = max(years)
for book in books:
year_of_publication = int(book[1])
if year_of_publication >= year_start and year_of_publication <= year_end:
new... |
def get_rule_full_description(tool_name, rule_id, test_name, issue_dict):
"""
Constructs a full description for the rule
:param tool_name:
:param rule_id:
:param test_name:
:param issue_dict:
:return:
"""
issue_text = issue_dict.get("issue_text", "")
# Extract just the first lin... |
def _parse_class_name(value):
"""_parse_class_name
There's got to be a better way to do this.
"""
def _extract_name(name):
return name[8 : name.find(">") - 1]
name = str(value)
tmp = name.find("<class '")
if tmp > -1:
# it is a type
name = _extract_name(name)
e... |
def iterate_items(dictish):
""" Return a consistent (key, value) iterable on dict-like objects,
including lists of tuple pairs.
Example:
>>> list(iterate_items({'a': 1}))
[('a', 1)]
>>> list(iterate_items([('a', 1), ('b', 2)]))
[('a', 1), ('b', 2)]
"""
if hasattr(di... |
def date_to_rt11(val):
"""
Translate python date to RT-11 time
"""
if val is None:
return 0
age = (val.year - 1972) / 32
if age < 0:
age = 0
elif age > 3:
age = 3
year = (val.year - 1972) % 32
return year + \
(val.day << 5) + \
(val.month... |
def class_to_str(obj):
""" get class string from object
Examples
--------
>>> class_to_str(list).split('.')[1]
'list'
"""
mod_str = obj.__module__
name_str = obj.__name__
if mod_str == '__main__':
return name_str
else:
return '.'.join([mod_str, name_str]) |
def replace_value_in_dict(the_dict, key, new_value):
"""Returns a new dict with value replaced"""
if not isinstance(the_dict, dict):
raise TypeError('the_dict should be a dict')
try:
dict_copy = the_dict
# this causes function to raise KeyError if key does
# not exist
... |
def remove_italics(to_parse: str) -> str:
"""
A utility function for removing the italic HTML tags.
Parameters
----------
to_parse: str
The string to be cleaned.
Returns
-------
str
The cleaned string.
"""
return to_parse.replace("<i>", "").replace("</i>", "") |
def currency_to_float(value):
"""Converte de R$ 69.848,70 (str) para 69848.70 (float)."""
try:
# format 37500.36 or '37500.36
return float(value.replace("'", ""))
except ValueError:
# format R$ 37.500,36 or 37.500,36
cleaned_value = value.replace("R$", "").replace(".", "").re... |
def calculate_mturk_cost(payment_opt):
"""MTurk Pricing: https://requester.mturk.com/pricing
20% fee on the reward and bonus amount (if any) you pay Workers.
HITs with 10 or more assignments will be charged an additional 20% fee on the reward you pay Workers.
Example payment_opt format for paying rewar... |
def allow_attrs_for_a(tag, name, value):
"""
allow data-* attributes
"""
if name.startswith('data-'):
return True
if name in ['href', 'target', 'title', 'rel', 'class', ]:
return True |
def bullet(text):
""" turns raw text into a markdown bullet"""
return '- ' + text |
def load_config(field_spec: dict, loader, **kwargs) -> dict:
"""
Loads the config and any secondary configs into one object
Args:
field_spec: that should contain config
loader: system spec loader
Returns:
the full config
"""
if not isinstance(field_spec, dict):
... |
def process_itm_on_rxn(conf,itm,rxn,item,state,dampt1,dampt2) :
""" Use the is/fs states for each reaction to get their activation energies.
Then write the formula for reaction rate according to their intermediates.
This formula is split between rtd (direct part) and rti (inverse part).
Then up... |
def create_message_subject(info, context):
"""
Create the message subject
"""
base = '%s request completed' % context['display_name']
if info['errors'] > 0:
return '%s with ERRORS!' % base
elif info['warnings'] > 0:
return '%s with WARNINGS!' % base
else:
return base |
def http_signature(message, key_id, signature):
"""Return a tuple (message signature, HTTP header message signature)."""
template = ('Signature keyId="%(keyId)s",algorithm="hmac-sha256",'
'headers="%(headers)s",signature="%(signature)s"')
headers = ['(request-target)', 'host', 'accept', 'dat... |
def grelha_nr_colunas(g):
"""
grelha_nr_colunas: grelha --> inteiro positivo
grelha_nr_colunas(g) devolve o numero de colunas da grelha g.
"""
return len(g[0]) |
def bump_down(month, year):
"""
bump is a utility function that takes a given month
and year and returns the next month and year. For
example bump(1, 2014) would return (2, 2014) while
bump(12, 2013) would return (1, 2014).
@param month the month to be bumped
@param year the year to be bum... |
def _LiteralPrefix(regex):
"""Returns longest prefix of regex which consists of literal characters."""
start = list(regex)
result = []
while True:
if not start:
return "".join(result)
if start[0] == "\\":
# A bar \ is a mystery, we do nothing with it.
if len(start) == 1:
retur... |
def linear_search(array, value):
"""
:param array: list of values
:param value: value to search for
:return: index of the value
If not found, return -1
Time complexity: O(n)
"""
for idx, ele in enumerate(array):
if ele == value:
return idx
return -1 |
def compare_ext(src_ext, dst_ext):
"""
An error occurs because the extension conversion is not supported
"""
if not src_ext == dst_ext:
return 1
return 0 |
def _get_n_leading_spaces(line: str):
"""Return number of spaces before the first non-space character."""
return len(line) - len(line.lstrip(" ")) |
def rescale_rectangle(top_left, sides, ratio):
"""
Rescale rectangle, leaving its center point unchanged
Parameters
----------
top_left : (float, float)
(x,y) coordinates of rectangle top left corner
sides : (float, float)
(x,y) lengths of rectangle sides
ratio : float
... |
def N_inc(q, n):
"""
function to find Number of incident particle
Arguments
---------
q: value of current digityzer in units of 1.0E-10[C]
n: charge of incident particle in units of e
Return
------
Ni : Number of incident particle
"""
e = 1.602176634E-19 # elementary charg... |
def getStateCentre(state):
"""
The 'centre' tuple contains the lat/long and 'width (in whole degrees)'
of the centre of the 'state' (or the Country 'AUS').
The return value is not always strictly within the state.
"""
try:
centre = {
'NSW': (-32, 145, 3),
'QLD': (-24, 145, 4),
'VIC': (... |
def quote_unident(val):
"""
This method returns a new string replacing "" with ",
and removing the " at the start and end of the string.
"""
if val != None and len(val) > 0:
val = val.replace('""', '"')
if val != None and len(val) > 1 and val[0] == '"' and val[-1] == '"':
... |
def extract_x_positions(parameter, joining_string="X"):
"""
find the positions within a string which are X and return as list, including length of list
:param parameter: str
the string for interrogation
:param joining_string: str
the string of interest whose character positions need to ... |
def bits_to_bytes(bits):
""" Convert a sequence of booleans into bytes """
while len(bits) % 8 != 0:
bits.append(False)
m = bytearray()
for i in range(0, len(bits), 8):
v = 0
for j in range(8):
if bits[i+j]:
v = v | (1 << j)
m.append(v)
re... |
def get_coords_from_line(line):
"""
Extracts atom coordinates from a PDB line based on chain ID, residue number and PDB atom name.
Input
line: str - PDB line
Output
string of coordinates extracted from the PDB line
"""
return line[30:54].split() |
def create_line(kp1,kp2):
"""
Parameters:
-----------
kp1 : int
First keypoint
kp2 : int
Second keypoint
"""
_ln = "L,%g,%g"%(kp1,kp2)
return _ln |
def variation_string(variation):
"""Generate a string representing the variation."""
pm_str = ''
for k, v in variation.items():
pm_str += f'{k}-{v}_'
return pm_str.rstrip('_') |
def to_pascal_case(value):
"""
Converts the value string to PascalCase.
:param value: The value that needs to be converted.
:type value: str
:return: The value in PascalCase.
:rtype: str
"""
return ''.join(character for character in value.title() if not character.isspace()) |
def score(x, y):
"""
Score the points on a dart game based on coordinates of a dart.
:param x int - the x coordinate (with 0 being the center of a dart board) of the dart.
:param y int - the y coordinate (with 0 being the center of a dart board) of the dart.
:return int - points scored based on whe... |
def calc_beta(beta0, beta1, d):
"""beta0+beta1/d**4
"""
return beta0+beta1/d**4 |
def central_critic_observer(agent_obs, **kw):
"""Rewrites the agent obs to include opponent data for training."""
new_obs = {
0: {
"own_obs": agent_obs[0],
"opponent_obs": agent_obs[1],
"opponent_action": 0, # filled in by FillInActions
},
1: {
... |
def cast_all(arr, final_type = "int"):
"""
Casts all elements in a given array to specified data type
Raises a type error if type is not found
"""
if(final_type == "int"):
return [int(i) for i in arr]
elif(final_type == "float"):
return [float(i) for i in arr]
elif(final_type... |
def scalar_mul_while(x):
""" scalar_mul_while """
rv = x
while rv < 100:
rv = rv * rv
return rv |
def add(a, b, c=10):
"""Take three inputs as integer and returns their sum."""
total = a+b+c
return total |
def check_move(player):
"""
Makes sure not they don't teleport through the outer walls.
:param player:
:return:
"""
x, y = player
legit_moves = ['l', 'r', 'u', 'd']
if x == 0:
legit_moves.remove('l')
if x == 4:
legit_moves.remove('r')
if y == 0:
legit_mov... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.