He escrito un pequeño programa en Python que básicamente hace lo siguiente:

Obtiene una palabra activa como entrada del usuario. Si coincide con la palabra clave establecida, continúa.Después de ingresar la palabra clave correcta, se le pide al usuario que ingrese un comando.Después de leer el comando, el programa verifica un archivo de comando para ver si hay un comando que coincida con esa entradaSi se encuentra un comando coincidente, ejecute lo que ese comando diga.

Me gustaría agregar la capacidad de ejecutar comandos en una red de la siguiente manera (y aprender a usar Twisted en el camino):

El cliente n. ° 1 ingresa un comando dirigido al cliente n. ° 2.El comando se envía a un servidor que lo dirige al cliente # 2.El cliente n. ° 2 recibe el comando y lo ejecuta si es válido.

Nota: Debería ser posible ingresar comandos localmente (usando el código a continuación) y remotamente.

Después de pensar un poco, no pude encontrar otra forma de implementar esto que no sea:

Haga que el programa anterior se ejecute como proceso n. ° 1 (el programa que se ejecuta localmente como he escrito al principio).Un cliente Twisted se ejecutará como proceso # 2 y recibirá los comandos de clientes remotos. Cada vez que se recibe un comando, el cliente Twisted inicializará un subproceso que analizará el comando, verificará su validez y lo ejecutará si es válido.

Como no tengo mucha experiencia con hilos y ninguno con programación de red, no podría pensar en ningún otro esquema que tenga sentido para mí.

¿El esquema mencionado anteriormente es demasiado complicado? Agradecería alguna idea antes de intentar implementarlo de esta manera.

El código para el programa python (sin el cliente) es:

El principal (que es el método start ()):

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")

El oyente (obtiene información del usuario):

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

El ejecutor (la clase que ejecuta el comando dado):

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

El analizador de archivos de comando:

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

Archivo de configuración de ejemplo:

Commands:
  echo : echo hello


Hotword: start