Vindicar

import typing as t
import enum


class Parser:
    @staticmethod
    def tokenize(line: str) -> t.Iterable[str]:
        token = []
        for ch in line:
            if ch.isalnum() or ch == '_':
                token.append(ch)
            else:
                if token:
                    yield ''.join(token)
                    token.clear()
                yield ch
        if token:
            yield ''.join(token)
    
    def process(self, line: str):
        tokens = list(self.tokenize(line))
        result = self.do_type(tokens)
        if tokens:
            raise ValueError('Extra tokens at the end of the line: {0!r}'.format(''.join(tokens)))
        return result
    
    def _consume(self, tokens: t.List[str], expected: t.Optional[str] = None):
        token = tokens.pop(0)
        if expected is not None and token != expected:
            raise ValueError(f'Expected {expected!r}, got {token!r}')
        return token
    
    def do_type(self, tokens: t.List[str]) -> t.Union[str, t.Dict]:
        if tokens[0] == 'struct':
            return self.do_struct(tokens)
        elif tokens[0] == 'array':
            return self.do_array(tokens)
        else:
            return self._consume(tokens)
    
    def do_struct(self, tokens: t.List[str]) -> t.Dict:
        self._consume(tokens, 'struct')
        self._consume(tokens, '<')
        result = {}
        while True:
            name, value = self.do_struct_part(tokens)
            result[name] = value
            if tokens[0] == ',':
                self._consume(tokens, ',')
            else:
                break
        self._consume(tokens, '>')
        return result
    
    def do_struct_part(self, tokens: t.List[str]) -> t.Tuple[str, t.Union[str, t.Dict]]:
        name = self._consume(tokens)
        self._consume(tokens, ':')
        value = self.do_type(tokens)
        return name, value
    
    def do_array(self, tokens: t.List[str]) -> t.Dict:
        self._consume(tokens, 'array')
        self._consume(tokens, '<')
        result = { None: self.do_type(tokens) }
        self._consume(tokens, '>')
        return result


data = 'struct<Milk:array<struct<id:string,type:string>>,Oil:string,batter:array<struct<id:string,type:string>>>'
p = Parser()
print(p.process(data))