pyedb 0.50.0__py3-none-any.whl → 0.51.2__py3-none-any.whl

pyedb/grpc/edb.py

@@ -20,10 +20,40 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-"""This module contains the ``Edb`` class.
-
-This module is implicitly loaded in HFSS 3D Layout when launched.
-
+"""Provides the main interface for interacting with Ansys Electronics Desktop Database (EDB).
+
+This module contains the ``Edb`` class which serves as the primary interface for:
+- Creating and managing EDB projects
+- Importing/exporting layout files
+- Configuring stackups, materials, and components
+- Setting up simulations (HFSS, SIwave, RaptorX)
+- Performing cutout operations
+- Generating ports and excitations
+- Parametrizing designs
+- Exporting to various formats (IPC2581, HFSS, Q3D)
+
+Key Functionality:
+- Database initialization and management
+- Layout manipulation and cutout generation
+- Material and stackup configuration
+- Net and component management
+- Simulation setup and execution
+- Design parametrization and optimization
+
+Examples
+--------
+Basic EDB initialization:
+>>> from pyedb.grpc.edb import Edb
+>>> edb = Edb(edbpath="myproject.aedb")
+
+Importing a board file:
+>>> edb.import_layout_file("my_board.brd")
+
+Creating a cutout:
+>>> edb.cutout(signal_list=["Net1", "Net2"], reference_list=["GND"])
+
+Exporting to HFSS:
+>>> edb.export_hfss(r"C:\output_folder")
 """
 
 from itertools import combinations
@@ -102,100 +132,60 @@ from pyedb.workflow import Workflow
 
 
 class Edb(EdbInit):
-    """Provides the EDB application interface.
+    """Main class for interacting with Ansys Electronics Desktop Database (EDB).
 
-    This module inherits all objects that belong to EDB.
+    Provides comprehensive control over EDB projects including:
+    - Project creation/management
+    - Layout import/export
+    - Material/stackup configuration
+    - Component/net management
+    - Simulation setup
+    - Cutout operations
+    - Parameterization
 
     Parameters
     ----------
-    edbpath : str, optional
-        Full path to the ``aedb`` folder. The variable can also contain
-        the path to a layout to import. Allowed formats are BRD, MCM,
-        XML (IPC2581), GDS, ODB++(TGZ and ZIP) and DXF. The default is ``None``.
-        For GDS import, the Ansys control file (also XML) should have the same
-        name as the GDS file. Only the file extension differs.
+    edbpath : str or Path, optional
+        Full path to AEDB folder or layout file to import. Supported formats:
+        BRD, MCM, XML (IPC2581), GDS, ODB++ (TGZ/ZIP), DXF.
+        Default creates new AEDB in documents folder.
     cellname : str, optional
-        Name of the cell to select. The default is ``None``.
+        Specific cell to open. Default opens first cell.
     isreadonly : bool, optional
-        Whether to open EBD in read-only mode when it is
-        owned by HFSS 3D Layout. The default is ``False``.
+        Open in read-only mode. Default False.
     edbversion : str, int, float, optional
-        Version of EDB to use. The default is ``None``.
-        Examples of input values are ``232``, ``23.2``, ``2023.2``, ``"2023.2"``.
+        EDB version (e.g., "2023.2", 232, 23.2). Default uses latest.
     isaedtowned : bool, optional
-        Whether to launch EDB from HFSS 3D Layout. The
-        default is ``False``.
-    oproject : optional
-        Reference to the AEDT project object.
+        Launch from HFSS 3D Layout. Default False.
+    oproject : object, optional
+        Reference to AEDT project object.
     student_version : bool, optional
-        Whether to open the AEDT student version. The default is ``False.``
+        Use student version. Default False.
+    use_ppe : bool, optional
+        Use PPE license. Default False.
     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.
+        XML control file path for import.
     map_file : str, optional
-        Layer map .map file.
+        Layer map file for import.
     technology_file : str, optional
-        Full path to technology file to be converted to xml before importing or xml.
-        Supported by GDS format only.
-    layer_filter:str,optional
-        Layer filter .txt file.
+        Technology file for import (GDS only).
+    layer_filter : str, optional
+        Layer filter file for import.
+    remove_existing_aedt : bool, optional
+        Remove existing AEDT project files. Default False.
     restart_rpc_server : bool, optional
-        ``True`` RPC server is terminated and restarted. This will close all open EDB. RPC server is running on single
-        instance loading all EDB, enabling this option should be used with caution but can be a solution to release
-        memory in case the server is draining resources. Default value is ``False``.
+        Restart gRPC server. Use with caution. Default False.
 
     Examples
     --------
-    Create :class:`Edb <pyedb.grpc.edb.Edb>` object.
-
-    >>> from pyedb.grpc.edb import Edb as Edb
-    >>> app = Edb()
-
-    Add a new variable named "s1" to the ``Edb`` instance.
-
-    >>> app['s1'] = "0.25 mm"
-    >>> app['s1']
-    >>> 0.00025
-
-    Create an ``Edb`` object and open the specified project.
-
-    >>> app = Edb(edbpath="myfile.aedb")
-
-    Create an ``Edb`` object from GDS and control files.
-    The XML control file resides in the same directory as the GDS file: (myfile.xml).
-
-    >>> app = Edb("/path/to/file/myfile.gds")
-
-    Loading Ansys layout
-
-    >>> from ansys.aedt.core.generic.general_methods import generate_unique_folder_name
-    >>> import pyedb.misc.downloads as downloads
-    >>> temp_folder = generate_unique_folder_name()
-    >>> targetfile = downloads.download_file("edb/ANSYS-HSD_V1.aedb", destination=temp_folder)
-    >>> from pyedb.grpc.edb import Edb as Edb
-    >>> edbapp = Edb(edbpath=targetfile)
-
-    Retrieving signal nets dictionary
-
-    >>> edbapp.nets.signal
-
-    Retrieving layers
-
-    >>> edbapp.stackup.layers
+    Create new EDB:
+    >>> edb = Edb()
 
-    Retrieving all component instances
-
-    >>> edbapp.components.instances
-
-    Retrieving all padstacks definitions
-
-    >>> edbapp.padstacks.definitions
-
-    Retrieving component pins
-
-    >>> edbapp.components["U1"].pins
+    Open existing AEDB:
+    >>> edb = Edb("myproject.aedb")
 
+    Import board file:
+    >>> edb = Edb("my_board.brd")
     """
 
     def __init__(
@@ -309,38 +299,39 @@ class Edb(EdbInit):
         self._layout_instance = None
 
     def __enter__(self):
+        """Context manager entry."""
         return self
 
     def __exit__(self, ex_type, ex_value, ex_traceback):
+        """Context manager exit. Closes EDB and cleans up resources."""
         self._signal_handler(ex_type, ex_value)
 
     def __getitem__(self, variable_name):
-        """Get a variable to the Edb project. The variable can be project using ``$`` prefix or
-        it can be a design variable, in which case the ``$`` is omitted.
+        """Get project or design variable value.
 
         Parameters
         ----------
         variable_name : str
+            Variable name with '$' for project variables.
 
         Returns
         -------
-        variable object.
-
+        float or None
+            Variable value if exists, else None.
         """
         if self.variable_exists(variable_name):
             return self.variables[variable_name]
         return
 
     def __setitem__(self, variable_name, variable_value):
-        """Set a variable to the Edb project. The variable can be project using ``$`` prefix or
-        it can be a design variable, in which case the ``$`` is omitted.
+        """Set project or design variable.
 
         Parameters
         ----------
         variable_name : str
-            variable name.
-        variable_value : str, float, int.
-            variable value.
+            Variable name (with '$' prefix for project variables).
+        variable_value : str, float, int, list/tuple
+            Value with units. List/tuple format: [value, description]
         """
         type_error_message = "Allowed values are str, numeric or two-item list with variable description."
         if type(variable_value) in [
@@ -387,23 +378,6 @@ class Edb(EdbInit):
                     except:
                         self.logger.info(f"Failed to delete AEDT project-related file {file}.")
 
-    def _clean_variables(self):
-        """Initialize internal variables and perform garbage collection."""
-        self.grpc = True
-        self._materials = None
-        self._components = None
-        self._core_primitives = None
-        self._stackup = None
-        self._padstack = None
-        self._siwave = None
-        self._hfss = None
-        self._nets = None
-        self._layout_instance = None
-        self._variables = None
-        self._active_cell = None
-        self._layout = None
-        self._configuration = None
-
     def _init_objects(self):
         self._components = Components(self)
         self._stackup = Stackup(self, self.layout.layer_collection)
@@ -419,53 +393,56 @@ class Edb(EdbInit):
 
     @property
     def cell_names(self) -> [str]:
-        """Cell name container.
+        """List of all cell names in the database.
 
         Returns
         -------
-        list of cell names : List[str]
+        list[str]
+            Names of all circuit cells.
         """
         return [cell.name for cell in self.active_db.top_circuit_cells]
 
     @property
     def design_variables(self) -> dict[str, float]:
-        """Get all edb design variables.
+        """All design variables in active cell.
 
         Returns
         -------
-        variable dictionary : Dict[str, variable_name: float, variable_value]
+        dict[str, float]
+            Variable names and values.
         """
         return {i: self.active_cell.get_variable_value(i).value for i in self.active_cell.get_all_variable_names()}
 
     @property
     def project_variables(self) -> dict[str, float]:
-        """Get all project variables.
+        """All project variables in database.
 
         Returns
         -------
-        variables dictionary : dict[str, variable_name: float, variable_value]
-
+        dict[str, float]
+            Variable names and values.
         """
         return {i: self.active_db.get_variable_value(i).value for i in self.active_db.get_all_variable_names()}
 
     @property
     def layout_validation(self) -> LayoutValidation:
-        """Return LayoutValidation object.
+        """Layout validation utilities.
 
         Returns
         -------
         :class:`LayoutValidation <pyedb.grpc.database.layout_validation.LayoutValidation>`
+            Tools for design rule checking and layout validation.
         """
         return LayoutValidation(self)
 
     @property
     def variables(self) -> dict[str, float]:
-        """Get all Edb variables.
+        """All variables (project + design) in database.
 
         Returns
         -------
-        variables dictionary : Dict[str: float]
-
+        dict[str, float]
+            Combined dictionary of all variables.
         """
         all_vars = dict()
         for i, j in self.project_variables.items():
@@ -476,23 +453,24 @@ class Edb(EdbInit):
 
     @property
     def terminals(self) -> dict[str, Terminal]:
-        """Get terminals belonging to active layout.
+        """Terminals in active layout.
 
         Returns
         -------
-        Dict : Dict[str: :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`],
+        dict[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`]
+            Terminal names and objects.
         """
         return {i.name: i for i in self.layout.terminals}
 
     @property
     def excitations(self) -> dict[str, GapPort]:
-        """Get all layout excitations.
+        """All layout excitations.
 
         Returns
         -------
-        Dict: Dict[str: :class:`<pyedb.grpc.database.port.GapPort>`]
+        dict[str, :class:`GapPort <pyedb.grpc.database.ports.ports.GapPort>`]
+            Excitation names and objects.
         """
-
         terms = [term for term in self.layout.terminals if term.boundary_type == "port"]
         temp = {}
         for term in terms:
@@ -504,13 +482,12 @@ class Edb(EdbInit):
 
     @property
     def ports(self) -> dict[str, GapPort]:
-        """Get all ports.
+        """All ports in design.
 
         Returns
         -------
-        port dictionary : Dict[str: :class:`GapPort <pyedb.grpc.database.ports.GapPort>` or
-        :class:`WavePort <pyedb.grpc.database.ports.WavePort>`]
-
+        dict[str, Union[:class:`GapPort`, :class:`WavePort`, :class:`CoaxPort`]]
+            Port names and objects.
         """
         terminals = [term for term in self.layout.terminals if not term.is_reference_terminal]
         ports = {}
@@ -538,34 +515,34 @@ class Edb(EdbInit):
 
     @property
     def excitations_nets(self) -> [str]:
-        """Get all net names with excitation defined.
+        """Nets with excitations defined.
 
         Returns
         -------
-        List[str]
-            List of net name.
+        list[str]
+            Net names with excitations.
         """
         return list(set([i.net.name for i in self.layout.terminals if not i.is_reference_terminal]))
 
     @property
     def sources(self) -> dict[str, Terminal]:
-        """Get all layout sources.
+        """All layout sources.
 
         Returns
         -------
-        Dict: Dic[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`]
+        dict[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`]
+            Source names and objects.
         """
         return self.terminals
 
     @property
     def voltage_regulator_modules(self):
-        """Get all voltage regulator modules
+        """Voltage regulator modules in design.
 
         Returns
         -------
-        List of voltage regulator modules.
-         List[:class:`VoltageRegulator <pyedb.grpc.database.layout.voltage_regulator.VoltageRegulator>`]
-
+        dict[str, :class:`VoltageRegulator <pyedb.grpc.database.layout.voltage_regulator.VoltageRegulator>`]
+            VRM names and objects.
         """
         vrms = self.layout.voltage_regulators
         _vrms = {}
@@ -575,28 +552,34 @@ class Edb(EdbInit):
 
     @property
     def probes(self) -> dict[str, Terminal]:
-        """Get all layout probes.
+        """All layout probes.
 
         Returns
         -------
-        Dictionary of probes.
-            Dict[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`
+        dict[str, :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`]
+            Probe names and objects.
         """
         terms = [term for term in self.layout.terminals if term.boundary_type.value == 8]
         return {ter.name: ter for ter in terms}
 
-    def open_edb(self, restart_rpc_server=False) -> bool:
-        """Open EDB.
+    def open(self, restart_rpc_server=False) -> bool:
+        """Open EDB database.
 
         Returns
         -------
-        bool: `True` when succeed `False` if failed.
+        bool
+            True if successful, False otherwise.
+
+        Examples
+        --------
+        Open an existing EDB database:
+        >>> edb = Edb("myproject.aedb")
         """
         self.standalone = self.standalone
         n_try = 10
         while not self.db and n_try:
             try:
-                self.open(
+                self._open(
                     self.edbpath,
                     self.isreadonly,
                     restart_rpc_server=restart_rpc_server,
@@ -626,12 +609,27 @@ class Edb(EdbInit):
                 self.logger.error("Builder was not initialized.")
             return True
 
-    def create_edb(self, restart_rpc_server=False) -> bool:
-        """Create EDB.
+    def open_edb(self, restart_rpc_server=False) -> bool:
+        """Open EDB database.
+
+        .. deprecated:: 0.50.1
+            Use :func:`open` instead.
 
         Returns
         -------
-        bool: `True` when succeed `False` if failed.
+        bool
+            True if successful, False otherwise.
+        """
+        warnings.warn("`open_edb` is deprecated use `open` instead.", DeprecationWarning)
+        return self.open(restart_rpc_server)
+
+    def create(self, restart_rpc_server=False) -> any:
+        """Create new EDB database.
+
+        Returns
+        -------
+        bool
+            True if successful, False otherwise.
         """
         from ansys.edb.core.layout.cell import Cell as GrpcCell
         from ansys.edb.core.layout.cell import CellType as GrpcCellType
@@ -640,7 +638,7 @@ class Edb(EdbInit):
         n_try = 10
         while not self.db and n_try:
             try:
-                self.create(self.edbpath, restart_rpc_server=restart_rpc_server)
+                self._create(self.edbpath, restart_rpc_server=restart_rpc_server)
                 n_try -= 1
             except Exception as e:
                 self.logger.error(e.args[0])
@@ -655,9 +653,22 @@ class Edb(EdbInit):
             )
         if self._active_cell:
             self._init_objects()
-            return True
+            return self
         return None
 
+    def create_edb(self, restart_rpc_server=False) -> bool:
+        """
+        .. deprecated:: 0.50.1
+            Use :func:`create` instead.
+
+        Returns
+        -------
+        bool
+            True if successful, False otherwise.
+        """
+        warnings.warn("`create_edb` is deprecated use `create` instead.", DeprecationWarning)
+        return self.create(restart_rpc_server)
+
     def import_layout_pcb(
         self,
         input_file,
@@ -669,38 +680,33 @@ class Edb(EdbInit):
         tech_file=None,
         layer_filter=None,
     ):
-        """Import a board file and generate an ``edb.def`` file in the working directory.
-
-        .. deprecated:: 0.42.0
-           Use :func:`import_layout_file` method instead.
+        """Import layout file and generate AEDB.
 
-        This function supports all AEDT formats, including DXF, GDS, SML (IPC2581), BRD, MCM, SIP, ZIP and TGZ.
+        Supported formats: BRD, MCM, XML (IPC2581), GDS, ODB++ (TGZ/ZIP), DXF
 
         Parameters
         ----------
         input_file : str
-            Full path to the board file.
+            Full path to input file.
         working_dir : str, optional
-            Directory in which to create the ``aedb`` folder. The name given to the AEDB file
-            is the same as the name of the board file.
+            Output directory for AEDB.
         anstranslator_full_path : str, optional
-            Full path to the Ansys translator. The default is ``""``.
-        use_ppe : bool
-            Whether to use the PPE License. The default is ``False``.
+            Path to Ansys translator executable.
+        use_ppe : bool, optional
+            Use PPE license. Default False.
         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.
+            XML control file path.
         tech_file : str, optional
-            Technology file. The file can be *.ircx, *.vlc.tech, or *.itf
+            Technology file path.
         map_file : str, optional
-            Layer map .map file.
-        layer_filter:str,optional
-            Layer filter .txt file.
+            Layer map file path.
+        layer_filter : str, optional
+            Layer filter file path.
 
         Returns
         -------
-        Full path to the AEDB file : str
+        str or bool
+            AEDB path if successful, False otherwise.
         """
         self.logger.warning("import_layout_pcb method is deprecated, use import_layout_file instead.")
         return self.import_layout_file(
@@ -755,6 +761,13 @@ class Edb(EdbInit):
         -------
         Full path to the AEDB file : str
 
+        Examples
+        --------
+        Import a BRD file:
+        >>> edb.import_layout_file("my_board.brd", r"C:/project")
+
+        Import a GDS file with control file:
+        >>> edb.import_layout_file("layout.gds", control_file="control.xml")
         """
         self._components = None
         self._core_primitives = None
@@ -802,29 +815,24 @@ class Edb(EdbInit):
         return self.open_edb()
 
     def export_to_ipc2581(self, ipc_path=None, units="MILLIMETER") -> str:
-        """Create an XML IPC2581 file from the active EDB.
-
-        .. note::
-           The method works only in CPython because of some limitations on Ironpython in XML parsing and
-           because it's time-consuming.
-           This method is still being tested and may need further debugging.
-           Any feedback is welcome. Back drills and custom pads are not supported yet.
+        """Export design to IPC2581 format.
 
         Parameters
         ----------
         ipc_path : str, optional
-            Path to the XML IPC2581 file. The default is ``None``, in which case
-            an attempt is made to find the XML IPC2581 file in the same directory
-            as the active EDB. To succeed, the XML IPC2581 file and the active
-            EDT must have the same name. Only the extension differs.
+            Output XML file path. Default: <edb_path>.xml.
         units : str, optional
-            Units of the XML IPC2581 file. Options are ``"millimeter"``,
-            ``"inch"``, and ``"micron"``. The default is ``"millimeter"``.
+            Output units ("millimeter", "inch", "micron"). Default millimeter.
 
         Returns
         -------
-        bool: `True` if successful, `False` if failed.
+        str or bool
+            Output file path if successful, False otherwise.
 
+        Examples
+        --------
+        Export to IPC2581 format:
+        >>> edb.export_to_ipc2581("output.xml")
         """
         if units.lower() not in ["millimeter", "inch", "micron"]:  # pragma no cover
             self.logger.warning("The wrong unit is entered. Setting to the default, millimeter.")
@@ -848,30 +856,26 @@ class Edb(EdbInit):
 
     @property
     def configuration(self) -> Configuration:
-        """Edb project configuration from a file.
+        """Project configuration manager.
 
         Returns
         -------
-        :class:`Configuration <pyedb.configuration.configuration.Configuration>`.
+        :class:`Configuration <pyedb.configuration.configuration.Configuration>`
+            Configuration file interface.
         """
         if not self._configuration:
             self._configuration = Configuration(self)
         return self._configuration
 
     def edb_exception(self, ex_value, tb_data):
-        """Write the trace stack to AEDT when a Python error occurs.
+        """Log Python exceptions to EDB logger.
 
         Parameters
         ----------
-        ex_value :
-
-        tb_data :
-
-
-        Returns
-        -------
-        None
-
+        ex_value : Exception
+            Exception value.
+        tb_data : traceback
+            Traceback object.
         """
         tb_trace = traceback.format_tb(tb_data)
         tblist = tb_trace[0].split("\n")
@@ -881,26 +885,40 @@ class Edb(EdbInit):
 
     @property
     def active_db(self):
-        """Database object.
+        """Active database object.
 
         Returns
         -------
-        :class:`Database <ansys.edb.core.database.Database>`.
+        :class:`ansys.edb.core.database.Database`
+            Current database instance.
         """
         return self.db
 
     @property
     def active_cell(self):
-        """Active cell.
+        """Active cell in the database.
 
         Returns
         -------
-        :class:`Cell <ansys.edb.core.layout.cell.Cell>`.
+        :class:`ansys.edb.core.layout.cell.Cell`
+            Currently active cell.
         """
         return self._active_cell
 
     @active_cell.setter
     def active_cell(self, value):
+        """Set active cell by name or object.
+
+        Parameters
+        ----------
+        value : str or ansys.edb.core.layout.cell.Cell
+            Cell name or object to set as active.
+
+        Raises
+        ------
+        ValueError
+            If cell not found in database.
+        """
         if isinstance(value, str):
             _cell = [cell for cell in self.circuit_cells if cell.name == value]
             if _cell:
@@ -918,17 +936,12 @@ class Edb(EdbInit):
 
     @property
     def components(self) -> Components:
-        """Edb Components methods and properties.
+        """Component management interface.
 
         Returns
         -------
-        :class:`Components <pyedb.grpc.database.components.Components>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> comp = edbapp.components.get_component_by_name("J1")
+        :class:`Components <pyedb.grpc.database.components.Components>`
+            Component manipulation tools.
         """
         if not self._components and self.active_db:
             self._components = Components(self)
@@ -936,19 +949,12 @@ class Edb(EdbInit):
 
     @property
     def stackup(self) -> Stackup:
-        """Stackup manager.
+        """Stackup management interface.
 
         Returns
         -------
         :class:`Stackup <pyedb.grpc.database.stackup.Stackup>`
-
-        Examples
-        --------
-        >>> from pyedb.grpc.edb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> edbapp.stackup.layers["TOP"].thickness = 4e-5
-        >>> edbapp.stackup.layers["TOP"].thickness == 4e-05
-        >>> edbapp.stackup.add_layer("Diel", "GND", layer_type="dielectric", thickness="0.1mm", material="FR4_epoxy")
+            Layer stack configuration tools.
         """
         if self.active_db:
             self._stackup = Stackup(self, self.active_cell.layout.layer_collection)
@@ -956,30 +962,24 @@ class Edb(EdbInit):
 
     @property
     def source_excitation(self) -> SourceExcitation:
-        """Returns layout source excitations.
+        """Source excitation management.
 
         Returns
         -------
-        :class:`SourceExcitation <pyedb.grpc.database.source_excitations.SourceExcitation>`.
+        :class:`SourceExcitation <pyedb.grpc.database.source_excitations.SourceExcitation>`
+            Source and port creation tools.
         """
         if self.active_db:
             return self._source_excitation
 
     @property
     def materials(self) -> Materials:
-        """Material Database.
+        """Material database interface.
 
         Returns
         -------
-        :class:`Materials <pyedb.grpc.database.definition.materials.Materials>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb()
-        >>> edbapp.materials.add_material("air", permittivity=1.0)
-        >>> edbapp.materials.add_debye_material("debye_mat", 5, 3, 0.02, 0.05, 1e5, 1e9)
-        >>> edbapp.materials.add_djordjevicsarkar_material("djord_mat", 3.3, 0.02, 3.3)
+        :class:`Materials <pyedb.grpc.database.definition.materials.Materials>`
+            Material definition and management.
         """
         if self.active_db:
             self._materials = Materials(self)
@@ -987,40 +987,25 @@ class Edb(EdbInit):
 
     @property
     def padstacks(self) -> Padstacks:
-        """Returns padstack object.
-
+        """Padstack management interface.
 
         Returns
         -------
-        :class:`Padstacks <pyedb.grpc.database.padstack.Padstacks>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> p = edbapp.padstacks.create(padstackname="myVia_bullet", antipad_shape="Bullet")
-        >>> edbapp.padstacks.get_pad_parameters(
-        >>> ... p, "TOP", edbapp.padstacks.pad_type.RegularPad
-        >>> ... )
+        :class:`Padstacks <pyedb.grpc.database.padstack.Padstacks>`
+            Padstack definition and editing.
         """
-
         if not self._padstack and self.active_db:
             self._padstack = Padstacks(self)
         return self._padstack
 
     @property
     def siwave(self) -> Siwave:
-        """Returns SIWave object.
+        """SIwave simulation interface.
 
         Returns
         -------
-        :class:`Siwave <pyedb.grpc.database.siwave.Siwave>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> p2 = edbapp.siwave.create_circuit_port_on_net("U2A5", "V3P3_S0", "U2A5", "GND", 50, "test")
+        :class:`Siwave <pyedb.grpc.database.siwave.Siwave>`
+            SIwave analysis setup tools.
         """
         if not self._siwave and self.active_db:
             self._siwave = Siwave(self)
@@ -1028,19 +1013,12 @@ class Edb(EdbInit):
 
     @property
     def hfss(self) -> Hfss:
-        """Returns HFSS object.
+        """HFSS simulation interface.
 
         Returns
         -------
-        :class:`Hfss <pyedb.grpc.database.hfss.Hfss>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> sim_config = edbapp.new_simulation_configuration()
-        >>> sim_config.mesh_freq = "10Ghz"
-        >>> edbapp.hfss.configure_hfss_analysis_setup(sim_config)
+        :class:`Hfss <pyedb.grpc.database.hfss.Hfss>`
+            HFSS analysis setup tools.
         """
         if not self._hfss and self.active_db:
             self._hfss = Hfss(self)
@@ -1048,74 +1026,50 @@ class Edb(EdbInit):
 
     @property
     def nets(self) -> Nets:
-        """Returns nets object.
+        """Net management interface.
 
         Returns
         -------
-        :class:`Nets <pyedb.grpc.database.nets.Nets>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb"myproject.aedb")
-        >>> edbapp.nets.find_or_create_net("GND")
-        >>> edbapp.nets.find_and_fix_disjoint_nets("GND", keep_only_main_net=True)
+        :class:`Nets <pyedb.grpc.database.nets.Nets>`
+            Net manipulation tools.
         """
-
         if not self._nets and self.active_db:
             self._nets = Nets(self)
         return self._nets
 
     @property
     def net_classes(self) -> NetClass:
-        """Returns net classes object.
+        """Net class management.
 
         Returns
         -------
-        :class:`NetClass <pyedb.grpc.database.net.net_class.NetClass>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> edbapp.net_classes
+        dict[str, :class:`NetClass <pyedb.grpc.database.net.net_class.NetClass>`]
+            Net class names and objects.
         """
