Have I gotten better at Python?

[DumbestPerson224]

Body

Learning Level:

import os 
def terminal():
  commands = ["exit", "echo", "python", "help", "addcmd"]
  if os.path.exists("newcmd.txt"):
    new_cmd = open("newcmd.txt", "r")
    commands.append(new_cmd.read())
  command = input("Enter a command > ")
  valid_command = ""
  if command not in commands:
    valid_command = False
  if valid_command != False:
    if command == "exit":
      exit()
    if command == "echo":
      message = input("Enter something to output > ")
      print(message)
      terminal()
    if command == "addcmd":
      new_cmd = input("Enter a new command that does not exist > ")
      if new_cmd in commands:
        print("The command " + new_cmd + " already exists!")
      else:
        commands.append(new_cmd)
        if not os.path.exists("newcmd.txt"):
          save_cmd = open("newcmd.txt", "w")
          save_cmd.write(new_cmd)
          save_cmd.close()
          terminal()
        else:
          save_cmd = open("newcmd.txt", "w")
          save_cmd.write(new_cmd)
          save_cmd.close()
          terminal()
    new_cmd = open("newcmd.txt", "r")
    if command == new_cmd.read():
        print("This command has no function")
        terminal()
  else:
    print("Invalid command! The commands are: ")
    for cmd in commands:
      print(cmd)
      terminal()
if not os.path.exists("username.txt"):
  terminal()
else:
  terminal()

Now:

import os
class CommandInterpreter:
    def __init__(self):
        self.commands = {"echo": self.handle_echo, "exit": self.handle_exit, "list": self.listcontent, "help": self.list_commands}
        self.isRunning = True
        self.osMode = False 
    """
    @Param inp 
    @Outputs inp
    @Type any 
    """
    def handle_echo(self, inp):
        print(inp)
    
    """
    @Outputs commands 
    """
    def list_commands(self):
        for command in self.commands:
            print(command)
            
    """
    @Outputs every file and folder in the current directory
    """
    def listcontent(self):
        print(os.listdir())
    
    def handle_exit(self):
        print("Exiting..")
        self.isRunning = False
        
    """
    @Param inp 
    @Returns inp as a string input stripped from any white space 
    @Type string
    """
    def handle_input(self, inp):
        return input(str(inp.strip(" ")))
        
    """
    This boring function here takes in a paremeter called command and checks 
    if it is a valid command
    @Param commands 
    @HandlesError TypeError 
    @Type string
    @ErrorHandleOutput The {command} must have a parameter dumbo!
    """
    def validate_command(self, command):
        try:
            self.commands[command]()
        except KeyError:
            if not command.startswith("echo"):
                print(f"{command.upper()} is not a valid command!")
            else:
                self.handle_echo(command[4::].strip())
        except TypeError:
            print(f"The {command} command must have a parameter, dumbo!")
            
commandInterpreter = CommandInterpreter()
while commandInterpreter.isRunning:
    command = commandInterpreter.handle_input("> ").lower()
    commandInterpreter.validate_command(command)

Guidelines

• I have read and understood this category's guidelines before making this post.

[jorritvanderheide]

Your new code demonstrates a clear understanding of software design principles. Moving from a procedural to an object-oriented approach is a good improvement, and the focus on readability and structure is nice as well.

Key improvements over the old code

Avoiding redundancy:

In the old code, the terminal() function was called recursively in multiple places, which could lead to stack overflow. The new code avoids recursion with a cleaner while-loop structure.

Dynamic command addition:

The new design simplifies how commands are handled dynamically, though adding commands programmatically isn’t yet implemented.

Eliminating file dependency:

Unlike the old code, the new design doesn’t rely on external files (newcmd.txt) for adding commands, reducing potential file I/O issues.

Suggestions for further improvement

Dynamic command registration:

Implement a method to allow users to add commands dynamically during runtime. For example:

def add_command(self, name, function):
    self.commands[name] = function

Error handling expansion:

Improve error messages to provide more guidance. For instance, when a command fails, suggest typing "help" to see available commands.

Unit testing:

Start incorporating tests to validate the behavior of your methods. For example, you could use Python’s unittest module to test command validation and input handling.

Avoiding hardcoded strings:

Consider using constants for command names to prevent typos and simplify updates. For example:

CMD_ECHO = "echo"
self.commands = {CMD_ECHO: self.handle_echo, ...}

Optional logging:

Add logging for command usage to help debug or analyze usage patterns:

import logging
logging.basicConfig(level=logging.INFO)
logging.info(f"Command executed: {command}")

Docstring consistency:

Use consistent styles for your docstrings. For example, adhere to the Google, NumPy, or PEP 257 conventions for clarity.

If you'd ask me, the next steps involve enhancing scalability and robustness, which will align with best practices in professional software development. You can explore code in well-design project such as Django or Flask. I can also recommend using ChatGPT to review your code.

[DumbestPerson224]

Why not have the .lower() function in handle_input?

[jorritvanderheide]

If you anticipate handling mostly case-insensitive commands, you can indeed move .lower() into handle_input like this:

def handle_input(self, inp):
    return input(str(inp.strip(" "))).lower()

Does that answer your question?