Type checking a DFA

dfa.py

from abc import ABCMeta
from enum import Enum
import typing as t

class AbstractDFA:
    ...

T = t.TypeVar('T', bound=t.Type[AbstractDFA])


class State(t.Generic[T]):
    def __init__(self, dfa: T) -> None:
        self.transitions = (None, None) # type: t.Tuple[State[T], State[T]]

    def transition(self, token: int) -> 'State[T]':
        if token:
            return self.transitions[1]
        else:
            return self.transitions[0]

class DFA(t.Generic[T]):
    def __init__(self, start_state: State[T], success_states: t.Sequence[State[T]]) -> None:
        self.start_state = start_state
        self.success_states = success_states

    def test_string(self, input_string: t.Iterable[int]) -> bool:
        current_state = self.start_state
        for letter in input_string:
            current_state = current_state.transition(letter)
        return current_state in self.success_states

class Ones(AbstractDFA):
    ...
class Zeros(AbstractDFA):
    ...

a, b, c, d = State(Ones), State(Ones), State(Zeros), State(Zeros)
a.transitions = (a, b)
b.transitions = (b, b)
c.transitions = (c, d)
d.transitions = (d, d)

OnesDFA = DFA(a, [b])

def dfa_str(s: str) -> t.Iterable[int]:
    return map(int, s)

print(OnesDFA.test_string(dfa_str("000000000")))
print(OnesDFA.test_string(dfa_str("000000010")))