text stringlengths 81 112k |
|---|
Find indicies of insignificant un-/correlated variables
Example:
--------
i, j = find_unrelated(x, plim, rlim)
def find_unrelated(x, plim=0.1, axis=0):
"""Find indicies of insignificant un-/correlated variables
Example:
--------
i, j = find_unrelated(x, plim, rlim)
"""
# ... |
Handle apply connectivity changes request json, trigger add or remove vlan methods,
get responce from them and create json response
:param request: json with all required action to configure or remove vlans from certain port
:return Serialized DriverResponseRoot to json
:rtype json
def... |
Validate action from the request json,
according to APPLY_CONNECTIVITY_CHANGES_ACTION_REQUIRED_ATTRIBUTE_LIST
def _validate_request_action(self, action):
""" Validate action from the request json,
according to APPLY_CONNECTIVITY_CHANGES_ACTION_REQUIRED_ATTRIBUTE_LIST
"""
... |
Get VLAN list from input string
:param vlan_str:
:return list of VLANs or Exception
def _get_vlan_list(self, vlan_str):
""" Get VLAN list from input string
:param vlan_str:
:return list of VLANs or Exception
"""
result = set()
for splitted_vlan in vlan... |
Run flow to add VLAN(s) to interface
:param vlan_id: Already validated number of VLAN(s)
:param full_name: Full interface name. Example: 2950/Chassis 0/FastEthernet0-23
:param port_mode: port mode type. Should be trunk or access
:param qnq:
:param c_tag:
def add_vlan(self, vlan... |
Run flow to remove VLAN(s) from interface
:param vlan_id: Already validated number of VLAN(s)
:param full_name: Full interface name. Example: 2950/Chassis 0/FastEthernet0-23
:param port_mode: port mode type. Should be trunk or access
def remove_vlan(self, vlan_id, full_name, port_mode):
... |
Process view and return root Node
def render_view(view_name, **args):
'''Process view and return root Node'''
try:
root_xml = get_view_root(view_name)
return render(root_xml, **args)
except CoreError as error:
error.add_view_info(ViewInfo(view_name, None))
raise
except:
... |
Parses xml file and return root XmlNode
def get_view_root(view_name: str) -> XmlNode:
'''Parses xml file and return root XmlNode'''
try:
path = join(deps.views_folder, '{0}.{1}'.format(view_name, deps.view_ext))
parser = Parser()
if path not in _XML_CACHE:
with open(path, 'r... |
Import passed module, class, function full name and stores it to node's globals
def import_global(node: Node, key: str, path: Any):
"""Import passed module, class, function full name and stores it to node's globals"""
node.node_globals[key] = import_path(path) |
Resolves passed dependency and stores it to node's globals
def inject_global(node: Node, global_key: str, inject_key: Any):
"""Resolves passed dependency and stores it to node's globals"""
value = get_current_scope().container.get(inject_key)
set_global(node, global_key, value) |
Adds passed value to node's globals
def set_global(node: Node, key: str, value: Any):
"""Adds passed value to node's globals"""
node.node_globals[key] = value |
Calls node or node instance method
def call(node: Node, key: str, value: Any):
"""Calls node or node instance method"""
value = _to_list(value)
if not value or not isinstance(value[-1], dict):
value.append({})
args = value[0:-1]
kwargs = value[-1]
node.__dict__[key](*args, **kwargs) |
Yield a tuple for each Flask handler containing annotated methods.
Each tuple contains a heading, routing rule, the view class associated
with the rule, and the annotations for the methods in that class.
def iter_annotations(self):
"""Yield a tuple for each Flask handler containing annotated m... |
Make a request against the app.
This attempts to use the schema to replace any url params in the path
pattern. If there are any unused parameters in the schema, after
substituting the ones in the path, they will be sent as query string
parameters or form parameters. The substituted valu... |
Subscribes to key changes
def observe(self, key: str, callback: Callable[[Any, Any], None]):
"""Subscribes to key changes"""
if key not in self._callbacks:
self._add_key(key)
self._callbacks[key].append(callback) |
Releases callback from key changes
def release(self, key: str, callback: Callable[[Any, Any], None]):
"""Releases callback from key changes"""
try:
self._callbacks[key].remove(callback)
except (KeyError, ValueError):
pass |
Subscribes to key changes
def observe(self, key, callback: Callable[[Any, Any], None]):
"""Subscribes to key changes"""
if key not in self.__dict__ and key not in self._callbacks:
raise KeyError('Entity ' + str(self) + 'doesn''t have attribute' + key)
super().observe(key, callback) |
Inherit passed dictionary
def inherit(self, parent):
"""Inherit passed dictionary"""
if self._parent == parent:
return
if self._parent:
self._parent.release_all(self._parent_changed)
self_values = {key: self._container[key] for key in self._own_keys}
self... |
Subscribes to all keys changes
def observe_all(self, callback: Callable[[str, Any, Any], None]):
"""Subscribes to all keys changes"""
self._all_callbacks.append(callback) |
Releases callback from all keys changes
def release_all(self, callback: Callable[[str, Any, Any], None]):
"""Releases callback from all keys changes"""
self._all_callbacks.remove(callback) |
Remove own key, value
def remove_key(self, key):
"""Remove own key, value"""
try:
self._own_keys.discard(key)
if self._parent and self._parent.has_key(key):
self._container[key] = self._parent[key]
else:
del self._container[key]
... |
Adds new rule
def add_rule(self, binding_type: str, rule: BindingRule):
"""Adds new rule"""
if binding_type not in self._rules:
self._rules[binding_type] = []
self._rules[binding_type].insert(0, rule) |
Finds rule by binding type and args
def find_rule(self, binding_type: str, **args):
"""Finds rule by binding type and args"""
try:
rules = self._rules[binding_type]
return next(rule for rule in rules if rule.suitable(**args))
except (KeyError, StopIteration):
... |
Returns apply function
def apply(self, binding_type, **args):
"""Returns apply function"""
rule = self.find_rule(binding_type, **args)
if rule is None:
error = BindingError('Binding rule is not found')
error.add_info('Binding type', binding_type)
error.add_in... |
Factory method to create expression target
def get_expression_target(expression: Expression, expr_vars: InheritedDict) -> BindingTarget:
'''Factory method to create expression target'''
root = expression.get_object_tree()
if len(root.children) != 1 or not PROPERTY_EXPRESSION_REGEX.fullmatch(expression.code... |
Calles modifier on instance with passed value
def on_change(self, value):
'''Calles modifier on instance with passed value'''
self._modifier(self.inst, self.prop, value) |
Unsubscribes callback from observable
def destroy(self):
'''Unsubscribes callback from observable'''
self._observable.release(self._key, self._callback)
self._observable = None
self._key = None
self._callback = None |
Add and parse the arguments for the script.
url: the url of the example to run
gae-sdk-path: this allows a user to point the script to their GAE SDK
if it's not in /usr/local/google_appengine.
def args():
"""Add and parse the arguments for the script.
url: the url of the example to ... |
Grabs the gae_lib_path from the options and inserts it into the first
index of the sys.path. Then calls GAE's fix_sys_path to get all the proper
GAE paths included.
:param options:
def setup(options):
"""Grabs the gae_lib_path from the options and inserts it into the first
index of the sys.path. T... |
Run the passed in url of the example using GAE's rpc runner.
Uses appengine_rpc.HttpRpcServer to send a request to the url passed in
via the options.
:param options:
def run(options):
"""Run the passed in url of the example using GAE's rpc runner.
Uses appengine_rpc.HttpRpcServer to send a reque... |
Enable and Disable SNMP communityon the device, Read it's structure and attributes: chassis, modules,
submodules, ports, port-channels and power supplies
:return: AutoLoadDetails object
:rtype: cloudshell.shell.core.driver_context.AutoLoadDetails
def discover(self):
"""Enable and Disab... |
Returns True if `querypart_name` with `value` is set.
For example you can check if you already used condition by `sql.has('where')`.
If you want to check for more information, for example if that condition
also contain ID, you can do this by `sql.has('where', 'id')`.
def has(self, querypart_n... |
Executes expression with passed parameters and returns result
def execute(self, parameters: dict = None):
"""Executes expression with passed parameters and returns result"""
try:
parameters = {} if parameters is None else parameters
return eval(self._compiled_code, parameters, {... |
There is a 50% chance that this function will AbortAndRestart or
complete successfully.
The 50% chance simply represents a process that will fail half the time
and succeed half the time.
def aborting_function():
"""There is a 50% chance that this function will AbortAndRestart or
complete successfu... |
Remove ANSI escape codes from student result.
def strip_ansi(state):
"""Remove ANSI escape codes from student result."""
stu_res = _strip_ansi(state.student_result)
return state.to_child(student_result = stu_res) |
Check whether the student code contains text.
This function is a simpler override of the `has_code` function in protowhat,
because ``ast_node._get_text()`` is not implemented in the OSH parser
Using ``has_code()`` should be a last resort. It is always better to look at the result of code
or the side e... |
Check whether student output contains specific text.
Before you use ``has_output()``, have a look at ``has_expr_output()`` or ``has_expr_error()``;
they might be more fit for your use case.
Args:
state: State instance describing student and solution code. Can be omitted if used with ``Ex()``.
... |
Check whether the student is in the expected directory.
This check is typically used before using ``has_expr_output()``
to make sure the student didn't navigate somewhere else.
Args:
state: State instance describing student and solution code. Can be omitted if used with ``Ex()``.
dir: Dire... |
Update service status, indicating "up"-ness.
Args:
status_info (dict): a dictionary representing the status of the
service
`status_info` must have at least the fields 'role', 'load', and
'ttl'. Some additional fields are populated automatically by this
method. I... |
Remove the service with id `id` from the service registry.
def unregister(self, id):
'''
Remove the service with id `id` from the service registry.
'''
result = self.rr.table(self.table).get(id).delete().run()
if result != {
'deleted':1, 'errors':0,'inserted':0,
... |
Retrieve a unique service, possibly setting or heartbeating it first.
A "unique service" is a service with only one instance for a given
role. Uniqueness is enforced by using the role name as the primary key
`{'id':role, ...}`.
Args:
role (str): role name
candid... |
Look up healthy services in the registry.
A service is considered healthy if its 'last_heartbeat' was less than
'ttl' seconds ago
Args:
role (str, optional): role name
Returns:
If `role` is supplied, returns list of healthy services for the
given ro... |
Get a new furious context and add it to the registry. If a batch size is
specified, use an AutoContext which inserts tasks in batches as they are
added to the context.
def new(batch_size=None, **options):
"""Get a new furious context and add it to the registry. If a batch size is
specified, use an Auto... |
Return a reference to the currently executing Async job object
or None if not in an Async job.
def get_current_async():
"""Return a reference to the currently executing Async job object
or None if not in an Async job.
"""
local_context = _local.get_local_context()
if local_context._executing_a... |
Return a reference to the current Context object.
def get_current_context():
"""Return a reference to the current Context object.
"""
local_context = _local.get_local_context()
if local_context.registry:
return local_context.registry[-1]
raise errors.NotInContextError('Not in a Context.') |
Generate a hash of the given token contents that can be verified.
:param action:
A string representing the action that the generated hash is valid
for. This string is usually a URL.
:returns:
A string containing the hash contents of the given `action` and the
... |
Generate a hash of the given token contents that can be verified.
:param token_string:
A string containing the hashed token (generated by
`generate_token_string`).
:param action:
A string containing the action that is being verified.
:param timeout:
... |
Takes a dict, and a path delimited with slashes like A/B/C/D, and returns a list of objects found at all leaf nodes at all trajectories `dict[A][B][C][D]`. It does this using BFS not DFS.
The word "leaf" hereby refers to an item at the search path level. That is, upon calling the function
it... |
Enable/Disable snmp
:param snmp_parameters:
:return:
:rtype: SnmpContextManager
def get_snmp_service(self):
"""
Enable/Disable snmp
:param snmp_parameters:
:return:
:rtype: SnmpContextManager
"""
return SnmpContextManager(self.enable_flow,... |
Command-line utility to periodically purge stale entries from the "services" table.
It is designed to be used in conjunction with cron.
def purge_stale_services(argv=None):
"""Command-line utility to periodically purge stale entries from the "services" table.
It is designed to be used in conjunction with... |
Insert a batch of tasks into the specified queue. If an error occurs
during insertion, split the batch and retry until they are successfully
inserted. Return the number of successfully inserted tasks.
def _insert_tasks(tasks, queue, transactional=False,
retry_transient_errors=True,
... |
Return a list containing the tasks that should be reinserted based on the
was_enqueued property and whether the insert is transactional or not.
def _tasks_to_reinsert(tasks, transactional):
"""Return a list containing the tasks that should be reinserted based on the
was_enqueued property and whether the in... |
Batches large task lists into groups of 100 so that they can all be
inserted.
def _task_batcher(tasks, batch_size=None):
"""Batches large task lists into groups of 100 so that they can all be
inserted.
"""
from itertools import izip_longest
if not batch_size:
batch_size = DEFAULT_TASK_... |
Convert all Async's into tasks, then insert them into queues.
def _handle_tasks_insert(self, batch_size=None):
"""Convert all Async's into tasks, then insert them into queues."""
if self._tasks_inserted:
raise errors.ContextAlreadyStartedError(
"This Context has already had ... |
Return the tasks for this Context, grouped by queue.
def _get_tasks_by_queue(self):
"""Return the tasks for this Context, grouped by queue."""
task_map = {}
_checker = None
# Ask the persistence engine for an Async to use for checking if the
# context is complete.
if se... |
Add an Async to be run on event.
def set_event_handler(self, event, handler):
"""Add an Async to be run on event."""
# QUESTION: Should we raise an exception if `event` is not in some
# known event-type list?
self._prepare_persistence_engine()
callbacks = self._options.get('ca... |
Execute the Async set to be run on event.
def exec_event_handler(self, event, transactional=False):
"""Execute the Async set to be run on event."""
# QUESTION: Should we raise an exception if `event` is not in some
# known event-type list?
callbacks = self._options.get('callbacks', {})... |
Add an Async job to this context.
Takes an Async object or the arguments to construct an Async
object as arguments. Returns the newly added Async object.
def add(self, target, args=None, kwargs=None, **options):
"""Add an Async job to this context.
Takes an Async object or the argume... |
Load and instantiate a Context from the persistence_engine.
def load(cls, context_id, persistence_engine=None):
"""Load and instantiate a Context from the persistence_engine."""
if not persistence_engine:
from furious.config import get_default_persistence_engine
persistence_engi... |
Return this Context as a dict suitable for json encoding.
def to_dict(self):
"""Return this Context as a dict suitable for json encoding."""
import copy
options = copy.deepcopy(self._options)
if self._insert_tasks:
options['insert_tasks'] = reference_to_path(self._insert_t... |
Return a context job from a dict output by Context.to_dict.
def from_dict(cls, context_options_dict):
"""Return a context job from a dict output by Context.to_dict."""
import copy
context_options = copy.deepcopy(context_options_dict)
tasks_inserted = context_options.pop('_tasks_insert... |
Return the context result object pulled from the persistence_engine
if it has been set.
def result(self):
"""Return the context result object pulled from the persistence_engine
if it has been set.
"""
if not self._result:
if not self._persistence_engine:
... |
Insert a batch of tasks into a specific queue. If a
DuplicateTaskNameError is raised, loop through the tasks and insert the
remaining, ignoring and logging the duplicate tasks.
Returns the number of successfully inserted tasks.
def insert_tasks_ignore_duplicate_names(tasks, queue, *args, **kwargs):
"... |
This is the callback that is run once the Async task is finished. It
takes the output from grep and logs it.
def log_results():
"""This is the callback that is run once the Async task is finished. It
takes the output from grep and logs it."""
from furious.context import get_current_async
# Get the... |
This function will create and then start a new Async task with the
default callbacks argument defined in the decorator.
def build_and_start(query, directory):
"""This function will create and then start a new Async task with the
default callbacks argument defined in the decorator."""
Async(target=grep... |
This function performs the actual grep on a given file.
def grep_file(query, item):
"""This function performs the actual grep on a given file."""
return ['%s: %s' % (item, line) for line in open(item)
if re.search(query, line)] |
This function will search through the directory structure of the
application and for each directory it finds it launches an Async task to
run itself. For each .py file it finds, it actually greps the file and then
returns the found output.
def grep(query, directory):
"""This function will search throug... |
Get the module specified by the value of option_name. The value of the
configuration option will be used to load the module by name from the known
module list or treated as a path if not found in known_modules.
Args:
option_name: name of persistence module
known_modules: dictionary of module... |
Traverse directory trees to find a furious.yaml file
Begins with the location of this file then checks the
working directory if not found
Args:
config_file: location of this file, override for
testing
Returns:
the path of furious.yaml or None if not found
def find_furious_yaml... |
Traverse the directory tree identified by start
until a directory already in checked is encountered or the path
of furious.yaml is found.
Checked is present both to make the loop termination easy
to reason about and so the same directories do not get
rechecked
Args:
start: the path to ... |
Open and return the yaml contents.
def _load_yaml_config(path=None):
"""Open and return the yaml contents."""
furious_yaml_path = path or find_furious_yaml()
if furious_yaml_path is None:
logging.debug("furious.yaml not found.")
return None
with open(furious_yaml_path) as yaml_file:
... |
Gets the configuration from the found furious.yaml
file and parses the data.
Returns:
a dictionary parsed from the yaml file
def _parse_yaml_config(config_data=None):
"""
Gets the configuration from the found furious.yaml
file and parses the data.
Returns:
a dictionary parsed fr... |
Minimizing of joins.
Left/right and inner join of the same condition is only inner join.
def _minimize_joins(self):
"""
Minimizing of joins.
Left/right and inner join of the same condition is only inner join.
"""
joins_group = []
for join in self._joins:
... |
Executes node content as python module and adds its definitions to globals
def run_code(node: Code, parent_node: Node = None, node_globals: InheritedDict = None, **args): #pylint: disable=unused-argument
'''Executes node content as python module and adds its definitions to globals'''
if not node.xml_node.text:... |
Merge two mappings objects together, combining overlapping Mappings,
and favoring right-values
left: The left Mapping object.
right: The right (favored) Mapping object.
NOTE: This is not commutative (merge(a,b) != merge(b,a)).
def merge(left, right):
"""
Merge two mappings objects together, c... |
A standardized constructor.
def _constructor(cls, mapping, configuration):
"""
A standardized constructor.
"""
sequence_type, default_factory, pass_key = configuration
return cls(default_factory, mapping, sequence_type=sequence_type,
pass_key=pass_key) |
A standardized constructor.
def _constructor(cls, mapping, configuration):
"""
A standardized constructor.
"""
attr = cls(mapping)
attr._setattr('_sequence_type', configuration)
return attr |
PELT algorithm to compute changepoints in time series
Ported from:
https://github.com/STOR-i/Changepoints.jl
https://github.com/rkillick/changepoint/
Reference:
Killick R, Fearnhead P, Eckley IA (2012) Optimal detection
of changepoints with a linear computational cost, JASA
... |
Creates a segment cost function for a time series with a
Normal distribution with changing mean
Args:
data (:obj:`list` of float): 1D time series data
variance (float): variance
Returns:
function: Function with signature
(int, int) -> float
where the firs... |
Creates a segment cost function for a time series with a
Normal distribution with changing variance
Args:
data (:obj:`list` of float): 1D time series data
variance (float): variance
Returns:
function: Function with signature
(int, int) -> float
where the ... |
Creates a segment cost function for a time series with a
Normal distribution with changing mean and variance
Args:
data (:obj:`list` of float): 1D time series data
Returns:
function: Function with signature
(int, int) -> float
where the first arg is the starting ... |
Creates a segment cost function for a time series with a
poisson distribution with changing mean
Args:
data (:obj:`list` of float): 1D time series data
Returns:
function: Function with signature
(int, int) -> float
where the first arg is the starting index, and t... |
Creates a segment cost function for a time series with a
exponential distribution with changing mean
Args:
data (:obj:`list` of float): 1D time series data
Returns:
function: Function with signature
(int, int) -> float
where the first arg is the starting index, a... |
Find the min and max values for the OID field.
def _get_layer_min_max(self, oid_field_name):
""" Find the min and max values for the OID field. """
query_args = self._build_query_args({
'f': 'json',
'outFields': '',
'outStatistics': json.dumps([
dict(... |
Determine if polygon ring coordinates are clockwise. Clockwise signifies
outer ring, counter-clockwise an inner ring or hole. this logic was found
at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-points-are-in-clockwise-order
this code taken from http://esri.github.com/geo... |
Take a date as either a datetime.date/datetime or a string and return it as a iso8601 formatted value
:param Union[datetime.date, datetime.datetime] date_element: passed argument
:rtype str
:return:
def format_date_argument(date_element):
"""
Take a date as either a datetime.date/datetime or a stri... |
Makes a URL from component parts
def make_url(*args, **kwargs):
"""Makes a URL from component parts"""
base = "/".join(args)
if kwargs:
return "%s?%s" % (base, urlencode(kwargs))
else:
return base |
Get additional keyword arguments
def _querystring(self):
"""Get additional keyword arguments"""
kw = {}
for key in self.KNOWN_QUERY_OPTIONS:
val = getattr(self, key)
if val is not None:
kw[key] = val
return kw |
Additional keyword arguments
def _querystring(self):
"""Additional keyword arguments"""
kw = {}
if self.status:
kw["status"] = "all"
if self.links:
kw["links"] = "all"
if self.include is not None:
kw["include"] = self.include
if self... |
Qualify the dataset_name with the dataset_format if supplied
:return: dataset name
:rtype: str
def dataset(self):
"""
Qualify the dataset_name with the dataset_format if supplied
:return: dataset name
:rtype: str
"""
if self.dataset_format:
re... |
Ensure dataset format is XML or CSV
:param str ds_format: Format of the Dataset (expected to be one of `csv` or `xml`)
def check_dataset_format(ds_format):
"""
Ensure dataset format is XML or CSV
:param str ds_format: Format of the Dataset (expected to be one of `csv` or `xml`)
"""
if ds_form... |
Get the preferred Dataset format extension
:param str ds_format: Format of the Dataset (expected to be one of `csv` or `xml`)
:rtype: str
def dataset_format_to_extension(ds_format):
"""
Get the preferred Dataset format extension
:param str ds_format: Format of the Dataset (expected to be one of `... |
Call rwscmd_getdata custom dataset to retrieve currently enterable, empty fields
def get_data(ctx, study, environment, subject):
"""
Call rwscmd_getdata custom dataset to retrieve currently enterable, empty fields
"""
cfg = GetDataConfigurableDataset(GET_DATA_DATASET,
... |
Make request to RWS
def rws_call(ctx, method, default_attr=None):
"""Make request to RWS"""
try:
response = ctx.obj['RWS'].send_request(method)
if ctx.obj['RAW']: # use response from RWS
result = ctx.obj['RWS'].last_result.text
elif default_attr is not None: # human-reada... |
List EDC data for [STUDY] [ENV] [SUBJECT]
def data(ctx, path):
"""List EDC data for [STUDY] [ENV] [SUBJECT]"""
_rws = partial(rws_call, ctx)
if len(path) == 0:
_rws(ClinicalStudiesRequest(), default_attr='oid')
elif len(path) == 1:
_rws(StudySubjectsRequest(path[0], 'Prod'), default_att... |
Post ODM clinical data
def post(ctx, odm):
"""Post ODM clinical data"""
try:
ctx.obj['RWS'].send_request(PostDataRequest(odm.read()))
if ctx.obj['RAW']:
click.echo(ctx.obj['RWS'].last_result.text)
except RWSException as e:
click.echo(e.message) |
List metadata for [PROJECT] [VERSION]
def metadata(ctx, drafts, path):
"""List metadata for [PROJECT] [VERSION]"""
_rws = partial(rws_call, ctx)
if len(path) == 0:
_rws(MetadataStudiesRequest(), default_attr='oid')
elif len(path) == 1:
if drafts:
_rws(StudyDraftsRequest(path... |
Make direct call to RWS, bypassing rwslib
def direct(ctx, path):
"""Make direct call to RWS, bypassing rwslib"""
try:
url = make_url(ctx.obj['RWS'].base_url, path)
resp = requests.get(url, auth=HTTPBasicAuth(ctx.obj['USERNAME'], ctx.obj['PASSWORD']))
click.echo(resp.text)
except RWS... |
Request enterable data for a subject, generate data values and post back to Rave.
Requires 'rwscmd_getdata' configurable dataset to be installed on the Rave URL.
def autofill(ctx, steps, metadata, fixed, study, environment, subject):
"""Request enterable data for a subject, generate data values and post back t... |
Build XML by appending to builder
def build(self, builder):
"""Build XML by appending to builder"""
params = dict(OID=self.oid)
params["mdsol:ProjectType"] = self.project_type
builder.start("Study", params)
# Ask children
if self.global_variables is not None:
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.