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

pyedb/dotnet/database/dotnet/database.py

@@ -21,21 +21,9 @@
 # SOFTWARE.
 
 """Database."""
-import os
 import re
-import sys
-import warnings
 
-from pyedb import __version__
 from pyedb.dotnet.database.general import convert_py_list_to_net_list
-from pyedb.generic.general_methods import (
-    env_path,
-    env_path_student,
-    env_value,
-    is_linux,
-    settings,
-)
-from pyedb.generic.grpc_warnings import GRPC_GENERAL_WARNING
 
 
 class HierarchyDotNet:
@@ -90,7 +78,7 @@ class PolygonDataDotNet:  # pragma: no cover
 
     def __init__(self, pedb, api_object=None):
         self._pedb = pedb
-        self.dotnetobj = pedb.core.geometry.api_class.PolygonData
+        self.dotnetobj = pedb.core.Geometry.PolygonData
         self.core = api_object
         self._edb_object = api_object
 
@@ -653,11 +641,6 @@ class CellDotNet:
         self._app = app
         self.core = app._edb
 
-    @property
-    def api_class(self):
-        """Return Ansys.Ansoft.Edb class object."""
-        return self.core
-
     @property
     def definition(self):
         """Edb Dotnet Api Definition."""
@@ -698,115 +681,8 @@ class CellDotNet:
         return GeometryDotNet(self._app)
 
 
-class EdbDotNet(object):
-    """Edb Dot Net Class."""
-
-    def __init__(self, edbversion, student_version=False):
-        self._logger.info(f"Edb version {edbversion}")
-        self.edbversion = edbversion
-        if float(self.edbversion) >= 2025.2:
-            warnings.warn(GRPC_GENERAL_WARNING, UserWarning)
-        self.student_version = student_version
-        """Initialize DLLs."""
-        from pyedb.dotnet.clr_module import _clr, edb_initialized
-
-        if not settings.use_pyaedt_log:
-            if settings.enable_screen_logs:
-                self._logger.enable_stdout_log()
-            else:  # pragma: no cover
-                self._logger.disable_stdout_log()
-        if not edb_initialized:  # pragma: no cover
-            self._logger.error("Failed to initialize Dlls.")
-            return
-        self._logger.info("Logger is initialized in EDB.")
-        self._logger.info("legacy v%s", __version__)
-        self._logger.info("Python version %s", sys.version)
-        if is_linux:  # pragma: no cover
-            if env_value(self.edbversion) in os.environ or settings.edb_dll_path:
-                if settings.edb_dll_path:
-                    self.base_path = settings.edb_dll_path
-                else:
-                    self.base_path = env_path(self.edbversion)
-                sys.path.append(self.base_path)
-            else:
-                main = sys.modules["__main__"]
-                if "oDesktop" in dir(main):
-                    self.base_path = main.oDesktop.GetExeDir()
-                    sys.path.append(main.oDesktop.GetExeDir())
-                    os.environ[env_value(self.edbversion)] = self.base_path
-                else:
-                    edb_path = os.getenv("PYAEDT_SERVER_AEDT_PATH")
-                    if edb_path:
-                        self.base_path = edb_path
-                        sys.path.append(edb_path)
-                        os.environ[env_value(self.edbversion)] = self.base_path
-
-            _clr.AddReference("Ansys.Ansoft.Edb")
-            _clr.AddReference("Ansys.Ansoft.EdbBuilderUtils")
-            _clr.AddReference("Ansys.Ansoft.SimSetupData")
-        else:
-            if settings.edb_dll_path:
-                self.base_path = settings.edb_dll_path
-            elif self.student_version:
-                self.base_path = env_path_student(self.edbversion)
-            else:
-                self.base_path = env_path(self.edbversion)
-            sys.path.append(self.base_path)
-            _clr.AddReference("Ansys.Ansoft.Edb")
-            _clr.AddReference("Ansys.Ansoft.EdbBuilderUtils")
-            _clr.AddReference("Ansys.Ansoft.SimSetupData")
-        os.environ["ECAD_TRANSLATORS_INSTALL_DIR"] = self.base_path
-        oaDirectory = os.path.join(self.base_path, "common", "oa")
-        os.environ["ANSYS_OADIR"] = oaDirectory
-        os.environ["PATH"] = "{};{}".format(os.environ["PATH"], self.base_path)
-        edb = __import__("Ansys.Ansoft.Edb")
-        self._edb = edb.Ansoft.Edb
-        edbbuilder = __import__("Ansys.Ansoft.EdbBuilderUtils")
-        self.edbutils = edbbuilder.Ansoft.EdbBuilderUtils
-        self.simSetup = __import__("Ansys.Ansoft.SimSetupData")
-        self.simsetupdata = self.simSetup.Ansoft.SimSetupData.Data
-
-    @property
-    def student_version(self):
-        """Set the student version flag."""
-        return self._student_version
-
-    @student_version.setter
-    def student_version(self, value):
-        self._student_version = value
-
-    @property
-    def logger(self):
-        """Logger for EDB.
-
-        Returns
-        -------
-        :class:`pyedb.edb_logger.EDBLogger`
-        """
-        return self._logger
-
-    @property
-    def edb_api(self):
-        """Edb Dotnet Api class.
-
-        .. deprecated:: 0.54.0
-            Use :func:core` instead.
-        Returns
-        -------
-        :class:`pyedb.dotnet.database.dotnet.database.CellDotNet`
-        """
-        warnings.warn("`edb_api` is deprecated, use `core` instead.", DeprecationWarning)
-        return CellDotNet(self)
-
-    @property
-    def core(self):
-        """Edb Dotnet Api class.
-
-        Returns
-        -------
-        :class:`pyedb.dotnet.database.dotnet.database.CellDotNet`
-        """
-        return CellDotNet(self)
+class Database:
+    """Class representing a database object."""
 
     @property
     def database(self):
