Cacher is the code snippet organizer for pro developers

import threading

class Poller:
    def __init__(self, thread_class, interpreter):
        assert hasattr(interpreter, '__call__')
 
        self.thread_class = thread_class
        self.interpreter = interpreter
 
    def poll(self):
        self._set_up_thread()
 
        while True:
            while not self.thread.data_ready.isSet():
                pass
 
            try:
                self.interpreter(self.thread.data)
            except SystemExit:
                break
            else:
                self._set_up_thread()
 
    def _set_up_thread(self):
        self.thread = self.thread_class()
        self.thread.start()
 
class KeyboardThread(threading.Thread):
    def __init__(self):
        self.data_ready = threading.Event()
 
        super(KeyboardThread, self).__init__()
 
    def run(self):
        self.data = self.get_data()
        self.data_ready.set()
 
class KeyboardInput(KeyboardThread):
    def get_data(self):
        return raw_input('>>> ')

def main():
    ...
    poller = Poller(KeyboardInput, interpreter)
    poller.poll()

if __name__ == "__main__" :
    main()

from file import PluginDirectory
from interpreter import Interpreter
from plugin_loader import PluginLoader
 
class Application:
 
    def run(self):
        plugin_loader = PluginLoader()
        plugin_directory = PluginDirectory()
        commands = plugin_loader.load(plugin_directory)
        interpreter = Interpreter(commands)

        try:
            while True:
                input = self.input()
                result = interpreter.interpret(input)

                if result is not None:
                    if isinstance(result, str):
                        lines = result.split('\n')

                        if len(lines) > 1:
                            for line in lines:
                                self.output(line)
                        else:
                            self.output(result)
                    else:
                        self.output(result)
        except SystemExit:
            pass

    def input(self):
        return raw_input('>>> ')

    def output(self, result):
        print result