implemented tree builder that builds tree given token stream

Author: ashwin6-dev

evaluation_function/parsing/__init__.py

@@ -2,6 +2,11 @@
 from .token import Token, TokenType
 from .character_stream import CharacterStream
 from .token_matcher import TokenMatcher, SingleCharTokenMatcher, AtomTokenMatcher, EOFTokenMatcher
+from .tree_builder import TreeBuilder, BuildError
+from .token_stream import TokenStream
+from .expression_builder import ExpressionBuilder
+from .primary_builder import PrimaryBuilder
+from .binary_operator_builder import BinaryOperatorBuilder
 
 __all__ = [
     "Tokenizer",
@@ -12,4 +17,10 @@
     "SingleCharTokenMatcher",
     "AtomTokenMatcher",
     "EOFTokenMatcher",
+    "TreeBuilder",
+    "BuildError",
+    "TokenStream",
+    "ExpressionBuilder",
+    "PrimaryBuilder",
+    "BinaryOperatorBuilder",
 ]

evaluation_function/parsing/binary_operator_builder.py

@@ -0,0 +1,59 @@
+from typing import Dict, Callable
+from ..domain.formula import Formula, Conjunction, Disjunction, Implication, Biconditional
+from .token_stream import TokenStream
+from .token import TokenType
+from .expression_builder import ExpressionBuilder
+
+
+class BinaryOperatorBuilder(ExpressionBuilder):
+    _PRECEDENCE: Dict[TokenType, int] = {
+        TokenType.BICONDITIONAL: 1,
+        TokenType.IMPLICATION: 2,
+        TokenType.DISJUNCTION: 3,
+        TokenType.CONJUNCTION: 4,
+    }
+
+    _OPERATOR_CONSTRUCTORS: Dict[TokenType, Callable[[Formula, Formula], Formula]] = {
+        TokenType.CONJUNCTION: Conjunction,
+        TokenType.DISJUNCTION: Disjunction,
+        TokenType.IMPLICATION: Implication,
+        TokenType.BICONDITIONAL: Biconditional,
+    }
+
+    _RIGHT_ASSOCIATIVE: set = {TokenType.IMPLICATION}
+
+    def __init__(self, primary_builder: ExpressionBuilder):
+        self._primary_builder = primary_builder
+
+    def build(self, stream: TokenStream) -> Formula:
+        return self._build_binary_operator(stream, 1)
+
+    def _build_binary_operator(self, stream: TokenStream, min_precedence: int) -> Formula:
+        left = self._primary_builder.build(stream)
+
+        while not stream.is_eof():
+            token = stream.current_token
+            if token is None:
+                break
+
+            if token.type == TokenType.RIGHT_PAREN:
+                break
+
+            if token.type not in self._PRECEDENCE:
+                break
+
+            op_precedence = self._PRECEDENCE[token.type]
+            if op_precedence < min_precedence:
+                break
+
+            stream.advance()
+
+            if token.type in self._RIGHT_ASSOCIATIVE:
+                right = self._build_binary_operator(stream, op_precedence)
+            else:
+                right = self._build_binary_operator(stream, op_precedence + 1)
+
+            constructor = self._OPERATOR_CONSTRUCTORS[token.type]
+            left = constructor(left, right)
+
+        return left

evaluation_function/parsing/expression_builder.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from ..domain.formula import Formula
+from .token_stream import TokenStream
+
+
+class ExpressionBuilder(ABC):
+    @abstractmethod
+    def build(self, stream: TokenStream) -> Formula:
+        pass

evaluation_function/parsing/primary_builder.py

