text stringlengths 81 112k |
|---|
Returns the top post from the provided section
def top_post(section: hug.types.one_of(('news', 'newest', 'show'))='news'):
"""Returns the top post from the provided section"""
content = requests.get('https://news.ycombinator.com/{0}'.format(section)).content
text = content.decode('utf-8')
return text.s... |
A decorator that allows you to override the default output format for an API
def default_output_format(content_type='application/json', apply_globally=False, api=None, cli=False, http=True):
"""A decorator that allows you to override the default output format for an API"""
def decorator(formatter):
for... |
A decorator that allows you to override the default output format for an API
def default_input_format(content_type='application/json', apply_globally=False, api=None):
"""A decorator that allows you to override the default output format for an API"""
def decorator(formatter):
formatter = hug.output_for... |
A decorator that registers a single hug directive
def directive(apply_globally=False, api=None):
"""A decorator that registers a single hug directive"""
def decorator(directive_method):
if apply_globally:
hug.defaults.directives[underscore(directive_method.__name__)] = directive_method
... |
A decorator that registers a single hug context factory
def context_factory(apply_globally=False, api=None):
"""A decorator that registers a single hug context factory"""
def decorator(context_factory_):
if apply_globally:
hug.defaults.context_factory = context_factory_
else:
... |
A decorator that registers a single hug delete context function
def delete_context(apply_globally=False, api=None):
"""A decorator that registers a single hug delete context function"""
def decorator(delete_context_):
if apply_globally:
hug.defaults.delete_context = delete_context_
... |
Runs the provided function on startup, passing in an instance of the api
def startup(api=None):
"""Runs the provided function on startup, passing in an instance of the api"""
def startup_wrapper(startup_function):
apply_to_api = hug.API(api) if api else hug.api.from_object(startup_function)
app... |
Registers a middleware function that will be called on every request
def request_middleware(api=None):
"""Registers a middleware function that will be called on every request"""
def decorator(middleware_method):
apply_to_api = hug.API(api) if api else hug.api.from_object(middleware_method)
cla... |
Registers a middleware function that will be called on every response
def response_middleware(api=None):
"""Registers a middleware function that will be called on every response"""
def decorator(middleware_method):
apply_to_api = hug.API(api) if api else hug.api.from_object(middleware_method)
... |
Registers a middleware function that will be called on every request and response
def reqresp_middleware(api=None):
"""Registers a middleware function that will be called on every request and response"""
def decorator(middleware_generator):
apply_to_api = hug.API(api) if api else hug.api.from_object(mi... |
Registers a middleware class
def middleware_class(api=None):
"""Registers a middleware class"""
def decorator(middleware_class):
apply_to_api = hug.API(api) if api else hug.api.from_object(middleware_class)
apply_to_api.http.add_middleware(middleware_class())
return middleware_class
... |
Extends the current api, with handlers from an imported api. Optionally provide a route that prefixes access
def extend_api(route="", api=None, base_url="", **kwargs):
"""Extends the current api, with handlers from an imported api. Optionally provide a route that prefixes access"""
def decorator(extend_with):
... |
Enables building decorators around functions used for hug routes without changing their function signature
def wraps(function):
"""Enables building decorators around functions used for hug routes without changing their function signature"""
def wrap(decorator):
decorator = functools.wraps(function)(dec... |
Modifies the provided function to support kwargs by only passing along kwargs for parameters it accepts
def auto_kwargs(function):
"""Modifies the provided function to support kwargs by only passing along kwargs for parameters it accepts"""
supported = introspect.arguments(function)
@wraps(function)
d... |
Get time from a locally running NTP server
def get_time():
"""Get time from a locally running NTP server"""
time_request = '\x1b' + 47 * '\0'
now = struct.unpack("!12I", ntp_service.request(time_request, timeout=5.0).data.read())[10]
return time.ctime(now - EPOCH_START) |
Simple reverse http proxy function that returns data/html from another http server (via sockets)
only drawback is the peername is static, and currently does not support being changed.
Example: curl localhost:8000/reverse_http_proxy?length=400
def reverse_http_proxy(length: int=100):
"""Simple reverse http ... |
Validation only succeeds if all passed in validators return no errors
def all(*validators):
"""Validation only succeeds if all passed in validators return no errors"""
def validate_all(fields):
for validator in validators:
errors = validator(fields)
if errors:
re... |
If any of the specified validators pass the validation succeeds
def any(*validators):
"""If any of the specified validators pass the validation succeeds"""
def validate_any(fields):
errors = {}
for validator in validators:
validation_errors = validator(fields)
if not val... |
Enables ensuring that one of multiple optional fields is set
def contains_one_of(*fields):
"""Enables ensuring that one of multiple optional fields is set"""
message = 'Must contain any one of the following fields: {0}'.format(', '.join(fields))
def check_contains(endpoint_fields):
for field in fi... |
Adds additional requirements to the specified route
def requires(self, requirements, **overrides):
"""Adds additional requirements to the specified route"""
return self.where(requires=tuple(self.route.get('requires', ())) + tuple(requirements), **overrides) |
Removes individual requirements while keeping all other defined ones within a route
def doesnt_require(self, requirements, **overrides):
"""Removes individual requirements while keeping all other defined ones within a route"""
return self.where(requires=tuple(set(self.route.get('requires', ())).differe... |
Creates a new route, based on the current route, with the specified overrided values
def where(self, **overrides):
"""Creates a new route, based on the current route, with the specified overrided values"""
route_data = self.route.copy()
route_data.update(overrides)
return self.__class__... |
Sets the route to raise validation errors instead of catching them
def raise_on_invalid(self, setting=True, **overrides):
"""Sets the route to raise validation errors instead of catching them"""
return self.where(raise_on_invalid=setting, **overrides) |
Tells hug to automatically parse the input body if it matches a registered input format
def parse_body(self, automatic=True, **overrides):
"""Tells hug to automatically parse the input body if it matches a registered input format"""
return self.where(parse_body=automatic, **overrides) |
Adds the specified response headers while keeping existing ones in-tact
def add_response_headers(self, headers, **overrides):
"""Adds the specified response headers while keeping existing ones in-tact"""
response_headers = self.route.get('response_headers', {}).copy()
response_headers.update(he... |
Convenience method for quickly adding cache header to route
def cache(self, private=False, max_age=31536000, s_maxage=None, no_cache=False, no_store=False,
must_revalidate=False, **overrides):
"""Convenience method for quickly adding cache header to route"""
parts = ('private' if private ... |
Convenience method for quickly allowing other resources to access this one
def allow_origins(self, *origins, methods=None, max_age=None, credentials=None, headers=None, **overrides):
"""Convenience method for quickly allowing other resources to access this one"""
response_headers = {}
if origin... |
Sets the acceptable HTTP method to a GET
def get(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to a GET"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='GET', **overrides) |
Sets the acceptable HTTP method to DELETE
def delete(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to DELETE"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='DELETE', **overrides) |
Sets the acceptable HTTP method to POST
def post(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to POST"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='POST', **overrides) |
Sets the acceptable HTTP method to PUT
def put(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to PUT"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='PUT', **overrides) |
Sets the acceptable HTTP method to TRACE
def trace(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to TRACE"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='TRACE', **overrides) |
Sets the acceptable HTTP method to PATCH
def patch(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to PATCH"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='PATCH', **overrides) |
Sets the acceptable HTTP method to OPTIONS
def options(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to OPTIONS"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='OPTIONS', **overrides) |
Sets the acceptable HTTP method to HEAD
def head(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to HEAD"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='HEAD', **overrides) |
Sets the acceptable HTTP method to CONNECT
def connect(self, urls=None, **overrides):
"""Sets the acceptable HTTP method to CONNECT"""
if urls is not None:
overrides['urls'] = urls
return self.where(accept='CONNECT', **overrides) |
Creates routes from a class, where the class method names should line up to HTTP METHOD types
def http_methods(self, urls=None, **route_data):
"""Creates routes from a class, where the class method names should line up to HTTP METHOD types"""
def decorator(class_definition):
instance = clas... |
Registers a method on an Object as a CLI route
def cli(self, method):
"""Registers a method on an Object as a CLI route"""
routes = getattr(method, '_hug_cli_routes', [])
routes.append(self.route)
method._hug_cli_routes = routes
return method |
Starts the process of building a new HTTP route linked to this API instance
def http(self, *args, **kwargs):
"""Starts the process of building a new HTTP route linked to this API instance"""
kwargs['api'] = self.api
return http(*args, **kwargs) |
Defines the handler that should handle not found requests against this API
def not_found(self, *args, **kwargs):
"""Defines the handler that should handle not found requests against this API"""
kwargs['api'] = self.api
return not_found(*args, **kwargs) |
Define the routes to static files the API should expose
def static(self, *args, **kwargs):
"""Define the routes to static files the API should expose"""
kwargs['api'] = self.api
return static(*args, **kwargs) |
Define URL prefixes/handler matches where everything under the URL prefix should be handled
def sink(self, *args, **kwargs):
"""Define URL prefixes/handler matches where everything under the URL prefix should be handled"""
kwargs['api'] = self.api
return sink(*args, **kwargs) |
Defines how this API should handle the provided exceptions
def exception(self, *args, **kwargs):
"""Defines how this API should handle the provided exceptions"""
kwargs['api'] = self.api
return exception(*args, **kwargs) |
Defines a CLI function that should be routed by this API
def cli(self, *args, **kwargs):
"""Defines a CLI function that should be routed by this API"""
kwargs['api'] = self.api
return cli(*args, **kwargs) |
Registers a class based router to this API
def object(self, *args, **kwargs):
"""Registers a class based router to this API"""
kwargs['api'] = self.api
return Object(*args, **kwargs) |
Returns a generator of all URLs attached to this API
def urls(self):
"""Returns a generator of all URLs attached to this API"""
for base_url, mapping in self.routes.items():
for url, _ in mapping.items():
yield base_url + url |
Returns all registered handlers attached to this API
def handlers(self):
"""Returns all registered handlers attached to this API"""
used = []
for base_url, mapping in self.routes.items():
for url, methods in mapping.items():
for method, versions in methods.items():
... |
Returns the set input_format handler for the given content_type
def input_format(self, content_type):
"""Returns the set input_format handler for the given content_type"""
return getattr(self, '_input_format', {}).get(content_type, hug.defaults.input_format.get(content_type, None)) |
Sets an input format handler for this Hug API, given the specified content_type
def set_input_format(self, content_type, handler):
"""Sets an input format handler for this Hug API, given the specified content_type"""
if getattr(self, '_input_format', None) is None:
self._input_format = {}
... |
Adds a middleware object used to process all incoming requests against the API
def add_middleware(self, middleware):
"""Adds a middleware object used to process all incoming requests against the API"""
if self.middleware is None:
self._middleware = []
self.middleware.append(middlewa... |
Adds a error handler to the hug api
def add_exception_handler(self, exception_type, error_handler, versions=(None, )):
"""Adds a error handler to the hug api"""
versions = (versions, ) if not isinstance(versions, (tuple, list)) else versions
if not hasattr(self, '_exception_handlers'):
... |
Adds handlers from a different Hug API to this one - to create a single API
def extend(self, http_api, route="", base_url="", **kwargs):
"""Adds handlers from a different Hug API to this one - to create a single API"""
self.versions.update(http_api.versions)
base_url = base_url or self.base_url... |
Sets the not_found handler for the specified version of the api
def set_not_found_handler(self, handler, version=None):
"""Sets the not_found handler for the specified version of the api"""
if not self.not_found_handlers:
self._not_found_handlers = {}
self.not_found_handlers[versio... |
Generates and returns documentation for this API endpoint
def documentation(self, base_url=None, api_version=None, prefix=""):
"""Generates and returns documentation for this API endpoint"""
documentation = OrderedDict()
base_url = self.base_url if base_url is None else base_url
overvie... |
Runs the basic hug development server against this API
def serve(self, host='', port=8000, no_documentation=False, display_intro=True):
"""Runs the basic hug development server against this API"""
if no_documentation:
api = self.server(None)
else:
api = self.server()
... |
Determines the appropriate version given the set api_version, the request header, and URL query params
def determine_version(self, request, api_version=None):
"""Determines the appropriate version given the set api_version, the request header, and URL query params"""
if api_version is False:
... |
Returns a smart 404 page that contains documentation for the written API
def documentation_404(self, base_url=None):
"""Returns a smart 404 page that contains documentation for the written API"""
base_url = self.base_url if base_url is None else base_url
def handle_404(request, response, *args... |
Intelligently routes a request to the correct handler based on the version being requested
def version_router(self, request, response, api_version=None, versions={}, not_found=None, **kwargs):
"""Intelligently routes a request to the correct handler based on the version being requested"""
request_versi... |
Returns a WSGI compatible API server for the given Hug API module
def server(self, default_not_found=True, base_url=None):
"""Returns a WSGI compatible API server for the given Hug API module"""
falcon_api = falcon.API(middleware=self.middleware)
default_not_found = self.documentation_404() if ... |
Extends this CLI api with the commands present in the provided cli_api object
def extend(self, cli_api, command_prefix="", sub_command="", **kwargs):
"""Extends this CLI api with the commands present in the provided cli_api object"""
if sub_command and command_prefix:
raise ValueError('It i... |
Returns all directives applicable to this Hug API
def directives(self):
"""Returns all directives applicable to this Hug API"""
directive_sources = chain(hug.defaults.directives.items(), getattr(self, '_directives', {}).items())
return {'hug_' + directive_name: directive for directive_name, dir... |
Returns the loaded directive with the specified name, or default if passed name is not present
def directive(self, name, default=None):
"""Returns the loaded directive with the specified name, or default if passed name is not present"""
return getattr(self, '_directives', {}).get(name, hug.defaults.di... |
Returns all registered handlers attached to this API
def handlers(self):
"""Returns all registered handlers attached to this API"""
if getattr(self, '_http'):
yield from self.http.handlers()
if getattr(self, '_cli'):
yield from self.cli.handlers() |
Adds handlers from a different Hug API to this one - to create a single API
def extend(self, api, route="", base_url="", http=True, cli=True, **kwargs):
"""Adds handlers from a different Hug API to this one - to create a single API"""
api = API(api)
if http and hasattr(api, '_http'):
... |
Adds a startup handler to the hug api
def add_startup_handler(self, handler):
"""Adds a startup handler to the hug api"""
if not self.startup_handlers:
self._startup_handlers = []
self.startup_handlers.append(handler) |
Marks the API as started and runs all startup handlers
def _ensure_started(self):
"""Marks the API as started and runs all startup handlers"""
if not self.started:
async_handlers = [startup_handler for startup_handler in self.startup_handlers if
introspect.is_c... |
Helper for `WeightDrop`.
def _weight_drop(module, weights, dropout):
"""
Helper for `WeightDrop`.
"""
for name_w in weights:
w = getattr(module, name_w)
del module._parameters[name_w]
module.register_parameter(name_w + '_raw', Parameter(w))
original_module_forward = module... |
Load the IMDB dataset (Large Movie Review Dataset v1.0).
This is a dataset for binary sentiment classification containing substantially more data than
previous benchmark datasets. Provided a set of 25,000 highly polar movie reviews for
training, and 25,000 for testing. There is additional unlabeled data fo... |
Load the Text REtrieval Conference (TREC) Question Classification dataset.
TREC dataset contains 5500 labeled questions in training set and another 500 for test set. The
dataset has 6 labels, 50 level-2 labels. Average length of each sentence is 10, vocabulary size
of 8700.
References:
* https... |
Load the Stanford Natural Language Inference (SNLI) dataset.
The SNLI corpus (version 1.0) is a collection of 570k human-written English sentence pairs
manually labeled for balanced classification with the labels entailment, contradiction, and
neutral, supporting the task of natural language inference (NLI... |
Args:
query (:class:`torch.FloatTensor` [batch size, output length, dimensions]): Sequence of
queries to query the context.
context (:class:`torch.FloatTensor` [batch size, query length, dimensions]): Data
overwhich to apply the attention mechanism.
Retur... |
Load the International Workshop on Spoken Language Translation (IWSLT) 2017 translation dataset.
In-domain training, development and evaluation sets were supplied through the website of the
WIT3 project, while out-of-domain training data were linked in the workshop’s website. With
respect to edition 2016 o... |
Encodes an object.
Args:
object_ (object): Object to encode.
Returns:
object: Encoding of the object.
def encode(self, object_):
""" Encodes an object.
Args:
object_ (object): Object to encode.
Returns:
object: Encoding of the ... |
Args:
batch (list): Batch of objects to encode.
*args: Arguments passed to ``encode``.
**kwargs: Keyword arguments passed to ``encode``.
Returns:
list: Batch of encoded objects.
def batch_encode(self, iterator, *args, **kwargs):
"""
Args:
... |
Decodes an object.
Args:
object_ (object): Encoded object.
Returns:
object: Object decoded.
def decode(self, encoded):
""" Decodes an object.
Args:
object_ (object): Encoded object.
Returns:
object: Object decoded.
"""
... |
Args:
iterator (list): Batch of encoded objects.
*args: Arguments passed to ``decode``.
**kwargs: Keyword arguments passed to ``decode``.
Returns:
list: Batch of decoded objects.
def batch_decode(self, iterator, *args, **kwargs):
"""
Args:
... |
Args:
tokens (:class:`torch.FloatTensor` [batch_size, num_tokens, input_dim]): Sequence
matrix to encode.
mask (:class:`torch.FloatTensor`): Broadcastable matrix to `tokens` used as a mask.
Returns:
(:class:`torch.FloatTensor` [batch_size, output_dim]): Encodi... |
Inverse of _escape_token().
Args:
escaped_token: a unicode string
Returns:
token: a unicode string
def _unescape_token(escaped_token):
"""
Inverse of _escape_token().
Args:
escaped_token: a unicode string
Returns:
token: a unicode string
"""
def match(m):
... |
Converts a list of tokens to a list of subtoken.
Args:
tokens: a list of strings.
Returns:
a list of integers in the range [0, vocab_size)
def _tokens_to_subtoken(self, tokens):
""" Converts a list of tokens to a list of subtoken.
Args:
tokens: a list of ... |
Converts a list of subtoken to a list of tokens.
Args:
subtokens: a list of integers in the range [0, vocab_size)
Returns:
a list of strings.
def _subtoken_to_tokens(self, subtokens):
""" Converts a list of subtoken to a list of tokens.
Args:
subtokens: ... |
Converts an escaped token string to a list of subtoken strings.
Args:
escaped_token: An escaped token as a unicode string.
Returns:
A list of subtokens as unicode strings.
def _escaped_token_to_subtoken_strings(self, escaped_token):
""" Converts an escaped token string to a... |
Builds a SubwordTextTokenizer that has `vocab_size` near `target_size`.
Uses simple recursive binary search to find a minimum token count that most
closely matches the `target_size`.
Args:
target_size: Desired vocab_size to approximate.
token_counts: A dictionary of token c... |
Train a SubwordTextTokenizer based on a dictionary of word counts.
Args:
token_counts: a dictionary of Unicode strings to int.
min_count: an integer - discard subtokens with lower counts.
num_iterations: an integer; how many iterations of refinement.
def build_from_token_counts(s... |
Initialize token information from a list of subtoken strings.
def _init_subtokens_from_list(self, subtoken_strings):
"""Initialize token information from a list of subtoken strings."""
# we remember the maximum length of any subtoken to avoid having to
# check arbitrarily long strings.
... |
Initialize alphabet from an iterable of token or subtoken strings.
def _init_alphabet_from_tokens(self, tokens):
"""Initialize alphabet from an iterable of token or subtoken strings."""
# Include all characters from all tokens in the alphabet to guarantee that
# any token can be encoded. Additi... |
Get the BLEU score using the moses `multi-bleu.perl` script.
**Script:**
https://raw.githubusercontent.com/moses-smt/mosesdecoder/master/scripts/generic/multi-bleu.perl
Args:
hypotheses (list of str): List of predicted values
references (list of str): List of target values
lowercase (boo... |
Load the Universal Dependencies - English Dependency Treebank dataset.
Corpus of sentences annotated using Universal Dependencies annotation. The corpus comprises
254,830 words and 16,622 sentences, taken from various web media including weblogs, newsgroups,
emails, reviews, and Yahoo! answers.
Refere... |
helper function for python 2 and 3 to call os.makedirs()
avoiding an error if the directory to be created already exists
def makedirs(name):
"""helper function for python 2 and 3 to call os.makedirs()
avoiding an error if the directory to be created already exists"""
import os, errno
try:
... |
list of tensors to a batch tensors
def collate_fn(batch, train=True):
""" list of tensors to a batch tensors """
premise_batch, _ = pad_batch([row['premise'] for row in batch])
hypothesis_batch, _ = pad_batch([row['hypothesis'] for row in batch])
label_batch = torch.stack([row['label'] for row in batch... |
Load the Stanford Sentiment Treebank dataset.
Semantic word spaces have been very useful but cannot express the meaning of longer phrases in
a principled way. Further progress towards understanding compositionality in tasks such as
sentiment detection requires richer supervised training and evaluation reso... |
Load the SimpleQuestions dataset.
Single-relation factoid questions (simple questions) are common in many settings
(e.g. Microsoft’s search query logs and WikiAnswers questions). The SimpleQuestions dataset is
one of the most commonly used benchmarks for studying single-relation factoid questions.
**R... |
Args:
x (:class:`torch.FloatTensor` [batch size, sequence length, rnn hidden size]): Input to
apply dropout too.
def forward(self, x):
"""
Args:
x (:class:`torch.FloatTensor` [batch size, sequence length, rnn hidden size]): Input to
apply dropout ... |
Pad a ``tensor`` to ``length`` with ``padding_index``.
Args:
tensor (torch.Tensor [n, ...]): Tensor to pad.
length (int): Pad the ``tensor`` up to ``length``.
padding_index (int, optional): Index to pad tensor with.
Returns
(torch.Tensor [length, ...]) Padded Tensor.
def pad_t... |
Pad a :class:`list` of ``tensors`` (``batch``) with ``padding_index``.
Args:
batch (:class:`list` of :class:`torch.Tensor`): Batch of tensors to pad.
padding_index (int, optional): Index to pad tensors with.
dim (int, optional): Dimension on to which to concatenate the batch of tensors.
... |
Args:
iterator (iterator): Batch of text to encode.
*args: Arguments passed onto ``Encoder.__init__``.
dim (int, optional): Dimension along which to concatenate tensors.
**kwargs: Keyword arguments passed onto ``Encoder.__init__``.
Returns
torch.Tenso... |
Args:
batch (list of :class:`torch.Tensor`): Batch of encoded sequences.
lengths (list of int): Original lengths of sequences.
dim (int, optional): Dimension along which to split tensors.
*args: Arguments passed to ``decode``.
**kwargs: Key word arguments pass... |
Encodes a ``sequence``.
Args:
sequence (str): String ``sequence`` to encode.
Returns:
torch.Tensor: Encoding of the ``sequence``.
def encode(self, sequence):
""" Encodes a ``sequence``.
Args:
sequence (str): String ``sequence`` to encode.
... |
Decodes a tensor into a sequence.
Args:
encoded (torch.Tensor): Encoded sequence.
Returns:
str: Sequence decoded from ``encoded``.
def decode(self, encoded):
""" Decodes a tensor into a sequence.
Args:
encoded (torch.Tensor): Encoded sequence.
... |
``reporthook`` to use with ``urllib.request`` that prints the process of the download.
Uses ``tqdm`` for progress bar.
**Reference:**
https://github.com/tqdm/tqdm
Args:
t (tqdm.tqdm) Progress bar.
Example:
>>> with tqdm(unit='B', unit_scale=True, miniters=1, desc=filename) as t: ... |
Download filename from google drive unless it's already in directory.
Args:
filename (str): Name of the file to download to (do nothing if it already exists).
url (str): URL to download from.
def _download_file_from_drive(filename, url): # pragma: no cover
""" Download filename from google dr... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.