def test_dyna():
DynaDogHive = hive.dyna_hive("Dog", build_dog, declare_dog)
print("\n#1: MetaArg=2, Arg='Jack'")
d = DynaDogHive(2, "Jack")
d.bark_0()
d.bark_1()
print("\n#2: MetaArg=1, Arg='Jill'")
d = DynaDogHive(1, "Jill")
d.bark_0()
print("\n#3: MetaArg=1, Arg='Bobby'")
d = DynaDogHive(1, "Bobby")
d.bark_0()
kwarg_fields.append(field_name)
# Create IO
attr = hive.attribute()
setattr(i, field_name, attr)
in_attr = hive.pull_in(attr)
setattr(i, "{}_in".format(field_name), in_attr)
setattr(ex, field_name, hive.antenna(in_attr))
hive.trigger(i.result_out, in_attr, pretrigger=True)
ex.result = hive.output(i.result_out)
def do_format(self):
args = [
getattr(self, "_{}".format(attr_name))
for attr_name in indexed_fields
]
kwargs = {
attr_name: getattr(self, "_{}".format(attr_name))
for attr_name in kwarg_fields
}
self._result = formatter.format(format_string, *args, **kwargs)
i.func = hive.modifier(do_format)
hive.trigger(i.result_out, i.func, pretrigger=True)
Format = hive.dyna_hive("Format", build_format, declarator=declare_format)
import hive
def declare_sorted(meta_args):
meta_args.data_type = hive.parameter('str', 'list', {'list', 'dict', 'set', 'tuple'})
def build_sorted(i, ex, args, meta_args):
"""Sort an iterable and output list"""
args.reverse = hive.parameter('bool', False)
i.reverse = hive.attribute('bool', args.reverse)
i.result = hive.attribute('list')
i.pull_result = hive.pull_out(i.result)
ex.result = hive.output(i.pull_result)
i.value = hive.attribute(meta_args.data_type)
i.pull_value = hive.pull_in(i.value)
ex.value = hive.antenna(i.pull_value)
def sort(self):
self._result = sorted(self._value, reverse=self._reverse)
i.sort = hive.modifier(sort)
hive.trigger(i.pull_result, i.pull_value, pretrigger=True)
hive.trigger(i.pull_value, i.sort)
Sorted = hive.dyna_hive("Sorted", build_sorted, declare_sorted)
i.push_key = hive.push_in(i.key)
ex.key = hive.antenna(i.push_key)
i.on_key_changed = hive.triggerable(cls.change_listener_keys)
hive.trigger(i.push_key, i.on_key_changed)
i.on_pressed = hive.triggerfunc()
ex.on_pressed = hive.hook(i.on_pressed)
i.on_released = hive.triggerfunc()
ex.on_released = hive.hook(i.on_released)
i.is_pressed = hive.property(cls, "is_pressed", "bool")
i.pull_is_pressed = hive.pull_out(i.is_pressed)
ex.is_pressed = hive.output(i.pull_is_pressed)
else:
ex.on_event = hive.socket(cls.add_any_listener, identifier="event.add_handler")
i.key_pressed = hive.property(cls, 'key_pressed', data_type='str.keycode')
i.pull_key_pressed = hive.push_out(i.key_pressed)
ex.key_pressed = hive.output(i.pull_key_pressed)
i.key_released = hive.property(cls, 'key_released', data_type='str.keycode')
i.pull_key_released = hive.push_out(i.key_released)
ex.key_released = hive.output(i.pull_key_released)
Keyboard = hive.dyna_hive("Keyboard", build_keyboard, declarator=declare_keyboard, builder_cls=Keyboard_)
def declare_filler(meta_args):
meta_args.i = hive.parameter("int", 2)
def build_filler(i, ex, args, meta_args):
print("NEW FILLER", meta_args.i)
if meta_args.i:
i.inner = FillerHive(meta_args.i - 1, import_namespace=True)
ex.inner = hive.hook(i.inner)
else:
i.inner = DogHive(import_namespace=True, name="DOGGY")
ex.inner = hive.hook(i.inner)
FillerHive = hive.dyna_hive("FillerHive", build_filler, declarator=declare_filler)
class House(object):
def get_current_hive(self):
return self
def build_house(cls, i, ex, args):
ex.some_plugin = hive.plugin(cls.get_current_hive, identifier="get.house", data_type="float")
# Auto connect
i.filler = FillerHive()
ex.filler = hive.hook(i.filler)
def declare_max(meta_args):
meta_args.data_type = hive.parameter('str', 'float', options={'complex', 'int', 'float'})
def build_max(i, ex, args, meta_args):
"""Determine the maximum of two values"""
i.a_value = hive.variable(meta_args.data_type)
i.b_value = hive.variable(meta_args.data_type)
i.value = hive.variable(meta_args.data_type)
i.pull_a = hive.pull_in(i.a_value)
i.pull_b = hive.pull_in(i.b_value)
i.pull_value = hive.pull_out(i.value)
ex.value = hive.output(i.pull_value)
ex.a = hive.antenna(i.pull_a)
ex.b = hive.antenna(i.pull_b)
def do_max(self):
self._value = max(self._a, self._b)
i.do_max = hive.modifier(do_max)
hive.trigger(i.pull_value, i.pull_a, pretrigger=True)
hive.trigger(i.pull_a, i.pull_b)
hive.trigger(i.pull_b, i.do_max)
Max = hive.dyna_hive("Max", build_max, declare_max)
def build_unpack_tuple(i, ex, args, meta_args):
"""Unpack a tuple from individual inputs"""
i.tuple_ = hive.attribute('tuple')
i.push_tuple = hive.push_in(i.tuple_)
ex.tuple_ = hive.antenna(i.push_tuple)
for index, data_type in enumerate(meta_args.types):
attr = hive.attribute(data_type)
setattr(i, "attr_{}".format(index), attr)
pull_out = hive.pull_out(attr)
setattr(i, "pull_out_{}".format(index), pull_out)
setattr(ex, "item_{}".format(index), hive.output(pull_out))
def do_unpack_tuple(self):
tuple_ = self._tuple_
data_types = meta_args.types
assert len(tuple_) == len(data_types)
for index, item in enumerate(tuple_):
setattr(self, "_attr_{}".format(index), item)
i.do_unpack_tuple = hive.modifier(do_unpack_tuple)
hive.trigger(i.push_tuple, i.do_unpack_tuple)
UnpackTuple = hive.dyna_hive("UnpackTuple", build_unpack_tuple,
declare_unpack_tuple)
""".format(argument_string)
exec(func_body, locals(), globals())
return func
def build_any(i, ex, args, meta_args):
"""Trigger output if any inputs evaluate to True"""
# On pull
func = build_any_func(meta_args.count)
i.run_any = hive.modifier(func)
i.result = hive.attribute(meta_args.data_type, False)
i.pull_result = hive.pull_out(i.result)
ex.result = hive.output(i.pull_result)
hive.trigger(i.pull_result, i.run_any, pretrigger=True)
for index, char in zip(range(meta_args.count), string.ascii_lowercase):
variable = hive.attribute(meta_args.data_type, False)
setattr(i, char, variable)
pull_in = hive.pull_in(variable)
setattr(i, "pull_{}".format(char), pull_in)
antenna = hive.antenna(pull_in)
setattr(ex, char, antenna)
Any = hive.dyna_hive("Any", build_any, declare_any)
"""Store the input value and output saved value.
In pull mode, the trigger is used to update the internal value.
In push mode, the trigger is used to output the internal value.
Can be used to cache changing values
"""
args.start_value = hive.parameter(meta_args.data_type, None)
i.cached_value = hive.attribute(meta_args.data_type, args.start_value)
if meta_args.mode == "push":
i.push_value = hive.push_in(i.cached_value)
ex.value = hive.antenna(i.push_value)
i.push_cached_value = hive.push_out(i.cached_value)
ex.cached_value = hive.output(i.push_cached_value)
ex.output = hive.entry(i.push_cached_value)
elif meta_args.mode == "pull":
i.pull_value = hive.pull_in(i.cached_value)
ex.value = hive.antenna(i.pull_value)
i.pull_cached_value = hive.pull_out(i.cached_value)
ex.cached_value = hive.output(i.pull_cached_value)
ex.update_cache = hive.entry(i.pull_value)
Buffer = hive.dyna_hive("Buffer", build_buffer, declarator=declare_buffer)
self._hive.entity_id()
return dict(entity_id=self.entity_id)
return {}
@factory.builds_external
def build_bind(cls, i, ex, args, meta_args):
bind_mode = meta_args.bind_entity
if bind_mode == 'bound':
i.entity_id = hive.property(cls, "entity_id", "int.entity_id")
i.pull_entity_id = hive.pull_in(i.entity_id)
ex.entity_id = hive.antenna(i.pull_entity_id)
_BindEntity = hive.dyna_hive("BindEntity",
build_bind,
declarator=factory.external_declarator,
builder_cls=EntityCls)
def get_environment(meta_args):
if meta_args.bind_entity != 'none':
return _EntityEnvironment
return None
bind_info = BindInfo("entity", _BindEntity, get_environment)
import hive
def declare_abs(meta_args):
meta_args.data_type = hive.parameter('str',
'int',
options={'int', 'complex', 'float'})
def build_abs(i, ex, args, meta_args):
"""Calculate the absolute abs() of a value"""
i.value = hive.variable(meta_args.data_type)
i.pull_value = hive.pull_in(i.value)
i.result = hive.variable(meta_args.data_type)
i.pull_result = hive.pull_out(i.result)
ex.value = hive.antenna(i.pull_value)
ex.result = hive.output(i.pull_result)
def do_abs(self):
self._result = abs(self._value)
i.do_abs = hive.modifier(do_abs)
hive.trigger(i.pull_result, i.pull_value, pretrigger=True)
hive.trigger(i.pull_value, i.do_abs)
Abs = hive.dyna_hive("Abs", build_abs, declarator=declare_abs)
meta_args.mode = hive.parameter("str", "get", {'get', 'set'})
meta_args.bound = hive.parameter("bool", True)
def build_visibility(cls, i, ex, args, meta_args):
"""Set/Get entity visibility"""
if meta_args.bound:
ex.get_bound_id = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound")
i.do_get_entity_id = hive.triggerable(cls.get_bound_entity)
else:
i.entity_id = hive.property(cls, "entity_id", "int.entity_id")
i.do_get_entity_id = hive.pull_in(i.entity_id)
ex.entity_id = hive.antenna(i.do_get_entity_id)
if meta_args.mode == 'get':
ex.get_get_visibility = hive.socket(cls.set_get_visibility, identifier="entity.visibility.get")
i.pull_visibility = hive.pull_out(cls.get_visibility)
ex.visibility = hive.output(i.pull_visibility)
hive.trigger(i.pull_visibility, i.do_get_entity_id, pretrigger=True)
else:
ex.get_set_visibility = hive.socket(cls.set_set_visibility, identifier="entity.visibility.set")
i.push_in_visibility = hive.push_in(cls.set_visibility)
ex.visibility = hive.antenna(i.push_in_visibility)
hive.trigger(i.push_in_visibility, i.do_get_entity_id, pretrigger=True)
Visibility = hive.dyna_hive("Visibility", build_visibility, declare_visibility, builder_cls=VisibilityClass)
ex.in_ = hive.antenna(i.in_)
hive.trigger(i.in_, )
i.out = meta_args.out(i.value)
ex.out = hive.output(i.out)
else:
i.value = hive.variable()
i.in_ = meta_args.in_(i.value)
ex.in_ = hive.antenna(i.in_)
i.out = meta_args.out(i.value)
ex.out = hive.output(i.out)
IOMethod = hive.dyna_hive("IOMethd", build_io, declarator=declare_io)
def build_struct(cls, i, ex, args):
"""Interface to Struct class"""
i.tuple = hive.variable("tuple")
i.pack_in = hive.push_in(i.tuple)
ex.pack = hive.antenna(i.pack_in)
i.bytes = hive.variable("bytes")
i.unpack_out = hive.push_out(i.bytes)
ex.unpack = hive.output(i.unpack_out)
i.size_out = hive.pull_out(cls.size)
ex.size = hive.output(i.size_out)
self._result = all({})
""".format(argument_string)
exec(func_body, locals(), globals())
return func
def build_all(i, ex, args, meta_args):
"""Trigger output if all inputs evaluate to True"""
# On pull
func = build_all_func(meta_args.count)
i.trigger = hive.modifier(func)
i.result = hive.variable(meta_args.data_type, False)
pull_out = hive.pull_out(i.result)
ex.output = hive.output(pull_out)
hive.trigger(pull_out, i.trigger, pretrigger=True)
for index, char in zip(range(meta_args.count), string.ascii_lowercase):
variable = hive.variable(meta_args.data_type, False)
setattr(i, char, variable)
pull_in = hive.pull_in(variable)
antenna = hive.antenna(pull_in)
setattr(ex, char, antenna)
All = hive.dyna_hive("All", build_all, declare_all)
i.result = hive.variable('bool')
i.pull_a = hive.pull_in(i.a)
if is_single_arg:
ex.value = hive.antenna(i.pull_a)
def calc(self):
self._result = op(self._a)
else:
ex.a = hive.antenna(i.pull_a)
def calc(self):
self._result = op(self._a, self._b)
i.pull_b = hive.pull_in(i.b)
ex.b = hive.antenna(i.pull_b)
hive.trigger(i.pull_a, i.pull_b)
i.run_operator = hive.modifier(calc)
i.pull_result = hive.pull_out(i.result)
ex.result = hive.output(i.pull_result)
hive.trigger(i.pull_a, i.run_operator)
hive.trigger(i.pull_result, i.pull_a, pretrigger=True)
BoolOperator = hive.dyna_hive("BoolOperator", build_operator, declare_operator)
import hive
from struct import pack, unpack_from, calcsize
def declare_struct(meta_args):
pass
def build_struct(i, ex, args, meta_args):
pass
Struct = hive.dyna_hive("Struct", build_struct, declarator=declare_struct)
ex.get_index = hive.antenna(i.pull_getitem_index)
i.pull_getitem = hive.pull_out(i.item)
ex.getitem = hive.output(i.pull_getitem)
def do_getitem(self):
self._item = self._list[self._index]
i.do_getitem = hive.modifier(do_getitem)
hive.trigger(i.pull_getitem, i.pull_getitem_index, pretrigger=True)
hive.trigger(i.pull_getitem_index, i.do_getitem)
# Setitem
i.pull_setitem_index = hive.pull_in(i.item)
ex.set_index = hive.antenna(i.pull_setitem_index)
i.push_setitem = hive.push_in(i.item)
ex.setitem = hive.antenna(i.push_setitem)
def do_setitem(self):
self._list[self._index] = self._item
i.do_setitem = hive.modifier(do_setitem)
hive.trigger(i.push_setitem, i.pull_setitem_index)
hive.trigger(i.pull_setitem_index, i.do_setitem)
List = hive.dyna_hive("List", build_list, declare_list)
self._result = next(iterator)
except StopIteration:
self._iterator = None
next_modifier(self)
def declare_next(meta_args):
meta_args.data_type = hive.parameter("str", "int")
def build_next(i, ex, args, meta_args):
"""Iterate over generator object, output new value when pulled"""
i.iterator = hive.attribute("iterator")
i.iterator_in = hive.pull_in(i.iterator)
ex.iterator = hive.antenna(i.iterator_in)
i.pull_iterator = hive.triggerfunc()
hive.trigger(i.pull_iterator, i.iterator_in)
i.result = hive.attribute(meta_args.data_type)
i.pull_value = hive.pull_out(i.result)
ex.value = hive.output(i.pull_value)
i.do_next = hive.modifier(next_modifier)
hive.trigger(i.pull_value, i.do_next, pretrigger=True)
Next = hive.dyna_hive("Next", build_next, declarator=declare_next)
hive.trigger(i.pull_position, i.pull_entity_id, pretrigger=True)
hive.trigger(i.pull_position, i.do_get_position, pretrigger=True)
else:
if coordinate_system == 'absolute':
ex.get_set_position = hive.socket(
cls.set_set_position,
identifier="entity.position.set.absolute")
i.do_set_position = hive.triggerable(cls.do_set_position)
else:
ex.get_set_position = hive.socket(
cls.set_set_position,
identifier="entity.position.set.relative")
i.do_set_position = hive.triggerable(cls.do_set_relative_position)
hive.trigger(i.push_position, i.pull_other_entity_id)
if meta_args.bound:
hive.trigger(i.push_position, i.do_get_entity_id)
else:
hive.trigger(i.push_position, i.pull_entity_id)
hive.trigger(i.push_position, i.do_set_position)
Position = hive.dyna_hive("Position",
build_position,
declare_position,
builder_cls=PositionClass)
def build_expression(i, ex, args, meta_args):
"""Evaluate Python expression and store result"""
ast_node = ast.parse(meta_args.expression, mode='eval')
# Visit AST and find variable names
visitor = VariableRecorder()
visitor.visit(ast_node)
variable_names = visitor.undefined_ids
i.result = hive.variable(meta_args.result_type)
i.pull_result = hive.pull_out(i.result)
ex.result = hive.output(i.pull_result)
for name in variable_names:
attribute = hive.variable(meta_args.result_type)
setattr(i, name, attribute)
pull_in = hive.pull_in(attribute)
setattr(ex, name, hive.antenna(pull_in))
hive.trigger(i.pull_result, pull_in, pretrigger=True)
func = create_func(meta_args.expression, variable_names)
i.modifier = hive.modifier(func)
hive.trigger(i.pull_result, i.modifier, pretrigger=True)
Expression = hive.dyna_hive("Expression",
build_expression,
declarator=declare_expression)
else:
callback = self.on_event
handler = EventHandler(callback, self.event, mode=mode)
add_handler(handler)
def declare_listener(meta_args):
meta_args.mode = hive.parameter("str",
'leader',
options={'leader', 'match', 'trigger'})
def build_listener(cls, i, ex, args, meta_args):
"""Tick event sensor, trigger on_tick every tick"""
i.on_event = hive.triggerfunc()
ex.on_event = hive.hook(i.on_event)
ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler")
if meta_args.mode == 'leader':
i.after_leader = hive.property(cls, 'after_leader', 'tuple')
i.pull_after_leader = hive.pull_out(i.after_leader)
ex.after_leader = hive.output(i.pull_after_leader)
Listener = hive.dyna_hive("Listener",
build_listener,
builder_cls=_ListenerCls,
declarator=declare_listener)
ex.add_get_plugins = hive.socket(cls.add_get_plugins,
identifier="bind.get_plugins",
policy=hive.MultipleOptional)
ex.add_get_config = hive.socket(cls.add_get_config,
identifier="bind.get_config",
policy=hive.MultipleOptional)
# Bind instantiator
if meta_args.bind_process == 'child':
# Add startup and stop callbacks
ex.on_stopped = hive.plugin(cls.stop_all_processes,
identifier="on_stopped")
Instantiator = hive.dyna_hive("Instantiator",
build_instantiator,
declare_instantiator,
builder_cls=InstantiatorClass)
def create_instantiator(*bind_infos, docstring=""):
"""Create instantiator Hive for particular BindInfo sequence
:param bind_infos: BindInfos to embed
"""
def build_instantiator(i, ex, args, meta_args):
bind_environments = get_active_bind_environments(bind_infos, meta_args)
# Update bind environment to use new bases
environment_class = i.bind_meta_class.start_value
i.bind_meta_class.start_value = environment_class.extend(
"BindEnvironment", bases=tuple(bind_environments))
def build_watch(cls, i, ex, args, meta_args):
"""Watch value and indicate when it is changed.
Uses a tick callback.
"""
args.start_value = hive.parameter(meta_args.data_type, None)
i.value = hive.property(cls, "current_value", meta_args.data_type, args.start_value)
if meta_args.mode == 'pull':
i.value_in = hive.pull_in(i.value)
else:
i.value_in = hive.push_in(i.value)
ex.value = hive.antenna(i.value_in)
i.on_changed = hive.triggerfunc()
ex.on_changed = hive.hook(i.on_changed)
if meta_args.mode == 'pull':
ex.get_add_handler = hive.socket(cls.set_add_handler, identifier="event.add_handler")
else:
i.compare_values = hive.triggerable(cls.compare_values)
hive.trigger(i.value_in, i.compare_values)
Watch = hive.dyna_hive("Watch", build_watch, declare_watch, builder_cls=WatchClass)
meta_args.data_type = hive.parameter("str", "int")
meta_args.advanced = hive.parameter("bool", False)
def build_variable(i, ex, args, meta_args):
"""Simple value-holding hive"""
args.start_value = hive.parameter(meta_args.data_type)
ex.value = hive.variable(meta_args.data_type, args.start_value)
i.pull_value = hive.pull_out(ex.value)
ex.value_out = hive.output(i.pull_value)
i.push_value = hive.push_in(ex.value)
ex.value_in = hive.antenna(i.push_value)
if meta_args.advanced:
i.pre_output = hive.triggerfunc()
ex.pre_output = hive.hook(i.pre_output)
i.do_pre_output = hive.triggerable(i.pre_output)
hive.trigger(i.pull_value, i.do_pre_output, pretrigger=True)
Variable = hive.dyna_hive("Variable", build_variable, declarator=declare_variable)
# Helpers
_MetaVariable = Variable.extend("MetaVariable", is_dyna_hive=False)
VariableStr = _MetaVariable(data_type='str')
VariableInt = _MetaVariable(data_type='int')
VariableFloat = _MetaVariable(data_type='float')
VariableBool = _MetaVariable(data_type='bool')
import hive
def declare_transistor(meta_args):
meta_args.data_type = hive.parameter("str", "int")
def build_transistor(i, ex, args, meta_args):
"""Convert a pull output into a push output, using a trigger input"""
i.value = hive.variable(meta_args.data_type)
i.pull_value = hive.pull_in(i.value)
ex.value = hive.antenna(i.pull_value)
i.push_value = hive.push_out(i.value)
ex.result = hive.output(i.push_value)
ex.trigger = hive.entry(i.pull_value)
hive.trigger(i.pull_value, i.push_value)
Transistor = hive.dyna_hive("Transistor", build_transistor, declare_transistor)
hive.trigger(i.pull_velocity, i.pull_other_entity_id, pretrigger=True)
if meta_args.bound:
hive.trigger(i.pull_velocity, i.do_get_entity_id, pretrigger=True)
else:
hive.trigger(i.pull_velocity, i.pull_entity_id, pretrigger=True)
hive.trigger(i.pull_velocity, i.do_get_velocity, pretrigger=True)
else:
if coordinate_system == 'absolute':
ex.get_set_velocity = hive.socket(cls.set_set_velocity, identifier="entity.linear_velocity.set")
i.do_set_velocity = hive.triggerable(cls.do_set_velocity)
else:
ex.get_set_velocity = hive.socket(cls.set_set_velocity, identifier="entity.linear_velocity.set")
i.do_set_velocity = hive.triggerable(cls.do_set_relative_velocity)
hive.trigger(i.push_velocity, i.pull_other_entity_id)
if meta_args.bound:
hive.trigger(i.push_velocity, i.do_get_entity_id)
else:
hive.trigger(i.push_velocity, i.pull_entity_id)
hive.trigger(i.push_velocity, i.do_set_velocity)
Velocity = hive.dyna_hive("Velocity", build_velocity, declare_velocity, builder_cls=VelocityClass)
self.name = None
def declare_dog(meta_args):
print("Invoked Declarator")
meta_args.puppies = hive.parameter(("int", ), 1)
def build_dog(cls, i, ex, args, meta_args):
print(meta_args)
print("Invoked Builder")
args.name = hive.parameter("str")
ex.name = hive.property(cls, "name", "str", args.name)
for ix in range(meta_args.puppies):
mod = hive.modifier(lambda h: print("Puppy {} barked".format(h.name)))
setattr(i, "mod_{}".format(ix), mod)
setattr(ex, "bark_{}".format(ix), hive.entry(mod))
DogHive = hive.dyna_hive("Dog", build_dog, declare_dog, Dog)
d = DogHive(2, "Jack")
d.bark_0()
d.bark_1()
print()
d = DogHive(1, "Jill")
d.bark_0()
'float',
options={'complex', 'int', 'float'})
def build_constrain(i, ex, args, meta_args):
"""Constrain a value between two bounding values"""
args.min_value = hive.parameter(meta_args.data_type)
args.max_value = hive.parameter(meta_args.data_type)
i.min_value = hive.attribute(meta_args.data_type, args.min_value)
i.max_value = hive.attribute(meta_args.data_type, args.max_value)
i.value = hive.attribute(meta_args.data_type)
i.result = hive.attribute(meta_args.data_type)
i.pull_result = hive.pull_out(i.result)
i.pull_value = hive.pull_in(i.value)
ex.result = hive.output(i.pull_result)
ex.value = hive.antenna(i.pull_value)
def do_contrain(self):
self._result = min(max(self._value, self._min_value), self._max_value)
i.do_constrain = hive.modifier(do_contrain)
hive.trigger(i.pull_result, i.pull_value, pretrigger=True)
hive.trigger(i.pull_value, i.do_constrain)
Constrain = hive.dyna_hive("Constrain", build_constrain, declare_constrain)
def build_operator(i, ex, args, meta_args):
"""HIVE interface to python mathematical operators"""
assert meta_args.operator in operators
op = operators[meta_args.operator]
i.a = hive.attribute(meta_args.data_type)
i.b = hive.attribute(meta_args.data_type)
i.pull_a = hive.pull_in(i.a)
ex.a = hive.antenna(i.pull_a)
i.pull_b = hive.pull_in(i.b)
ex.b = hive.antenna(i.pull_b)
hive.trigger(i.pull_a, i.pull_b)
i.result = hive.attribute(meta_args.data_type)
i.pull_result = hive.pull_out(i.result)
ex.result = hive.output(i.pull_result)
def calc(self):
self._result = op(self._a, self._b)
i.run_operator = hive.modifier(calc)
hive.trigger(i.pull_a, i.run_operator)
hive.trigger(i.pull_result, i.pull_a, pretrigger=True)
MathOperator = hive.dyna_hive("MathOperator", build_operator, declare_operator)
i.ppin = hive.pull_in(i.value_in)
i.ppout = hive.pull_out(i.value_out)
hive.trigger(i.ppout, i.ppin, pretrigger=True)
ex.value_in = hive.antenna(i.ppin)
ex.value_out = hive.output(i.ppout)
# For casting (explicit conversion)
if meta_args.conversion == "cast":
to_type_tuple = hive.identifier_to_tuple(meta_args.to_data_type)
to_base_type_name = to_type_tuple[0]
value_cls = _type_map[to_base_type_name]
def converter(self):
self._value_out = value_cls(self._value_in)
i.do_conversion = hive.modifier(converter)
hive.trigger(i.ppout, i.do_conversion, pretrigger=True)
# For duck typing, move value through
else:
i.move_value = hive.modifier(move_value)
hive.trigger(i.ppin, i.move_value)
Convert = hive.dyna_hive("Convert",
builder=build_convert,
declarator=declare_convert)
