pyedb 0.49.0__py3-none-any.whl → 0.50.1__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
-
-    Retrieving all component instances
-
-    >>> edbapp.components.instances
-
-    Retrieving all padstacks definitions
-
-    >>> edbapp.padstacks.definitions
-
-    Retrieving component pins
+    Create new EDB:
+    >>> edb = Edb()
 
-    >>> 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 [
@@ -418,54 +409,57 @@ class Edb(EdbInit):
         self._extended_nets = ExtendedNets(self)
 
     @property
-    def cell_names(self):
-        """Cell name container.
+    def cell_names(self) -> [str]:
+        """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):
-        """Get all edb design variables.
+    def design_variables(self) -> dict[str, float]:
+        """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):
-        """Get all project variables.
+    def project_variables(self) -> dict[str, float]:
+        """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):
-        """Return LayoutValidation object.
+    def layout_validation(self) -> LayoutValidation:
+        """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):
-        """Get all Edb variables.
+    def variables(self) -> dict[str, float]:
+        """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():
@@ -475,24 +469,25 @@ class Edb(EdbInit):
         return all_vars
 
     @property
-    def terminals(self):
-        """Get terminals belonging to active layout.
+    def terminals(self) -> dict[str, Terminal]:
+        """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):
-        """Get all layout excitations.
+    def excitations(self) -> dict[str, GapPort]:
+        """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:
@@ -503,14 +498,13 @@ class Edb(EdbInit):
         return temp
 
     @property
-    def ports(self):
-        """Get all ports.
+    def ports(self) -> dict[str, GapPort]:
+        """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 = {}
@@ -537,35 +531,35 @@ class Edb(EdbInit):
         return ports
 
     @property
-    def excitations_nets(self):
-        """Get all net names with excitation defined.
+    def excitations_nets(self) -> [str]:
+        """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):
-        """Get all layout sources.
+    def sources(self) -> dict[str, Terminal]:
+        """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 = {}
@@ -574,23 +568,24 @@ class Edb(EdbInit):
         return _vrms
 
     @property
-    def probes(self):
-        """Get all layout probes.
+    def probes(self) -> dict[str, Terminal]:
+        """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, kill_all_instances=False):
-        """Open EDB.
+    def open_edb(self, restart_rpc_server=False) -> bool:
+        """Open EDB database.
 
         Returns
         -------
-        bool: `True` when succeed `False` if failed.
+        bool
+            True if successful, False otherwise.
         """
         self.standalone = self.standalone
         n_try = 10
@@ -626,12 +621,13 @@ class Edb(EdbInit):
                 self.logger.error("Builder was not initialized.")
             return True
 
-    def create_edb(self, restart_rpc_server=False, kill_all_instances=False):
-        """Create EDB.
+    def create_edb(self, restart_rpc_server=False) -> bool:
+        """Create new EDB database.
 
         Returns
         -------
-        bool: `True` when succeed `False` if failed.
+        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
@@ -669,38 +665,33 @@ class Edb(EdbInit):
         tech_file=None,
         layer_filter=None,
     ):
-        """Import a board file and generate an ``edb.def`` file in the working directory.
+        """Import layout file and generate AEDB.
 
-        .. deprecated:: 0.42.0
-           Use :func:`import_layout_file` method instead.
-
-        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(
@@ -801,30 +792,20 @@ class Edb(EdbInit):
         self.edbpath = os.path.join(working_dir, aedb_name)
         return self.open_edb()
 
-    def export_to_ipc2581(self, ipc_path=None, units="MILLIMETER"):
-        """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.
+    def export_to_ipc2581(self, ipc_path=None, units="MILLIMETER") -> str:
+        """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.
         """
         if units.lower() not in ["millimeter", "inch", "micron"]:  # pragma no cover
             self.logger.warning("The wrong unit is entered. Setting to the default, millimeter.")
@@ -847,31 +828,27 @@ class Edb(EdbInit):
         return False
 
     @property
-    def configuration(self):
-        """Edb project configuration from a file.
+    def configuration(self) -> Configuration:
+        """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 +858,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:
@@ -917,270 +908,206 @@ class Edb(EdbInit):
             raise "No valid design."
 
     @property
