more testing of pyside6

changes in pyinstaller>=6.0.0 removed getfullnameof

.github/workflows/pyinstaller-builds-actions-PIP-TAR.yml

@@ -12,31 +12,34 @@ jobs:
   build-linux:
     runs-on: ubuntu-20.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
-    - uses: mamba-org/provision-with-micromamba@main
+    - uses: mamba-org/setup-micromamba@v1
       with:
         #miniconda-version: "latest"
         #auto-update-conda: true
         environment-name: test
         environment-file: environment.yml
-        extra-specs:
+        create-args: >-
-            python=3.9
+            python=3.10
-    - name: Mamba install CadQuery and pyinstaller
+    - name: pip install cadquery CQ-editor ... etc
       shell: bash --login {0}
       run: |
         sudo apt install -y libblas-dev libblas3 libblas64-3 libblas64-dev
         sudo apt install -y libxkbcommon0
         sudo apt install -y libxkbcommon-x11-0
         sudo apt install -y libxcb-xinerama0
+        sudo apt install -y qtbase5-dev qt5-qmake
         micromamba info
+        pip install pyopengl
         pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
-        pip install -vvv --pre git+https://github.com/cadquery/cadquery casadi==3.5.5
+        pip install -vvv --pre git+https://github.com/cadquery/cadquery casadi
-        pip install pyinstaller==4.10
+        pip install pyinstaller>=5.6 git+https://github.com/jdegenstein/pyinstaller-hooks-contrib
         pip install path
+        pip install jupyter-rfb
         pip install git+https://github.com/gumyr/cq_warehouse.git#egg=cq_warehouse
         pip install git+https://github.com/meadiode/cq_gears.git@main
         pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=cq_cache&subdirectory=plugins/cq_cache"
-        pip install git+https://github.com/gumyr/build123d.git#egg=build123d
+        pip install git+https://github.com/gumyr/build123d
         pip install git+https://github.com/JustinSDK/cqMore
         pip list
     - name: Run build
@@ -45,29 +48,29 @@ jobs:
         micromamba info
         pyinstaller pyinstaller_pip.spec ${{ github.event.inputs.type }}
         cp /home/runner/work/jmwright-CQ-Editor/jmwright-CQ-Editor/pyinstaller/CQ-editor.sh /home/runner/work/jmwright-CQ-Editor/jmwright-CQ-Editor/dist/
-    - uses: alehechka/upload-tartifact@v1
+    - uses: alehechka/upload-tartifact@v2
       with:
         name: CQ-editor-Linux-x86_64
         path: dist
   build-macos:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
-    - uses: mamba-org/provision-with-micromamba@main
+    - uses: mamba-org/setup-micromamba@v1
       with:
         #miniconda-version: "latest"
         #auto-update-conda: true
         environment-name: test
         environment-file: environment.yml
-        extra-specs:
+        create-args: >-
-            python=3.9
+            python=3.10
-    - name: Mamba install CadQuery and pyinstaller
+    - name: pip install cadquery CQ-editor ... etc
       shell: bash --login {0}
       run: |
         micromamba info
         pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
-        pip install --pre git+https://github.com/cadquery/cadquery casadi==3.5.5
+        pip install --pre git+https://github.com/cadquery/cadquery casadi
-        pip install pyinstaller==4.10
+        pip install pyinstaller>=5.6 git+https://github.com/jdegenstein/pyinstaller-hooks-contrib
         pip install path
         pip uninstall -y PyQt5
         pip install PyQt5==5.15.7
@@ -75,7 +78,7 @@ jobs:
         pip install git+https://github.com/gumyr/cq_warehouse.git#egg=cq_warehouse
         pip install git+https://github.com/meadiode/cq_gears.git@main
         pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=cq_cache&subdirectory=plugins/cq_cache"
-        pip install git+https://github.com/gumyr/build123d.git#egg=build123d
+        pip install git+https://github.com/gumyr/build123d
         pip install git+https://github.com/JustinSDK/cqMore
         pip list
     - name: Run build
@@ -91,36 +94,38 @@ jobs:
   build-windows:
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
-    - uses: mamba-org/provision-with-micromamba@main
+    - uses: mamba-org/setup-micromamba@v1
       with:
         #miniconda-version: "latest"
         #auto-update-conda: true
         environment-name: test
         environment-file: environment.yml
-        extra-specs:
+        init-shell: >-
-            python=3.9
+            powershell
+        create-args: >-
+            python=3.10
     - name: pip install cadquery CQ-editor ... etc
       shell: powershell
       run: |
         micromamba info
         pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
-        pip install --pre git+https://github.com/cadquery/cadquery casadi==3.5.5
+        pip install --pre git+https://github.com/cadquery/cadquery casadi
-        pip install pyinstaller==4.10
+        pip install pyinstaller>=5.6 git+https://github.com/jdegenstein/pyinstaller-hooks-contrib
         pip install path
         pip install git+https://github.com/gumyr/cq_warehouse.git#egg=cq_warehouse
         pip install git+https://github.com/meadiode/cq_gears.git@main
         pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=cq_cache&subdirectory=plugins/cq_cache"
-        pip install git+https://github.com/gumyr/build123d.git#egg=build123d
+        pip install git+https://github.com/gumyr/build123d
         pip install git+https://github.com/JustinSDK/cqMore
         pip list
     - name: Run build
       shell: powershell
       run: |
         micromamba info
-        pyinstaller --debug all pyinstaller_pip.spec ${{ github.event.inputs.type }}
+        pyinstaller pyinstaller_pip.spec ${{ github.event.inputs.type }}
         Copy-Item D:\a\jmwright-CQ-Editor\jmwright-CQ-Editor\pyinstaller\CQ-editor.cmd D:\a\jmwright-CQ-Editor\jmwright-CQ-Editor\dist\
-    - uses: alehechka/upload-tartifact@v1
+    - uses: alehechka/upload-tartifact@v2
       with:
         name: CQ-editor-Windows
         path: dist

.github/workflows/pyinstaller-builds-actions-build-PIP-TAR-pyinst5-6p.yml

@@ -0,0 +1,126 @@
+name: build-PIP-TAR-pyinst5-6p
+on:
+  # schedule:
+    # - cron: '0 0 * * 1'
+  workflow_dispatch:
+    inputs:
+      type:
+        description: 'Whether to build a single file (onefile) or directory (dir) dist'
+        required: true
+        default: 'dir'
+jobs:
+  # build-linux:
+    # runs-on: ubuntu-20.04
+    # steps:
+    # - uses: actions/checkout@v2
+    # - uses: mamba-org/provision-with-micromamba@main
+      # with:
+        # #miniconda-version: "latest"
+        # #auto-update-conda: true
+        # environment-name: test
+        # environment-file: environment.yml
+        # extra-specs:
+            # python=3.9
+    # - name: Mamba install CadQuery and pyinstaller
+      # shell: bash --login {0}
+      # run: |
+        # sudo apt install -y libblas-dev libblas3 libblas64-3 libblas64-dev
+        # sudo apt install -y libxkbcommon0
+        # sudo apt install -y libxkbcommon-x11-0
+        # sudo apt install -y libxcb-xinerama0
+        # micromamba info
+        # pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
+        # pip install -vvv --pre git+https://github.com/cadquery/cadquery casadi==3.5.5
+        # pip install pyinstaller==4.10
+        # pip install path
+        # pip install git+https://github.com/gumyr/cq_warehouse.git#egg=cq_warehouse
+        # pip install git+https://github.com/meadiode/cq_gears.git@main
+        # pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=cq_cache&subdirectory=plugins/cq_cache"
+        # pip install git+https://github.com/gumyr/build123d.git#egg=build123d
+        # pip install git+https://github.com/JustinSDK/cqMore
+        # pip list
+    # - name: Run build
+      # shell: bash --login {0}
+      # run: |
+        # micromamba info
+        # pyinstaller pyinstaller_pip.spec ${{ github.event.inputs.type }}
+        # cp /home/runner/work/jmwright-CQ-Editor/jmwright-CQ-Editor/pyinstaller/CQ-editor.sh /home/runner/work/jmwright-CQ-Editor/jmwright-CQ-Editor/dist/
+    # - uses: alehechka/upload-tartifact@v1
+      # with:
+        # name: CQ-editor-Linux-x86_64
+        # path: dist
+  # build-macos:
+    # runs-on: macos-latest
+    # steps:
+    # - uses: actions/checkout@v2
+    # - uses: mamba-org/provision-with-micromamba@main
+      # with:
+        # #miniconda-version: "latest"
+        # #auto-update-conda: true
+        # environment-name: test
+        # environment-file: environment.yml
+        # extra-specs:
+            # python=3.9
+    # - name: Mamba install CadQuery and pyinstaller
+      # shell: bash --login {0}
+      # run: |
+        # micromamba info
+        # pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
+        # pip install --pre git+https://github.com/cadquery/cadquery casadi==3.5.5
+        # pip install pyinstaller==4.10
+        # pip install path
+        # pip uninstall -y PyQt5
+        # pip install PyQt5==5.15.7
+        # pip install PyQtWebEngine==5.15.6
+        # pip install git+https://github.com/gumyr/cq_warehouse.git#egg=cq_warehouse
+        # pip install git+https://github.com/meadiode/cq_gears.git@main
+        # pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=cq_cache&subdirectory=plugins/cq_cache"
+        # pip install git+https://github.com/gumyr/build123d.git#egg=build123d
+        # pip install git+https://github.com/JustinSDK/cqMore
+        # pip list
+    # - name: Run build
+      # shell: bash --login {0}
+      # run: |
+        # micromamba info
+        # pyinstaller pyinstaller_pip.spec ${{ github.event.inputs.type }}
+        # cp /Users/runner/work/jmwright-CQ-Editor/jmwright-CQ-Editor/pyinstaller/CQ-editor.sh /Users/runner/work/jmwright-CQ-Editor/jmwright-CQ-Editor/dist/
+    # - uses: alehechka/upload-tartifact@v1
+      # with:
+        # name: CQ-editor-MacOS
+        # path: dist
+  build-windows:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: mamba-org/provision-with-micromamba@main
+      with:
+        #miniconda-version: "latest"
+        #auto-update-conda: true
+        environment-name: test
+        environment-file: environment.yml
+        extra-specs:
+            python=3.9
+    - name: pip install cadquery CQ-editor ... etc
+      shell: powershell
+      run: |
+        micromamba info
+        pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
+        pip install --pre git+https://github.com/cadquery/cadquery casadi==3.5.5
+        pip install pyinstaller>=5.6
+        pip install path
+        pip install git+https://github.com/gumyr/cq_warehouse.git#egg=cq_warehouse
+        pip install git+https://github.com/meadiode/cq_gears.git@main
+        pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=cq_cache&subdirectory=plugins/cq_cache"
+        pip install git+https://github.com/gumyr/build123d
+        pip install git+https://github.com/JustinSDK/cqMore
+        pip list
+    - name: Run build
+      shell: powershell
+      run: |
+        micromamba info
+        pyinstaller pyinstaller_pip.spec ${{ github.event.inputs.type }}
+        Copy-Item D:\a\jmwright-CQ-Editor\jmwright-CQ-Editor\pyinstaller\CQ-editor.cmd D:\a\jmwright-CQ-Editor\jmwright-CQ-Editor\dist\
+    - uses: alehechka/upload-tartifact@v1
+      with:
+        name: CQ-editor-Windows
+        path: dist

README.md