-
         if self.active_db:
             return {net.name: NetClass(self, net) for net in self.active_layout.net_classes}
 
     @property
     def extended_nets(self) -> ExtendedNets:
-        """Returns extended nets.
+        """Extended net management.
 
         Returns
         -------
-        :class:`ExtendedNets <pyedb.grpc.database.net.extended_net.ExtendedNets>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> edbapp.extended_nets
+        :class:`ExtendedNets <pyedb.grpc.database.net.extended_net.ExtendedNets>`
+            Extended net tools.
         """
-
         if not self._extended_nets:
             self._extended_nets = ExtendedNets(self)
         return self._extended_nets
 
     @property
     def differential_pairs(self) -> DifferentialPairs:
-        """Returns differential pairs.
+        """Differential pair management.
 
         Returns
         -------
-        :class:`DifferentialPairs <pyedb.grpc.database.net.differential_par.DifferentialPairs>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> edbapp.differential_pairs
+        :class:`DifferentialPairs <pyedb.grpc.database.net.differential_par.DifferentialPairs>`
+            Differential pair tools.
         """
         if not self._differential_pairs and self.active_db:
             self._differential_pairs = DifferentialPairs(self)
@@ -1123,17 +1077,12 @@ class Edb(EdbInit):
 
     @property
     def modeler(self) -> Modeler:
-        """Returns primitives modeler object.
+        """Geometry modeling interface.
 
         Returns
         -------
-        :class:`Modeler <pyedb.grpc.database.modeler.Modeler>`.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> top_prims = edbapp.modeler.primitives_by_layer["TOP"]
+        :class:`Modeler <pyedb.grpc.database.modeler.Modeler>`
+            Geometry creation and editing.
         """
         if not self._modeler and self.active_db:
             self._modeler = Modeler(self)
