teletype-simulator 0.1.0__tar.gz

teletype_simulator-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: teletype-simulator
+Version: 0.1.0
+Summary: A simple teletype and BASIC interpreter simulator
+Requires-Python: >=3.10

teletype_simulator-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "teletype-simulator"
+version = "0.1.0"
+description = "A simple teletype and BASIC interpreter simulator"
+requires-python = ">=3.10"
+
+[project.scripts]
+teletype-sim = "teletype_simulator.main:main"

teletype_simulator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

teletype_simulator-0.1.0/teletype_simulator/computer.py

@@ -0,0 +1,53 @@
+from teletype_simulator.teletype import Teletype
+from teletype_simulator.interpreter import BASIC_Interpreter
+import sys
+
+class Computer():
+    def __init__(self):
+        self.teletype = Teletype()
+        """Instance of the Teletype object in Computer"""
+
+        self.interpreter = BASIC_Interpreter(self.teletype)
+        """Instance of the interpreter in Computer"""
+
+        self.script_name = None
+        """Stores the name of BASIC scripts being ran/created"""
+
+        self.script = None
+        """Stores the actual BASIC script once it's loaded by open_program. HAS .txt APPENDED TO IT AT THE END AT INPUT"""
+
+    def configure(self):
+        self.teletype.output_from_teletype("Configuring BASIC Interpreter...")
+        #just a rizzy little thing I guess
+
+    def get_input(self):
+        option = self.teletype.input_to_teletype(0) 
+        #Option runs from 1 - 3, 1 being create new program and 2 being opening a program; 3 is exit and is dealt with in Teletype
+        #This determines which function of the computer we're going to use
+
+        self.script_name = self.teletype.input_to_teletype(option)
+        #This gets the name of the script being created/opened from the user
+        
+        if option == 1: #creates a new program and exits
+            self.new_program()
+            self.teletype.output_from_teletype("The program will now exit; you can work on the new script.")
+            sys.exit(0)
+
+        elif option == 2: #parses the script into self.script to be interpreted
+            self.open_program()
+            self.interpreter.interpret(self.script)
+
+    def new_program(self):
+        """Opens a new .txt file for the user to write their BASIC scripts in."""
+        with open(f"user_scripts/{self.script_name}", "w") as file:
+            file.write("New script!\n")
+
+    def open_program(self):
+        """Opens an existing .txt file for the interpreter to execute."""
+        try:
+            with open(f"user_scripts/{self.script_name}") as file:
+                self.script = file.read()
+        except FileNotFoundError:
+            print("File not found")
+            sys.exit(1)
+        

teletype_simulator-0.1.0/teletype_simulator/csv_reader.py

@@ -0,0 +1,7 @@
+import csv
+
+def read_csv(file_name):
+    with open(file_name, "r") as file:
+        reader = csv.DictReader(file)
+        rows = list(reader)
+    return rows

teletype_simulator-0.1.0/teletype_simulator/interpreter.py

