Lets implement a command shell by using a command dispatcher. The objective is to have an event loop which is to dispatch input commands, and implement some handlers who are going to handle those commands. And, we dont want to change in event loop whenever some new command comes in future. So, our design should be scalble enough to support adding new commands without affecting the event loop.

Decorator in Python

I hope you have seen Timeit implementation using Decorator

Event loop (Command Dispatcher)


class CommandDispatch:
    def __init__(self):
        # list of commands
        self.commands = {}

    """
    For registering commands
    """
    def for_command(self, cmd):
        def wrap(fn):
            self.commands[cmd] = fn
        return wrap

    """
    For registering invalid command handler
    """
    def invalid(self, fn):
        self.invalidfn = fn

    """
    For registering input method
    """
    def input(self, fn):
        self.inputfn = fn

    """
    Main event loop
    """
    def run(self):
        while True:
            args = self.inputfn()
            self.commands.get(args[0], self.invalidfn)(*args)

Above class implements Decorator pattern, and provides an event loop. And, some methods to register method handlers.

Command Handlers

"""
     A command_dispatch module with class CommandDispatch
     such that the following example program that implements a
     rudimentary command-line shell works.
"""

from command_dispatch import CommandDispatch

shell = CommandDispatch()

@shell.for_command("list")
def list_directory(*args):
    from os import listdir
    if len(args) < 2:
        args += ".",
    for path in args[1:]:
        print("{}:".format(path))
        print("\n".join(listdir(path)))

@shell.for_command("whoami")
def show_user(*args):
    from getpass import getuser
    print(getuser())

@shell.for_command("date")
def print_date(*args):
    from time import ctime
    print(ctime())

@shell.for_command("pwd")
def show_curr_dir(*args):
    import os
    print(os.getcwd())

@shell.for_command("exit")
def exit_shell(*args):
    exit(0)

@shell.for_command("hostname")
def show_hostname(*args):
    from os import uname
    print(uname().nodename)

@shell.invalid
def invalid_command(*args):
    print("Invalid command - ", args[0])


@shell.input
def get_input():
    # import rlcompleter
    return input("PyShell> ").split()

if __name__ == '__main__':
    shell.run()

Here, we are instantiating our event loop. And, using that instance, registering different command handlers. For example:

@shell.for_command("exit")
def exit_shell(*args):
    exit(0)

We are registering a command handler for command: exit. It gets registered in our CommandDispatcher’s list: commands. After executing this file. The dictionary in CommandDispatcher looks like:

{
    'list': <function list_directory>, 
    'whoami': <function show_user>, 
    'date': <function print_date>, 
    'pwd': <function show_curr_dir>, 
    'exit': <function exit_shell>, 
    'hostname': <function show_hostname>}

So, when we ran our program. At first, it runs run method of CommandDispatcher’s class. And, in the infinite loop, it calls input function. And, whatever argument it returns. We are checking in the dictionary: commands. If it is found, we are calling that method by passing args, else calling invalidfn.

def run(self):
    while True:
        args = self.inputfn()
        self.commands.get(args[0], self.invalidfn)(*args)

Github

The code can be found at GyanBlog Github repository

Let me know in comment section, if there is any confusion. Hope it helps.