_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q16300 | KATCPClientResourceContainer.set_sampling_strategies | train | def set_sampling_strategies(self, filter, strategy_and_parms):
"""Set sampling strategies for filtered sensors - these sensors have to exsist"""
result_list = yield self.list_sensors(filter=filter)
sensor_dict = {}
for result in result_list:
sensor_name = result.object.normalised_name
resource_name = result.object.parent_name
if resource_name not in sensor_dict:
sensor_dict[resource_name] = {}
try:
resource_obj = self.children[resource_name]
yield resource_obj.set_sampling_strategy(sensor_name, strategy_and_parms)
sensor_dict[resource_name][sensor_name] = strategy_and_parms
| python | {
"resource": ""
} |
q16301 | KATCPClientResourceContainer.add_child_resource_client | train | def add_child_resource_client(self, res_name, res_spec):
"""Add a resource client to the container and start the resource connection"""
res_spec = dict(res_spec)
res_spec['name'] = res_name
res = self.client_resource_factory(
res_spec, parent=self, logger=self._logger)
| python | {
"resource": ""
} |
q16302 | KATCPClientResourceContainer.stop | train | def stop(self):
"""Stop all child resources"""
for child_name, child in dict.items(self.children):
# Catch child exceptions when stopping so we make sure to stop all children | python | {
"resource": ""
} |
q16303 | make_chunk | train | def make_chunk(chunk_type, chunk_data):
"""Create a raw chunk by composing chunk type and data. It
calculates chunk length and CRC for you.
:arg str chunk_type: PNG chunk type.
:arg bytes chunk_data: PNG chunk data, **excluding chunk length, type, and CRC**.
:rtype: bytes
"""
out = | python | {
"resource": ""
} |
q16304 | PNG.init | train | def init(self):
"""Extract some info from chunks"""
for type_, data in self.chunks:
if type_ == "IHDR":
self.hdr = data
elif type_ == "IEND":
self.end = | python | {
"resource": ""
} |
q16305 | readme | train | def readme():
"""Live reload readme"""
from livereload import Server
server = Server()
server.watch("README.rst", | python | {
"resource": ""
} |
q16306 | BenchmarkServer.request_add_sensor | train | def request_add_sensor(self, sock, msg):
""" add a sensor
"""
self.add_sensor(Sensor(int, 'int_sensor%d' % | python | {
"resource": ""
} |
q16307 | normalize_strategy_parameters | train | def normalize_strategy_parameters(params):
"""Normalize strategy parameters to be a list of strings.
Parameters
----------
params : (space-delimited) string or sequence of strings/numbers Parameters
expected by :class:`SampleStrategy` object, in various forms, where the first
parameter is the name of the strategy.
Returns
-------
params : tuple of strings
Strategy parameters as a list of strings
"""
def fixup_numbers(val):
try:
# See if | python | {
"resource": ""
} |
q16308 | KATCPResource.wait | train | def wait(self, sensor_name, condition_or_value, timeout=5):
"""Wait for a sensor in this resource to satisfy a condition.
Parameters
----------
sensor_name : string
The name of the sensor to check
condition_or_value : obj or callable, or seq of objs or callables
If obj, sensor.value is compared with obj. If callable,
condition_or_value(reading) is called, and must return True if its
condition is satisfied. Since the reading is passed in, the value,
status, timestamp or received_timestamp attributes can all be used
in the check.
timeout : float or None
The timeout in seconds (None means wait forever)
Returns
-------
This command returns a tornado Future that resolves with True when the
sensor value satisfies the condition, or False if the condition is
still not satisfied after a given timeout period.
Raises
------ | python | {
"resource": ""
} |
q16309 | KATCPResource.set_sampling_strategies | train | def set_sampling_strategies(self, filter, strategy_and_params):
"""Set a sampling strategy for all sensors that match the specified filter.
Parameters
----------
filter : string
The regular expression filter to use to select the sensors to which
to apply the specified strategy. Use "" to match all sensors. Is
matched using :meth:`list_sensors`.
strategy_and_params : seq of str or str
As tuple contains (<strat_name>, [<strat_parm1>, ...]) where the strategy
names and parameters are as defined by the KATCP spec. As str contains the
same elements in space-separated form.
**list_sensor_args : keyword arguments
Passed to the :meth:`list_sensors` call as kwargs
Returns
-------
sensors_strategies : tornado Future
resolves with a dict with the Python identifier names of the sensors
as keys and the value a tuple:
(success, info) with
sucess : bool
True if setting succeeded for this sensor, else False
info : tuple | python | {
"resource": ""
} |
q16310 | KATCPResource.set_sampling_strategy | train | def set_sampling_strategy(self, sensor_name, strategy_and_params):
"""Set a sampling strategy for a specific sensor.
Parameters
----------
sensor_name : string
The specific sensor.
strategy_and_params : seq of str or str
As tuple contains (<strat_name>, [<strat_parm1>, ...]) where the strategy
names and parameters are as defined by the KATCP spec. As str contains the
same elements in space-separated form.
Returns
-------
sensors_strategies : tornado Future
resolves with a dict with the Python identifier names of the sensors
as keys and the value a tuple:
(success, info) with
sucess : bool
True if setting succeeded for this sensor, else False
info : tuple
normalised sensor strategy and parameters as tuple if success == True
else, sys.exc_info() tuple for the error that occured.
| python | {
"resource": ""
} |
q16311 | KATCPSensor.set_strategy | train | def set_strategy(self, strategy, params=None):
"""Set current sampling strategy for sensor.
Add this footprint for backwards compatibility.
Parameters
----------
strategy : seq of str or str
As tuple contains (<strat_name>, [<strat_parm1>, ...]) where the strategy
names and parameters are as defined by the KATCP spec. As str contains the
same elements in space-separated form.
| python | {
"resource": ""
} |
q16312 | KATCPSensor.register_listener | train | def register_listener(self, listener, reading=False):
"""Add a callback function that is called when sensor value is updated.
The callback footprint is received_timestamp, timestamp, status, value.
Parameters
----------
listener : function
Callback signature: if reading
listener(katcp_sensor, reading) where
`katcp_sensor` is this KATCPSensor instance
`reading` is an instance of :class:`KATCPSensorReading`
Callback signature: default, if not reading
| python | {
"resource": ""
} |
q16313 | KATCPSensor.set_value | train | def set_value(self, value, status=Sensor.NOMINAL, timestamp=None):
"""Set sensor value with optinal specification of status and timestamp"""
if timestamp is None:
| python | {
"resource": ""
} |
q16314 | KATCPSensor.get_reading | train | def get_reading(self):
"""Get a fresh sensor reading from the KATCP resource
Returns
-------
reply : tornado Future resolving with :class:`KATCPSensorReading` object
Note
----
As a side-effect this will update the reading stored in this object, and result in
| python | {
"resource": ""
} |
q16315 | KATCPSensor.get_value | train | def get_value(self):
"""Get a fresh sensor value from the KATCP resource
Returns
-------
reply : tornado Future resolving with :class:`KATCPSensorReading` object
Note
----
As a side-effect this will update the reading stored in this object, and result in
| python | {
"resource": ""
} |
q16316 | KATCPSensor.get_status | train | def get_status(self):
"""Get a fresh sensor status from the KATCP resource
Returns
-------
reply : tornado Future resolving with :class:`KATCPSensorReading` object
Note
----
As a side-effect this will update the reading stored in this object, and result in
| python | {
"resource": ""
} |
q16317 | KATCPSensor.wait | train | def wait(self, condition_or_value, timeout=None):
"""Wait for the sensor to satisfy a condition.
Parameters
----------
condition_or_value : obj or callable, or seq of objs or callables
If obj, sensor.value is compared with obj. If callable,
condition_or_value(reading) is called, and must return True if its
condition is satisfied. Since the reading is passed in, the value,
status, timestamp or received_timestamp attributes can all be used
in the check.
TODO: Sequences of conditions (use SensorTransitionWaiter thingum?)
timeout : float or None
The timeout in seconds (None means wait forever)
Returns
-------
This command returns a tornado Future that resolves with True when the
sensor value satisfies the condition. It will never resolve with False;
if a timeout is given a TimeoutError happens instead.
Raises
------
:class:`KATCPSensorError`
If the sensor does not have a strategy set
:class:`tornado.gen.TimeoutError`
If the sensor condition still fails after a stated timeout period
"""
if (isinstance(condition_or_value, collections.Sequence) and not
isinstance(condition_or_value, basestring)):
raise NotImplementedError(
'Currently only single conditions are supported')
condition_test = (condition_or_value if callable(condition_or_value)
else lambda s: s.value == condition_or_value)
ioloop = tornado.ioloop.IOLoop.current()
f = Future()
if self.sampling_strategy == ('none', ):
raise KATCPSensorError(
'Cannot wait on a sensor that does not have a strategy set')
def handle_update(sensor, reading):
# This handler is called whenever a sensor update is received
try:
assert sensor is self
if condition_test(reading):
self.unregister_listener(handle_update)
| python | {
"resource": ""
} |
q16318 | fake_KATCP_client_resource_factory | train | def fake_KATCP_client_resource_factory(
KATCPClientResourceClass, fake_options, resource_spec, *args, **kwargs):
"""Create a fake KATCPClientResource-like class and a fake-manager
Parameters
----------
KATCPClientResourceClass : class
Subclass of :class:`katcp.resource_client.KATCPClientResource`
fake_options : dict
Options for the faking process. Keys:
allow_any_request : bool, default False
(TODO not implemented behaves as if it were True)
resource_spec, *args, **kwargs : passed to KATCPClientResourceClass
A subclass of the passed-in KATCPClientResourceClass is created that replaces the
internal InspecingClient instances with fakes using fake_inspecting_client_factory()
based on the InspectingClient class used by KATCPClientResourceClass.
Returns
-------
(fake_katcp_client_resource, fake_katcp_client_resource_manager):
fake_katcp_client_resource : instance of faked subclass of KATCPClientResourceClass
fake_katcp_client_resource_manager : :class:`FakeKATCPClientResourceManager` instance
Bound to the `fake_katcp_client_resource` instance.
"""
# TODO Implement allow_any_request functionality. When True, any unknown request (even
# if there is | python | {
"resource": ""
} |
q16319 | fake_KATCP_client_resource_container_factory | train | def fake_KATCP_client_resource_container_factory(
KATCPClientResourceContainerClass, fake_options, resources_spec,
*args, **kwargs):
"""Create a fake KATCPClientResourceContainer-like class and a fake-manager
Parameters
----------
KATCPClientResourceContainerClass : class
Subclass of :class:`katcp.resource_client.KATCPClientResourceContainer`
fake_options : dict
Options for the faking process. Keys:
allow_any_request : bool, default False
(TODO not implemented behaves as if it were True)
resources_spec, *args, **kwargs : passed to KATCPClientResourceContainerClass
A subclass of the passed-in KATCPClientResourceClassContainer is created that replaces the
KATCPClientResource child instances with fakes using fake_KATCP_client_resource_factory()
based on the KATCPClientResource class used by `KATCPClientResourceContainerClass`.
Returns
-------
(fake_katcp_client_resource_container, fake_katcp_client_resource_container_manager):
fake_katcp_client_resource_container : instance of faked subclass of
KATCPClientResourceContainerClass
fake_katcp_client_resource_manager : :class:`FakeKATCPClientResourceContainerManager`
instance
Bound to the `fake_katcp_client_resource_container` instance.
"""
# TODO allow_any_request see comment in fake_KATCP_client_resource_factory()
allow_any_request = fake_options.get('allow_any_request', False)
| python | {
"resource": ""
} |
q16320 | FakeInspectingClientManager.add_sensors | train | def add_sensors(self, sensor_infos):
"""Add fake sensors
sensor_infos is a dict <sensor-name> : (
<description>, <unit>, <sensor-type>, <params>*)
The sensor info is string-reprs of whatever they are, as they would be on
the wire in a real KATCP connection. Values are passed to a katcp.Message object,
| python | {
"resource": ""
} |
q16321 | FakeInspectingClientManager.add_request_handlers_dict | train | def add_request_handlers_dict(self, rh_dict):
"""Add fake request handler functions from a dict keyed by request name
Note the keys must be the KATCP message name (i.e. "the-request", not
"the_request")
The request-handler interface is more or less compatible with request handler API
in :class:`katcp.server.DeviceServerBase`. The fake ClientRequestConnection req
object does not support mass_inform() or reply_with_message.
| python | {
"resource": ""
} |
q16322 | ExponentialRandomBackoff.failed | train | def failed(self):
"""Call whenever an action has failed, grows delay exponentially
After calling failed(), the `delay` property contains the next delay
"""
try:
self._validate_parameters()
self._base_delay = min(
self._base_delay * self.exp_fac,
| python | {
"resource": ""
} |
q16323 | _InformHookDeviceClient.hook_inform | train | def hook_inform(self, inform_name, callback):
"""Hookup a function to be called when an inform is received.
Useful for interface-changed and sensor-status informs.
Parameters
----------
inform_name : str
The name of the inform.
callback : function
The function to be called.
"""
| python | {
"resource": ""
} |
q16324 | _InformHookDeviceClient.handle_inform | train | def handle_inform(self, msg):
"""Call callbacks on hooked informs followed by normal processing"""
try:
for func in self._inform_hooks.get(msg.name, []):
func(msg)
except Exception:
| python | {
"resource": ""
} |
q16325 | InspectingClientAsync.until_state | train | def until_state(self, desired_state, timeout=None):
"""
Wait until state is desired_state, InspectingClientStateType instance
Returns a future
| python | {
"resource": ""
} |
q16326 | InspectingClientAsync.connect | train | def connect(self, timeout=None):
"""Connect to KATCP interface, starting what is needed
Parameters
----------
timeout : float, None
Time to wait until connected. No waiting if None.
Raises
------
:class:`tornado.gen.TimeoutError` if the connect timeout expires
"""
# Start KATCP device client.
assert not self._running
| python | {
"resource": ""
} |
q16327 | InspectingClientAsync.inspect | train | def inspect(self):
"""Inspect device requests and sensors, update model
Returns
-------
Tornado future that resolves with:
model_changes : Nested AttrDict or None
Contains sets of added/removed request/sensor names
Example structure:
{'requests': {
'added': set(['req1', 'req2']),
'removed': set(['req10', 'req20'])}
'sensors': {
'added': set(['sens1', 'sens2']),
'removed': set(['sens10', 'sens20'])}
}
If there are no changes keys may be omitted. If an item is in both
the 'added' and 'removed' sets that means that it changed.
If neither request not sensor changes are present, None is returned
instead of a nested structure.
"""
timeout_manager = future_timeout_manager(self.sync_timeout)
sensor_index_before = copy.copy(self._sensors_index)
request_index_before = copy.copy(self._requests_index)
try:
request_changes = yield self.inspect_requests(
timeout=timeout_manager.remaining())
sensor_changes = yield self.inspect_sensors(
timeout=timeout_manager.remaining()) | python | {
"resource": ""
} |
q16328 | InspectingClientAsync.inspect_requests | train | def inspect_requests(self, name=None, timeout=None):
"""Inspect all or one requests on the device. Update requests index.
Parameters
----------
name : str or None, optional
Name of the request or None to get all requests.
timeout : float or None, optional
Timeout for request inspection, None for no timeout
Returns
-------
Tornado future that resolves with:
changes : :class:`~katcp.core.AttrDict`
AttrDict with keys ``added`` and ``removed`` (of type
:class:`set`), listing the requests that have been added or removed
respectively. Modified requests are listed in both. If there are
no changes, returns ``None`` instead.
Example structure:
{'added': set(['req1', 'req2']),
'removed': set(['req10', 'req20'])}
"""
maybe_timeout = future_timeout_manager(timeout)
if name is None:
msg = katcp.Message.request('help')
else:
msg = katcp.Message.request('help', name)
reply, informs = yield self.katcp_client.future_request(
msg, timeout=maybe_timeout.remaining())
if not reply.reply_ok():
# If an unknown request is specified the desired result is to return
# an empty list even though the request will fail
if name is None or 'Unknown request' not in reply.arguments[1]:
raise SyncError(
| python | {
"resource": ""
} |
q16329 | InspectingClientAsync._get_request_timeout_hints | train | def _get_request_timeout_hints(self, name=None, timeout=None):
"""Get request timeout hints from device
Parameters
=========
name : str or None, optional
Name of the request or None to get all request timeout hints.
timeout : float seconds
Timeout for ?request-timeout-hint
Returns
-------
Tornado future that resolves with:
timeout_hints : dict request_name -> timeout_hint
where
request_name : str
Name of the request
timeout_hint : float
Suggested request timeout hint from device ?request-timeout_hint
Note, if there is no request hint, there will be no entry in the
dict. If you request the hint for a named request that has no hint, an
empty dict will be returned.
"""
timeout_hints = {}
req_msg_args = ['request-timeout-hint']
if name:
req_msg_args.append(name)
req_msg = katcp.Message.request(*req_msg_args)
reply, informs = yield self.katcp_client.future_request(
| python | {
"resource": ""
} |
q16330 | InspectingClientAsync.inspect_sensors | train | def inspect_sensors(self, name=None, timeout=None):
"""Inspect all or one sensor on the device. Update sensors index.
Parameters
----------
name : str or None, optional
Name of the sensor or None to get all sensors.
timeout : float or None, optional
Timeout for sensors inspection, None for no timeout
Returns
-------
Tornado future that resolves with:
changes : :class:`~katcp.core.AttrDict`
AttrDict with keys ``added`` and ``removed`` (of type
:class:`set`), listing the sensors that have been added or removed
respectively. Modified sensors are listed in both. If there are no
changes, returns ``None`` instead.
Example structure:
{'added': set(['sens1', 'sens2']),
'removed': set(['sens10', 'sens20'])}
"""
if name is None:
msg = katcp.Message.request('sensor-list')
else:
msg = katcp.Message.request('sensor-list', name)
reply, informs = yield self.katcp_client.future_request(
msg, timeout=timeout)
self._logger.debug('{} received {} sensor-list informs, reply: {}'
.format(self.bind_address_string, len(informs), reply))
if not reply.reply_ok():
# If an unknown sensor is specified the desired result is to return
# an empty list, even though the request will fail
if name | python | {
"resource": ""
} |
q16331 | InspectingClientAsync.future_check_sensor | train | def future_check_sensor(self, name, update=None):
"""Check if the sensor exists.
Used internally by future_get_sensor. This method is aware of
synchronisation in progress and if inspection of the server is allowed.
Parameters
----------
name : str
Name of the sensor to verify.
update : bool or None, optional
If a katcp request to the server should be made to check if the
sensor is on the server now.
Notes
-----
Ensure that self.state.data_synced == True if yielding to
future_check_sensor from a state-change callback, or | python | {
"resource": ""
} |
q16332 | InspectingClientAsync.future_get_sensor | train | def future_get_sensor(self, name, update=None):
"""Get the sensor object.
Check if we have information for this sensor, if not connect to server
and update (if allowed) to get information.
Parameters
----------
name : string
Name of the sensor.
update : bool or None, optional
True allow inspect client to inspect katcp server if the sensor
is not known.
Returns
-------
Sensor created by :meth:`sensor_factory` or None if sensor not found.
Notes
-----
Ensure that self.state.data_synced == True if yielding to future_get_sensor from
a state-change callback, or a deadlock will occur.
"""
obj = None
exist = yield self.future_check_sensor(name, update)
if exist:
sensor_info = self._sensors_index[name]
obj = sensor_info.get('obj')
if obj is None:
sensor_type = katcp.Sensor.parse_type(
| python | {
"resource": ""
} |
q16333 | InspectingClientAsync.future_check_request | train | def future_check_request(self, name, update=None):
"""Check if the request exists.
Used internally by future_get_request. This method is aware of
synchronisation in progress and if inspection of the server is allowed.
Parameters
----------
name : str
Name of the request to verify.
update : bool or None, optional
If a katcp request to the server should be made to check if the
sensor is on the server. True = Allow, False do not Allow, None
use the class default.
Notes
-----
Ensure that self.state.data_synced == | python | {
"resource": ""
} |
q16334 | InspectingClientAsync.future_get_request | train | def future_get_request(self, name, update=None):
"""Get the request object.
Check if we have information for this request, if not connect to server
and update (if allowed).
Parameters
----------
name : string
Name of the request.
update : bool or None, optional
True allow inspect client to inspect katcp server if the request
is not known.
Returns
-------
Request created by :meth:`request_factory` or None if request not found.
Notes
-----
Ensure that self.state.data_synced == True if yielding to future_get_request
from a | python | {
"resource": ""
} |
q16335 | InspectingClientAsync._cb_inform_sensor_status | train | def _cb_inform_sensor_status(self, msg):
"""Update received for an sensor."""
timestamp = msg.arguments[0]
num_sensors = int(msg.arguments[1])
assert len(msg.arguments) == 2 + num_sensors * 3
for n in xrange(num_sensors):
name = msg.arguments[2 + n * | python | {
"resource": ""
} |
q16336 | InspectingClientAsync._cb_inform_interface_change | train | def _cb_inform_interface_change(self, msg):
"""Update the sensors and requests available."""
| python | {
"resource": ""
} |
q16337 | InspectingClientAsync._difference | train | def _difference(self, original_keys, updated_keys, name, item_index):
"""Calculate difference between the original and updated sets of keys.
Removed items will be removed from item_index, new items should have
been added by the discovery process. (?help or ?sensor-list)
This method is for use in inspect_requests and inspect_sensors only.
Returns
-------
(added, removed)
added : set of str
Names of the keys that were added
removed : set of str
Names of the keys that were removed
"""
| python | {
"resource": ""
} |
q16338 | SampleStrategy.get_strategy | train | def get_strategy(cls, strategyName, inform_callback, sensor,
*params, **kwargs):
"""Factory method to create a strategy object.
Parameters
----------
strategyName : str
Name of strategy.
inform_callback : callable, signature inform_callback(sensor, reading)
Callback to receive inform messages.
sensor : Sensor object
Sensor to sample.
params : list of objects
Custom sampling parameters for specified strategy.
Keyword Arguments
-----------------
ioloop : tornado.ioloop.IOLoop instance, optional
Tornado ioloop to use, otherwise tornado.ioloop.IOLoop.current()
Returns
-------
strategy : :class:`SampleStrategy` object
The created sampling strategy.
"""
if strategyName not in cls.SAMPLING_LOOKUP_REV:
raise ValueError("Unknown sampling strategy '%s'. "
"Known strategies are %s."
% (strategyName, cls.SAMPLING_LOOKUP.values()))
strategyType = cls.SAMPLING_LOOKUP_REV[strategyName]
if strategyType == cls.NONE:
return SampleNone(inform_callback, sensor, *params, | python | {
"resource": ""
} |
q16339 | SampleStrategy.get_sampling_formatted | train | def get_sampling_formatted(self):
"""The current sampling strategy and parameters.
The strategy is returned as a string and the values
in the parameter list are formatted as strings using
the formatter for this sensor type.
Returns
-------
strategy_name : string
KATCP name for the strategy.
params : list of strings
KATCP | python | {
"resource": ""
} |
q16340 | SampleStrategy.attach | train | def attach(self):
"""Attach strategy to its sensor and send initial update."""
s = self._sensor
| python | {
"resource": ""
} |
q16341 | SampleStrategy.cancel | train | def cancel(self):
"""Detach strategy from its sensor and cancel ioloop callbacks."""
if self.OBSERVE_UPDATES:
| python | {
"resource": ""
} |
q16342 | SampleStrategy.start | train | def start(self):
"""Start operating the strategy.
Subclasses that override start() should call the super method before
it does anything that uses the ioloop. This will attach to the sensor
as an observer if :attr:`OBSERVE_UPDATES` is True, and sets
:attr:`_ioloop_thread_id` using `thread.get_ident()`.
"""
| python | {
"resource": ""
} |
q16343 | SampleStrategy.inform | train | def inform(self, reading):
"""Inform strategy creator of the sensor status."""
try:
self._inform_callback(self._sensor, reading)
except Exception:
log.exception('Unhandled exception trying to send {!r} '
| python | {
"resource": ""
} |
q16344 | IOLoopManager.start | train | def start(self, timeout=None):
"""Start managed ioloop thread, or do nothing if not managed.
If a timeout is passed, it will block until the the event loop is alive
(or the timeout expires) even if the ioloop is not managed.
"""
if not self._ioloop:
raise RuntimeError('Call get_ioloop() or set_ioloop() first')
self._ioloop.add_callback(self._running.set)
| python | {
"resource": ""
} |
q16345 | IOLoopManager.join | train | def join(self, timeout=None):
"""Join managed ioloop thread, or do nothing if not managed."""
if not self._ioloop_managed:
# Do nothing if the loop is not managed
return
| python | {
"resource": ""
} |
q16346 | GenericSensorTree.update | train | def update(self, sensor, reading):
"""Update callback used by sensors to notify obervers of changes.
Parameters
----------
sensor : :class:`katcp.Sensor` object
The sensor whose value has changed.
reading : (timestamp, status, value) tuple
| python | {
"resource": ""
} |
q16347 | GenericSensorTree._add_sensor | train | def _add_sensor(self, sensor):
"""Add a new sensor to the tree.
Parameters
----------
sensor : :class:`katcp.Sensor` | python | {
"resource": ""
} |
q16348 | GenericSensorTree.add_links | train | def add_links(self, parent, children):
"""Create dependency links from parent to child.
Any sensors not in the tree are added. After all dependency links have
been created, the parent is recalculated and the tree attaches to any
sensors it was not yet attached to. Links that already exist are
ignored.
Parameters
----------
parent : :class:`katcp.Sensor` object
The sensor that depends on children.
children : sequence of :class:`katcp.Sensor` objects
The sensors parent depends on.
"""
new_sensors = []
if parent not in | python | {
"resource": ""
} |
q16349 | GenericSensorTree.remove_links | train | def remove_links(self, parent, children):
"""Remove dependency links from parent to child.
Any sensors that have no dependency links are removed from the tree and
the tree detaches from each sensor removed. After all dependency links
have been removed the parent is recalculated. Links that don't exist
are ignored.
Parameters
----------
parent : :class:`katcp.Sensor` object
The sensor that used to depend on children.
children : sequence of :class:`katcp.Sensor` objects
The sensors that parent used to depend on.
"""
old_sensors = []
if parent in self:
for child in children:
if child not in self:
continue
self._parent_to_children[parent].discard(child)
self._child_to_parents[child].discard(parent)
| python | {
"resource": ""
} |
q16350 | GenericSensorTree.children | train | def children(self, parent):
"""Return set of children of parent.
Parameters
----------
parent : :class:`katcp.Sensor` object
Parent whose children to return.
Returns | python | {
"resource": ""
} |
q16351 | GenericSensorTree.parents | train | def parents(self, child):
"""Return set of parents of child.
Parameters
----------
child : :class:`katcp.Sensor` object
Child whose parents to return.
Returns
| python | {
"resource": ""
} |
q16352 | BooleanSensorTree.add | train | def add(self, parent, child):
"""Add a pair of boolean sensors.
Parent depends on child.
Parameters
----------
parent : boolean instance of :class:`katcp.Sensor`
The sensor that depends on child.
child : boolean instance of :class:`katcp.Sensor`
The sensor parent depends on.
"""
if parent not in self:
if parent.stype != "boolean":
raise ValueError("Parent sensor %r is not boolean" % child)
| python | {
"resource": ""
} |
q16353 | BooleanSensorTree.remove | train | def remove(self, parent, child):
"""Remove a dependency between parent and child.
Parameters
----------
parent : boolean instance of :class:`katcp.Sensor`
The sensor that used to depend on child.
child : boolean instance of :class:`katcp.Sensor` or None
The sensor parent used to depend on.
"""
| python | {
"resource": ""
} |
q16354 | AggregateSensorTree.add | train | def add(self, parent, rule_function, children):
"""Create an aggregation rule.
Parameters
----------
parent : :class:`katcp.Sensor` object
The aggregate sensor.
rule_function : f(parent, children)
Function to update the parent sensor value.
| python | {
"resource": ""
} |
q16355 | AggregateSensorTree.add_delayed | train | def add_delayed(self, parent, rule_function, child_names):
"""Create an aggregation rule before child sensors are present.
Parameters
----------
parent : :class:`katcp.Sensor` object
The aggregate sensor.
rule_function : f(parent, children)
Function to update the parent sensor value.
child_names : sequence of str
The names of the sensors the aggregate sensor depends on. These
sensor must be registered using :meth:`register_sensor` to become
active.
"""
if parent in self._aggregates or parent in self._incomplete_aggregates:
raise ValueError("Sensor %r already has an aggregate rule"
| python | {
"resource": ""
} |
q16356 | AggregateSensorTree.register_sensor | train | def register_sensor(self, child):
"""Register a sensor required by an aggregate sensor registered with
add_delayed.
Parameters
----------
child : :class:`katcp.Sensor` object
A child sensor required by one or more delayed aggregate sensors.
"""
child_name = self._get_sensor_reference(child)
if child_name in self._registered_sensors:
raise ValueError("Sensor %r already registered with aggregate"
| python | {
"resource": ""
} |
q16357 | AggregateSensorTree._child_from_reference | train | def _child_from_reference(self, reference):
"""Returns the child sensor from its reference.
Parameters
----------
reference : str
Reference to sensor (typically its name).
Returns
-------
child : :class:`katcp.Sensor` object
| python | {
"resource": ""
} |
q16358 | AggregateSensorTree.remove | train | def remove(self, parent):
"""Remove an aggregation rule.
Parameters
----------
parent : :class:`katcp.Sensor` object
The aggregate sensor to remove.
"""
if parent not in self._aggregates:
| python | {
"resource": ""
} |
q16359 | request | train | def request(*types, **options):
"""Decorator for request handler methods.
The method being decorated should take a req argument followed
by arguments matching the list of types. The decorator will
unpack the request message into the arguments.
Parameters
----------
types : list of kattypes
The types of the request message parameters (in order). A type
with multiple=True has to be the last type.
Keyword Arguments
-----------------
include_msg : bool, optional
Pass the request message as the third parameter to the decorated
request handler function (default is False).
major : int, optional
Major version of KATCP to use when interpreting types.
Defaults to latest implemented KATCP version.
Examples
--------
>>> class MyDevice(DeviceServer):
... @request(Int(), Float(), Bool())
... @return_reply(Int(), Float())
... def request_myreq(self, req, my_int, my_float, my_bool):
... '''?myreq my_int my_float my_bool'''
... return ("ok", my_int + 1, my_float / 2.0)
...
... @request(Int(), include_msg=True)
... @return_reply(Bool())
... def request_is_odd(self, req, msg, my_int):
'''?is-odd <my_int>, reply '1' if <my_int> is odd, else 0'''
... req.inform('Checking oddity of %d' % my_int)
... return ("ok", my_int % 2)
...
"""
include_msg = options.pop('include_msg', False)
has_req = options.pop('has_req', True)
major = options.pop('major', DEFAULT_KATCP_MAJOR)
check_req = options.pop('_check_req', True)
if len(options) > 0:
raise TypeError('does not take keyword argument(s) %r.'
% options.keys())
# Check that only the last type has multiple=True
if len(types) > 1:
for type_ in types[:-1]:
if type_._multiple:
raise TypeError('Only the last parameter type '
'can accept multiple arguments.')
def decorator(handler):
argnames = []
# If this decorator is on the outside, get the parameter names which
# have been preserved by the other decorator
all_argnames = getattr(handler, "_orig_argnames", None)
if all_argnames is None:
# We must be on the inside. Introspect the parameter names.
all_argnames = inspect.getargspec(handler)[0] | python | {
"resource": ""
} |
q16360 | return_reply | train | def return_reply(*types, **options):
"""Decorator for returning replies from request handler methods.
The method being decorated should return an iterable of result
values. If the first value is 'ok', the decorator will check the
remaining values against the specified list of types (if any).
If the first value is 'fail' or 'error', there must be only
one remaining parameter, and it must be a string describing the
failure or error In both cases, the decorator will pack the
values into a reply message.
Parameters
----------
types : list of kattypes
The types of the reply message parameters (in order).
Keyword Arguments
-----------------
major : int, optional
Major version of KATCP to use when interpreting types.
Defaults to latest implemented KATCP version.
Examples
--------
>>> class MyDevice(DeviceServer):
... @request(Int())
... @return_reply(Int(), Float())
... def request_myreq(self, req, my_int):
... return ("ok", my_int + 1, my_int * 2.0)
...
"""
major = options.pop('major', DEFAULT_KATCP_MAJOR)
| python | {
"resource": ""
} |
q16361 | send_reply | train | def send_reply(*types, **options):
"""Decorator for sending replies from request callback methods.
This decorator constructs a reply from a list or tuple returned
from a callback method, but unlike the return_reply decorator it
also sends the reply rather than returning it.
The list/tuple returned from the callback method must have req (a
ClientRequestConnection instance) as its first parameter and the original
message as the second. The original message is needed to determine the
message name and ID.
The device with the callback method must have a reply method.
Parameters
----------
types : list of kattypes
| python | {
"resource": ""
} |
q16362 | make_reply | train | def make_reply(msgname, types, arguments, major):
"""Helper method for constructing a reply message from a list or tuple.
Parameters
----------
msgname : str
Name of the reply message.
types : list of kattypes
The types of the reply message parameters (in order).
arguments : list of objects
The (unpacked) reply message parameters.
major : integer
Major version of KATCP to use when packing types
"""
status = arguments[0]
if status == "fail":
return Message.reply(
| python | {
"resource": ""
} |
q16363 | minimum_katcp_version | train | def minimum_katcp_version(major, minor=0):
"""Decorator; exclude handler if server's protocol version is too low
Useful for including default handler implementations for KATCP features that
are only present in certain KATCP protocol versions
Examples
--------
>>> class MyDevice(DeviceServer):
... '''This device server will expose ?myreq'''
... PROTOCOL_INFO = katcp.core.ProtocolFlags(5, 1)
...
... @minimum_katcp_version(5, 1)
... def request_myreq(self, req, msg):
... '''A request that should only be present for KATCP >v5.1'''
... # Request handler implementation here.
| python | {
"resource": ""
} |
q16364 | request_timeout_hint | train | def request_timeout_hint(timeout_hint):
"""Decorator; add recommended client timeout hint to a request for request
Useful for requests that take longer than average to reply. Hint is provided
to clients via ?request-timeout-hint. Note this is only exposed if the
device server sets the protocol version to KATCP v5.1 or higher and enables
the REQUEST_TIMEOUT_HINTS flag in its PROTOCOL_INFO class attribute
Parameters
----------
timeout_hint : float (seconds) or None
How long the decorated request should reasonably take to reply. No
timeout hint if None, similar to never using the decorator, provided for
consistency.
Examples
--------
>>> class MyDevice(DeviceServer):
... @return_reply(Int())
... | python | {
"resource": ""
} |
q16365 | unpack_types | train | def unpack_types(types, args, argnames, major):
"""Parse arguments according to types list.
Parameters
----------
types : list of kattypes
The types of the arguments (in order).
args : list of strings
The arguments to parse.
argnames : list of strings
The names of the arguments.
major : integer
Major version of KATCP to use when packing types
"""
if len(types) > 0:
multiple = types[-1]._multiple
else:
multiple = False
if len(types) < len(args) and not multiple:
raise FailReply("Too many parameters given.")
# Wrap the types in parameter objects
params = []
for i, kattype in enumerate(types):
| python | {
"resource": ""
} |
q16366 | pack_types | train | def pack_types(types, args, major):
"""Pack arguments according the the types list.
Parameters
----------
types : list of kattypes
The types of the arguments (in order).
args : list of objects
The arguments to format.
major : integer
Major version of KATCP to use when packing types
"""
if len(types) > 0:
multiple = types[-1]._multiple
else:
multiple = False
if len(types) < len(args) and not multiple:
raise ValueError("Too many arguments to pack.")
if len(args) < len(types):
# this passes in None for missing args
retvals = map(lambda ktype, arg: | python | {
"resource": ""
} |
q16367 | KatcpType.pack | train | def pack(self, value, nocheck=False, major=DEFAULT_KATCP_MAJOR):
"""Return the value formatted as a KATCP parameter.
Parameters
----------
value : object
The value to pack.
nocheck : bool, optional
Whether to check that the value is valid before
packing it.
major : int, optional
Major version of KATCP to use when interpreting types.
Defaults to latest implemented KATCP version.
Returns
-------
packed_value : str
| python | {
"resource": ""
} |
q16368 | KatcpType.unpack | train | def unpack(self, packed_value, major=DEFAULT_KATCP_MAJOR):
"""Parse a KATCP parameter into an object.
Parameters
----------
packed_value : str
The unescaped KATCP string to parse into a value.
major : int, optional
Major version of KATCP to use when interpreting types.
Defaults to latest implemented KATCP version.
Returns
-------
value : object
The value the KATCP string represented.
| python | {
"resource": ""
} |
q16369 | Int.check | train | def check(self, value, major):
"""Check whether the value is between the minimum and maximum.
Raise a ValueError if it is not.
"""
if self._min is not None and value < self._min:
raise ValueError("Integer %d is lower than minimum %d."
| python | {
"resource": ""
} |
q16370 | Discrete.check | train | def check(self, value, major):
"""Check whether the value in the set of allowed values.
Raise a ValueError if it is not.
"""
if self._case_insensitive:
value = value.lower()
| python | {
"resource": ""
} |
q16371 | DiscreteMulti.check | train | def check(self, value, major):
"""Check that each item in the value list | python | {
"resource": ""
} |
q16372 | Parameter.unpack | train | def unpack(self, value):
"""Unpack the parameter using its kattype.
Parameters
----------
packed_value : str
The unescaped KATCP string to unpack.
Returns
-------
value : object
| python | {
"resource": ""
} |
q16373 | return_future | train | def return_future(fn):
"""Decorator that turns a synchronous function into one returning a future.
This should only be applied to non-blocking functions. Will do set_result()
with the return value, or set_exc_info() if an exception is raised. | python | {
"resource": ""
} |
q16374 | construct_name_filter | train | def construct_name_filter(pattern):
"""Return a function for filtering sensor names based on a pattern.
Parameters
----------
pattern : None or str
If None, the returned function matches all names.
If pattern starts and ends with '/' the text between the slashes
is used as a regular expression to search the names.
Otherwise the pattern must match the name of the sensor exactly.
Returns
-------
exact : bool
Return True if pattern is expected to match exactly. Used to
determine whether having no matching sensors constitutes an error.
filter_func : f(str) -> bool
| python | {
"resource": ""
} |
q16375 | ClientConnection.disconnect | train | def disconnect(self, reason):
"""Disconnect this client connection for specified reason"""
| python | {
"resource": ""
} |
q16376 | KATCPServer.start | train | def start(self, timeout=None):
"""Install the server on its IOLoop, optionally starting the IOLoop.
Parameters
----------
timeout : float or None, optional
Time in seconds to wait for server thread to start.
"""
if self._running.isSet():
raise RuntimeError('Server already started')
self._stopped.clear()
# Make sure we have an ioloop
self.ioloop = self._ioloop_manager.get_ioloop()
self._ioloop_manager.start()
# Set max_buffer_size to ensure streams are closed
# if too-large messages are received
self._tcp_server = tornado.tcpserver.TCPServer(
| python | {
"resource": ""
} |
q16377 | KATCPServer._bind_socket | train | def _bind_socket(self, bindaddr):
"""Create a listening server socket."""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setblocking(0)
try:
sock.bind(bindaddr)
| python | {
"resource": ""
} |
q16378 | KATCPServer._handle_stream | train | def _handle_stream(self, stream, address):
"""Handle a new connection as a tornado.iostream.IOStream instance."""
try:
assert get_thread_ident() == self.ioloop_thread_id
stream.set_close_callback(partial(self._stream_closed_callback,
stream))
# Our message packets are small, don't delay sending them.
stream.set_nodelay(True)
stream.max_write_buffer_size = self.MAX_WRITE_BUFFER_SIZE
# Abuse IOStream object slightly by adding 'address' and 'closing'
# attributes. Use nasty prefix to prevent naming collisions.
stream.KATCPServer_address = address
# Flag to indicate that no more write should be accepted so that
# we can flush the write buffer when closing a connection
stream.KATCPServer_closing = False
client_conn = self.client_connection_factory(self, stream)
self._connections[stream] = client_conn
try:
yield gen.maybe_future(self._device.on_client_connect(client_conn))
except Exception:
# If on_client_connect fails there is no reason to continue
# trying to handle | python | {
"resource": ""
} |
q16379 | KATCPServer.get_address | train | def get_address(self, stream):
"""Text representation of the network address of a connection stream.
Notes
-----
This method is thread-safe
"""
try:
addr = ":".join(str(part) for part in stream.KATCPServer_address)
except AttributeError:
# Something weird happened, but keep trucking
| python | {
"resource": ""
} |
q16380 | KATCPServer.send_message | train | def send_message(self, stream, msg):
"""Send an arbitrary message to a particular client.
Parameters
----------
stream : :class:`tornado.iostream.IOStream` object
The stream to send the message to.
msg : Message object
The message to send.
Notes
-----
This method can only be called in the IOLoop thread.
Failed sends disconnect the client connection and calls the device
on_client_disconnect() method. They do not raise exceptions, but they
are logged. Sends also fail if more than self.MAX_WRITE_BUFFER_SIZE
bytes are queued for sending, implying that client is falling behind.
"""
assert get_thread_ident() == self.ioloop_thread_id
| python | {
"resource": ""
} |
q16381 | KATCPServer.flush_on_close | train | def flush_on_close(self, stream):
"""Flush tornado iostream write buffer and prevent further writes.
Returns a future that resolves when the stream is flushed.
"""
assert get_thread_ident() == self.ioloop_thread_id
# Prevent futher writes
| python | {
"resource": ""
} |
q16382 | KATCPServer.call_from_thread | train | def call_from_thread(self, fn):
"""Allow thread-safe calls to ioloop functions.
Uses add_callback if not in the IOLoop thread, otherwise calls
directly. Returns an already resolved `tornado.concurrent.Future` if in
ioloop, otherwise a `concurrent.Future`. Logs unhandled exceptions.
Resolves with an exception if one occurred.
"""
if self.in_ioloop_thread():
f = tornado_Future()
try:
f.set_result(fn())
except Exception, e:
f.set_exception(e)
self._logger.exception('Error executing callback '
'in ioloop thread')
finally:
return f
else:
f = Future()
| python | {
"resource": ""
} |
q16383 | KATCPServer.mass_send_message | train | def mass_send_message(self, msg):
"""Send a message to all connected clients.
Notes
-----
This method can only be called in the IOLoop thread.
"""
for stream in self._connections.keys():
| python | {
"resource": ""
} |
q16384 | ClientRequestConnection.reply_with_message | train | def reply_with_message(self, rep_msg):
"""Send a pre-created reply message to the client connection.
| python | {
"resource": ""
} |
q16385 | MessageHandlerThread.on_message | train | def on_message(self, client_conn, msg):
"""Handle message.
Returns
-------
ready : Future
A future that will resolve once we're ready, else None.
Notes
-----
*on_message* should not be called again until *ready* has resolved.
"""
MAX_QUEUE_SIZE = 30
if len(self._msg_queue) >= MAX_QUEUE_SIZE:
# This should never happen if callers to handle_message wait
# for its futures to resolve before sending another message.
# NM 2014-10-06: Except when there are multiple clients. Oops.
| python | {
"resource": ""
} |
q16386 | DeviceServerBase.create_log_inform | train | def create_log_inform(self, level_name, msg, name, timestamp=None):
"""Create a katcp logging inform message.
Usually this will be called from inside a DeviceLogger object,
but it is also used by the methods in this class when errors
need to be reported to | python | {
"resource": ""
} |
q16387 | DeviceServerBase.handle_message | train | def handle_message(self, client_conn, msg):
"""Handle messages of all types from clients.
Parameters
----------
client_conn : ClientConnection object
The client connection the message was from.
msg : Message object
The message to process.
"""
# log messages received so that no one else has to
self._logger.debug('received: {0!s}'.format(msg))
if msg.mtype == msg.REQUEST:
return self.handle_request(client_conn, msg)
elif msg.mtype == msg.INFORM:
return self.handle_inform(client_conn, msg)
| python | {
"resource": ""
} |
q16388 | DeviceServerBase.set_ioloop | train | def set_ioloop(self, ioloop=None):
"""Set the tornado IOLoop to use.
Sets the tornado.ioloop.IOLoop instance to use, defaulting to
IOLoop.current(). If set_ioloop() is never called the IOLoop is
started in a new thread, and will be stopped if self.stop() is called.
| python | {
"resource": ""
} |
q16389 | DeviceServerBase.start | train | def start(self, timeout=None):
"""Start the server in a new thread.
Parameters
----------
timeout : float or None, optional
Time in seconds to wait for server thread to start.
"""
if self._handler_thread and self._handler_thread.isAlive():
raise RuntimeError('Message handler thread already started')
self._server.start(timeout) | python | {
"resource": ""
} |
q16390 | DeviceServerBase.sync_with_ioloop | train | def sync_with_ioloop(self, timeout=None):
"""Block for ioloop to complete a loop if called from another thread.
Returns a future if called from inside the ioloop.
Raises concurrent.futures.TimeoutError if timed out while blocking.
| python | {
"resource": ""
} |
q16391 | DeviceServer.on_client_connect | train | def on_client_connect(self, client_conn):
"""Inform client of build state and version on connect.
Parameters
----------
client_conn : ClientConnection object
The client connection that has been successfully established.
Returns
-------
Future that resolves when the device is ready to accept messages.
"""
assert get_thread_ident() == self._server.ioloop_thread_id
self._client_conns.add(client_conn)
self._strategies[client_conn] = {} # map sensors -> sampling strategies
katcp_version = self.PROTOCOL_INFO.major
if katcp_version >= VERSION_CONNECT_KATCP_MAJOR:
client_conn.inform(Message.inform(
"version-connect", "katcp-protocol", self.PROTOCOL_INFO))
| python | {
"resource": ""
} |
q16392 | DeviceServer.clear_strategies | train | def clear_strategies(self, client_conn, remove_client=False):
"""Clear the sensor strategies of a client connection.
Parameters
----------
client_connection : ClientConnection instance
The connection that should have its sampling strategies cleared
remove_client : bool, optional
Remove the | python | {
"resource": ""
} |
q16393 | DeviceServer.on_client_disconnect | train | def on_client_disconnect(self, client_conn, msg, connection_valid):
"""Inform client it is about to be disconnected.
Parameters
----------
client_conn : ClientConnection object
The client connection being disconnected.
msg : str
Reason client is being disconnected.
connection_valid : bool
True if connection is still open for sending,
False otherwise.
Returns
-------
Future that resolves when the client connection can be closed.
"""
f = tornado_Future()
@gen.coroutine
| python | {
"resource": ""
} |
q16394 | DeviceServer.remove_sensor | train | def remove_sensor(self, sensor):
"""Remove a sensor from the device.
Also deregisters all clients observing the sensor.
Parameters
----------
sensor : Sensor object or name string
The sensor to remove from the device server.
"""
if isinstance(sensor, basestring):
sensor_name = sensor
else:
sensor_name = sensor.name
sensor = self._sensors.pop(sensor_name)
def cancel_sensor_strategies():
| python | {
"resource": ""
} |
q16395 | DeviceServer.get_sensor | train | def get_sensor(self, sensor_name):
"""Fetch the sensor with the given name.
Parameters
----------
sensor_name : str
Name of the sensor to retrieve.
| python | {
"resource": ""
} |
q16396 | DeviceServer.request_halt | train | def request_halt(self, req, msg):
"""Halt the device server.
Returns
-------
success : {'ok', 'fail'}
Whether scheduling the halt succeeded.
Examples
--------
::
?halt
!halt ok
"""
f = Future()
@gen.coroutine
| python | {
"resource": ""
} |
q16397 | DeviceServer.request_help | train | def request_help(self, req, msg):
"""Return help on the available requests.
Return a description of the available requests using a sequence of
#help informs.
Parameters
----------
request : str, optional
The name of the request to return help for (the default is to
return help for all requests).
Informs
-------
request : str
The name of a request.
description : str
Documentation for the named request.
Returns
-------
success : {'ok', 'fail'}
Whether sending the help succeeded.
informs : int
Number of #help inform messages sent.
Examples
--------
::
?help
#help halt ...description...
#help help ...description...
...
!help ok 5
?help halt
| python | {
"resource": ""
} |
q16398 | DeviceServer.request_request_timeout_hint | train | def request_request_timeout_hint(self, req, request):
"""Return timeout hints for requests
KATCP requests should generally take less than 5s to complete, but some
requests are unavoidably slow. This results in spurious client timeout
errors. This request provides timeout hints that clients can use to
select suitable request timeouts.
Parameters
----------
request : str, optional
The name of the request to return a timeout hint for (the default is
to return hints for all requests that have timeout hints). Returns
one inform per request. Must be an existing request if specified.
Informs
-------
request : str
The name of the request.
suggested_timeout : float
Suggested request timeout in seconds for the request. If
`suggested_timeout` is zero (0), no timeout hint is available.
Returns
-------
success : {'ok', 'fail'}
Whether sending the help succeeded.
informs : int
| python | {
"resource": ""
} |
q16399 | DeviceServer.request_log_level | train | def request_log_level(self, req, msg):
"""Query or set the current logging level.
Parameters
----------
level : {'all', 'trace', 'debug', 'info', 'warn', 'error', 'fatal', \
'off'}, optional
Name of the logging level to set the device server to (the default
is to leave the log level unchanged).
Returns
-------
success : {'ok', 'fail'}
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.