-    def components(self):
-        """Edb Components methods and properties.
+    def components(self) -> Components:
+        """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)
         return self._components
 
     @property
-    def stackup(self):
-        """Stackup manager.
+    def stackup(self) -> Stackup:
+        """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)
         return self._stackup
 
     @property
-    def source_excitation(self):
-        """Returns layout source excitations.
+    def source_excitation(self) -> SourceExcitation:
+        """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):
-        """Material Database.
+    def materials(self) -> Materials:
+        """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)
         return self._materials
 
     @property
-    def padstacks(self):
-        """Returns padstack object.
-
+    def padstacks(self) -> Padstacks:
+        """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):
-        """Returns SIWave object.
+    def siwave(self) -> Siwave:
+        """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)
         return self._siwave
 
     @property
-    def hfss(self):
-        """Returns HFSS object.
+    def hfss(self) -> Hfss:
+        """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)
         return self._hfss
 
     @property
-    def nets(self):
-        """Returns nets object.
+    def nets(self) -> Nets:
+        """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):
-        """Returns net classes object.
+    def net_classes(self) -> NetClass:
+        """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):
-        """Returns extended nets.
+    def extended_nets(self) -> ExtendedNets:
+        """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):
-        """Returns differential pairs.
+    def differential_pairs(self) -> DifferentialPairs:
+        """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)
         return self._differential_pairs
 
     @property
-    def modeler(self):
-        """Returns primitives modeler object.
+    def modeler(self) -> Modeler:
+        """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)
         return self._modeler
 
     @property
-    def layout(self):
-        """Returns Layout object.
+    def layout(self) -> Layout:
+        """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):
-        """Active layout.
+    def active_layout(self) -> 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 +1140,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
 
@@ -1255,7 +1183,7 @@ class Edb(EdbInit):
             return PointData(x, y)
 
     @staticmethod
-    def _is_file_existing_and_released(filename):
+    def _is_file_existing_and_released(filename) -> bool:
         if os.path.exists(filename):
             try:
                 os.rename(filename, filename + "_")
@@ -1267,13 +1195,13 @@ class Edb(EdbInit):
             return False
 
     @staticmethod
-    def _is_file_existing(filename):
+    def _is_file_existing(filename) -> bool:
         if os.path.exists(filename):
             return True
         else:
             return False
 
-    def _wait_for_file_release(self, timeout=30, file_to_release=None):
+    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()
@@ -1303,12 +1231,13 @@ class Edb(EdbInit):
                 times = 0
                 time.sleep(0.250)
 
-    def close_edb(self):
-        """Close EDB and cleanup variables.
+    def close_edb(self) -> bool:
+        """Close EDB and clean up resources.
 
         Returns
         -------
-        bool: `True` when successful, `False` when failed.
+        bool
+            True if successful, False otherwise.
         """
         self.close()
         start_time = time.time()
@@ -1318,12 +1247,13 @@ class Edb(EdbInit):
         self._clean_variables()
         return True
 
-    def save_edb(self):
-        """Save the EDB file.
+    def save_edb(self) -> bool:
+        """Save current EDB database.
 
         Returns
         -------
-        bool: `True` when successful, `False` when failed.
+        bool
+            True if successful, False otherwise.
         """
         self.save()
         start_time = time.time()
@@ -1332,17 +1262,18 @@ class Edb(EdbInit):
         self.logger.info("EDB file save time: {0:.2f}ms".format(elapsed_time * 1000.0))
         return True
 
-    def save_edb_as(self, fname):
-        """Save the EDB file as another file.
+    def save_edb_as(self, fname) -> bool:
+        """Save EDB database to new location.
 
         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.
         """
         self.save_as(fname)
         start_time = time.time()
@@ -1356,41 +1287,18 @@ class Edb(EdbInit):
         return True
 
     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 +1319,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 +1637,63 @@ 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.