@@ -1141,46 +1090,51 @@ class Edb(EdbInit):
 
     @property
     def layout(self) -> Layout:
-        """Returns Layout object.
+        """Layout access interface.
 
         Returns
         -------
-        :class:`Layout <pyedb.grpc.database.layout.layout.Layout>`.
+        :class:`Layout <pyedb.grpc.database.layout.layout.Layout>`
+            Layout manipulation tools.
         """
         return Layout(self)
 
     @property
     def active_layout(self) -> Layout:
-        """Active layout.
+        """Active layout access.
 
         Returns
         -------
-        :class:`Layout <pyedb.grpc.database.layout.layout.Layout>`.
+        :class:`Layout <pyedb.grpc.database.layout.layout.Layout>`
+            Current layout tools.
         """
         return self.layout
 
     @property
     def layout_instance(self):
-        """Returns Layout Instance object.
+        """Layout instance object.
 
         Returns
         -------
         :class:`LayoutInstance <ansys.edb.core.layout_instance.layout_instance.LayoutInstance>`
+            Current layout instance.
         """
         if not self._layout_instance:
             self._layout_instance = self.layout.layout_instance
         return self._layout_instance
 
     def get_connected_objects(self, layout_object_instance):
-        """Returns connected objects.
+        """Get objects connected to a layout object.
+
+        Parameters
+        ----------
+        layout_object_instance :
+            Target layout object.
 
         Returns
         -------
-        list[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`,
-        :class:`Path <pyedb.grpc.database.primitive.path.Path>`,
-        :class:`Rectangle <pyedb.grpc.database.primitive.rectangle.Rectangle>`,
-        :class:`Circle <pyedb.grpc.database.primitive.circle.Circle>`,
-        :class:`Polygon <pyedb.grpc.database.primitive.polygon.Polygon>`]
+        list
+            Connected objects (padstacks, paths, polygons, etc.).
         """
         from ansys.edb.core.terminal.padstack_instance_terminal import (
             PadstackInstanceTerminal as GrpcPadstackInstanceTerminal,
@@ -1213,39 +1167,40 @@ class Edb(EdbInit):
         return temp
 
     def point_3d(self, x, y, z=0.0):
-        """Compute the Edb 3d Point Data.
+        """Create 3D point.
 
         Parameters
         ----------
-        x : float, int or str
-            X value.
-        y : float, int or str
-            Y value.
-        z : float, int or str, optional
-            Z value.
+        x : float, int, str
+            X coordinate.
+        y : float, int, str
+            Y coordinate.
+        z : float, int, str, optional
+            Z coordinate.
 
         Returns
         -------
         :class:`Point3DData <pyedb.grpc.database.geometry.point_3d_data.Point3DData>`
+            3D point object.
         """
         from pyedb.grpc.database.geometry.point_3d_data import Point3DData
 
         return Point3DData(x, y, z)
 
     def point_data(self, x, y=None):
-        """Compute the Edb Point Data.
+        """Create 2D point.
 
         Parameters
         ----------
-        x : float, int or str
-            X value.
-        y : float, int or str, optional
-            Y value.
-
+        x : float, int, str or PointData
+            X coordinate or PointData object.
+        y : float, int, str, optional
+            Y coordinate.
 
         Returns
         -------
         :class:`PointData <pyedb.grpc.database.geometry.point_data.PointData>`
+            2D point object.
         """
         from pyedb.grpc.database.geometry.point_data import PointData
 
@@ -1254,18 +1209,6 @@ class Edb(EdbInit):
         else:
             return PointData(x, y)
 
-    @staticmethod
-    def _is_file_existing_and_released(filename) -> bool:
-        if os.path.exists(filename):
-            try:
-                os.rename(filename, filename + "_")
-                os.rename(filename + "_", filename)
-                return True
-            except OSError as e:
-                return False
-        else:
-            return False
-
     @staticmethod
     def _is_file_existing(filename) -> bool:
         if os.path.exists(filename):
@@ -1273,18 +1216,6 @@ class Edb(EdbInit):
         else:
             return False
 
-    def _wait_for_file_release(self, timeout=30, file_to_release=None) -> bool:
-        if not file_to_release:
-            file_to_release = os.path.join(self.edbpath)
-        tstart = time.time()
-        while True:
-            if self._is_file_existing_and_released(file_to_release):
-                return True
-            elif time.time() - tstart > timeout:
-                return False
-            else:
-                time.sleep(0.250)
-
     def _wait_for_file_exists(self, timeout=30, file_to_release=None, wait_count=4):
         if not file_to_release:
             file_to_release = os.path.join(self.edbpath)
@@ -1304,93 +1235,80 @@ class Edb(EdbInit):
                 time.sleep(0.250)
 
     def close_edb(self) -> bool:
-        """Close EDB and cleanup variables.
+        """Close EDB and clean up resources.
+
+        ..deprecated:: 0.51.0
+           Use: func:`close` instead.
 
         Returns
         -------
-        bool: `True` when successful, `False` when failed.
+        bool
+            True if successful, False otherwise.
+
+        Examples
+        --------
+        Close the EDB session:
+        >>> edb.close_edb()
         """
-        self.close()
-        start_time = time.time()
-        self._wait_for_file_release()
-        elapsed_time = time.time() - start_time
-        self.logger.info("EDB file release time: {0:.2f}ms".format(elapsed_time * 1000.0))
-        self._clean_variables()
-        return True
+        warnings.warn("Use method close instead.", DeprecationWarning)
+        return self.close()
 
     def save_edb(self) -> bool:
-        """Save the EDB file.
+        """Save current EDB database.
+
+        ..deprecated:: 0.51.0
+           Use: func:`save` instead.
 
         Returns
         -------
-        bool: `True` when successful, `False` when failed.
+        bool
+            True if successful, False otherwise.
+
+        Examples
+        --------
+        Save the current EDB:
+        >>> edb.save_edb()
         """
-        self.save()
-        start_time = time.time()
-        self._wait_for_file_release()
-        elapsed_time = time.time() - start_time
-        self.logger.info("EDB file save time: {0:.2f}ms".format(elapsed_time * 1000.0))
-        return True
+        warnings.warn("Use method save instead.", DeprecationWarning)
+        return self.save()
 
     def save_edb_as(self, fname) -> bool:
-        """Save the EDB file as another file.
+        """Save EDB database to new location.
+
+        ..deprecated:: 0.51.0
+           Use: func:`save_as` instead.
 
         Parameters
         ----------
         fname : str
-            Name of the new file to save to.
+            New AEDB path.
 
         Returns
         -------
-        bool: `True` when successful, `False` when failed.
+        bool
+            True if successful, False otherwise.
+
+        Examples
+        --------
+        Save EDB to new location:
+        >>> edb.save_edb_as("new_location.aedb")
         """
-        self.save_as(fname)
-        start_time = time.time()
-        self._wait_for_file_release()
-        elapsed_time = time.time() - start_time
-        self.logger.info("EDB file save time: {0:.2f}ms".format(elapsed_time * 1000.0))
-        self.edbpath = self.directory
-        self.log_name = os.path.join(
-            os.path.dirname(fname), "pyedb_" + os.path.splitext(os.path.split(fname)[-1])[0] + ".log"
-        )
-        return True
+        warnings.warn("Use method save_as instead.", DeprecationWarning)
+        return self.save_as(fname)
 
     def execute(self, func):
-        """Execute a function.
+        """Execute EDB utility command (Not implemented in gRPC).
 
         Parameters
         ----------
         func : str
-            Function to execute.
-
-
-        Returns
-        -------
-        bool: `True` when successful, `False` when failed.
+            Command to execute.
         """
         # return self.edb_api.utility.utility.Command.Execute(func)
         pass
 
     def import_cadence_file(self, inputBrd, WorkDir=None, anstranslator_full_path="", use_ppe=False):
-        """Import a board file and generate an ``edb.def`` file in the working directory.
-
-        Parameters
-        ----------
-        inputBrd : str
-            Full path to the board file.
-        WorkDir : str, optional
-            Directory in which to create the ``aedb`` folder. The default value is ``None``,
-            in which case the AEDB file is given the same name as the board file. Only
-            the extension differs.
-        anstranslator_full_path : str, optional
-            Full path to the Ansys translator.
-        use_ppe : bool, optional
-            Whether to use the PPE License. The default is ``False``.
-
-        Returns
-        -------
-        bool: `True` when successful, `False` when failed.
-        """
+        """Import Cadence board file (Deprecated - use import_layout_file)."""
         if self.import_layout_pcb(
             inputBrd,
             working_dir=WorkDir,
@@ -1411,32 +1329,24 @@ class Edb(EdbInit):
         map_file=None,
         layer_filter=None,
     ):
-        """Import a GDS file and generate an ``edb.def`` file in the working directory.
-
-        ..note::
-            ANSYS license is necessary to run the translator.
+        """Import GDS file.
 
         Parameters
         ----------
         inputGDS : str
-            Full path to the GDS file.
+            GDS file path.
         anstranslator_full_path : str, optional
-            Full path to the Ansys translator.
+            Ansys translator path.
         use_ppe : bool, optional
-            Whether to use the PPE License. The default is ``False``.
+            Use PPE license. Default False.
         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 GDS file. To succeed, the XML file and GDS file must
-            have the same name. Only the extension differs.
+            XML control file.
         tech_file : str, optional
-            Technology file. For versions<2024.1 it uses Helic to convert tech file to xml and then imports
-            the gds. Works on Linux only.
-            For versions>=2024.1 it can directly parse through supported foundry tech files.
+            Technology file.
         map_file : str, optional
             Layer map file.
-        layer_filter:str,optional
+        layer_filter : str, optional
             Layer filter file.
-
         """
         control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
         if float(self.edbversion) < 2024.1:
@@ -1737,114 +1647,72 @@ class Edb(EdbInit):
         keep_lines_as_path=False,
         include_voids_in_extents=False,
     ):
-        """Create a cutout using an approach entirely based on PyAEDT.
-        This method replaces all legacy cutout methods in PyAEDT.
-        It does in sequence:
-        - delete all nets not in list,
-        - create a extent of the nets,
-        - check and delete all vias not in the extent,
-        - check and delete all the primitives not in extent,
-        - check and intersect all the primitives that intersect the extent.
+        """Create layout cutout with various options.
 
         Parameters
         ----------
-         signal_list : list
-            List of signal strings.
+        signal_list : list, optional
+            Signal nets to include.
         reference_list : list, optional
-            List of references to add. The default is ``["GND"]``.
+            Reference nets to include.
         extent_type : str, optional
-            Type of the extension. Options are ``"Conforming"``, ``"ConvexHull"``, and
-            ``"Bounding"``. The default is ``"Conforming"``.
-        expansion_size : float, str, optional
-            Expansion size ratio in meters. The default is ``0.002``.
+            Cutout type ("Conforming", "ConvexHull", "Bounding").
+        expansion_size : float, optional
+            Boundary expansion size (meters).
         use_round_corner : bool, optional
-            Whether to use round corners. The default is ``False``.
+            Use rounded corners. Default False.
         output_aedb_path : str, optional
-            Full path and name for the new AEDB file. If None, then current aedb will be cutout.
+            Output AEDB path.
         open_cutout_at_end : bool, optional
-            Whether to open the cutout at the end. The default is ``True``.
+            Open cutout when finished. Default True.
         use_pyaedt_cutout : bool, optional
-            Whether to use new PyAEDT cutout method or EDB API method.
-            New method is faster than native API method since it benefits of multithread.
+            Use PyAEDT cutout method. Default True.
         number_of_threads : int, optional
-            Number of thread to use. Default is 4. Valid only if ``use_pyaedt_cutout`` is set to ``True``.
+            Thread count for PyAEDT cutout.
         use_pyaedt_extent_computing : bool, optional
-            Whether to use legacy extent computing (experimental) or EDB API.
+            Use PyAEDT extent computation. Default True.
         extent_defeature : float, optional
-            Defeature the cutout before applying it to produce simpler geometry for mesh (Experimental).
-            It applies only to Conforming bounding box. Default value is ``0`` which disable it.
+            Geometry simplification factor.
         remove_single_pin_components : bool, optional
-            Remove all Single Pin RLC after the cutout is completed. Default is `False`.
-        custom_extent : list
-            Points list defining the cutout shape. This setting will override `extent_type` field.
-        custom_extent_units : str
-            Units of the point list. The default is ``"mm"``. Valid only if `custom_extend` is provided.
+            Remove single-pin components. Default False.
+        custom_extent : list, optional
+            Custom polygon points for cutout.
+        custom_extent_units : str, optional
+            Units for custom_extent points.
         include_partial_instances : bool, optional
-            Whether to include padstack instances that have bounding boxes intersecting with point list polygons.
-            This operation may slow down the cutout export.Valid only if `custom_extend` and
-            `use_pyaedt_cutout` is provided.
-        keep_voids : bool
-            Boolean used for keep or not the voids intersecting the polygon used for clipping the layout.
-            Default value is ``True``, ``False`` will remove the voids.Valid only if `custom_extend` is provided.
+            Include partial padstack instances. Default False.
+        keep_voids : bool, optional
+            Preserve voids in cutout. Default True.
         check_terminals : bool, optional
-            Whether to check for all reference terminals and increase extent to include them into the cutout.
-            This applies to components which have a model (spice, touchstone or netlist) associated.
+            Verify terminal references. Default False.
         include_pingroups : bool, optional
-            Whether to check for all pingroups terminals and increase extent to include them into the cutout.
-            It requires ``check_terminals``.
+            Include pin groups. Default False.
         expansion_factor : int, optional
-            The method computes a float representing the largest number between
-            the dielectric thickness or trace width multiplied by the expansion_factor factor.
-            The trace width search is limited to nets with ports attached. Works only if `use_pyaedt_cutout`.
-            Default is `0` to disable the search.
+            Auto-expansion factor. Default 0 (disabled).
         maximum_iterations : int, optional
-            Maximum number of iterations before stopping a search for a cutout with an error.
-            Default is `10`.
+            Max auto-expansion iterations. Default 10.
         preserve_components_with_model : bool, optional
-            Whether to preserve all pins of components that have associated models (Spice or NPort).
-            This parameter is applicable only for a PyAEDT cutout (except point list).
+            Keep components with models. Default False.
         simple_pad_check : bool, optional
-            Whether to use the center of the pad to find the intersection with extent or use the bounding box.
-            Second method is much slower and requires to disable multithread on padstack removal.
-            Default is `True`.
+            Use simplified pad checking. Default True.
         keep_lines_as_path : bool, optional
-            Whether to keep the lines as Path after they are cutout or convert them to PolygonData.
-            This feature works only in Electronics Desktop (3D Layout).
-            If the flag is set to ``True`` it can cause issues in SiWave once the Edb is imported.
-            Default is ``False`` to generate PolygonData of cut lines.
+            Preserve paths as lines. Default False.
         include_voids_in_extents : bool, optional
-            Whether to compute and include voids in pyaedt extent before the cutout. Cutout time can be affected.
-            It works only with Conforming cutout.
-            Default is ``False`` to generate extent without voids.
-
+            Include voids in extent calculation. Default False.
 
         Returns
         -------
-        List
-            List of coordinate points defining the extent used for clipping the design. If failed, return an empty
-            list.
+        list or bool
+            Cutout boundary points if successful, False otherwise.
 
         Examples
         --------
-        >>> from pyedb import Edb
-        >>> edb = Edb(r'C:\\test.aedb', edbversion="2022.2")
-        >>> edb.logger.info_timer("Edb Opening")
-        >>> edb.logger.reset_timer()
-        >>> start = time.time()
-        >>> signal_list = []
-        >>> for net in edb.nets.netlist:
-        >>>      if "3V3" in net:
-        >>>           signal_list.append(net)
-        >>> power_list = ["PGND"]
-        >>> edb.cutout(signal_list=signal_list, reference_list=power_list, extent_type="Conforming")
-        >>> end_time = str((time.time() - start)/60)
-        >>> edb.logger.info("Total legacy cutout time in min %s", end_time)
-        >>> edb.nets.plot(signal_list, None, color_by_net=True)
-        >>> edb.nets.plot(power_list, None, color_by_net=True)
-        >>> edb.save_edb()
-        >>> edb.close_edb()
-
+        Create a basic cutout:
+        >>> edb.cutout(signal_list=["Net1"], reference_list=["GND"])
 
+        Create cutout with custom polygon:
+        >>> custom_poly = [[0,0], [10e-3,0], [10e-3,10e-3], [0,10e-3]]
+        >>> edb.cutout(custom_extent=custom_poly)
         """
         if expansion_factor > 0:
             expansion_size = self.calculate_initial_extent(expansion_factor)
@@ -1921,7 +1789,7 @@ class Edb(EdbInit):
                         break
                     self.close_edb()
                     self.edbpath = legacy_path
-                    self.open_edb()
+                    self.open()
                     i += 1
                     expansion = expansion_size * i
                 if working_cutout:
@@ -2007,15 +1875,15 @@ class Edb(EdbInit):
         # _cutout.simulation_setups = self.active_cell.simulation_setups see bug #433 status.
         _dbCells = [_cutout]
         if output_aedb_path:
-            db2 = self.create(output_aedb_path)
-            _success = db2.save()
-            _dbCells = _dbCells
+            from ansys.edb.core.database import Database as GrpcDatabase
+
+            db2 = GrpcDatabase.create(output_aedb_path)
             db2.copy_cells(_dbCells)  # Copies cutout cell/design to db2 project
-            if len(list(db2.circuit_cells)) > 0:
-                for net in db2.circuit_cells[0].layout.nets:
+            if len(list(db2.top_circuit_cells)) > 0:
+                for net in db2.top_circuit_cells[0].layout.nets:
                     if not net.name in included_nets_list:
                         net.delete()
-                _success = db2.save()
+                db2.save()
             for c in self.active_db.top_circuit_cells:
                 if c.name == _cutout.name:
                     c.delete()
@@ -2041,7 +1909,7 @@ class Edb(EdbInit):
                         for _cmp in _cmps:
                             _cmp.delete()
                     except:
-                        self._logger.error("Failed to remove single pin components.")
+                        self.logger.error("Failed to remove single pin components.")
                 db2.close()
                 source = os.path.join(output_aedb_path, "edb.def.tmp")
                 target = os.path.join(output_aedb_path, "edb.def")
@@ -2493,7 +2361,9 @@ class Edb(EdbInit):
 
         _dbCells = [_cutout]
         if output_aedb_path:
-            db2 = self.create(output_aedb_path)
+            from ansys.edb.core.database import Database as GrpcDatabase
+
+            db2 = GrpcDatabase.create(output_aedb_path)
             db2.save()
             cell_copied = db2.copy_cells(_dbCells)  # Copies cutout cell/design to db2 project
             cell = cell_copied[0]
@@ -2503,7 +2373,7 @@ class Edb(EdbInit):
                 if c.name == _cutout.name:
                     c.delete()
             if open_cutout_at_end:  # pragma: no cover
-                _success = db2.save()
+                db2.save()
                 self._db = db2
                 self.edbpath = output_aedb_path
                 self._active_cell = cell
@@ -2568,37 +2438,30 @@ class Edb(EdbInit):
         aedt_file_name=None,
         hidden=False,
     ):
