Update Multi Script Editor to work with Python 3, Pyside6 and newer Maya, Nuke and Houdini versions

.gitignore

@@ -4,3 +4,6 @@ todo
 tmp
 _backup
 _tmp
+*.pyc
+.history/
+.agents/

license.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Carlos Rico Adega
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

multi_script_editor/__init__.py

@@ -1,37 +1,63 @@
-import os, sys
+import os
+import sys
 
 root = os.path.dirname(__file__)
 if not root in sys.path:
     sys.path.append(root)
 
 
 # HOUDINI
-def showHoudini(clear=False, ontop=False, name=None, floating=False, position=(), size=(),
-                pane=None, replacePyPanel=False, hideTitleMenu=True):
+def showHoudini(*args, **kwargs):
     """
-    This method use hqt module. Download it before
+    Launch Multi Script Editor in Houdini
     """
     from .managers import _houdini
-    reload(_houdini)
-    _houdini.show(clear=clear, ontop=ontop, name=name, floating=floating, position=position,
-                  size=size, pane=pane, replacePyPanel=replacePyPanel, hideTitleMenu=hideTitleMenu)
+    return _houdini.show(*args, **kwargs)
+
 
 # NUKE
 def showNuke(panel=False):
+    """
+    Launch Multi Script Editor in Nuke
+    """
     from .managers import _nuke
-    reload(_nuke)
+
     _nuke.show(panel)
 
 
 # MAYA
 def showMaya(dock=False):
+    """
+    Launch Multi Script Editor in Maya
+    """
     from .managers import _maya
-    reload (_maya)
+
     _maya.show(dock)
 
+
 # 3DSMAX PLUS
 def show3DSMax():
+    """
+    Launch Multi Script Editor in 3DSMax
+    """
     sys.argv = []
     from .managers import _3dsmax
-    reload (_3dsmax)
-    _3dsmax.show()
+
+    _3dsmax.show()
+
+
+def show(*args, **kwargs):
+    from . import managers
+    if managers.context == 'hou':
+        return showHoudini(*args, **kwargs)
+    elif managers.context == 'maya':
+        # Maya's show takes 'dock' kwarg
+        return showMaya(kwargs.get('dock', False))
+    elif managers.context == 'nuke':
+        # Nuke's show takes 'panel' kwarg
+        return showNuke(kwargs.get('panel', False))
+    elif managers.context == 'max':
+        return show3DSMax()
+
+    import scriptEditor
+    scriptEditor.show()

multi_script_editor/core/__init__.py

@@ -0,0 +1 @@
+# Core package for Multi Script Editor

multi_script_editor/core/autocomplete_provider.py

