code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
with open_file(file, "rb") as f:
header = f.read(8)
f.seek(0)
if header != PNG_SIGN:
b = file_to_png(f)
else:
b = f.read()
return cls.from_bytes(b) | def open_any(cls, file) | Open an image file. If the image is not PNG format, it would convert
the image into PNG with Pillow module. If the module is not
installed, :class:`ImportError` would be raised.
:arg file: Input file.
:type file: path-like or file-like
:rtype: :class:`PNG` | 3.405565 | 3.735693 | 0.911629 |
im = cls()
im.chunks = list(parse_chunks(b))
im.init()
return im | def from_bytes(cls, b) | Create :class:`PNG` from raw bytes.
:arg bytes b: The raw bytes of the PNG file.
:rtype: :class:`PNG` | 7.076591 | 8.284366 | 0.85421 |
im = cls()
im.chunks = chunks
im.init()
return im | def from_chunks(cls, chunks) | Construct PNG from raw chunks.
:arg chunks: A list of ``(chunk_type, chunk_raw_data)``. Also see
:func:`chunks`.
:type chunks: list[tuple(str, bytes)] | 6.100677 | 6.731064 | 0.906347 |
chunks = [PNG_SIGN]
chunks.extend(c[1] for c in self.chunks)
return b"".join(chunks) | def to_bytes(self) | Convert the entire image to bytes.
:rtype: bytes | 6.222947 | 6.915537 | 0.89985 |
return struct.pack(
"!IIIIHHbb", self.width, self.height, self.x_offset, self.y_offset,
self.delay, self.delay_den, self.depose_op, self.blend_op
) | def to_bytes(self) | Convert to bytes.
:rtype: bytes | 6.324043 | 6.38676 | 0.99018 |
if not isinstance(png, PNG):
raise TypeError("Expect an instance of `PNG` but got `{}`".format(png))
control = FrameControl(**options)
if control.width is None:
control.width = png.width
if control.height is None:
control.height = png.height
self.frames.append((png, control)) | def append(self, png, **options) | Append one frame.
:arg PNG png: Append a :class:`PNG` as a frame.
:arg dict options: The options for :class:`FrameControl`. | 2.882509 | 2.559258 | 1.126307 |
self.append(PNG.open_any(file), **options) | def append_file(self, file, **options) | Create a PNG from file and append the PNG as a frame.
:arg file: Input file.
:type file: path-like or file-like.
:arg dict options: The options for :class:`FrameControl`. | 16.459822 | 16.930502 | 0.972199 |
# grab the chunks we needs
out = [PNG_SIGN]
# FIXME: it's tricky to define "other_chunks". HoneyView stop the
# animation if it sees chunks other than fctl or idat, so we put other
# chunks to the end of the file
other_chunks = []
seq = 0
# for first frame
png, control = self.frames[0]
# header
out.append(png.hdr)
# acTL
out.append(make_chunk("acTL", struct.pack("!II", len(self.frames), self.num_plays)))
# fcTL
if control:
out.append(make_chunk("fcTL", struct.pack("!I", seq) + control.to_bytes()))
seq += 1
# and others...
idat_chunks = []
for type_, data in png.chunks:
if type_ in ("IHDR", "IEND"):
continue
if type_ == "IDAT":
# put at last
idat_chunks.append(data)
continue
out.append(data)
out.extend(idat_chunks)
# FIXME: we should do some optimization to frames...
# for other frames
for png, control in self.frames[1:]:
# fcTL
out.append(
make_chunk("fcTL", struct.pack("!I", seq) + control.to_bytes())
)
seq += 1
# and others...
for type_, data in png.chunks:
if type_ in ("IHDR", "IEND") or type_ in CHUNK_BEFORE_IDAT:
continue
elif type_ == "IDAT":
# convert IDAT to fdAT
out.append(
make_chunk("fdAT", struct.pack("!I", seq) + data[8:-4])
)
seq += 1
else:
other_chunks.append(data)
# end
out.extend(other_chunks)
out.append(png.end)
return b"".join(out) | def to_bytes(self) | Convert the entire image to bytes.
:rtype: bytes | 3.640769 | 3.579044 | 1.017246 |
im = cls()
for file in files:
im.append_file(file, **options)
return im | def from_files(cls, files, **options) | Create an APNG from multiple files.
This is a shortcut of::
im = APNG()
for file in files:
im.append_file(file, **options)
:arg list files: A list of filename. See :meth:`PNG.open`.
:arg dict options: Options for :class:`FrameControl`.
:rtype: APNG | 3.826815 | 3.00854 | 1.271984 |
hdr = None
head_chunks = []
end = ("IEND", make_chunk("IEND", b""))
frame_chunks = []
frames = []
num_plays = 0
frame_has_head_chunks = False
control = None
for type_, data in parse_chunks(b):
if type_ == "IHDR":
hdr = data
frame_chunks.append((type_, data))
elif type_ == "acTL":
_num_frames, num_plays = struct.unpack("!II", data[8:-4])
continue
elif type_ == "fcTL":
if any(type_ == "IDAT" for type_, data in frame_chunks):
# IDAT inside chunk, go to next frame
frame_chunks.append(end)
frames.append((PNG.from_chunks(frame_chunks), control))
frame_has_head_chunks = False
control = FrameControl.from_bytes(data[12:-4])
# https://github.com/PyCQA/pylint/issues/2072
# pylint: disable=typecheck
hdr = make_chunk("IHDR", struct.pack("!II", control.width, control.height) + hdr[16:-4])
frame_chunks = [("IHDR", hdr)]
else:
control = FrameControl.from_bytes(data[12:-4])
elif type_ == "IDAT":
if not frame_has_head_chunks:
frame_chunks.extend(head_chunks)
frame_has_head_chunks = True
frame_chunks.append((type_, data))
elif type_ == "fdAT":
# convert to IDAT
if not frame_has_head_chunks:
frame_chunks.extend(head_chunks)
frame_has_head_chunks = True
frame_chunks.append(("IDAT", make_chunk("IDAT", data[12:-4])))
elif type_ == "IEND":
# end
frame_chunks.append(end)
frames.append((PNG.from_chunks(frame_chunks), control))
break
elif type_ in CHUNK_BEFORE_IDAT:
head_chunks.append((type_, data))
else:
frame_chunks.append((type_, data))
o = cls()
o.frames = frames
o.num_plays = num_plays
return o | def from_bytes(cls, b) | Create an APNG from raw bytes.
:arg bytes b: The raw bytes of the APNG file.
:rtype: APNG | 2.61534 | 2.561574 | 1.020989 |
from livereload import Server
server = Server()
server.watch("README.rst", "py cute.py readme_build")
server.serve(open_url_delay=1, root="build/readme") | def readme() | Live reload readme | 8.443266 | 6.983119 | 1.209097 |
self.add_sensor(Sensor(int, 'int_sensor%d' % len(self._sensors),
'descr', 'unit', params=[-10, 10]))
return Message.reply('add-sensor', 'ok') | def request_add_sensor(self, sock, msg) | add a sensor | 9.973846 | 9.57715 | 1.041421 |
def fixup_numbers(val):
try:
# See if it is a number
return str(float(val))
except ValueError:
# ok, it is not a number we know of, perhaps a string
return str(val)
if isinstance(params, basestring):
params = params.split(' ')
# No number
return tuple(fixup_numbers(p) for p in params) | 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 | 5.890491 | 5.521961 | 1.066739 |
sensor_name = escape_name(sensor_name)
sensor = self.sensor[sensor_name]
try:
yield sensor.wait(condition_or_value, timeout)
except tornado.gen.TimeoutError:
raise tornado.gen.Return(False)
else:
raise tornado.gen.Return(True) | 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
------
:class:`KATCPSensorError`
If the sensor does not have a strategy set, or if the named sensor
is not present | 2.558517 | 3.341157 | 0.765758 |
def list_sensors(self, filter="", strategy=False, status="",
use_python_identifiers=True, tuple=False, refresh=False) | List sensors available on this resource matching certain criteria.
Parameters
----------
filter : string, optional
Filter each returned sensor's name against this regexp if specified.
To ease the dichotomy between Python identifier names and actual
sensor names, the default is to search on Python identifier names
rather than KATCP sensor names, unless `use_python_identifiers`
below is set to False. Note that the sensors of subordinate
KATCPResource instances may have inconsistent names and Python
identifiers, better to always search on Python identifiers in this
case.
strategy : {False, True}, optional
Only list sensors with a set strategy if True
status : string, optional
Filter each returned sensor's status against this regexp if given
use_python_identifiers : {True, False}, optional
Match on python identfiers even the the KATCP name is available.
tuple : {True, False}, optional, Default: False
Return backwards compatible tuple instead of SensorResultTuples
refresh : {True, False}, optional, Default: False
If set the sensor values will be refreshed with get_value before
returning the results.
Returns
-------
sensors : list of SensorResultTuples, or list of tuples
List of matching sensors presented as named tuples. The `object`
field is the :class:`KATCPSensor` object associated with the sensor.
Note that the name of the object may not match `name` if it
originates from a subordinate device. | 47,497.375 | 65,890.335938 | 0.720855 | |
sensors_strategies = {}
sensor_results = yield self.list_sensors(filter)
for sensor_reslt in sensor_results:
norm_name = sensor_reslt.object.normalised_name
try:
sensor_strat = yield self.set_sampling_strategy(norm_name, strategy_and_params)
sensors_strategies[norm_name] = sensor_strat[norm_name]
except Exception:
sensors_strategies[norm_name] = (
False, sys.exc_info())
raise tornado.gen.Return(sensors_strategies) | 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
normalised sensor strategy and parameters as tuple if success == True
else, sys.exc_info() tuple for the error that occured. | 4.080971 | 3.176811 | 1.284612 |
sensors_strategies = {}
try:
sensor_obj = self.sensor.get(sensor_name)
yield sensor_obj.set_sampling_strategy(strategy_and_params)
sensors_strategies[sensor_obj.normalised_name] = (
True, sensor_obj.sampling_strategy)
except Exception:
sensors_strategies[sensor_obj.normalised_name] = (
False, sys.exc_info())
raise tornado.gen.Return(sensors_strategies) | 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. | 3.208283 | 2.628772 | 1.220449 |
if not params:
param_args = []
elif isinstance(params, basestring):
param_args = [str(p) for p in params.split(' ')]
else:
if not isinstance(params, collections.Iterable):
params = (params,)
param_args = [str(p) for p in params]
samp_strategy = " ".join([strategy] + param_args)
return self._manager.set_sampling_strategy(self.name, samp_strategy) | 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.
params : seq of str or str
(<strat_name>, [<strat_parm1>, ...])
Returns
-------
done : tornado Future that resolves when done or raises KATCPSensorError | 3.068521 | 2.936178 | 1.045073 |
listener_id = hashable_identity(listener)
self._listeners[listener_id] = (listener, reading)
logger.debug(
'Register listener for {}'
.format(self.name)) | 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
listener(received_timestamp, timestamp, status, value) | 6.094497 | 8.785133 | 0.693728 |
listener_id = hashable_identity(listener)
self._listeners.pop(listener_id, None) | def unregister_listener(self, listener) | Remove a listener callback added with register_listener().
Parameters
----------
listener : function
Reference to the callback function that should be removed | 6.118714 | 17.625242 | 0.347156 |
received_timestamp = self._manager.time()
reading = KATCPSensorReading(received_timestamp, timestamp, status, value)
self._reading = reading
self.call_listeners(reading) | def set(self, timestamp, status, value) | Set sensor with a given received value, matches :meth:`katcp.Sensor.set` | 8.99698 | 6.181375 | 1.455498 |
if timestamp is None:
timestamp = self._manager.time()
self.set(timestamp, status, value) | def set_value(self, value, status=Sensor.NOMINAL, timestamp=None) | Set sensor value with optinal specification of status and timestamp | 5.774866 | 5.85681 | 0.986009 |
yield self._manager.poll_sensor(self._name)
# By now the sensor manager should have set the reading
raise Return(self._reading) | 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
registered listeners being called. | 17.33403 | 18.151768 | 0.95495 |
yield self._manager.poll_sensor(self._name)
# By now the sensor manager should have set the reading
raise Return(self._reading.value) | 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
registered listeners being called. | 22.26408 | 17.720129 | 1.256429 |
yield self._manager.poll_sensor(self._name)
# By now the sensor manager should have set the reading
raise Return(self._reading.status) | 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
registered listeners being called. | 22.327433 | 18.322962 | 1.218549 |
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)
# Try and be idempotent if called multiple times after the
# condition is matched. This should not happen unless the
# sensor object is being updated in a thread outside of the
# ioloop.
if not f.done():
ioloop.add_callback(f.set_result, True)
except Exception:
f.set_exc_info(sys.exc_info())
self.unregister_listener(handle_update)
self.register_listener(handle_update, reading=True)
# Handle case where sensor is already at the desired value
ioloop.add_callback(handle_update, self, self._reading)
if timeout:
to = ioloop.time() + timeout
timeout_f = with_timeout(to, f)
# Make sure we stop listening if the wait times out to prevent a
# buildup of listeners
timeout_f.add_done_callback(
lambda f: self.unregister_listener(handle_update))
return timeout_f
else:
return f | 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 | 3.973233 | 3.543739 | 1.121198 |
# TODO Implement allow_any_request functionality. When True, any unknown request (even
# if there is no fake implementation) should succeed
allow_any_request = fake_options.get('allow_any_request', False)
class FakeKATCPClientResource(KATCPClientResourceClass):
def inspecting_client_factory(self, host, port, ioloop_set_to):
real_instance = (super(FakeKATCPClientResource, self)
.inspecting_client_factory(host, port, ioloop_set_to) )
fic, fic_manager = fake_inspecting_client_factory(
real_instance.__class__, fake_options, host, port,
ioloop=ioloop_set_to, auto_reconnect=self.auto_reconnect)
self.fake_inspecting_client_manager = fic_manager
return fic
fkcr = FakeKATCPClientResource(resource_spec, *args, **kwargs)
fkcr_manager = FakeKATCPClientResourceManager(fkcr)
return (fkcr, fkcr_manager) | 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. | 4.184691 | 3.293428 | 1.270619 |
# TODO allow_any_request see comment in fake_KATCP_client_resource_factory()
allow_any_request = fake_options.get('allow_any_request', False)
class FakeKATCPClientResourceContainer(KATCPClientResourceContainerClass):
def __init__(self, *args, **kwargs):
self.fake_client_resource_managers = {}
super(FakeKATCPClientResourceContainer, self).__init__(*args, **kwargs)
def client_resource_factory(self, res_spec, parent, logger):
real_instance = (super(FakeKATCPClientResourceContainer, self)
.client_resource_factory(res_spec, parent, logger) )
fkcr, fkcr_manager = fake_KATCP_client_resource_factory(
real_instance.__class__, fake_options,
res_spec, parent=self, logger=logger)
self.fake_client_resource_managers[
resource.escape_name(fkcr.name)] = fkcr_manager
return fkcr
fkcrc = FakeKATCPClientResourceContainer(resources_spec, *args, **kwargs)
fkcrc_manager = FakeKATCPClientResourceContainerManager(fkcrc)
return (fkcrc, fkcrc_manager) | 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. | 2.673731 | 2.313473 | 1.155722 |
if msg.arguments:
name = (msg.arguments[0],)
keys = (name, )
if name not in self.fake_sensor_infos:
return ("fail", "Unknown sensor name.")
else:
keys = self.fake_sensor_infos.keys()
num_informs = 0
for sensor_name in keys:
infos = self.fake_sensor_infos[sensor_name]
num_informs += 1
req.inform(sensor_name, *infos)
return ('ok', num_informs) | def request_sensor_list(self, req, msg) | Sensor list | 3.832523 | 3.811465 | 1.005525 |
# Check sensor validity. parse_type() and parse_params should raise if not OK
for s_name, s_info in sensor_infos.items():
s_type = Sensor.parse_type(s_info[2])
s_params = Sensor.parse_params(s_type, s_info[3:])
self.fake_sensor_infos.update(sensor_infos)
self._fic._interface_changed.set() | 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,
so some automatic conversions are done, hence it is OK to pass numbers without
stringifying them. | 7.001494 | 6.286239 | 1.113781 |
rh_dict = {}
for name in dir(rh_obj):
if not callable(getattr(rh_obj, name)):
continue
if name.startswith("request_"):
request_name = convert_method_name("request_", name)
req_meth = getattr(rh_obj, name)
rh_dict[request_name] = req_meth
self.add_request_handlers_dict(rh_dict) | def add_request_handlers_object(self, rh_obj) | Add fake request handlers from an object with request_* method(s)
See :meth:`FakeInspectingClientManager.add_request_handlers_dict` for more detail. | 2.700973 | 2.556452 | 1.056532 |
# Check that all the callables have docstrings as strings
for req_func in rh_dict.values():
assert req_func.__doc__, "Even fake request handlers must have docstrings"
self._fkc.request_handlers.update(rh_dict)
self._fic._interface_changed.set() | 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. | 13.519594 | 11.780773 | 1.147598 |
mid = self._get_mid_and_update_msg(msg, use_mid)
if msg.name in self.request_handlers:
req = FakeClientRequestConnection(self.client_connection, msg)
reply_msg = yield tornado.gen.maybe_future(
self.request_handlers[msg.name](req, msg))
reply_informs = req.informs_sent
else:
reply_msg = Message.reply(msg.name, 'ok')
reply_informs = []
reply_msg.mid = mid
raise Return((reply_msg, reply_informs)) | def future_request(self, msg, timeout=None, use_mid=None) | Send a request messsage, with future replies.
Parameters
----------
msg : Message object
The request Message to send.
timeout : float in seconds
How long to wait for a reply. The default is the
the timeout set when creating the AsyncClient.
use_mid : boolean, optional
Whether to use message IDs. Default is to use message IDs
if the server supports them.
Returns
-------
A tornado.concurrent.Future that resolves with:
reply : Message object
The reply message received.
informs : list of Message objects
A list of the inform messages received. | 4.685216 | 4.71443 | 0.993803 |
try:
self._validate_parameters()
self._base_delay = min(
self._base_delay * self.exp_fac,
self.delay_max)
self._update_delay()
except Exception:
ic_logger.exception(
'Unhandled exception trying to calculate a retry timout') | def failed(self) | Call whenever an action has failed, grows delay exponentially
After calling failed(), the `delay` property contains the next delay | 10.035425 | 8.386035 | 1.196683 |
# Do not hook the same callback multiple times
if callback not in self._inform_hooks[inform_name]:
self._inform_hooks[inform_name].append(callback) | 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. | 3.562504 | 4.717937 | 0.755098 |
try:
for func in self._inform_hooks.get(msg.name, []):
func(msg)
except Exception:
self._logger.warning('Call to function "{0}" with message "{1}".'
.format(func, msg), exc_info=True)
super(_InformHookDeviceClient, self).handle_inform(msg) | def handle_inform(self, msg) | Call callbacks on hooked informs followed by normal processing | 5.056144 | 4.366518 | 1.157935 |
return _InformHookDeviceClient(host, port, *args, **kwargs) | def inform_hook_client_factory(self, host, port, *args, **kwargs) | Return an instance of :class:`_InformHookDeviceClient` or similar
Provided to ease testing. Dynamically overriding this method after instantiation
but before start() is called allows for deep brain surgery. See
:class:`katcp.fake_clients.TBD` | 7.313822 | 4.340995 | 1.684826 |
return self._state.until_state(desired_state, timeout=timeout) | def until_state(self, desired_state, timeout=None) | Wait until state is desired_state, InspectingClientStateType instance
Returns a future | 5.776423 | 7.32385 | 0.788714 |
# Start KATCP device client.
assert not self._running
maybe_timeout = future_timeout_manager(timeout)
self._logger.debug('Starting katcp client')
self.katcp_client.start()
try:
yield maybe_timeout(self.katcp_client.until_running())
self._logger.debug('Katcp client running')
except tornado.gen.TimeoutError:
self.katcp_client.stop()
raise
if timeout:
yield maybe_timeout(self.katcp_client.until_connected())
self._logger.debug('Katcp client connected')
self._running = True
self._state_loop() | 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 | 4.051088 | 3.92848 | 1.03121 |
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())
except Exception:
# Ensure atomicity of sensor and request updates ; if the one
# fails, the other should act as if it has failed too.
self._sensors_index = sensor_index_before
self._requests_index = request_index_before
raise
model_changes = AttrDict()
if request_changes:
model_changes.requests = request_changes
if sensor_changes:
model_changes.sensors = sensor_changes
if model_changes:
raise Return(model_changes) | 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. | 4.213518 | 3.402609 | 1.23832 |
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(
'Error reply during sync process for {}: {}'
.format(self.bind_address_string, reply))
# Get recommended timeouts hints for slow requests if the server
# provides them
timeout_hints_available = (
self.katcp_client.protocol_flags.request_timeout_hints)
if timeout_hints_available:
timeout_hints = yield self._get_request_timeout_hints(
name, timeout=maybe_timeout.remaining())
else:
timeout_hints = {}
requests_old = set(self._requests_index.keys())
requests_updated = set()
for msg in informs:
req_name = msg.arguments[0]
req = {'name': req_name,
'description': msg.arguments[1],
'timeout_hint': timeout_hints.get(req_name)}
requests_updated.add(req_name)
self._update_index(self._requests_index, req_name, req)
added, removed = self._difference(
requests_old, requests_updated, name, self._requests_index)
if added or removed:
raise Return(AttrDict(added=added, removed=removed)) | 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'])} | 4.437538 | 4.327999 | 1.02531 |
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(
req_msg, timeout=timeout)
if not reply.reply_ok():
raise SyncError('Error retrieving request timeout hints: "{}"\n'
'in reply to request {}, continuing with sync'
.format(reply, req_msg))
for inform in informs:
request_name = inform.arguments[0]
timeout_hint = float(inform.arguments[1])
if timeout_hint > 0:
timeout_hints[request_name] = timeout_hint
raise Return(timeout_hints) | 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. | 3.688393 | 3.220437 | 1.145308 |
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 is None or 'Unknown sensor' not in reply.arguments[1]:
raise SyncError('Error reply during sync process: {}'
.format(reply))
sensors_old = set(self._sensors_index.keys())
sensors_updated = set()
for msg in informs:
sen_name = msg.arguments[0]
sensors_updated.add(sen_name)
sen = {'description': msg.arguments[1],
'units': msg.arguments[2],
'sensor_type': msg.arguments[3],
'params': msg.arguments[4:]}
self._update_index(self._sensors_index, sen_name, sen)
added, removed = self._difference(
sensors_old, sensors_updated, name, self._sensors_index)
for sensor_name in removed:
if sensor_name in self._sensor_object_cache:
del self._sensor_object_cache[sensor_name]
if added or removed:
raise Return(AttrDict(added=added, removed=removed)) | 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'])} | 3.84319 | 3.799395 | 1.011527 |
exist = False
yield self.until_data_synced()
if name in self._sensors_index:
exist = True
else:
if update or (update is None and self._update_on_lookup):
yield self.inspect_sensors(name)
exist = yield self.future_check_sensor(name, False)
raise tornado.gen.Return(exist) | 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 a deadlock will
occur. | 6.260334 | 5.967037 | 1.049153 |
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(
sensor_info.get('sensor_type'))
sensor_params = katcp.Sensor.parse_params(
sensor_type,
sensor_info.get('params'))
obj = self.sensor_factory(
name=name,
sensor_type=sensor_type,
description=sensor_info.get('description'),
units=sensor_info.get('units'),
params=sensor_params)
self._sensors_index[name]['obj'] = obj
self._sensor_object_cache[name] = obj
raise tornado.gen.Return(obj) | 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. | 2.816216 | 2.854047 | 0.986745 |
exist = False
yield self.until_data_synced()
if name in self._requests_index:
exist = True
else:
if update or (update is None and self._update_on_lookup):
yield self.inspect_requests(name)
exist = yield self.future_check_request(name, False)
raise tornado.gen.Return(exist) | 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 == True if yielding to future_check_request
from a state-change callback, or a deadlock will occur. | 6.348905 | 5.661349 | 1.121447 |
obj = None
exist = yield self.future_check_request(name, update)
if exist:
request_info = self._requests_index[name]
obj = request_info.get('obj')
if obj is None:
obj = self.request_factory(**request_info)
self._requests_index[name]['obj'] = obj
raise tornado.gen.Return(obj) | 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 state-change callback, or a deadlock will occur. | 3.719048 | 3.955206 | 0.940292 |
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 * 3]
status = msg.arguments[3 + n * 3]
value = msg.arguments[4 + n * 3]
self.update_sensor(name, timestamp, status, value) | def _cb_inform_sensor_status(self, msg) | Update received for an sensor. | 2.4207 | 2.303614 | 1.050827 |
self._logger.debug('cb_inform_interface_change(%s)', msg)
self._interface_changed.set() | def _cb_inform_interface_change(self, msg) | Update the sensors and requests available. | 4.505548 | 3.812105 | 1.181905 |
# TODO (NM 2016-11-03) This method should really live on the lower level
# katcp_client in client.py, is generally useful IMHO
use_mid = kwargs.get('use_mid')
timeout = kwargs.get('timeout')
mid = kwargs.get('mid')
msg = katcp.Message.request(request, *args, mid=mid)
return self.katcp_client.future_request(msg, timeout, use_mid) | def simple_request(self, request, *args, **kwargs) | Create and send a request to the server.
This method implements a very small subset of the options
possible to send an request. It is provided as a shortcut to
sending a simple request.
Parameters
----------
request : str
The request to call.
*args : list of objects
Arguments to pass on to the request.
Keyword Arguments
-----------------
timeout : float or None, optional
Timeout after this amount of seconds (keyword argument).
mid : None or int, optional
Message identifier to use for the request message. If None, use either
auto-incrementing value or no mid depending on the KATCP protocol version
(mid's were only introduced with KATCP v5) and the value of the `use_mid`
argument. Defaults to None
use_mid : bool
Use a mid for the request if True. Defaults to True if the server supports
them.
Returns
-------
future object.
Example
-------
::
reply, informs = yield ic.simple_request('help', 'sensor-list') | 7.683805 | 6.286361 | 1.222298 |
original_keys = set(original_keys)
updated_keys = set(updated_keys)
added_keys = updated_keys.difference(original_keys)
removed_keys = set()
if name is None:
removed_keys = original_keys.difference(updated_keys)
elif name not in updated_keys and name in original_keys:
removed_keys = set([name])
for key in removed_keys:
if key in item_index:
del(item_index[key])
# Check the keys that was not added now or not lined up for removal,
# and see if they changed.
for key in updated_keys.difference(added_keys.union(removed_keys)):
if item_index[key].get('_changed'):
item_index[key]['_changed'] = False
removed_keys.add(key)
added_keys.add(key)
return added_keys, removed_keys | 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 | 2.837766 | 2.96202 | 0.958051 |
r = random.choice(self.FRUIT + [None])
if r is None:
return ("fail", "No fruit.")
delay = random.randrange(1,5)
req.inform("Picking will take %d seconds" % delay)
def pick_handler():
self._fruit_result.set_value(r)
req.reply("ok", r)
self.ioloop.add_callback(
self.ioloop.call_later, delay, pick_handler)
raise AsyncReply | def request_pick_fruit(self, req) | Pick a random fruit. | 6.846311 | 6.502358 | 1.052897 |
@wraps(update)
def wrapped_update(self, sensor, reading):
if get_thread_ident() == self._ioloop_thread_id:
update(self, sensor, reading)
else:
self.ioloop.add_callback(update, self, sensor, reading)
return wrapped_update | def update_in_ioloop(update) | Decorator that ensures an update() method is run in the tornado ioloop.
Does this by checking the thread identity. Requires that the object to
which the method is bound has the attributes :attr:`_ioloop_thread_id`
(the result of thread.get_ident() in the ioloop thread) and :attr:`ioloop`
(the ioloop instance in use). Also assumes the signature
`update(self, sensor, reading)` for the method. | 3.127647 | 2.005549 | 1.559496 |
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, **kwargs)
elif strategyType == cls.AUTO:
return SampleAuto(inform_callback, sensor, *params, **kwargs)
elif strategyType == cls.EVENT:
return SampleEvent(inform_callback, sensor, *params, **kwargs)
elif strategyType == cls.DIFFERENTIAL:
return SampleDifferential(inform_callback, sensor,
*params, **kwargs)
elif strategyType == cls.PERIOD:
return SamplePeriod(inform_callback, sensor, *params, **kwargs)
elif strategyType == cls.EVENT_RATE:
return SampleEventRate(inform_callback, sensor, *params, **kwargs)
elif strategyType == cls.DIFFERENTIAL_RATE:
return SampleDifferentialRate(inform_callback, sensor,
*params, **kwargs) | 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. | 1.948221 | 2.032397 | 0.958583 |
strategy = self.get_sampling()
strategy = self.SAMPLING_LOOKUP[strategy]
params = [str(p) for p in self._params]
return strategy, params | 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 formatted parameters for the strategy. | 7.297851 | 5.420312 | 1.34639 |
s = self._sensor
self.update(s, s.read())
self._sensor.attach(self) | def attach(self) | Attach strategy to its sensor and send initial update. | 11.621017 | 6.02448 | 1.928966 |
if self.OBSERVE_UPDATES:
self.detach()
self.ioloop.add_callback(self.cancel_timeouts) | def cancel(self) | Detach strategy from its sensor and cancel ioloop callbacks. | 10.103631 | 6.46508 | 1.562801 |
def first_run():
self._ioloop_thread_id = get_thread_ident()
if self.OBSERVE_UPDATES:
self.attach()
self.ioloop.add_callback(first_run) | 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()`. | 8.956945 | 3.681215 | 2.433149 |
try:
self._inform_callback(self._sensor, reading)
except Exception:
log.exception('Unhandled exception trying to send {!r} '
'for sensor {!r} of type {!r}'
.format(reading, self._sensor.name, self._sensor.type)) | def inform(self, reading) | Inform strategy creator of the sensor status. | 4.154168 | 4.109275 | 1.010925 |
if not self._ioloop:
raise RuntimeError('Call get_ioloop() or set_ioloop() first')
self._ioloop.add_callback(self._running.set)
if self._ioloop_managed:
self._run_managed_ioloop()
else: # TODO this seems inconsistent with what the docstring describes
self._running.set()
if timeout:
return self._running.wait(timeout) | 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. | 6.662146 | 5.82982 | 1.14277 |
if timeout:
self._running.wait(timeout)
stopped_future = Future()
@gen.coroutine
def _stop():
if callback:
try:
yield gen.maybe_future(callback())
except Exception:
self._logger.exception('Unhandled exception calling stop callback')
if self._ioloop_managed:
self._logger.info('Stopping ioloop {0!r}'.format(self._ioloop))
# Allow ioloop to run once before stopping so that callbacks
# scheduled by callback() above get a chance to run.
yield gen.moment
self._ioloop.stop()
self._running.clear()
try:
self._ioloop.add_callback(
lambda: gen.chain_future(_stop(), stopped_future))
except AttributeError:
# Probably we have been shut-down already
pass
return stopped_future | def stop(self, timeout=None, callback=None) | Stop ioloop (if managed) and call callback in ioloop before close.
Parameters
----------
timeout : float or None
Seconds to wait for ioloop to have *started*.
Returns
-------
stopped : thread-safe Future
Resolves when the callback() is done | 4.325816 | 4.313943 | 1.002752 |
if not self._ioloop_managed:
# Do nothing if the loop is not managed
return
try:
self._ioloop_thread.join(timeout)
except AttributeError:
raise RuntimeError('Cannot join if not started') | def join(self, timeout=None) | Join managed ioloop thread, or do nothing if not managed. | 6.413261 | 3.974982 | 1.613406 |
@wraps(callable_)
def decorated(*args, **kwargs):
# Extract timeout from request itself or use default for ioloop wrapper
timeout = kwargs.get('timeout')
return self.call_in_ioloop(callable_, args, kwargs, timeout)
decorated.__doc__ = '\n\n'.join((
,
textwrap.dedent(decorated.__doc__ or '')))
return decorated | def decorate_callable(self, callable_) | Decorate a callable to use call_in_ioloop | 6.599028 | 5.515461 | 1.19646 |
parents = list(self._child_to_parents[sensor])
for parent in parents:
self.recalculate(parent, (sensor,)) | 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
Sensor reading as would be returned by sensor.read() | 10.944119 | 14.062197 | 0.778265 |
self._parent_to_children[sensor] = set()
self._child_to_parents[sensor] = set() | def _add_sensor(self, sensor) | Add a new sensor to the tree.
Parameters
----------
sensor : :class:`katcp.Sensor` object
New sensor to add to the tree. | 4.564373 | 5.495491 | 0.830567 |
new_sensors = []
if parent not in self:
self._add_sensor(parent)
new_sensors.append(parent)
for child in children:
if child not in self:
self._add_sensor(child)
new_sensors.append(child)
self._parent_to_children[parent].add(child)
self._child_to_parents[child].add(parent)
self.recalculate(parent, children)
for sensor in new_sensors:
sensor.attach(self) | 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. | 2.549267 | 2.489371 | 1.024061 |
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)
if not self._child_to_parents[child] and \
not self._parent_to_children[child]:
self._remove_sensor(child)
old_sensors.append(child)
if not self._child_to_parents[parent] and \
not self._parent_to_children[parent]:
self._remove_sensor(parent)
old_sensors.append(parent)
for sensor in old_sensors:
sensor.detach(self)
self.recalculate(parent, children) | 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. | 2.413444 | 2.316703 | 1.041758 |
if parent not in self._parent_to_children:
raise ValueError("Parent sensor %r not in tree." % parent)
return self._parent_to_children[parent].copy() | def children(self, parent) | Return set of children of parent.
Parameters
----------
parent : :class:`katcp.Sensor` object
Parent whose children to return.
Returns
-------
children : set of :class:`katcp.Sensor` objects
The child sensors of parent. | 4.703393 | 3.925156 | 1.198269 |
if child not in self._child_to_parents:
raise ValueError("Child sensor %r not in tree." % child)
return self._child_to_parents[child].copy() | def parents(self, child) | Return set of parents of child.
Parameters
----------
child : :class:`katcp.Sensor` object
Child whose parents to return.
Returns
-------
parents : set of :class:`katcp.Sensor` objects
The parent sensors of child. | 4.752187 | 3.921698 | 1.211768 |
if parent not in self:
if parent.stype != "boolean":
raise ValueError("Parent sensor %r is not boolean" % child)
self._parent_to_not_ok[parent] = set()
if child not in self:
if child.stype != "boolean":
raise ValueError("Child sensor %r is not booelan" % child)
self._parent_to_not_ok[child] = set()
self.add_links(parent, (child,)) | 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. | 4.125157 | 3.763869 | 1.095989 |
self.remove_links(parent, (child,))
if parent not in self and parent in self._parent_to_not_ok:
del self._parent_to_not_ok[parent]
if child not in self and child in self._parent_to_not_ok:
del self._parent_to_not_ok[child] | 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. | 3.095586 | 3.410023 | 0.90779 |
not_ok = self._parent_to_not_ok[parent]
children = self.children(parent) if parent in self else set()
for sensor in updates:
if sensor not in children or sensor.value():
not_ok.discard(sensor)
else:
not_ok.add(sensor)
parent.set_value(not not_ok) | def recalculate(self, parent, updates) | Re-calculate the value of parent sensor.
Parent's value is the boolean AND of all child sensors.
Parameters
----------
parent : :class:`katcp.Sensor` object
The sensor that needs to be updated.
updates : sequence of :class:`katcp.Sensor` objects
The child sensors which triggered the update. | 4.799489 | 4.427958 | 1.083906 |
if parent in self._aggregates or parent in self._incomplete_aggregates:
raise ValueError("Sensor %r already has an aggregate rule "
"associated" % parent)
self._aggregates[parent] = (rule_function, children)
self.add_links(parent, children) | 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.
children : sequence of :class:`katcp.Sensor` objects
The sensors the aggregate sensor depends on. | 5.304725 | 4.535813 | 1.16952 |
if parent in self._aggregates or parent in self._incomplete_aggregates:
raise ValueError("Sensor %r already has an aggregate rule"
" associated" % parent)
reg = self._registered_sensors
names = set(name for name in child_names if name not in reg)
sensors = set(reg[name] for name in child_names if name in reg)
if names:
self._incomplete_aggregates[parent] = (rule_function, names,
sensors)
else:
self.add(parent, rule_function, sensors) | 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. | 3.911915 | 3.408548 | 1.147678 |
child_name = self._get_sensor_reference(child)
if child_name in self._registered_sensors:
raise ValueError("Sensor %r already registered with aggregate"
" tree" % child)
self._registered_sensors[child_name] = child
completed = []
for parent, (_rule, names, sensors) in \
self._incomplete_aggregates.iteritems():
if child_name in names:
names.remove(child_name)
sensors.add(child)
if not names:
completed.append(parent)
for parent in completed:
rule_function, _names, sensors = \
self._incomplete_aggregates[parent]
del self._incomplete_aggregates[parent]
self.add(parent, rule_function, sensors) | 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. | 3.636192 | 3.75152 | 0.969258 |
for child in self._child_to_parents:
if self._get_sensor_reference(child) == reference:
return child | 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
A child sensor linked to one or more aggregate sensors. | 8.020343 | 6.85673 | 1.169704 |
if parent not in self._aggregates:
raise ValueError("Sensor %r does not have an aggregate rule "
"associated" % parent)
children = self.children(parent)
try:
self.remove_links(parent, children)
except Exception:
pass
del self._aggregates[parent] | def remove(self, parent) | Remove an aggregation rule.
Parameters
----------
parent : :class:`katcp.Sensor` object
The aggregate sensor to remove. | 5.40076 | 4.059456 | 1.330415 |
rule_function, children = self._aggregates[parent]
rule_function(parent, children) | def recalculate(self, parent, updates) | Re-calculate the value of parent sensor.
Parent's value is calculated by calling the associate aggregation rule.
Parameters
----------
parent : :class:`katcp.Sensor` object
The sensor that needs to be updated.
updates : sequence of :class:`katcp.Sensor` objects
The child sensors which triggered the update. | 18.868553 | 17.878021 | 1.055405 |
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]
params_start = 1 # Skip 'self' parameter
if has_req: # Skip 'req' parameter
params_start += 1
if include_msg:
params_start += 1
# Get other parameter names
argnames = all_argnames[params_start:]
if has_req and include_msg:
def raw_handler(self, req, msg):
new_args = unpack_types(types, msg.arguments, argnames, major)
return handler(self, req, msg, *new_args)
elif has_req and not include_msg:
def raw_handler(self, req, msg):
new_args = unpack_types(types, msg.arguments, argnames, major)
return handler(self, req, *new_args)
elif not has_req and include_msg:
def raw_handler(self, msg):
new_args = unpack_types(types, msg.arguments, argnames, major)
return handler(self, msg, *new_args)
elif not has_req and not include_msg:
def raw_handler(self, msg):
new_args = unpack_types(types, msg.arguments, argnames, major)
return handler(self, *new_args)
update_wrapper(raw_handler, handler)
# explicitly note that this decorator has been run, so that
# return_reply can know if it's on the outside.
raw_handler._request_decorated = True
return raw_handler
return decorator | 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)
... | 2.962966 | 2.645799 | 1.119876 |
major = options.pop('major', DEFAULT_KATCP_MAJOR)
if len(options) > 0:
raise TypeError('return_reply 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):
if not handler.__name__.startswith("request_"):
raise ValueError("This decorator can only be used on a katcp"
" request handler (method name should start"
" with 'request_').")
msgname = convert_method_name('request_', handler.__name__)
@wraps(handler)
def raw_handler(self, *args):
reply_args = handler(self, *args)
if gen.is_future(reply_args):
return async_make_reply(msgname, types, reply_args, major)
else:
return make_reply(msgname, types, reply_args, major)
# TODO NM 2017-01-12 Consider using the decorator module to create
# signature preserving decorators that would avoid the need for this
# trickery
if not getattr(handler, "_request_decorated", False):
# We are on the inside.
# We must preserve the original function parameter names for the
# request decorator
raw_handler._orig_argnames = inspect.getargspec(handler)[0]
return raw_handler
return decorator | 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)
... | 4.838656 | 5.013787 | 0.96507 |
major = options.pop('major', DEFAULT_KATCP_MAJOR)
if len(options) > 0:
raise TypeError('send_reply does not take keyword argument(s) %r.'
% options.keys())
def decorator(handler):
@wraps(handler)
def raw_handler(self, *args):
reply_args = handler(self, *args)
req = reply_args[0]
reply = make_reply(req.msg.name, types, reply_args[1:], major)
req.reply_with_message(reply)
return raw_handler
return decorator | 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
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):
... @send_reply(Int(), Float())
... def my_callback(self, req):
... return (req, "ok", 5, 2.0)
... | 3.712602 | 3.890224 | 0.954341 |
status = arguments[0]
if status == "fail":
return Message.reply(
msgname, *pack_types((Str(), Str()), arguments, major))
if status == "ok":
return Message.reply(
msgname, *pack_types((Str(),) + types, arguments, major))
raise ValueError("First returned value must be 'ok' or 'fail'.") | 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 | 5.532859 | 6.694808 | 0.82644 |
version_tuple = (major, minor)
def decorator(handler):
handler._minimum_katcp_version = version_tuple
return handler
return decorator | 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.
...
>>> class MyOldDevice(MyDevice):
... '''This device server will not expose ?myreq'''
...
... PROTOCOL_INFO = katcp.core.ProtocolFlags(5, 0)
... | 5.404253 | 5.551869 | 0.973411 |
if timeout_hint is not None:
timeout_hint = float(timeout_hint)
def decorator(handler):
handler.request_timeout_hint = timeout_hint
return handler
return decorator | 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())
... @request_timeout_hint(15) # Set request timeout hint to 15 seconds
... @tornado.gen.coroutine
... def request_myreq(self, req):
... '''A slow request'''
... result = yield self.slow_operation()
... raise tornado.gen.Return((req, result))
... | 2.76016 | 4.006677 | 0.68889 |
arguments = yield arguments_future
raise gen.Return(make_reply(msgname, types, arguments, major)) | def async_make_reply(msgname, types, arguments_future, major) | Wrap future that will resolve with arguments needed by make_reply(). | 4.002659 | 3.509778 | 1.140431 |
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):
name = ""
if i < len(argnames):
name = argnames[i]
params.append(Parameter(i+1, name, kattype, major))
if len(args) > len(types) and multiple:
for i in range(len(types), len(args)):
params.append(Parameter(i+1, name, kattype, major))
# if len(args) < len(types) this passes in None for missing args
return map(lambda param, arg: param.unpack(arg), params, args) | 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 | 3.568252 | 3.602418 | 0.990516 |
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: ktype.pack(arg, major=major),
types, args)
else:
retvals = [ktype.pack(arg, major=major)
for ktype, arg in zip(types, args)]
if len(args) > len(types) and multiple:
last_ktype = types[-1]
for arg in args[len(types):]:
retvals.append(last_ktype.pack(arg, major=major))
return retvals | 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 | 2.818601 | 2.806288 | 1.004388 |
if value is None:
value = self.get_default()
if value is None:
raise ValueError("Cannot pack a None value.")
if not nocheck:
self.check(value, major)
return self.encode(value, major) | 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
The unescaped KATCP string representing the value. | 3.233964 | 3.707254 | 0.872334 |
if packed_value is None:
value = self.get_default()
else:
try:
value = self.decode(packed_value, major)
except Exception:
raise
if value is not None:
self.check(value, major)
return value | 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. | 3.019921 | 3.367472 | 0.896792 |
if self._min is not None and value < self._min:
raise ValueError("Integer %d is lower than minimum %d."
% (value, self._min))
if self._max is not None and value > self._max:
raise ValueError("Integer %d is higher than maximum %d."
% (value, self._max)) | def check(self, value, major) | Check whether the value is between the minimum and maximum.
Raise a ValueError if it is not. | 1.977981 | 1.859249 | 1.06386 |
if self._case_insensitive:
value = value.lower()
values = self._valid_values_lower
caseflag = " (case-insensitive)"
else:
values = self._valid_values
caseflag = ""
if value not in values:
raise ValueError("Discrete value '%s' is not one of %s%s."
% (value, list(self._values), caseflag)) | def check(self, value, major) | Check whether the value in the set of allowed values.
Raise a ValueError if it is not. | 3.558244 | 3.25071 | 1.094605 |
for v in value:
super(DiscreteMulti, self).check(v, major) | def check(self, value, major) | Check that each item in the value list is in the allowed set. | 9.796257 | 7.857124 | 1.246799 |
# Wrap errors in FailReplies with information identifying the parameter
try:
return self._kattype.unpack(value, self.major)
except ValueError, message:
raise FailReply("Error in parameter %s (%s): %s" %
(self.position, self.name, message)) | def unpack(self, value) | Unpack the parameter using its kattype.
Parameters
----------
packed_value : str
The unescaped KATCP string to unpack.
Returns
-------
value : object
The unpacked value. | 14.075402 | 11.597549 | 1.213653 |
@wraps(fn)
def decorated(*args, **kwargs):
return gen.maybe_future(fn(*args, **kwargs))
return decorated | 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. | 2.705869 | 3.480808 | 0.777368 |
if pattern is None:
return False, lambda name: True
if pattern.startswith('/') and pattern.endswith('/'):
name_re = re.compile(pattern[1:-1])
return False, lambda name: name_re.search(name) is not None
return True, lambda name: name == pattern | 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
Function for determining whether a name matches the pattern. | 2.518484 | 2.166012 | 1.162728 |
self._server._disconnect_client(self._conn_key, self, reason) | def disconnect(self, reason) | Disconnect this client connection for specified reason | 10.54631 | 10.386719 | 1.015365 |
assert (msg.mtype == Message.INFORM)
return self._send_message(msg) | def inform(self, msg) | Send an inform message to a particular client.
Should only be used for asynchronous informs. Informs
that are part of the response to a request should use
:meth:`reply_inform` so that the message identifier
from the original request can be attached to the
inform.
Parameters
----------
msg : Message object
The inform message to send. | 8.472341 | 10.852576 | 0.780676 |
assert (inform.mtype == Message.INFORM)
assert (inform.name == orig_req.name)
inform.mid = orig_req.mid
return self._send_message(inform) | def reply_inform(self, inform, orig_req) | Send an inform as part of the reply to an earlier request.
Parameters
----------
inform : Message object
The inform message to send.
orig_req : Message object
The request message being replied to. The inform message's
id is overridden with the id from orig_req before the
inform is sent. | 4.796948 | 4.593643 | 1.044258 |
assert (msg.mtype == Message.INFORM)
return self._mass_send_message(msg) | def mass_inform(self, msg) | Send an inform message to all clients.
Parameters
----------
msg : Message object
The inform message to send. | 9.708404 | 10.728312 | 0.904933 |
assert (reply.mtype == Message.REPLY)
assert reply.name == orig_req.name
reply.mid = orig_req.mid
return self._send_message(reply) | def reply(self, reply, orig_req) | Send an asynchronous reply to an earlier request.
Parameters
----------
reply : Message object
The reply message to send.
orig_req : Message object
The request message being replied to. The reply message's
id is overridden with the id from orig_req before the
reply is sent. | 5.694724 | 5.687832 | 1.001212 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.