-        """Export EDB to HFSS.
+        """Export to HFSS project.
 
         Parameters
         ----------
         path_to_output : str
-            Full path and name for saving the AEDT file.
+            Output directory.
         net_list : list, optional
-            List of nets to export if only certain ones are to be exported.
-            The default is ``None``, in which case all nets are eported.
+            Nets to export.
         num_cores : int, optional
-            Number of cores to use for the export. The default is ``None``.
+            Processing cores to use.
         aedt_file_name : str, optional
-            Name of the AEDT output file without the ``.aedt`` extension. The default is ``None``,
-            in which case the default name is used.
+            Custom AEDT filename.
         hidden : bool, optional
-            Open Siwave in embedding mode. User will only see Siwave Icon but UI will be hidden.
+            Run Siwave in background. Default False.
 
         Returns
         -------
         str
-            Full path to the AEDT file.
+            Path to generated AEDT file.
 
         Examples
         --------
-
-        >>> from pyedb import Edb
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2023.2")
-
-        >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_hfss(r"C:\temp")
+        Export to HFSS project:
+        >>> edb.export_hfss(r"C:/output", net_list=["SignalNet"])
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad("HFSS", path_to_output, net_list, num_cores, aedt_file_name, hidden=hidden)
@@ -2611,38 +2474,31 @@ class Edb(EdbInit):
         aedt_file_name=None,
         hidden=False,
     ):