@@ -0,0 +1,200 @@
+import sys
+
+class BASIC_Interpreter():
+    def __init__(self, teletype):
+        self.teletype = teletype
+        """Dependency injection to allow easier outputting"""
+
+        self.script = None
+        """Stores the actual BASIC script passed into the interpreter; line_number, command, argument"""
+        
+        self.interpreted_script = None
+        """Stores a parsed version of the script separated into keywords; a list of dicts"""
+
+        self.script_variables = dict() 
+        """Stores the variables in the script: {"variable name": x, "value": y}"""
+
+        self.loop_data = dict()
+        """Stores data for loops"""
+
+    def interpret(self, script):
+        """Interprets lines, separating them into line number, command, and argument for running"""
+        self.script = script 
+        self.interpreted_script = list()
+
+        for line in self.script.splitlines():
+            line = line.split(maxsplit=2)
+            if len(line) != 3:
+                argument = None
+            else:
+                argument = line[2].strip()
+            interpreted_line = {
+                "line_number": int(line[0]),
+                "command": line[1].upper(),
+                "argument": argument
+            }
+            self.interpreted_script.append(interpreted_line)
+
+        self.run_program()
+
+    def run_program(self):
+        """Continously runs the program and keeps track of the line index"""
+        index = 0
+        while index < len(self.interpreted_script):
+            #Continously runs the program 
+            current_line = self.interpreted_script[index]
+            command = current_line["command"]
+            argument = current_line["argument"]
+
+            new_index = self.execute(index, command, argument)
+            if new_index is not None:
+                index = new_index
+            else:
+                index += 1
+
+    def execute(self, index, command, argument):
+        """Executes each line of the program, matching commands to functions"""
+        if command == "PRINT":
+            self.print_method(argument)
+            return None
+
+        elif command == "LET":
+            self.let_method(argument)
+            return None
+
+        elif command == "GOTO":
+            return self.goto_method(argument)
+
+        elif command == "IF":
+            action = self.booleans(argument)
+            if action:
+                return self.execute(index, *(action.split(maxsplit=1)))
+            return None
+
+        elif command == "INPUT":
+            self.input_method(argument)
+            return None
+
+        elif command == "FOR":
+            self.for_loop(index, argument)
+
+        elif command == "NEXT":
+            new_index = self.next_method(argument)
+            if new_index is not None:
+                return new_index
+
+        elif command == "END":
+            sys.exit(0)
+
+        else:
+            print("FATAL ERROR")
+            sys.exit(1)
+
+    def print_method(self, argument):
+        """prints variables"""
+        printed_thing = None
+        if argument in self.script_variables:
+            printed_thing = self.script_variables[argument]
+        else:
+            printed_thing = argument
+                
+        self.teletype.output_from_teletype(str(printed_thing).strip('"'))    
+
+    def let_method(self, argument):
+        """assigns a value to data"""
+        argument = argument.split("=")
+        argument[0] = argument[0].strip()
+        argument[1] = argument[1].strip()
+
+        for operator in ["+", "-", "*", "/"]:
+            if operator in argument[1]:
+                argument[1] = self.evaluate_expression(argument[1])
+                break
+
+        self.script_variables[argument[0]] = argument[1]
+
+    def goto_method(self, line_number):
+        """goes from one line to another line, skipping lines in between"""
+        for index, line in enumerate(self.interpreted_script):
+            if line["line_number"] == int(line_number):
+                return index
+
+    def evaluate_expression(self, expression):
+        """Does basic mathematical calculations; Compares two numbers with operators"""
+        expression = expression.split()
+
+        left = expression[0].strip()
+        right = expression[2].strip()
+        if not left.isnumeric():
+            left = int(self.script_variables[left])
+        else:
+            left = int(left)
+        if not right.isnumeric():
+            right = int(self.script_variables[right])
+        else:
+            right = int(right)
+
+        operator = expression[1].strip()
+        if operator == "+":
+            return left + right
+        elif operator == "-":
+            return left - right
+        elif operator == "*":
+            return left * right
+        elif operator == "/":
+            return left / right
+        elif operator == ">":
+            return True if left > right else False
+        elif operator == ">=":
+            return True if left >= right else False
+        elif operator == "==":
+            return True if left == right else False
+        elif operator == "<":
+            return True if left < right else False
+        elif operator == "<=":
+            return True if left <= right else False
+
+    def input_method(self, argument):
+        """asks for an input and stores it in a variable"""
+        prompt, variable = argument.split(";")
+        prompt = prompt.strip()
+        variable = variable.strip()
+
+        self.print_method(prompt)
+        user_input = self.teletype.input_to_teletype(3)
+
+        self.let_method(f"{variable} = {user_input}")
+
+    def booleans(self, expression):
+        """Evaluates boolean expressions"""
+        condition, action = expression.split("THEN")
+        condition = condition.strip()
+        action = action.strip()
+
+        if self.evaluate_expression(condition):
+            return action
+        return None
+
+    def for_loop(self, index, argument):
+        """For loop"""
+        variable, bound = argument.split("=")
+        start, end = bound.split("TO")
+        variable = variable.strip()
+        start = int(start.strip())
+        end = int(end.strip())
+
+        self.script_variables[variable] = start
+        self.loop_data[variable] = {"end": end, "start_index": index + 1}
+
+    def next_method(self, loop_variable_name):
+        """Advances a for loop and see if it should continue"""
+        loop_variable_name = loop_variable_name.strip()
+        self.script_variables[loop_variable_name] += 1
+
+        loop_variable_value = self.script_variables[loop_variable_name]
+        loop_data = self.loop_data[loop_variable_name]
+
+        if loop_variable_value <= loop_data["end"]:
+            return loop_data["start_index"]
+        
+        return None

