pyedb 0.54.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

pyedb/generic/design_types.py

@@ -23,7 +23,8 @@ from typing import TYPE_CHECKING, Literal, Union, overload
 import warnings
 
 from pyedb.generic.grpc_warnings import GRPC_GENERAL_WARNING
-from pyedb.misc.misc import list_installed_ansysem
+from pyedb.generic.settings import settings
+from pyedb.misc.decorators import deprecate_argument_name
 
 if TYPE_CHECKING:
     from pyedb.dotnet.edb import Edb as EdbDotnet
@@ -46,18 +47,21 @@ def Edb(*, grpc: bool, **kwargs) -> Union["EdbGrpc", "EdbDotnet"]:
 
 
 # lazy imports
+@deprecate_argument_name({"edbversion": "version"})
 def Edb(
     edbpath=None,
     cellname=None,
     isreadonly=False,
-    edbversion=None,
+    version=None,
     isaedtowned=False,
     oproject=None,
     student_version=False,
     use_ppe=False,
+    map_file=None,
     technology_file=None,
     grpc=False,
     control_file=None,
+    layer_filter=None,
 ):
     """Provides the EDB application interface.
 
@@ -76,7 +80,7 @@ def Edb(
         isreadonly : bool, optional
             Whether to open EBD in read-only mode when it is
             owned by HFSS 3D Layout. The default is ``False``.
-        edbversion : str, optional
+        version : str, optional
             Version of EDB to use. The default is ``"2021.2"``.
         isaedtowned : bool, optional
             Whether to launch EDB from HFSS 3D Layout. The
@@ -85,10 +89,20 @@ def Edb(
             Reference to the AEDT project object.
         student_version : bool, optional
             Whether to open the AEDT student version. The default is ``False.``
+        use_ppe : bool, optional
+            Whether to use PPE license. The default is ``False``.
         technology_file : str, optional
             Full path to technology file to be converted to xml before importing or xml. Supported by GDS format only.
         grpc : bool, optional
             Whether to enable gRPC. Default value is ``False``.
+        layer_filter: str,optional
+            Layer filter .txt file.
+        map_file : str, optional
+            Layer map .map file.
+        control_file : str, optional
+            Path to the XML file. The default is ``None``, in which case an attempt is made to find
+            the XML file in the same directory as the board file. To succeed, the XML file and board file
+            must have the same name. Only the extension differs.
 
         Returns
         -------
@@ -257,38 +271,75 @@ def Edb(
     >>> workflow.run()
 
     """
-
-    if not edbversion:  # pragma: no cover
-        try:
-            version = "20{}.{}".format(list_installed_ansysem()[0][-3:-1], list_installed_ansysem()[0][-1:])
-        except IndexError:
-            raise Exception("No ANSYSEM_ROOTxxx is found.")
+    settings.is_student_version = student_version
+    if grpc is False and settings.edb_dll_path is not None:
+        # Check if the user specified a .dll path
+        settings.logger.info(f"Force to use .dll from {settings.edb_dll_path} defined in settings.")
+    elif version is None:
+        if settings.specified_version is not None:
+            settings.logger.info(f"Use {settings.specified_version} defined in settings.")
+            # Use the latest version
+        elif student_version:
+            if settings.LATEST_STUDENT_VERSION is None:
+                raise RuntimeWarning("AEDT is not properly installed.")
+            else:
+                settings.specified_version = settings.LATEST_STUDENT_VERSION
+        else:
+            if settings.LATEST_VERSION is None:
+                raise RuntimeWarning("AEDT is not properly installed.")
+            else:
+                settings.specified_version = settings.LATEST_VERSION
     else:
-        version = edbversion
+        # Version is specified
+        version = str(version)
+        if student_version:
+            if version not in settings.INSTALLED_STUDENT_VERSIONS:
+                raise RuntimeWarning(f"AEDT student version {version} is not properly installed.")
+            else:
+                settings.specified_version = version
+        else:
+            if version not in settings.INSTALLED_VERSIONS:
+                raise RuntimeWarning(f"AEDT version {version} is not properly installed.")
+            else:
+                settings.specified_version = version
 