-        """Export EDB to Q3D.
+        """Export to Q3D project.
 
         Parameters
         ----------
         path_to_output : str
-            Full path and name for saving the AEDT file.
+            Output directory.
         net_list : list, optional
-            List of nets to export only if certain ones are to be exported.
-            The default is ``None``, in which case all nets are eported.
+            Nets to export.
         num_cores : int, optional
-            Number of cores to use for the export. The default is ``None``.
+            Processing cores to use.
         aedt_file_name : str, optional
-            Name of the AEDT output file without the ``.aedt`` extension. The default is ``None``,
-            in which case the default name is used.
+            Custom AEDT filename.
         hidden : bool, optional
-            Open Siwave in embedding mode. User will only see Siwave Icon but UI will be hidden.
+            Run Siwave in background. Default False.
 
         Returns
         -------
         str
-            Full path to the AEDT file.
+            Path to generated AEDT file.
 
         Examples
         --------
-
-        >>> from pyedb import Edb
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2021.2")
-        >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_q3d(r"C:\temp")
+        Export to Q3D project:
+        >>> edb.export_q3d(r"C:/output")
         """
-
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad(
             "Q3D",
@@ -2661,38 +2517,30 @@ class Edb(EdbInit):
         aedt_file_name=None,
         hidden=False,
     ):
-        """Export EDB to Maxwell 3D.
+        """Export to Maxwell project.
 
         Parameters
         ----------
         path_to_output : str
-            Full path and name for saving the AEDT file.
+            Output directory.
         net_list : list, optional
-            List of nets to export only if certain ones are to be
-            exported. The default is ``None``, in which case all nets are exported.
+            Nets to export.
         num_cores : int, optional
-            Number of cores to use for the export. The default is ``None.``
+            Processing cores to use.
         aedt_file_name : str, optional
-            Name of the AEDT output file without the ``.aedt`` extension. The default is ``None``,
-            in which case the default name is used.
+            Custom AEDT filename.
         hidden : bool, optional
-            Open Siwave in embedding mode. User will only see Siwave Icon but UI will be hidden.
+            Run Siwave in background. Default False.
 
         Returns
         -------
         str
-            Full path to the AEDT file.
+            Path to generated AEDT file.
 
         Examples
         --------
-
-        >>> from pyedb import Edb
-
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2021.2")
-
-        >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_maxwell(r"C:\temp")
+        Export to Maxwell project:
+        >>> edb.export_maxwell(r"C:/output")
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad(
@@ -2705,12 +2553,17 @@ class Edb(EdbInit):
         )
 
     def solve_siwave(self):
-        """Close EDB and solve it with Siwave.
+        """Solve with SIwave.
 
         Returns
         -------
         str
-            Siwave project path.
+            Path to SIwave project.
+
+        Examples
+        --------
+        Solve with SIwave:
+        >>> edb.solve_siwave()
         """
         process = SiwaveSolve(self.edbpath, aedt_version=self.edbversion)
         try:
