pyedb 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

pyedb/edb_logger.py

@@ -29,8 +29,6 @@ import sys
 import tempfile
 import time
 
-from pyedb.generic.settings import settings
-
 
 class Msg:
     (INFO, WARNING, ERROR, FATAL) = range(4)
@@ -91,14 +89,17 @@ class EdbLogger(object):
         Whether to write log messages to stdout. The default is ``False``.
     """
 
-    def __init__(self, level=logging.DEBUG, filename=None, to_stdout=False):
+    log_file = ""
+
+    def __init__(self, level=logging.DEBUG, filename=None, to_stdout=False, settings=None):
+        self.settings = settings
         self._std_out_handler = None
         self._files_handlers = []
         self.level = level
         self.filename = filename or settings.logger_file_path
         settings.logger_file_path = self.filename
 
-        self._global = logging.getLogger("Global")
+        self._global = logging.getLogger("Edb")
         if not settings.enable_logger:
             self._global.addHandler(logging.NullHandler())
             return
@@ -123,6 +124,7 @@ class EdbLogger(object):
                 encoding="utf-8",
                 delay=0,
             )
+            self.log_file = log_file
             my_handler.setFormatter(self.formatter)
             my_handler.setLevel(self.level)
             if not global_handler and settings.global_log_file_name:
@@ -171,11 +173,11 @@ class EdbLogger(object):
 
     @property
     def _log_on_file(self):
-        return settings.enable_file_logs
+        return self.settings.enable_file_logs
 
     @_log_on_file.setter
     def _log_on_file(self, val):
-        settings.enable_file_logs = val
+        self.settings.enable_file_logs = val
 
     @property
     def logger(self):
@@ -334,7 +336,7 @@ class EdbLogger(object):
 
     def info(self, msg, *args, **kwargs):
         """Write an info message to the global logger."""
-        if not settings.enable_logger:
+        if not self.settings.enable_logger:
             return
         if args:
             try:
@@ -348,7 +350,7 @@ class EdbLogger(object):
     def info_timer(self, msg, start_time=None, *args, **kwargs):
         """Write an info message to the global logger with elapsed time.
         Message will have an appendix of type Elapsed time: time."""
-        if not settings.enable_logger:
+        if not self.settings.enable_logger:
             return
         if not start_time:
             start_time = self._timer
@@ -373,7 +375,7 @@ class EdbLogger(object):
 
     def warning(self, msg, *args, **kwargs):
         """Write a warning message to the global logger."""
-        if not settings.enable_logger:
+        if not self.settings.enable_logger:
             return
         if args:
             try:
@@ -397,7 +399,7 @@ class EdbLogger(object):
 
     def debug(self, msg, *args, **kwargs):
         """Write a debug message to the global logger."""
-        if not settings.enable_debug_logger or not settings.enable_logger:
+        if not self.settings.enable_debug_logger or not self.settings.enable_logger:
             return
         if args:
             try:
@@ -413,20 +415,3 @@ class EdbLogger(object):
         """Global logger."""
         self._global = logging.getLogger("Global")
         return self._global
-
-
-logger = logging.getLogger("Global")
-if any("aedt_logger" in str(i) for i in logger.filters):
-    from ansys.aedt.core.generic.settings import settings as pyaedt_settings
-
-    from pyedb.generic.settings import settings as pyaedb_settings
-
-    pyedb_logger = pyaedt_settings.logger
-    pyaedb_settings.use_pyaedt_log = True
-    pyaedb_settings.logger = pyedb_logger
-
-else:
-    pyedb_logger = EdbLogger(to_stdout=settings.enable_screen_logs)
-    from pyedb.generic.settings import settings as pyaedb_settings
-
-    pyaedb_settings.logger = pyedb_logger

pyedb/extensions/via_design_backend.py

@@ -663,7 +663,7 @@ class ViaDesignBackend:
         pitch = self.cfg["general"]["pitch"]
 
         board = Board(
-            stackup=self.cfg["stackup"],
+            stackup=self.cfg["stackup"] if isinstance(self.cfg["stackup"], list) else self.cfg["stackup"]["layers"],
             padstack_defs=self.cfg["padstack_defs"],
             outline_extent=outline_extent,
             pitch=pitch,
@@ -673,9 +673,12 @@ class ViaDesignBackend:
         )
         board.populate_config(cfg_json)
 
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.output_dir / "config.json", "w") as f:
+            json.dump(cfg_json, f, indent=4)
         self.app = Edb(
             edbpath=str((Path(self.output_dir) / self.cfg["title"]).with_suffix(".aedb")), edbversion=self.version
         )
         self.app.configuration.load(cfg_json, apply_file=True)
-        self.app.save_edb()
-        self.app.close_edb()
+        self.app.save()
+        self.app.close()

pyedb/generic/design_types.py

@@ -23,6 +23,8 @@ from typing import TYPE_CHECKING, Literal, Union, overload
 import warnings
 
 from pyedb.generic.grpc_warnings import GRPC_GENERAL_WARNING
+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
@@ -45,11 +47,12 @@ 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,
@@ -256,30 +259,74 @@ def Edb(
     >>> workflow.run()
 
     """
-
-    # Use EDB legacy (default choice)
-    if float(edbversion) >= 2025.2:
-        if not grpc:
-            warnings.warn(GRPC_GENERAL_WARNING, UserWarning)
+    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.")
+        settings.specified_version = "unknown"
+    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:
-        if grpc:
-            raise ValueError(f"gRPC flag was enabled however your ANSYS AEDT version {edbversion} is not compatible")
+        # 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
+
     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=edbversion,
-        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,
+            technology_file=technology_file,
+            control_file=control_file,
+        )
 
 
 def Siwave(

pyedb/generic/general_methods.py

@@ -43,7 +43,6 @@ 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())))

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