@@ -0,0 +1,102 @@
+import managers
+
+class CompletionItem:
+    def __init__(self, name, complete, comp_type, docstring_val="", prefix_length=0):
+        self.name = name
+        self.complete = complete
+        self.type = comp_type
+        self._docstring = docstring_val
+        self.prefix_length = prefix_length
+
+    def get_completion_prefix_length(self):
+        return self.prefix_length
+
+    def docstring(self):
+        return self._docstring
+
+
+class AutocompleteProvider:
+    def __init__(self):
+        # Lazy load jedi to avoid heavy startup overhead if possible
+        self._jedi = None
+
+    def _get_jedi(self):
+        if self._jedi is None:
+            import jedi
+            self._jedi = jedi
+        return self._jedi
+
+    def get_completions(self, text, line, column, namespace=None, fuzzy=True, context=None):
+        """
+        Returns a list of CompletionItem objects.
+        """
+        comp_items = []
+        context_completer = False
+
+        # 1. Try Context-Specific Completers (e.g., Maya, Nuke specific cmds)
+        if context and context in managers.contextCompleters:
+            current_line_text = text.split('\n')[line - 1] if text else ''
+            # We don't have exact cursor offset here easily, but managers used it roughly
+            # The original code passed `line` string to contextCompleters.
+            comp, extra = managers.contextCompleters[context](current_line_text, namespace)
+            if comp or extra:
+                context_completer = True
+                # Format them as CompletionItem
+                if comp:
+                    for c in comp:
+                        comp_items.append(CompletionItem(c.name, getattr(c, 'complete', ''), getattr(c, 'type', 'statement'), c.docstring() if hasattr(c, 'docstring') else ''))
+                if extra:
+                    for c in extra:
+                        comp_items.append(CompletionItem(c.name, getattr(c, 'complete', ''), getattr(c, 'type', 'statement'), c.docstring() if hasattr(c, 'docstring') else ''))
+
+                if comp_items:
+                    return comp_items
+
+        # 2. Fallback to Jedi Autocompletion
+        if not context_completer:
+            jedi = self._get_jedi()
+
+            # Prepend autoImports if necessary
+            offs = 0
+            if context and context in managers.autoImport:
+                autoImp = managers.autoImport.get(context, '')
+                text = autoImp + text
+                offs = len(autoImp.split('\n')) - 1
+
+            # Shift the line number due to autoImports
+            jedi_line = line + offs
+
+            try:
+                if namespace:
+                    script = jedi.Interpreter(text, namespaces=[namespace])
+                else:
+                    script = jedi.Script(code=text)
+
+                jedi_comps = script.complete(line=jedi_line, column=column, fuzzy=fuzzy)
+
+                for c in jedi_comps:
+                    # Filter out 'mro' as original code did
+                    if c.name == 'mro':
+                        continue
+
+                    doc = ''
+                    try:
+                        doc = c.docstring()
+                    except Exception:
+                        pass
+
+                    prefix_len = 0
+                    if hasattr(c, 'get_completion_prefix_length'):
+                        prefix_len = c.get_completion_prefix_length()
+
+                    comp_items.append(CompletionItem(
+                        name=c.name,
+                        complete=c.complete,
+                        comp_type=c.type,
+                        docstring_val=doc,
+                        prefix_length=prefix_len
+                    ))
+            except Exception:
+                pass
+
+        return comp_items

multi_script_editor/core/base_text_widget.py

@@ -0,0 +1,91 @@
+from vendor.Qt.QtGui import QFont, QTextOption, QFontDatabase
+from vendor.Qt.QtWidgets import QTextEdit
+
+class BaseTextWidgetMixin:
+    """
+    Mixin class that provides common text editing functionalities
+    such as font size manipulation, word wrap, and whitespace rendering.
+    Expects to be mixed into a QTextEdit or QTextBrowser.
+    """
+    def changeFontSize(self, up):
+        f = self.font()
+        size = f.pointSize()
+        if up:
+            size = min(30, size + 1)
+        else:
+            size = max(8, size - 1)
+        f.setPointSize(size)
+        self.setFont(f)
+
+    def setTextEditFontSize(self, size):
+        f = self.font()
+        f.setPointSize(size)
+        self.setFont(f)
+
+    def wordWrap(self, state):
+        if state:
+            self.setLineWrapMode(QTextEdit.WidgetWidth)
+        else:
+            self.setLineWrapMode(QTextEdit.NoWrap)
+
+    def set_font(self, font):
+        self.setFont(font)
+
+    def render_whitespace(self, state):
+        text_option = self.document().defaultTextOption()
+        if state:
+            text_option.setFlags(text_option.flags() | QTextOption.ShowTabsAndSpaces)
+        else:
+            text_option.setFlags(text_option.flags() & ~QTextOption.ShowTabsAndSpaces)
+        self.document().setDefaultTextOption(text_option)
+
+    def set_start_font(self, font_d=None):
+        if not font_d:
+            return
+        family = font_d.get('family', 'monospace')
+        pointSize = font_d.get('pointSize', 14)
+        italic = font_d.get('italic', False)
+        weight = font_d.get('weight', 1)
+
+        # Cross-compatibility patch for PySide2 (NF) vs PySide6 (Nerd Font)
+        try:
+            families = QFontDatabase.families()
+        except TypeError:
+            db = QFontDatabase()
+            families = db.families()
+
+        if family not in families:
+            variations = [
+                family.replace(" NFM", " Nerd Font Mono"),
+                family.replace(" Nerd Font Mono", " NFM"),
+                family.replace(" NFP", " Nerd Font Propo"),
+                family.replace(" Nerd Font Propo", " NFP"),
+                family.replace(" NF", " Nerd Font"),
+                family.replace(" Nerd Font", " NF"),
+                family.replace(" Nerd Font Mono", " Nerd Font"),
+                family.replace(" Nerd Font Propo", " Nerd Font"),
+                family.replace(" Nerd Font", " Nerd Font Mono"),
+                family.replace(" Nerd Font", " Nerd Font Propo")
+            ]
+            for alt in variations:
+                if alt in families:
+                    family = alt
+                    break
+
+        editor_font = QFont(family, pointSize, weight, italic)
+        editor_font.setStyleHint(QFont.Monospace)
+        self.setFont(editor_font)
+
+        if hasattr(self, 'completer') and self.completer:
+            self.completer.setFont(editor_font)
+            if hasattr(self.completer, 'doc_tooltip') and self.completer.doc_tooltip:
+                self.completer.doc_tooltip.setFont(editor_font)
+
+    def contextMenuEvent(self, event):
+        menu = self.createStandardContextMenu()
+        main_win = self.window()
+        if hasattr(main_win, 'menubar'):
+            menu.setFont(main_win.menubar.font())
+            menu.setStyleSheet(main_win.menubar.styleSheet())
+        menu.exec_(event.globalPos())
+        del menu