-
-        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()
-
-
+        list or bool
+            Cutout boundary points if successful, False otherwise.
         """
         if expansion_factor > 0:
             expansion_size = self.calculate_initial_extent(expansion_factor)
@@ -2306,7 +2155,7 @@ class Edb(EdbInit):
         self.logger.reset_timer()
         return [[pt.x.value, pt.y.value] for pt in _poly.without_arcs().points]
 
-    def get_conformal_polygon_from_netlist(self, netlist=None):
+    def get_conformal_polygon_from_netlist(self, netlist=None) -> Union[bool, Polygon]:
         """Returns conformal polygon data based on a netlist.
 
         Parameters
@@ -2337,7 +2186,7 @@ class Edb(EdbInit):
         else:
             return False
 
-    def number_with_units(self, value, units=None):
+    def number_with_units(self, value, units=None) -> str:
         """Convert a number to a string with units. If value is a string, it's returned as is.
 
         Parameters
@@ -2568,37 +2417,25 @@ 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.
-
-        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")
+            Path to generated AEDT file.
         """
         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 +2448,26 @@ 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.
-
-        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")
+            Path to generated AEDT file.
         """
-
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad(
             "Q3D",
@@ -2661,38 +2486,25 @@ 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.
-
-        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")
+            Path to generated AEDT file.
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad(
@@ -2705,12 +2517,12 @@ 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.
         """
         process = SiwaveSolve(self.edbpath, aedt_version=self.edbversion)
         try:
@@ -2733,35 +2545,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 +2595,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 +2619,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:
@@ -2821,99 +2641,73 @@ class Edb(EdbInit):
         self.logger.info(f"Variable {variable_name} doesn't exists.")
         return False
 
-    def add_project_variable(self, variable_name, variable_value):
-        """Add a variable to database. The variable will have the prefix `$`.
+    def add_project_variable(self, variable_name, variable_value, description=None) -> bool:
+        """Add project variable.
 
         Parameters
-         ----------
-         variable_name : str
-             Name of the variable. Name can be provided without ``$`` prefix.
-         variable_value : str, float
-             Value of the variable with units.
-
-         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
+        ----------
+        variable_name : str
+            Variable name (auto-prefixed with '$').
+        variable_value : str, float
+            Variable value with units.
+        description : str, optional
+            Variable description.
 
+        Returns
+        -------
+        bool
+            True if successful, False if variable exists.
         """
         if not variable_name.startswith("$"):
             variable_name = f"${variable_name}"
         if not self.variable_exists(variable_name):
-            return self.active_db.add_variable(variable_name, variable_value)
+            var = self.active_db.add_variable(variable_name, variable_value)
+            if description:
+                self.active_db.set_variable_desc(name=variable_name, desc=description)
+            return var
         else:
             self.logger.error(f"Variable {variable_name} already exists.")
             return False
 
-    def add_design_variable(self, variable_name, variable_value, is_parameter=False):
-        """Add a variable to edb. The variable can be a design one or a project variable (using ``$`` prefix).
+    def add_design_variable(self, variable_name, variable_value, is_parameter=False, description=None) -> bool:
+        """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
+            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:]
         if not self.variable_exists(variable_name):
-            return self.active_cell.add_variable(variable_name, variable_value)
+            var = self.active_cell.add_variable(variable_name, variable_value)
+            if description:
+                self.active_cell.set_variable_desc(name=variable_name, desc=description)
+            return var
         else:
             self.logger.error(f"Variable {variable_name} already exists.")
             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():
@@ -2921,55 +2715,45 @@ class Edb(EdbInit):
             elif variable_name in self.active_cell.get_all_variable_names():
                 self.active_cell.set_variable_value(variable_name, GrpcValue(variable_value))
 
-    def get_bounding_box(self):
-        """Get the layout bounding box.
+    def get_bounding_box(self) -> list[list[float, float], list[float, float]]:
+        """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()])
@@ -3030,7 +2814,9 @@ class Edb(EdbInit):
         return True if len(iDintersection) > 0 else False
 
     @property
-    def setups(self):
+    def setups(
+        self,
+    ) -> Union[HfssSimulationSetup, SiwaveSimulationSetup, SIWaveDCIRSimulationSetup, RaptorXSimulationSetup]:
         """Get the dictionary of all EDB HFSS and SIwave setups.
 
         Returns
