TL.DR;
这是一个复杂的请求。我不认为可以通过技巧来实现。或者你拥有运行blender的进程（意味着你导入它的api），或者你附加到进程（使用gdb，但我不知道你是否可以使用你想要的IDE）或者你使用IDE包括pydevd。即便如此，我也不知道你能达到多少。
同步两个python进程并非易事。答案说明了一点。
PyDev.Debugger
您想找到一种方法来同步位于不同 python 实例中的两个 python 对象。我认为解决您的问题的唯一真正方法是设置pydevd 服务器并连接到它。如果您使用受支持的 IDE 之一（例如 PyDEV 或 PyCharm）会更简单，因为它们已经准备好执行此操作：
pydev 所做的工作不是微不足道的，存储库是一个相当大的项目。这是你最好的选择，但我不能保证它会奏效。
进程通信
通常的通信解决方案将不起作用，因为它们会在后台序列化和反序列化（pickle 和 unpickle）数据。让我们举个例子，在搅拌机进程中实现一个服务器，它接收任意代码作为字符串并执行它，发回代码的最后结果。结果将作为 Python 对象被客户端接收，因此您可以使用 IDE 接口对其进行检查，甚至可以在其上运行一些代码。有限制：
- 并非所有内容都可以被客户端接收（例如，类定义必须存在于客户端中）
- 只有可拾取的对象可以在连接上传输
- 客户端和服务器中的对象不同：如果没有额外的（相当复杂的）逻辑，客户端上所做的修改将不会应用到服务器上
这是应该在您的 Blender 实例上运行的服务器
from multiprocessing.connection import Listener
from threading import Thread
import pdb
import traceback
import ast
import copy
# This is your configuration, chose a strong password and only open
# on localhost, because you are opening an arbitrary code execution
# server. It is not much but at least we cover something.
port = 6000
address = ('127.0.0.1', port)
authkey = b'blender'
# If you want to run it from another machine, you must set the address
# to '0.0.0.0' (on Linux, on Windows is not accepted and you have to
# specify the interface that will accept the connection)
# Credits: https://stackoverflow.com/a/52361938/2319299
# Awesome piece of code, it is a carbon copy from there
def convertExpr2Expression(Expr):
r"""
Convert a "subexpression" of a piece of code in an actual
Expression in order to be handled by eval without a syntax error
:param Expr: input expression
:return: an ast.Expression object correctly initialized
"""
Expr.lineno = 0
Expr.col_offset = 0
result = ast.Expression(Expr.value, lineno=0, col_offset=0)
return result
def exec_with_return(code):
r"""
We need an evaluation with return value. The only two function
that are available are `eval` and `exec`, where the first evaluates
an expression, returning the result and the latter evaluates arbitrary code
but does not return.
Those two functions intercept the commands coming from the client and checks
if the last line is an expression. All the code is executed with an `exec`,
if the last one is an expression (e.g. "a = 10"), then it will return the
result of the expression, if it is not an expression (e.g. "import os")
then it will only `exec` it.
It is bindend with the global context, thus it saves the variables there.
:param code: string of code
:return: object if the last line is an expression, None otherwise
"""
code_ast = ast.parse(code)
init_ast = copy.deepcopy(code_ast)
init_ast.body = code_ast.body[:-1]
last_ast = copy.deepcopy(code_ast)
last_ast.body = code_ast.body[-1:]
exec(compile(init_ast, "<ast>", "exec"), globals())
if type(last_ast.body[0]) == ast.Expr:
return eval(compile(convertExpr2Expression(last_ast.body[0]), "<ast>", "eval"), globals())
else:
exec(compile(last_ast, "<ast>", "exec"), globals())
# End of carbon copy code
class ArbitraryExecutionServer(Thread):
r"""
We create a server execute arbitrary piece of code (the most dangerous
approach ever, but needed in this case) and it is capable of sending
python object. There is an important thing to keep in mind. It cannot send
**not pickable** objects, that probably **include blender objects**!
This is a dirty server to be used as an example, the only way to close
it is by sending the "quit" string on the connection. You can envision
your stopping approach as you wish
It is a Thread object, remeber to initialize it and then call the
start method on it.
:param address: the tuple with address interface and port
:param authkey: the connection "password"
"""
QUIT = "quit" ## This is the string that closes the server
def __init__(self, address, authkey):
self.address = address
self.authkey = authkey
super().__init__()
def run(self):
last_input = ""
with Listener(self.address, authkey=self.authkey) as server:
with server.accept() as connection:
while last_input != self.__class__.QUIT:
try:
last_input = connection.recv()
if last_input != self.__class__.QUIT:
result = exec_with_return(last_input) # Evaluating remote input
connection.send(result)
except:
# In case of an error we return a formatted string of the exception
# as a little plus to understand what's happening
connection.send(traceback.format_exc())
if __name__ == "__main__":
server = ArbitraryExecutionServer(address, authkey)
server.start() # You have to start the server thread
pdb.set_trace() # I'm using a set_trace to get a repl in the server.
# You can start to interact with the server via the client
server.join() # Remember to join the thread at the end, by sending quit
虽然这是您的 VSCode 中的客户端
import time
from multiprocessing.connection import Client
# This is your configuration, should be coherent with
# the one on the server to allow the connection
port = 6000
address = ('127.0.0.1', port)
authkey = b'blender'
class ArbitraryExecutionClient:
QUIT = "quit"
def __init__(self, address, authkey):
self.address = address
self.authkey = authkey
self.connection = Client(address, authkey=authkey)
def close(self):
self.connection.send(self.__class__.QUIT)
time.sleep(0.5) # Gives some time before cutting connection
self.connection.close()
def send(self, code):
r"""
Run an arbitrary piece of code on the server. If the
last line is an expression a python object will be returned.
Otherwise nothing is returned
"""
code = str(code)
self.connection.send(code)
result = self.connection.recv()
return result
def repl(self):
r"""
Run code in a repl loop fashion until user enter "quit". Closing
the repl will not close the connection. It must be manually
closed.
"""
last_input = ""
last_result = None
while last_input != self.__class__.QUIT:
last_input = input("REMOTE >>> ")
if last_input != self.__class__.QUIT:
last_result = self.send(last_input)
print(last_result)
return last_result
if __name__ == "__main__":
client = ArbitraryExecutionClient(address, authkey)
import pdb; pdb.set_trace()
client.close()
在脚本的底部还有如何在将pdb 设置为“repl”时启动它们。 使用此配置，您可以在服务器上从客户端运行任意代码（实际上这是一个极其危险的场景，但对于您非常具体的情况是有效的，或者更好“主要要求”）。
让我们深入了解我预期的限制。
你可以在服务器上定义一个类Foo：
[client] >>> client = ArbitraryExecutionClient(address, authkey)
[client] >>> client.send("class Foo: pass")
[server] >>> Foo
[server] <class '__main__.Foo'>
你可以在服务器上定义一个名为“foo”的对象，但是你会立即收到一个错误，因为类Foo在本地实例中不存在（这次使用repl）：
[client] >>> client.repl()
[client] REMOTE >>> foo = Foo()
[client] None
[client] REMOTE >>> foo
[client] *** AttributeError: Can't get attribute 'Foo' on <module '__main__' from 'client.py'>
出现此错误是因为在本地实例中没有Foo 类的声明，因此无法正确解开接收到的对象（所有 Blender 对象都会出现此问题。请注意，如果对象在某种程度上是可导入的，它可能仍然有效，我们稍后会看到这种情况）。
不接收错误的唯一方法是预先在客户端上声明该类，但它们不会是同一个对象，正如您可以通过查看它们的 id 看到的那样：
[client] >>> class Foo: pass
[client] >>> client.send("foo")
[client] <__main__.Foo object at 0x0000021E2F2F3488>
[server] >>> foo
[server] <__main__.Foo object at 0x00000203AE425308>
它们的 id 不同，因为它们存在于不同的内存空间中：它们是完全不同的实例，你必须手动同步它们上的每个操作！
如果类定义在某种程度上是可导入的并且对象是可挑选的，你可以避免重复类定义，据我所知它将自动导入：
[client] >>> client.repl()
[client] REMOTE >>> import numpy as np
[client] None
[client] REMOTE >>> ary = np.array([1, 2, 3])
[client] None
[client] REMOTE >>> ary
[client] [1 2 3]
[client] REMOTE >>> quit
[client] array([1, 2, 3])
[client] >>> ary = client.send("ary")
[client] >>> ary
[client] array([1, 2, 3])
[client] >>> type(ary)
[client] <class 'numpy.ndarray'>
我们从未在客户端上导入numpy，但我们已正确接收到对象。但是如果我们将本地实例修改为远程实例会怎样呢？
[client] >>> ary[0] = 10
[client] >>> ary
[client] array([10, 2, 3])
[client] >>> client.send("ary")
[client] array([1, 2, 3])
[server] >>> ary
[server] array([1, 2, 3])
我们没有同步对象内部的修改。
如果一个对象不可拾取怎么办？我们可以使用server 变量进行测试，该对象是Thread 并包含一个连接，它们都是不可选择的（意味着您不能将它们作为字节列表提供可逆的表示）：
[server] >>> import pickle
[server] >>> pickle.dumps(server)
[server] *** TypeError: can't pickle _thread.lock objects
我们也可以在客户端看到错误，尝试接收它：
[client] >>> client.send("server")
[client] ... traceback for "TypeError: can't pickle _thread.lock objects" exception ...
我认为这个问题没有“简单”的解决方案，但我认为有一些库（如pydevd）实现了克服这个问题的完整协议。
我希望现在我的 cmets 更清楚了。