class MemoryTarget(Target): """ Knows how to talk to fake devices as if they were on the network. """ devices = dictobj.Field(sb.listof(sb.any_spec()), wrapper=sb.required) default_broadcast = dictobj.Field( sb.defaulted(sb.string_spec(), "255.255.255.255")) session_kls = makeMemorySession(NetworkSession)
class MemoryTarget(LanTarget): """ Knows how to talk to fake devices as if they were on the network. """ gaps = dictobj.Field( Gaps(gap_between_results=0.05, gap_between_ack_and_res=0.05, timeouts=[(0.2, 0.2)])) io_service = dictobj.Field(sb.any_spec, default=MemoryService) transport_kls = dictobj.Field(sb.any_spec, default=MemoryTransport) devices = dictobj.Field(sb.listof(sb.any_spec()), wrapper=sb.required) default_broadcast = dictobj.Field( sb.defaulted(sb.string_spec(), "255.255.255.255")) session_kls = makeMemorySession(NetworkSession)
def normalise_filled(self, meta, val): val = sized_list_spec(sb.any_spec(), 4).normalise(meta, val) res = [] for i, (v, s) in enumerate(zip(val, self.specs)): res.append(s.normalise(meta.at(i), v)) return res
("Uint16", 16, "<H", int), ("Int32", 32, "<i", int), ("Uint32", 32, "<I", int), ("Int64", 64, "<q", int), ("Uint64", 64, "<Q", int), ("Float", 32, "<f", float), ("Double", 64, "<d", float), ("Bytes", None, None, bytes), ("String", None, None, str), ("Reserved", None, None, bytes), ("CSV", None, None, (list, str, ",")), ("JSON", None, None, json), ) json_spec = sb.match_spec( (bool, sb.any_spec()), (int, sb.any_spec()), (float, sb.any_spec()), (str, sb.any_spec()), (list, lambda: sb.listof(json_spec)), (type(None), sb.any_spec()), fallback=lambda: sb.dictof(sb.string_spec(), json_spec), ) # Here so we don't have to instantiate these every time we get a value from a packet static_conversion_from_spec = { any: sb.any_spec(), bool: boolean(), float: float_spec(), (bool, int): boolean_as_int_spec(), json: json_spec,
it "knows about string_spec": self.assertSignature(sb.string_spec(), "string") it "knows about boolean": self.assertSignature(sb.boolean(), "boolean") it "knows about dictionary_spec": self.assertSignature(sb.dictionary_spec(), "dictionary") it "knows about string_choice_spec": self.assertSignature(sb.string_choice_spec(["one", "two"]), "choice of (one | two)") it "knows about optional_spec": self.assertSignature(sb.optional_spec(sb.integer_spec()), "integer (optional)") self.assertSignature(sb.optional_spec(sb.any_spec()), "(optional)") it "knows about defaulted": self.assertSignature(sb.defaulted(sb.integer_spec(), 20), "integer (default 20)") self.assertSignature(sb.defaulted(sb.any_spec(), True), "(default True)") it "knows about required": self.assertSignature(sb.required(sb.integer_spec()), "integer (required)") self.assertSignature(sb.required(sb.any_spec()), "(required)") it "knows about listof": self.assertSignature(sb.listof(sb.integer_spec()), "[ integer , ... ]") self.assertSignature(sb.listof(sb.any_spec()), "[ <item> , ... ]") it "knows about dictof": self.assertSignature(sb.dictof(sb.string_spec(), sb.integer_spec()), "{ string : integer }")
from photons_app.errors import BadTarget, BadOption, BadTask from photons_app.tasks.tasks import Task, GracefulTask from delfick_project.norms import sb, dictobj from collections import namedtuple artifact_spec = lambda: sb.optional_spec(sb.any_spec()) class target_spec(sb.Spec): def setup(self, restrictions, *, mandatory=True): self.mandatory = mandatory self.restrictions = restrictions def normalise_empty(self, meta): if not self.mandatory: return sb.NotSpecified usage = "lifx <target>:<task> <reference> <artifact> -- '{{<options>}}'" raise BadTarget("This task requires you specify a target", usage=usage, meta=meta) def normalise(self, meta, val): if val in ("", None, sb.NotSpecified): return self.normalise_empty(meta) collector = meta.everything["collector"] target_register = collector.configuration["target_register"] return target_register.restricted(**self.restrictions).resolve(val)
class Options(dictobj.Spec): got_event_fut = dictobj.NullableField(sb.any_spec()) record_annotations = dictobj.Field(sb.boolean, default=False) record_events_store = dictobj.Field(sb.any_spec(), wrapper=sb.required)
it "calls post_register": register = mock.Mock(name="register") collector = Collector() collector.register = register final_future = hp.create_future() photons_app = mock.Mock(name="photons_app", final_future=final_future) configuration = MergedOptions.using({"photons_app": photons_app}, dont_prefix=[dictobj]) args_dict = mock.Mock(name="args_dict") # Necessary setup for extra_prepare_after_activation collector.extra_configuration_collection(configuration) collector.register_converters( { "photons_app": sb.any_spec(), }, configuration=configuration, ) configuration.converters._converters.insert( 0, configuration.converters._converters.pop() ) configuration.converters.activate() collector.extra_prepare_after_activation(configuration, args_dict) assert configuration["final_future"] is final_future register.post_register.assert_called_once_with({"lifx.photons": {}}) it "creates and sets up a task finder": final_future = hp.create_future()