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
