content stringlengths 42 6.51k |
|---|
def header_population(headers):
"""make column headers from a list
:param headers: list of column headers
:return: a list of dictionaries
"""
return [{'id': field, 'name': field, 'field': field} for field in headers] |
def _normalize_output_name(output_name):
"""Remove :0 suffix from output tensor names."""
return output_name.split(":")[0] if output_name.endswith(
":0") else output_name |
def prepare(link:str):
"""A function to check if the link is complete (it includes the protocol)
and that it can be used by the library (it should not end with a slash)
Args:
**link (str)**: The link to check/prepare
Raises:
**Exception**: Thrown if the protocol is not present in the URL
Returns:
**str... |
def getCSSimpleWuPalmer(ic_lca, depth):
"""
CS calculation based on a simplified version of IC-based Wu-Palmer,
where the two concepts are on the deepest level of the taxonomy tree
"""
return 1-(depth - ic_lca)/depth |
def get_output_ready_pairs(mapping):
"""
Gets a list of the output ready tags for all buildings
Returns
output_ready_pairs -- list of tuples (building_name, output_ready_tag) for each building, in the order specified by mapping.json
"""
output_group = []
for building_name in mapping.keys():
controls = mappi... |
def _should_generate_labeled_dialog_turn_ids(with_label: bool,
num_model_latent_states: int,
num_latent_states: int,
label_sampling_path: str) -> bool:
"""Determines whether to genera... |
def create_id(elements):
"""Return an unused ID for a new element.
Positional arguments:
elements -- list or dictionary containing all existing IDs
"""
i = 1
while str(i) in elements:
i += 1
return str(i) |
def convert_units_apply(value, factor, fromto='from', mode='mul'):
"""
Apply a conversion factor to a value. For plain factors, if ('from' and
'mul') or ('to' and 'div'), the value is multipled by the factor,
otherwise the value is divided by the factor.
Enter: value: a floating point value to adj... |
def _set_default_construction_id(construction_id: int, subcategory_id: int) -> int:
"""Set the default construction ID for switches.
:param construction_id: the current construction ID.
:param subcategory_id: the subcategory ID of the switch with missing defaults.
:return: _construction_id
:rtype: ... |
def missing_newline(physical_line):
"""
JCR: The last line should have a newline.
"""
if physical_line.rstrip() == physical_line:
return len(physical_line), "W292 no newline at end of file" |
def sizeofh(num, suffix="B"):
"""
Generate a human readable sizeof format.
Args:
num (number): input number of bytes to convert.
suffix (str): suffix of the output format.
Returns:
String containing the correctly formatted sizeof.
"""
for unit in ['', 'Ki',... |
def k2c(k: float, r: int = 2) -> float:
"""Kelvin to Celsius."""
return round(k - 273.15, r) |
def create_input_obj(val, cols_list, input_type=None, condition=False):
"""
Used to generate larger input objects for the query creation e.g., by iterating in a list
Example use: create_input_obj(1, "uid")
Output form: [{"val": uid, "cols": ["uid"], "type": "exact", "condition": True}]
"""
input... |
def get_resized_bbox(height, width, bbox):
""" Adjusts bounding box from annotation, since input
data should be squares.
"""
xmin, ymin, xmax, ymax = bbox
xlen = xmax - xmin
ylen = ymax - ymin
if xlen > ylen:
diff = xlen - ylen
min_pad = min(ymin, diff // 2)
max_... |
def get_name(artist_name):
"""this function takes the name of artist whose music we want to look for in itunes
:param artist_name:
:return: complete_url, name
"""
if isinstance(artist_name, str):
name = '' + artist_name
name = ''.join(name.split())
else:
return 'Enter a v... |
def decapitalize(s):
""" Decapitalizes a string """
return s[:1].lower() + s[1:] if s else "" |
def parse_command(command_line):
"""
Parse command and returns argv.
"""
argv = []
string_marker=None
in_arg = False
in_str = False
acc = ''
escaped = False
i=0
while i<len(command_line):
if command_line[i]!=' ':
if not in_arg:
in_arg = Tru... |
def reverse(number) -> int:
"""
Takes a integer number as input and returns the reverse of it.
"""
rev = 0
while number > 0:
d = number % 10
rev = rev*10+d
number //= 10
return rev |
def remove_repeat(goal_seq, kg_seq):
"""remove_repeat"""
assert len(goal_seq) == len(kg_seq)
new_goal_seq, new_kg_seq = list(), list()
for idx, (a, b) in enumerate(zip(goal_seq, kg_seq)):
if idx > 0:
if a == goal_seq[idx - 1] and b == kg_seq[idx - 1]:
continue
... |
def env_to_bool(input):
"""
Must change String from environment variable into Boolean
defaults to True
"""
if isinstance(input, str):
return input not in ("False", "false")
else:
return input |
def _attribToString(attrib):
"""
convert attrib dictionnary to string suitable for XPath search
{'name': 'Reacher', 'date': '2016', 'type': 'Movie'}
[contains(@name, "Reacher") and contains(@type, "Movie")]
"""
s = "["
lFirst = True
for k in attrib:
if lFirst:
s =... |
def score(word: str):
"""Calculate a simple "score" for a word for the sake of sorting candidate
guesses. For this agent, the score is just the number of distinct letters
in the word. For example, "taste" has a score of 4 while "tears" has a
score of 5."""
return len(set(word)) |
def mktemp_cmd(local_tmp_dir_prefix):
"""mktemp command to create a local temp dir"""
return "mktemp -d %sXXXXXX" % local_tmp_dir_prefix |
def _get_magnitude(string):
"""
Get the magnitude of the smallest significant value in the string
:param str string: A representation of the value as a string
:returns: The magnitude of the value in the string. e.g. for 102, the magnitude is 0, and for 102.03 it is -2
:rtype: int
"""
split_... |
def sum_of_n_natual_numbers(n):
"""
Returns sum of first n natural numbers
"""
try:
n+1
except TypeError: # invlid input hence return early
return
if n < 1: # invlid input hence return early
return
return n*(n+1) // 2 |
def simple_format(num):
"""Takes a number and returns the simplest format for the number removing
all trailing 0's and the '.' if it's the trailing character.
>>> simple_format(123)
'123'
>>> simple_format(123.0)
'123'
>>> simple_format(123.01100)
'123.011'
"""
return ('%f' % nu... |
def contains_pipeline_for(pos, lines):
"""Examine if there is any for loop with hls_pipeline annotation inside the current for loop"""
n_l_bracket = 0
n_r_bracket = 0
code_len = len(lines)
init_state = 1
while pos < code_len and n_r_bracket <= n_l_bracket:
if lines[pos].find("{") != -1:
... |
def normalize_space(string):
"""Normalize all whitespace in string so that only a single space
between words is ever used, and that the string neither starts with
nor ends with whitespace.
>>> normalize_space(" This is a long \\n string\\n") == 'This is a long string'
True
"""
return ' '.join(str... |
def get_attribute_name(node_and_attribute):
"""
For a string node.attribute, return the attribute portion
"""
split = node_and_attribute.split('.')
attribute = ''
if split and len(split) > 1:
attribute = '.'.join(split[1:])
return attribute |
def iou(box1, box2):
"""Intersection over Union value."""
# Intersection rectangle
intersect_x1 = max(box1[0], box2[0])
intersect_y1 = max(box1[1], box2[1])
intersect_x2 = min(box1[2], box2[2])
intersect_y2 = min(box1[3], box2[3])
# Area of intersection rectangle
if intersect_x1 >= inte... |
def HTMLColorToRGB(colorstring):
""" convert #RRGGBB to an (R, G, B) tuple """
colorstring = colorstring.strip()
if colorstring[0] == '#':
colorstring = colorstring[1:]
if len(colorstring) != 6:
raise ValueError(
"input #{0} is not in #RRGGBB format".format(colorstring))
... |
def dms_to_deg(deg,min,sec):
"""Convert a (deg,arcmin,arcsec) to decimal degrees"""
return deg+min/60.+sec/3600. |
def checkPath(path_type_in):
"""
function: Check the path:
the path must be composed of letters, numbers,
underscores, slashes, hyphen, and spaces
input : path_type_in
output: NA
"""
pathLen = len(path_type_in)
i = 0
a_ascii = ord('a')
z_ascii = ord('z')
... |
def evalBasis1D(x, basis,interval=None):
""" evaluation of the basis functions in one dimension """
if interval is None:
return 1. - abs(x*2**basis[0]-basis[1])
else:
pos = (x-interval[0])/(interval[1]-interval[0])
return 1. - abs(pos*2**basis[0]-basis[1]) |
def allocate_examples(max_examples, subtasks):
"""Calculates the number of examples each subtask should evaluate.
Implements this requirement by BIG-bench organizers:
https://github.com/google/BIG-bench/pull/288#issuecomment-844333336
For example, we're allowed to evaluate only 7 examples, but we have... |
def parse_file(input_file):
""" takes all text from nubbe database file and returns a list of lists
with NPs which is easy to use
input_file: nubbe database txt file
"""
all_lines = input_file.split('\n')
all_info_list = []
for line in all_lines:
line = line.split('\t')
... |
def sumValues(d):
"""Return the sum of int values of a dict d."""
result = 0
for value in d.values():
if type(value) == int:
result += value
return result |
def strip_mac_address_format(mac):
"""normalizes the various mac address formats"""
return mac.lower().replace("-", "").replace(".", "").replace(":", "") |
def Nobullet_f(val):
"""
:param val: The value of this Nobullet
"""
return val.strip() + '\n' |
def single_div_toggle_style(mode_val):
"""toggle the layout for single measure"""
if mode_val == 'single':
return {
'display': 'flex',
'flex-direction': 'column',
'alignItems': 'center'
}
else:
return {'display': 'none'} |
def prepare_query_domains(domain):
"""
prepare a domain or a list of domains for google query (adding site:*.)
"""
domain = domain.replace(" " , "").replace("," , " OR site:*.")
domain = "site:*." + domain
domain = domain.replace(".." , ".")
return domain |
def neighborhood_size(node, neighborhoods):
"""
SCAN Section 3.1 Definition 1
"""
return len(neighborhoods[node]) + 1 |
def power_of_k(k, power=1):
"""
Compute an integer power of a user-specified number k.
"""
# initialize
x = 1
# multiply x by k power times.
for i in range(power):
x *= k
return x |
def clean_text (text):
"""
Replace breack lines in text
"""
return str(text).replace ("\n", " | ") |
def parse_color(hex):
"""
Reads a hex two digit hex string and converts it to a decimal between 0 and 1.
"""
return int(hex, 16) / 255. |
def ppv_converter(sensitivity, specificity, prevalence):
"""Generates the Positive Predictive Value from designated Sensitivity, Specificity, and Prevalence.
Returns positive predictive value
sensitivity:
-sensitivity of the criteria
specificity:
-specificity of the criteria
preval... |
def combSort(arr):
"""
>>> combSort(arr)
[-12, 1, 3, 7, 12, 22, 100]
"""
gap = len(arr)
shrink = int(gap * 10 / 13)
sorted = False
while gap > 1 or sorted == False:
gap = int(gap / shrink)
if gap <= 1:
gap = 1
sorted = True
for... |
def insertionSort2(nums):
"""
Improved version,merged the find and move forward step
:type nums:list[int]
:rtype list[int]
"""
res=list(nums)
for i in range(1,len(res)):
#if res[i]>=res[i-1] res[:0] are already sorted
if res[i]<res[i-1]:
temp=res[i]
j=... |
def _cleandoc(doc):
"""Remove uniform indents from ``doc`` lines that are not empty
:returns: Cleaned ``doc``
"""
indent_length = lambda s: len(s) - len(s.lstrip(" "))
not_empty = lambda s: s != ""
lines = doc.split("\n")
indent = min(map(indent_length, filter(not_empty, lines)))
retu... |
def get_mean(elements):
"""The average of all the integers in a set of values."""
s = 0
for element in elements:
s += element
return (s / len(elements)) |
def fetch_ids(input_path):
"""
Args:
input_path:
Returns:
(dict): 'subjectID' and 'formID'
"""
parts = input_path.split('/')
ids = {}
ids['subjectID'] = int(parts[-3])
ids['formID'] = parts[-2]
return ids |
def is_empty_list_of_dicts(list_):
"""
A helper function to find out if a list of dicts contains values or
not. The following values are considered as empty values:
* ``[{"key": ""}]``
* ``[{"key": None}]``
* ``[{"key": []}]``
Args:
``list_`` (list): A list of dicts.
Returns:
... |
def _add_neurodocker_header(specs):
"""Return Dockerfile comment that references Neurodocker."""
return ("# Generated by Neurodocker v{}."
"\n#"
"\n# Thank you for using Neurodocker. If you discover any issues "
"\n# or ways to improve this software, please submit an issue or... |
def permutation_any_order(l, o='lexicographic'):
"""The slowest permutation solution of all but the most versatile.
(About 10x slower than the other two) This function is capable
of permuting in either the lexicographical order or the
anti-lexicographical order. It can also permute lists of all kinds
... |
def _datesplit(timestr):
"""
Split a unit string for time into its three components:
unit, string 'since' or 'as', and the remainder
"""
try:
(units, sincestring, remainder) = timestr.split(None, 2)
except ValueError:
raise ValueError(f'Incorrectly formatted date-time unit_strin... |
def reduce_sets_or(sets):
"""
Compute the set conjunctive reduction of a list of iterables.
Equivalent to (though faster than)::
reduce(lambda a, b: a | b, sets, set())
"""
retval = set()
for item in sets:
retval.update(item)
return retval |
def time_str_sec(delta):
"""Print a hh:mm::ss time"""
fraction = delta % 1
delta -= fraction
delta = int(delta)
seconds = delta % 60
delta /= 60
minutes = delta % 60
delta /= 60
hours = delta
return '%02u:%02u:%02u' % (hours, minutes, seconds) |
def gen_data(data):
"""
gen_data
=======
Generates a list containing 8 bit binary representation of the data
Parameters:
-----------
* data: the cipher-text that needs to converted to 8 bit binary strings
Returns:
* A list containing the 8 bit binary strings
Doctests
====... |
def pentagonal(n: int) -> int:
"""Find the number of dots in nth pentagonal number."""
# Find the pentagonal number to nth degree.
pentagonal_number = (n * ((3 * n) - 1) // 2)
# Find the total number of dots.
dots = ((n-1) ** 2)
dots += pentagonal_number
return dots |
def coding_problem_12(budget, choices):
"""
There exists a staircase with N steps, and you can climb up either 1 or 2 steps at a time. Given N, write a
function that returns the number of unique ways you can climb the staircase. The order of the steps matters.
For example, if N is 4, then there are 5 un... |
def get_sp_pred(pred_sp_idx, data):
"""get the prediction of supporting facts in original format
Arguments:
pred_sp_idx {[type]} -- [description]
data {[type]} -- [description]
"""
pred = []
for p in pred_sp_idx:
if p < len(data):
pred.append([data[p].doc_tit... |
def safe_readable(handle):
"""Attempts to find if the handle is readable without throwing an error."""
try:
status = handle.readable()
except (OSError, ValueError):
status = False
return status |
def recall_at_with_k_candidates(preds, labels, k, at):
"""
Calculates recall with k candidates. labels list must be sorted by relevance.
Args:
preds: float list containing the predictions.
labels: float list containing the relevance labels.
k: number of candidates to consider.
... |
def field_values(iterable, field):
"""
Convert an iterable of models into a list of strings, one for each model,
where the string for each model is the value of the field "field".
"""
objects = []
if field:
for item in iterable:
objects.append(getattr(item, field))
retu... |
def _unroll(seq):
"""Unroll nested sequences of stuff and return a flattened list"""
out = []
if isinstance(seq, (list, tuple)):
for elem in seq:
out.extend(_unroll(elem))
else:
out.append(seq)
return out |
def snake_to_camel_fast(s: str) -> str:
"""Converts the given text from snake_case to CamelCase, faster.
This function is *slightly* faster than the :obj:`snake_to_camel`
implementation, however that comes at the expense of accuracy.
Please see the warnings below for more information.
Parameters
... |
def naive_tokenizer(sentence):
"""Naive tokenizer: split the sentence by space into a list of tokens."""
return sentence.split() |
def split_sample_name(s):
"""Split sample name into numerical and non-numerical parts
Utility function which splits the supplied sample name
into numerical (i.e. integer) and non-numerical (i.e. all
other types of character) parts, and returns the parts as
a list.
For example:
>>> split_s... |
def mod_dist(a, b, n):
"""Return the distance between floats a and b, modulo n.
The result is always non-negative.
For example, thinking of a clock:
mod_dist(11, 1, 12) == 2 because you can "wrap around".
"""
return min((a-b) % n, (b-a) % n) |
def is_open_access(record):
"""Returns True if permissions subject(s) is anyone (all)."""
return record.get('permissions', '').startswith('all_') |
def prepare_id(id_):
"""if id_ is string uuid, return as is, if list, format as comma separated list."""
if isinstance(id_, list):
return ','.join(id_)
elif isinstance(id_, str):
return id_
else:
raise ValueError(f'Incorrect ID type: {type(id_)}') |
def get_language(abrev):
"""
returns: the list of languages of a canton. The list is sorted by main language
"""
lang = {
'AG': ['D'],
'AR': ['D'],
'AI': ['D'],
'BL': ['D'],
'BS': ['D'],
'BE': ['D', 'FR'],
'FR': ['FR', 'D'] ,
'GE'... |
def strip_markup(text):
"""Strip yWriter 6/7 raw markup. Return a plain text string."""
try:
text = text.replace('[i]', '')
text = text.replace('[/i]', '')
text = text.replace('[b]', '')
text = text.replace('[/b]', '')
except:
pass
return text |
def make_skills_section(skls, indent):
"""
Create the liens of the skill section
Args:
skls: the list of skills
indent: the original indentation
Returns:
A list of lines of the skill section
"""
lines = []
for skl in skls:
lines.append(f"{indent}<li>{skl}</li... |
def convert_num(mode, num):
"""Converts a number in any given number scale
Example:
`convert_num("100K", 600000) returns 6`
Args:
- mode: (string) the scale for the conversion ("100K", "M", "10M", "100M", "B")
- num: the number to be converted
Returns:
the converted number
"... |
def handle_integer_input(input, desired_len):
"""
Checks if the input is an integer or a list.
If an integer, it is replicated the number of desired times
If a tuple, the tuple is returned as it is
Parameters
----------
input : int, tuple
The input can be either a tuple of paramete... |
def balance_groups(groups):
"""Balances a list of lists, so they are roughly equally sized."""
numPlayers = sum([len(group) for group in groups])
minGroupSize = int(numPlayers / len(groups))
groupsArr = list(enumerate(groups))
for i, group in groupsArr:
while len(group) < minGroupSize:
... |
def get_list_of_block_numbers(item):
"""Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return [] |
def query_commons_nearby(lat: float, lon: float, radiusmetres: int) -> dict:
"""get images near given coordinates from wikimedia commons.
options for image info are found here:
https://www.mediawiki.org/w/api.php?action=help&modules=query%2Bimageinfo"""
if not 10 <= radiusmetres <= 10000:
r... |
def _update_frames(expected_settings):
"""
Calculate proper frame range including handles set in DB.
Harmony requires rendering from 1, so frame range is always moved
to 1.
Args:
expected_settings (dict): pulled from DB
Returns:
modified expected_setting (dict)
... |
def get_optimal_bin_size(n):
"""
This function calculates the optimal amount of bins for the number of events n.
:param n: number of Events
:return: optimal bin size
"""
return int(2 * n**(1/3.0)) |
def kodi_to_ansi(string):
"""Convert Kodi format tags to ANSI codes"""
if string is None:
return None
string = string.replace('[B]', '\033[1m')
string = string.replace('[/B]', '\033[21m')
string = string.replace('[I]', '\033[3m')
string = string.replace('[/I]', '\033[23m')
string = s... |
def is_in(item, a_list):
"""
Checks whether the item is in the ordered
list a_list using a binary search.
Returns Boolean.
"""
if len(a_list) == 0:
return False
elif len(a_list) == 1:
return item == a_list[0]
else:
if item < a_list[len(a_list) / 2]:
r... |
def create_composite_func(func0, func1):
""" return a composite of two funcs"""
if func0 is None:
return func1
if func1 is None:
return func0
return lambda x: func0(func1(x)) |
def cleanUnicodeFractions(s):
"""
Replace unicode fractions with ascii representation, preceded by a
space.
"1\x215e" => "1 7/8"
"""
fractions = {
u'\x215b': '1/8',
u'\x215c': '3/8',
u'\x215d': '5/8',
u'\x215e': '7/8',
u'\x2159': '1/6',
u'\x215a'... |
def format_line(entries, sep=' | ', pads=None, center=False):
"""
Format data for use in a simple table output to text.
args:
entries: List of data to put in table, left to right.
sep: String to separate data with.
pad: List of numbers, pad each entry as you go with this number.
... |
def padHash(hashNum,size):
"""Pads all inputs until its the size of size bits"""
hashLength = len(bin(hashNum)[2:])
if (hashLength!=size):
paddedHash = '0'*(size-hashLength)
paddedHash = paddedHash + bin(int(hashNum))[2:]
else:
paddedHash = bin(int(hashNum))[2:]
return padded... |
def area_of_polygon(XYs):
""" Calculates the area of an arbitrary polygon given its verticies """
n = len(XYs) # of corners
area = 0.0
for i in range(n):
j = (i + 1) % n
area += XYs[i][0] * XYs[j][1]
area -= XYs[j][0] * XYs[i][1]
area = abs(area) / 2.0
# print ("XYs {0} area {1}".format(XYs, ar... |
def _convex_hull(points):
"""Computes the convex hull of a set of 2D points.
Input: an iterable sequence of (x, y) pairs representing the points.
Output: a list of vertices of the convex hull in counter-clockwise order,
starting from the vertex with the lexicographically smallest coordinates.
Imp... |
def _filter_pipelines_by_time(con, pipelines, days):
"""
Will return pipelines that are older than the number of days specified.
"""
# for each pipeline in pipelines we should get their builds
# if the most recent build is older than $days old then we should add it to
# the list of things to rem... |
def sameObject( obj1, obj2 ):
"""True if the two objects are the same. Very similar to the "is" python keyword, but returns
true if both objects are different SWIG wrapper of the same object."""
try:
return obj1.this == obj2.this
except AttributeError:
return obj1 is obj2 |
def find_parenthesis_pairs(s, one, two):
"""
:param s: The string to look for pairs in.
:param one: The first of a pair.
:param two: The second of a pair.
:return: returns a list of pairs.
"""
counter = 0
pairs = []
for i in range(0, len(s)):
if s[i] == one:
# STA... |
def get_score(
distance, searched_lat=None, current_object_lat=None,
searched_long=None, current_object_long=None
):
"""
Given: distance, searched_lat, current_object_lat,
searched_long, current_object_long
Evaluate score due to the distance range
And increase it if the provided searched lat... |
def get_container_specs(request_object: dict):
"""
Returns the container specifications of the `request_object`, based on its
type.
"""
object_kind = request_object.get("kind")
if object_kind == "Pod":
relevant_spec = request_object["spec"]
init_containers = relevant_spec.get("in... |
def parse_degrees(coord):
"""Parse an encoded geocoordinate value into real degrees.
:param float coord: encoded geocoordinate value
:return: real degrees
:rtype: float
"""
degrees = int(coord)
minutes = coord - degrees
return degrees + minutes * 5 / 3 |
def eval_overlap(n1, n2):
"""
Return a tuple containing the number of matches (resp.,
mismatches) between a pair (n1,n2) of overlapping reads
"""
hang1 = n2["begin"] - n1["begin"]
overlap = zip(n1["alleles"][hang1:], n2["alleles"])
match = mismatch = 0
for (c1, c2) in overlap:
if... |
def get_G(E, nu):
"""
Returns shear modulus given Young's modulus and Poisson's ratio
Parameters
----------
E: float
Young's modulus
nu : float
Poisson's ratio
Returns
-------
float
Shear modulus
"""
return E / (2. * (1. + nu)) |
def count_ones(word_ones):
"""
Counts the ones associated with a (word, next) pair
:param word_ones: tuple (word, [1,1,..,1])
:return: tuple (word, count)
"""
(word, ones) = word_ones
return (word, sum(ones)) |
def _helper(mongo_return) -> dict:
"""
The _helper function takes the mongo_return and returns a dictionary with the id, guess, and time.
:param mongo_return: Used to store the data returned from the MongoDB query.
:return: a dictionary containing the document's id and lhguess.
"""
return {
... |
def get_adaptive_eval_interval(cur_dev_size, thres_dev_size, base_interval):
""" Adjust the evaluation interval adaptively.
If cur_dev_size <= thres_dev_size, return base_interval;
else, linearly increase the interval (round to integer times of base interval).
"""
if cur_dev_size <= thres_dev_s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.