-    # Use EDB legacy (default choice)
-    if float(version) >= 2025.2:
-        if not grpc:
-            warnings.warn(GRPC_GENERAL_WARNING, UserWarning)
-    else:
-        if grpc:
-            raise ValueError(f"gRPC flag was enabled however your ANSYS AEDT version {version} is not compatible")
     if grpc:
+        if float(settings.specified_version) < 2025.2:
+            raise ValueError(
+                f"gRPC flag was enabled however your ANSYS AEDT version {settings.specified_version} is not compatible"
+            )
+
         from pyedb.grpc.edb import Edb as app
+
+        return app(
+            edbpath=edbpath,
+            cellname=cellname,
+            isreadonly=isreadonly,
+            edbversion=version,
+            isaedtowned=isaedtowned,
+            oproject=oproject,
+            use_ppe=use_ppe,
+            technology_file=technology_file,
+            control_file=control_file,
+        )
     else:
-        from pyedb.dotnet.edb import Edb as app
-    return app(
-        edbpath=edbpath,
-        cellname=cellname,
-        isreadonly=isreadonly,
-        edbversion=version,
-        isaedtowned=isaedtowned,
-        oproject=oproject,
-        student_version=student_version,
-        use_ppe=use_ppe,
-        technology_file=technology_file,
-        control_file=control_file,
-    )
+        if float(settings.specified_version) >= 2025.2:
+            warnings.warn(GRPC_GENERAL_WARNING, UserWarning)
+
+        from pyedb.dotnet.edb import Edb
+
+        return Edb(
+            edbpath=edbpath,
+            cellname=cellname,
+            isreadonly=isreadonly,
+            isaedtowned=isaedtowned,
+            oproject=oproject,
+            use_ppe=use_ppe,
+            control_file=control_file,
+            map_file=map_file,
+            technology_file=technology_file,
+            layer_filter=layer_filter,
+        )
 
 
 def Siwave(

pyedb/generic/filesystem.py

@@ -1,5 +1,5 @@
 import os
-import random
+import secrets
 import shutil
 import string
 
@@ -44,7 +44,10 @@ class Scratch:
         self._volatile = volatile
         self._cleaned = True
         char_set = string.ascii_uppercase + string.digits
-        self._scratch_path = os.path.normpath(os.path.join(local_path, "scratch" + "".join(random.sample(char_set, 6))))
+        generator = secrets.SystemRandom()
+        self._scratch_path = os.path.normpath(
+            os.path.join(local_path, "scratch" + "".join(secrets.SystemRandom.sample(generator, char_set, 6)))
+        )
         if os.path.exists(self._scratch_path):
             try:
                 self.remove()

pyedb/generic/general_methods.py

@@ -35,15 +35,14 @@ import itertools
 import logging
 import math
 import os
-import random
 import re
+import secrets
 import string
 import sys
 import tempfile
 import time
 import traceback
 
-from pyedb.exceptions import MaterialModelException
 from pyedb.generic.constants import CSS4_COLORS
 from pyedb.generic.settings import settings
 
@@ -141,82 +140,6 @@ def _exception(ex_info, func, args, kwargs, message="Type Error"):
         )
 
 
