turing-py 2.0.0__tar.gz → 2.2.0__tar.gz

{turing_py-2.0.0 → turing_py-2.2.0}/PKG-INFO

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

{turing_py-2.0.0 → turing_py-2.2.0}/pyproject.toml

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

{turing_py-2.0.0 → turing_py-2.2.0}/src/tmpy/__init__.py

@@ -1,4 +1,13 @@
 from .alphabet import Alphabet, Symbol, TapeAlphabet
+from .dsl import (
+    Lexer,
+    MachineLoader,
+    MachineNode,
+    Parser,
+    Token,
+    TokenType,
+    TransitionNode,
+)
 from .exception import (
     AlphabetError,
     BlankSymbolError,
@@ -28,6 +37,13 @@ __all__ = [
     "States",
     "Tape",
     "Direction",
+    "MachineNode",
+    "TransitionNode",
+    "Lexer",
+    "MachineLoader",
+    "Parser",
+    "Token",
+    "TokenType",
     "BlankSymbolError",
     "TuringMachineError",
     "AlphabetError",

turing_py-2.2.0/src/tmpy/dsl/__init__.py

@@ -0,0 +1,15 @@
+from .ast import MachineNode, TransitionNode
+from .lexer import Lexer
+from .loader import MachineLoader
+from .parser import Parser
+from .token import Token, TokenType
+
+__all__ = [
+    "MachineNode",
+    "TransitionNode",
+    "Lexer",
+    "MachineLoader",
+    "Parser",
+    "Token",
+    "TokenType",
+]

turing_py-2.2.0/src/tmpy/dsl/ast.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Eric Santos <ericshantos13@gmai.com>
+
+AST node definitions for the Turing machine description language.
+"""
+
+from typing import Optional
+
+
+class MachineNode:
+
+    def __init__(self, name: str):
+        self.name = name
+        self.start: Optional[str] = None
+        self.accept: Optional[str] = None
+        self.blank: Optional[str] = None
+        self.transitions: list[TransitionNode] = []
+
+
+class TransitionNode:
+
+    def __init__(self, state, read, next_state, write, move):
+        self.state = state
+        self.read = read
+        self.next_state = next_state
+        self.write = write
+        self.move = move

turing_py-2.2.0/src/tmpy/dsl/lexer.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Eric Santos <ericshantos13@gmail.com>
+
+Lexer for the Turing machine description language.
+"""
+
+from .token import Token, TokenType
+
+
+class Lexer:
+
+    def __init__(self, input_text: str) -> None:
+
+        self.lines = input_text.splitlines()
+        self.current_line: int = 0
+
+    def tokenize(self) -> list[Token]:
+
+        tokens = []
+
+        for line in self.lines:
+
+            line = line.strip()
+
+            if not line or line.startswith("#"):
+                continue
+
+            parts = line.split()
+
+            for part in parts:
+
+                if part == "machine":
+                    tokens.append(Token(TokenType.MACHINE, part))
+
+                elif part == "start":
+                    tokens.append(Token(TokenType.START, part))
+
+                elif part == "accept":
+                    tokens.append(Token(TokenType.ACCEPT, part))
+
+                elif part == "blank":
+                    tokens.append(Token(TokenType.BLANK, part))
+
+                elif part == "->":
+                    tokens.append(Token(TokenType.ARROW, part))
+
+                elif part in ("L", "R", "S"):
+                    tokens.append(Token(TokenType.MOVE, part))
+
+                else:
+                    tokens.append(Token(TokenType.IDENTIFIER, part))
+
+        tokens.append(Token(TokenType.EOF, None))
+
+        return tokens

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

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Eric Santos <ericshantos13@gmail.com>
+
+Loader for the Turing machine DSL.
+"""
+
+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, node.read, node.next_state, node.write, node.move)
+
+            transitions.append(t)
+
+        return transitions

turing_py-2.2.0/src/tmpy/dsl/parser.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Eric Santos <ericshantos13@gmail.com>
+
+Parser for the Turing machine DSL.
+"""
+
+from .ast import MachineNode, TransitionNode
+from .token import Token, TokenType
+
+
+class Parser:
+
+    def __init__(self, tokens: list[Token]) -> None:
+        self.tokens = tokens
+        self.pos: int = 0
+
+    def current(self) -> Token:
+        return self.tokens[self.pos]
+
+    def advance(self) -> None:
+        self.pos += 1
+
+    def parse(self) -> MachineNode:
+
+        machine: MachineNode | None = None
+
+        while self.current().type != TokenType.EOF:
+
+            token = self.current()
+
+            if token.type == TokenType.MACHINE:
+
+                self.advance()
+                name = self.current().value
+
+                if name is None:
+                    raise SyntaxError("Machine name expected")
+
+                machine = MachineNode(name)
+
+                self.advance()
+
+            elif token.type == TokenType.START:
+
+                if machine is None:
+                    raise SyntaxError("Machine must be declared first")
+
+                self.advance()
+                machine.start = self.current().value
+                self.advance()
+
+            elif token.type == TokenType.ACCEPT:
+
+                if machine is None:
+                    raise SyntaxError("Machine must be declared first")
+
+                self.advance()
+                machine.accept = self.current().value
+                self.advance()
+
+            elif token.type == TokenType.BLANK:
+
+                if machine is None:
+                    raise SyntaxError("Machine must be declared first")
+
+                self.advance()
+                machine.blank = self.current().value
+                self.advance()
+
+            else:
+
+                if machine is None:
+                    raise SyntaxError("Machine must be declared first")
+
+                transition = self.parse_transition()
+                machine.transitions.append(transition)
+
+        if machine is None:
+            raise SyntaxError("Machine declaration not found")
+
+        return machine
+
+    def parse_transition(self) -> TransitionNode:
+
+        state = self.current().value
+        self.advance()
+
+        read = self.current().value
+        self.advance()
+
+        self.advance()
+
+        next_state = self.current().value
+        self.advance()
+
+        write = self.current().value
+        self.advance()
+
+        move = self.current().value
+        self.advance()
+
+        return TransitionNode(state, read, next_state, write, move)

turing_py-2.2.0/src/tmpy/dsl/token.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Eric dos Santos <ericshantos13@gmail.com>
+
+Token definitions for the Turing machine parser.
+"""
+
+from enum import Enum
+
+
+class TokenType(Enum):
+    MACHINE = "MACHINE"
+    START = "START"
+    ACCEPT = "ACCEPT"
+    BLANK = "BLANK"
+
+    ARROW = "ARROW"
+
+    IDENTIFIER = "IDENTIFIER"
+    MOVE = "MOVE"
+
+    EOF = "EOF"
+
+    def __repr__(self):
+        return self.name
+
+
+class Token:
+    def __init__(self, type_: TokenType, value: str | None) -> None:
+        self.type = type_
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f"Token({self.type.name}, {self.value})"

{turing_py-2.0.0 → turing_py-2.2.0}/src/tmpy/machine/machine.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 """
 @author: Eric Santos <ericshantos13@gmail.com>
 

{turing_py-2.0.0 → turing_py-2.2.0}/src/tmpy/transition/transition_function.py

@@ -13,25 +13,23 @@ from .transition import Transition
 
 
 class TransitionFunction:
-    def __init__(self) -> None:
-        self._transitions: dict[tuple[str, Symbol], Transition] = {}
+    def __init__(self, *args: Transition) -> None:
 
-    def add(self, *transitions: Transition) -> None:
+        self._tr: dict[tuple[str, Symbol], Transition] = {}
 
-        for t in transitions:
+        for t in args:
 
             if isinstance(t, Iterable) and not isinstance(t, Transition):
                 for tr in t:
-                    self._transitions[(tr.state, tr.symbol)] = tr
+                    self._tr[(tr.state, tr.symbol)] = tr
             else:
-                self._transitions[(t.state, t.symbol)] = t
+                self._tr[(t.state, t.symbol)] = t
 
     def __call__(self, state: str, symbol: Symbol) -> Transition | None:
-        return self._transitions.get((state, symbol))
+        return self._tr.get((state, symbol))
 
-    def __str__(self) -> str:
-        return "\n".join(str(t) for t in self._transitions.values())
+    def __contains__(self, item) -> bool:
+        return item in self._tr
 
-    @property
-    def conjugates(self) -> dict[tuple[str, Symbol], Transition]:
-        return self._transitions
+    def __str__(self) -> str:
+        return "\n".join(str(t) for t in self._tr.values())