Refactor: make it ready for school level project

sylvie/__init__.py

@@ -0,0 +1,22 @@
+"""Sylvie is a mathematical interpreter.
+
+It takes mathematical expressions as text and then evaluate it.
+
+Examples:
+    From command line:
+
+        Sylvie>> 4*8(93-2/4*3)-9
+        -8.650273224043715
+
+        Sylvie>> 8/4
+        2.0
+
+        Sylvie>> 5*5
+        25
+"""
+
+
+if __name__ == "__main__":
+    from sylvie.bin import cmd
+
+    cmd()

sylvie/__main__.py

@@ -0,0 +1,42 @@
+"""This module allows using package from command line.
+
+This allows `python -m sylvie` command as well as `python sylvie`
+to start REPL.
+"""
+
+import sys
+from pathlib import Path
+
+# if it was run from directory other than sylvie then directory
+# sylvie/ would not be present in sys.path, from where imports start.
+# Thus, add sylvie/ to sys.path and remove current file directory(i.e sylvie/).
+# when __file__ is not defined then use parent of '.' (Path.cwd())
+# Note: it would still not work if current directory is not sylvie/.
+# There is nothing I could think of to solve this issue.
+#
+# Although it's highly unlikley for __file__ to be not defined.
+script_dir = Path(globals().get("__file__", "./_")).absolute().parent
+
+if str(script_dir.parent) not in sys.path:
+
+    # remove current path, although it is not necessary.
+    #
+    # sys.path may contain a trailing '/' depending on the the command used
+    # to invoke.
+    # For example:
+    # - when using `python sylvie`, sys.path will not contain trailing '/'
+    #   in search path of this file.
+    #
+    # - but when `python sylvie/` is used, it will contain trailing '/'
+    try:
+        sys.path.remove(str(script_dir))
+    except ValueError:
+        sys.path.remove(f"{script_dir}/")
+
+    # insert parent of script_dir (sylvie/), i.e src/ to sys.path
+    sys.path.insert(0, str(script_dir.parent))
+
+# skipcq: FLK-E402
+from sylvie.bin import cmd  # noqa: E402
+
+cmd()

sylvie/bin.py

@@ -0,0 +1,17 @@
+"""This module contains functioncs to run Sylvie from command line."""
+
+from sylvie.interpreter.parser import Parser
+
+
+def cmd():
+    """Starts Sylvie's REPL."""
+    parser = Parser()
+    try:
+        while True:
+            try:
+                text = input("Sylvie >> ")
+                print(parser.parse(text))
+            except (ValueError, SyntaxError, ZeroDivisionError) as err:
+                print("Error :", err)
+    except (EOFError, KeyboardInterrupt):
+        print("Exiting as requested.")

src/sylvie/syntax_directed/lexer.py → sylvie/interpreter/lexer.py

@@ -6,7 +6,7 @@
 
 from typing import Any, Generator, Union
 
-from sylvie.tokens import Token, TokenType
+from sylvie.interpreter.tokens import Token, TokenType
 
 
 class Lexer:
@@ -16,7 +16,12 @@ class Lexer:
         text: input mathematical expression
     """
 
-    def __init__(self, text: str) -> None:
+    def __init__(self) -> None:
+        """Initialize lexer."""
+        self.text = None
+        self.current_char: Union[str, Any] = None
+
+    def analyze(self, text: str) -> Generator:
         """Converts input text into a stream of tokens.
 
         Args:
@@ -25,18 +30,20 @@ def __init__(self, text: str) -> None:
         self.text = iter(text)
         self.advance()
 
+        return self.tokens()
+
     def advance(self) -> None:
         """Move to next character."""
         try:
-            self.current_char: Union[str, Any] = next(self.text)
+            self.current_char = next(self.text)
         except StopIteration:
             self.current_char = "EOF" if self.current_char != "EOF" else None
 
     @staticmethod
     def error(msg: str):  # skipcq: PY-D0003
-        raise ValueError(f"ValueError: {msg}")
+        raise ValueError(msg)
 
-    def get_tokens(self) -> Generator:
+    def tokens(self) -> Generator:
         """Yields tokens generated by the lexer."""
         while self.current_char:
             if self.current_char.isspace():
@@ -50,9 +57,9 @@ def get_tokens(self) -> Generator:
                 # TokenType('(') --> TokenType.LPAREN
                 token_type = TokenType(self.current_char)
             # skipcq: PYL-W0511
-            except ValueError:  # TODO: define custom exceptions
-                # if self.current_char not member of TokenType
-                self.error(f"Invalid character '{self.current_char}'")
+            except ValueError:
+                # if self.current_char not member of TokenType raise error
+                self.error(f"invalid character '{self.current_char}'")
             else:
                 token = Token(token_type, token_type.value)
 

src/sylvie/syntax_directed/parser.py → sylvie/interpreter/parser.py

@@ -13,8 +13,8 @@
 
 from typing import Union
 
-from sylvie.syntax_directed.lexer import Lexer
-from sylvie.tokens import TokenType
+from sylvie.interpreter.lexer import Lexer
+from sylvie.interpreter.tokens import TokenType
 
 
 class Parser:
@@ -27,16 +27,28 @@ class Parser:
         expr: returns result of input expression.
     """
 
-    def __init__(self, text: str) -> None:
+    def __init__(self) -> None:
+        """Initialize parser."""
+        self.lexer = Lexer()
+        self.tokens = None
+        self.column = 0
+        self.current_token = None
+
+    def parse(self, text: str) -> Union[int, float]:
         """Parses tokens and evaluates the expression formed.
 
+        This function takes an expression as input and returns its value
+        after evaluating.
+
         Args:
             text: text to be parsed.
         """
-        self.tokens = Lexer(text).get_tokens()
+        self.tokens = self.lexer.analyze(text)
         self.column = 0
         self.advance()
 
+        return self.expr()
+
     def advance(self) -> None:
         """Move to next token and increase column count."""
         try:
@@ -64,11 +76,11 @@ def eat(self, expected_token: TokenType) -> None:
         if self.current_token.type == expected_token:
             self.advance()
         else:
-            self.error(
-                "Unexpected character '{}' at column {}, expected '{}'".format(
-                    self.current_token.value, self.column, expected_token.value
-                )
-            )
+            msg = f"character '{self.current_token.value}'"
+            if self.current_token.type == TokenType.EOF:
+                msg = "end of expression"
+
+            self.error(f"unexpected {msg} at column {self.column}")
 
     def factor(self) -> Union[int, float]:
         """Extracts NUMBER or PAREN terminal.
@@ -114,11 +126,7 @@ def mul(self) -> Union[int, float]:
                 result *= self.term()
             elif self.current_token.type == TokenType.DIV:
                 self.eat(TokenType.DIV)
-                try:
-                    result /= self.term()
-                except ZeroDivisionError:
-                    print("Oh! Its beyond my limit")
-                    raise
+                result /= self.term()
         return result
 
     def sub_expr(self) -> Union[int, float]: