Run Speos Labs As Admin (#173)

MarinVillalobos · web-flow · commit ba730a8300d3 · 2025-04-08T14:00:24.000+01:00
* RunAsAdmin

* RunAsAdmin
diff --git a/ansys_optical_automation/application/Run_Speos_Labs_Admin.py b/ansys_optical_automation/application/Run_Speos_Labs_Admin.py
@@ -0,0 +1,202 @@
+"""
+Requirements: administrative privileges.
+-----------------------------------------------------------------------
+This module launches with administrator privileges all executables in:
+`C:\\Program Files\\ANSYS Inc\\vXXX\\Optical Products\\Viewers`
+
+Many users lack administrative rights, so this module can be executed right after the installation
+while the user still has admin rights.
+
+Upon launching each application, the module registers the associated COM server used to call each application, 
+with the path to each executable appropriately registered.
+
+Class
+-----------------------------------------------------------------------
+2. **LabsAdmin**
+   - This class offers methods to open or close one or multiple applications simultaneously.
+   - By default, if no specific applications are specified, it will launch all applications found.
+
+"""
+
+import subprocess, os, time, sys
+# Get the absolute path to the scdm_core directory
+current_dir = os.path.dirname(os.path.abspath(__file__))
+scdm_core_path = os.path.join(current_dir, '..', 'scdm_core')
+# Add the scdm_core path to sys.path if it's not already there
+if scdm_core_path not in sys.path:
+    sys.path.append(scdm_core_path)
+# Try importing the function from utils
+try:
+    from utils import find_awp_root
+    print("get_scdm_install_location imported.")
+except ModuleNotFoundError as e:
+    print(f"Error: {e}")
+    print(f"sys.path: {sys.path}")
+
+# If pygetwindow is not installed, do it
+third_party_package = "pygetwindow"
+try: 
+    gw =  __import__(third_party_package)
+    print(f"{third_party_package} is already installed.")
+except ImportError:
+    print(f"{third_party_package} not found. Installing...")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", third_party_package])
+    import pygetwindow as gw
+
+
+import numpy as np
+
+class LabsAdmin:
+    '''
+    Class with methods to:
+    - Run one specific application.
+    - Kill one specific application.
+    - Run all applications as admin.
+    - Kill all applications.
+    - Run and Kill one application.
+    - Run and Kill all applications.
+    '''
+
+    def __init__(self, ThreeDigitCode=""):
+        """
+        Initializes the LabsAdmin class with a given ThreeDigitCode or derives it from the installation path.
+
+        Parameters
+        ----------
+        ThreeDigitCode : str, optional
+            A 3-digit version code (default is an empty string, which causes the code to be derived from the installation path).
+        Path_Installation_Root: str
+            Path to Ansys installation, format C:\Program Files\ANSYS Inc\v242.
+            Uses find_awp_root, imported from utils. If no ThreeDigitCode is given as input, the function will return
+            the latest installed Ansys installation path.
+        """
+        if not ThreeDigitCode:
+            self.Path_Installation_Root = find_awp_root(version="")
+            version_part = self.Path_Installation_Root.split("\\")[-1]
+            self.ThreeDigitCode = version_part[1:]
+        else:
+            self.ThreeDigitCode = ThreeDigitCode
+            self.Path_Installation_Root = find_awp_root(version=self.ThreeDigitCode)
+
+        if not self.Path_Installation_Root:
+            raise ValueError(f"AWP_ROOT path for version {self.ThreeDigitCode} not found.")
+
+    def RunSingleApp(self, exe_name):
+        """
+        Runs a single application as an administrator.
+
+        Parameters
+        ----------
+        exe_name : str
+            The name of the executable to run.
+        """
+        exe_path = os.path.join(self.Path_Installation_Root, 'Optical Products', 'Viewers', exe_name)
+        print("Application Executed: " + exe_path)
+        subprocess.Popen(["powershell", "-Command", f"Start-Process '{exe_path}' -Verb RunAs"])
+
+    def RunAll(self):
+        """
+        Runs all applications as administrators.
+        """
+        print("\n\n#### Run all Viewer as admin STARTED: \n")
+        Dictionary_Labs = self.Applications()
+        for App in Dictionary_Labs.keys():
+            self.RunSingleApp(App)
+
+    def Applications(self):
+        """
+        Returns a dictionary of applications with the names of the applications to run as key, and the title visible
+        for each application after running the viewer without input files, as items.
+
+        Returns
+        -------
+        dict
+            A dictionary where the keys are executable names and the values are titles.
+        """
+        if len(self.ThreeDigitCode) != 3:
+            raise ValueError("\n\nThe code must be of 3 characters long to derive the version.")
+        self.Version = "20" + self.ThreeDigitCode[0] + self.ThreeDigitCode[1] + " R" + self.ThreeDigitCode[2]
+        self.Labs_Applications = {
+            "XmpViewer.exe": "Speos " + self.Version + " - Extended map [No Name]",
+            "VRLab.exe": "Speos " + self.Version + " - Empty view",
+            "Xm3Viewer.exe": "Speos " + self.Version + " - Virtual 3D Photometric Lab [No file loaded]",
+            "VisionLabViewer.exe": "Speos " + self.Version + " - Spectral map [No Name]",
+            "TextureMappingViewer.exe": "Texture Mapping Viewer",
+            "VMPViewer.exe": "Speos " + self.Version + " - 3D Energy Density Lab [No Name]",
+            "SimpleScatteringViewer.exe": "Speos " + self.Version + " - Scattering surface [No Name]",
+            "VPLab.exe": "Speos " + self.Version + " - Photometric Calc",
+            "SPEOSCore.exe": "Speos Core " + self.Version,
+            "SpectrumViewer.exe": "Speos " + self.Version + " - Spectrum [No Name]",
+            "RoughMirrorViewer.exe": "Speos " + self.Version + " - Mirror surface [No Name]",
+            "FluorescentSurfaceViewer.exe": "Speos " + self.Version + " - Fluorescent surface [No Name]",
+            "BSDF_BRDF_Anisotropic_Viewer.exe": "Speos " + self.Version + " - Bsdf surface [No Name]",
+            "PolarizerSurfaceEditor.exe": "Speos " + self.Version + " - Polarizer surface [No Name]",
+            "RetroReflectingSurfaceViewer.exe": "Speos " + self.Version + " - Retro-reflecting surface [No Name]",
+            "IESViewer.exe": "Speos " + self.Version + " - Iesna LM-63 []",
+            "CoatedSurfaceViewer.exe": "Speos " + self.Version + " - Coated surface [No Name]",
+            "EulumdatViewer.exe": "Speos " + self.Version + " - Eulumdat [No Name]",
+            "VirtualLightingAnimation.exe": "Virtual Lighting Animation [BETA] " + self.Version,
+            "AdvancedScatteringViewer.exe": "Speos " + self.Version + " - Scattering surface (Advanced model) [No Name]",
+            "DoeSurfaceViewer.exe": "Speos " + self.Version + " - Thin lens surface [No Name]",
+            "GratingSurfaceViewer.exe": "Speos " + self.Version + " - Grating surface [No Name]",
+            "RayEditor.exe": "Speos " + self.Version + " -  [No Name]",
+            "UserMaterialViewer.exe": "Speos " + self.Version + " - User Material (Advanced Model) [No Name]"
+        }
+        return self.Labs_Applications
+
+    def KillApp(self, exe_name):
+        """
+        Kills a specific running application.
+
+        Parameters
+        ----------
+        exe_name : str
+            The name of the executable to kill.
+        """
+        Dictionary_Labs = self.Applications()
+        open_windows = gw.getAllTitles()
+        app_opened = False
+        Expected_title = Dictionary_Labs[exe_name]
+        while not app_opened:
+            open_windows = gw.getAllTitles()
+            for title in open_windows:
+                if Expected_title in title:
+                    app_opened = True
+                    print("Trying to find: " + exe_name)
+                    subprocess.run(["taskkill", "/f", "/im", exe_name])
+                    break
+            time.sleep(0.2)
+
+    def KillAll(self):
+        """
+        Kills all running applications.
+        """
+        Dictionary_Labs = self.Applications()
+        print("\n\n#### Kill all process: \n")
+        for App in Dictionary_Labs.keys():
+            self.KillApp(App)
+
+    def RunAndKillApp(self, exe_name):
+        """
+        Runs and then kills a specific application.
+
+        Parameters
+        ----------
+        exe_name : str
+            The name of the executable to run and kill.
+        """
+        self.RunSingleApp(exe_name)
+        self.KillApp(exe_name)
+
+    def RunAndKillAll(self):
+        """
+        Runs all applications and then kills all of them.
+        """
+        self.RunAll()
+        self.KillAll()
+
+# Example usage of LabsAdmin with the new integration
+try:
+    LabsAdmin("242").RunAndKillAll()
+except Exception as err:
+    print("Unexpected error: "+str(err)+", "+str(type(err)))
diff --git a/ansys_optical_automation/scdm_core/utils.py b/ansys_optical_automation/scdm_core/utils.py
@@ -4,26 +4,103 @@
 
 import numpy as np
 
+import os
+
+import os
+
 
-def get_scdm_install_location(version):
+def find_awp_root(version=""):
+    """
+    Finds the AWP_ROOT path based on the given version.
+
+    This function searches the environmental variables for keys containing "AWP_ROOT".
+    If a specific version is provided, it returns the path for that version.
+    If no version is provided (i.e., an empty string is passed), it returns the path for the latest version.
+
+    Parameters
+    ----------
+    version : str, optional
+        The version of AWP_ROOT to search for. If an empty string is passed,
+        the path for the latest version is returned. Default is an empty string.
+
+    Returns
+    -------
+    str
+        The path to the specified AWP_ROOT version if `version` is provided.
+        If no `version` is specified, it returns the path to the latest AWP_ROOT version.
+
+    Raises
+    ------
+    ValueError
+        If the specified `version` does not exist or if no AWP_ROOT path is found in the environment variables.
+
+    Notes
+    -----
+    The function compares the version numbers by splitting the keys containing "AWP_ROOT"
+    and checking the version number after "AWP_ROOT".
+    """
+    try:
+        if version:
+            # If version is specified, return the path for that version
+            awp_root_path = os.environ.get(f"AWP_ROOT{version}", "")
+            if not awp_root_path:
+                raise ValueError(f"AWP_ROOT path for version {version} not found in the environment variables.")
+        else:
+            # If no version is specified, find the latest version
+            last_version = "000"
+            for key in os.environ:
+                if "AWP_ROOT" in key and key.split("AWP_ROOT")[1] > last_version:
+                    last_version = key.split("AWP_ROOT")[1]
+
+            awp_root_path = os.environ.get(f"AWP_ROOT{last_version}", "")
+            if not awp_root_path:
+                raise ValueError("AWP_ROOT path for the latest version not found in the environment variables.")
+
+        return awp_root_path
+
+    except Exception as e:
+        raise ValueError(f"An error occurred while finding the AWP_ROOT path: {str(e)}")
+
+
+print(find_awp_root("242"))
+def get_scdm_install_location(version=""):
     """
     Get the SpaceClaim installation path.
 
+    This function retrieves the installation path for SpaceClaim based on the provided version.
+    It calls the `find_awp_root` function to obtain the AWP_ROOT path for the given version,
+    and then appends the "scdm" directory to determine the SpaceClaim installation path.
+
     Parameters
     ----------
-    version : int
+    version : str, optional
         Version of SpaceClaim in numerical format. For example, ``211`` for 2021 R1.
+        If an empty string is passed, the function will use the latest version found.
 
     Returns
     -------
     str
         Path of the SpaceClaim installation.
 
-    """
-    ansys_install_dir = os.environ["AWP_ROOT{}".format(version)]
-    scdm_install_dir = os.path.join(ansys_install_dir, "scdm")
-    return scdm_install_dir
-
+    Raises
+    ------
+    ValueError
+        If the AWP_ROOT path for the specified or latest version cannot be found,
+        or if there is an issue with accessing the environment variables.
+
+    Notes
+    -----
+    The `find_awp_root` function is used to retrieve the AWP_ROOT path, and the "scdm" directory
+    is appended to this path to return the full path to the SpaceClaim installation.
+    """
+    try:
+        ansys_install_dir = find_awp_root(version=version)
+        scdm_install_dir = os.path.join(ansys_install_dir, "scdm")
+        return scdm_install_dir
+    except ValueError as e:
+        raise ValueError(f"Error while getting the SpaceClaim installation path: {str(e)}")
+
+print("####",get_scdm_install_location("242"))
 
 def get_speos_core(version):
     """