@@ -818,78 +694,6 @@ class EdbDotNet(object):
         """Edb Dotnet Api Database `Edb.Definition`."""
         return self.core.Definition
 
-
-class Database(EdbDotNet):
-    """Class representing a database object."""
-
-    def __init__(self, edbversion, student_version=False):
-        """Initialize a new Database."""
-        EdbDotNet.__init__(self, edbversion=edbversion, student_version=student_version)
-        self._db = None
-
-    @property
-    def api_class(self):
-        """Return Ansys.Ansoft.Edb class object."""
-        return self._edb
-
-    @property
-    def api_object(self):
-        """Return Ansys.Ansoft.Edb object."""
-        return self._db
-
-    @property
-    def db(self):
-        """Active database object."""
-        return self._db
-
-    def run_as_standalone(self, flag):
-        """Set if Edb is run as standalone or embedded in AEDT.
-
-        Parameters
-        ----------
-        flag : bool
-            Whether if Edb is run as standalone or embedded in AEDT.
-        """
-        self.core.database.SetRunAsStandAlone(flag)
-
-    def create(self, db_path):
-        """Create a Database at the specified file location.
-
-        Parameters
-        ----------
-        db_path : str
-            Path to top-level database folder
-
-        Returns
-        -------
-        Database
-        """
-        self._db = self.core.database.Create(db_path)
-        return self._db
-
-    def open(self, db_path, read_only):
-        """Open an existing Database at the specified file location.
-
-        Parameters
-        ----------
-        db_path : str
-            Path to top-level Database folder.
-        read_only : bool
-            Obtain read-only access.
-
-        Returns
-        -------
-        Database or None
-            The opened Database object, or None if not found.
-        """
-        self._db = self.core.database.Open(
-            db_path,
-            read_only,
-        )
-        if self._db.IsNull():
-            raise AttributeError(f"Failed to open edb file {db_path}")
-        return self._db
-
     def delete(self, db_path):
         """Delete a database at the specified file location.
 

pyedb/dotnet/database/dotnet/primitive.py

@@ -133,7 +133,7 @@ class PrimitiveDotNet:
             if _poly is None or _poly.IsNull() or _poly is False:
                 self._logger.error("Failed to create void polygon data")
                 return False
-            point_list = self._app.core.cell.primitive.polygon.create(
+            point_list = self._app.core.Cell.primitive.polygon.create(
                 self._app.active_layout, self.layer_name, self.prim_obj.GetNet(), _poly
             ).prim_obj
         elif "prim_obj" in dir(point_list):
@@ -422,9 +422,9 @@ class RectangleDotNet(PrimitiveDotNet):
             net = net.api_object
         if isinstance(rep_type, int):
             if rep_type == 1:
-                rep_type = self.core.cell.primitive.RectangleRepresentationType.CenterWidthHeight
+                rep_type = self.core.Cell.primitive.RectangleRepresentationType.CenterWidthHeight
             else:
-                rep_type = self.core.cell.primitive.RectangleRepresentationType.LowerLeftUpperRight
+                rep_type = self.core.Cell.primitive.RectangleRepresentationType.LowerLeftUpperRight
         param1 = self._app.core.utility.value(param1)
         param2 = self._app.core.utility.value(param2)
         param3 = self._app.core.utility.value(param3)

pyedb/dotnet/database/edb_data/control_file.py

@@ -27,8 +27,8 @@ import subprocess
 import sys
 import xml
 
-from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
+from pyedb.generic.settings import settings
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 from pyedb.misc.misc import list_installed_ansysem
 
@@ -57,7 +57,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             base_path = env_path(edbversion)
             sys.path.append(base_path)
         else:
-            pyedb_logger.error("No Edb installation found. Check environment variables")
+            settings.logger.error("No Edb installation found. Check environment variables")
             return False
         os.environ["HELIC_ROOT"] = os.path.join(base_path, "helic")
         if os.getenv("ANSYSLMD_LICENCE_FILE", None) is None:
@@ -70,7 +70,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
                             os.environ["ANSYSLMD_LICENSE_FILE"] = line.split("=")[1]
                             break
             else:
-                pyedb_logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
+                settings.logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
         vlc_file_name = os.path.splitext(tech_file)[0]
         if not control_file:
             control_file = vlc_file_name + ".xml"
@@ -104,9 +104,9 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             p = subprocess.Popen(command, env=my_env)
             p.wait()
         if os.path.exists(control_file):
-            pyedb_logger.info("Xml file created.")
+            settings.logger.info("Xml file created.")
             return control_file
-    pyedb_logger.error("Technology files are supported only in Linux. Use control file instead.")
+    settings.logger.error("Technology files are supported only in Linux. Use control file instead.")
     return False
 
 

pyedb/dotnet/database/edb_data/hfss_extent_info.py

@@ -38,14 +38,14 @@ class HfssExtentInfo:
         self._pedb = pedb
 
         self._hfss_extent_info_type = {
-            "bounding_box": self._pedb.core.utility.utility.HFSSExtentInfoType.BoundingBox,
-            "conforming": self._pedb.core.utility.utility.HFSSExtentInfoType.Conforming,
-            "convexHull": self._pedb.core.utility.utility.HFSSExtentInfoType.ConvexHull,
-            "polygon": self._pedb.core.utility.utility.HFSSExtentInfoType.Polygon,
+            "bounding_box": self._pedb.core.Utility.HFSSExtentInfoType.BoundingBox,
+            "conforming": self._pedb.core.Utility.HFSSExtentInfoType.Conforming,
+            "convexHull": self._pedb.core.Utility.HFSSExtentInfoType.ConvexHull,
+            "polygon": self._pedb.core.Utility.HFSSExtentInfoType.Polygon,
         }
         self._open_region_type = {
-            "radiation": self._pedb.core.utility.utility.OpenRegionType.Radiation,
-            "pml": self._pedb.core.utility.utility.OpenRegionType.PML,
+            "radiation": self._pedb.core.Utility.OpenRegionType.Radiation,
+            "pml": self._pedb.core.Utility.OpenRegionType.PML,
         }
 
     def _get_edb_value(self, value):

pyedb/dotnet/database/edb_data/layer_data.py

@@ -49,7 +49,7 @@ class LayerEdbClass(object):
         layer_type = self._layer_name_mapping[layer_type]
         layer_type = self._doc_layer_mapping[layer_type]
 
-        self._edb_object = self._pedb.core.cell._cell.Layer(
+        self._edb_object = self._pedb.core.Cell.Layer(
             self._name,
             layer_type,
         )
@@ -83,30 +83,30 @@ class LayerEdbClass(object):
     @property
     def _stackup_layer_mapping(self):
         return {
-            "SignalLayer": self._edb.cell.layer_type.SignalLayer,
-            "DielectricLayer": self._edb.cell.layer_type.DielectricLayer,
+            "SignalLayer": self._edb.Cell.LayerType.SignalLayer,
+            "DielectricLayer": self._edb.Cell.LayerType.DielectricLayer,
         }
 
     @property
     def _doc_layer_mapping(self):
         return {
-            "ConductingLayer": self._edb.cell.layer_type.ConductingLayer,
-            "AirlinesLayer": self._edb.cell.layer_type.AirlinesLayer,
-            "ErrorsLayer": self._edb.cell.layer_type.ErrorsLayer,
-            "SymbolLayer": self._edb.cell.layer_type.SymbolLayer,
-            "MeasureLayer": self._edb.cell.layer_type.MeasureLayer,
-            "AssemblyLayer": self._edb.cell.layer_type.AssemblyLayer,
-            "SilkscreenLayer": self._edb.cell.layer_type.SilkscreenLayer,
-            "SolderMaskLayer": self._edb.cell.layer_type.SolderMaskLayer,
-            "SolderPasteLayer": self._edb.cell.layer_type.SolderPasteLayer,
-            "GlueLayer": self._edb.cell.layer_type.GlueLayer,
-            "WirebondLayer": self._edb.cell.layer_type.WirebondLayer,
-            "UserLayer": self._edb.cell.layer_type.UserLayer,
-            "SIwaveHFSSSolverRegions": self._edb.cell.layer_type.SIwaveHFSSSolverRegions,
-            "PostprocessingLayer": self._edb.cell.layer_type.PostprocessingLayer,
-            "OutlineLayer": self._edb.cell.layer_type.OutlineLayer,
-            "LayerTypesCount": self._edb.cell.layer_type.LayerTypesCount,
-            "UndefinedLayerType": self._edb.cell.layer_type.UndefinedLayerType,
+            "ConductingLayer": self._edb.Cell.LayerType.ConductingLayer,
+            "AirlinesLayer": self._edb.Cell.LayerType.AirlinesLayer,
+            "ErrorsLayer": self._edb.Cell.LayerType.ErrorsLayer,
+            "SymbolLayer": self._edb.Cell.LayerType.SymbolLayer,
+            "MeasureLayer": self._edb.Cell.LayerType.MeasureLayer,
+            "AssemblyLayer": self._edb.Cell.LayerType.AssemblyLayer,
+            "SilkscreenLayer": self._edb.Cell.LayerType.SilkscreenLayer,
+            "SolderMaskLayer": self._edb.Cell.LayerType.SolderMaskLayer,
+            "SolderPasteLayer": self._edb.Cell.LayerType.SolderPasteLayer,
+            "GlueLayer": self._edb.Cell.LayerType.GlueLayer,
+            "WirebondLayer": self._edb.Cell.LayerType.WirebondLayer,
+            "UserLayer": self._edb.Cell.LayerType.UserLayer,
+            "SIwaveHFSSSolverRegions": self._edb.Cell.LayerType.SIwaveHFSSSolverRegions,
+            "PostprocessingLayer": self._edb.Cell.LayerType.PostprocessingLayer,
+            "OutlineLayer": self._edb.Cell.LayerType.OutlineLayer,
+            "LayerTypesCount": self._edb.Cell.LayerType.LayerTypesCount,
+            "UndefinedLayerType": self._edb.Cell.LayerType.UndefinedLayerType,
         }
 
     @property
@@ -289,7 +289,7 @@ class StackupLayerEdbClass(LayerEdbClass):
     def _create(self, layer_type):
         layer_type_edb_name = self._layer_name_mapping[layer_type]
         layer_type = self._layer_type_mapping[layer_type_edb_name]
-        self._edb_object = self._pedb.core.cell._cell.StackupLayer(
+        self._edb_object = self._pedb.core.Cell.StackupLayer(
             self._name,
             layer_type,
             self._pedb.edb_value(0),
@@ -800,7 +800,7 @@ class StackupLayerEdbClass(LayerEdbClass):
             "factor": self._edb_layer.GetEtchFactor().ToString(),
             "enabled": self._edb_layer.IsEtchFactorEnabled(),
         }
-        if self._pedb.edbversion >= "2024.2":
+        if self._pedb.version >= "2024.2":
             etch_power_ground_nets = int(self._edb_layer.GetEtchNetClass())
             etch_power_ground_nets = False if etch_power_ground_nets else True
             data["etching"]["etch_power_ground_nets"] = etch_power_ground_nets
@@ -869,7 +869,7 @@ class StackupLayerEdbClass(LayerEdbClass):
             layer_clone = self._edb_layer
             layer_clone.SetEtchFactorEnabled(etching["enabled"])
             layer_clone.SetEtchFactor(self._pedb.stackup._edb_value(float(etching["factor"])))
-            if self._pedb.edbversion >= "2024.2":
+            if self._pedb.version >= "2024.2":
                 if etching["etch_power_ground_nets"]:
                     layer_clone.SetEtchNetClass(self._pedb._edb.Cell.EtchNetClass.NoEtchPowerGroundNets)
                 else: