当从网络接收到数据时，如何运行程序并执行代码?

问题描述

我用 Python 编写了一个小程序，它基本上执行以下操作:

I've written a little program in Python that basically does the following:

1. 从用户那里获取一个启动指令作为输入.如果它与 set 关键字匹配，它将继续.
2. 输入正确的启动指令后，系统会要求用户输入命令.
3. 读取命令后，程序会检查命令文件以查看是否有与该输入匹配的命令
4. 如果找到匹配的命令，则执行该命令所说的任何内容.

我想添加通过网络执行命令的功能，如下所示(并在途中学习使用 Twisted):

I'd like to add the ability to execute commands over a network as follows (and learn to use Twisted on the way):

1. 客户端 #1 输入针对客户端 #2 的命令.
2. 命令被发送到服务器，该服务器将其路由到客户端 #2.
3. 客户端 #2 接收命令并在其有效时执行.

注意:本地(使用下面的代码)和远程输入命令应该是可能的.

Note: Entering commands locally (using the code below) and remotely should be possible.

经过一番思考，我想不出任何其他方法来实现这一点，除了:

After some thinking I couldn't come up with any other way to implement this other than:

1. 让上面的程序作为进程 #1 运行(我在开始时写的本地运行的程序).
2. Twisted 客户端将作为进程 #2 运行并接收来自远程客户端的命令.每当收到命令时，Twisted 客户端都会初始化一个线程，该线程将解析该命令，检查其有效性并在有效时执行.

由于我没有太多线程经验，也没有网络编程经验，所以我想不出任何其他对我有意义的方案.

Since I don't have that much experience with threads and none with network programming, I couldn't think of any other scheme that makes sense to me.

上述方案是否过于复杂?在尝试以这种方式实施之前，我将不胜感激.

python程序(不含客户端)的代码为:

The code for the python program (without the client) is:

main(也就是start()方法):

The main (which is the start() method):

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

监听器(从用户那里获取输入):

The Listener (gets input from the user):

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

执行者(执行给定命令的类):

The executor (the class that executes the given command):

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

命令文件解析器:

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

示例配置文件:

Commands:
  echo : echo hello


Hotword: start

推荐答案

我发现很难理解你的问题的背景，但我会自己解决问题.

I'm finding it extremely difficult to follow the background in your questions, but I'll take a stab at the questions themselves.

正如您在问题中指出的那样，写走路和嚼口香糖"的典型方式是样式应用程序是以线程或事件循环样式设计您的代码.

As you noted in your question, the typical way to write a "walk and chew-gum" style app is to design your code in a threaded or an event-loop style.

鉴于您谈论线程和 Twisted(这是事件循环样式)，我担心您可能正在考虑将两者混合使用.

Given you talking about threading and Twisted (which is event-loop style) I'm worried that you may be thinking about mixing the two.

我认为它们是完全不同的编程风格(每个都有自己擅长的地方)，混合它们通常是一条通往地狱的道路.

I view them as fundamentally different styles of programming (each with places they excel) and that mixing them is generally a path to hell.

让我给你一些背景解释

• 如何思考这个概念:

• How to think of the concept:

我需要同时做多项事情，并且我希望我的操作系统能够确定如何以及何时运行这些单独的任务.

I have multiple things I need to do at the same time, and I want my operating system to figure how and when to run those separate tasks.

虽然您的应用程序似乎并非完全基于 IO，但似乎都不是基于 CPU 的(看起来您当前通过 system 调用播放音频，system 每次被调用时都会分离出一个独立的进程，因此它的工作不会消耗你的进程 CPU - 尽管 system 阻塞，所以它在扭曲时是禁忌 - 你必须使用不同的调用扭曲).

While your application doesn't seem to be exclusively IO based, none of it seems to be CPU based (it looks like your currently playing audio via a system call, system spins off an independent process every time its called, so its work doesn't burn your processes CPU - though system blocks, so its a no-no in twisted - you have to use different calls in twisted).