multi_script_editor/core/execution_manager.py

@@ -0,0 +1,60 @@
+import sys
+import traceback
+from vendor.Qt.QtCore import QCoreApplication
+
+class StdoutProxy:
+    def __init__(self, write_func):
+        self.write_func = write_func
+        self.skip = False
+
+    def write(self, text):
+        if not self.skip:
+            stripped_text = text.rstrip('\n')
+            self.write_func(stripped_text)
+            # Process events so UI doesn't freeze entirely if output is heavy
+            QCoreApplication.processEvents()
+        self.skip = not self.skip
+
+    def flush(self):
+        pass
+
+
+class ExecutionManager:
+    def __init__(self):
+        # We can store execution context or state here
+        pass
+
+    def run_command(self, command, namespace, output_callback, close_callback):
+        """
+        Executes a python command within the given namespace.
+        Output is redirected to output_callback.
+        If a SystemExit is raised, close_callback is called.
+        """
+        if not command:
+            return
+
+        tmp_stdout = sys.stdout
+        sys.stdout = StdoutProxy(output_callback)
+
+        try:
+            try:
+                # Try evaluating first to see if it's an expression that returns a value
+                result = eval(command, namespace, namespace)
+                if result is not None:
+                    output_callback(repr(result))
+            except SyntaxError:
+                # If it's a statement, exec it
+                exec(command, namespace)
+        except SystemExit:
+            close_callback()
+        except:
+            traceback_lines = traceback.format_exc().split('\n')
+            # Remove eval/exec internal traceback lines for cleaner output
+            try:
+                for i in (3, 2, 1, -1):
+                    traceback_lines.pop(i)
+            except IndexError:
+                pass
+            output_callback('\n'.join(traceback_lines))
+        finally:
+            sys.stdout = tmp_stdout

multi_script_editor/core/linter_provider.py

@@ -0,0 +1,15 @@
+class LinterProvider:
+    def check_syntax(self, code):
+        """
+        Validates the python syntax using compile().
+        Returns a dictionary of errors: {line_number: error_message}
+        """
+        syntax_errors = {}
+        if code.strip():
+            try:
+                compile(code.encode('utf-8'), '<string>', 'exec')
+            except SyntaxError as e:
+                syntax_errors[e.lineno] = e.msg
+            except Exception:
+                pass
+        return syntax_errors