@@ -3056,7 +2842,7 @@ class Edb(EdbInit):
         return self._setups
 
     @property
-    def hfss_setups(self):
+    def hfss_setups(self) -> dict[str, HfssSimulationSetup]:
         """Active HFSS setup in EDB.
 
         Returns
@@ -3072,7 +2858,7 @@ class Edb(EdbInit):
         return setups
 
     @property
-    def siwave_dc_setups(self):
+    def siwave_dc_setups(self) -> dict[str, SIWaveDCIRSimulationSetup]:
         """Active Siwave DC IR Setups.
 
         Returns
@@ -3084,7 +2870,7 @@ class Edb(EdbInit):
         return {name: i for name, i in self.setups.items() if isinstance(i, SIWaveDCIRSimulationSetup)}
 
     @property
-    def siwave_ac_setups(self):
+    def siwave_ac_setups(self) -> dict[str, SiwaveSimulationSetup]:
         """Active Siwave SYZ setups.
 
         Returns
@@ -3094,7 +2880,9 @@ class Edb(EdbInit):
         """
         return {name: i for name, i in self.setups.items() if isinstance(i, SiwaveSimulationSetup)}
 
-    def create_hfss_setup(self, name=None, start_frequency="0GHz", stop_frequency="20GHz", step_frequency="10MHz"):
+    def create_hfss_setup(
+        self, name=None, start_frequency="0GHz", stop_frequency="20GHz", step_frequency="10MHz"
+    ) -> HfssSimulationSetup:
         """Create an HFSS simulation setup from a template.
 
         . deprecated:: pyedb 0.30.0
@@ -3122,18 +2910,19 @@ class Edb(EdbInit):
             step_freq=step_frequency,
         )
 
-    def create_raptorx_setup(self, name=None):
-        """Create an RaptorX simulation setup from a template.
+    def create_raptorx_setup(self, name=None) -> RaptorXSimulationSetup:
+        """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,
@@ -3176,29 +2965,21 @@ class Edb(EdbInit):
         #  TODO check HFSS-PI with Grpc. seems to defined at terminal level not setup.
         pass
 
-    def create_siwave_syz_setup(self, name=None, **kwargs):
-        """Create a setup from a template.
+    def create_siwave_syz_setup(self, name=None, **kwargs) -> SiwaveSimulationSetup:
+        """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")
@@ -3213,26 +2994,21 @@ class Edb(EdbInit):
             setattr(setup, k, v)
         return self.setups[name]
 
-    def create_siwave_dc_setup(self, name=None, **kwargs):
-        """Create a setup from a template.
+    def create_siwave_dc_setup(self, name=None, **kwargs) -> GrpcSIWaveDCIRSimulationSetup:
+        """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")
@@ -3459,6 +3235,9 @@ class Edb(EdbInit):
     def create_port(self, terminal, ref_terminal=None, is_circuit_port=False, name=None):
         """Create a port.
 
+        ..deprecated:: 0.51.0
+           Use: func:`create_port` has been move to source_excitation.create_port.
+
         Parameters
         ----------
         terminal : class:`pyedb.dotnet.database.edb_data.terminals.EdgeTerminal`,
@@ -3481,22 +3260,16 @@ class Edb(EdbInit):
         list: [:class:`GapPort <pyedb.grpc.database.ports.ports.GapPort`>,
             :class:`WavePort <pyedb.grpc.database.ports.ports.WavePort>`].
         """
-        from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
-
-        if terminal.boundary_type == "port":
-            terminal.boundary_type = GrpcBoundaryType.PORT
-        terminal.is_circuit_port = is_circuit_port
-        if ref_terminal:
-            if ref_terminal.boundary_type == "port":
-                ref_terminal.boundary_type = GrpcBoundaryType.PORT
-            terminal.reference_terminal = ref_terminal
-        if name:
-            terminal.name = name
-        return self.ports[terminal.name]
+
+        warnings.warn("Use create_port from edb.source_excitation.create_port", DeprecationWarning)
+        return self.source_excitation.create_port(terminal, ref_terminal, is_circuit_port, name)
 
     def create_voltage_probe(self, terminal, ref_terminal):
         """Create a voltage probe.
 