-def _function_handler_wrapper(user_function):  # pragma: no cover
-    def wrapper(*args, **kwargs):  # pragma: no cover
-        if not settings.enable_error_handler:
-            result = user_function(*args, **kwargs)
-            return result
-        else:
-            try:
-                settings.time_tick = time.time()
-                out = user_function(*args, **kwargs)
-                if settings.enable_debug_logger or settings.enable_debug_edb_logger:
-                    _log_method(user_function, args, kwargs)
-                return out
-            except TypeError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Type Error")
-                return False
-            except ValueError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Value Error")
-                return False
-            except AttributeError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Attribute Error")
-                return False
-            except KeyError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Key Error")
-                return False
-            except IndexError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Index Error")
-                return False
-            except AssertionError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Assertion Error")
-                return False
-            except NameError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Name Error")
-                return False
-            except IOError:
-                _exception(sys.exc_info(), user_function, args, kwargs, "IO Error")
-                return False
-            except MaterialModelException:
-                _exception(sys.exc_info(), user_function, args, kwargs, "Material Model")
-                return False
-
-    return wrapper
-
-
-import functools
-import warnings
-
-
-def deprecate_argument_name(argument_map):
-    """Decorator to deprecate certain argument names in favor of new ones."""
-
-    def decorator(func):
-        """Decorator that wraps the function to handle deprecated arguments."""
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            """Wrapper function that checks for deprecated arguments."""
-            func_name = func.__name__
-            for old_arg, new_arg in argument_map.items():
-                if old_arg in kwargs:
-                    warnings.warn(
-                        f"Argument `{old_arg}` is deprecated for method `{func_name}`; use `{new_arg}` instead.",
-                        DeprecationWarning,
-                        stacklevel=2,
-                    )
-                    # NOTE: Use old argument if new argument is not provided
-                    if new_arg not in kwargs:
-                        kwargs[new_arg] = kwargs.pop(old_arg)
-                    else:
-                        kwargs.pop(old_arg)
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
 def get_filename_without_extension(path):
     """Get the filename without its extension.
 
@@ -242,49 +165,6 @@ def _write_mes(mes_text):
         settings.logger.error(el)
 
 
-def _log_method(func, new_args, new_kwargs):  # pragma: no cover
-    if not settings.enable_debug_internal_methods_logger and str(func.__name__)[0] == "_":
-        return
-    if not settings.enable_debug_geometry_operator_logger and "GeometryOperators" in str(func):
-        return
-    if (
-        not settings.enable_debug_edb_logger
-        and "Edb" in str(func) + str(new_args)
-        or "database" in str(func) + str(new_args)
-    ):
-        return
-    line_begin = "ARGUMENTS: "
-    message = []
-    delta = time.time() - settings.time_tick
-    m, s = divmod(delta, 60)
-    h, m = divmod(m, 60)
-    d, h = divmod(h, 24)
-    msec = (s - int(s)) * 1000
-    if d > 0:
-        time_msg = " {}days {}h {}m {}sec.".format(d, h, m, int(s))
-    elif h > 0:
-        time_msg = " {}h {}m {}sec.".format(h, m, int(s))
-    else:
-        time_msg = "  {}m {}sec {}msec.".format(m, int(s), int(msec))
-    if settings.enable_debug_methods_argument_logger:
-        args_dict = _get_args_dicts(func, new_args, new_kwargs)
-        id = 0
-        if new_args:
-            object_name = str([new_args[0]])[1:-1]
-            id = object_name.find(" object at ")
-        if id > 0:
-            object_name = object_name[1:id]
-            message.append("'{}' was run in {}".format(object_name + "." + str(func.__name__), time_msg))
-        else:
-            message.append("'{}' was run in {}".format(str(func.__name__), time_msg))
-        message.append(line_begin)
-        for k, v in args_dict.items():
-            if k != "self":
-                message.append("    {} = {}".format(k, v))
-    for m in message:
-        settings.logger.debug(m)
-
-
 def _get_args_dicts(func, args, kwargs):
     if int(sys.version[0]) > 2:
         args_name = list(OrderedDict.fromkeys(inspect.getfullargspec(func)[0] + list(kwargs.keys())))
@@ -374,7 +254,7 @@ def generate_unique_name(rootname, suffix="", n=6):
 
     """
     char_set = string.ascii_uppercase + string.digits
-    uName = "".join(random.choice(char_set) for _ in range(n))
+    uName = "".join(secrets.choice(char_set) for _ in range(n))
     unique_name = rootname + "_" + uName
     if suffix:
         unique_name += "_" + suffix

pyedb/generic/process.py

@@ -1,104 +1,51 @@
 import os.path
+from pathlib import Path
 import subprocess
 
-from pyedb.generic.general_methods import env_path, is_linux, is_windows
+from pyedb.generic.general_methods import is_linux
 
 
 class SiwaveSolve(object):