@@ -2733,35 +2586,35 @@ class Edb(EdbInit):
         power_tree=True,
         loop_res=True,
     ):
-        """Close EDB and solve it with Siwave.
+        """Export SIwave DC results.
 
         Parameters
         ----------
         siwave_project : str
-            Siwave full project name.
+            SIwave project path.
         solution_name : str
-            Siwave DC Analysis name.
+            DC analysis name.
         output_folder : str, optional
-            Ouptu folder where files will be downloaded.
+            Custom output folder.
         html_report : bool, optional
-            Either if generate or not html report. Default is `True`.
+            Generate HTML report. Default True.
         vias : bool, optional
-            Either if generate or not vias report. Default is `True`.
+            Export vias report. Default True.
         voltage_probes : bool, optional
-            Either if generate or not voltage probe report. Default is `True`.
+            Export voltage probes. Default True.
         current_sources : bool, optional
-            Either if generate or not current source report. Default is `True`.
+            Export current sources. Default True.
         voltage_sources : bool, optional
-            Either if generate or not voltage source report. Default is `True`.
+            Export voltage sources. Default True.
         power_tree : bool, optional
-            Either if generate or not power tree image. Default is `True`.
+            Export power tree. Default True.
         loop_res : bool, optional
-            Either if generate or not loop resistance report. Default is `True`.
+            Export loop resistance. Default True.
 
         Returns
         -------
         list[str]