+        ..deprecated:: 0.50.0
+           Use: func:`create_voltage_probe` located in edb.source_excitation.create_voltage_probe instead.
+
         Parameters
         ----------
         terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
@@ -3514,18 +3287,15 @@ class Edb(EdbInit):
         -------
         :class:`Terminal <pyedb.dotnet.database.edb_data.terminals.Terminal>`
         """
-        term = Terminal(self, terminal)
-        term.boundary_type = "voltage_probe"
-
-        ref_term = Terminal(self, ref_terminal)
-        ref_term.boundary_type = "voltage_probe"
-
-        term.ref_terminal = ref_terminal
-        return term
+        warnings.warn("Use create_voltage_probe located in edb.source_excitation instead", DeprecationWarning)
+        return self.source_excitation.create_voltage_probe(terminal, ref_terminal)
 
     def create_voltage_source(self, terminal, ref_terminal):
         """Create a voltage source.
 
+        ..deprecated:: 0.50.0
+           Use: func:`create_voltage_source` located in edb.source_excitation.create_voltage_source instead.
+
         Parameters
         ----------
         terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
@@ -3543,18 +3313,18 @@ class Edb(EdbInit):
         -------
         class:`ExcitationSources <legacy.database.edb_data.ports.ExcitationSources>`
         """
-        term = Terminal(self, terminal)
-        term.boundary_type = "voltage_source"
-
-        ref_term = Terminal(self, ref_terminal)
-        ref_term.boundary_type = "voltage_source"
-
-        term.ref_terminal = ref_terminal
-        return term
+        warnings.warn(
+            "use create_voltage_source located in edb.source_excitation.create_voltage_source instead",
+            DeprecationWarning,
+        )
+        return self.source_excitation.create_voltage_source(terminal, ref_terminal)
 
     def create_current_source(self, terminal, ref_terminal):
         """Create a current source.
 
+        ..deprecated:: 0.50.0
+           Use: func:`create_current_source` located in edb.source_excitation.create_current_source instead.
+
         Parameters
         ----------
         terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
@@ -3572,17 +3342,17 @@ class Edb(EdbInit):
         -------
         :class:`ExcitationSources <legacy.database.edb_data.ports.ExcitationSources>`
         """
-        term = Terminal(self, terminal)
-        term.boundary_type = "current_source"
-
-        ref_term = Terminal(self, ref_terminal)
-        ref_term.boundary_type = "current_source"
-
-        term.ref_terminal = ref_terminal
-        return term
+        warnings.warn(
+            "use create_current_source located in edb.source_excitation.create_current_source instead",
+            DeprecationWarning,
+        )
+        return self.source_excitation.create_current_source(terminal, ref_terminal)
 
     def get_point_terminal(self, name, net_name, location, layer):
-        """Place a voltage probe between two points.
+        """Place terminal between two points.
+
+        ..deprecated:: 0.50.0
+           Use: func:`get_point_terminal` located in edb.source_excitation.get_point_terminal instead.
 
         Parameters
         ----------
@@ -3599,9 +3369,11 @@ class Edb(EdbInit):
         -------
         :class:`PointTerminal <pyedb.grpc.database.terminal.point_terminal.PointTerminal>`
         """
-        from pyedb.grpc.database.terminal.point_terminal import PointTerminal
 
-        return PointTerminal.create(layout=self.active_layout, name=name, net=net_name, layer=layer, point=location)
+        warnings.warn(
+            "use get_point_terminal located in edb.source_excitation.get_point_terminal instead", DeprecationWarning
+        )
+        return self.source_excitation.get_point_terminal(name, net_name, location, layer)
 
     def auto_parametrize_design(
         self,
@@ -3623,51 +3395,49 @@ 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.
         """
         edb_original_path = self.edbpath
         if output_aedb_path:
@@ -3894,41 +3664,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")
@@ -4049,11 +3805,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
 
@@ -4061,28 +3818,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