Wie man ein Programm ausführt und auch Code ausführt, wenn Daten vom Netzwerk empfangen werden?

Ich habe ein kleines Programm in Python geschrieben, das im Grunde Folgendes tut:

Ruft ein Hotword als Eingabe vom Benutzer ab. Wenn es mit dem festgelegten Schlüsselwort übereinstimmt, wird es fortgesetzt.Nach Eingabe des richtigen Hotwords wird der Benutzer aufgefordert, einen Befehl einzugeben.Nachdem der Befehl gelesen wurde, überprüft das Programm eine Befehlsdatei, um festzustellen, ob ein Befehl mit dieser Eingabe übereinstimmtWenn ein passender Befehl gefunden wird, führen Sie den Befehl aus.

Ich möchte die Fähigkeit, Befehle über ein Netzwerk auszuführen, wie folgt hinzufügen (und lernen, Twisted unterwegs zu verwenden):

Client 1 gibt einen Befehl für Client 2 ein.Der Befehl wird an einen Server gesendet, der ihn an Client 2 weiterleitet.Client # 2 empfängt den Befehl und führt ihn aus, wenn er gültig ist.

Hinweis: Die Eingabe von Befehlen lokal (mit dem folgenden Code) und remote sollte möglich sein.

Nach einigem Überlegen konnte ich keine andere Möglichkeit finden, dies umzusetzen, als:

Lassen Sie das obige Programm als Prozess 1 ausführen (das Programm, das lokal ausgeführt wird, wie ich es am Anfang geschrieben habe).Ein Twisted-Client wird als Prozess 2 ausgeführt und empfängt die Befehle von Remoteclients. Immer wenn ein Befehl empfangen wird, initialisiert der Twisted-Client einen Thread, der den Befehl analysiert, auf seine Gültigkeit prüft und ihn ausführt, wenn er gültig ist.

Da ich nicht so viel Erfahrung mit Threads und keine mit Netzwerkprogrammierung habe, konnte ich mir kein anderes Schema vorstellen, das für mich Sinn macht.

Ist das oben genannte Schema zu kompliziert? Ich würde mich über einen Einblick freuen, bevor ich versuche, ihn auf diese Weise umzusetzen.

Der Code für das Python-Programm (ohne den Client) lautet:

Die main (das ist die start () Methode):

class Controller:
    def __init__(self,listener, executor):
        self.listener = listener
        self.executor = executor


    def start(self):
        while True:
            text = self.listener.listen_for_hotword()

            if self.executor.is_hotword(text):
                text = self.listener.listen_for_command()
                if self.executor.has_matching_command(text):
                    self.executor.execute_command(text)
                else:
                    tts.say("No command found. Please try again")

Der Listener (wird vom Benutzer eingegeben):

class TextListener(Listener):
    def listen_for_hotword(self):
        text = raw_input("Hotword: ")
        text =' '.join(text.split()).lower()
        return text

    def listen_for_command(self):
        text = raw_input("What would you like me to do: ")
        text = ' '.join(text.split()).lower()
        return text

Der Executor (die Klasse, die den angegebenen Befehl ausführt):

class Executor:
    #TODO: Define default path
    def __init__(self,parser, audio_path='../Misc/audio.wav'):
        self.command_parser = parser
        self.audio_path = audio_path

    def is_hotword(self,hotword):
        return self.command_parser.is_hotword(hotword)

    def has_matching_command(self,command):
        return self.command_parser.has_matching_command(command)

    def execute_command(self,command):
        val = self.command_parser.getCommand(command)
        print val
        val = os.system(val) #So we don't see the return value of the command

Der Befehlsdatei-Parser:

class KeyNotFoundException(Exception):
    pass


class YAMLParser:
    THRESHOLD = 0.6

    def __init__(self,path='Configurations/commands.yaml'):
        with open(path,'r') as f:
            self.parsed_yaml = yaml.load(f)

    def getCommand(self,key):
        try:
            matching_command = self.find_matching_command(key)
            return self.parsed_yaml["Commands"][matching_command]
        except KeyError:
            raise KeyNotFoundException("No key matching {}".format(key))

    def has_matching_command(self,key):
        try:
            for command in self.parsed_yaml["Commands"]:
                if jellyfish.jaro_distance(command,key) >=self.THRESHOLD:
                    return True
        except KeyError:
            return False

    def find_matching_command(self,key):
        for command in self.parsed_yaml["Commands"]:
            if jellyfish.jaro_distance(command,key) >=0.5:
                return command

    def is_hotword(self,hotword):
        return jellyfish.jaro_distance(self.parsed_yaml["Hotword"],hotword)>=self.THRESHOLD

Beispiel Konfigurationsdatei:

Commands:
  echo : echo hello


Hotword: start