@@ -4,6 +4,8 @@ This is a fork of [jmwright's fork](https://github.com/jmwright/CQ-editor) of [C
 
 This fork also contains additional changes to the `show_object` function in CQ-editor that make it easier to display and export build123d objects and object lists.
 
+Running into issues? Please click here to join the [***CadQuery, CQ-Editor, and build123d Discord***](https://discord.com/invite/Bj9AQPsCfx)
+
 ![image](https://user-images.githubusercontent.com/16868537/191054760-a2cac297-3488-48d4-b9f6-52747dffcce3.png)
 
 [![Build status](https://ci.appveyor.com/api/projects/status/g98rs7la393mgy91/branch/master?svg=true)](https://ci.appveyor.com/project/adam-urbanczyk/cq-editor/branch/master)
@@ -33,7 +35,7 @@ CadQuery GUI editor based on PyQT supports Linux, Windows and Mac.
 
 ### Release Packages
 
-TBD
+Stable release builds which do not require Anaconda are attached to the [latest release](https://github.com/jdegenstein/jmwright-CQ-editor/releases). Download the zip file for your operating system, extract it, and run the CQ-editor script for your OS (CQ-editor.cmd for Windows, CQ-editor.sh for Linux and MacOS). On Windows you should be able to simply double-click on CQ-editor.cmd. On Linux and MacOS you may need to make the script executable with `chmod +x CQ-editor.sh` and run the script from the command line. On later MacOS versions you may also need `xattr -r -d com.apple.quarantine path/to/CQ-editor-MacOS`.  The script contains an environment variable export that may be required to get CQ-editor to launch correctly on MacOS Big Sur, so it is better to use the script than to launch CQ-editor directly.
 
 ### Development Packages
 
@@ -41,19 +43,27 @@ Development builds are also available, but can be unstable and should be used at
 
 ## Installation (pip)
 
+Additional packages for Linux (known as needed on Ubuntu 22.04):
+```
+sudo apt install qtbase5-dev qt5-qmake
+```
+All platforms (Windows/Mac/Linux):
 ```
 pip install git+https://github.com/jdegenstein/jmwright-CQ-Editor
-pip install --pre git+https://github.com/cadquery/cadquery
+pip install --pre "cadquery>=2.2"
+pip install git+https://github.com/gumyr/build123d
 ```
 
 ## Usage
 
 ### Showing Objects
 
-By default, CQ-editor will display a 3D representation of all `Workplane` objects in a script with a default color and alpha (transparency). To have more control over what is shown, and what the color and alpha settings are, the `show_object` method can be used. `show_object` tells CQ-editor to explicity display an object, and accepts the `options` parameter. The `options` parameter is a dictionary of rendering options named `alpha` and `color`. `alpha` is scaled between 0.0 and 1.0, with 0.0 being completely opaque and 1.0 being completely transparent. The color is set using R (red), G (green) and B (blue) values, and each one is scaled from 0 to 255. Either option or both can be omitted.
+By default, CQ-editor will display a 3D representation of all `Workplane` objects in a script with a default color and alpha (transparency). To have more control over what is shown, and what the color and alpha settings are, the `show_object` method can be used. `show_object` tells CQ-editor to explicity display an object, and accepts the `options` parameter. The `options` parameter is a dictionary of rendering options named `alpha` and `color`. `alpha` is scaled between 0.0 and 1.0, with 0.0 being completely opaque and 1.0 being completely transparent. The color is set using R (red), G (green) and B (blue) values, and each one is scaled from 0 to 255. Either option or both can be omitted. The `name` parameter can assign a custom name which will appear in the objects pane of CQ-editor.
 
 ```python
-show_object(result, options={"alpha":0.5, "color": (64, 164, 223)})
+show_object(result, name="somename", options={"alpha":0.5, "color": (64, 164, 223)})
+# or using rand_color:
+show_object(result, name="somename", options=rand_color(alpha=.5))
 ```
 
 Note that `show_object` works for `Shape` and `TopoDS_Shape` objects too. In order to display objects from the embedded Python console use `show`.

cq_editor/__main__.py

@@ -1,7 +1,7 @@
 import sys
 import argparse
 
-from PyQt5.QtWidgets import QApplication
+from PySide6.QtWidgets import QApplication
 
 NAME = 'CQ-editor'
 

cq_editor/cq_utils.py

@@ -15,7 +15,7 @@ from OCP.Quantity import (
 )
 from OCP.Graphic3d import Graphic3d_NOM_JADE, Graphic3d_MaterialAspect
 
-from PyQt5.QtGui import QColor
+from PySide6.QtGui import QColor
 
 DEFAULT_FACE_COLOR = Quantity_Color(GOLD)
 DEFAULT_MATERIAL = Graphic3d_MaterialAspect(Graphic3d_NOM_JADE)

cq_editor/editor.py

@@ -3,9 +3,9 @@ import spyder.utils.encoding
 from modulefinder import ModuleFinder
 
 from spyder.plugins.editor.widgets.codeeditor import CodeEditor
-from PyQt5.QtCore import pyqtSignal, QFileSystemWatcher, QTimer
+from PySide6.QtCore import Signal as pyqtSignal, QFileSystemWatcher, QTimer
-from PyQt5.QtWidgets import QAction, QFileDialog
+from PySide6.QtWidgets import QAction, QFileDialog
-from PyQt5.QtGui import QFontDatabase
+from PySide6.QtGui import QFontDatabase
 from path import Path
 
 import sys
@@ -17,91 +17,104 @@ from ..utils import get_save_filename, get_open_filename, confirm
 
 from ..icons import icon
 
-class Editor(CodeEditor,ComponentMixin):
 
-    name = 'Code Editor'
+class Editor(CodeEditor, ComponentMixin):
+    name = "Code Editor"
 
     # This signal is emitted whenever the currently-open file changes and
     # autoreload is enabled.
     triggerRerender = pyqtSignal(bool)
     sigFilenameChanged = pyqtSignal(str)
 
-    preferences = Parameter.create(name='Preferences',children=[
+    preferences = Parameter.create(
-        {'name': 'Font size', 'type': 'int', 'value': 12},
+        name="Preferences",
-        {'name': 'Autoreload', 'type': 'bool', 'value': False},
+        children=[
-        {'name': 'Autoreload delay', 'type': 'int', 'value': 50},
+            {"name": "Font size", "type": "int", "value": 12},
-        {'name': 'Autoreload: watch imported modules', 'type': 'bool', 'value': False},
+            {"name": "Autoreload", "type": "bool", "value": False},
-        {'name': 'Line wrap', 'type': 'bool', 'value': False},
+            {"name": "Autoreload delay", "type": "int", "value": 50},
-        {'name': 'Color scheme', 'type': 'list',
+            {
-         'values': ['Spyder','Monokai','Zenburn'], 'value': 'Spyder'}])
+                "name": "Autoreload: watch imported modules",
+                "type": "bool",
+                "value": False,
+            },
+            {"name": "Line wrap", "type": "bool", "value": False},
+            {
+                "name": "Color scheme",
+                "type": "list",
+                "values": ["Spyder", "Monokai", "Zenburn"],
+                "value": "Spyder",
+            },
+        ],
+    )
 
-    EXTENSIONS = 'py'
+    EXTENSIONS = "py"
 
     def __init__(self, parent=None):
-
         self._watched_file = None
 
         super(Editor, self).__init__(parent)
         ComponentMixin.__init__(self)
 
-        self.setup_editor(linenumbers=True,
+        self.setup_editor(
+            linenumbers=True,
             markers=True,
             edge_line=False,
             tab_mode=False,
             show_blanks=True,
             font=QFontDatabase.systemFont(QFontDatabase.FixedFont),
-                          language='Python',
+            language="Python",
-                          filename='')
+            filename="",
+        )
 
-        self._actions =  \
+        self._actions = {
-                {'File' : [QAction(icon('new'),
+            "File": [
-                                  'New',
+                QAction(
+                    icon("new"), "New", self, shortcut="ctrl+N", triggered=self.new
+                ),
+                QAction(
+                    icon("open"), "Open", self, shortcut="ctrl+O", triggered=self.open
+                ),
+                QAction(
+                    icon("save"), "Save", self, shortcut="ctrl+S", triggered=self.save
+                ),
+                QAction(
+                    icon("save_as"),
+                    "Save as",
                     self,
-                                  shortcut='ctrl+N',
+                    shortcut="ctrl+shift+S",
-                                  triggered=self.new),
+                    triggered=self.save_as,
-                          QAction(icon('open'),
+                ),
-                                  'Open',
+                QAction(
+                    icon("autoreload"),
+                    "Automatic reload and preview",
                     self,
-                                  shortcut='ctrl+O',
+                    triggered=self.autoreload,
-                                  triggered=self.open),
-                          QAction(icon('save'),
-                                  'Save',
-                                  self,
-                                  shortcut='ctrl+S',
-                                  triggered=self.save),
-                          QAction(icon('save_as'),
-                                  'Save as',
-                                  self,
-                                  shortcut='ctrl+shift+S',
-                                  triggered=self.save_as),
-                          QAction(icon('autoreload'),
-                                  'Automatic reload and preview',
-                                  self,triggered=self.autoreload,
                     checkable=True,
                     checked=False,
-                                  objectName='autoreload'),
+                    objectName="autoreload",
-                          ]}
+                ),
+            ]
+        }
 
         for a in self._actions.values():
             self.addActions(a)
 
-
         self._fixContextMenu()
 
         # autoreload support
         self._file_watcher = QFileSystemWatcher(self)
         # we wait for 50ms after a file change for the file to be written completely
         self._file_watch_timer = QTimer(self)
-        self._file_watch_timer.setInterval(self.preferences['Autoreload delay'])
+        self._file_watch_timer.setInterval(self.preferences["Autoreload delay"])
         self._file_watch_timer.setSingleShot(True)
         self._file_watcher.fileChanged.connect(
-                lambda val: self._file_watch_timer.start())
+            lambda val: self._file_watch_timer.start()
+        )
         self._file_watch_timer.timeout.connect(self._file_changed)
 
         self.updatePreferences()
 
     def _fixContextMenu(self):
-
         menu = self.menu
 
         menu.removeAction(self.run_cell_action)
@@ -110,51 +123,51 @@ class Editor(CodeEditor,ComponentMixin):
         menu.removeAction(self.re_run_last_cell_action)
 
     def updatePreferences(self, *args):
-
+        self.set_color_scheme(self.preferences["Color scheme"])
-        self.set_color_scheme(self.preferences['Color scheme'])
 
         font = self.font()
-        font.setPointSize(self.preferences['Font size'])
+        font.setPointSize(self.preferences["Font size"])
         self.set_font(font)
 
-        self.findChild(QAction, 'autoreload') \
+        self.findChild(QAction, "autoreload").setChecked(self.preferences["Autoreload"])
-            .setChecked(self.preferences['Autoreload'])
 
-        self._file_watch_timer.setInterval(self.preferences['Autoreload delay'])
+        self._file_watch_timer.setInterval(self.preferences["Autoreload delay"])
 
-        self.toggle_wrap_mode(self.preferences['Line wrap'])
+        self.toggle_wrap_mode(self.preferences["Line wrap"])
 
         self._clear_watched_paths()
         self._watch_paths()
 
     def confirm_discard(self):
-
         if self.modified:
-            rv =  confirm(self,'Please confirm','Current document is not saved - do you want to continue?')
+            rv = confirm(
+                self,
+                "Please confirm",
+                "Current document is not saved - do you want to continue?",
+            )
         else:
             rv = True
 
         return rv
 
     def new(self):
+        if not self.confirm_discard():
+            return
 
-        if not self.confirm_discard(): return
+        self.set_text("")
-
+        self.filename = ""
-        self.set_text('')
-        self.filename = ''
         self.reset_modified()
 
     def open(self):
-        
+        if not self.confirm_discard():
-        if not self.confirm_discard(): return
+            return
 
         curr_dir = Path(self.filename).abspath().dirname()
         fname = get_open_filename(self.EXTENSIONS, curr_dir)
-        if fname != '':
+        if fname != "":
             self.load_from_file(fname)
 
     def load_from_file(self, fname):
-
         self.set_text_from_file(fname)
         self.filename = fname
         self.reset_modified()
@@ -164,24 +177,22 @@ class Editor(CodeEditor,ComponentMixin):
             # this function returns the encoding spyder used to read the file
             _, encoding = spyder.utils.encoding.read(fname)
             # spyder returns a -guessed suffix in some cases
-            return encoding.replace('-guessed', '')
+            return encoding.replace("-guessed", "")
         else:
-            return 'utf-8'
+            return "utf-8"
 
     def save(self):
-
+        if self._filename != "":
-        if self._filename != '':
+            if self.preferences["Autoreload"]:
-
-            if self.preferences['Autoreload']:
                 self._file_watcher.blockSignals(True)
                 self._file_watch_timer.stop()
 
             encoding = self.determine_encoding(self._filename)
             encoded = self.toPlainText().encode(encoding)
-            with open(self._filename, 'wb') as f:
+            with open(self._filename, "wb") as f:
                 f.write(encoded)
 
-            if self.preferences['Autoreload']:
+            if self.preferences["Autoreload"]:
                 self._file_watcher.blockSignals(False)
                 self.triggerRerender.emit(True)
 
@@ -191,21 +202,26 @@ class Editor(CodeEditor,ComponentMixin):
             self.save_as()
 
     def save_as(self):
-
         fname = get_save_filename(self.EXTENSIONS)
-        if fname != '':
+        if fname != "":
-            encoded = self.toPlainText().encode('utf-8')
+            encoded = self.toPlainText().encode("utf-8")
-            with open(fname, 'wb') as f:
+            with open(fname, "wb") as f:
                 f.write(encoded)
                 self.filename = fname
 
             self.reset_modified()
 
     def _update_filewatcher(self):
-        if self._watched_file and (self._watched_file != self.filename or not self.preferences['Autoreload']):
+        if self._watched_file and (
+            self._watched_file != self.filename or not self.preferences["Autoreload"]
+        ):
             self._clear_watched_paths()
             self._watched_file = None
-        if self.preferences['Autoreload'] and self.filename and self.filename != self._watched_file:
+        if (
+            self.preferences["Autoreload"]
+            and self.filename
+            and self.filename != self._watched_file
+        ):
             self._watched_file = self._filename
             self._watch_paths()
 
@@ -227,7 +243,7 @@ class Editor(CodeEditor,ComponentMixin):
     def _watch_paths(self):
         if Path(self._filename).exists():
             self._file_watcher.addPath(self._filename)
-            if self.preferences['Autoreload: watch imported modules']:
+            if self.preferences["Autoreload: watch imported modules"]:
                 module_paths = self.get_imported_module_paths(self._filename)
                 if module_paths:
                     self._file_watcher.addPaths(module_paths)
@@ -241,51 +257,45 @@ class Editor(CodeEditor,ComponentMixin):
 
     # Turn autoreload on/off.
     def autoreload(self, enabled):
-        self.preferences['Autoreload'] = enabled
+        self.preferences["Autoreload"] = enabled
         self._update_filewatcher()
 
     def reset_modified(self):
-
         self.document().setModified(False)
 
     @property
     def modified(self):
-        
         return self.document().isModified()
 
     def saveComponentState(self, store):
-
+        if self.filename != "":
-        if self.filename != '':
+            store.setValue(self.name + "/state", self.filename)
-            store.setValue(self.name+'/state',self.filename)
 
     def restoreComponentState(self, store):
+        filename = store.value(self.name + "/state")
 
-        filename = store.value(self.name+'/state')
+        if filename and self.filename == "":
-
-        if filename and self.filename == '':
             try:
                 self.load_from_file(filename)
             except IOError:
-                self._logger.warning(f'could not open {filename}')
+                self._logger.warning(f"could not open {filename}")
-
 
     def get_imported_module_paths(self, module_path):
-
         finder = ModuleFinder([os.path.dirname(module_path)])
         imported_modules = []
 
         try:
             finder.run_script(module_path)
         except SyntaxError as err:
-            self._logger.warning(f'Syntax error in {module_path}: {err}')
+            self._logger.warning(f"Syntax error in {module_path}: {err}")
         except Exception as err:
             self._logger.warning(
-                f'Cannot determine imported modules in {module_path}: {type(err).__name__} {err}'
+                f"Cannot determine imported modules in {module_path}: {type(err).__name__} {err}"
             )
         else:
             for module_name, module in finder.modules.items():
-                if module_name != '__main__':
+                if module_name != "__main__":
-                    path = getattr(module, '__file__', None)
+                    path = getattr(module, "__file__", None)
                     if path is not None and os.path.isfile(path):
                         imported_modules.append(path)
 
@@ -293,8 +303,7 @@ class Editor(CodeEditor,ComponentMixin):
 
 
 if __name__ == "__main__":
-
+    from PySide6.QtWidgets import QApplication
-    from PyQt5.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
     editor = Editor()

cq_editor/icons.py

@@ -6,7 +6,7 @@ Created on Fri May 25 14:47:10 2018
 @author: adam
 """
 
-from PyQt5.QtGui import QIcon
+from PySide6.QtGui import QIcon
 
 from . import icons_res
 _icons = {

cq_editor/icons_res.py

@@ -6,7 +6,7 @@
 #
 # WARNING! All changes made in this file will be lost!
 
-from PyQt5 import QtCore
+from PySide6 import QtCore
 
 qt_resource_data = b"\
 \x00\x00\x4e\x4c\

cq_editor/main_window.py

@@ -1,6 +1,8 @@
 import sys
 
-from PyQt5.QtWidgets import (QLabel, QMainWindow, QToolBar, QDockWidget, QAction)
+from PySide6.QtWidgets import QLabel, QMainWindow, QToolBar, QDockWidget
+from PySide6.QtGui import QAction
+from PySide6.QtCore import Signal as pyqtSignal
 from logbook import Logger
 import cadquery as cq
 
@@ -14,15 +16,25 @@ from .widgets.cq_object_inspector import CQObjectInspector
 from .widgets.log import LogViewer
 
 from . import __version__
-from .utils import dock, add_actions, open_url, about_dialog, check_gtihub_for_updates, confirm
+from .utils import (
+    dock,
+    add_actions,
+    open_url,
+    about_dialog,
+    check_gtihub_for_updates,
+    confirm,
+)
 from .mixins import MainMixin
 from .icons import icon
 from .preferences import PreferencesWidget
 
 # DARKMODE edits: https://stackoverflow.com/questions/48256772/dark-theme-for-qt-widgets
-from PyQt5.QtCore import Qt
+from PySide6.QtCore import Qt
-from PyQt5.QtWidgets import QApplication
+from PySide6.QtWidgets import QApplication
-from PyQt5.QtGui import QPalette, QColor
+from PySide6.QtGui import QPalette, QColor
+
+app = QApplication.instance()
+if app == None:
     app = QApplication([])
 # Force the style to be the same on all OSs:
 app.setStyle("Fusion")
@@ -43,54 +55,51 @@ palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
 palette.setColor(QPalette.HighlightedText, Qt.black)
 app.setPalette(palette)
 
-class MainWindow(QMainWindow,MainMixin):
 
-    name = 'CQ-Editor'
+class MainWindow(QMainWindow, MainMixin):
-    org = 'CadQuery'
+    name = "CQ-Editor"
+    org = "CadQuery"
 
     def __init__(self, parent=None, filename=None):
-
         super(MainWindow, self).__init__(parent)
         MainMixin.__init__(self)
 
-        self.setWindowIcon(icon('app'))
+        self.setWindowIcon(icon("app"))
 
         self.viewer = OCCViewer(self)
-        self.setCentralWidget(self.viewer.canvas)
+        # self.setCentralWidget(self.viewer.canvas)
 
-        self.prepare_panes()
+        # self.prepare_panes()
-        self.registerComponent('viewer',self.viewer)
+        # self.registerComponent("viewer", self.viewer)
-        self.prepare_toolbar()
+        # self.prepare_toolbar()
-        self.prepare_menubar()
+        # self.prepare_menubar()
 
-        self.prepare_statusbar()
+        # self.prepare_statusbar()
-        self.prepare_actions()
+        # self.prepare_actions()
 
-        self.components['object_tree'].addLines()
+        # self.components["object_tree"].addLines()
 
-        self.prepare_console()
+        # self.prepare_console()
 
-        self.fill_dummy()
+        # self.fill_dummy()
 
-        self.setup_logging()
+        # self.setup_logging()
 
-        self.restorePreferences()
+        # self.restorePreferences()
-        self.restoreWindow()
+        # self.restoreWindow()
 
-        if filename:
+        # if filename:
-            self.components['editor'].load_from_file(filename)
+        #    self.components["editor"].load_from_file(filename)
 
-        self.restoreComponentState()
+        # self.restoreComponentState()
 
     def closeEvent(self, event):
-
         self.saveWindow()
         self.savePreferences()
         self.saveComponentState()
 
-        if self.components['editor'].document().isModified():
+        if self.components["editor"].document().isModified():
-
+            rv = confirm(self, "Confirm close", "Close without saving?")
-            rv = confirm(self, 'Confirm close', 'Close without saving?')
 
             if rv:
                 event.accept()
@@ -101,81 +110,74 @@ class MainWindow(QMainWindow,MainMixin):
             super(MainWindow, self).closeEvent(event)
 
     def prepare_panes(self):
-
+        self.registerComponent(
-        self.registerComponent('editor',
+            "editor",
             Editor(self),
-                               lambda c : dock(c,
+            lambda c: dock(c, "Editor", self, defaultArea="left"),
-                                               'Editor',
+        )
-                                               self,
-                                               defaultArea='left'))
 
-        self.registerComponent('object_tree',
+        self.registerComponent(
+            "object_tree",
             ObjectTree(self),
-                               lambda c: dock(c,
+            lambda c: dock(c, "Objects", self, defaultArea="right"),
-                                              'Objects',
+        )
-                                              self,
-                                              defaultArea='right'))
 
-        self.registerComponent('console',
+        self.registerComponent(
+            "console",
             ConsoleWidget(self),
-                               lambda c: dock(c,
+            lambda c: dock(c, "Console", self, defaultArea="bottom"),
-                                              'Console',
+        )
-                                              self,
-                                              defaultArea='bottom'))
 
-        self.registerComponent('traceback_viewer',
+        self.registerComponent(
+            "traceback_viewer",
             TracebackPane(self),
-                               lambda c: dock(c,
+            lambda c: dock(c, "Current traceback", self, defaultArea="bottom"),
-                                              'Current traceback',
+        )
-                                              self,
-                                              defaultArea='bottom'))
 
-        self.registerComponent('debugger',Debugger(self))
+        self.registerComponent("debugger", Debugger(self))
 
-        self.registerComponent('variables_viewer',LocalsView(self),
+        self.registerComponent(
-                               lambda c: dock(c,
+            "variables_viewer",
-                                              'Variables',
+            LocalsView(self),
-                                              self,
+            lambda c: dock(c, "Variables", self, defaultArea="right"),
-                                              defaultArea='right'))
+        )
 
-        self.registerComponent('cq_object_inspector',
+        self.registerComponent(
+            "cq_object_inspector",
             CQObjectInspector(self),
-                               lambda c: dock(c,
+            lambda c: dock(c, "CQ object inspector", self, defaultArea="right"),
-                                              'CQ object inspector',
+        )
-                                              self,
+        self.registerComponent(
-                                              defaultArea='right'))
+            "log",
-        self.registerComponent('log',
             LogViewer(self),
-                               lambda c: dock(c,
+            lambda c: dock(c, "Log viewer", self, defaultArea="bottom"),
-                                              'Log viewer',
+        )
-                                              self,
-                                              defaultArea='bottom'))
 
         for d in self.docks.values():
             d.show()
 
     def prepare_menubar(self):
-
         menu = self.menuBar()
 
-        menu_file = menu.addMenu('&File')
+        menu_file = menu.addMenu("&File")
-        menu_edit = menu.addMenu('&Edit')
+        menu_edit = menu.addMenu("&Edit")
-        menu_tools = menu.addMenu('&Tools')
+        menu_tools = menu.addMenu("&Tools")
-        menu_run = menu.addMenu('&Run')
+        menu_run = menu.addMenu("&Run")
-        menu_view = menu.addMenu('&View')
+        menu_view = menu.addMenu("&View")
-        menu_help = menu.addMenu('&Help')
+        menu_help = menu.addMenu("&Help")
 
         # per component menu elements
-        menus = {'File' : menu_file,
+        menus = {
-                 'Edit' : menu_edit,
+            "File": menu_file,
-                 'Run'  : menu_run,
+            "Edit": menu_edit,
-                 'Tools': menu_tools,
+            "Run": menu_run,
-                 'View' : menu_view,
+            "Tools": menu_tools,
-                 'Help' : menu_help}
+            "View": menu_view,
+            "Help": menu_help,
+        }
 
         for comp in self.components.values():
-            self.prepare_menubar_component(menus,
+            self.prepare_menubar_component(menus, comp.menuActions())
-                                            comp.menuActions())
 
         # global menu elements
         menu_view.addSeparator()
@@ -186,37 +188,37 @@ class MainWindow(QMainWindow,MainMixin):
         for t in self.findChildren(QToolBar):
             menu_view.addAction(t.toggleViewAction())
 
-        menu_edit.addAction( \
+        menu_edit.addAction(
-            QAction(icon('preferences'),
+            QAction(
-                    'Preferences',
+                icon("preferences"),
-                    self,triggered=self.edit_preferences))
+                "Preferences",
+                self,
+                triggered=self.edit_preferences,
+            )
+        )
 
-        menu_help.addAction( \
+        menu_help.addAction(
-            QAction(icon('help'),
+            QAction(icon("help"), "Documentation", self, triggered=self.documentation)
-                    'Documentation',
+        )
-                    self,triggered=self.documentation))
 
-        menu_help.addAction( \
+        menu_help.addAction(
-             QAction('CQ documentation',
+            QAction("CQ documentation", self, triggered=self.cq_documentation)
-                    self,triggered=self.cq_documentation))
+        )
 
-        menu_help.addAction( \
+        menu_help.addAction(QAction(icon("about"), "About", self, triggered=self.about))
-            QAction(icon('about'),
-                    'About',
-                    self,triggered=self.about))
 
-        menu_help.addAction( \
+        menu_help.addAction(
-            QAction('Check for CadQuery updates',
+            QAction(
-                    self,triggered=self.check_for_cq_updates))
+                "Check for CadQuery updates", self, triggered=self.check_for_cq_updates
+            )
+        )
 
     def prepare_menubar_component(self, menus, comp_menu_dict):
-
         for name, action in comp_menu_dict.items():
             menus[name].addActions(action)
 
     def prepare_toolbar(self):
-
+        self.toolbar = QToolBar("Main toolbar", self, objectName="Main toolbar")
-        self.toolbar = QToolBar('Main toolbar',self,objectName='Main toolbar')
 
         for c in self.components.values():
             add_actions(self.toolbar, c.toolbarActions())
@@ -224,143 +226,162 @@ class MainWindow(QMainWindow,MainMixin):
         self.addToolBar(self.toolbar)
 
     def prepare_statusbar(self):
-
+        self.status_label = QLabel("", parent=self)
-        self.status_label = QLabel('',parent=self)
         self.statusBar().insertPermanentWidget(0, self.status_label)
 
     def prepare_actions(self):
+        self.components["debugger"].sigRendered.connect(
+            self.components["object_tree"].addObjects
+        )
+        self.components["debugger"].sigTraceback.connect(
+            self.components["traceback_viewer"].addTraceback
+        )
+        self.components["debugger"].sigLocals.connect(
+            self.components["variables_viewer"].update_frame
+        )
+        self.components["debugger"].sigLocals.connect(
+            self.components["console"].push_vars
+        )
 
-        self.components['debugger'].sigRendered\
+        self.components["object_tree"].sigObjectsAdded[list].connect(
-            .connect(self.components['object_tree'].addObjects)
+            self.components["viewer"].display_many
-        self.components['debugger'].sigTraceback\
+        )
-            .connect(self.components['traceback_viewer'].addTraceback)
+        self.components["object_tree"].sigObjectsAdded2[list, bool].connect(
-        self.components['debugger'].sigLocals\
+            self.components["viewer"].display_many
-            .connect(self.components['variables_viewer'].update_frame)
+        )
-        self.components['debugger'].sigLocals\
+        self.components["object_tree"].sigItemChanged.connect(
-            .connect(self.components['console'].push_vars)
+            self.components["viewer"].update_item
+        )
+        self.components["object_tree"].sigObjectsRemoved.connect(
+            self.components["viewer"].remove_items
+        )
+        self.components["object_tree"].sigCQObjectSelected.connect(
+            self.components["cq_object_inspector"].setObject
+        )
+        self.components["object_tree"].sigObjectPropertiesChanged.connect(
+            self.components["viewer"].redraw
+        )
+        self.components["object_tree"].sigAISObjectsSelected.connect(
+            self.components["viewer"].set_selected
+        )
 
-        self.components['object_tree'].sigObjectsAdded[list]\
+        self.components["viewer"].sigObjectSelected.connect(
-            .connect(self.components['viewer'].display_many)
+            self.components["object_tree"].handleGraphicalSelection
-        self.components['object_tree'].sigObjectsAdded[list,bool]\
+        )
-            .connect(self.components['viewer'].display_many)
-        self.components['object_tree'].sigItemChanged.\
-            connect(self.components['viewer'].update_item)
-        self.components['object_tree'].sigObjectsRemoved\
-            .connect(self.components['viewer'].remove_items)
-        self.components['object_tree'].sigCQObjectSelected\
-            .connect(self.components['cq_object_inspector'].setObject)
-        self.components['object_tree'].sigObjectPropertiesChanged\
-            .connect(self.components['viewer'].redraw)
-        self.components['object_tree'].sigAISObjectsSelected\
-            .connect(self.components['viewer'].set_selected)
 
-        self.components['viewer'].sigObjectSelected\
+        self.components["traceback_viewer"].sigHighlightLine.connect(
-            .connect(self.components['object_tree'].handleGraphicalSelection)
+            self.components["editor"].go_to_line
+        )
 
-        self.components['traceback_viewer'].sigHighlightLine\
+        self.components["cq_object_inspector"].sigDisplayObjects.connect(
-            .connect(self.components['editor'].go_to_line)
+            self.components["viewer"].display_many
+        )
+        self.components["cq_object_inspector"].sigRemoveObjects.connect(
+            self.components["viewer"].remove_items
+        )
+        self.components["cq_object_inspector"].sigShowPlane.connect(
+            self.components["viewer"].toggle_grid
+        )
+        self.components["cq_object_inspector"].sigShowPlane2[bool, float].connect(
+            self.components["viewer"].toggle_grid
+        )
+        self.components["cq_object_inspector"].sigChangePlane.connect(
+            self.components["viewer"].set_grid_orientation
+        )
 
-        self.components['cq_object_inspector'].sigDisplayObjects\
+        self.components["debugger"].sigLocalsChanged.connect(
-            .connect(self.components['viewer'].display_many)
+            self.components["variables_viewer"].update_frame
-        self.components['cq_object_inspector'].sigRemoveObjects\
+        )
-            .connect(self.components['viewer'].remove_items)
+        self.components["debugger"].sigLineChanged.connect(
-        self.components['cq_object_inspector'].sigShowPlane\
+            self.components["editor"].go_to_line
-            .connect(self.components['viewer'].toggle_grid)
+        )
-        self.components['cq_object_inspector'].sigShowPlane[bool,float]\
+        self.components["debugger"].sigDebugging.connect(
-            .connect(self.components['viewer'].toggle_grid)
+            self.components["object_tree"].stashObjects
-        self.components['cq_object_inspector'].sigChangePlane\
+        )
-            .connect(self.components['viewer'].set_grid_orientation)
+        self.components["debugger"].sigCQChanged.connect(
-
+            self.components["object_tree"].addObjects
-        self.components['debugger'].sigLocalsChanged\
+        )
-            .connect(self.components['variables_viewer'].update_frame)
+        self.components["debugger"].sigTraceback.connect(
-        self.components['debugger'].sigLineChanged\
+            self.components["traceback_viewer"].addTraceback
-            .connect(self.components['editor'].go_to_line)
+        )
-        self.components['debugger'].sigDebugging\
-            .connect(self.components['object_tree'].stashObjects)
-        self.components['debugger'].sigCQChanged\
-            .connect(self.components['object_tree'].addObjects)
-        self.components['debugger'].sigTraceback\
-            .connect(self.components['traceback_viewer'].addTraceback)
 
         # trigger re-render when file is modified externally or saved
-        self.components['editor'].triggerRerender \
+        self.components["editor"].triggerRerender.connect(
-            .connect(self.components['debugger'].render)
+            self.components["debugger"].render
-        self.components['editor'].sigFilenameChanged\
+        )
-            .connect(self.handle_filename_change)
+        self.components["editor"].sigFilenameChanged.connect(
+            self.handle_filename_change
+        )
 
     def prepare_console(self):
-
+        console = self.components["console"]
-        console = self.components['console']
+        obj_tree = self.components["object_tree"]
-        obj_tree = self.components['object_tree']
 
         # application related items
-        console.push_vars({'self' : self})
+        console.push_vars({"self": self})
 
         # CQ related items
-        console.push_vars({'show' : obj_tree.addObject,
+        console.push_vars(
-                           'show_object' : obj_tree.addObject,
+            {
-                           'rand_color' : self.components['debugger']._rand_color,
+                "show": obj_tree.addObject,
-                           'cq' : cq,
+                "show_object": obj_tree.addObject,
-                           'log' : Logger(self.name).info})
+                "rand_color": self.components["debugger"]._rand_color,
+                "cq": cq,
+                "log": Logger(self.name).info,
+            }
+        )
 
     def fill_dummy(self):
-
+        self.components["editor"].set_text(
-        self.components['editor']\
+            'import cadquery as cq\nresult = cq.Workplane("XY" ).box(3, 3, 0.5).edges("|Z").fillet(0.125)'
-            .set_text('import cadquery as cq\nresult = cq.Workplane("XY" ).box(3, 3, 0.5).edges("|Z").fillet(0.125)')
+        )
 
     def setup_logging(self):
-
         from logbook.compat import redirect_logging
         from logbook import INFO, Logger
 
         redirect_logging()
-        self.components['log'].handler.level = INFO
+        self.components["log"].handler.level = INFO
-        self.components['log'].handler.push_application()
+        self.components["log"].handler.push_application()
 
         self._logger = Logger(self.name)
 
         def handle_exception(exc_type, exc_value, exc_traceback):
-
             if issubclass(exc_type, KeyboardInterrupt):
                 sys.__excepthook__(exc_type, exc_value, exc_traceback)
                 return
 
-            self._logger.error("Uncaught exception occurred",
+            self._logger.error(
-                               exc_info=(exc_type, exc_value, exc_traceback))
+                "Uncaught exception occurred",
+                exc_info=(exc_type, exc_value, exc_traceback),
+            )
 
         sys.excepthook = handle_exception
 
-
     def edit_preferences(self):
-
         prefs = PreferencesWidget(self, self.components)
         prefs.exec_()
 
     def about(self):
-
         about_dialog(
             self,
-            f'About CQ-editor',
+            f"About CQ-editor",
-            f'PyQt GUI for CadQuery.\nVersion: {__version__}.\nSource Code: https://github.com/CadQuery/CQ-editor',
+            f"PyQt GUI for CadQuery.\nVersion: {__version__}.\nSource Code: https://github.com/CadQuery/CQ-editor",
         )
 
     def check_for_cq_updates(self):
-        
         check_gtihub_for_updates(self, cq)
 
     def documentation(self):
-
+        open_url("https://github.com/CadQuery")
-        open_url('https://github.com/CadQuery')
 
     def cq_documentation(self):
-
+        open_url("https://cadquery.readthedocs.io/en/latest/")
-        open_url('https://cadquery.readthedocs.io/en/latest/')
 
     def handle_filename_change(self, fname):
-
         new_title = fname if fname else "*"
         self.setWindowTitle(f"{self.name}: {new_title}")
 
-if __name__ == "__main__":
 
+if __name__ == "__main__":
     pass

cq_editor/mixins.py

@@ -10,72 +10,67 @@ from functools import reduce
 from operator import add
 from logbook import Logger
 
-from PyQt5.QtCore import pyqtSlot, QSettings
+from PySide6.QtCore import QSettings
+from PySide6.QtCore import Slot as pyqtSlot
+
 
 class MainMixin(object):
-
+    name = "Main"
-    name = 'Main'
+    org = "Unknown"
-    org = 'Unknown'
 
     components = {}
     docks = {}
     preferences = None
 
     def __init__(self):
-
         self.settings = QSettings(self.org, self.name)
 
     def registerComponent(self, name, component, dock=None):
-
         self.components[name] = component
 
         if dock:
             self.docks[name] = dock(component)
 
     def saveWindow(self):
-
+        self.settings.setValue("geometry", self.saveGeometry())
-        self.settings.setValue('geometry',self.saveGeometry())
+        self.settings.setValue("windowState", self.saveState())
-        self.settings.setValue('windowState',self.saveState())
 
     def restoreWindow(self):
-
+        if self.settings.value("geometry"):
-        if self.settings.value('geometry'):
+            self.restoreGeometry(self.settings.value("geometry"))
-            self.restoreGeometry(self.settings.value('geometry'))
+        if self.settings.value("windowState"):
-        if self.settings.value('windowState'):
+            self.restoreState(self.settings.value("windowState"))
-            self.restoreState(self.settings.value('windowState'))
 
     def savePreferences(self):
-
         settings = self.settings
 
         if self.preferences:
-            settings.setValue('General',self.preferences.saveState())
+            settings.setValue("General", self.preferences.saveState())
 
         for comp in (c for c in self.components.values() if c.preferences):
             settings.setValue(comp.name, comp.preferences.saveState())
 
     def restorePreferences(self):
-
         settings = self.settings
 
-        if self.preferences and settings.value('General'):
+        if self.preferences and settings.value("General"):
-            self.preferences.restoreState(settings.value('General'),
+            self.preferences.restoreState(
-                                          removeChildren=False)
+                settings.value("General"), removeChildren=False
+            )
 
         for comp in (c for c in self.components.values() if c.preferences):
             if settings.value(comp.name):
-                comp.preferences.restoreState(settings.value(comp.name),
+                comp.preferences.restoreState(
-                                              removeChildren=False)
+                    settings.value(comp.name), removeChildren=False
+                )
 
     def saveComponentState(self):
-
         settings = self.settings
 
         for comp in self.components.values():
             comp.saveComponentState(settings)
 
     def restoreComponentState(self):
-
         settings = self.settings
 
         for comp in self.components.values():
@@ -83,28 +78,21 @@ class MainMixin(object):
 
 
 class ComponentMixin(object):
-
+    name = "Component"
-
-    name = 'Component'
     preferences = None
 
     _actions = {}
 
-
     def __init__(self):
-
         if self.preferences:
-            self.preferences.sigTreeStateChanged.\
+            self.preferences.sigTreeStateChanged.connect(self.updatePreferences)
-                connect(self.updatePreferences)
 
         self._logger = Logger(self.name)
 
     def menuActions(self):
-
         return self._actions
 
     def toolbarActions(self):
-
         if len(self._actions) > 0:
             return reduce(add, [a for a in self._actions.values()])
         else:
@@ -112,13 +100,10 @@ class ComponentMixin(object):
 
     @pyqtSlot(object, object)
     def updatePreferences(self, *args):
-
         pass
 
     def saveComponentState(self, store):
-
         pass
 
     def restoreComponentState(self, store):
-
         pass

cq_editor/preferences.py

@@ -1,6 +1,5 @@
-from PyQt5.QtWidgets import (QTreeWidget, QTreeWidgetItem, 
+from PySide6.QtWidgets import QTreeWidget, QTreeWidgetItem, QStackedWidget, QDialog
-                             QStackedWidget, QDialog)
+from PySide6.QtCore import Slot as pyqtSlot, Qt
-from PyQt5.QtCore import pyqtSlot, Qt
 
 from pyqtgraph.parametertree import ParameterTree
 
@@ -8,32 +7,35 @@ from .utils import splitter, layout
 
 
 class PreferencesTreeItem(QTreeWidgetItem):
-    
+    def __init__(
-    def __init__(self,name,widget,):
+        self,
-        
+        name,
+        widget,
+    ):
         super(PreferencesTreeItem, self).__init__(name)
         self.widget = widget
 
+
 class PreferencesWidget(QDialog):
-    
     def __init__(self, parent, components):
-        
         super(PreferencesWidget, self).__init__(
             parent,
             Qt.Window | Qt.CustomizeWindowHint | Qt.WindowCloseButtonHint,
-                windowTitle='Preferences')
+            windowTitle="Preferences",
+        )
 
         self.stacked = QStackedWidget(self)
-        self.preferences_tree = QTreeWidget(self,
+        self.preferences_tree = QTreeWidget(
+            self,
             headerHidden=True,
             itemsExpandable=False,
             rootIsDecorated=False,
-                                            columnCount=1)
+            columnCount=1,
+        )
 
         self.root = self.preferences_tree.invisibleRootItem()
 
-        self.add('General',
+        self.add("General", parent)
-                 parent)
 
         for v in parent.components.values():
             self.add(v.name, v)
@@ -44,19 +46,15 @@ class PreferencesWidget(QDialog):
         self.preferences_tree.currentItemChanged.connect(self.handleSelection)
 
     def add(self, name, component):
-        
         if component.preferences:
             widget = ParameterTree()
             widget.setHeaderHidden(True)
             widget.setParameters(component.preferences, showTop=False)
-            self.root.addChild(PreferencesTreeItem((name,),
+            self.root.addChild(PreferencesTreeItem((name,), widget))
-                                                    widget))
 
             self.stacked.addWidget(widget)
 
     @pyqtSlot(QTreeWidgetItem, QTreeWidgetItem)
     def handleSelection(self, item, *args):
-        
         if item:
             self.stacked.setCurrentWidget(item.widget)
-

cq_editor/utils.py

@@ -2,22 +2,27 @@ import requests
 
 from pkg_resources import parse_version
 
-from PyQt5 import QtCore, QtWidgets
+from PySide6 import QtCore, QtWidgets
-from PyQt5.QtGui import QDesktopServices
+from PySide6.QtGui import QDesktopServices
-from PyQt5.QtCore import QUrl
+from PySide6.QtCore import QUrl
-from PyQt5.QtWidgets import QFileDialog, QMessageBox
+from PySide6.QtWidgets import QFileDialog, QMessageBox
 
-DOCK_POSITIONS = {'right'   : QtCore.Qt.RightDockWidgetArea,
+DOCK_POSITIONS = {
-                  'left'    : QtCore.Qt.LeftDockWidgetArea,
+    "right": QtCore.Qt.RightDockWidgetArea,
-                  'top'     : QtCore.Qt.TopDockWidgetArea,
+    "left": QtCore.Qt.LeftDockWidgetArea,
-                  'bottom'  : QtCore.Qt.BottomDockWidgetArea}
+    "top": QtCore.Qt.TopDockWidgetArea,
+    "bottom": QtCore.Qt.BottomDockWidgetArea,
+}
 
-def layout(parent,items,
+
+def layout(
+    parent,
+    items,
     top_widget=None,
     layout_type=QtWidgets.QVBoxLayout,
     margin=2,
-           spacing = 0):
+    spacing=0,
-    
+):
     if not top_widget:
         top_widget = QtWidgets.QWidget(parent)
         top_widget_was_none = True
@@ -26,7 +31,8 @@ def layout(parent,items,
     layout = layout_type(top_widget)
     top_widget.setLayout(layout)
 
-    for item in items: layout.addWidget(item)
+    for item in items:
+        layout.addWidget(item)
 
     layout.setSpacing(spacing)
     layout.setContentsMargins(margin, margin, margin, margin)
@@ -36,99 +42,112 @@ def layout(parent,items,
     else:
         return layout
 
-def splitter(items,
-             stretch_factors = None,
-             orientation=QtCore.Qt.Horizontal):
 
+def splitter(items, stretch_factors=None, orientation=QtCore.Qt.Horizontal):
     sp = QtWidgets.QSplitter(orientation)
 
-    for item in items: sp.addWidget(item)
+    for item in items:
+        sp.addWidget(item)
 
     if stretch_factors:
         for i, s in enumerate(stretch_factors):
             sp.setStretchFactor(i, s)
 
-    
     return sp
 
-def dock(widget,
+
+def dock(
+    widget,
     title,
     parent,
     allowedAreas=QtCore.Qt.AllDockWidgetAreas,
-         defaultArea = 'right',
+    defaultArea="right",
     name=None,
-         icon = None):
+    icon=None,
-    
+):
     dock = QtWidgets.QDockWidget(title, parent, objectName=title)
 
-    if name: dock.setObjectName(name)
+    if name:
-    if icon: dock.toggleViewAction().setIcon(icon)
+        dock.setObjectName(name)
+    if icon:
+        dock.toggleViewAction().setIcon(icon)
 
     dock.setAllowedAreas(allowedAreas)
     dock.setWidget(widget)
     action = dock.toggleViewAction()
     action.setText(title)
 
-    dock.setFeatures(QtWidgets.QDockWidget.DockWidgetFeatures(\
+    dock.setFeatures(
-                     QtWidgets.QDockWidget.AllDockWidgetFeatures))
+        QtWidgets.QDockWidget.DockWidgetFeatures(
+            QtWidgets.QDockWidget.DockWidgetFloatable
+        )
+    )
 
-    parent.addDockWidget(DOCK_POSITIONS[defaultArea],
+    parent.addDockWidget(DOCK_POSITIONS[defaultArea], dock)
-                         dock)
 
     return dock
 
-def add_actions(menu,actions):
 
+def add_actions(menu, actions):
     if len(actions) > 0:
         menu.addActions(actions)
         menu.addSeparator()
 
-def open_url(url):
 
+def open_url(url):
     QDesktopServices.openUrl(QUrl(url))
 
-def about_dialog(parent,title,text):
 
+def about_dialog(parent, title, text):
     QtWidgets.QMessageBox.about(parent, title, text)
 
+
 def get_save_filename(suffix):
-    
+    rv, _ = QFileDialog.getSaveFileName(filter="*.{}".format(suffix))
-    rv,_ = QFileDialog.getSaveFileName(filter='*.{}'.format(suffix))
+    if rv != "" and not rv.endswith(suffix):
-    if rv != '' and not rv.endswith(suffix): rv += '.'+suffix
+        rv += "." + suffix
 
     return rv
 
+
 def get_open_filename(suffix, curr_dir):
-    
+    rv, _ = QFileDialog.getOpenFileName(
-    rv,_ = QFileDialog.getOpenFileName(directory=curr_dir, filter='*.{}'.format(suffix))
+        directory=curr_dir, filter="*.{}".format(suffix)
-    if rv != '' and not rv.endswith(suffix): rv += '.'+suffix
+    )
+    if rv != "" and not rv.endswith(suffix):
+        rv += "." + suffix
 
     return rv
 
-def check_gtihub_for_updates(parent,
-                             mod,
-                             github_org='cadquery',
-                             github_proj='cadquery'):
 
-    url = f'https://api.github.com/repos/{github_org}/{github_proj}/releases'    
+def check_gtihub_for_updates(
+    parent, mod, github_org="cadquery", github_proj="cadquery"
+):
+    url = f"https://api.github.com/repos/{github_org}/{github_proj}/releases"
     resp = requests.get(url).json()
 
-    newer = [el['tag_name'] for el in resp if not el['draft'] and \
+    newer = [
-             parse_version(el['tag_name']) > parse_version(mod.__version__)]    
+        el["tag_name"]
+        for el in resp
+        if not el["draft"]
+        and parse_version(el["tag_name"]) > parse_version(mod.__version__)
+    ]
 
     if newer:
-        title='Updates available'
+        title = "Updates available"
-        text=f'There are newer versions of {github_proj} ' \
+        text = (
-             f'available on github:\n' + '\n'.join(newer)
+            f"There are newer versions of {github_proj} "
+            f"available on github:\n" + "\n".join(newer)
+        )
 
     else:
-        title='No updates available'
+        title = "No updates available"
-        text=f'You are already using the latest version of {github_proj}'
+        text = f"You are already using the latest version of {github_proj}"
 
     QtWidgets.QMessageBox.about(parent, title, text)
 
-def confirm(parent,title,msg):
 
+def confirm(parent, title, msg):
     rv = QMessageBox.question(parent, title, msg, QMessageBox.Yes, QMessageBox.No)
 
     return True if rv == QMessageBox.Yes else False

cq_editor/widgets/console.py

@@ -1,14 +1,14 @@
-from PyQt5.QtWidgets import QApplication
+from PySide6.QtWidgets import QApplication
-from PyQt5.QtCore import pyqtSlot
+from PySide6.QtCore import Slot as pyqtSlot
 
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 from qtconsole.inprocess import QtInProcessKernelManager
 
 from ..mixins import ComponentMixin
 
-class ConsoleWidget(RichJupyterWidget,ComponentMixin):
 
-    name = 'Console'
+class ConsoleWidget(RichJupyterWidget, ComponentMixin):
+    name = "Console"
 
     def __init__(self, customBanner=None, namespace=dict(), *args, **kwargs):
         super(ConsoleWidget, self).__init__(*args, **kwargs)
@@ -17,7 +17,7 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
         #            self.banner = customBanner
 
         self.font_size = 6
-        self.style_sheet = '''<style>
+        self.style_sheet = """<style>
         QPlainTextEdit, QTextEdit {
             background-color: #3f3f3f;
             background-clip: padding;
@@ -34,12 +34,12 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
         .in-prompt { color: navy; }
         .out-prompt { color: darkred; }
         </style>
-        '''
+        """
-        self.syntax_style = 'zenburn' #CHANGES FOR DARKMODE
+        self.syntax_style = "zenburn"  # CHANGES FOR DARKMODE
 
         self.kernel_manager = kernel_manager = QtInProcessKernelManager()
         kernel_manager.start_kernel(show_banner=False)
-        kernel_manager.kernel.gui = 'qt'
+        kernel_manager.kernel.gui = "qt"
         kernel_manager.kernel.shell.banner1 = ""
 
         self.kernel_client = kernel_client = self._kernel_manager.client()
@@ -70,7 +70,6 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
         """
         self._control.clear()
 
-
     def print_text(self, text):
         """
         Prints some plain text to the console
@@ -84,18 +83,15 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
         self._execute(command, False)
 
     def _banner_default(self):
-        
+        return ""
-        return ''
 
 
 if __name__ == "__main__":
-   
-    
     import sys
 
     app = QApplication(sys.argv)
 
-    console = ConsoleWidget(customBanner='IPython console test')
+    console = ConsoleWidget(customBanner="IPython console test")
     console.show()
 
     sys.exit(app.exec_())

cq_editor/widgets/cq_object_inspector.py

@@ -1,6 +1,6 @@
-from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem, QAction
+from PySide6.QtWidgets import QTreeWidget, QTreeWidgetItem
-from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
+from PySide6.QtCore import Qt, Slot as pyqtSlot, Signal as pyqtSignal
-
+from PySide6.QtGui import QAction
 from OCP.AIS import AIS_ColoredShape
 from OCP.gp import gp_Ax3
 
@@ -10,63 +10,62 @@ from ..mixins import ComponentMixin
 from ..icons import icon
 
 
-        
 class CQChildItem(QTreeWidgetItem):
-    
     def __init__(self, cq_item, **kwargs):
-        
+        super(CQChildItem, self).__init__(
-        super(CQChildItem,self).\
+            [type(cq_item).__name__, str(cq_item)], **kwargs
-            __init__([type(cq_item).__name__,str(cq_item)],**kwargs)
+        )
 
         self.cq_item = cq_item
 
+
 class CQStackItem(QTreeWidgetItem):
-    
     def __init__(self, name, workplane=None, **kwargs):
-        
+        super(CQStackItem, self).__init__([name, ""], **kwargs)
-        super(CQStackItem,self).__init__([name,''],**kwargs)
 
         self.workplane = workplane
 
 
 class CQObjectInspector(QTreeWidget, ComponentMixin):
-    
+    name = "CQ Object Inspector"
-    name = 'CQ Object Inspector'
 
     sigRemoveObjects = pyqtSignal(list)
     sigDisplayObjects = pyqtSignal(list, bool)
-    sigShowPlane = pyqtSignal([bool],[bool,float])
+    sigShowPlane = pyqtSignal(bool)
+    sigShowPlane2 = pyqtSignal(bool, float)
     sigChangePlane = pyqtSignal(gp_Ax3)
 
     def __init__(self, parent):
-        
         super(CQObjectInspector, self).__init__(parent)
         self.setHeaderHidden(False)
         self.setRootIsDecorated(True)
         self.setContextMenuPolicy(Qt.ActionsContextMenu)
         self.setColumnCount(2)
-        self.setHeaderLabels(['Type','Value'])
+        self.setHeaderLabels(["Type", "Value"])
 
         self.root = self.invisibleRootItem()
         self.inspected_items = []
 
-        self._toolbar_actions = \
+        self._toolbar_actions = [
-            [QAction(icon('inspect'),'Inspect CQ object',self,\
+            QAction(
-                     toggled=self.inspect,checkable=True)]
+                icon("inspect"),
+                "Inspect CQ object",
+                self,
+                toggled=self.inspect,
+                checkable=True,
+            )
+        ]
 
         self.addActions(self._toolbar_actions)
 
     def menuActions(self):
-        
+        return {"Tools": self._toolbar_actions}
-        return {'Tools' : self._toolbar_actions}
 
     def toolbarActions(self):
-        
         return self._toolbar_actions
 
     @pyqtSlot(bool)
     def inspect(self, value):
-        
         if value:
             self.itemSelectionChanged.connect(self.handleSelection)
             self.itemSelectionChanged.emit()
@@ -77,7 +76,6 @@ class CQObjectInspector(QTreeWidget,ComponentMixin):
 
     @pyqtSlot()
     def handleSelection(self):
-        
         inspected_items = self.inspected_items
         self.sigRemoveObjects.emit(inspected_items)
         inspected_items.clear()
@@ -90,22 +88,22 @@ class CQObjectInspector(QTreeWidget,ComponentMixin):
         if type(item) is CQStackItem:
             cq_plane = item.workplane.plane
             dim = item.workplane.largestDimension()
-            plane = gp_Ax3(cq_plane.origin.toPnt(),
+            plane = gp_Ax3(
-                           cq_plane.zDir.toDir(),
+                cq_plane.origin.toPnt(), cq_plane.zDir.toDir(), cq_plane.xDir.toDir()
-                           cq_plane.xDir.toDir())
+            )
             self.sigChangePlane.emit(plane)
             self.sigShowPlane[bool, float].emit(True, dim)
 
             for child in (item.child(i) for i in range(item.childCount())):
                 obj = child.cq_item
-                if hasattr(obj,'wrapped') and type(obj) != Vector:
+                if hasattr(obj, "wrapped") and type(obj) != Vector:
                     ais = AIS_ColoredShape(obj.wrapped)
                     inspected_items.append(ais)
 
         else:
             self.sigShowPlane.emit(False)
             obj = item.cq_item
-            if hasattr(obj,'wrapped') and type(obj) != Vector:
+            if hasattr(obj, "wrapped") and type(obj) != Vector:
                 ais = AIS_ColoredShape(obj.wrapped)
                 inspected_items.append(ais)
 
@@ -113,11 +111,10 @@ class CQObjectInspector(QTreeWidget,ComponentMixin):
 
     @pyqtSlot(object)
     def setObject(self, cq_obj):
-        
         self.root.takeChildren()
 
         # iterate through parent objects if they exist
-        while getattr(cq_obj, 'parent', None):
+        while getattr(cq_obj, "parent", None):
             current_frame = CQStackItem(str(cq_obj.plane.origin), workplane=cq_obj)
             self.root.addChild(current_frame)
 
@@ -125,5 +122,3 @@ class CQObjectInspector(QTreeWidget,ComponentMixin):
                 current_frame.addChild(CQChildItem(obj))
 
             cq_obj = cq_obj.parent
-            
-            

cq_editor/widgets/debugger.py

@@ -5,10 +5,17 @@ from types import SimpleNamespace, FrameType, ModuleType
 from typing import List
 
 import cadquery as cq
-from PyQt5 import QtCore
+from PySide6 import QtCore
-from PyQt5.QtCore import Qt, QObject, pyqtSlot, pyqtSignal, QEventLoop, QAbstractTableModel
+from PySide6.QtCore import (
-from PyQt5.QtWidgets import (QAction,
+    Qt,
-                             QTableView)
+    QObject,
+    Slot as pyqtSlot,
+    Signal as pyqtSignal,
+    QEventLoop,
+    QAbstractTableModel,
+)
+from PySide6.QtWidgets import QTableView
+from PySide6.QtGui import QAction
 from logbook import info
 from path import Path
 from pyqtgraph.parametertree import Parameter
@@ -18,46 +25,43 @@ from random import randrange as rrr, seed
 from ..cq_utils import find_cq_objects, reload_cq
 from ..mixins import ComponentMixin
 
-DUMMY_FILE = '<string>'
+DUMMY_FILE = "<string>"
 
 
 class DbgState(Enum):
-
     STEP = auto()
     CONT = auto()
     STEP_IN = auto()
     RETURN = auto()
 
-class DbgEevent(object):
 
-    LINE = 'line'
+class DbgEevent(object):
-    CALL = 'call'
+    LINE = "line"
-    RETURN = 'return'
+    CALL = "call"
+    RETURN = "return"
+
 
 class LocalsModel(QAbstractTableModel):
-
+    HEADER = ("Name", "Type", "Value")
-    HEADER = ('Name','Type', 'Value')
 
     def __init__(self, parent):
-
         super(LocalsModel, self).__init__(parent)
         self.frame = None
 
     def update_frame(self, frame):
-
+        self.frame = [
-        self.frame = \
+            (k, type(v).__name__, str(v))
-            [(k,type(v).__name__, str(v)) for k,v in frame.items() if not k.startswith('_')]
+            for k, v in frame.items()
-
+            if not k.startswith("_")
+        ]
 
     def rowCount(self, parent=QtCore.QModelIndex()):
-
         if self.frame:
             return len(self.frame)
         else:
             return 0
 
     def columnCount(self, parent=QtCore.QModelIndex()):
-
         return 3
 
     def headerData(self, section, orientation, role=Qt.DisplayRole):
@@ -75,11 +79,9 @@ class LocalsModel(QAbstractTableModel):
 
 
 class LocalsView(QTableView, ComponentMixin):
-
+    name = "Variables"
-    name = 'Variables'
 
     def __init__(self, parent):
-
         super(LocalsView, self).__init__(parent)
         ComponentMixin.__init__(self)
 
@@ -91,23 +93,24 @@ class LocalsView(QTableView,ComponentMixin):
 
     @pyqtSlot(dict)
     def update_frame(self, frame):
-
         model = LocalsModel(self)
         model.update_frame(frame)
 
         self.setModel(model)
 
+
 class Debugger(QObject, ComponentMixin):
+    name = "Debugger"
 
-    name = 'Debugger'
+    preferences = Parameter.create(
-
+        name="Preferences",
-    preferences = Parameter.create(name='Preferences',children=[
+        children=[
-        {'name': 'Reload CQ', 'type': 'bool', 'value': False},
+            {"name": "Reload CQ", "type": "bool", "value": False},
-        {'name': 'Add script dir to path','type': 'bool', 'value': True},
+            {"name": "Add script dir to path", "type": "bool", "value": True},
-        {'name': 'Change working dir to script dir','type': 'bool', 'value': True},
+            {"name": "Change working dir to script dir", "type": "bool", "value": True},
-        {'name': 'Reload imported modules', 'type': 'bool', 'value': True},
+            {"name": "Reload imported modules", "type": "bool", "value": True},
-    ])
+        ],
-
+    )
 
     sigRendered = pyqtSignal(dict)
     sigLocals = pyqtSignal(dict)
@@ -122,78 +125,81 @@ class Debugger(QObject,ComponentMixin):
     _frames: List[FrameType]
 
     def __init__(self, parent):
-
         super(Debugger, self).__init__(parent)
         ComponentMixin.__init__(self)
 
         self.inner_event_loop = QEventLoop(self)
 
-        self._actions =  \
+        self._actions = {
-            {'Run' : [QAction(icon('run'),
+            "Run": [
-                              'Render',
+                QAction(
-                               self,
+                    icon("run"), "Render", self, shortcut="F5", triggered=self.render
-                               shortcut='F5',
+                ),
-                               triggered=self.render),
+                QAction(
-                      QAction(icon('debug'),
+                    icon("debug"),
-                             'Debug',
+                    "Debug",
                     self,
                     checkable=True,
-                             shortcut='ctrl+F5',
+                    shortcut="ctrl+F5",
-                             triggered=self.debug),
+                    triggered=self.debug,
-                      QAction(icon('arrow-step-over'),
+                ),
-                             'Step',
+                QAction(
+                    icon("arrow-step-over"),
+                    "Step",
                     self,
-                             shortcut='ctrl+F10',
+                    shortcut="ctrl+F10",
-                             triggered=lambda: self.debug_cmd(DbgState.STEP)),
+                    triggered=lambda: self.debug_cmd(DbgState.STEP),
-                      QAction(icon('arrow-step-in'),
+                ),
-                             'Step in',
+                QAction(
+                    icon("arrow-step-in"),
+                    "Step in",
                     self,
-                             shortcut='ctrl+F11',
+                    shortcut="ctrl+F11",
-                             triggered=lambda: self.debug_cmd(DbgState.STEP_IN)),
+                    triggered=lambda: self.debug_cmd(DbgState.STEP_IN),
-                      QAction(icon('arrow-continue'),
+                ),
-                              'Continue',
+                QAction(
+                    icon("arrow-continue"),
+                    "Continue",
                     self,
-                              shortcut='ctrl+F12',
+                    shortcut="ctrl+F12",
-                              triggered=lambda: self.debug_cmd(DbgState.CONT))
+                    triggered=lambda: self.debug_cmd(DbgState.CONT),
-                      ]}
+                ),
+            ]
+        }
 
         self._frames = []
 
     def get_current_script(self):
-
+        return self.parent().components["editor"].get_text_with_eol()
-        return self.parent().components['editor'].get_text_with_eol()
 
     def get_breakpoints(self):
-
+        return self.parent().components["editor"].debugger.get_breakpoints()
-        return self.parent().components['editor'].debugger.get_breakpoints()
 
     def compile_code(self, cq_script):
-
         try:
-            module = ModuleType('temp')
+            module = ModuleType("temp")
-            cq_code = compile(cq_script, '<string>', 'exec')
+            cq_code = compile(cq_script, "<string>", "exec")
             return cq_code, module
         except Exception:
             self.sigTraceback.emit(sys.exc_info(), cq_script)
             return None, None
 
     def _exec(self, code, locals_dict, globals_dict):
-
         with ExitStack() as stack:
-            fname = self.parent().components['editor'].filename
+            fname = self.parent().components["editor"].filename
-            p = Path(fname if fname else '').abspath().dirname()
+            p = Path(fname if fname else "").abspath().dirname()
 
-            if self.preferences['Add script dir to path'] and p.exists():
+            if self.preferences["Add script dir to path"] and p.exists():
                 sys.path.insert(0, p)
                 stack.callback(sys.path.remove, p)
-            if self.preferences['Change working dir to script dir'] and p.exists():
+            if self.preferences["Change working dir to script dir"] and p.exists():
                 stack.enter_context(p)
-            if self.preferences['Reload imported modules']:
+            if self.preferences["Reload imported modules"]:
                 stack.enter_context(module_manager())
 
             exec(code, locals_dict, globals_dict)
 
-    def _rand_color(self, alpha = 0., cfloat=False):
+    def _rand_color(self, alpha=0.0, cfloat=False):
         # helper function to generate a random color dict
         # for CQ-editor's show_object function
         lower = 10
@@ -205,50 +211,80 @@ class Debugger(QObject,ComponentMixin):
                 (rrr(lower, upper) / 255),
                 alpha,
             )
-        return {"alpha": alpha,
+        return {
+            "alpha": alpha,
             "color": (
                 rrr(lower, upper),
                 rrr(lower, upper),
                 rrr(lower, upper),
-                         )}
+            ),
+        }
 
     def _inject_locals(self, module):
-
         cq_objects = {}
 
-        def _show_object(obj,name=None, options={}):
+        def _show_object(
-
+            obj,
+            name=None,
+            options={},  # all following inputs are ignored by cq-editor
+            parent=1,
+            clear=True,
+            port=3939,
+            axes=False,
+            axes0=False,
+            grid=False,
+            ticks=10,
+            ortho=True,
+            transparent=False,
+            default_color=(232, 176, 36),
+            reset_camera=True,
+            zoom=1.0,
+            default_edgecolor=(128, 128, 128),
+            render_edges=True,
+            render_normals=False,
+            render_mates=False,
+            mate_scale=1.0,
+            deviation=0.1,
+            angular_tolerance=0.2,
+            edge_accuracy=5.0,
+            ambient_intensity=1.0,
+            direct_intensity=0.12,
+        ):
             if name:
                 cq_objects.update({name: SimpleNamespace(shape=obj, options=options)})
             else:
-                cq_objects.update({str(id(obj)) : SimpleNamespace(shape=obj,options=options)})
+                cq_objects.update(
+                    {str(id(obj)): SimpleNamespace(shape=obj, options=options)}
+                )
 
         def _debug(obj, name=None):
+            _show_object(obj, name, options=dict(color="red", alpha=0.2))
 
-            _show_object(obj,name,options=dict(color='red',alpha=0.2))
+        module.__dict__["show_object"] = _show_object
+        module.__dict__["debug"] = _debug
+        module.__dict__["rand_color"] = self._rand_color
+        module.__dict__["log"] = lambda x: info(str(x))
+        module.__dict__["cq"] = cq
 
-        module.__dict__['show_object'] = _show_object
+        return cq_objects, set(module.__dict__) - {"cq"}
-        module.__dict__['debug'] = _debug
-        module.__dict__['rand_color'] = self._rand_color
-        module.__dict__['log'] = lambda x: info(str(x))
-        module.__dict__['cq'] = cq
-
-        return cq_objects, set(module.__dict__)-{'cq'}
 
     def _cleanup_locals(self, module, injected_names):
-
+        for name in injected_names:
-        for name in injected_names: module.__dict__.pop(name)
+            module.__dict__.pop(name)
 
     @pyqtSlot(bool)
     def render(self):
-        seed(371353) #reset the seed every time render is called (preserves colors run to run)
+        seed(
-        if self.preferences['Reload CQ']:
+            59798267586177
+        )  # reset the seed every time render is called (preserves colors run to run)
+        if self.preferences["Reload CQ"]:
             reload_cq()
 
         cq_script = self.get_current_script()
         cq_code, module = self.compile_code(cq_script)
 
-        if cq_code is None: return
+        if cq_code is None:
+            return
 
         cq_objects, injected_names = self._inject_locals(module)
 
@@ -262,8 +298,7 @@ class Debugger(QObject,ComponentMixin):
             if len(cq_objects) == 0:
                 cq_objects = find_cq_objects(module.__dict__)
             self.sigRendered.emit(cq_objects)
-            self.sigTraceback.emit(None,
+            self.sigTraceback.emit(None, cq_script)
-                                   cq_script)
             self.sigLocals.emit(module.__dict__)
         except Exception:
             exc_info = sys.exc_info()
@@ -276,7 +311,6 @@ class Debugger(QObject,ComponentMixin):
 
     @pyqtSlot(bool)
     def debug(self, value):
-
         previous_trace = sys.gettrace()
 
         if value:
@@ -288,14 +322,13 @@ class Debugger(QObject,ComponentMixin):
 
             if code is None:
                 self.sigDebugging.emit(False)
-                self._actions['Run'][1].setChecked(False)
+                self._actions["Run"][1].setChecked(False)
                 return
 
             cq_objects, injected_names = self._inject_locals(module)
 
             # clear possible traceback
-            self.sigTraceback.emit(None,
+            self.sigTraceback.emit(None, self.script)
-                                   self.script)
 
             try:
                 sys.settrace(self.trace_callback)
@@ -303,12 +336,11 @@ class Debugger(QObject,ComponentMixin):
             except Exception:
                 exc_info = sys.exc_info()
                 sys.last_traceback = exc_info[-1]
-                self.sigTraceback.emit(exc_info,
+                self.sigTraceback.emit(exc_info, self.script)
-                                       self.script)
             finally:
                 sys.settrace(previous_trace)
                 self.sigDebugging.emit(False)
-                self._actions['Run'][1].setChecked(False)
+                self._actions["Run"][1].setChecked(False)
 
                 if len(cq_objects) == 0:
                     cq_objects = find_cq_objects(module.__dict__)
@@ -322,15 +354,11 @@ class Debugger(QObject,ComponentMixin):
             sys.settrace(previous_trace)
             self.inner_event_loop.exit(0)
 
-
     def debug_cmd(self, state=DbgState.STEP):
-
         self.state = state
         self.inner_event_loop.exit(0)
 
-
     def trace_callback(self, frame, event, arg):
-
         filename = frame.f_code.co_filename
 
         if filename == DUMMY_FILE:
@@ -343,13 +371,13 @@ class Debugger(QObject,ComponentMixin):
             return None
 
     def trace_local(self, frame, event, arg):
-
         lineno = frame.f_lineno
 
         if event in (DbgEevent.LINE,):
-            if (self.state in (DbgState.STEP, DbgState.STEP_IN) and frame is self._frames[-1]) \
+            if (
-            or (lineno in self.breakpoints):
+                self.state in (DbgState.STEP, DbgState.STEP_IN)
-                
+                and frame is self._frames[-1]
+            ) or (lineno in self.breakpoints):
                 if lineno in self.breakpoints:
                     self._frames.append(frame)
 

cq_editor/widgets/editor.py

@@ -2,9 +2,11 @@ import os
 from modulefinder import ModuleFinder
 
 from spyder.plugins.editor.widgets.codeeditor import CodeEditor
-from PyQt5.QtCore import pyqtSignal, QFileSystemWatcher, QTimer
+from PySide6.QtCore import Signal as pyqtSignal
-from PyQt5.QtWidgets import QAction, QFileDialog
+from PySide6.QtCore import QFileSystemWatcher, QTimerEvent, QTimer
-from PyQt5.QtGui import QFontDatabase
+
+from PySide6.QtWidgets import QFileDialog
+from PySide6.QtGui import QFontDatabase, QAction
 from path import Path
 
 import sys
@@ -16,91 +18,104 @@ from ..utils import get_save_filename, get_open_filename, confirm
 
 from ..icons import icon
 
-class Editor(CodeEditor,ComponentMixin):
 
-    name = 'Code Editor'
+class Editor(CodeEditor, ComponentMixin):
+    name = "Code Editor"
 
     # This signal is emitted whenever the currently-open file changes and
     # autoreload is enabled.
     triggerRerender = pyqtSignal(bool)
     sigFilenameChanged = pyqtSignal(str)
 
-    preferences = Parameter.create(name='Preferences',children=[
+    preferences = Parameter.create(
-        {'name': 'Font size', 'type': 'int', 'value': 12},
+        name="Preferences",
-        {'name': 'Autoreload', 'type': 'bool', 'value': False},
+        children=[
-        {'name': 'Autoreload delay', 'type': 'int', 'value': 50},
+            {"name": "Font size", "type": "int", "value": 12},
-        {'name': 'Autoreload: watch imported modules', 'type': 'bool', 'value': False},
+            {"name": "Autoreload", "type": "bool", "value": False},
-        {'name': 'Line wrap', 'type': 'bool', 'value': False},
+            {"name": "Autoreload delay", "type": "int", "value": 50},
-        {'name': 'Color scheme', 'type': 'list',
+            {
-         'values': ['Spyder','Monokai','Zenburn'], 'value': 'Spyder'}])
+                "name": "Autoreload: watch imported modules",
+                "type": "bool",
+                "value": False,
+            },
+            {"name": "Line wrap", "type": "bool", "value": False},
+            {
+                "name": "Color scheme",
+                "type": "list",
+                "values": ["Spyder", "Monokai", "Zenburn"],
+                "value": "Spyder",
+            },
+        ],
+    )
 
-    EXTENSIONS = 'py'
+    EXTENSIONS = "py"
 
     def __init__(self, parent=None):
-
         self._watched_file = None
 
         super(Editor, self).__init__(parent)
         ComponentMixin.__init__(self)
 
-        self.setup_editor(linenumbers=True,
+        self.setup_editor(
+            linenumbers=True,
             markers=True,
             edge_line=False,
             tab_mode=False,
             show_blanks=True,
             font=QFontDatabase.systemFont(QFontDatabase.FixedFont),
-                          language='Python',
+            language="Python",
-                          filename='')
+            filename="",
+        )
 
-        self._actions =  \
+        self._actions = {
-                {'File' : [QAction(icon('new'),
+            "File": [
-                                  'New',
+                QAction(
+                    icon("new"), "New", self, shortcut="ctrl+N", triggered=self.new
+                ),
+                QAction(
+                    icon("open"), "Open", self, shortcut="ctrl+O", triggered=self.open
+                ),
+                QAction(
+                    icon("save"), "Save", self, shortcut="ctrl+S", triggered=self.save
+                ),
+                QAction(
+                    icon("save_as"),
+                    "Save as",
                     self,
-                                  shortcut='ctrl+N',
+                    shortcut="ctrl+shift+S",
-                                  triggered=self.new),
+                    triggered=self.save_as,
-                          QAction(icon('open'),
+                ),
-                                  'Open',
+                QAction(
+                    icon("autoreload"),
+                    "Automatic reload and preview",
                     self,
-                                  shortcut='ctrl+O',
+                    triggered=self.autoreload,
-                                  triggered=self.open),
-                          QAction(icon('save'),
-                                  'Save',
-                                  self,
-                                  shortcut='ctrl+S',
-                                  triggered=self.save),
-                          QAction(icon('save_as'),
-                                  'Save as',
-                                  self,
-                                  shortcut='ctrl+shift+S',
-                                  triggered=self.save_as),
-                          QAction(icon('autoreload'),
-                                  'Automatic reload and preview',
-                                  self,triggered=self.autoreload,
                     checkable=True,
                     checked=False,
-                                  objectName='autoreload'),
+                    objectName="autoreload",
-                          ]}
+                ),
+            ]
+        }
 
         for a in self._actions.values():
             self.addActions(a)
 
-
         self._fixContextMenu()
 
         # autoreload support
         self._file_watcher = QFileSystemWatcher(self)
         # we wait for 50ms after a file change for the file to be written completely
         self._file_watch_timer = QTimer(self)
-        self._file_watch_timer.setInterval(self.preferences['Autoreload delay'])
+        self._file_watch_timer.setInterval(self.preferences["Autoreload delay"])
         self._file_watch_timer.setSingleShot(True)
         self._file_watcher.fileChanged.connect(
-                lambda val: self._file_watch_timer.start())
+            lambda val: self._file_watch_timer.start()
+        )
         self._file_watch_timer.timeout.connect(self._file_changed)
 
         self.updatePreferences()
 
     def _fixContextMenu(self):
-
         menu = self.menu
 
         menu.removeAction(self.run_cell_action)
@@ -109,67 +124,65 @@ class Editor(CodeEditor,ComponentMixin):
         menu.removeAction(self.re_run_last_cell_action)
 
     def updatePreferences(self, *args):
-
+        self.set_color_scheme(self.preferences["Color scheme"])
-        self.set_color_scheme(self.preferences['Color scheme'])
 
         font = self.font()
-        font.setPointSize(self.preferences['Font size'])
+        font.setPointSize(self.preferences["Font size"])
         self.set_font(font)
 
-        self.findChild(QAction, 'autoreload') \
+        self.findChild(QAction, "autoreload").setChecked(self.preferences["Autoreload"])
-            .setChecked(self.preferences['Autoreload'])
 
-        self._file_watch_timer.setInterval(self.preferences['Autoreload delay'])
+        self._file_watch_timer.setInterval(self.preferences["Autoreload delay"])
 
-        self.toggle_wrap_mode(self.preferences['Line wrap'])
+        self.toggle_wrap_mode(self.preferences["Line wrap"])
 
         self._clear_watched_paths()
         self._watch_paths()
 
     def confirm_discard(self):
-
         if self.modified:
-            rv =  confirm(self,'Please confirm','Current document is not saved - do you want to continue?')
+            rv = confirm(
+                self,
+                "Please confirm",
+                "Current document is not saved - do you want to continue?",
+            )
         else:
             rv = True
 
         return rv
 
     def new(self):
+        if not self.confirm_discard():
+            return
 
-        if not self.confirm_discard(): return
+        self.set_text("")
-
+        self.filename = ""
-        self.set_text('')
-        self.filename = ''
         self.reset_modified()
 
     def open(self):
-        
+        if not self.confirm_discard():
-        if not self.confirm_discard(): return
+            return
 
         curr_dir = Path(self.filename).abspath().dirname()
         fname = get_open_filename(self.EXTENSIONS, curr_dir)
-        if fname != '':
+        if fname != "":
             self.load_from_file(fname)
 
     def load_from_file(self, fname):
-
         self.set_text_from_file(fname)
         self.filename = fname
         self.reset_modified()
 
     def save(self):
-
+        if self._filename != "":
-        if self._filename != '':
+            if self.preferences["Autoreload"]:
-
-            if self.preferences['Autoreload']:
                 self._file_watcher.blockSignals(True)
                 self._file_watch_timer.stop()
 
-            with open(self._filename, 'w') as f:
+            with open(self._filename, "w") as f:
                 f.write(self.toPlainText())
 
-            if self.preferences['Autoreload']:
+            if self.preferences["Autoreload"]:
                 self._file_watcher.blockSignals(False)
                 self.triggerRerender.emit(True)
 
@@ -179,20 +192,25 @@ class Editor(CodeEditor,ComponentMixin):
             self.save_as()
 
     def save_as(self):
-
         fname = get_save_filename(self.EXTENSIONS)
-        if fname != '':
+        if fname != "":
-            with open(fname,'w') as f:
+            with open(fname, "w") as f:
                 f.write(self.toPlainText())
                 self.filename = fname
 
             self.reset_modified()
 
     def _update_filewatcher(self):
-        if self._watched_file and (self._watched_file != self.filename or not self.preferences['Autoreload']):
+        if self._watched_file and (
+            self._watched_file != self.filename or not self.preferences["Autoreload"]
+        ):
             self._clear_watched_paths()
             self._watched_file = None
-        if self.preferences['Autoreload'] and self.filename and self.filename != self._watched_file:
+        if (
+            self.preferences["Autoreload"]
+            and self.filename
+            and self.filename != self._watched_file
+        ):
             self._watched_file = self._filename
             self._watch_paths()
 
@@ -214,7 +232,7 @@ class Editor(CodeEditor,ComponentMixin):
     def _watch_paths(self):
         if Path(self._filename).exists():
             self._file_watcher.addPath(self._filename)
-            if self.preferences['Autoreload: watch imported modules']:
+            if self.preferences["Autoreload: watch imported modules"]:
                 module_paths = self.get_imported_module_paths(self._filename)
                 if module_paths:
                     self._file_watcher.addPaths(module_paths)
@@ -228,51 +246,45 @@ class Editor(CodeEditor,ComponentMixin):
 
     # Turn autoreload on/off.
     def autoreload(self, enabled):
-        self.preferences['Autoreload'] = enabled
+        self.preferences["Autoreload"] = enabled
         self._update_filewatcher()
 
     def reset_modified(self):
-
         self.document().setModified(False)
 
     @property
     def modified(self):
-        
         return self.document().isModified()
 
     def saveComponentState(self, store):
-
+        if self.filename != "":
-        if self.filename != '':
+            store.setValue(self.name + "/state", self.filename)
-            store.setValue(self.name+'/state',self.filename)
 
     def restoreComponentState(self, store):
+        filename = store.value(self.name + "/state")
 
-        filename = store.value(self.name+'/state')
+        if filename and self.filename == "":
-
-        if filename and self.filename == '':
             try:
                 self.load_from_file(filename)
             except IOError:
-                self._logger.warning(f'could not open {filename}')
+                self._logger.warning(f"could not open {filename}")
-
 
     def get_imported_module_paths(self, module_path):
-
         finder = ModuleFinder([os.path.dirname(module_path)])
         imported_modules = []
 
         try:
             finder.run_script(module_path)
         except SyntaxError as err:
-            self._logger.warning(f'Syntax error in {module_path}: {err}')
+            self._logger.warning(f"Syntax error in {module_path}: {err}")
         except Exception as err:
             self._logger.warning(
-                f'Cannot determine imported modules in {module_path}: {type(err).__name__} {err}'
+                f"Cannot determine imported modules in {module_path}: {type(err).__name__} {err}"
             )
         else:
             for module_name, module in finder.modules.items():
-                if module_name != '__main__':
+                if module_name != "__main__":
-                    path = getattr(module, '__file__', None)
+                    path = getattr(module, "__file__", None)
                     if path is not None and os.path.isfile(path):
                         imported_modules.append(path)
 
@@ -280,8 +292,7 @@ class Editor(CodeEditor,ComponentMixin):
 
 
 if __name__ == "__main__":
-
+    from PySide6.QtWidgets import QApplication
-    from PyQt5.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
     editor = Editor()

cq_editor/widgets/log.py

@@ -1,7 +1,7 @@
 import logbook as logging
 
-from PyQt5.QtWidgets import QPlainTextEdit
+from PySide6.QtWidgets import QPlainTextEdit
-from PyQt5 import QtCore
+from PySide6 import QtCore
 
 from ..mixins import ComponentMixin
 

cq_editor/widgets/object_tree.py

@@ -1,5 +1,12 @@
-from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem, QAction, QMenu, QWidget, QAbstractItemView
+from PySide6.QtWidgets import (
-from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
+    QTreeWidget,
+    QTreeWidgetItem,
+    QMenu,
+    QWidget,
+    QAbstractItemView,
+)
+from PySide6.QtGui import QAction
+from PySide6.QtCore import Qt, Slot as pyqtSlot, Signal as pyqtSignal
 from pyqtgraph.parametertree import Parameter, ParameterTree
 
 from OCP.AIS import AIS_Line
@@ -8,33 +15,42 @@ from OCP.gp import gp_Dir, gp_Pnt, gp_Ax1
 
 from ..mixins import ComponentMixin
 from ..icons import icon
-from ..cq_utils import make_AIS, export, to_occ_color, is_obj_empty, get_occ_color, set_color
+from ..cq_utils import (
+    make_AIS,
+    export,
+    to_occ_color,
+    is_obj_empty,
+    get_occ_color,
+    set_color,
+)
 from .viewer import DEFAULT_FACE_COLOR
 from ..utils import splitter, layout, get_save_filename
 
+
 class TopTreeItem(QTreeWidgetItem):
-
     def __init__(self, *args, **kwargs):
-
         super(TopTreeItem, self).__init__(*args, **kwargs)
 
+
 class ObjectTreeItem(QTreeWidgetItem):
+    props = [
+        {"name": "Name", "type": "str", "value": ""},
+        {"name": "Color", "type": "color", "value": "#f4a824"},
+        {"name": "Alpha", "type": "float", "value": 0, "limits": (0, 1), "step": 1e-1},
+        {"name": "Visible", "type": "bool", "value": True},
+    ]
 
-    props = [{'name': 'Name', 'type': 'str', 'value': ''},
+    def __init__(
-             {'name': 'Color', 'type': 'color', 'value': "#f4a824"},
+        self,
-             {'name': 'Alpha', 'type': 'float', 'value': 0, 'limits': (0,1), 'step': 1e-1},
-             {'name': 'Visible', 'type': 'bool','value': True}]
-
-    def __init__(self,
         name,
         ais=None,
         shape=None,
         shape_display=None,
         sig=None,
-                 alpha=0.,
+        alpha=0.0,
-                 color='#f4a824',
+        color="#f4a824",
-                 **kwargs):
+        **kwargs
-
+    ):
         super(ObjectTreeItem, self).__init__([name], **kwargs)
         self.setFlags(self.flags() | Qt.ItemIsUserCheckable)
         self.setCheckState(0, Qt.Checked)
@@ -44,27 +60,29 @@ class ObjectTreeItem(QTreeWidgetItem):
         self.shape_display = shape_display
         self.sig = sig
 
-        self.properties = Parameter.create(name='Properties',
+        self.properties = Parameter.create(name="Properties", children=self.props)
-                                           children=self.props)
 
-        self.properties['Name'] = name
+        self.properties["Name"] = name
-        self.properties['Alpha'] = ais.Transparency()
+        self.properties["Alpha"] = ais.Transparency()
-        self.properties['Color'] = get_occ_color(ais) if ais and ais.HasColor() else get_occ_color(DEFAULT_FACE_COLOR)
+        self.properties["Color"] = (
+            get_occ_color(ais)
+            if ais and ais.HasColor()
+            else get_occ_color(DEFAULT_FACE_COLOR)
+        )
         self.properties.sigTreeStateChanged.connect(self.propertiesChanged)
 
     def propertiesChanged(self, properties, changed):
-
         changed_prop = changed[0][0]
 
-        self.setData(0,0,self.properties['Name'])
+        self.setData(0, 0, self.properties["Name"])
-        self.ais.SetTransparency(self.properties['Alpha'])
+        self.ais.SetTransparency(self.properties["Alpha"])
 
-        if changed_prop.name() == 'Color':
+        if changed_prop.name() == "Color":
-            set_color(self.ais, to_occ_color(self.properties['Color']))
+            set_color(self.ais, to_occ_color(self.properties["Color"]))
 
         self.ais.Redisplay()
 
-        if self.properties['Visible']:
+        if self.properties["Visible"]:
             self.setCheckState(0, Qt.Checked)
         else:
             self.setCheckState(0, Qt.Unchecked)
@@ -72,31 +90,32 @@ class ObjectTreeItem(QTreeWidgetItem):
         if self.sig:
             self.sig.emit()
 
+
 class CQRootItem(TopTreeItem):
-
     def __init__(self, *args, **kwargs):
-
+        super(CQRootItem, self).__init__(["CQ models"], *args, **kwargs)
-        super(CQRootItem,self).__init__(['CQ models'],*args,**kwargs)
 
 
 class HelpersRootItem(TopTreeItem):
-
     def __init__(self, *args, **kwargs):
-
+        super(HelpersRootItem, self).__init__(["Helpers"], *args, **kwargs)
-        super(HelpersRootItem,self).__init__(['Helpers'],*args,**kwargs)
 
 
 class ObjectTree(QWidget, ComponentMixin):
-
+    name = "Object Tree"
-    name = 'Object Tree'
     _stash = []
 
-    preferences = Parameter.create(name='Preferences',children=[
+    preferences = Parameter.create(
-        {'name': 'Preserve properties on reload', 'type': 'bool', 'value': False},
+        name="Preferences",
-        {'name': 'Clear all before each run', 'type': 'bool', 'value': True},
+        children=[
-        {'name': 'STL precision','type': 'float', 'value': .1}])
+            {"name": "Preserve properties on reload", "type": "bool", "value": False},
+            {"name": "Clear all before each run", "type": "bool", "value": True},
+            {"name": "STL precision", "type": "float", "value": 0.1},
+        ],
+    )
 
-    sigObjectsAdded = pyqtSignal([list],[list,bool])
+    sigObjectsAdded = pyqtSignal(list)
+    sigObjectsAdded2 = pyqtSignal(list, bool)
     sigObjectsRemoved = pyqtSignal(list)
     sigCQObjectSelected = pyqtSignal(object)
     sigAISObjectsSelected = pyqtSignal(list)
@@ -104,11 +123,11 @@ class ObjectTree(QWidget,ComponentMixin):
     sigObjectPropertiesChanged = pyqtSignal()
 
     def __init__(self, parent):
-
         super(ObjectTree, self).__init__(parent)
 
-        self.tree = tree = QTreeWidget(self,
+        self.tree = tree = QTreeWidget(
-                                       selectionMode=QAbstractItemView.ExtendedSelection)
+            self, selectionMode=QAbstractItemView.ExtendedSelection
+        )
         self.properties_editor = ParameterTree(self)
 
         tree.setHeaderHidden(True)
@@ -117,8 +136,7 @@ class ObjectTree(QWidget,ComponentMixin):
         tree.setContextMenuPolicy(Qt.ActionsContextMenu)
 
         # forward itemChanged singal
-        tree.itemChanged.connect(\
+        tree.itemChanged.connect(lambda item, col: self.sigItemChanged.emit(item, col))
-            lambda item,col: self.sigItemChanged.emit(item,col))
         # handle visibility changes form tree
         tree.itemChanged.connect(self.handleChecked)
 
@@ -131,30 +149,31 @@ class ObjectTree(QWidget,ComponentMixin):
 
         tree.expandToDepth(1)
 
-        self._export_STL_action = \
+        self._export_STL_action = QAction(
-            QAction('Export as STL',
+            "Export as STL",
             self,
             enabled=False,
-                    triggered=lambda: \
+            triggered=lambda: self.export("stl", self.preferences["STL precision"]),
-                        self.export('stl',
+        )
-                                    self.preferences['STL precision']))
 
-        self._export_STEP_action = \
+        self._export_STEP_action = QAction(
-            QAction('Export as STEP',
+            "Export as STEP", self, enabled=False, triggered=lambda: self.export("step")
+        )
+
+        self._clear_current_action = QAction(
+            icon("delete"),
+            "Clear current",
             self,
             enabled=False,
-                    triggered=lambda: \
+            triggered=self.removeSelected,
-                        self.export('step'))
+        )
 
-        self._clear_current_action = QAction(icon('delete'),
+        self._toolbar_actions = [
-                                             'Clear current',
+            QAction(
-                                             self,
+                icon("delete-many"), "Clear all", self, triggered=self.removeObjects
-                                             enabled=False,
+            ),
-                                             triggered=self.removeSelected)
+            self._clear_current_action,
-
+        ]
-        self._toolbar_actions = \
-            [QAction(icon('delete-many'),'Clear all',self,triggered=self.removeObjects),
-             self._clear_current_action,]
 
         self.prepareMenu()
 
@@ -163,87 +182,78 @@ class ObjectTree(QWidget,ComponentMixin):
 
         self.prepareLayout()
 
-
     def prepareMenu(self):
-
         self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
 
         self._context_menu = QMenu(self)
         self._context_menu.addActions(self._toolbar_actions)
-        self._context_menu.addActions((self._export_STL_action,
+        self._context_menu.addActions(
-                                       self._export_STEP_action))
+            (self._export_STL_action, self._export_STEP_action)
+        )
 
     def prepareLayout(self):
-
+        self._splitter = splitter(
-        self._splitter = splitter((self.tree,self.properties_editor),
+            (self.tree, self.properties_editor),
             stretch_factors=(2, 1),
-                                  orientation=Qt.Vertical)
+            orientation=Qt.Vertical,
+        )
         layout(self, (self._splitter,), top_widget=self)
 
         self._splitter.show()
 
     def showMenu(self, position):
-
         self._context_menu.exec_(self.tree.viewport().mapToGlobal(position))
 
-
     def menuActions(self):
-
+        return {"Tools": [self._export_STL_action, self._export_STEP_action]}
-        return {'Tools' : [self._export_STL_action,
-                           self._export_STEP_action]}
 
     def toolbarActions(self):
-
         return self._toolbar_actions
 
     def addLines(self):
-
         origin = (0, 0, 0)
         ais_list = []
 
-        for name,color,direction in zip(('X','Y','Z'),
+        for name, color, direction in zip(
-                                        ('red','lawngreen','blue'),
+            ("X", "Y", "Z"),
-                                        ((1,0,0),(0,1,0),(0,0,1))):
+            ((0.2, 0, 0), "lawngreen", "blue"),
-            line_placement = Geom_Line(gp_Ax1(gp_Pnt(*origin),
+            ((1, 0, 0), (0, 1, 0), (0, 0, 1)),
-                                       gp_Dir(*direction)))
+        ):
+            line_placement = Geom_Line(gp_Ax1(gp_Pnt(*origin), gp_Dir(*direction)))
             line = AIS_Line(line_placement)
             line.SetColor(to_occ_color(color))
 
-            self.Helpers.addChild(ObjectTreeItem(name,
+            self.Helpers.addChild(ObjectTreeItem(name, ais=line))
-                                                 ais=line))
 
             ais_list.append(line)
 
         self.sigObjectsAdded.emit(ais_list)
 
     def _current_properties(self):
-
         current_params = {}
         for i in range(self.CQ.childCount()):
             child = self.CQ.child(i)
-            current_params[child.properties['Name']] = child.properties
+            current_params[child.properties["Name"]] = child.properties
 
         return current_params
 
     def _restore_properties(self, obj, properties):
-
+        for p in properties[obj.properties["Name"]]:
-        for p in properties[obj.properties['Name']]:
             obj.properties[p.name()] = p.value()
 
     @pyqtSlot(dict, bool)
     @pyqtSlot(dict)
     def addObjects(self, objects, clean=False, root=None):
-
         if root is None:
             root = self.CQ
 
         request_fit_view = True if root.childCount() == 0 else False
-        preserve_props = self.preferences['Preserve properties on reload']
+        preserve_props = self.preferences["Preserve properties on reload"]
 
         if preserve_props:
             current_props = self._current_properties()
 
-        if clean or self.preferences['Clear all before each run']:
+        if clean or self.preferences["Clear all before each run"]:
             self.removeObjects()
 
         ais_list = []
@@ -254,16 +264,18 @@ class ObjectTree(QWidget,ComponentMixin):
         for name, obj in objects_f.items():
             ais, shape_display = make_AIS(obj.shape, obj.options)
 
-            child = ObjectTreeItem(name,
+            child = ObjectTreeItem(
+                name,
                 shape=obj.shape,
                 shape_display=shape_display,
                 ais=ais,
-                                   sig=self.sigObjectPropertiesChanged)
+                sig=self.sigObjectPropertiesChanged,
+            )
 
             if preserve_props and name in current_props:
                 self._restore_properties(child, current_props)
 
-            if child.properties['Visible']:
+            if child.properties["Visible"]:
                 ais_list.append(ais)
 
             root.addChild(child)
@@ -274,24 +286,53 @@ class ObjectTree(QWidget,ComponentMixin):
             self.sigObjectsAdded[list].emit(ais_list)
 
     @pyqtSlot(object, str, object)
-    def addObject(self,obj,name='',options={}):
+    def addObject(
-
+        self,
+        obj,
+        name="",
+        options={},  # all following inputs are ignored by cq-editor
+        parent=1,
+        clear=True,
+        port=3939,
+        axes=False,
+        axes0=False,
+        grid=False,
+        ticks=10,
+        ortho=True,
+        transparent=False,
+        default_color=(232, 176, 36),
+        reset_camera=True,
+        zoom=1.0,
+        default_edgecolor=(128, 128, 128),
+        render_edges=True,
+        render_normals=False,
+        render_mates=False,
+        mate_scale=1.0,
+        deviation=0.1,
+        angular_tolerance=0.2,
+        edge_accuracy=5.0,
+        ambient_intensity=1.0,
+        direct_intensity=0.12,
+    ):
         root = self.CQ
 
         ais, shape_display = make_AIS(obj, options)
 
-        root.addChild(ObjectTreeItem(name,
+        root.addChild(
+            ObjectTreeItem(
+                name,
                 shape=obj,
                 shape_display=shape_display,
                 ais=ais,
-                                     sig=self.sigObjectPropertiesChanged))
+                sig=self.sigObjectPropertiesChanged,
+            )
+        )
 
         self.sigObjectsAdded.emit([ais])
 
     @pyqtSlot(list)
     @pyqtSlot()
     def removeObjects(self, objects=None):
-
         if objects:
             removed_items_ais = [self.CQ.takeChild(i).ais for i in objects]
         else:
@@ -301,7 +342,6 @@ class ObjectTree(QWidget,ComponentMixin):
 
     @pyqtSlot(bool)
     def stashObjects(self, action: bool):
-
         if action:
             self._stash = self.CQ.takeChildren()
             removed_items_ais = [ch.ais for ch in self._stash]
@@ -314,14 +354,12 @@ class ObjectTree(QWidget,ComponentMixin):
 
     @pyqtSlot()
     def removeSelected(self):
-
         ixs = self.tree.selectedIndexes()
         rows = [ix.row() for ix in ixs]
 
         self.removeObjects(rows)
 
     def export(self, export_type, precision=None):
-
         items = self.tree.selectedItems()
 
         # if CQ models is selected get all children
@@ -333,12 +371,11 @@ class ObjectTree(QWidget,ComponentMixin):
             shapes = [item.shape for item in items if item.parent() is self.CQ]
 
         fname = get_save_filename(export_type)
-        if fname != '':
+        if fname != "":
             export(shapes, export_type, fname, precision)
 
     @pyqtSlot()
     def handleSelection(self):
-
         items = self.tree.selectedItems()
         if len(items) == 0:
             self._export_STL_action.setEnabled(False)
@@ -356,8 +393,7 @@ class ObjectTree(QWidget,ComponentMixin):
             self._export_STEP_action.setEnabled(True)
             self._clear_current_action.setEnabled(True)
             self.sigCQObjectSelected.emit(item.shape)
-            self.properties_editor.setParameters(item.properties,
+            self.properties_editor.setParameters(item.properties, showTop=False)
-                                                 showTop=False)
             self.properties_editor.setEnabled(True)
         elif item is self.CQ and item.childCount() > 0:
             self._export_STL_action.setEnabled(True)
@@ -371,7 +407,6 @@ class ObjectTree(QWidget,ComponentMixin):
 
     @pyqtSlot(list)
     def handleGraphicalSelection(self, shapes):
-
         self.tree.clearSelection()
 
         CQ = self.CQ
@@ -383,9 +418,8 @@ class ObjectTree(QWidget,ComponentMixin):
 
     @pyqtSlot(QTreeWidgetItem, int)
     def handleChecked(self, item, col):
-
         if type(item) is ObjectTreeItem:
             if item.checkState(0):
-                item.properties['Visible'] = True
+                item.properties["Visible"] = True
             else:
-                item.properties['Visible'] = False
+                item.properties["Visible"] = False

cq_editor/widgets/occt_widget.py

@@ -1,8 +1,8 @@
 from sys import platform
 
 
-from PyQt5.QtWidgets import QWidget, QApplication
+from PySide6.QtWidgets import QWidget, QApplication
-from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QEvent
+from PySide6.QtCore import Slot as pyqtSlot, Signal as pyqtSignal, Qt, QEvent
 
 import OCP
 
@@ -10,18 +10,16 @@ from OCP.Aspect import Aspect_DisplayConnection, Aspect_TypeOfTriedronPosition
 from OCP.OpenGl import OpenGl_GraphicDriver
 from OCP.V3d import V3d_Viewer
 from OCP.AIS import AIS_InteractiveContext, AIS_DisplayMode
-from OCP.Quantity import Quantity_Color
+from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB as TOC_RGB
 
 
 ZOOM_STEP = 0.9
 
 
 class OCCTWidget(QWidget):
-    
     sigObjectSelected = pyqtSignal(list)
 
     def __init__(self, parent=None):
-        
         super(OCCTWidget, self).__init__(parent)
 
         self.setAttribute(Qt.WA_NativeWindow)
@@ -43,7 +41,6 @@ class OCCTWidget(QWidget):
         self.prepare_display()
 
     def prepare_display(self):
-        
         view = self.view
 
         params = view.ChangeRenderingParams()
@@ -51,8 +48,10 @@ class OCCTWidget(QWidget):
         params.IsAntialiasingEnabled = True
 
         view.TriedronDisplay(
-            Aspect_TypeOfTriedronPosition.Aspect_TOTP_RIGHT_LOWER,
+            Aspect_TypeOfTriedronPosition.Aspect_TOTP_RIGHT_LOWER, Quantity_Color(), 0.1
-            Quantity_Color(), 0.1)
+        )
+
+        view.ZBufferTriedronSetup(Quantity_Color(*(0.2, 0.0, 0.0), TOC_RGB))
 
         viewer = self.viewer
 
@@ -65,14 +64,12 @@ class OCCTWidget(QWidget):
         ctx.DefaultDrawer().SetFaceBoundaryDraw(True)
 
     def wheelEvent(self, event):
-        
         delta = event.angleDelta().y()
         factor = ZOOM_STEP if delta < 0 else 1 / ZOOM_STEP
 
         self.view.SetZoom(factor)
 
     def mousePressEvent(self, event):
-        
         pos = event.pos()
 
         if event.button() == Qt.LeftButton:
@@ -83,7 +80,6 @@ class OCCTWidget(QWidget):
         self.old_pos = pos
 
     def mouseMoveEvent(self, event):
-        
         pos = event.pos()
         x, y = pos.x(), pos.y()
 
@@ -91,17 +87,14 @@ class OCCTWidget(QWidget):
             self.view.Rotation(x, y)
 
         elif event.buttons() == Qt.MiddleButton:
-            self.view.Pan(x - self.old_pos.x(),
+            self.view.Pan(x - self.old_pos.x(), self.old_pos.y() - y, theToStart=True)
-                          self.old_pos.y() - y, theToStart=True)
 
         elif event.buttons() == Qt.RightButton:
-            self.view.Pan(x - self.old_pos.x(),
+            self.view.Pan(x - self.old_pos.x(), self.old_pos.y() - y, theToStart=True)
-                          self.old_pos.y() - y, theToStart=True)
 
         self.old_pos = pos
 
     def mouseReleaseEvent(self, event):
-        
         if event.button() == Qt.LeftButton:
             pos = event.pos()
             x, y = pos.x(), pos.y()
@@ -111,7 +104,6 @@ class OCCTWidget(QWidget):
             self._handle_selection()
 
     def _handle_selection(self):
-        
         self.context.Select(True)
         self.context.InitSelected()
 
@@ -122,32 +114,27 @@ class OCCTWidget(QWidget):
         self.sigObjectSelected.emit(selected)
 
     def paintEngine(self):
-    
         return None
 
     def paintEvent(self, event):
-        
         if not self._initialized:
             self._initialize()
         else:
             self.view.Redraw()
 
     def showEvent(self, event):
-    
         super(OCCTWidget, self).showEvent(event)
 
     def resizeEvent(self, event):
-        
         super(OCCTWidget, self).resizeEvent(event)
 
         self.view.MustBeResized()
 
     def _initialize(self):
-
         wins = {
-            'darwin' : self._get_window_osx,
+            "darwin": self._get_window_osx,
-            'linux'  : self._get_window_linux,
+            "linux": self._get_window_linux,
-            'win32': self._get_window_win           
+            "win32": self._get_window_win,
         }
 
         self.view.SetWindow(wins.get(platform, self._get_window_linux)(self.winId()))
@@ -155,19 +142,17 @@ class OCCTWidget(QWidget):
         self._initialized = True
 
     def _get_window_win(self, wid):
-    
         from OCP.WNT import WNT_Window
 
+        print(wid)
         return WNT_Window(wid.ascapsule())
 
     def _get_window_linux(self, wid):
-        
         from OCP.Xw import Xw_Window
 
         return Xw_Window(self.display_connection, int(wid))
 
     def _get_window_osx(self, wid):
-        
         from OCP.Cocoa import Cocoa_Window
 
         return Cocoa_Window(wid.ascapsule())

cq_editor/widgets/traceback_viewer.py

@@ -1,18 +1,17 @@
 from traceback import extract_tb, format_exception_only
 
-from PyQt5.QtWidgets import (QWidget, QTreeWidget, QTreeWidgetItem, QAction,
+from PySide6.QtWidgets import QWidget, QTreeWidget, QTreeWidgetItem, QLabel
-                             QLabel)
+from PySide6.QtGui import QAction
-from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
+from PySide6.QtCore import Qt, Slot as pyqtSlot, Signal as pyqtSignal
 
 from ..mixins import ComponentMixin
 from ..utils import layout
 
-class TracebackTree(QTreeWidget):
 
-    name = 'Traceback Viewer'
+class TracebackTree(QTreeWidget):
+    name = "Traceback Viewer"
 
     def __init__(self, parent):
-        
         super(TracebackTree, self).__init__(parent)
         self.setHeaderHidden(False)
         self.setItemsExpandable(False)
@@ -20,34 +19,27 @@ class TracebackTree(QTreeWidget):
         self.setContextMenuPolicy(Qt.ActionsContextMenu)
 
         self.setColumnCount(3)
-        self.setHeaderLabels(['File','Line','Code'])
+        self.setHeaderLabels(["File", "Line", "Code"])
-        
 
         self.root = self.invisibleRootItem()
 
-class TracebackPane(QWidget,ComponentMixin):
 
+class TracebackPane(QWidget, ComponentMixin):
     sigHighlightLine = pyqtSignal(int)
 
     def __init__(self, parent):
-        
         super(TracebackPane, self).__init__(parent)
 
         self.tree = TracebackTree(self)
         self.current_exception = QLabel(self)
-        self.current_exception.setStyleSheet(\
+        self.current_exception.setStyleSheet("QLabel {color : red; }")
-            "QLabel {color : red; }");
 
-        layout(self,
+        layout(self, (self.current_exception, self.tree), self)
-               (self.current_exception,
-                self.tree),
-               self)
 
         self.tree.currentItemChanged.connect(self.handleSelection)
 
     @pyqtSlot(object, str)
     def addTraceback(self, exc_info, code):
-        
         self.tree.clear()
 
         if exc_info:
@@ -55,43 +47,43 @@ class TracebackPane(QWidget,ComponentMixin):
 
             root = self.tree.root
             code = code.splitlines()
-            tb = [t for t in extract_tb(tb) if '<string>' in t.filename] #ignore highest frames (debug, exec)
+            tb = [
+                t for t in extract_tb(tb) if "<string>" in t.filename
+            ]  # ignore highest frames (debug, exec)
 
             for el in tb:
                 # workaround of the traceback module
-                if el.line == '':
+                if el.line == "":
                     line = code[el.lineno - 1].strip()
                 else:
                     line = el.line
 
-                root.addChild(QTreeWidgetItem([el.filename,
+                root.addChild(QTreeWidgetItem([el.filename, str(el.lineno), line]))
-                                               str(el.lineno),
-                                               line]))
 
             exc_name = t.__name__
             exc_msg = str(exc)
-            exc_msg = exc_msg.replace('<', '&lt;').replace('>', '&gt;') #replace <> 
+            exc_msg = exc_msg.replace("<", "&lt;").replace(">", "&gt;")  # replace <>
 
-            self.current_exception.\
+            self.current_exception.setText("<b>{}</b>: {}".format(exc_name, exc_msg))
-                setText('<b>{}</b>: {}'.format(exc_name,exc_msg))
 
             # handle the special case of a SyntaxError
             if t is SyntaxError:
-                root.addChild(QTreeWidgetItem(
+                root.addChild(
-                  [exc.filename,
+                    QTreeWidgetItem(
+                        [
+                            exc.filename,
                             str(exc.lineno),
-                   exc.text.strip() if exc.text else '']
+                            exc.text.strip() if exc.text else "",
-                ))
+                        ]
+                    )
+                )
         else:
-            self.current_exception.setText('')
+            self.current_exception.setText("")
 
     @pyqtSlot(QTreeWidgetItem, QTreeWidgetItem)
     def handleSelection(self, item, *args):
-        
         if item:
             f, line = item.data(0, 0), int(item.data(1, 0))
 
-            if '<string>' in f:
+            if "<string>" in f:
                 self.sigHighlightLine.emit(line)
-    
-        

cq_editor/widgets/viewer.py

@@ -1,14 +1,21 @@
-from PyQt5.QtWidgets import QWidget, QDialog, QTreeWidgetItem, QApplication, QAction
+from PySide6.QtWidgets import QWidget, QDialog, QTreeWidgetItem, QApplication
 
-from PyQt5.QtCore import pyqtSlot, pyqtSignal
+from PySide6.QtCore import Slot as pyqtSlot, Signal as pyqtSignal
-from PyQt5.QtGui import QIcon
+from PySide6.QtGui import QIcon, QAction
 
-from OCP.Graphic3d import Graphic3d_Camera, Graphic3d_StereoMode, Graphic3d_NOM_JADE,\
+from OCP.Graphic3d import (
-    Graphic3d_MaterialAspect
+    Graphic3d_Camera,
+    Graphic3d_StereoMode,
+    Graphic3d_NOM_JADE,
+    Graphic3d_MaterialAspect,
+)
 from OCP.AIS import AIS_Shaded, AIS_WireFrame, AIS_ColoredShape, AIS_Axis
 from OCP.Aspect import Aspect_GDM_Lines, Aspect_GT_Rectangular
-from OCP.Quantity import Quantity_NOC_BLACK as BLACK, Quantity_TOC_RGB as TOC_RGB,\
+from OCP.Quantity import (
-    Quantity_Color
+    Quantity_NOC_BLACK as BLACK,
+    Quantity_TOC_RGB as TOC_RGB,
+    Quantity_Color,
+)
 from OCP.Geom import Geom_Axis1Placement
 from OCP.gp import gp_Ax3, gp_Dir, gp_Pnt, gp_Ax1
 
@@ -25,29 +32,65 @@ import qtawesome as qta
 DEFAULT_EDGE_COLOR = Quantity_Color(BLACK)
 DEFAULT_EDGE_WIDTH = 2
 
+
 class OCCViewer(QWidget, ComponentMixin):
+    name = "3D Viewer"
 
-    name = '3D Viewer'
+    preferences = Parameter.create(
-
+        name="Pref",
-    preferences = Parameter.create(name='Pref',children=[
+        children=[
-        {'name': 'Fit automatically', 'type': 'bool', 'value': True},
+            {"name": "Fit automatically", "type": "bool", "value": True},
-        {'name': 'Use gradient', 'type': 'bool', 'value': False},
+            {"name": "Use gradient", "type": "bool", "value": False},
-        {'name': 'Background color', 'type': 'color', 'value': (95,95,95)},
+            {"name": "Background color", "type": "color", "value": (95, 95, 95)},
-        {'name': 'Background color (aux)', 'type': 'color', 'value': (30,30,30)},
+            {"name": "Background color (aux)", "type": "color", "value": (30, 30, 30)},
-        {'name': 'Default object color', 'type': 'color', 'value': "#FF0"},
+            {"name": "Default object color", "type": "color", "value": "#FF0"},
-        {'name': 'Deviation', 'type': 'float', 'value': 1e-5, 'dec': True, 'step': 1},
+            {
-        {'name': 'Angular deviation', 'type': 'float', 'value': 0.1, 'dec': True, 'step': 1},
+                "name": "Deviation",
-        {'name': 'Projection Type', 'type': 'list', 'value': 'Orthographic',
+                "type": "float",
-         'values': ['Orthographic', 'Perspective', 'Stereo', 'MonoLeftEye', 'MonoRightEye']},
+                "value": 1e-5,
-        {'name': 'Stereo Mode', 'type': 'list', 'value': 'QuadBuffer',
+                "dec": True,
-         'values': ['QuadBuffer', 'Anaglyph', 'RowInterlaced', 'ColumnInterlaced',
+                "step": 1,
-                    'ChessBoard', 'SideBySide', 'OverUnder']}])
+            },
-    IMAGE_EXTENSIONS = 'png'
+            {
+                "name": "Angular deviation",
+                "type": "float",
+                "value": 0.1,
+                "dec": True,
+                "step": 1,
+            },
+            {
+                "name": "Projection Type",
+                "type": "list",
+                "value": "Orthographic",
+                "values": [
+                    "Orthographic",
+                    "Perspective",
+                    "Stereo",
+                    "MonoLeftEye",
+                    "MonoRightEye",
+                ],
+            },
+            {
+                "name": "Stereo Mode",
+                "type": "list",
+                "value": "QuadBuffer",
+                "values": [
+                    "QuadBuffer",
+                    "Anaglyph",
+                    "RowInterlaced",
+                    "ColumnInterlaced",
+                    "ChessBoard",
+                    "SideBySide",
+                    "OverUnder",
+                ],
+            },
+        ],
+    )
+    IMAGE_EXTENSIONS = "png"
 
     sigObjectSelected = pyqtSignal(list)
 
     def __init__(self, parent=None):
-
         super(OCCViewer, self).__init__(parent)
         ComponentMixin.__init__(self)
 
@@ -56,15 +99,18 @@ class OCCViewer(QWidget,ComponentMixin):
 
         self.create_actions(self)
 
-        self.layout_ = layout(self,
+        self.layout_ = layout(
-                             [self.canvas,],
+            self,
+            [
+                self.canvas,
+            ],
             top_widget=self,
-                             margin=0)
+            margin=0,
+        )
         self.setup_default_drawer()  # misspelled in original
         self.updatePreferences()
 
     def setup_default_drawer(self):
-
         # set the default color and material
         material = Graphic3d_MaterialAspect(Graphic3d_NOM_JADE)
 
@@ -78,97 +124,127 @@ class OCCViewer(QWidget,ComponentMixin):
         line_aspect.SetColor(DEFAULT_EDGE_COLOR)
 
     def updatePreferences(self, *args):
+        color1 = to_occ_color(self.preferences["Background color"])
+        color2 = to_occ_color(self.preferences["Background color (aux)"])
 
-        color1 = to_occ_color(self.preferences['Background color'])
+        if not self.preferences["Use gradient"]:
-        color2 = to_occ_color(self.preferences['Background color (aux)'])
-
-        if not self.preferences['Use gradient']:
             color2 = color1
         self.canvas.view.SetBgGradientColors(color1, color2, theToUpdate=True)
 
         self.canvas.update()
 
         ctx = self.canvas.context
-        ctx.SetDeviationCoefficient(self.preferences['Deviation'])
+        ctx.SetDeviationCoefficient(self.preferences["Deviation"])
-        ctx.SetDeviationAngle(self.preferences['Angular deviation'])
+        ctx.SetDeviationAngle(self.preferences["Angular deviation"])
 
         v = self._get_view()
         camera = v.Camera()
-        projection_type = self.preferences['Projection Type']
+        projection_type = self.preferences["Projection Type"]
-        camera.SetProjectionType(getattr(Graphic3d_Camera, f'Projection_{projection_type}',
+        camera.SetProjectionType(
-                                         Graphic3d_Camera.Projection_Orthographic))
+            getattr(
+                Graphic3d_Camera,
+                f"Projection_{projection_type}",
+                Graphic3d_Camera.Projection_Orthographic,
+            )
+        )
 
         # onle relevant for stereo projection
-        stereo_mode = self.preferences['Stereo Mode']
+        stereo_mode = self.preferences["Stereo Mode"]
         params = v.ChangeRenderingParams()
-        params.StereoMode = getattr(Graphic3d_StereoMode, f'Graphic3d_StereoMode_{stereo_mode}',
+        params.StereoMode = getattr(
-                                    Graphic3d_StereoMode.Graphic3d_StereoMode_QuadBuffer)
+            Graphic3d_StereoMode,
+            f"Graphic3d_StereoMode_{stereo_mode}",
+            Graphic3d_StereoMode.Graphic3d_StereoMode_QuadBuffer,
+        )
 
     def create_actions(self, parent):
-
+        self._actions = {
-        self._actions =  \
+            "View": [
-                {'View' : [QAction(qta.icon('fa.arrows-alt'),
+                QAction(
-                                   'Fit (Shift+F1)',
+                    qta.icon("fa.arrows-alt"),
+                    "Fit (Shift+F1)",
                     parent,
-                                   shortcut='shift+F1',
+                    shortcut="shift+F1",
-                                   triggered=self.fit),
+                    triggered=self.fit,
-                          QAction(QIcon(':/images/icons/isometric_view.svg'),
+                ),
-                                  'Iso (Shift+F2)',
+                QAction(
+                    QIcon(":/images/icons/isometric_view.svg"),
+                    "Iso (Shift+F2)",
                     parent,
-                                  shortcut='shift+F2',
+                    shortcut="shift+F2",
-                                  triggered=self.iso_view),
+                    triggered=self.iso_view,
-                          QAction(QIcon(':/images/icons/top_view.svg'),
+                ),
-                                  'Top (Shift+F3)',
+                QAction(
+                    QIcon(":/images/icons/top_view.svg"),
+                    "Top (Shift+F3)",
                     parent,
-                                  shortcut='shift+F3',
+                    shortcut="shift+F3",
-                                  triggered=self.top_view),
+                    triggered=self.top_view,
-                          QAction(QIcon(':/images/icons/bottom_view.svg'),
+                ),
-                                  'Bottom (Shift+F4)',
+                QAction(
+                    QIcon(":/images/icons/bottom_view.svg"),
+                    "Bottom (Shift+F4)",
                     parent,
-                                  shortcut='shift+F4',
+                    shortcut="shift+F4",
-                                  triggered=self.bottom_view),
+                    triggered=self.bottom_view,
-                          QAction(QIcon(':/images/icons/front_view.svg'),
+                ),
-                                  'Front (Shift+F5)',
+                QAction(
+                    QIcon(":/images/icons/front_view.svg"),
+                    "Front (Shift+F5)",
                     parent,
-                                  shortcut='shift+F5',
+                    shortcut="shift+F5",
-                                  triggered=self.front_view),
+                    triggered=self.front_view,
-                          QAction(QIcon(':/images/icons/back_view.svg'),
+                ),
-                                  'Back (Shift+F6)',
+                QAction(
+                    QIcon(":/images/icons/back_view.svg"),
+                    "Back (Shift+F6)",
                     parent,
-                                  shortcut='shift+F6',
+                    shortcut="shift+F6",
-                                  triggered=self.back_view),
+                    triggered=self.back_view,
-                          QAction(QIcon(':/images/icons/left_side_view.svg'),
+                ),
-                                  'Left (Shift+F7)',
+                QAction(
+                    QIcon(":/images/icons/left_side_view.svg"),
+                    "Left (Shift+F7)",
                     parent,
-                                  shortcut='shift+F7',
+                    shortcut="shift+F7",
-                                  triggered=self.left_view),
+                    triggered=self.left_view,
-                          QAction(QIcon(':/images/icons/right_side_view.svg'),
+                ),
-                                  'Right (Shift+F8)',
+                QAction(
+                    QIcon(":/images/icons/right_side_view.svg"),
+                    "Right (Shift+F8)",
                     parent,
-                                  shortcut='shift+F8',
+                    shortcut="shift+F8",
-                                  triggered=self.right_view),
+                    triggered=self.right_view,
-                          QAction(qta.icon('fa.square-o'),
+                ),
-                                  'Wireframe (Shift+F9)',
+                QAction(
+                    qta.icon("fa.square-o"),
+                    "Wireframe (Shift+F9)",
                     parent,
-                                  shortcut='shift+F9',
+                    shortcut="shift+F9",
-                                  triggered=self.wireframe_view),
+                    triggered=self.wireframe_view,
-                                  QAction(qta.icon('fa.square'),
+                ),
-                                          'Shaded (Shift+F10)',
+                QAction(
+                    qta.icon("fa.square"),
+                    "Shaded (Shift+F10)",
                     parent,
-                                          shortcut='shift+F10',
+                    shortcut="shift+F10",
-                                          triggered=self.shaded_view)],
+                    triggered=self.shaded_view,
-                 'Tools' : [QAction(icon('screenshot'),
+                ),
-                                   'Screenshot',
+            ],
+            "Tools": [
+                QAction(
+                    icon("screenshot"),
+                    "Screenshot",
                     parent,
-                                   triggered=self.save_screenshot)]}
+                    triggered=self.save_screenshot,
+                )
+            ],
+        }
 
     def toolbarActions(self):
-
+        return self._actions["View"]
-        return self._actions['View']
-
 
     def clear(self):
-
         self.displayed_shapes = []
         self.displayed_ais = []
         self.canvas.context.EraseAll(True)
@@ -177,7 +253,6 @@ class OCCViewer(QWidget,ComponentMixin):
         context.RemoveAll(True)
 
     def _display(self, shape):
-
         ais = make_AIS(shape)
         self.canvas.context.Display(shape, True)
 
@@ -188,28 +263,26 @@ class OCCViewer(QWidget,ComponentMixin):
 
     @pyqtSlot(object)
     def display(self, ais):
-
         context = self._get_context()
         context.Display(ais, True)
 
-        if self.preferences['Fit automatically']: self.fit()
+        if self.preferences["Fit automatically"]:
+            self.fit()
 
     @pyqtSlot(list)
     @pyqtSlot(list, bool)
     def display_many(self, ais_list, fit=None):
-
         context = self._get_context()
         for ais in ais_list:
             context.Display(ais, True)
 
-        if self.preferences['Fit automatically'] and fit is None:
+        if self.preferences["Fit automatically"] and fit is None:
             self.fit()
         elif fit:
             self.fit()
 
     @pyqtSlot(QTreeWidgetItem, int)
     def update_item(self, item, col):
-
         ctx = self._get_context()
         if item.checkState(0):
             ctx.Display(item.ais, True)
@@ -218,97 +291,79 @@ class OCCViewer(QWidget,ComponentMixin):
 
     @pyqtSlot(list)
     def remove_items(self, ais_items):
-
         ctx = self._get_context()
-        for ais in ais_items: ctx.Erase(ais,True)
+        for ais in ais_items:
+            ctx.Erase(ais, True)
 
     @pyqtSlot()
     def redraw(self):
-
         self._get_viewer().Redraw()
 
     def fit(self):
-
         self.canvas.view.FitAll()
 
     def iso_view(self):
-
         v = self._get_view()
         v.SetProj(1, -1, 1)
         v.SetTwist(0)
 
     def bottom_view(self):
-
         v = self._get_view()
         v.SetProj(0, 0, -1)
         v.SetTwist(0)
 
     def top_view(self):
-
         v = self._get_view()
         v.SetProj(0, 0, 1)
         v.SetTwist(0)
 
     def front_view(self):
-
-        v = self._get_view()
-        v.SetProj(0,1,0)
-        v.SetTwist(0)
-
-    def back_view(self):
-
         v = self._get_view()
         v.SetProj(0, -1, 0)
         v.SetTwist(0)
 
-    def left_view(self):
+    def back_view(self):
+        v = self._get_view()
+        v.SetProj(0, 1, 0)
+        v.SetTwist(0)
 
+    def left_view(self):
         v = self._get_view()
         v.SetProj(-1, 0, 0)
         v.SetTwist(0)
 
     def right_view(self):
-
         v = self._get_view()
         v.SetProj(1, 0, 0)
         v.SetTwist(0)
 
     def shaded_view(self):
-
         c = self._get_context()
         c.SetDisplayMode(AIS_Shaded, True)
 
     def wireframe_view(self):
-
         c = self._get_context()
         c.SetDisplayMode(AIS_WireFrame, True)
 
-    def show_grid(self,
+    def show_grid(
-                  step=1.,
+        self, step=1.0, size=10.0 + 1e-6, color1=(0.7, 0.7, 0.7), color2=(0, 0, 0)
-                  size=10.+1e-6,
+    ):
-                  color1=(.7,.7,.7),
-                  color2=(0,0,0)):
-
         viewer = self._get_viewer()
-        viewer.ActivateGrid(Aspect_GT_Rectangular,
+        viewer.ActivateGrid(Aspect_GT_Rectangular, Aspect_GDM_Lines)
-                            Aspect_GDM_Lines)
         viewer.SetRectangularGridGraphicValues(size, size, 0)
         viewer.SetRectangularGridValues(0, 0, step, step, 0)
         grid = viewer.Grid()
-        grid.SetColors(Quantity_Color(*color1,TOC_RGB),
+        grid.SetColors(
-                       Quantity_Color(*color2,TOC_RGB))
+            Quantity_Color(*color1, TOC_RGB), Quantity_Color(*color2, TOC_RGB)
+        )
 
     def hide_grid(self):
-
         viewer = self._get_viewer()
         viewer.DeactivateGrid()
 
     @pyqtSlot(bool, float)
     @pyqtSlot(bool)
-    def toggle_grid(self,
+    def toggle_grid(self, value: bool, dim: float = 10.0):
-                    value : bool,
-                    dim : float = 10.):
-
         if value:
             self.show_grid(step=dim / 20, size=dim + 1e-9)
         else:
@@ -316,48 +371,37 @@ class OCCViewer(QWidget,ComponentMixin):
 
     @pyqtSlot(gp_Ax3)
     def set_grid_orientation(self, orientation: gp_Ax3):
-
         viewer = self._get_viewer()
         viewer.SetPrivilegedPlane(orientation)
 
     def show_axis(self, origin=(0, 0, 0), direction=(0, 0, 1)):
-
+        ax_placement = Geom_Axis1Placement(gp_Ax1(gp_Pnt(*origin), gp_Dir(*direction)))
-        ax_placement = Geom_Axis1Placement(gp_Ax1(gp_Pnt(*origin),
-                                                  gp_Dir(*direction)))
         ax = AIS_Axis(ax_placement)
         self._display_ais(ax)
 
     def save_screenshot(self):
-
         fname = get_save_filename(self.IMAGE_EXTENSIONS)
-        if fname != '':
+        if fname != "":
             self._get_view().Dump(fname)
 
     def _display_ais(self, ais):
-
         self._get_context().Display(ais)
 
-
     def _get_view(self):
-
         return self.canvas.view
 
     def _get_viewer(self):
-
         return self.canvas.viewer
 
     def _get_context(self):
-
         return self.canvas.context
 
     @pyqtSlot(list)
     def handle_selection(self, obj):
-
         self.sigObjectSelected.emit(obj)
 
     @pyqtSlot(list)
     def set_selected(self, ais):
-
         ctx = self._get_context()
         ctx.ClearSelected(False)
 
@@ -368,7 +412,7 @@ class OCCViewer(QWidget,ComponentMixin):
 
 
 if __name__ == "__main__":
-
+    # pass
     import sys
     from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox
 

environment.yml

@@ -3,4 +3,4 @@ channels:
   - conda-forge
   - defaults
 dependencies:
-  - python=3.9
+  - python=3.10

pyinstaller_pip.spec

@@ -13,13 +13,13 @@ cq_path = Path(site.getsitepackages()[-1]) / 'cadquery'
 
 if sys.platform == 'linux':
     occt_dir = os.path.join(Path(sys.prefix), 'share', 'opencascade')
-    ocp_path = [(os.path.join(HOMEPATH, 'OCP.cpython-39-x86_64-linux-gnu.so'), '.')]
+    ocp_path = [(os.path.join(HOMEPATH, 'OCP.cpython-310-x86_64-linux-gnu.so'), '.')]
 elif sys.platform == 'darwin':
     occt_dir = os.path.join(Path(sys.prefix), 'share', 'opencascade')
-    ocp_path = [(os.path.join(HOMEPATH, 'OCP.cpython-39-darwin.so'), '.')]
+    ocp_path = [(os.path.join(HOMEPATH, 'OCP.cpython-310-darwin.so'), '.')]
 elif sys.platform == 'win32':
     occt_dir = os.path.join(Path(sys.prefix), 'Library', 'share', 'opencascade')
-    ocp_path = [(os.path.join(HOMEPATH, 'OCP.cp39-win_amd64.pyd'), '.')]
+    ocp_path = [(os.path.join(HOMEPATH, 'OCP.cp310-win_amd64.pyd'), '.')]
 
 datas1, binaries1, hiddenimports1 = collect_all('debugpy')
 hiddenimports2 = collect_submodules('xmlrpc')
@@ -50,13 +50,13 @@ a = Analysis(['run.py'],
 
 # There is an issue that keeps the OpenSSL libraries from being copied to the output directory.
 # This should work if nothing else, but does not with GitHub Actions
-if sys.platform == 'win32':
+# if sys.platform == 'win32':
-    from PyInstaller.depend.bindepend import getfullnameof
+#     from PyInstaller.depend.bindepend import getfullnameof
-    rel_data_path = ['PyQt5', 'Qt', 'bin']
+#     rel_data_path = ['PyQt5', 'Qt', 'bin']
-    a.datas += [
+#     a.datas += [
-        (getfullnameof('libssl-1_1-x64.dll'), os.path.join(*rel_data_path), 'DATA'),
+#         (getfullnameof('libssl-1_1-x64.dll'), os.path.join(*rel_data_path), 'DATA'),
-        (getfullnameof('libcrypto-1_1-x64.dll'), os.path.join(*rel_data_path), 'DATA'),
+#         (getfullnameof('libcrypto-1_1-x64.dll'), os.path.join(*rel_data_path), 'DATA'),
-    ]
+#     ]
 
 
 pyz = PYZ(a.pure, a.zipped_data,

setup.py

@@ -26,15 +26,14 @@ setup(
             "CQ-editor = cq_editor.__main__:main",
         ]
     },
-    python_requires=">=3.8,<3.11",
+    python_requires=">=3.8,<3.12",
     install_requires=[
         "logbook>=1",
-        "ipython==8.4.0",
+        "ipython",
-        "jedi==0.17.2",
         "path>=16",
-        "PyQt5>=5",
+        "PySide6",
         "requests>=2,<3",
         "spyder>=5,<6",
-        "pyqtgraph==0.12.4",
+        "pyqtgraph",
     ],
 )