Нужен совет как сделать ML

@dataclass
class Token:
  type: TokenType
  value: str

@dataclass
class Parser:
  stream: typing.TextIO
  curch: str | None = None
  nextch: str | None = None
  def readch(self) -> str: ...
  def advance(self):
    self.curch, self.nextch = self.nextch, self.readch() 
  def peekch(self, charset: str) -> bool:
    if self.nextch in charset:
       self.advance()
       return True
    return False
  def parse(self) -> Iterable[Token]:
    self.advance()
    while True:
      if self.peekch('\\'):
        val = ''  # Если эта косая палка не нужна, а она не нужна в принципе
        # Тут еще один цикл
        while self.peekch('abcdef...A..Z'):
          val += self.curch
        yield Token(TokenType.Tag, val)
      if self.peekch(''):
        return Token(TokenType.EOF, self.curch)

input: str | None = None # разбираемая строка
def match(self, pat: re.Pattern) -> str | Literal[False]:
  if m := pat.match(self.input):
    rv = m.group(0)
    # Все время обрезаем строку
    self.input = self.input[len(rv):]
    return rv
  return False

NAME_RE = re.complile('[a-z]\w*')
if val := self.match(NAME_RE):
   yield Token('NAME', val)

import re
from dataclasses import dataclass


@dataclass
class Token:
    name: str
    value: str


@dataclass
class Tokenizer:
    token_types = {
        "ID": re.compile(r"[a-z]\w*", re.I),
        "NUMBER": re.compile(r"\d+(\.\d*)?"),
        "SPACE": re.compile(r"\s+"),
        "OPERATOR": re.compile(r"[-+*/()=]"),
    }

    def next_token(self) -> Token:
        for token_name, token_pat in self.token_types.items():
            if m := token_pat.match(self.input):
                val = m.group(0)
                self.input = self.input[len(val) :]
                return Token(token_name, val)
        raise ValueError()

    def tokenize(self, input_: str) -> list[Token]:
        self.input = input_
        rv = []
        while self.input:
            tok = self.next_token()
            rv.append(tok)
        return rv


assert Tokenizer().tokenize("res = 2 + 2 * 2") == [
    Token(name="ID", value="res"),
    Token(name="SPACE", value=" "),
    Token(name="OPERATOR", value="="),
    Token(name="SPACE", value=" "),
    Token(name="NUMBER", value="2"),
    Token(name="SPACE", value=" "),
    Token(name="OPERATOR", value="+"),
    Token(name="SPACE", value=" "),
    Token(name="NUMBER", value="2"),
    Token(name="SPACE", value=" "),
    Token(name="OPERATOR", value="*"),
    Token(name="SPACE", value=" "),
    Token(name="NUMBER", value="2"),
]

from __future__ import annotations

import operator
import re
import typing
from dataclasses import dataclass


class Token(typing.NamedTuple):
    type: str
    value: str


class TokenizerError(Exception):
    pass


class Tokenizer:
    TOKEN_TYPES = {
        # "ID": re.compile(r"[a-z]\w*", re.I),
        "NUMBER": re.compile(r"\d+(\.\d*)?"),
        "SPACE": re.compile(r"\s+"),
        "ADDSUB": re.compile(r"[-+]"),
        "MULDIV": re.compile(r"[*/]"),
        "LPAREN": re.compile(r"\("),
        "RPAREN": re.compile(r"\)"),
        "EOF": re.compile(r"$"),
    }

    def get_token(self) -> Token:
        for typ, pat in self.TOKEN_TYPES.items():
            if m := pat.match(self.input, self.pos):
                self.pos = m.end()
                return Token(typ, m.group(0))
        raise TokenizerError(f"unpexpected character at position: {self.pos}")

    def tokenize(self, input_: str) -> list[Token]:
        self.input = input_
        self.pos = 0
        rv = []
        while 1:
            t = self.get_token()
            rv.append(t)
            if t.type == "EOF":
                break
        return rv


class Expr:
    def eval(self) -> int:
        raise NotImplemented


@dataclass
class Const(Expr):
    val: int

    def eval(self) -> int:
        return self.val


@dataclass
class BinOp(Expr):
    op: str
    left: Expr
    right: Expr

    def eval(self) -> int:
        return {
            "+": operator.add,
            "-": operator.sub,
            "*": operator.mul,
            "/": operator.floordiv,
        }[self.op](
            self.left.eval(),
            self.right.eval(),
        )


@dataclass
class UnaryOp(Expr):
    op: str
    right: Expr

    def eval(self) -> int:
        return {
            "+": operator.pos,
            "-": operator.neg,
        }[self.op](
            self.right.eval(),
        )


class ParseError(Exception):
    pass


