sv_lang_compiler.py

sn_lang_str = """\


<sv_main>
  inputs:
    verts: v [[]] some_socket_name
    edges: s [[]]
    radius: s 0.3
  outputs:
    verts: v verts_out
    edges: s edges_out
    mask: s masked_items_out

"""


class sn_parser(object):

    in_sockets = []
    out_sockets = []
    output_lines = ""
    state = -1

    def __init__(self, fstring, indentation=4):
        self.file_as_string = fstring
        self.indent = indentation * ' '
        self.convert()
        self.construct()

    def convert(self):
        split_lines = self.file_as_string.split('\n')
        for line in [i for i in split_lines if i]:
            line_type = self.process(line)

    def process(self, line):
        line = line.strip()

        if '<sv_main>' in line:
            self.state = 0
            self.output_lines += 'def sv_main('

        if line.startswith('inputs'):
            self.state = 1
            return

        if line.startswith('outputs'):
            self.state = 2
            return

        if self.state == 1:
            if line.count(':'):
                leftside, rightside = line.split(':')
                '''
                leftside is name of variable,
                rightside is type and default value

                edges: s [[]] ui_name_on_socket <- optional 3rd param
                edges: s [[]]                   <- default socket name
                '''
                var = lambda: None
                var.name = leftside.strip()
                args = rightside.split(' ')
                args = [v for v in args if v]
                num_args = len(args)
                if not num_args in {2, 3}:
                    return

                args = [v.strip() for v in args]
                if num_args == 2:
                    var.type, var.default = args
                else:
                    var.type, var.default, var.socket_name = args
                self.in_sockets.append(var)
            return

        if self.state == 2:
            if line.count(':'):
                leftside, rightside = line.split(':')
                '''
                leftside is name of socket_output,
                rightside is type and variable sent to socket

                mask: s masked_items_out
                '''
                var = lambda: None
                var.name = leftside.strip()
                args = rightside.split(' ')
                args = [v for v in args if v]
                if not len(args) == 2:
                    return

                args = [v.strip() for v in args]
                var.type, var.socket_variable = args
                self.out_sockets.append(var)
            return

    def construct(self):
        _lines = str(self.output_lines)

        ''' add defaults to sv_main '''
        for var in self.in_sockets:
            _lines += (var.name + '=' + var.default + ', ')
        _lines = _lines[:-2] + '):\n'

        self.output_lines = _lines

        ''' add out_socket_vars '''
        out_variables = ''
        for var in self.out_sockets:
            out_variables += (self.indent + var.socket_variable + ' = []\n')
        out_variables += '\n'
        self.output_lines += out_variables

        ''' add in_sockets '''
        self.output_lines += self.make_sockets('in', self.in_sockets)

        ''' add out_sockets '''
        self.output_lines += '\n'
        self.output_lines += self.make_sockets('out', self.out_sockets)

        ''' add return statement '''
        if self.in_sockets and self.out_sockets:
            self.output_lines += '\n'
            self.output_lines += self.indent + 'return in_sockets, out_sockets'
            self.output_lines += '\n'

    def make_sockets(self, direction, sockets):
        sockets_str = ''
        socket_type = direction + '_sockets'
        sockets_str += (self.indent + socket_type + ' = [\n')
        for var in sockets:
            ind = self.indent * 2
            sock_name = var.socket_name if hasattr(var, 'socket_name') else var.name
            variables = {
                'type': var.type,
                'sock_name': sock_name,
                'var_ref': var.name if direction == 'in' else var.socket_variable
            }
            k = """['{type}', '{sock_name}', {var_ref}],\n"""
            k = k.format(**variables)
            sockets_str += ind + k

        sockets_str = sockets_str[:-2]
        sockets_str += '\n' + (self.indent + "]\n")
        return sockets_str

    @property
    def result(self):
        return self.output_lines


obj = sn_parser(sn_lang_str)
print(obj.result)