您的问题也不表明您担心最大化多个内核.

Your question also doesn't suggest your concerned about maxing out multiple cores.

因此，鉴于您专门谈到了 Twisted，并且事件循环解决方案似乎最适合您的应用程序，我建议您查看 Twisted 和 -not-threads.

Therefor, given you specifically talked about Twisted, and an event-loop solution seems to be the best match for your application, I would recommend looking at Twisted and -not- threads.

鉴于上面列出的最佳用途"，您可能会认为混合扭曲和线程是一种方法，但是当您这样做时，如果您做任何事情，即使是轻微错误，您也会禁用事件循环(你会阻塞)和线程(GIL 不会让线程执行多任务)的优势，并且有一些超级复杂的东西给你没有优势.

Given the 'Best use' listed above you might be tempted to think that mixing twisted and threads is the way-to-got, but when doing that if you do anything even slightly wrong you will disable the advantages of both the event-loop (you'll block) and threading (GIL won't let the threads multitask) and have something super complex that provides you no advantage.

你给出的方案"是:

经过一番思考，我想不出任何其他方法来实现这一点，除了:

After some thinking I couldn't come up with any other way to implement this other than:

1. 让上面的程序作为进程 #1 运行(我在开始时写的本地运行的程序).
2. Twisted 客户端将作为进程 #2 运行并接收来自远程客户端的命令.每当收到命令时，Twisted 客户端都会初始化一个线程，该线程将解析该命令，检查其有效性并在有效时执行.

由于我没有太多线程方面的经验，也没有网络编程方面的经验，所以我想不出任何其他对我有意义的方案.

Since I don't have that much experience with threads and none with network programming, I couldn't think of any other scheme that makes sense to me.

在回答方案是否......过于复杂"时，我几乎可以肯定地说是的，因为您谈论的是扭曲的 和 线程.(见上面的 tr; dr)

In answer to "Is the scheme ... overly complicated", I would say almost certainly yes because your talking about twisted and threads. (see tr; dr above)

鉴于我对您要构建的内容的理解肯定不完整(并且很困惑)，我想您的一个扭曲的解决方案如下所示:

Given my certainly incomplete (and confused) understanding of what you want to build, I would imagine a twisted solution for you would look like:

1. 仔细研究krondo Twisted Introduction(它确实需要跟踪示例代码行-for-行，但如果你做这项工作，它是一个很棒的学习工具，用于扭曲和事件编程)
2. 从头开始，您可以使用您在 krondo 指南中学到的东西，以扭曲的方式重写您的启动词" - 开始时只需提供您当前拥有的任何界面(键盘?)
3. 向该代码添加其他通信接口(telnet、Web 等)，以便您访问您为键盘(?)接口编写的处理代码.

1. Carefully study the krondo Twisted Introduction (it really requires tracing the example code line-for-line, but if you do the work its an AWESOME learning tool for twisted - and event programing in general)
2. From the ground-up you rewrite your 'hotword' thingy in twisted using what you learned in the krondo guide - starting out just providing whichever interface you currently have (keyboard?)
3. Add other communication interfaces to that code (telnet, web, etc) which would let you access the processing code you wrote for the keyboard(?) interface.

如果如您在问题中所述，您确实需要一台服务器，您可以编写第二个扭曲程序来提供该服务器(您将在 krondo 指南中看到所有这些示例).虽然我猜当您了解了 twisted 的库支持时，您会意识到您不必构建任何额外的服务器，您可以在基本代码中包含您需要的任何协议.

If, as you state in your question, you really need a server, you could write a second twisted program to provide that (you'll see examples of all that in the krondo guide). Though I'm guessing when you understand twisted's library support you'll realize you don't have to build any extra servers, that you can just include whichever protocols you need in your base code.

这篇关于当从网络接收到数据时，如何运行程序并执行代码?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！