FEAT: Update extension handling (#6758)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: pyansys-ci-bot <[email protected]>

Author: 3 people

doc/changelog.d/6758.added.md

@@ -0,0 +1 @@
+Update extension handling

src/ansys/aedt/core/extensions/customize_automation_tab.py

@@ -142,17 +142,10 @@ def add_automation_tab(
             icon_file = Path(ansys.aedt.core.extensions.__file__).parent / "images" / "large" / "pyansys.png"
         else:
             icon_file = Path(icon_file)
-        file_name = icon_file.name
-        dest_dir = lib_dir / product / toolkit_name / "images" / "large"
-        dest_file = dest_dir / file_name
-        dest_dir.parent.mkdir(parents=True, exist_ok=True)
-        dest_dir.mkdir(parents=True, exist_ok=True)
-        shutil.copy(str(icon_file), str(dest_file))
-        relative_image_path = dest_file.relative_to(lib_dir / product)
         button_kwargs = dict(
             label=name,
             isLarge="1",
-            image=str(relative_image_path.as_posix()),
+            image=str(icon_file.as_posix()),
             script=f"{toolkit_name}/{template}",
         )
     ET.SubElement(panel_element, "button", **button_kwargs)
@@ -404,8 +397,13 @@ def add_script_to_menu(
         build_file_data = build_file_data.replace("##JUPYTER_EXE##", str(jupyter_executable))
         build_file_data = build_file_data.replace("##TOOLKIT_NAME##", str(name))
         build_file_data = build_file_data.replace("##EXTENSION_TEMPLATES##", str(templates_dir))
-        if dest_script_path:
-            build_file_data = build_file_data.replace("##PYTHON_SCRIPT##", str(dest_script_path))
+        if copy_to_personal_lib and dest_script_path:
+            extension_dir = dest_script_path.parent
+        else:
+            extension_dir = Path(ansys.aedt.core.extensions.__file__).parent / "installer"
+        build_file_data = build_file_data.replace("##BASE_EXTENSION_LOCATION##", str(extension_dir))
+        if script_file:
+            build_file_data = build_file_data.replace("##PYTHON_SCRIPT##", str(os.path.basename(script_file)))
         if version_agnostic:
             build_file_data = build_file_data.replace(" % version", "")
         with open(tool_dir / (template_file + ".py"), "w") as out_file:

src/ansys/aedt/core/extensions/installer/extension_manager.py

@@ -637,7 +637,7 @@ def launch_extension(self, category: str, option: str):
         script_field = None
         option_label = option
         logger = logging.getLogger("Global")
-        if option not in self.toolkits.get(self.current_category, {}) and option != "Custom":
+        if option not in self.toolkits.get(self.current_category, {}) and option != "Custom": # pragma: no cover
             toolkit_dir = Path(self.desktop.personallib) / "Toolkits"
             xml_dir = toolkit_dir / self.current_category
             tabconfig_path = xml_dir / "TabConfig.xml"
@@ -673,21 +673,33 @@ def launch_extension(self, category: str, option: str):
                 return
         icon = EXTENSIONS_PATH / "images" / "large" / "pyansys.png"
         if is_custom and script_field is None:
-            add_script_to_menu(
-                name=option_label,
-                script_file=str(script_file),
-                product=category,
-                executable_interpreter=sys.executable,
-                personal_lib=self.desktop.personallib,
-                aedt_version=self.desktop.aedt_version_id,
-                copy_to_personal_lib=False,
-                icon_file=str(icon),
-                is_custom=is_custom
-            )
+            try:
+                add_script_to_menu(
+                    name=option_label,
+                    script_file=str(script_file),
+                    product=category,
+                    executable_interpreter=sys.executable,
+                    personal_lib=self.desktop.personallib,
+                    aedt_version=self.desktop.aedt_version_id,
+                    copy_to_personal_lib=True,
+                    icon_file=str(icon),
+                    is_custom=True,
+                )
+            except Exception as e:
+                self.desktop.logger.error(
+                    "Failed to install custom extension %s: %s",
+                    option_label,
+                    e,
+                )
+                messagebox.showerror("Error", f"Failed to pin custom extension: {e}")
+                return
+
             # Refresh the custom extensions
             self.load_extensions(category)
-            self.desktop.logger.info(f"Extension {option_label} pinned successfully. If the extension is not visible,"
-                                     f" create a new AEDT session or create a new project.")
+            self.desktop.logger.info(
+                "Extension %s pinned successfully. If the extension is not visible, create a new AEDT session or create a new project.",
+                option_label,
+            )
 
             # if hasattr(self.desktop, "odesktop"):
             #     self.desktop.odesktop.RefreshToolkitUI()
@@ -916,6 +928,30 @@ def pin_extension(self, category: str, option: str):
             icon = (
                 EXTENSIONS_PATH / "images" / "large" / "pyansys.png"
             )
+            # If the user selected a script, copy it into personal lib Toolkits/<product>/<option>/Lib
+            if not script_file:
+                self.desktop.logger.info("No script selected for custom extension. Aborting pin.")
+                return
+            try:
+                add_script_to_menu(
+                    name=option,
+                    script_file=str(script_file),
+                    product=category,
+                    executable_interpreter=sys.executable,
+                    personal_lib=self.desktop.personallib,
+                    aedt_version=self.desktop.aedt_version_id,
+                    copy_to_personal_lib=True,
+                    icon_file=str(icon),
+                    is_custom=True,
+                )
+                msg = (f"Extension {option} pinned successfully.\n"
+                       f"If the extension is not visible create a new AEDT session or create a new project.")
+                self.desktop.logger.info(msg)
+                self.log_message(msg)
+            except Exception as e:
+                self.desktop.logger.error(f"Failed to pin custom extension {option}: {e}")
+                messagebox.showerror("Error", f"Failed to pin custom extension: {e}")
+                return
         else:
             if self.toolkits[self.current_category][option].get("script", None):
                 script_file = (
@@ -1293,7 +1329,7 @@ def check_extension_pinned(self, category: str, option: str):
         bool
             True if the extension is pinned, False otherwise.
         """
-        if option.lower() == "custom":
+        if option.lower() == "custom": # pragma: no cover
             return False  # Custom extensions are not tracked
 
         try:
@@ -1340,11 +1376,11 @@ def launch_web_url(self, category: str, option: str):
     def check_for_pyaedt_update_on_startup(self):
         """Spawn a background thread to check PyPI for a newer PyAEDT release.
         """
-        def worker():
+        def worker(): # pragma: no cover
             log = logging.getLogger("Global")
             try:
                 latest, declined_file = check_for_pyaedt_update(self.desktop.personallib)
-                if not latest: # pragma: no cover
+                if not latest:
                     log.debug("PyAEDT update check: no prompt required or latest unavailable.")
                     return
                 try:
@@ -1354,7 +1390,7 @@ def worker():
                     )
                 except Exception:
                     log.debug("PyAEDT update check: failed to schedule popup.", exc_info=True)
-            except Exception: # pragma: no cover
+            except Exception:
                 log.debug("PyAEDT update check: worker failed.", exc_info=True)
 
         threading.Thread(target=worker, daemon=True).start()
@@ -1423,11 +1459,12 @@ def open_changelog():
 
             def decline():
                 try:
-                    declined_file_path.parent.mkdir(
-                        parents=True, exist_ok=True
+                    from ansys.aedt.core.extensions.misc import (
+                        decline_pyaedt_update,
                     )
-                    declined_file_path.write_text(
-                        latest_version, encoding="utf-8"
+
+                    decline_pyaedt_update(
+                        declined_file_path, latest_version
                     )
                 except Exception:
                     logging.getLogger("Global").debug(

src/ansys/aedt/core/extensions/installer/pyaedt_installer.py

@@ -89,7 +89,7 @@ def __add_pyaedt_tabs(personal_lib, aedt_version, skip_version_manager):
                 template_name,
                 icon_file=icon_file,
                 product="Project",
-                copy_to_personal_lib=True,
+                copy_to_personal_lib=False,
                 executable_interpreter=None,
                 panel="Panel_PyAEDT_Installer",
                 personal_lib=personal_lib,

src/ansys/aedt/core/extensions/misc.py

@@ -118,7 +118,9 @@ def compare_versions(local: str, remote: str) -> bool:
 
         def to_tuple(v: str):
             out = []
-            for token in v.split("."):
+            # Remove dev/rc suffixes and split by dots
+            version_clean = v.split("dev")[0].split("rc")[0]
+            for token in version_clean.split("."):
                 try:
                     out.append(int(token))
                 except Exception:  # pragma: no cover
@@ -130,8 +132,49 @@ def to_tuple(v: str):
         except Exception:  # pragma: no cover
             return False
 
+    def read_version_file(file_path: Path) -> Tuple[Optional[str], bool]:
+        """Read version file and return (last_known_version, show_updates).
+
+        File format:
+        Line 1: last known version
+        Line 2: show_updates preference ("true" or "false")
+        """
+        if not file_path.is_file():
+            return None, True  # First start - don't show popup
+
+        try:
+            content = file_path.read_text(encoding="utf-8").strip()
+            lines = content.split("\n")
+            if len(lines) >= 2:
+                last_version = lines[0].strip()
+                show_updates = lines[1].strip().lower() == "true"
+                return last_version, show_updates
+            elif len(lines) == 1:
+                # Legacy format - only version, assume user wants updates
+                return lines[0].strip(), True
+            else:  # pragma: no cover
+                return None, True
+        except Exception:  # pragma: no cover
+            return None, True
+
+    def write_version_file(file_path: Path, version: str, show_updates: bool):
+        """Write version and preference to file."""
+        try:
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            content = f"{version}\n{str(show_updates).lower()}"
+            file_path.write_text(content, encoding="utf-8")
+        except Exception:  # pragma: no cover
+            log.debug("PyAEDT update check: failed to write version file.", exc_info=True)
+
     log = logging.getLogger("Global")
 
+    # Get current PyAEDT version
+    try:
+        from ansys.aedt.core import __version__ as current_version
+    except ImportError:  # pragma: no cover
+        log.debug("PyAEDT update check: could not import version.")
+        return None, None
+
     latest = get_latest_version("pyaedt")
     if not latest or latest == "Unknown":
         log.debug("PyAEDT update check: latest version unavailable.")
@@ -144,20 +187,36 @@ def to_tuple(v: str):
         log.debug("PyAEDT update check: personal lib path not found.", exc_info=True)
         return None, None
 
-    declined_file = toolkit_dir / ".pyaedt_version"
-    declined_version = None
-    if declined_file.is_file():
-        try:
-            declined_version = declined_file.read_text(encoding="utf-8").strip()
-        except Exception:  # pragma: no cover
-            declined_version = None
+    version_file = toolkit_dir / ".pyaedt_version"
+    last_known_version, show_updates = read_version_file(version_file)
+
+    # If this is first start (no file exists), record the latest known release
+    # (not the installed version) so we won't prompt until a newer release appears.
+    if last_known_version is None:
+        write_version_file(version_file, latest, False)
+        log.debug("PyAEDT update check: first start, recording latest release.")
+        return None, None
+
+    # If the user already has the latest version installed, never show the popup.
+    if current_version == latest:  # pragma: no cover
+        if last_known_version != latest:
+            write_version_file(version_file, latest, False)
+        return None, None
+
+    # Check if there's a newer version available compared to installed package
+    has_newer_version = compare_versions(current_version, latest)
 
-    prompt_user = declined_version is None or compare_versions(declined_version, latest)
+    if not has_newer_version:
+        if last_known_version != latest:
+            write_version_file(version_file, latest, show_updates)
+        return None, None
+    version_changed = compare_versions(last_known_version, latest)
+    prompt_user = show_updates or version_changed
 
     if not prompt_user:
         return None, None
 
-    return latest, declined_file
+    return latest, version_file
 
 
 @dataclass
@@ -1043,3 +1102,15 @@ def hide_tooltip(self):  # pragma: no cover
         self.tipwindow = None
         if tw:
             tw.destroy()
+
+
+def decline_pyaedt_update(declined_file_path: Path, latest_version: str):
+    """Record that the user declined the update notification."""
+    try:
+        declined_file_path.parent.mkdir(parents=True, exist_ok=True)
+        if latest_version is None:
+            return
+        content = f"{latest_version}\nfalse"
+        declined_file_path.write_text(content, encoding="utf-8")
+    except Exception:  # pragma: no cover
+        logging.getLogger("Global").debug("Failed to write declined update file", exc_info=True)

src/ansys/aedt/core/extensions/templates/jupyter.py_build

@@ -48,13 +48,12 @@ def main():
     proj_dir = oDesktop.GetProjectDirectory()
     os.chdir(proj_dir)
     # Extension directory
-    current_dir = os.path.dirname(os.path.abspath(os.path.realpath(__file__)))
-    pyaedt_toolkit_dir = os.path.normpath(os.path.join(current_dir, r"##TOOLKIT_REL_LIB_DIR##"))
+    base_extensions_loc = r"##BASE_EXTENSION_LOCATION##"
     # Jupyter interpreter
     jupyter_exe = r"##JUPYTER_EXE##" % version
     # Check if Jupyter version and AEDT release match
     python_exe = pyaedt_utils.sanitize_interpreter_path(jupyter_exe, version_short)
-    template = os.path.join(pyaedt_toolkit_dir, "jupyter_template.ipynb")
+    template = os.path.join(base_extensions_loc, "jupyter_template.ipynb")
     target = os.path.join(proj_dir, pyaedt_utils.generate_unique_name("pyaedt", ".ipynb", n=3))
     # Check executable
     jupyter_exe_flag = pyaedt_utils.check_file(jupyter_exe, oDesktop)
@@ -86,7 +85,7 @@ def main():
         subprocess.Popen(command)
     else:
         if notebook_dir:
-            command = ['"{}"'.format(jupyter_exe), "lab", '"{}"'.format(target),"--notebook-dir",'"{0}"'.format(notebook_dir)]
+            command = ['"{}"'.format(jupyter_exe), "lab", '"{}"'.format(target), "--notebook-dir", '"{0}"'.format(notebook_dir)]
         else:
             command = ['"{}"'.format(jupyter_exe), "lab", '"{}"'.format(target)]
         subprocess.Popen(" ".join(command))

src/ansys/aedt/core/extensions/templates/pyaedt_console.py_build

@@ -45,15 +45,14 @@ import pyaedt_utils
 def main():
     # Get AEDT version
     version_short = oDesktop.GetVersion()[2:6].replace(".", "")
-    # Extension directory
-    current_dir = os.path.dirname(os.path.abspath(os.path.realpath(__file__)))
-    pyaedt_toolkit_dir = os.path.normpath(os.path.join(current_dir, r"##TOOLKIT_REL_LIB_DIR##"))
+    # Base extensions location
+    base_extensions_loc = r"##BASE_EXTENSION_LOCATION##"
     # CPython interpreter
     python_exe = r"##IPYTHON_EXE##" % version
     # Check if CPython interpreter and AEDT release match
     python_exe = pyaedt_utils.sanitize_interpreter_path(python_exe, version_short)
     # Console launcher
-    pyaedt_script = os.path.join(pyaedt_toolkit_dir, "console_setup.py")
+    pyaedt_script = os.path.normpath(os.path.join(base_extensions_loc, "console_setup.py"))
     # Check python executable
     python_exe_flag = pyaedt_utils.check_file(python_exe, oDesktop)
     if not python_exe_flag:
@@ -70,22 +69,10 @@ def main():
         if not command:
             pyaedt_utils.show_error("No terminal found on system.", oDesktop)
         pyaedt_utils.set_ansys_em_environment(oDesktop)
-        command.extend([
-            python_exe,
-            "-i",
-            pyaedt_script,
-            str(oDesktop.GetProcessID()),
-            str(oDesktop.GetVersion()[:6]),
-        ])
+        command.extend([python_exe, "-i", pyaedt_script, str(oDesktop.GetProcessID()), str(oDesktop.GetVersion()[:6])])
         subprocess.Popen(command)
     else:
-        command = [
-            '"{}"'.format(python_exe),
-            "-i",
-            '"{}"'.format(pyaedt_script),
-            str(oDesktop.GetProcessID()),
-            str(oDesktop.GetVersion()[:6]),
-        ]
+        command = ['"{}"'.format(python_exe), "-i", '"{}"'.format(pyaedt_script), str(oDesktop.GetProcessID()), str(oDesktop.GetVersion()[:6])]
         subprocess.Popen(" ".join(command))