-            List of files generated.
+            Generated report files.
         """
         process = SiwaveSolve(self.edbpath, aedt_version=self.edbversion)
         try:
@@ -2783,11 +2636,17 @@ class Edb(EdbInit):
         )
 
     def variable_exists(self, variable_name):
-        """Check if a variable exists or not.
+        """Check if variable exists.
+
+        Parameters
+        ----------
+        variable_name : str
+            Variable name.
 
         Returns
         -------
         bool
+            True if variable exists.
         """
         if "$" in variable_name:
             if variable_name.index("$") == 0:
@@ -2801,15 +2660,17 @@ class Edb(EdbInit):
         return False
 
     def get_variable(self, variable_name):
-        """Return Variable Value if variable exists.
+        """Get variable value.
 
         Parameters
         ----------
-        variable_name
+        variable_name : str
+            Variable name.
 
         Returns
         -------
-        float
+        float or bool
+            Variable value if exists, else False.
         """
         if self.variable_exists(variable_name):
             if "$" in variable_name:
@@ -2822,30 +2683,21 @@ class Edb(EdbInit):
         return False
 
     def add_project_variable(self, variable_name, variable_value, description=None) -> bool:
-        """Add a variable to database. The variable will have the prefix `$`.
+        """Add project variable.
 
         Parameters
         ----------
         variable_name : str
-            Name of the variable. Name can be provided without ``$`` prefix.
+            Variable name (auto-prefixed with '$').
         variable_value : str, float
-            Value of the variable with units.
-        description : str, optional.
-            Add variable description.
+            Variable value with units.
+        description : str, optional
+            Variable description.
 
         Returns
         -------
         bool
-
-        Examples
-        --------
-
-        >>> from pyedb import Edb
-        >>> edb_app = Edb()
-        >>> boolean_1, ant_length = edb_app.add_project_variable("my_local_variable", "1cm")
-        >>> print(edb_app["$my_local_variable"])    #using getitem
-        >>> edb_app["$my_local_variable"] = "1cm"   #using setitem
-
+            True if successful, False if variable exists.
         """
         if not variable_name.startswith("$"):
             variable_name = f"${variable_name}"
@@ -2859,37 +2711,23 @@ class Edb(EdbInit):
             return False
 
     def add_design_variable(self, variable_name, variable_value, is_parameter=False, description=None) -> bool:
-        """Add a variable to edb. The variable can be a design one or a project variable (using ``$`` prefix).
+        """Add design variable.
 
         Parameters
         ----------
         variable_name : str
-            Name of the variable. To added the variable as a project variable, the name
-            must begin with ``$``.
+            Variable name.
         variable_value : str, float
-            Value of the variable with units.
+            Variable value with units.
         is_parameter : bool, optional
-            Whether to add the variable as a local variable. The default is ``False``.
-            When ``True``, the variable is added as a parameter default.
+            Add as local variable. Default False.
         description : str, optional
-            Add variable description.
+            Variable description.
 
         Returns
         -------
