generic_node.mustache

import bpy
import ladybug_tools.helper
from bpy.props import StringProperty
from sverchok.node_tree import SverchCustomTreeNode
from sverchok.data_structure import updateNode, zip_long_repeat

ghenv = ladybug_tools.helper.ghenv

class Sv{{{nickname}}}(bpy.types.Node, SverchCustomTreeNode):
    bl_idname = 'Sv{{{nickname}}}'
    bl_label = '{{{name}}}'
    sv_icon = 'LB_{{{nickname_uppercase}}}'
    {{#inputs}}
    sv_{{{name}}}: StringProperty(name='{{{name}}}', update=updateNode, description='{{{description}}}')
    {{/inputs}}

    def sv_init(self, context):
        self.width *= 1.3
        {{#inputs}}
        input_node = self.inputs.new('SvLBSocket', '{{{name}}}')
        input_node.prop_name = 'sv_{{{name}}}'
        input_node.tooltip = '{{{description}}}'
        {{/inputs}}
        {{#outputs}}
        output_node = self.outputs.new('SvLBSocket', '{{{name}}}')
        output_node.tooltip = '{{{description}}}'
        {{/outputs}}

    def draw_buttons(self, context, layout):
        op = layout.operator('node.sv_lb_socket_name', text='', icon='QUESTION', emboss=False).tooltip = '{{{description}}}'

    def process(self):
        if not any(socket.is_linked for socket in self.outputs):
            return

        self.sv_output_names = [{{{output_name_list}}}]
        for name in self.sv_output_names:
            setattr(self, '{}_out'.format(name), [])
        self.sv_input_names = [{{{input_name_list}}}]
        self.sv_input_types = [{{{input_type_list}}}]
        self.sv_input_defaults = [{{{input_default_list}}}]
        self.sv_input_access = [{{{input_access_list}}}]
        sv_inputs_nested = []
        for name in self.sv_input_names:
            sv_inputs_nested.append(self.inputs[name].sv_get())
        for sv_input_nested in zip_long_repeat(*sv_inputs_nested):
            for sv_input in zip_long_repeat(*sv_input_nested):
                sv_input = list(sv_input)
                for i, value in enumerate(sv_input):
                    if self.sv_input_access[i] == 'list':
                        if isinstance(value, (list, tuple)):
                            values = value
                        else:
                            values = [value]
                        value = [self.sv_cast(v, self.sv_input_types[i], self.sv_input_defaults[i]) for v in values]
                        if value == [None]:
                            value = []
                        sv_input[i] = value
                    else:
                        sv_input[i] = self.sv_cast(value, self.sv_input_types[i], self.sv_input_defaults[i])
                self.process_ladybug(*sv_input)
        for name in self.sv_output_names:
            value = getattr(self, '{}_out'.format(name))
            # Not sure if this hack is correct, will find out when more nodes are generated
            #if len(value) == 0 or not isinstance(value[0], (list, tuple)):
            #    value = [value]
            self.outputs[name].sv_set(value)

    def sv_cast(self, value, data_type, default):
        result = default if isinstance(value, str) and value == '' else value
        if result is None and data_type == 'bool':
            return False
        elif result is not None and data_type == 'bool':
            if result == 'True' or result == '1':
                return True
            elif result == 'False' or result == '0':
                return False
            return bool(result)
        elif result is not None and data_type == 'int':
            return int(result)
        elif result is not None and data_type == 'double':
            return float(result)
        return result

    def process_ladybug(self, {{{input_name_unquoted_list}}}):
{{{code}}}

        for name in self.sv_output_names:
            if name in locals():
                getattr(self, '{}_out'.format(name)).append([locals()[name]])


def register():
    bpy.utils.register_class(Sv{{{nickname}}})

def unregister():
    bpy.utils.unregister_class(Sv{{{nickname}}})