teletype_simulator-0.1.0/teletype_simulator/main.py

@@ -0,0 +1,12 @@
+from teletype_simulator.computer import Computer   
+
+def main():
+    computer = Computer()
+    computer.configure()
+    running = True
+    while running:
+        computer.get_input()
+
+if __name__ == "__main__":
+    main()
+    

teletype_simulator-0.1.0/teletype_simulator/teletype.py

@@ -0,0 +1,58 @@
+import sys, time
+
+OUTPUT_SPEED = 0
+"""A teletype returns about 10 characters per second according to research; the output speed is also hardwired to this in this program."""
+
+class Teletype():
+    def __init__(self):
+        self.script_name = None
+
+    def input_to_teletype(self, log_in: int):
+        if log_in == 0:
+            try:
+                self.output_from_teletype("Enter 1 to create a new script, 2 to run an existing one, 3 to exit, \"commands\" for command menu: ")
+                option = input("\nINPUT > ")
+                if option not in ["1", "2", "3", "commands"]:
+                    raise ValueError
+
+                if option == "commands":
+                    self.commands()
+                    print()
+                    sys.exit(0)
+                option = int(option)
+
+            except ValueError,:
+                #Exits if none of the three numeric options are picked
+                print("Invalid input")
+                sys.exit(1)
+            if option == 3:
+                sys.exit(0)
+            return option
+
+        elif log_in == 1 or log_in == 2: #called by Computer to get a script name
+            if log_in == 1:
+                self.output_from_teletype("New script name: ") #For new scripts
+            else:
+                self.output_from_teletype("Name of the script you want to run: ") #For existing scripts
+ 
+            self.script_name = input("\nINPUT > ")
+            self.script_name += ".txt" #.txt extension is ADDED TO THE FILE NAME HERE
+            return self.script_name
+        
+        elif log_in == 3: #Called by INPUT in interpreter to get an input from the user
+            return input("\nINPUT > ")
+        
+    def output_from_teletype(self, message: str):
+        print("\nOUTPUT > ", end="")
+        for character in message:
+            print(character, end="", flush=True)
+            time.sleep(OUTPUT_SPEED)
+            #it outputs character by characteron a line
+    
+    def commands(self):
+        """Displays command menu for help"""
+        with open("commands.txt", "r") as file:
+            commands = file.read()
+
+        for line in commands.splitlines():
+            self.output_from_teletype(line)

teletype_simulator-0.1.0/teletype_simulator.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: teletype-simulator
+Version: 0.1.0
+Summary: A simple teletype and BASIC interpreter simulator
+Requires-Python: >=3.10

teletype_simulator-0.1.0/teletype_simulator.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+teletype_simulator/__init__.py
+teletype_simulator/computer.py
+teletype_simulator/csv_reader.py
+teletype_simulator/interpreter.py
+teletype_simulator/main.py
+teletype_simulator/teletype.py
+teletype_simulator.egg-info/PKG-INFO
+teletype_simulator.egg-info/SOURCES.txt
+teletype_simulator.egg-info/dependency_links.txt
+teletype_simulator.egg-info/entry_points.txt
+teletype_simulator.egg-info/top_level.txt

teletype_simulator-0.1.0/teletype_simulator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

teletype_simulator-0.1.0/teletype_simulator.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+teletype-sim = teletype_simulator.main:main

teletype_simulator-0.1.0/teletype_simulator.egg-info/top_level.txt

@@ -0,0 +1 @@
+teletype_simulator