@@ -0,0 +1,42 @@
+from ..domain.formula import Formula, Atom, Truth, Falsity, Negation
+from .token_stream import TokenStream
+from .token import TokenType
+from .expression_builder import ExpressionBuilder
+
+
+class PrimaryBuilder(ExpressionBuilder):
+    def __init__(self, expression_builder: ExpressionBuilder):
+        self._expression_builder = expression_builder
+
+    def build(self, stream: TokenStream) -> Formula:
+        token = stream.current_token
+        if token is None:
+            raise ValueError("Unexpected end of input")
+
+        if token.type == TokenType.TRUTH:
+            stream.advance()
+            return Truth()
+
+        if token.type == TokenType.FALSITY:
+            stream.advance()
+            return Falsity()
+
+        if token.type == TokenType.NEGATION:
+            stream.advance()
+            operand = self.build(stream)
+            return Negation(operand)
+
+        if token.type == TokenType.LEFT_PAREN:
+            stream.advance()
+            formula = self._expression_builder.build(stream)
+            if stream.current_token is None or stream.current_token.type != TokenType.RIGHT_PAREN:
+                raise ValueError(f"Expected ')' at position {stream.position}")
+            stream.advance()
+            return formula
+
+        if token.type == TokenType.ATOM:
+            atom_name = token.value
+            stream.advance()
+            return Atom(atom_name)
+
+        raise ValueError(f"Unexpected token {token.type.name} at position {token.position}")

evaluation_function/parsing/token_stream.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+from .token import Token, TokenType
+
+
+class TokenStream:
+    def __init__(self, tokens: List[Token]):
+        self._tokens = tokens
+        self._position = 0
+
+    @property
+    def current_token(self) -> Optional[Token]:
+        if self._position >= len(self._tokens):
+            return None
+        return self._tokens[self._position]
+
+    @property
+    def position(self) -> int:
+        return self._position
+
+    def advance(self):
+        if self._position < len(self._tokens):
+            self._position += 1
+
+    def peek(self, offset: int = 1) -> Optional[Token]:
+        peek_pos = self._position + offset
+        if peek_pos >= len(self._tokens):
+            return None
+        return self._tokens[peek_pos]
+
+    def is_eof(self) -> bool:
+        return self._position >= len(self._tokens) or (
+            self.current_token is not None and self.current_token.type == TokenType.EOF
+        )

evaluation_function/parsing/tree_builder.py

@@ -0,0 +1,45 @@
+from typing import List, Optional
+from ..domain.formula import Formula
+from .token import Token, TokenType
+from .token_stream import TokenStream
+from .expression_builder import ExpressionBuilder
+from .primary_builder import PrimaryBuilder
+from .binary_operator_builder import BinaryOperatorBuilder
+
+
+class BuildError(Exception):
+    def __init__(self, message: str, position: int):
+        self.message = message
+        self.position = position
+        super().__init__(f"{message} at position {position}")
+
+
+class TreeBuilder:
+    def __init__(self, tokens: List[Token], expression_builder: Optional[ExpressionBuilder] = None):
+        self._stream = TokenStream(tokens)
+        if expression_builder is None:
+            self._expression_builder = self._create_default_builder()
+        else:
+            self._expression_builder = expression_builder
+
+    def _create_default_builder(self) -> ExpressionBuilder:
+        binary_builder = BinaryOperatorBuilder(None)
+        primary_builder = PrimaryBuilder(binary_builder)
+        binary_builder._primary_builder = primary_builder
+        return binary_builder
+
+    def build(self) -> Formula:
+        if self._stream.is_eof():
+            raise BuildError("Empty input", 0)
+
+        formula = self._expression_builder.build(self._stream)
+
+        if not self._stream.is_eof():
+            token = self._stream.current_token
+            if token is not None and token.type != TokenType.EOF:
+                raise BuildError(
+                    f"Unexpected token {token.type.name} after expression",
+                    token.position
+                )
+
+        return formula

examples/basic_formula_parsing.py

@@ -30,6 +30,7 @@ def main():
         ("p ∨ q", Disjunction(p, q)),
         ("p → q", Implication(p, q)),
         ("p ↔ q", Biconditional(p, q)),
+        ("p ∧ q ∨ q", Disjunction(Conjunction(p, q), q)),
     ]
 
     passed = 0

examples/basic_usage.py

@@ -1,4 +1,4 @@
-from evaluation_function.propositional_logic import (
+from evaluation_function.domain import (
     Atom,
     Truth,
     Falsity,

examples/complex_formula_parsing.py

@@ -1,6 +1,6 @@
 from evaluation_function.evaluation import parse_response
 
-from evaluation_function.propositional_logic import (
+from evaluation_function.domain import (
     Atom,
     Truth,
     Falsity,

examples/complex_formulas.py

@@ -1,4 +1,4 @@
-from evaluation_function.propositional_logic import (
+from evaluation_function.domain import (
     Atom,
     Negation,
     Conjunction,