Python REPL

[gswifort]

Would it be possible to run something similar to PYCMDPROMPT (REPL) in an external console, preferably in the vscode console (integratedConsole). It's a bit like running debugpy, but without locking the AutoCAD interface.

[CEXT-Dan]

I don’t know, that would be cool though

Debugpy, is all Python, or at least I don’t do anything in C++ to enable this except redirect stdout

PyRx/PyRxCore/PyAcRx.cpp

Lines 36 to 89 in d7a9404

	enum eDirection_type
	{
	eStdin,
	eStdout,
	eStderr
	};
	template<eDirection_type>
	class py_redirector
	{
	public:
	void write(const std::string& text)
	{
	if (text.size() != 0)
	acutPrintf(utf8_to_wstr(text).c_str());
	}
	void flush()
	{
	acutPrintf(_T("\n"));
	}
	};
	typedef py_redirector<eStdout> stdout_redirector;
	typedef py_redirector<eStderr> stderr_redirector;
	static boost::shared_ptr<stdout_redirector> make_stdout_redirector()
	{
	return boost::shared_ptr<stdout_redirector>(new stdout_redirector);
	}
	static boost::shared_ptr<stderr_redirector> make_stderr_redirector()
	{
	return boost::shared_ptr<stderr_redirector>(new stderr_redirector);
	}
	//-----------------------------------------------------------------------------------------------------------
	//PyRx Module
	BOOST_PYTHON_MODULE(PyRx)
	{
	docstring_options local_docstring_options(py_show_user_defined, py_show_py_signatures, py_show_cpp_signatures);
	class_<stdout_redirector>("stdout", init<>())
	.def("__init__", make_constructor(make_stdout_redirector))
	.def("write", &stdout_redirector::write)
	.def("flush", &stdout_redirector::flush)
	;
	class_<stderr_redirector>("stderr", init<>())
	.def("__init__", make_constructor(make_stderr_redirector))
	.def("write", &stderr_redirector::write)
	.def("flush", &stderr_redirector::flush)
	;
	boost::python::import("sys").attr("stdout") = make_stdout_redirector().get();
	boost::python::import("sys").attr("stderr") = make_stderr_redirector().get();

Communication with Debugpy is not without its side effects. I’m pretty sure that Debugpy hijacks stdin to push data to python. But if you notice when debugging, interaction with AutoCAD’s command line gets wonky

Ideally, I would like to see something that can be more interactive with the CAD side like autolisp
I would also like to see this done in Python. The goal is to expose AutoCAD to Python so these sorts of tasks could be done in Python

A short-term solution would be to create a modeless dialog, or even better a palette (Like the PyChat sample, maybe with the send button removed and have an ‘enter event’)

[gswifort]

So, let's do it!
Below is a demo.

1. Load the module into CAD:

   import code
   import sys
   import threading
   
   import win32console
   
   from pyrx_imp import *
   
   
   def PyRxCmd_interact():
   
       threading.Thread(target=main).start()
   
   
   def main():
       try:
           win32console.AllocConsole()
           f_in = open("CONIN$", "r")
           f_out = open("CONOUT$", "w")
           sys.stdout = f_out
           sys.stderr = f_out
           sys.stdin = f_in
   
           code.interact(local=globals())
   
       finally:
           win32console.FreeConsole()

2. Call INTERACT. A console window should open.

3. Do anything in the console, e.g.:

   >>> p = (
       Ap.Application()
       .docManager()
       .curDocument()
       .editor()
       .getPoint("\nGetPoint\n")
   )
   >>> print(p)

   and now the strange thing... at the beginning it worked for me, the console waited for me to click on the point and returned it. Then it stopped working - the command is sent to CAD, the point cursor appears, but the console immediately raises RuntimeError: unidentifiable C++ exception.
   Maybe I should use this part somehow:

   PyRx/PySamples/wxWidgets/EditorInteraction/testwxpyxrcmodeless.py

   Lines 61 to 71 in 4583ba3

   	#we need this to capture WM_ACAD_KEEPFOCUS
   	def addHook(self):
   	self.oldWndProc = win32gui.SetWindowLong(self.GetHandle(),win32con.GWL_WNDPROC,self.MyWndProc)
   	def restoreHook(self):
   	wx.MessageBox("YAY")
   	return win32api.SetWindowLong(self.GetHandle(), win32con.GWL_WNDPROC, self.oldWndProc)
   	def OnClose(self, event):
   	self.restoreHook()
   	self.Destroy()

4. When you finish your actions in the console, type exit() to release the console, otherwise when you close the console, CAD will also close.

Additionally, I don't know how to add something to the model space of the current document, I get a message that the database is locked.

[gswifort]

Ok, now I know why it worked for me the first time. I loaded your module, ran the command WXPYXRCM, closed the dialog, loaded my module, ran INTERACT , in the console I ran:

>>> p = (
    Ap.Application()
    .docManager()
    .curDocument()
    .editor()
    .getPoint("\nGetPoint\n")
)
>>> print(p)

With this combination, the console waits for the CAD to indicate a point.

[gswifort]

This works very well:

import traceback

import wx
import wx.py.shell
from pyrx_imp import Ap, Db, Ed, Ge, Gi, Gs, Rx  # will be added to PyShell


def PyRxCmd_pyshell():
    try:
        dlg = wx.py.shell.ShellFrame(None, locals=globals())
        dlg.Show()
    except Exception:
        traceback.print_exc()

---

I still don't know how to add something to the database:

>>> p1 = Ge.Point3d(0,0,0)
>>> p2 = Ge.Point3d(100,100,0)
>>> line = Db.Line(p1,p2)
>>> Db.curDb().addToCurrentspace(line)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
RuntimeError: 
Exception!(eLockViolation), function addToBlock1, Line 560, File PyDbDatabase.cpp: 

[CEXT-Dan]

try this for zwcad

lock = Ap.AutoDocLock()
line = Db.Line(Ge.Point3d(0,0,0),Ge.Point3d(100,100,0))
Db.curDb().addToModelspace(line)
del(line)
del(lock)

[CEXT-Dan]

So GC will be an issue for database objects. User will need to manually call DbObject.close(), or dispose()
use the ActiveX wrappers, or add a scope

def foo():
    lock = Ap.AutoDocLock()
    line = Db.Line(Ge.Point3d(0,0,0),Ge.Point3d(100,100,0))
    Db.curDb().addToModelspace(line)

[gswifort]

It works! Thanks!

[gswifort]

User will need to manually call DbObject.close(), or dispose() use the ActiveX wrappers, or add a scope

Or this:

import inspect
import traceback

import wx
import wx.py.shell
from pyrx_imp import Ap, Db, Ed, Ge, Gi, Gs, Rx  # will be added to PyShell


class DbTransaction:
    def __enter__(self):
        self.frame = inspect.currentframe().f_back
        self.enter_vars = set(self.frame.f_locals.keys())
        self.lock = Ap.AutoDocLock()
        return Db.curDb()

    def __exit__(self, exc_type, exc_val, exc_tb):
        exit_vars = set(self.frame.f_locals.keys())
        new_vars = exit_vars - self.enter_vars
        for var in new_vars:
            del self.frame.f_locals[var]
        del self.lock


def PyRxCmd_pyshell():
    try:
        dlg = wx.py.shell.ShellFrame(None, locals=globals())
        dlg.Show()
    except Exception:
        traceback.print_exc()

in PyShell:

with DbTransaction() as db:
    line = Db.Line(Ge.Point3d(0,0,0),Ge.Point3d(100,100,0))
    db.addToModelspace(line)

[CEXT-Dan]

Super cool!

[CEXT-Dan]

PyShell, calling help(), copyright(), credits(), license(), nukes AutoCAD

[CEXT-Dan]

seems these can be overridden

def help():
    print("No help for you")
    
def copyright():
    print("No copyright for you")
    
def credits():
    print("No credits for you")
    
def license():
    print("No license for you")

def PyRxCmd_pyshell():
...

[CEXT-Dan]

I tried to improve PyEdUserInteraction::userInteraction,for function like entSel(“\nSelect: “)
but failed, it turned ShellFrame modal

ShellFrame inherits from a custom frame, that may be the place to start customizing
I.e. on mouse leave, set focus to parent ( AutoCAD)

[gswifort]

I guess I don't understand what exactly you are trying to achieve.

[CEXT-Dan]

Not a big deal really, but to illustrate the behavior, see testwxpyxrc
PySamples\wxWidgets\EditorInteraction\testwxpyxrc.py

Is a modal dialog with getpoint, and getdist
userInteraction class automatically hides child dialogs, sets focus to AutoCAD’s editor,
then restores the dialog hierarchy.

Since userInteraction is already embedded in all the editor functions, I thought that might be the place
So set focus from PyShell to AutoCAD, when editor commands are run.

[gswifort]

PyShell on the palette:

import traceback

import wx
from pyrx_imp import *
from wx.py.shell import Shell

palette = Ap.PaletteSet("PyShell")


class MyPanel(wx.Panel):
    def __init__(self):
        super().__init__()
        self.Bind(wx.EVT_SHOW, self.OnShow)

    def OnShow(self, event):
        sizer = wx.BoxSizer()
        sizer.Add(Shell(self, locals=globals()), 1, wx.EXPAND, 0)
        self.SetSizerAndFit(sizer)
        self.Layout()


def createPalette():
    try:
        panel = MyPanel()
        palette.add("PyShell", panel)
        palette.setVisible(True)
        palette.setName("PyShell")

    except Exception:
        traceback.print_exc()


def PyRxCmd_pyshellpalette():
    try:
        createPalette()
    except Exception:
        traceback.print_exc()

[gswifort]

In Zwcad 2024, when it docks under the command line, it positions itself above the command line after restart. kNone docking sometimes loads fine and sometimes it docks to the left.

[CEXT-Dan]

There’s a function Ed.Core. getAcadDockCmdLine, this return’s the handle to the command line. Though I have not test it with zwcad
https://help.autodesk.com/view/OARX/2023/ENU/?guid=OARX-RefGuide-acedGetAcadDockCmdLine
You maybe be able use win32api

I’ll wrap restoreControlBar, maybe that will give you more control, additionally I will investigate wrapping acedRegisterWatchWinMsg
This will give you every message in the loop.

[CEXT-Dan]

kNone calls PostMessage(WM_COMMAND, ID_ADUI_ALLOWDOCK, 0); 0x1001 (4097)
as far as I can tell

[CEXT-Dan]

kNone docking sometimes loads fine and sometimes it docks to the left.

I see, I think I had a typo

[CEXT-Dan]

Thinking of also working the other direction, instead of me writing the implementation, for more generic applications, just wrapping what is needed from CAdUiDockControlBar and CControlBar, so the python developer can have finer grained control

You can get hints of the implementation from using IlSpy
https://github.com/icsharpcode/ILSpy

In IlSpy add ZwManaged, dill down to ZwSoft.ZwCAD.Windows.PaletteSet.Dock

[CEXT-Dan]

Autocomplete doesn't use the stubs. I asked about it here
https://discuss.wxpython.org/t/wx-py-pyshell-read-pyi/37000
there's a response, but I don't understand it

[gswifort]

So to make a patch for Shell I will have to have access to the json files and perform roughly the same steps as in genDoc, but instead of writing a pyi file I will have to call Ed.Editor.getCorner.__doc__ = docstring

[CEXT-Dan]

For now, seems like the easiest.
It’s been a real battle from a stub perspective, mostly because of my incompetence

[gswifort]

Ok, so I'll work on it.

[gswifort]

Do you have any wishes regarding the behavior of the tooltip window? I think there should be an option to turn it off (it can be annoying with small palette sizes). Unless its position can be better controlled. I also think that the previous line editing mode should be activated by the up arrow and not Ctrl + up arrow.

[CEXT-Dan]

Not really, though, there should be some control over setting the tool tip position.
If there’s an event, something like ontooltip, it would be possible to send messages to it, like move and size

[gswifort]

The pyshell palette loses focus when the tooltip is displayed and the cursor is on the tooltip. When the cursor is out, it's ok, but you can't see what you're writing.

[CEXT-Dan]

AutoCAD doesn't lose focus, but sometimes the command line is covered. something like this seems to work

import traceback

import wx
from pyrx_imp import *
from wx.py.shell import Shell

host = Ap.Application.hostAPI()
palette = Ap.PaletteSet("PyShell","{b98f3a34-ed66-4c3f-9c6a-9804e13b18b0}")

class MyPanel(wx.Panel):
    def __init__(self):
        super().__init__()
        self.Bind(wx.EVT_SHOW, self.OnShow)
        
    def OnShow(self, event: wx.ShowEvent):
        sizer = wx.BoxSizer()
        self.shellcrl = Shell(self, locals=globals())
        sizer.Add(self.shellcrl, 1, wx.EXPAND, 0)
        self.SetSizerAndFit(sizer)
        self.Layout()
        self.shellcrl.Bind(wx.EVT_CHAR, self.OnChar)
        
    def OnChar(self, event: wx.KeyEvent):
        try:
            if self.shellcrl.CallTipActive():
                self.shellcrl.CallTipCancel()
        finally:
            event.Skip()
            
def PyRxCmd_pyshell():
    try:
        panel = MyPanel()
        palette.add("PyShell", panel)
        palette.setVisible(True)
    except Exception:
        traceback.print_exc()

[gswifort]

#105 (reply in thread)

I installed python 3.13
the console is improved but still doesn't show signatures and documentation - ptpython seems better.

@CEXT-Dan, how do you feel about using the python interpreter in the console instead of the palette?

[gswifort]

Ok, so I think it's enough to run the REPL in a new thread, but send the code to be executed to the main thread.

import queue
import sys
import threading
import traceback
from code import InteractiveConsole

import win32api
import win32con
import win32console
import win32gui
from pyrx_imp import Ap


class Repl(InteractiveConsole):
    WND_PROC_MSG = 1111

    def __init__(self, locals=None, filename="<console>") -> None:
        super().__init__(locals, filename)
        self._res_queue = queue.Queue(1)
        self._code_queue = queue.Queue(1)

    def _runcode_in_main_thread(self):
        code = self._code_queue.get_nowait()
        try:
            res = super().runcode(code)
        except Exception as e:
            self._res_queue.put((False, e))
        else:
            self._res_queue.put((True, res))

    def runcode(self, code) -> None:
        self._code_queue.put(code)
        win32gui.PostMessage(Ap.Application.mainWnd(), self.WND_PROC_MSG, 0, 0)
        success, res = self._res_queue.get()
        if success:
            return res
        else:
            raise res

    def is_repl_msg(self, msg, w_param, l_param):
        return msg == self.WND_PROC_MSG

    def my_wnd_proc(self, hwnd, msg, w_param, l_param):
        if self.is_repl_msg(msg, w_param, l_param):
            self._runcode_in_main_thread()
            return 0
        return win32gui.CallWindowProc(self._old_wnd_proc, hwnd, msg, w_param, l_param)

    def _add_wnd_proc_hook(self):
        self._old_wnd_proc = win32gui.SetWindowLong(Ap.Application.mainWnd(), win32con.GWL_WNDPROC, self.my_wnd_proc)

    def _restore_wnd_proc_hook(self):
        win32api.SetWindowLong(Ap.Application.mainWnd(), win32con.GWL_WNDPROC, self._old_wnd_proc)

    def run(self, *args, **kwargs):
        self._add_wnd_proc_hook()
        try:
            self.interact(*args, **kwargs)
        finally:
            self._restore_wnd_proc_hook()


def run_in_thread():
    try:
        win32console.FreeConsole()
        win32console.AllocConsole()
        stderr = sys.stderr
        stdout = sys.stdout
        stdin = sys.stdin
        conin = open("CONIN$", "r")
        conout = open("CONOUT$", "w")
        sys.stdout = sys.stderr = conout
        sys.stdin = conin

        repl = Repl()
        repl.run()

    finally:
        sys.stderr = stderr
        sys.stdout = stdout
        sys.stdin = stdin
        win32console.FreeConsole()


def PyRxCmd_repl():
    try:
        t = threading.Thread(target=run_in_thread)
        t.start()
    except Exception:
        traceback.print_exc()

It seems that the wx.CallAfter function is used for the same purpose, but wx.GetApp() would have to return the same as Ap.Application.wxApp()

[gswifort]

@CEXT-Dan, are you planning to overwrite wx.CallAfter?

[CEXT-Dan]

I’m not familiar with that function, so I guess I have no plans.

[gswifort]

To call a function in the main thread I need to use a unique msg in my_wnd_proc, the system reserves the range to WM_USER (1024) does AutoCAD have a reserved range?

[CEXT-Dan]

There’s no set range for AutoCAD, i.e. WM_ACAD_KEEPFOCUS = 28929
There’s always the possibility of a conflict, here’s some ideas:
https://learn.microsoft.com/en-us/windows/win32/winmsg/wm-user

somewhere in WM_USER through 0x7FFF

[gswifort]

I am uploading a module to test the REPL. The original file is here, but in the attached file I have added all the functions from other pyrx modules. The only additional dependency is ptpython (apart from pywin32). NOTE: after finishing work in the console it is necessary to call the exit() command, closing the console window will immediately close the CAD application.
Two REPLs are implemented:

• STDREPL - based on the REPL from the standard library
• PTREPL - based on ptpython

repl.zip

[CEXT-Dan]

Looks pretty cool! Though, for me I don’t see that ptpython is any better than the wxPython shell, in that it does not see the .PYI stubs

[gswifort]

That's right, unfortunately it doesn't read docstrings from pyi, but type hints do (you have to enable them in the settings - F2). For me, the advantage is that it copes better with syntax hinting (nesting) and can work with other console tools (e.g. output formatting and coloring). I will still work on overwriting docstrings.