-    def __init__(self, aedb_path="", aedt_version="2021.2", aedt_installer_path=None):
-        self._project_path = aedb_path
-        self._exec_path = ""
-        self._nbcores = 4
-        self._ng = True
-        if aedt_installer_path:
-            self.installer_path = aedt_installer_path
-        else:
-            try:
-                self.installer_path = env_path(aedt_version)
-            except:
-                raise Exception("Either a valid aedt version or full path has to be provided")
-        if self._ng:
-            executable = "siwave_ng"
-        else:
-            executable = "siwave"
-        if is_linux:
-            self._exe = os.path.join(self.installer_path, executable)
-        else:
-            self._exe = os.path.join(self.installer_path, executable + ".exe")
+    def __init__(self, pedb):
+        self._pedb = pedb
 
     @property
-    def siwave_exe(self):
-        return self._exe
-
-    @siwave_exe.setter
-    def siwave_exe(self, value):
-        self._exe = value
-
-    @property
-    def projectpath(self):
-        return self._project_path
-
-    @projectpath.setter
-    def projectpath(self, value):
-        self._project_path = value
+    def __siwave_exe_path(self):
+        executable = "siwave"
+        executable = executable if is_linux else executable + ".exe"
+        full_path = Path(self._pedb.ansys_em_path) / executable
+        return str(full_path)
 
     @property
-    def execfile(self):
-        return self._exec_path
-
-    @execfile.setter
-    def execfile(self, value):
-        self._exec_path = value
-
-    @property
-    def nbcores(self):
-        return self._nbcores
-
-    @nbcores.setter
-    def nbcores(self, value):
-        self._nbcores = value
-
-    @property
-    def nongraphical(self):
-        return self._ng
-
-    @nongraphical.setter
-    def nongraphical(self, value):
-        self._ng = value
-
-    def solve(self):
-        # supporting non graphical solve only
-        if self.nongraphical:
-            if is_linux:
-                exe_path = os.path.join(self.installer_path, "siwave_ng")
-            else:
-                exe_path = os.path.join(self.installer_path, "siwave_ng.exe")
-            exec_file = os.path.splitext(self._project_path)[0] + ".exec"
-            if os.path.exists(exec_file):
-                with open(exec_file, "r+") as f:
-                    content = f.readlines()
-                    if "SetNumCpus" not in content:
-                        f.writelines(str.format("SetNumCpus {}", str(self.nbcores)) + "\n")
-                        f.writelines("SaveSiw")
-                    else:
-                        fstarts = [i for i in range(len(content)) if content[i].startswith("SetNumCpus")]
-                        content[fstarts[0]] = str.format("SetNumCpus {}", str(self.nbcores))
-                        f.close()
-                        os.remove(exec_file)
-                        f = open(exec_file, "w")
-                        f.writelines(content)
-            command = [exe_path]
-            command.append(self._project_path)
-            command.append(exec_file)
-            command.append("-formatOutput -useSubdir")
-            if os.name == "posix":
-                p = subprocess.Popen(command)
-            else:
-                p = subprocess.Popen(" ".join(command))
-            p.wait()
+    def __siwave_ng_exe_path(self):
+        executable = "siwave_ng"
+        executable = executable if is_linux else executable + ".exe"
+        full_path = Path(self._pedb.ansys_em_path) / executable
+        return str(full_path)
+
+    def solve(self, num_of_cores=4):
+        exec_file = os.path.splitext(self._pedb.edbpath)[0] + ".exec"
+        if os.path.exists(exec_file):
+            with open(exec_file, "r+") as f:
+                content = f.readlines()
+                if "SetNumCpus" not in content:
+                    f.writelines(str.format("SetNumCpus {}", str(num_of_cores)) + "\n")
+                    f.writelines("SaveSiw")
+                else:
+                    fstarts = [i for i in range(len(content)) if content[i].startswith("SetNumCpus")]
+                    content[fstarts[0]] = str.format("SetNumCpus {}", str(num_of_cores))
+                    f.close()
+                    os.remove(exec_file)
+                    f = open(exec_file, "w")
+                    f.writelines(content)
+        command = [self.__siwave_ng_exe_path, self._pedb.edbpath, exec_file, "-formatOutput -useSubdir"]
+        command_ = command if os.name == "posix" else " ".join(command)
+        # p = subprocess.Popen(command_)
+        p = subprocess.Popen(command)
+        p.wait()
 
     def export_3d_cad(
-        self, format_3d="Q3D", output_folder=None, net_list=None, num_cores=None, aedt_file_name=None, hidden=False
+        self, format_3d="Q3D", output_folder=None, net_list=None, num_cores=4, aedt_file_name=None, hidden=False
     ):  # pragma: no cover
         """Export edb to Q3D or HFSS
 
@@ -119,11 +66,11 @@ class SiwaveSolve(object):
             path to aedt file
         """
         if not output_folder:
