text stringlengths 81 112k |
|---|
Renders a markdown file with support for Jinja2 templating. Any keyword
arguments will be passed to Jinja2 for templating prior to rendering the
markdown to HTML for display within the notebook.
:param source:
A string of markdown text that should be rendered to HTML for
notebook display.
... |
Creates a list of non-python data files to include in package distribution
def populate_extra_files():
"""
Creates a list of non-python data files to include in package distribution
"""
out = ['cauldron/settings.json']
for entry in glob.iglob('cauldron/resources/examples/**/*', recursive=True):
... |
Creates a STEP_RENAME for the given ProjectStep instance
:param step:
The ProjectStep instance for which the STEP_RENAME will be created
:param insertion_index:
An optional index where a step will be inserted as part of this
renaming process. Allows files to be renamed prior to the inse... |
:param project:
:param insert_index:
def synchronize_step_names(
project: 'projects.Project',
insert_index: int = None
) -> Response:
"""
:param project:
:param insert_index:
"""
response = Response()
response.returned = dict()
if not project.naming_scheme:
ret... |
Assembles a fully-resolved remote connection URL from the given endpoint
and remote_connection structure. If the remote_connection is omitted, the
global remote_connection object stored in the environ module will be
used in its place.
:param endpoint:
The endpoint for the API call
:param re... |
Returns a Cauldron response object parsed from the serialized JSON data
specified in the http_response argument. If the response doesn't contain
valid Cauldron response data, an error Cauldron response object is
returned instead.
:param http_response:
The response object from an http request th... |
Sends a request to the remote kernel specified by the RemoteConnection
object and processes the result. If the request fails or times out it
will be retried until the max retries is reached. After that a failed
response will be returned instead.
:param endpoint:
Remote endpoint where the reques... |
Retrieves the contents of the file specified by the view route if it
exists.
def view(route: str):
"""
Retrieves the contents of the file specified by the view route if it
exists.
"""
project = cauldron.project.get_internal_project()
results_path = project.results_path if project else None
... |
Computes the file write list for the current state of the project if no
write_list was specified in the arguments, and then writes each entry in
that list to disk.
:param project:
The project to be saved
:param write_list:
The file writes list for the project if one already exists, or N... |
Returns a list containing the file/directory writes that should be executed
to deploy the project assets to the results folder. If the project has no
assets an empty list is returned.
:param project:
The project for which the assets should be copied
:return:
A list containing the file c... |
Adds the path to the Python system path if not already added and the path
exists.
:param path:
The path to add to the system paths
:return:
Whether or not the path was added. Only returns False if the path was
not added because it doesn't exist
def add_library_path(path: str) -> bo... |
Removes the path from the Python system path if it is found in the system
paths.
:param path:
The path to remove from the system paths
:return:
Whether or not the path was removed.
def remove_library_path(path: str) -> bool:
"""
Removes the path from the Python system path if it is... |
...
def close():
"""..."""
os.chdir(os.path.expanduser('~'))
project = cauldron.project.internal_project
if not project:
return False
[remove_library_path(path) for path in project.library_directories]
remove_library_path(project.source_directory)
cauldron.project.unload()
ret... |
Reload the libraries stored in the project's local and shared library
directories
def reload_libraries(library_directories: list = None):
"""
Reload the libraries stored in the project's local and shared library
directories
"""
directories = library_directories or []
project = cauldron.proj... |
Runs the entire project, writes the results files, and returns the URL to
the report file
:param response:
:param project:
:param starting:
:param force:
:param limit:
:return:
Local URL to the report path
def complete(
response: Response,
project: typing.Union[Proj... |
The number of seconds that has elapsed since the step started running
if the step is still running. Or, if the step has already finished
running, the amount of time that elapsed during the last execution of
the step.
def elapsed_time(self) -> float:
"""
The number of seconds tha... |
A human-readable version of the elapsed time for the last execution
of the step. The value is derived from the `ProjectStep.elapsed_time`
property.
def get_elapsed_timestamp(self) -> str:
"""
A human-readable version of the elapsed time for the last execution
of the step. The va... |
Retrieves the current value of the DOM for the step
def get_dom(self) -> str:
""" Retrieves the current value of the DOM for the step """
if self.is_running:
return self.dumps()
if self.dom is not None:
return self.dom
dom = self.dumps()
self.dom = dom... |
Writes the step information to an HTML-formatted string
def dumps(self) -> str:
"""Writes the step information to an HTML-formatted string"""
code_file_path = os.path.join(
self.project.source_directory,
self.filename
)
code = dict(
filename=self.file... |
A decorator to specify a bunch of exceptions that should be caught
and the job retried. It turns out this comes up with relative frequency
def retry(*excepts):
'''A decorator to specify a bunch of exceptions that should be caught
and the job retried. It turns out this comes up with relative frequency'''
... |
Return an array of job objects that are being tracked
def tracked(self):
'''Return an array of job objects that are being tracked'''
results = json.loads(self.client('track'))
results['jobs'] = [Job(self, **job) for job in results['jobs']]
return results |
Return the paginated jids of jobs tagged with a tag
def tagged(self, tag, offset=0, count=25):
'''Return the paginated jids of jobs tagged with a tag'''
return json.loads(self.client('tag', 'get', tag, offset, count)) |
If no group is provided, this returns a JSON blob of the counts of
the various types of failures known. If a type is provided, returns
paginated job objects affected by that kind of failure.
def failed(self, group=None, start=0, limit=25):
'''If no group is provided, this returns a JSON blob of... |
Return jobs objects for all the jids
def get(self, *jids):
'''Return jobs objects for all the jids'''
if jids:
return [
Job(self.client, **j) for j in
json.loads(self.client('multiget', *jids))]
return [] |
Set the title of the process
def title(cls, message=None):
'''Set the title of the process'''
if message == None:
return getproctitle()
else:
setproctitle('qless-py-worker %s' % message)
logger.info(message) |
Divide up the provided jobs into count evenly-sized groups
def divide(cls, jobs, count):
'''Divide up the provided jobs into count evenly-sized groups'''
jobs = list(zip(*zip_longest(*[iter(jobs)] * count)))
# If we had no jobs to resume, then we get an empty list
jobs = jobs or [()] * ... |
Clean up all the files in a provided path
def clean(cls, path):
'''Clean up all the files in a provided path'''
for pth in os.listdir(path):
pth = os.path.abspath(os.path.join(path, pth))
if os.path.isdir(pth):
logger.debug('Removing directory %s' % pth)
... |
Ensures path exists before yielding, cleans up after
def sandbox(cls, path):
'''Ensures path exists before yielding, cleans up after'''
# Ensure the path exists and is clean
try:
os.makedirs(path)
logger.debug('Making %s' % path)
except OSError:
if no... |
Find all the jobs that we'd previously been working on
def resumable(self):
'''Find all the jobs that we'd previously been working on'''
# First, find the jids of all the jobs registered to this client.
# Then, get the corresponding job objects
jids = self.client.workers[self.client.wor... |
Generator for all the jobs
def jobs(self):
'''Generator for all the jobs'''
# If we should resume work, then we should hand those out first,
# assuming we can still heartbeat them
for job in self.resume:
try:
if job.heartbeat():
yield job
... |
Listen for pubsub messages relevant to this worker in a thread
def listener(self):
'''Listen for pubsub messages relevant to this worker in a thread'''
channels = ['ql:w:' + self.client.worker_name]
listener = Listener(self.client.redis, channels)
thread = threading.Thread(target=self.l... |
Listen for events that affect our ownership of a job
def listen(self, listener):
'''Listen for events that affect our ownership of a job'''
for message in listener.listen():
try:
data = json.loads(message['data'])
if data['event'] in ('canceled', 'lock_lost',... |
Register our signal handler
def signals(self, signals=('QUIT', 'USR1', 'USR2')):
'''Register our signal handler'''
for sig in signals:
signal.signal(getattr(signal, 'SIG' + sig), self.handler) |
Signal handler for this process
def handler(self, signum, frame): # pragma: no cover
'''Signal handler for this process'''
if signum == signal.SIGQUIT:
# QUIT - Finish processing, but don't do any more work after that
self.stop()
elif signum == signal.SIGUSR1:
... |
This function will truncate the values of Entry.title so they are
255 characters or less.
def truncate_entry_titles(apps, schema_editor):
"""This function will truncate the values of Entry.title so they are
255 characters or less.
"""
Entry = apps.get_model("andablog", "Entry")
for entry in En... |
Process a job
def process(self, job):
'''Process a job'''
sandbox = self.sandboxes.pop(0)
try:
with Worker.sandbox(sandbox):
job.sandbox = sandbox
job.process()
finally:
# Delete its entry from our greenlets mapping
sel... |
Stop the greenlet processing the provided jid
def kill(self, jid):
'''Stop the greenlet processing the provided jid'''
greenlet = self.greenlets.get(jid)
if greenlet is not None:
logger.warn('Lost ownership of %s' % jid)
greenlet.kill() |
Work on jobs
def run(self):
'''Work on jobs'''
# Register signal handlers
self.signals()
# Start listening
with self.listener():
try:
generator = self.jobs()
while not self.shutdown:
self.pool.wait_available()
... |
Initialize a postgresql connection by each connection string
defined in the configuration file
def init_db_conn(connection_name, connection_string, scopefunc=None):
"""
Initialize a postgresql connection by each connection string
defined in the configuration file
"""
engine = create_engine(conn... |
If postgresql url is defined in configuration params a
scoped session will be created
def initialize(g, app):
"""
If postgresql url is defined in configuration params a
scoped session will be created
"""
if 'DATABASES' in app.config and 'POSTGRESQL' in app.config['DATABASES']:
# Databas... |
Loads extensions
def load_extensions_from_config(**config):
"""
Loads extensions
"""
extensions = []
if 'EXTENSIONS' in config:
for ext in config['EXTENSIONS']:
try:
extensions.append(locate(ext))
except Exception as e:
print(e)
re... |
Appends request object to the globals dict
def set_request(self, r):
"""
Appends request object to the globals dict
"""
for k in self.environments.keys():
self.environments[k].globals['REQUEST'] = r |
Initialize a redis connection by each connection string
defined in the configuration file
def init_db_conn(connection_name, HOSTS=None):
"""
Initialize a redis connection by each connection string
defined in the configuration file
"""
el = elasticsearch.Elasticsearch(hosts=HOSTS)
el_pool.co... |
Tags can be in the forma key:value or simply value
def parse_tags(targs):
"""
Tags can be in the forma key:value or simply value
"""
tags = {}
for t in targs:
split_tag = t.split(':')
if len(split_tag) > 1:
tags['tag:' + split_tag[0]] = split_tag[1]
else:
... |
To set flask to inject specific headers on response request,
such as CORS_ORIGIN headers
def json_response(self, status=200, data={}, headers={}):
'''
To set flask to inject specific headers on response request,
such as CORS_ORIGIN headers
'''
mimetype = 'applicati... |
Constructs a response, allowing custom template name and content_type
def template_response(self, template_name, headers={}, **values):
"""
Constructs a response, allowing custom template name and content_type
"""
response = make_response(
self.render_template(template_name,... |
Returns all key pairs for region
def describe_key_pairs():
"""
Returns all key pairs for region
"""
region_keys = {}
for r in boto3.client('ec2', 'us-west-2').describe_regions()['Regions']:
region = r['RegionName']
client = boto3.client('ec2', region_name=region)
try:
... |
Initalize an app, call this method once from start_app
def init_app(module, BASE_DIR, **kwargs):
"""
Initalize an app, call this method once from start_app
"""
global app
def init_config():
"""
Load settings module and attach values to the application
config dictionary
... |
execute a console command
def execute_command(cmd, **kwargs):
"""
execute a console command
"""
cmd_dict = {
c: 'flask_philo.commands_flask_philo.' + c for c
in dir(commands_flask_philo) if not c.startswith('_') and c != 'os' # noqa
}
# loading specific app commands
tr... |
Create tables if they don't exist
def syncdb():
"""
Create tables if they don't exist
"""
from flask_philo.db.postgresql.schema import Base
from flask_philo.db.postgresql.orm import BaseModel # noqa
from flask_philo.db.postgresql.connection import get_pool
for conn_name, conn in get_pool(... |
Creates a PasswordHash from the given password.
def new(cls, password, rounds):
"""Creates a PasswordHash from the given password."""
if isinstance(password, str):
password = password.encode('utf8')
value = bcrypt.hashpw(password, bcrypt.gensalt(rounds))
return cls(value) |
Returns a PasswordHash from the given string.
PasswordHash instances or None values will return unchanged.
Strings will be hashed and the resulting PasswordHash returned.
Any other input will result in a TypeError.
def _convert(self, value):
"""Returns a PasswordHash from the given str... |
Initialize a redis connection by each connection string
defined in the configuration file
def init_db_conn(
connection_name, HOST=None, PORT=None, DB=None, PASSWORD=None):
"""
Initialize a redis connection by each connection string
defined in the configuration file
"""
rpool = redis.Con... |
If redis connection parameters are defined in configuration params a
session will be created
def initialize(g, app):
"""
If redis connection parameters are defined in configuration params a
session will be created
"""
if 'DATABASES' in app.config and 'REDIS' in app.config['DATABASES']:
... |
Loads serializer from a request object
def _initialize_from_dict(self, data):
"""
Loads serializer from a request object
"""
self._json = data
self._validate()
for name, value in self._json.items():
if name in self._properties:
if '$ref' in s... |
Loads a model from
def _initialize_from_model(self, model):
"""
Loads a model from
"""
for name, value in model.__dict__.items():
if name in self._properties:
setattr(self, name, value) |
Finds record and update it based in serializer values
def update(self):
"""
Finds record and update it based in serializer values
"""
obj = self.__model__.objects.get_for_update(id=self.id)
for name, value in self.__dict__.items():
if name in self._properties:
... |
Returns a json representation
def to_json(self):
"""
Returns a json representation
"""
data = {}
for k, v in self.__dict__.items():
if not k.startswith('_'):
# values not serializable, should be converted to strings
if isinstance(v, da... |
General information about the operating system.
This is a flag you can pass to `Stats.submit()`.
def OPERATING_SYSTEM(stats, info):
"""General information about the operating system.
This is a flag you can pass to `Stats.submit()`.
"""
info.append(('architecture', platform.machine().lower()))
... |
Total time of this session.
Reports the time elapsed from the construction of the `Stats` object to
this `submit()` call.
This is a flag you can pass to `Stats.submit()`.
def SESSION_TIME(stats, info):
"""Total time of this session.
Reports the time elapsed from the construction of the `Stats` o... |
Python interpreter version.
This is a flag you can pass to `Stats.submit()`.
def PYTHON_VERSION(stats, info):
"""Python interpreter version.
This is a flag you can pass to `Stats.submit()`.
"""
# Some versions of Python have a \n in sys.version!
version = sys.version.replace(' \n', ' ').repla... |
Reads the configuration.
This method can be overloaded to integrate with your application's own
configuration mechanism. By default, a single 'status' file is read
from the reports' directory.
This should set `self.status` to one of the state constants, and make
sure `self.loca... |
Writes the configuration.
This method can be overloaded to integrate with your application's own
configuration mechanism. By default, a single 'status' file is written
in the reports' directory, containing either ``ENABLED`` or
``DISABLED``; if the file doesn't exist, `UNSET` is assumed... |
Call this method to explicitly enable reporting.
The current report will be uploaded, plus the previously recorded ones,
and the configuration will be updated so that future runs also upload
automatically.
def enable_reporting(self):
"""Call this method to explicitly enable reporting.
... |
Call this method to explicitly disable reporting.
The current report will be discarded, along with the previously
recorded ones that haven't been uploaded. The configuration is updated
so that future runs do not record or upload reports.
def disable_reporting(self):
"""Call this method... |
Record some info to the report.
:param info: Dictionary of info to record. Note that previous info
recorded under the same keys will not be overwritten.
def note(self, info):
"""Record some info to the report.
:param info: Dictionary of info to record. Note that previous info
... |
Finish recording and upload or save the report.
This closes the `Stats` object, no further methods should be called.
The report is either saved, uploaded or discarded, depending on
configuration. If uploading is enabled, previous reports might be
uploaded too. If uploading is not explic... |
Stores the report on disk.
def store(report, address):
"""Stores the report on disk.
"""
now = time.time()
secs = int(now)
msecs = int((now - secs) * 1000)
submitted_date = filename = None # avoids warnings
while True:
submitted_date = '%d.%03d' % (secs, msecs)
filename = '... |
WSGI interface.
def application(environ, start_response):
"""WSGI interface.
"""
def send_response(status, body):
if not isinstance(body, bytes):
body = body.encode('utf-8')
start_response(status, [('Content-Type', 'text/plain'),
('Content-Lengt... |
Read the pin state of an input pin.
Make sure you put the pin in input modus with the IODIR* register or direction_* attribute first.
:Example:
>>> expander = MCP23017I2C(gw)
>>> # Read the logic level on pin B3
>>> expander.read('B3')
False
>>> # Read the logic... |
Read the pin state of a whole port (8 pins)
:Example:
>>> expander = MCP23017I2C(gw)
>>> # Read pin A0-A7 as a int (A0 and A1 are high)
>>> expander.read_port('A')
3
>>> # Read pin B0-B7 as a int (B2 is high)
>>> expander.read_port('B')
4
:param... |
Set the pin state.
Make sure you put the pin in output mode first.
:param pin: The label for the pin to write to. (Ex. A0)
:param value: Boolean representing the new state
def write(self, pin, value):
""" Set the pin state.
Make sure you put the pin in output mode first.
... |
Use a whole port as a bus and write a byte to it.
:param port: Name of the port ('A' or 'B')
:param value: Value to write (0-255)
def write_port(self, port, value):
""" Use a whole port as a bus and write a byte to it.
:param port: Name of the port ('A' or 'B')
:param value: V... |
Upload the changed registers to the chip
This will check which register have been changed since the last sync and send them to the chip.
You need to call this method if you modify one of the register attributes (mcp23017.IODIRA for example) or
if you use one of the helper attributes (mcp23017.d... |
Get a list containing references to all 16 pins of the chip.
:Example:
>>> expander = MCP23017I2C(gw)
>>> pins = expander.get_pins()
>>> pprint.pprint(pins)
[<GPIOPin A0 on MCP23017I2C>,
<GPIOPin A1 on MCP23017I2C>,
<GPIOPin A2 on MCP23017I2C>,
<GPIOP... |
Get the logic input level for the pin
:return: True if the input is high
def read(self):
""" Get the logic input level for the pin
:return: True if the input is high
"""
m = getattr(self.chip, self.method)
return m(**self.arguments) |
Set the logic output level for the pin.
:type value: bool
:param value: True for a logic high
def write(self, value):
""" Set the logic output level for the pin.
:type value: bool
:param value: True for a logic high
"""
if self.inverted:
value = not... |
Initialize application object.
:param app: An instance of :class:`~flask.Flask`.
def init_app(self, app, **kwargs):
"""Initialize application object.
:param app: An instance of :class:`~flask.Flask`.
"""
self.init_config(app)
# Initialize extensions
self.menu_... |
Initialize configuration.
:param app: An instance of :class:`~flask.Flask`.
def init_config(self, app):
"""Initialize configuration.
:param app: An instance of :class:`~flask.Flask`.
"""
_vars = ['BASE_TEMPLATE', 'COVER_TEMPLATE', 'SETTINGS_TEMPLATE']
# Sets RequireJS... |
Set the measurement range for the accel and gyro MEMS. Higher range means less resolution.
:param accel: a RANGE_ACCEL_* constant
:param gyro: a RANGE_GYRO_* constant
:Example:
.. code-block:: python
sensor = MPU6050I2C(gateway_class_instance)
sensor.set_range... |
Put the aux i2c bus on the MPU-6050 in bypass mode, thus connecting it to the main i2c bus directly
Dont forget to use wakeup() or else the slave bus is unavailable
:param enable:
:return:
def set_slave_bus_bypass(self, enable):
"""Put the aux i2c bus on the MPU-6050 in bypass mode, th... |
Read the value for the internal temperature sensor.
:returns: Temperature in degree celcius as float
:Example:
>>> sensor = MPU6050I2C(gw)
>>> sensor.wakeup()
>>> sensor.temperature()
49.38
def temperature(self):
"""Read the value for the internal temperature ... |
Return the acceleration in G's
:returns: Acceleration for every axis as a tuple
:Example:
>>> sensor = MPU6050I2C(gw)
>>> sensor.wakeup()
>>> sensor.acceleration()
(0.6279296875, 0.87890625, 1.1298828125)
def acceleration(self):
"""Return the acceleration in G... |
Return the angular rate for every axis in degree/second.
:returns: Angular rate for every axis as a tuple
:Example:
>>> sensor = MPU6050I2C(gw)
>>> sensor.wakeup()
>>> sensor.angular_rate()
(1.380859375, 1.6318359375, 1.8828125)
def angular_rate(self):
"""Retu... |
Create strings from lazy strings.
def _get_contents(self):
"""Create strings from lazy strings."""
return [
str(value) if is_lazy_string(value) else value
for value in super(LazyNpmBundle, self)._get_contents()
] |
Load factory calibration data from device.
def load_calibration(self):
"""Load factory calibration data from device."""
registers = self.i2c_read_register(0xAA, 22)
(
self.cal['AC1'],
self.cal['AC2'],
self.cal['AC3'],
self.cal['AC4'],
... |
Get the temperature from the sensor.
:returns: The temperature in degree celcius as a float
:example:
>>> sensor = BMP180(gw)
>>> sensor.load_calibration()
>>> sensor.temperature()
21.4
def temperature(self):
"""Get the temperature from the sensor.
:r... |
Get barometric pressure in milibar
:returns: The pressure in milibar as a int
:example:
>>> sensor = BMP180(gw)
>>> sensor.load_calibration()
>>> sensor.pressure()
75216
def pressure(self):
"""
Get barometric pressure in milibar
:returns: The ... |
Explicitly switch the Bus Pirate mode
:param new_mode: The mode to switch to. Use the buspirate.MODE_* constants
def switch_mode(self, new_mode):
""" Explicitly switch the Bus Pirate mode
:param new_mode: The mode to switch to. Use the buspirate.MODE_* constants
"""
packet = b... |
Set the peripheral config at runtime.
If a parameter is None then the config will not be changed.
:param power: Set to True to enable the power supply or False to disable
:param pullup: Set to True to enable the internal pull-up resistors. False to disable
:param aux: Set the AUX pin ou... |
Set I2C speed to one of '400kHz', '100kHz', 50kHz', '5kHz'
def _set_i2c_speed(self, i2c_speed):
""" Set I2C speed to one of '400kHz', '100kHz', 50kHz', '5kHz'
"""
lower_bits_mapping = {
'400kHz': 3,
'100kHz': 2,
'50kHz': 1,
'5kHz': 0,
}
... |
Set the base config for sensor
:param averaging: Sets the numer of samples that are internally averaged
:param datarate: Datarate in hertz
:param mode: one of the MODE_* constants
def config(self, averaging=1, datarate=15, mode=MODE_NORMAL):
"""
Set the base config for sensor
... |
Set the resolution of the sensor
The resolution value is the amount of steps recorded in a single Gauss. The possible options are:
======================= ========== =============
Recommended Gauss range Resolution Gauss per bit
======================= ========== =============
... |
Get the magnetometer values as gauss for each axis as a tuple (x,y,z)
:example:
>>> sensor = HMC5883L(gw)
>>> sensor.gauss()
(16.56, 21.2888, 26.017599999999998)
def gauss(self):
"""
Get the magnetometer values as gauss for each axis as a tuple (x,y,z)
:exampl... |
Get the temperature in degree celcius
def temperature(self):
""" Get the temperature in degree celcius
"""
result = self.i2c_read(2)
value = struct.unpack('>H', result)[0]
if value < 32768:
return value / 256.0
else:
return (value - 65536) / 256.... |
Display a single character on the display
:type char: str or int
:param char: Character to display
def write(self, char):
""" Display a single character on the display
:type char: str or int
:param char: Character to display
"""
char = str(char).lower()
... |
Get the absolute path of the directory containing the theme files.
def get_html_theme_path():
"""
Get the absolute path of the directory containing the theme files.
"""
return os.path.abspath(os.path.dirname(os.path.dirname(__file__))) |
Create a URL for feedback on a particular page in a project.
def feedback_form_url(project, page):
"""
Create a URL for feedback on a particular page in a project.
"""
return FEEDBACK_FORM_FMT.format(pageid=quote("{}: {}".format(project, page))) |
Update the page rendering context to include ``feedback_form_url``.
def update_context(app, pagename, templatename, context, doctree): # pylint: disable=unused-argument
"""
Update the page rendering context to include ``feedback_form_url``.
"""
context['feedback_form_url'] = feedback_form_url(app.conf... |
Sphinx extension to update the rendering context with the feedback form URL.
Arguments:
app (Sphinx): Application object for the Sphinx process
Returns:
a dictionary of metadata (http://www.sphinx-doc.org/en/stable/extdev/#extension-metadata)
def setup(app):
"""
Sphinx extension to up... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.