Помогите привести во вменяймый вид функцию

STRING = "{}"
print(parenthesis([STRING]))
STRING = "{lol}"
print(parenthesis([STRING]))
STRING = "{lol{lol}lol}"
print(parenthesis([STRING]))
STRING = "{lol{lol}{lol}lol}"
print(parenthesis([STRING]))

Должен выдавать такое:

[]
[['lol']]
[['lol', ['lol'], 'lol']]
[['lol', ['lol'], ['lol'], 'lol']]

def b2l (s):
    s = s.replace("}{", "'],['")
    s = s.replace("{", "',['")
    s = s.replace("}", "'],'")
    return eval(s[2:-2])

for b in "{}", "{lol}", "{lol{lol}lol}", "{lol{lol}{lol}lol}":
    print(b, "=", b2l(b))

import re

def boo(str):
    result = []
    stack = [result]
    lastpos = None
    for match in re.finditer(r'[{}]', str):
        br = match.group(0)
        if lastpos and lastpos != match.start():
            stack[-1].append(str[lastpos:match.start()])

        if br == '{':
            cur = []
            stack[-1].append(cur)
            stack.append(cur)
        else:
            stack.pop()

        lastpos = match.end()

    return result


if __name__ == '__main__':
    print boo('')
    print boo('{}')
    print boo('{lol}')
    print boo('{lol{lol}lol}')
    print boo('{lol{lol}{lol}lol}') 

    def parenthesis(array):
        stack = []
        dictionary = 0
        for s in array[0].split('{'):
            if dictionary!=0:
                stack.append(dictionary)
            dictionary = []
            j = 0
            for s in s.split('}'):
                if j != 0:
                    if not stack:
                        return
                    t = stack.pop()
                    t.append(dictionary)
                    dictionary = t
                j = 1
                if s:
                    dictionary.append(s);
        if stack:
            return
        if dictionary==0:
            return
        return dictionary[0]

;; OPEN = \{
;; CLOSE = \}
;; WS(ignored) = [\s]*
;; TOKEN = [^\s\{\}]
;; EOF = $
(defun lex (in)
  (prog ((c nil)
         (token (make-array 0 :adjustable t
                              :fill-pointer t
                              :element-type 'character)))
     :start
     (setf c (read-char in nil nil))
     (case c
       ((nil) (return :eof))
       ((#\space #\tab #\return #\newline) (go :start))
       (#\{ (return :open))
       (#\} (return :close))
       (t (vector-push-extend c token)
          (go :token)))
     :token
     (setf c (read-char in nil nil))
     (case c
       ((nil) (return (values :token token)))
       ((#\{ #\} #\space #\tab #\return #\newline)
        (unread-char c in)
        (return (values :token token)))
       (t (vector-push-extend c token)
          (go :token)))))

;; Exprs -> EOF
;;          / Expr Exprs
;; Expr -> TOKEN
;;         / List
;; List -> OPEN ListBody
;; ListBody -> CLOSE
;;             / Expr ListBody
(defun parse (&optional (in *standard-input*))
  (let (token value)
    (labels ((next ()
               (setf (values token value) (lex in)))
             (exprs ()
               (case token
                 (:eof '())
                 (t (cons (expr) (exprs)))))
             (expr ()
               (case token
                 (:token (prog1 value (next)))
                 (t (list-begin))))
             (list-begin ()
               (case token
                 (:open (next) (list-body))
                 (t (error "Unexpected token: ~s" token))))
             (list-body ()
               (case token
                 (:close (next) '())
                 (t (cons (expr) (list-body))))))
      (next)
      (exprs))))