-        bool.
-
-        Examples
-        --------
-
-        >>> from pyedb import Edb
-        >>> edb_app = Edb()
-        >>> boolean_1, ant_length = edb_app.add_design_variable("my_local_variable", "1cm")
-        >>> print(edb_app["my_local_variable"])    #using getitem
-        >>> edb_app["my_local_variable"] = "1cm"   #using setitem
-        >>> boolean_2, para_length = edb_app.change_design_variable_value("my_parameter", "1m", is_parameter=True
-        >>> boolean_3, project_length = edb_app.change_design_variable_value("$my_project_variable", "1m")
-
-
+        bool
+            True if successful, False if variable exists.
         """
         if variable_name.startswith("$"):
             variable_name = variable_name[1:]
@@ -2903,27 +2741,14 @@ class Edb(EdbInit):
             return False
 
     def change_design_variable_value(self, variable_name, variable_value):
-        """Change a variable value.
+        """Update variable value.
 
         Parameters
         ----------
         variable_name : str
-            Name of the variable.
+            Variable name.
         variable_value : str, float
-            Value of the variable with units.
-
-        Returns
-        -------
-        bool.
-
-        Examples
-        --------
-
-        >>> from pyedb import Edb
-        >>> edb_app = Edb()
-        >>> boolean, ant_length = edb_app.add_design_variable("ant_length", "1cm")
-        >>> boolean, ant_length = edb_app.change_design_variable_value("ant_length", "1m")
-        >>> print(edb_app["ant_length"])    #using getitem
+            New value with units.
         """
         if self.variable_exists(variable_name):
             if variable_name in self.db.get_all_variable_names():
@@ -2932,54 +2757,44 @@ class Edb(EdbInit):
                 self.active_cell.set_variable_value(variable_name, GrpcValue(variable_value))
 
     def get_bounding_box(self) -> list[list[float, float], list[float, float]]:
-        """Get the layout bounding box.
+        """Get layout bounding box.
 
         Returns
         -------
-        list[float]
-            Bounding box as a [lower-left X, lower-left Y, upper-right X, upper-right Y] in meters.
+        list
+            [[min_x, min_y], [max_x, max_y]] in meters.
         """
         lay_inst_polygon_data = [obj_inst.get_bbox() for obj_inst in self.layout_instance.query_layout_obj_instances()]
         layout_bbox = GrpcPolygonData.bbox_of_polygons(lay_inst_polygon_data)
         return [[layout_bbox[0].x.value, layout_bbox[0].y.value], [layout_bbox[1].x.value, layout_bbox[1].y.value]]
 
     def get_statistics(self, compute_area=False):
-        """Get the EDBStatistics object.
+        """Get layout statistics.
+
+        Parameters
+        ----------
+        compute_area : bool, optional
+            Calculate net areas. Default False.
 
         Returns
         -------
         :class:`LayoutStatistics <pyedb.grpc.database.utility.layout_statistics.LayoutStatistics>`
+            Layout statistics report.
         """
         return self.modeler.get_layout_statistics(evaluate_area=compute_area, net_list=None)
 
     def are_port_reference_terminals_connected(self, common_reference=None):
-        """Check if all terminal references in design are connected.
-        If the reference nets are different, there is no hope for the terminal references to be connected.
-        After we have identified a common reference net we need to loop the terminals again to get
-        the correct reference terminals that uses that net.
+        """Check if port reference terminals are connected.
 
         Parameters
         ----------
         common_reference : str, optional
-            Common Reference name. If ``None`` it will be searched in ports terminal.
-            If a string is passed then all excitations must have such reference assigned.
+            Reference net name to check.
 
         Returns
         -------
         bool
-            Either if the ports are connected to reference_name or not.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>>edb = Edb()
-        >>> edb.hfss.create_edge_port_vertical(prim_1_id, ["-66mm", "-4mm"], "port_ver")
-        >>> edb.hfss.create_edge_port_horizontal(
-        >>> ... prim_1_id, ["-60mm", "-4mm"], prim_2_id, ["-59mm", "-4mm"], "port_hori", 30, "Lower"
-        >>> ... )
-        >>> edb.hfss.create_wave_port(traces[0].id, trace_paths[0][0], "wave_port")
-        >>> edb.cutout(["Net1"])
-        >>> assert edb.are_port_reference_terminals_connected()
+            True if all port references are connected.
         """
         all_sources = [i for i in self.excitations.values() if not isinstance(i, (WavePort, GapPort, BundleWavePort))]
         all_sources.extend([i for i in self.sources.values()])
@@ -2987,7 +2802,10 @@ class Edb(EdbInit):
             return True
         self.logger.reset_timer()
         if not common_reference:
-            common_reference = list(set([i.reference_net.name for i in all_sources if i.reference_net.name]))
+            ref_terminals = [term for term in all_sources if term.is_reference_terminal]
+            common_reference = list(
+                set([i.reference_terminal.net.name for i in all_sources if i.is_reference_terminal])
+            )
             if len(common_reference) > 1:
                 self.logger.error("More than 1 reference found.")
                 return False
@@ -3137,17 +2955,18 @@ class Edb(EdbInit):
         )
 
     def create_raptorx_setup(self, name=None) -> RaptorXSimulationSetup:
-        """Create an RaptorX simulation setup from a template.
+        """Create RaptorX analysis setup (2024R2+ only).
 
         Parameters
         ----------
         name : str, optional
-            Setup name.
+            Setup name. Auto-generated if None.
 
         Returns
         -------
-        :class:`RaptorXSimulationSetup <legacy.database.edb_data.raptor_x_simulation_setup_data.RaptorXSimulationSetup>`
-
+        :class:`RaptorXSimulationSetup
+        <pyedb.grpc.database.simulation_setup.raptor_x_simulation_setup.RaptorXSimulationSetup>`
+            RaptorX setup or False if unsupported.
         """
         from ansys.edb.core.simulation_setup.raptor_x_simulation_setup import (
             RaptorXSimulationSetup as GrpcRaptorXSimulationSetup,
@@ -3191,28 +3010,20 @@ class Edb(EdbInit):
         pass
 
     def create_siwave_syz_setup(self, name=None, **kwargs) -> SiwaveSimulationSetup:
-        """Create a setup from a template.
+        """Create SIwave SYZ analysis setup.
 
         Parameters
         ----------
         name : str, optional
-            Setup name.
+            Setup name. Auto-generated if None.
+        **kwargs
+            Setup properties to modify.
 
         Returns
         -------
         :class:`SiwaveSimulationSetup
         <pyedb.grpc.database.simulation_setup.siwave_simulation_setup.SiwaveSimulationSetup>`
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb()
-        >>> setup1 = edbapp.create_siwave_syz_setup("setup1")
-        >>> setup1.add_frequency_sweep(frequency_sweep=[
-        ...                           ["linear count", "0", "1kHz", 1],
-        ...                           ["log scale", "1kHz", "0.1GHz", 10],
-        ...                           ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
-        ...                           ])
+            SYZ analysis setup.
         """
         if not name:
             name = generate_unique_name("Siwave_SYZ")
@@ -3228,25 +3039,20 @@ class Edb(EdbInit):
         return self.setups[name]
 
     def create_siwave_dc_setup(self, name=None, **kwargs) -> GrpcSIWaveDCIRSimulationSetup:
-        """Create a setup from a template.
+        """Create SIwave DC analysis setup.
 
         Parameters
         ----------
         name : str, optional
-            Setup name.
+            Setup name. Auto-generated if None.
+        **kwargs
+            Setup properties to modify.
 
         Returns
         -------
         :class:`SIWaveDCIRSimulationSetup
         <pyedb.grpc.database.simulation_setup.siwave_dcir_simulation_setup.SIWaveDCIRSimulationSetup>`
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> edbapp = Edb()
-        >>> setup1 = edbapp.create_siwave_dc_setup("setup1")
-        >>> setup1.mesh_bondwires = True
-
+            DC analysis setup.
         """
         if not name:
             name = generate_unique_name("Siwave_DC")
@@ -3274,7 +3080,7 @@ class Edb(EdbInit):
         for port in self.excitations.values():
             nets.append(port.net.name)
         for port in self.sources.values():
-            nets.append(port.net_name)
+            nets.append(port.net.name)
         nets = list(set(nets))
         max_width = 0
         for net in nets:
@@ -3633,51 +3439,58 @@ class Edb(EdbInit):
         expand_voids_size=0,
         via_offset=True,
     ):
-        """Assign automatically design and project variables with current values.
+        """Automatically parametrize design elements.
 
         Parameters
         ----------
         layers : bool, optional
-            Enable layer thickness parametrization. Default value is ``True``.
+            Parametrize layer thicknesses. Default True.
         materials : bool, optional
-            Enable material parametrization. Default value is ``True``.
+            Parametrize material properties. Default True.
         via_holes : bool, optional
-            Enable via diameter parametrization. Default value is ``True``.
+            Parametrize via holes. Default True.
         pads : bool, optional
-            Enable pads size parametrization. Default value is ``True``.
+            Parametrize pads. Default True.
         antipads : bool, optional
-            Enable anti pads size parametrization. Default value is ``True``.
+            Parametrize antipads. Default True.
         traces : bool, optional
-            Enable trace width parametrization. Default value is ``True``.
-        layer_filter : str, List(str), optional
-            Enable layer filter. Default value is ``None``, all layers are parametrized.
-        material_filter : str, List(str), optional
-            Enable material filter. Default value is ``None``, all material are parametrized.
-        padstack_definition_filter : str, List(str), optional
-            Enable padstack definition filter. Default value is ``None``, all padsatcks are parametrized.
-        trace_net_filter : str, List(str), optional
-            Enable nets filter for trace width parametrization. Default value is ``None``, all layers are parametrized.
+            Parametrize trace widths. Default True.
+        layer_filter : list, optional
+            Layers to include. All if None.
+        material_filter : list, optional
+            Materials to include. All if None.
+        padstack_definition_filter : list, optional
+            Padstacks to include. All if None.
+        trace_net_filter : list, optional
+            Nets to parametrize. All if None.
         use_single_variable_for_padstack_definitions : bool, optional
-            Whether to use a single design variable for each padstack definition or a variable per pad layer.
-            Default value is ``True``.
+            Single variable per padstack. Default True.
         use_relative_variables : bool, optional
-            Whether if use an absolute variable for each trace, padstacks and layers or a delta variable instead.
-            Default value is ``True``.
+            Use delta variables. Default True.
         output_aedb_path : str, optional
-            Full path and name for the new AEDB file. If None, then current aedb will be cutout.
+            Output AEDB path.
         open_aedb_at_end : bool, optional
-            Whether to open the cutout at the end. The default is ``True``.
+            Open AEDB when finished. Default True.
         expand_polygons_size : float, optional
-            Expansion size on polygons. Polygons will be expanded in all directions. The default is ``0``.
+            Polygon expansion size. Default 0.
         expand_voids_size : float, optional
-            Expansion size on polygon voids. Polygons voids will be expanded in all directions. The default is ``0``.
+            Void expansion size. Default 0.
         via_offset : bool, optional
-            Whether if offset the via position or not. The default is ``True``.
+            Parametrize via positions. Default True.
 
         Returns
         -------
-        List(str)
-            List of all parameter name created.
+        list[str]
+            Created parameter names.
+
+        Examples
+        --------
+        Parametrize design elements:
+        >>> params = edb.auto_parametrize_design(
+        ...     layers=True,
+        ...     materials=True,
+        ...     trace_net_filter=["Clock"]
+        ... )
         """
         edb_original_path = self.edbpath
         if output_aedb_path:
@@ -3904,41 +3717,27 @@ class Edb(EdbInit):
         output_edb=None,
         launching_box_thickness="100um",
     ):
-        """Generate EDB design to be consumed by PyAEDT to generate arbitrary wave ports shapes.
-        This model has to be considered as merged onto another one. The current opened design must have voids
-        surrounding the pad-stacks where wave ports terminal will be created. THe open design won't be edited, only
-        primitives like voids and pads-stack definition included in the voids are collected to generate a new design.
+        """Create simplified model for arbitrary wave port generation.
 
         Parameters
         ----------
         temp_directory : str
-            Temporary directory used during the method execution.
-
-        mounting_side : str
-            Gives the orientation to be considered for the current design. 2 options are available ``"top"`` and
-            ``"bottom". Default value is ``"top"``. If ``"top"`` is selected the method will voids at the top signal
-            layer, and the bottom layer if ``"bottom"`` is used.
-
-        signal_nets : List[str], optional
-            Provides the nets to be included for the model creation. Default value is ``None``. If None is provided,
-            all nets will be included.
-
-        terminal_diameter : float, str, optional
-            When ``None``, the terminal diameter is evaluated at each pads-tack instance found inside the voids. The top
-            or bottom layer pad diameter will be taken, depending on ``mounting_side`` selected. If value is provided,
-            it will overwrite the evaluated diameter.
-
+            Working directory.
+        mounting_side : str, optional
+            Board orientation ("top" or "bottom").
+        signal_nets : list, optional
+            Nets to include. All if None.
+        terminal_diameter : float, optional
+            Custom terminal diameter. Auto-calculated if None.
         output_edb : str, optional
-            The output EDB absolute. If ``None`` the edb is created in the ``temp_directory`` as default name
-            `"waveport_model.aedb"``
-
-        launching_box_thickness : float, str, optional
-            Launching box thickness  used for wave ports. Default value is ``"100um"``.
+            Output AEDB path.
+        launching_box_thickness : str, optional
+            Wave port box thickness.
 
         Returns
         -------
         bool
-            ``True`` when succeeded, ``False`` if failed.
+            True if successful, False otherwise.
         """
         if not temp_directory:
             self.logger.error("Temp directory must be provided when creating model foe arbitrary wave port")
@@ -4059,11 +3858,12 @@ class Edb(EdbInit):
 
     @property
     def definitions(self):
-        """Returns Definitions class.
+        """EDB definitions access.
 
         Returns
         -------
         :class:`Definitions <pyedb.grpc.database.definitions.Definitions>`
+            Definitions interface.
         """
         from pyedb.grpc.database.definitions import Definitions
 
@@ -4071,28 +3871,31 @@ class Edb(EdbInit):
 
     @property
     def workflow(self):
-        """Returns workflow class.
+        """Workflow automation interface.
 
         Returns
-        ------
+        -------
         :class:`Workflow <pyedb.workflow.Workflow>`
+            Workflow automation tools.
         """
         return Workflow(self)
 
     def export_gds_comp_xml(self, comps_to_export, gds_comps_unit="mm", control_path=None):
-        """Exports an XML file with selected components information for use in a GDS import.
+        """Export component data to GDS XML control file.
+
         Parameters
         ----------
         comps_to_export : list
-            List of components whose information will be exported to xml file.
+            Components to export.
         gds_comps_unit : str, optional
-            GDS_COMPONENTS section units. Default is ``"mm"``.
+            Output units. Default "mm".
         control_path : str, optional
-            Path for outputting the XML file.
+            Output XML path.
+
         Returns
         -------
         bool
-            ``True`` when successful, ``False`` when failed.
+            True if successful, False otherwise.
         """
         from pyedb.generic.general_methods import ET