turing-py 2.2.1__tar.gz → 2.3.0__tar.gz

{turing_py-2.2.1 → turing_py-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turing-py
-Version: 2.2.1
+Version: 2.3.0
 Summary: Education Turing Machine simulator in Python
 License-File: LICENSE
 Author: Eric Santos

{turing_py-2.2.1 → turing_py-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "turing-py"
-version = "2.2.1"
+version = "2.3.0"
 description = "Education Turing Machine simulator in Python"
 authors = [
     {name = "Eric Santos",email = "ericshantos13@gmail.com"}

{turing_py-2.2.1 → turing_py-2.3.0}/src/tmpy/__init__.py

@@ -1,13 +1,4 @@
-from .alphabet import Alphabet, Symbol, TapeAlphabet
-from .dsl import (
-    Lexer,
-    MachineLoader,
-    MachineNode,
-    Parser,
-    Token,
-    TokenType,
-    TransitionNode,
-)
+from . import alphabet, dsl, machine, transition
 from .exception import (
     AlphabetError,
     BlankSymbolError,
@@ -24,25 +15,12 @@ from .exception import (
     TransitionNotDefinedError,
     TuringMachineError,
 )
-from .machine import States, Tape, TuringMachine
-from .transition import Direction, Transition, TransitionFunction
 
 __all__ = [
-    "TransitionFunction",
-    "Transition",
-    "Alphabet",
-    "TapeAlphabet",
-    "Symbol",
-    "TuringMachine",
-    "States",
-    "Tape",
-    "Direction",
-    "MachineNode",
-    "TransitionNode",
-    "Lexer",
-    "MachineLoader",
-    "Parser",
-    "Token",
+    "alphabet",
+    "dsl",
+    "machine",
+    "transition",
     "TokenType",
     "BlankSymbolError",
     "TuringMachineError",

turing_py-2.3.0/src/tmpy/dsl/loader.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Eric Santos <ericshantos13@gmail.com>
+
+Loader for the Turing machine DSL.
+"""
+
+from pathlib import Path
+
+from ..alphabet import Alphabet, Symbol, TapeAlphabet
+from ..machine import States, TuringMachine
+from ..transition import Direction, Transition, TransitionFunction
+from .ast import MachineNode
+from .lexer import Lexer
+from .parser import Parser
+from .token import Token
+
+move_map = {"L": Direction.LEFT, "R": Direction.RIGHT, "S": Direction.STAY}
+
+
+class MachineLoader:
+
+    @classmethod
+    def load(cls, path: str | Path) -> TuringMachine:
+
+        text = cls._read_file(path)
+        tokens = cls._lex(text)
+        ast = cls._parse(tokens)
+
+        symbols, blank = cls._collect_symbols(ast)
+
+        alphabet, tape_alphabet = cls._build_alphabets(symbols, blank)
+        states = cls._build_states(ast)
+        delta = cls._build_delta(ast)
+
+        return TuringMachine(states, alphabet, tape_alphabet, delta)
+
+    @classmethod
+    def _collect_symbols(cls, ast: MachineNode) -> tuple[set[Symbol], Symbol]:
+        symbols: set[Symbol] = set()
+
+        for t in ast.transitions:
+            symbols.add(Symbol(t.read))
+            symbols.add(Symbol(t.write))
+
+        if ast.blank is None:
+            raise ValueError("Blank symbol not defined")
+
+        blank = Symbol(ast.blank)
+
+        return symbols, blank
+
+    @classmethod
+    def _build_alphabets(cls, symbols: set[Symbol], blank: Symbol) -> tuple[Alphabet, TapeAlphabet]:
+        input_alphabet = Alphabet(*[s for s in symbols if s != blank])
+        tape_alphabet = TapeAlphabet(blank, *symbols)
+
+        return input_alphabet, tape_alphabet
+
+    @classmethod
+    def _build_states(cls, ast: MachineNode) -> States:
+        states = set()
+
+        for t in ast.transitions:
+            states.add(t.state)
+            states.add(t.next_state)
+
+        if ast.start is None:
+            raise ValueError("Start state not defined")
+
+        if ast.accept is None:
+            raise ValueError("Accept state not defined")
+
+        states.add(ast.start)
+        states.add(ast.accept)
+
+        return States(
+            *states,
+            initial_state=ast.start,
+            final_states={ast.accept},
+        )
+
+    @classmethod
+    def _build_delta(cls, ast: MachineNode):
+        transitions = []
+
+        for node in ast.transitions:
+            transitions.append(
+                Transition(
+                    node.state,
+                    Symbol(node.read),
+                    node.next_state,
+                    Symbol(node.write),
+                    move_map[node.move],
+                )
+            )
+
+        return TransitionFunction(*transitions)
+
+    @classmethod
+    def _read_file(cls, path: str | Path) -> str:
+
+        with open(path, "r") as f:
+            return f.read()
+
+    @classmethod
+    def _lex(cls, text: str) -> list[Token]:
+
+        lexer = Lexer(text)
+
+        return lexer.tokenize()
+
+    @classmethod
+    def _parse(cls, tokens: list[Token]) -> MachineNode:
+
+        parser = Parser(tokens)
+
+        return parser.parse()
+
+    @classmethod
+    def _build_transitions(cls, ast: MachineNode) -> list[Transition]:
+
+        transitions = []
+
+        for node in ast.transitions:
+
+            transitions.append(Transition(node.state, Symbol(node.read), node.next_state, Symbol(node.write), node.move))
+
+        return transitions

turing_py-2.2.1/src/tmpy/dsl/loader.py

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-@author: Eric Santos <ericshantos13@gmail.com>
-
-Loader for the Turing machine DSL.
-"""
-
-from ..alphabet import Symbol
-from ..transition import Transition
-from .lexer import Lexer
-from .parser import MachineNode, Parser
-
-
-class MachineLoader:
-
-    def load(self, path: str):
-        text = self._read_file(path)
-
-        tokens = self._lex(text)
-
-        ast = self._parse(tokens)
-
-        transitions = self._build_transitions(ast)
-
-        return transitions
-
-    def _read_file(self, path: str) -> str:
-
-        with open(path, "r") as f:
-            return f.read()
-
-    from tmpy.dsl.lexer import Lexer
-
-    def _lex(self, text: str):
-
-        lexer = Lexer(text)
-
-        return lexer.tokenize()
-
-    def _parse(self, tokens):
-
-        parser = Parser(tokens)
-
-        return parser.parse()
-
-    def _build_transitions(self, machine_ast: MachineNode) -> list[Transition]:
-
-        transitions = []
-
-        for node in machine_ast.transitions:
-
-            t = Transition(node.state, Symbol(node.read), node.next_state, Symbol(node.write), node.move)
-
-            transitions.append(t)
-
-        return transitions