def __new__(cls, inputs, outputs): io_names = set() reserved = ("trig", "code", "code_parameter_", "persistent", "persistent_parameter_", "form") for inp in inputs: if inp.io_name in reserved: raise ValueError("Reserved input name: %s" % inp.io_name) if inp.io_name in io_names: raise ValueError("Duplicate input name: %s" % inp.io_name) io_names.add(inp.io_name) for outp in outputs: if outp.io_name in reserved: raise ValueError("Reserved output name: %s" % outp.io_name) if outp.io_name in io_names: raise ValueError("Duplicate input/output name: %s" % outp.io_name) io_names.add(outp.io_name) dic = { "trig": antenna("push", "trigger"), "code": variable("str"), "persistent": variable("bool"), } dic["code_parameter_"] = parameter(dic["code"], "") dic["persistent_parameter_"] = parameter(dic["persistent"], False) guiparams = {} guiparams["trig"] = {"name": "Trigger"} guiparams["_memberorder"] = ["trig"] counter = 0 for inp in inputs: name = inp.io_name name2 = name + "_" typ = inp.type_ if typ == "custom": typ = inp.customtype if typ: typ = stringtupleparser(typ) dic[name2] = antenna("pull", typ) dic[name] = buffer("pull", typ) guiparams[name2] = {"name": name} while 1: counter += 1 conname = "con" + str(counter) if conname not in io_names: break dic[conname] = connect(name2, name) for outp in outputs: name = outp.io_name name2 = name + "_" typ = outp.type_ guiparams[name2] = {"name": name} if typ == "custom": typ = outp.customtype if typ: typ = stringtupleparser(typ) if outp.mode == "trigger": dic[name2] = output("push", "trigger") dic[name2 + "trig_"] = triggerfunc(dic[name2]) dic[name] = variable("bool") else: dic[name2] = output(outp.mode, typ) dic[name] = buffer(outp.mode, typ) while 1: counter += 1 conname = "con" + str(counter) if conname not in io_names: break dic[conname] = connect(name, name2) dic["guiparams"] = guiparams return type("python", (_python_base,), dic)
def __new__(cls, syntaxmode, output_type, advanced, inputs): io_names = set() reserved = ("code", "code_parameter_", "outp", "v_outp", "con_outp", "form") output_type = stringtupleparser(output_type) cls_dict = { "code": variable("str"), "outp": output("pull", output_type), "v_outp": variable(output_type), "con_outp": connect("v_outp", "outp") } cls_dict["code_parameter_"] = parameter(cls_dict["code"], "") guiparams = {"outp": {"name": "Output"}} # Build set of IO names for input_ in inputs: if input_.io_name in reserved: raise ValueError("Reserved input name: %s" % input_.io_name) if input_.io_name in io_names: raise ValueError("Duplicate input name: %s" % input_.io_name) io_names.add(input_.io_name) # Create connections for input_ in inputs: buffer_name = input_.io_name antenna_name = buffer_name + "_" type_ = input_.type_ if type_ == "custom": type_ = input_.customtype if type_: type_ = stringtupleparser(type_) cls_dict[antenna_name] = antenna("pull", type_) cls_dict[buffer_name] = buffer("pull", type_) guiparams[antenna_name] = {"name": buffer_name} # Ensure we don't have a name clash with IO names connection_name = antenna_name + "connection" while connection_name in io_names: connection_name += "_" cls_dict[connection_name] = connect(antenna_name, buffer_name) cls_dict["guiparams"] = guiparams return type("python", (_python_base,), cls_dict)
def __new__(cls, type_): type_ = stringtupleparser(type_) class pull_buffer(bee.worker): __doc__ = cls.__doc__ # Implementation inp = antenna("pull", type_) value_ = buffer("pull", type_) outp = output("pull", type_) connect(inp, value_) connect(value_, outp) trig = antenna("push", "trigger") trigger(trig, value_) parameter(value_) @staticmethod def form(f): f.value_.name = "Value" guiparams = { "inp": { "name": "Input", "foldable": False }, "outp": { "name": "Output" }, "trig": { "name": "Trigger" }, "_memberorder": ["trig", "inp", "outp"], } return pull_buffer
def __new__(cls, type_): type_ = stringtupleparser(type_) class transistor(bee.worker): __doc__ = cls.__doc__ # Implementation val = antenna("pull", type_) trans = bee.segments.transistor(type_) outp = output("push", type_) connect(val, trans) connect(trans, outp) trig = antenna("push", "trigger") trigger(trig, trans) guiparams = { "val": { "name": "Value" }, "outp": { "name": "Output" }, "trig": { "name": "Trigger" }, "_memberorder": ["trig", "val", "outp"], } return transistor
def __new__(cls, type_): type_ = stringtupleparser(type_) class splitter(bee.worker): __doc__ = cls.__doc__ # One input value inp = antenna("push", type_) # Three output values outp1 = output("push", type_) outp2 = output("push", type_) outp3 = output("push", type_) connect(inp, outp1) connect(inp, outp2) connect(inp, outp3) guiparams = { "inp": { "name": "Input" }, "outp1": { "name": "Output 1" }, "outp2": { "name": "Output 2" }, "outp3": { "name": "Output 3" }, } return splitter
def __new__(cls, mode, type_): type_ = stringtupleparser(type_) class hop_out(bee.worker): __doc__ = cls.__doc__ name_ = variable("str") parameter(name_) outp = output(mode, type_) b_outp = buffer(mode, type_) connect(b_outp, outp) trig_outp = triggerfunc(b_outp) @staticmethod def form(f): f.name_.name = "Name" guiparams = { "outp": {"name": "Output"}, } def place(self): raise NotImplementedError("sparta.assessors.hop_out is not designed for use outside of the Hive GUI") return hop_out
def __new__(cls, type_): type_ = stringtupleparser(type_) class variable(bee.worker): __doc__ = cls.__doc__ # Implementation inp = antenna("push", type_) value_ = bee.segments.variable(type_) outp = output("pull", type_) connect(inp, value_) connect(value_, outp) parameter(value_) @staticmethod def form(f): f.value_.name = "Value" guiparams = { "inp": { "name": "Input", "advanced": True }, "outp": { "name": "Output" }, } return variable
def __new__(cls, mode, type_): type_ = stringtupleparser(type_) class hop_in(bee.worker): __doc__ = cls.__doc__ name_ = variable("str") parameter(name_) inp = antenna(mode, type_) b_inp = buffer(mode, type_) connect(inp, b_inp) trig_inp = triggerfunc(b_inp) @staticmethod def form(f): f.name_.name = "Name" guiparams = { "inp": {"name": "Input", "foldable": False}, } def place(self): raise NotImplementedError("sparta.assessors.hop_in is not designed for use outside of the Hive GUI") return hop_in
def __new__(cls, type_): type_ = stringtupleparser(type_) class pull_buffer(bee.worker): __doc__ = cls.__doc__ # Implementation inp = antenna("pull", type_) value_ = buffer("pull", type_) outp = output("pull", type_) connect(inp, value_) connect(value_, outp) trig = antenna("push", "trigger") trigger(trig, value_) parameter(value_) @staticmethod def form(f): f.value_.name = "Value" guiparams = { "inp": {"name": "Input", "foldable": False}, "outp": {"name": "Output"}, "trig": {"name": "Trigger"}, "_memberorder": ["trig", "inp", "outp"], } return pull_buffer
def __new__(cls, mode, type_): type_ = stringtupleparser(type_) class hop_out(bee.worker): __doc__ = cls.__doc__ name_ = variable("str") parameter(name_) outp = output(mode, type_) b_outp = buffer(mode, type_) connect(b_outp, outp) trig_outp = triggerfunc(b_outp) @staticmethod def form(f): f.name_.name = "Name" guiparams = { "outp": { "name": "Output" }, } def place(self): raise NotImplementedError( "sparta.assessors.hop_out is not designed for use outside of the Hive GUI" ) return hop_out
def __new__(cls, mode, type_): type_ = stringtupleparser(type_) class hop_in(bee.worker): __doc__ = cls.__doc__ name_ = variable("str") parameter(name_) inp = antenna(mode, type_) b_inp = buffer(mode, type_) connect(inp, b_inp) trig_inp = triggerfunc(b_inp) @staticmethod def form(f): f.name_.name = "Name" guiparams = { "inp": { "name": "Input", "foldable": False }, } def place(self): raise NotImplementedError( "sparta.assessors.hop_in is not designed for use outside of the Hive GUI" ) return hop_in
def __new__(cls, type_): type_ = stringtupleparser(type_) class compare(bee.worker): __doc__ = cls.__doc__ # Comparison mode mode = variable("str") parameter(mode, "equal") # Two input values inp1 = antenna("pull", type_) inp2 = antenna("pull", type_) # One output value returning the result of the comparision outp = output("pull", "bool") result = variable("bool") connect(result, outp) # Whenever the result of the comparison is requested.. # ...pull in the input values... b_inp1 = buffer("pull", type_) connect(inp1, b_inp1) pretrigger(result, b_inp1) b_inp2 = buffer("pull", type_) connect(inp1, b_inp2) pretrigger(result, b_inp2) # ...and then compare the values @modifier def do_compare(self): if self.mode == "equal": result = (self.b_inp1 == self.b_inp2) elif self.mode == "greater": result = (self.b_inp1 > self.b_inp2) elif self.mode == "lesser": result = (self.b_inp1 < self.b_inp2) self.result = result pretrigger(result, do_compare) # Specify names for the comparison mode @staticmethod def form(f): f.mode.name = "Mode" f.mode.type = "option" f.mode.options = "equal", "greater", "lesser" f.mode.optiontitles = "EqualTo", "GreaterThan", "LesserThan" guiparams = { "inp1": {"name": "Input 1"}, "inp2": {"name": "Input 2"}, "outp": {"name": "Output"}, } return compare
def stringtupleparser2(s): if s.count("'") % 2: return s if s.count('"') % 2: return s if isinstance(s, str): if s.startswith("(") and not s.rstrip().endswith(")"): s = s.replace("'", "") s = s[1:-2] + s[-1] return s ret = deslash(stringtupleparser(s)) return ret
def __new__(cls, type_): type_ = stringtupleparser(type_) class change(bee.worker): __doc__ = cls.__doc__ inp = antenna("pull", type_) b_inp = buffer("pull", type_) connect(inp, b_inp) trig = output("push", "trigger") trigfunc = triggerfunc(trig) pullfunc = triggerfunc(b_inp) # Name the inputs and outputs guiparams = { "inp": { "name": "Input" }, "trig": { "name": "Trigger" }, } def update_value(self): self.pullfunc() if self.previous_state != self.b_inp: self.trigfunc() self.previous_state = self.b_inp def enable(self): # Add a high-priority deactivate() listener on every tick self.add_listener("trigger", self.update_value, "tick", priority=9) def set_add_listener(self, add_listener): self.add_listener = add_listener def place(self): self.previous_state = None libcontext.socket( ("evin", "add_listener"), socket_single_required(self.set_add_listener)) #Make sure we are enabled at startup libcontext.plugin(("bee", "init"), plugin_single_required(self.enable)) return change
def __new__(cls, type_): type_ = stringtupleparser(type_) class between(bee.worker): __doc__ = cls.__doc__ # Input values inp = antenna("pull", type_) if type_ == "int": spydertype = "IntRange" elif type_ == "float": spydertype = "FloatRange" range_ = antenna("pull", spydertype) # One output value returning the result of the comparison outp = output("pull", "bool") result = variable("bool") connect(result, outp) # Whenever the result of the comparison is requested.. # ...pull in the input values... b_inp = buffer("pull", type_) connect(inp, b_inp) pretrigger(result, b_inp) b_range = buffer("pull", spydertype) connect(range_, b_range) pretrigger(result, b_range) # ...and then compare the values @modifier def do_compare(self): self.result = self.b_range.minimum <= self.b_inp <= self.b_range.maximum pretrigger(result, do_compare) guiparams = { "inp": { "name": "Input" }, "range_": { "name": "Range", "fold": True }, "outp": { "name": "Output" }, } return between
def reserve_slot(slot): import bee from bee.types import stringtupleparser from dragonfly.canvas import box2d c = bee.configure(slot.canvasname) b = slot.box box = box2d(b.x, b.y, b.sizex, b.sizey, b.mode) params = None col = slot.color if col is not None: params = parameters(color=(col.r,col.g,col.b,col.a)) c.reserve ( slot.slotname, stringtupleparser(slot.slottype), box=box, parameters=params, ) return c
def __new__(cls, type_): type_ = stringtupleparser(type_) class between(bee.worker): __doc__ = cls.__doc__ # Input values inp = antenna("pull", type_) if type_ == "int": spydertype = "IntRange" elif type_ == "float": spydertype = "FloatRange" range_ = antenna("pull", spydertype) # One output value returning the result of the comparison outp = output("pull", "bool") result = variable("bool") connect(result, outp) # Whenever the result of the comparison is requested.. # ...pull in the input values... b_inp = buffer("pull", type_) connect(inp, b_inp) pretrigger(result, b_inp) b_range = buffer("pull", spydertype) connect(range_, b_range) pretrigger(result, b_range) # ...and then compare the values @modifier def do_compare(self): self.result = self.b_range.minimum <= self.b_inp <= self.b_range.maximum pretrigger(result, do_compare) guiparams = { "inp": {"name": "Input"}, "range_": {"name": "Range", "fold": True}, "outp": {"name": "Output"}, } return between
def __new__(cls, type_): type_ = stringtupleparser(type_) class transistor(bee.worker): __doc__ = cls.__doc__ # Implementation val = antenna("pull", type_) trans = bee.segments.transistor(type_) outp = output("push", type_) connect(val, trans) connect(trans, outp) trig = antenna("push", "trigger") trigger(trig, trans) guiparams = { "val": {"name": "Value"}, "outp": {"name": "Output"}, "trig": {"name": "Trigger"}, "_memberorder": ["trig", "val", "outp"], } return transistor
def __new__(cls, type_): type_ = stringtupleparser(type_) class variable(bee.worker): __doc__ = cls.__doc__ # Implementation inp = antenna("push", type_) value_ = bee.segments.variable(type_) outp = output("pull", type_) connect(inp, value_) connect(value_, outp) parameter(value_) @staticmethod def form(f): f.value_.name = "Value" guiparams = { "inp": {"name": "Input", "advanced": True}, "outp": {"name": "Output"}, } return variable
def __new__(cls, type_): type_ = stringtupleparser(type_) class splitter(bee.worker): __doc__ = cls.__doc__ # One input value inp = antenna("push", type_) # Three output values outp1 = output("push", type_) outp2 = output("push", type_) outp3 = output("push", type_) connect(inp, outp1) connect(inp, outp2) connect(inp, outp3) guiparams = { "inp": {"name": "Input"}, "outp1": {"name": "Output 1"}, "outp2": {"name": "Output 2"}, "outp3": {"name": "Output 3"}, } return splitter
def __new__(cls, idmode, type_): assert idmode in ("bound", "unbound", "fallback"), idmode type_ = stringtupleparser(type_) class set_property(bee.worker): __doc__ = cls.__doc__ trig = antenna("push", "trigger") property_name = antenna("pull", ("str", "property")) property_name_buffer = buffer("pull", ("str", "property")) connect(property_name, property_name_buffer) property_value = antenna("pull", type_) property_value_buffer = buffer("pull", type_) connect(property_value, property_value_buffer) trigger(trig, property_name_buffer) trigger(trig, property_value_buffer) # Entity Identifier if idmode == "unbound": identifier = antenna("pull", ("str", "identifier")) identifier_buffer = buffer("pull", ("str", "identifier")) connect(identifier, identifier_buffer) trigger(trig, identifier_buffer) @modifier def set_property_value(self): self.set_property_for(self.identifier_buffer, self.property_name_buffer, self.property_value_buffer) def set_set_property_for(self, set_property_for): self.set_property_for = set_property_for else: @modifier def set_property_value(self): self.set_property(self.property_name_buffer, self.property_value_buffer) def set_set_property(self, set_property): self.set_property = set_property # Name the inputs and outputs guiparams = { "trig": { "name": "Trigger" }, "identifier": { "name": "Identifier", "fold": True }, "property_name": { "name": "Property Name", "fold": True }, "property_value": { "name": "Property Value" }, "_memberorder": ["trig", "identifier", "property_name", "property_value"], } trigger(trig, set_property_value) def place(self): if idmode == "bound": libcontext.socket( ("entity", "bound", "property", "set"), socket_single_required(self.set_set_property)) else: libcontext.socket( ("entity", "property", "set"), socket_single_required(self.set_set_property_for)) return set_property
def __new__(cls, idmode, type_): assert idmode in ("bound", "unbound", "fallback"), idmode type_ = stringtupleparser(type_) class mod_property(bee.worker): __doc__ = cls.__doc__ trig = antenna("push", "trigger") property_name = antenna("pull", ("str", "property")) property_name_buffer = buffer("pull", ("str", "property")) connect(property_name, property_name_buffer) trigger(trig, property_name_buffer) modifier_value = antenna("pull", type_) modifier_value_buffer = buffer("pull", type_) connect(modifier_value, modifier_value_buffer) trigger(trig, modifier_value_buffer) mode = variable("str") parameter(mode, "add") if idmode == "unbound": identifier = antenna("pull", ("str", "identifier")) identifier_buffer = buffer("pull", ("str", "identifier")) connect(identifier, identifier_buffer) trigger(trig, identifier_buffer) @modifier def modify_property_value(self): entity_name = self.identifier_buffer property_name = self.property_name_buffer modifier_value = self.modifier_value_buffer property_value = self.get_property(entity_name, property_name) operation = self.get_operation() result = operation(property_value, modifier_value) self.set_property(entity_name, property_name, result) def set_get_property_for(self, get_property_for): self.get_property_for = get_property_for def set_set_property_for(self, set_property_for): self.set_property_for = set_property_for else: @modifier def modify_property_value(self): property_name = self.property_name_buffer modifier_value = self.modifier_value_buffer property_value = self.get_property(property_name) operation = self.get_operation() result = operation(property_value, modifier_value) self.set_property(property_name, result) def set_get_property(self, get_property): self.get_property = get_property def set_set_property(self, set_property): self.set_property = set_property # Name the inputs and outputs guiparams = { "trig": {"name": "Trigger"}, "identifier": {"name": "Identifier", "fold": True}, "property_name": {"name": "Property Name", "fold": True}, "modifier_value": {"name": "Modification Value", "fold": True}, "_memberorder": ["trig", "identifier", "property_name", "modifier_value"], } @classmethod def form(cls, f): f.mode.name = "Modification mode" f.mode.type = "option" f.mode.options = "add", "sub", "mul", "div" f.mode.optiontitles = "Add", "Subtract", "Multiply", "Divide" f.mode.default = "add" trigger(trig, modify_property_value) def get_operation(self): mode = self.mode if mode == "add": return operator.add if mode == "sub": return operator.sub if mode == "mul": return operator.mul return operator.truediv def place(self): if idmode == "bound": libcontext.socket(("entity", "bound", "property", "set"), socket_single_required(self.set_set_property)) libcontext.socket(("entity", "bound", "property", "get"), socket_single_required(self.set_get_property)) else: libcontext.socket(("entity", "property", "set"), socket_single_required(self.set_set_property_for)) libcontext.socket(("entity", "property", "get"), socket_single_required(self.set_get_property_for)) return mod_property
def __new__(cls, idmode, type_): assert idmode in ("bound", "unbound", "fallback"), idmode type_ = stringtupleparser(type_) class set_property(bee.worker): __doc__ = cls.__doc__ trig = antenna("push", "trigger") property_name = antenna("pull", ("str", "property")) property_name_buffer = buffer("pull", ("str", "property")) connect(property_name, property_name_buffer) property_value = antenna("pull", type_) property_value_buffer = buffer("pull", type_) connect(property_value, property_value_buffer) trigger(trig, property_name_buffer) trigger(trig, property_value_buffer) # Entity Identifier if idmode == "unbound": identifier = antenna("pull", ("str", "identifier")) identifier_buffer = buffer("pull", ("str", "identifier")) connect(identifier, identifier_buffer) trigger(trig, identifier_buffer) @modifier def set_property_value(self): self.set_property_for(self.identifier_buffer, self.property_name_buffer, self.property_value_buffer) def set_set_property_for(self, set_property_for): self.set_property_for = set_property_for else: @modifier def set_property_value(self): self.set_property(self.property_name_buffer, self.property_value_buffer) def set_set_property(self, set_property): self.set_property = set_property # Name the inputs and outputs guiparams = { "trig": {"name": "Trigger"}, "identifier": {"name": "Identifier", "fold": True}, "property_name": {"name": "Property Name", "fold": True}, "property_value": {"name": "Property Value"}, "_memberorder": ["trig", "identifier", "property_name", "property_value"], } trigger(trig, set_property_value) def place(self): if idmode == "bound": libcontext.socket(("entity", "bound", "property", "set"), socket_single_required(self.set_set_property)) else: libcontext.socket(("entity", "property", "set"), socket_single_required(self.set_set_property_for)) return set_property
def __new__(cls, idmode, type_): assert idmode in ("bound", "unbound"), idmode type_ = stringtupleparser(type_) class get_property(bee.worker): __doc__ = cls.__doc__ property_name = antenna("pull", ("str", "property")) property_name_buffer = buffer("pull", ("str", "property")) connect(property_name, property_name_buffer) property_value = output("pull", type_) property_value_variable = variable(type_) connect(property_value_variable, property_value) trigger_property_name = triggerfunc(property_name_buffer) if idmode == "unbound": identifier = antenna("pull", ("str", "identifier")) identifier_buffer = buffer("pull", ("str", "identifier")) connect(identifier, identifier_buffer) trigger_identifier_buffer = triggerfunc(identifier_buffer) @modifier def read_property_value(self): self.trigger_property_name() self.trigger_identifier_buffer() self.property_value_variable = self.get_property_for(self.identifier_buffer, self.property_name_buffer) def set_get_property_for(self, get_property_for): self.get_property_for = get_property_for else: @modifier def read_property_value(self): self.trigger_property_name() self.property_value_variable = self.get_property(self.property_name_buffer) def set_get_property(self, get_property): self.get_property = get_property pretrigger(property_value_variable, read_property_value) # Name the inputs and outputs guiparams = { "identifier": {"name": "Identifier", "fold": True}, "property_name": {"name": "Property Name", "fold": True}, "property_value": {"name": "Property Value"}, "_memberorder": ["identifier", "property_name", "property_value"], } def place(self): if idmode == "bound": libcontext.socket(("entity", "bound", "property", "get"), socket_single_required(self.set_get_property)) else: libcontext.socket(("entity", "property", "get"), socket_single_required(self.set_get_property_for)) return get_property
def __new__(cls, idmode, type_): assert idmode in ("bound", "unbound"), idmode type_ = stringtupleparser(type_) class get_property(bee.worker): __doc__ = cls.__doc__ property_name = antenna("pull", ("str", "property")) property_name_buffer = buffer("pull", ("str", "property")) connect(property_name, property_name_buffer) property_value = output("pull", type_) property_value_variable = variable(type_) connect(property_value_variable, property_value) trigger_property_name = triggerfunc(property_name_buffer) if idmode == "unbound": identifier = antenna("pull", ("str", "identifier")) identifier_buffer = buffer("pull", ("str", "identifier")) connect(identifier, identifier_buffer) trigger_identifier_buffer = triggerfunc(identifier_buffer) @modifier def read_property_value(self): self.trigger_property_name() self.trigger_identifier_buffer() self.property_value_variable = self.get_property_for( self.identifier_buffer, self.property_name_buffer) def set_get_property_for(self, get_property_for): self.get_property_for = get_property_for else: @modifier def read_property_value(self): self.trigger_property_name() self.property_value_variable = self.get_property( self.property_name_buffer) def set_get_property(self, get_property): self.get_property = get_property pretrigger(property_value_variable, read_property_value) # Name the inputs and outputs guiparams = { "identifier": { "name": "Identifier", "fold": True }, "property_name": { "name": "Property Name", "fold": True }, "property_value": { "name": "Property Value" }, "_memberorder": ["identifier", "property_name", "property_value"], } def place(self): if idmode == "bound": libcontext.socket( ("entity", "bound", "property", "get"), socket_single_required(self.set_get_property)) else: libcontext.socket( ("entity", "property", "get"), socket_single_required(self.set_get_property_for)) return get_property