class Parser:
    def advance(self) -> None:
        self.cur_tok, self.next_tok = self.next_tok, next(self.token_it, None)

    def match(self, token_type: str) -> bool:
        if self.next_tok is not None and self.next_tok.type == token_type:
            self.advance()
            return True
        return False

    def expect(self, token_type: str) -> None:
        if not self.match(token_type):
            raise ParseError(
                f"Unexpected token: expected {token_type!r}, got {self.next_tok.type!r}"
            )

    def factor(self) -> Expr:
        if self.match("LPAREN"):
            rv = self.expr()
            self.expect("RPAREN")
            return rv
        if self.match("ADDSUB"):
            return UnaryOp(op=self.cur_tok.value, right=self.factor())
        self.expect("NUMBER")
        return Const(val=float(self.cur_tok.value))

    def muldiv(self) -> Expr:
        rv = self.factor()
        while self.match("MULDIV"):
            rv = BinOp(left=rv, op=self.cur_tok.value, right=self.factor())
        return rv

    def addsub(self) -> Expr:
        rv = self.muldiv()
        while self.match("ADDSUB"):
            rv = BinOp(left=rv, op=self.cur_tok.value, right=self.muldiv())
        return rv

    expr = addsub

    def parse(self, tokens: list[Token]) -> Expr:
        # Всякий мусор типа пробелов и комментариев фильтруют
        self.token_it = filter(lambda t: t.type != "SPACE", tokens)
        self.next_tok = None
        self.advance()
        rv = self.expr()
        self.expect("EOF")
        print(rv)
        return rv


import sys

tokens = Tokenizer().tokenize(sys.argv[1])
print(tokens)
print(Parser().parse(tokens).eval())

BinOp(op='+', left=Const(val=2.0), right=BinOp(op='*', left=Const(val=2.0), right=Const(val=2.0)))

(+ 2.0 (* 2.0 2.0))

class Token(typing.NamedTuple):
    type: str
    value: str


class Tokenizer:
    TOKEN_TYPES = {
        "NUMBER": r"\d+(\.\d*)?",
        "SPACE": r"\s+",
        "ADDSUB": r"[-+]",
        "MULDIV": r"[*/]",
        "LPAREN": r"\(",
        "RPAREN": r"\)",
        "EOF": "$",
        # must by last
        "UNEXPECTED": ".",
    }

    @cached_property
    def re_token(self) -> re.Pattern:
        return re.compile(
            "|".join(f"(?P<{k}>{v})" for k, v in self.TOKEN_TYPES.items())
        )

    def tokenize(self, s: str) -> typing.Iterable[Token]:
        def make_token(m: re.Match) -> Token:
            if m.lastgroup == "UNEXPECTED":
                raise ValueError(f"Unexpected character at offset {m.start()}")
            return Token(m.lastgroup, m.group(m.lastgroup))

        return map(make_token, self.re_token.finditer(s))

from __future__ import annotations

import string
import typing
from dataclasses import dataclass, field
from io import StringIO


class Node:
    pass


@dataclass
class Element(Node):
    name: str
    attrs: dict[str, str] = field(default_factory=dict)
    children: list[Node] = field(default_factory=list)


@dataclass
class Text(Node):
    value: str


class SyntaxError(Exception):
    pass


class MLParser:
    def readch(self) -> str:
        return self.fp.read(1)

    def advance(self) -> None:
        self.curch, self.nextch = self.nextch, self.readch()

    def match(self, charset: str) -> bool:
        if self.nextch and self.nextch in charset:
            self.advance()
            return True
        return False

    def expect(self, charset: str) -> None:
        if not self.match(charset):
            raise SyntaxError(f"syntax error at offset {self.fp.tell()}")

    def parse_name(self) -> str:
        rv = ""
        while self.match(string.ascii_letters):
            rv += self.curch
        if not rv:
            raise SyntaxError("required name")
        return rv

    def skip_spaces(self) -> None:
        while self.match(string.whitespace):
            pass

    def parse_quouted(self) -> str:
        self.expect('"')
        rv = ""
        while True:
            if not self.nextch:
                raise SyntaxError("unexpected end")
            if self.match('"'):
                break
            self.advance()
            rv += self.curch
        return rv

    def handle_close_tag(self) -> None:
        name = self.parse_name()
        self.expect(">")
        if not self.open_tags or self.open_tags.pop() != name:
            raise SyntaxError(f"unexpected close tag {name}")
        # self.skip_spaces()

    def collect_children(self, node: Element) -> None:
        text = ""
        while self.nextch:
            if self.match("<"):
                if text:
                    node.children.append(Text(text))
                    text = ""
                if self.match("/"):
                    self.handle_close_tag()
                    break
                child = Element(self.parse_name())
                self.open_tags.append(child.name)
                while True:
                    if self.match(">"):
                        break
                    self.expect(string.whitespace)
                    self.skip_spaces()
                    attr = self.parse_name()
                    self.skip_spaces()
                    self.expect("=")
                    self.skip_spaces()
                    child.attrs[attr] = self.parse_quouted()
                self.collect_children(child)
                node.children.append(child)
            else:
                self.advance()
                text += self.curch
        if text:
            node.children.append(Text(text))

    def parse(self, fp: typing.TextIO) -> Element:
        self.fp = fp
        self.curch = self.nextch = None
        self.open_tags = []
        self.advance()
        root = Element("root")
        self.collect_children(root)
        if self.open_tags:
            raise SyntaxError(f"unclosed tags: {', '.join(self.open_tags)}")
        return root


import sys

print(MLParser().parse(StringIO(sys.argv[1])))

python ml.py 'Hello, <span color="red"><i><b>world</b></i></span>!'
Element(name='root', attrs={}, children=[Text(value='Hello, '), Element(name='span', attrs={'color': 'red'}, children=[Element(name='i', attrs={}, children=[Element(name='b', attrs={}, children=[Text(value='world')])])]), Text(value='!')])

(. Hello, (red (i (b world)))!)

pip install terml

from terml import format

print(format("[b][color=#f70000 background=yellow] WARNING [/color]:[/b] [magenta]Life leads to [i blue underline]Death[/i].[/magenta]"))