-            output_folder = os.path.dirname(self.projectpath)
+            output_folder = os.path.dirname(self._pedb.edbpath)
         scriptname = os.path.join(output_folder, "export_cad.py")
         with open(scriptname, "w") as f:
             f.write("import os\n")
-            f.write("edbpath = r'{}'\n".format(self.projectpath))
+            f.write("edbpath = r'{}'\n".format(self._pedb.edbpath))
             f.write("exportOptions = os.path.join(r'{}', 'options.config')\n".format(output_folder))
             f.write("oDoc.ScrImportEDB(edbpath)\n")
             f.write("oDoc.ScrSaveProjectAs(os.path.join(r'{}','{}'))\n".format(output_folder, "test.siw"))
@@ -140,14 +87,11 @@ class SiwaveSolve(object):
             f.write("q3d_filename = os.path.join(r'{}', '{}')\n".format(output_folder, aedt_file_name))
             if num_cores:
                 f.write("oDoc.ScrSetNumCpusToUse('{}')\n".format(num_cores))
-                self.nbcores = num_cores
             f.write("oDoc.ScrExport3DModel('{}', q3d_filename)\n".format(format_3d))
             f.write("oDoc.ScrCloseProject()\n")
             f.write("oApp.Quit()\n")
-        _exe = os.path.join(self.installer_path, "siwave")
-        if is_windows:
-            _exe += ".exe"
-        command = [_exe]
+
+        command = [self.__siwave_exe_path]
         if hidden:
             command.append("-embedding")
         command += ["-RunScriptAndExit", scriptname]
@@ -204,7 +148,7 @@ class SiwaveSolve(object):
             list of files generated.
         """
         if not output_folder:
-            output_folder = os.path.dirname(self.projectpath)
+            output_folder = os.path.dirname(self._pedb.edbpath)
         output_list = []
         scriptname = os.path.normpath(os.path.join(os.path.normpath(output_folder), "export_results.py"))
         with open(scriptname, "w") as f:
@@ -265,20 +209,12 @@ class SiwaveSolve(object):
             f.write("proj.ScrCloseProject()\n")
 
             f.write("oApp.Quit()\n")
-        if is_linux:
-            _exe = '"' + os.path.join(self.installer_path, "siwave") + '"'
-        else:
-            _exe = '"' + os.path.join(self.installer_path, "siwave.exe") + '"'
-        command = [_exe]
+        command = [self.__siwave_exe_path]
         if hidden:
             command.append("-embedding")
         command.append("-RunScriptAndExit")
-        command.append('"' + scriptname + '"')
+        command.append(scriptname)
         print(command)
-        if os.name == "posix":
-            p = subprocess.Popen(command)
-
-        else:
-            p = subprocess.Popen(" ".join(command))
+        p = subprocess.Popen(command)
         p.wait()
         return output_list

pyedb/generic/settings.py

@@ -21,12 +21,25 @@
 # SOFTWARE.
 
 import os
+from pathlib import Path
+import re
+import sys
 import time
+import warnings
 
 
 class Settings(object):
     """Manages all PyEDB environment variables and global settings."""
 
+    INSTALLED_VERSIONS = None
+    INSTALLED_STUDENT_VERSIONS = None
+    INSTALLED_CLIENT_VERSIONS = None
+    LATEST_VERSION = None
+    LATEST_STUDENT_VERSION = None
+
+    specified_version = None
+    is_student_version = False
+
     def __init__(self):
         self.remote_rpc_session = False
         self._enable_screen_logs = True
@@ -58,26 +71,12 @@ class Settings(object):
         self._global_log_file_size = 10
         self._lsf_queue = None
         self._edb_environment_variables = {}
-        self._use_pyaedt_log = False
-        self._logger = None
-
-    @property
-    def logger(self):
-        """Active logger."""
-        return self._logger
-
-    @logger.setter
-    def logger(self, val):
-        self._logger = val
+        self.logger = None
+        self.log_file = None
+        self._aedt_version = None
 
-    @property
-    def use_pyaedt_log(self):
-        """Flag that disable Edb log when PyAEDT is used."""
-        return self._use_pyaedt_log
-
-    @use_pyaedt_log.setter
-    def use_pyaedt_log(self, value):
-        self._use_pyaedt_log = value
+        self.__get_version_information()
+        self.__init_logger()
 
     @property
     def edb_environment_variables(self):
@@ -250,6 +249,9 @@ class Settings(object):
     @edb_dll_path.setter
     def edb_dll_path(self, value):
         if os.path.exists(value):
+            ver = Path(value).parts[-2]
+            version, release = ver[-3:-1], ver[-1]
+            self.specified_version = f"20{version}.{release}"
             self._edb_dll_path = value
 
     @property
@@ -261,5 +263,63 @@ class Settings(object):
     def retry_n_times_time_interval(self, value):
         self._retry_n_times_time_interval = float(value)
 
+    def __get_version_information(self):
+        """Get the installed AEDT versions.
+
+        This method returns a dictionary, with the version as the key and the installation path
+        as the value."""
+        version_pattern = re.compile(r"^(ANSYSEM_ROOT|ANSYSEM_PY_CLIENT_ROOT|ANSYSEMSV_ROOT)\d{3}$")
+        env_list = sorted([x for x in os.environ if version_pattern.match(x)], reverse=True)
+        if not env_list:  # pragma: no cover
+            warnings.warn("No installed versions of AEDT are found in the system environment variables.")
+            return
+
+        aedt_system_env_variables = {i: os.environ[i] for i in env_list}
+
+        standard_versions = {}
+        client_versions = {}
+        student_versions = {}
+        # version_list is ordered: first normal versions, then client versions, finally student versions
+        for var_name, aedt_path in aedt_system_env_variables.items():
+            version_id = var_name[-3:]
+            version, release = version_id[0:2], version_id[2]
+            version_name = f"20{version}.{release}"
+            if "ANSYSEM_ROOT" in var_name:
+                standard_versions[version_name] = aedt_path
+            elif "ANSYSEM_PY_CLIENT_ROOT" in var_name:
+                client_versions[version_name] = aedt_path
+            else:
+                student_versions[version_name] = aedt_path
+        self.INSTALLED_VERSIONS = standard_versions
+        self.INSTALLED_STUDENT_VERSIONS = student_versions
+        self.INSTALLED_CLIENT_VERSIONS = client_versions
+
+        if len(self.INSTALLED_VERSIONS):
+            self.LATEST_VERSION = max(standard_versions.keys(), key=lambda x: tuple(map(int, x.split("."))))
+        if len(self.INSTALLED_STUDENT_VERSIONS):
+            self.LATEST_STUDENT_VERSION = max(student_versions.keys(), key=lambda x: tuple(map(int, x.split("."))))
+
+    @property
+    def aedt_installation_path(self):
+        if self.edb_dll_path:
+            return self.edb_dll_path
+        elif self.is_student_version:
+            return self.INSTALLED_STUDENT_VERSIONS[self.specified_version]
+        elif self.specified_version in self.INSTALLED_VERSIONS.keys():
+            return self.INSTALLED_VERSIONS[self.specified_version]
+        elif os.name == "posix":
+            main = sys.modules["__main__"]
+            if "oDesktop" in dir(main):
+                return main.oDesktop.GetExeDir()
+            else:
+                raise RuntimeError(f"Version {self.specified_version} is not installed on the system. ")
+        else:
+            raise RuntimeError(f"Version {self.specified_version} is not installed on the system. ")
+
+    def __init_logger(self):
+        from pyedb.edb_logger import EdbLogger
+
+        self.logger = EdbLogger(to_stdout=self.enable_screen_logs, settings=self)
+
 
 settings = Settings()