pyedb 0.49.0__py3-none-any.whl → 0.50.1__py3-none-any.whl

pyedb/grpc/database/nets.py

@@ -44,99 +44,101 @@ class Nets(CommonNets):
     """
 
     def __getitem__(self, name):
-        """Get nets from the Edb project.
+        """Get a net by name.
 
         Parameters
         ----------
-        name : str, int
+        name : str
+            Name of the net to retrieve.
 
         Returns
         -------
-        :class:` .:class:`pyedb.grpc.database.nets_data.EDBNets`
-
+        pyedb.grpc.database.net.net.Net
+            Net object if found, otherwise None.
         """
         return Net(self._pedb, Net.find_by_name(self._active_layout, name))
 
     def __contains__(self, name):
-        """Determine if a net is named ``name`` or not.
+        """Check if a net exists in the layout.
 
         Parameters
         ----------
         name : str
+            Name of the net to check.
 
         Returns
         -------
         bool
-            ``True`` when one of the net is named ``name``, ``False`` otherwise.
-
+            True if the net exists, False otherwise.
         """
         return name in self.nets
 
     def __init__(self, p_edb):
+        """Initialize the Nets class."""
         CommonNets.__init__(self, p_edb)
         self._nets_by_comp_dict = {}
         self._comps_by_nets_dict = {}
 
     @property
     def _edb(self):
-        """ """
+        """EDB object."""
         return self._pedb
 
     @property
     def _active_layout(self):
-        """ """
+        """Active layout."""
         return self._pedb.active_layout
 
     @property
     def _layout(self):
-        """ """
+        """Current layout."""
         return self._pedb.layout
 
     @property
     def _cell(self):
-        """ """
+        """Current cell."""
         return self._pedb.cell
 
     @property
     def db(self):
-        """Db object."""
+        """Database object."""
         return self._pedb.active_db
 
     @property
     def _logger(self):
-        """Edb logger."""
+        """Logger instance."""
         return self._pedb.logger
 
     @property
     def nets(self):
-        """Nets.
+        """All nets in the layout.
 
         Returns
         -------
-        dict[str, :class:`pyedb.dotnet.database.edb_data.nets_data.EDBNetsData`]
-            Dictionary of nets.
+        dict[str, pyedb.grpc.database.net.net.Net]
+            Dictionary of net names to Net objects.
         """
         return {i.name: i for i in self._pedb.layout.nets}
 
     @property
     def netlist(self):
-        """Return the cell netlist.
+        """List of all net names.
 
         Returns
         -------
-        list
-            Net names.
+        list[str]
+            Names of all nets in the layout.
         """
         return list(self.nets.keys())
 
     @property
     def signal(self):
-        """Signal nets.
+        """Signal nets in the layout.
 
         Returns
         -------
-        dict[str, :class:`pyedb.dotnet.database.edb_data.EDBNetsData`]
-            Dictionary of signal nets.
+        dict[str, pyedb.grpc.database.net.net.Net]
+            Dictionary of signal net names to Net objects.
         """
         nets = {}
         for net, value in self.nets.items():
@@ -146,12 +148,12 @@ class Nets(CommonNets):
 
     @property
     def power(self):
-        """Power nets.
+        """Power and ground nets in the layout.
 
         Returns
         -------
-        dict[str, :class:`pyedb.dotnet.database.edb_data.EDBNetsData`]
-            Dictionary of power nets.
+        dict[str, pyedb.grpc.database.net.net.Net]
+            Dictionary of power/ground net names to Net objects.
         """
         nets = {}
         for net, value in self.nets.items():
@@ -160,17 +162,20 @@ class Nets(CommonNets):
         return nets
 
     def eligible_power_nets(self, threshold=0.3):
-        """Return a list of nets calculated by area to be eligible for PWR/Ground net classification.
-            It uses the same algorithm implemented in SIwave.
+        """Identify nets eligible for power/ground classification based on area ratio.
+
+        Uses the same algorithm implemented in SIwave.
 
         Parameters
         ----------
         threshold : float, optional
-           Area ratio used by the ``get_power_ground_nets`` method.
+            Area ratio threshold. Nets with plane area ratio above this value are
+            considered power/ground nets.
 
         Returns
         -------
-        list of  :class:`pyedb.dotnet.database.edb_data.EDBNetsData`
+        list[pyedb.grpc.database.net.net.Net]
+            List of nets eligible as power/ground nets.
         """
         pwr_gnd_nets = []
         for net in self._layout.nets[:]:
@@ -194,16 +199,26 @@ class Nets(CommonNets):
 
     @property
     def nets_by_components(self):
-        # type: () -> dict
-        """Get all nets for each component instance."""
+        """Mapping of components to their associated nets.
+
+        Returns
+        -------
+        dict[str, list[str]]
+            Dictionary mapping component names to list of net names.
+        """
         for comp, i in self._pedb.components.instances.items():
             self._nets_by_comp_dict[comp] = i.nets
         return self._nets_by_comp_dict
 
     @property
     def components_by_nets(self):
-        # type: () -> dict
-        """Get all component instances grouped by nets."""
+        """Mapping of nets to their associated components.
+
+        Returns
+        -------
+        dict[str, list[str]]
+            Dictionary mapping net names to list of component names.
+        """
         for comp, i in self._pedb.components.instances.items():
             for n in i.nets:
                 if n in self._comps_by_nets_dict:
@@ -221,40 +236,30 @@ class Nets(CommonNets):
         include_signal=True,
         include_power=True,
     ):
-        # type: (int | float, int | float, int |float, list, bool, bool) -> list
-        """Get extended net and associated components.
+        """Generate extended nets based on component thresholds.
 
-        . deprecated:: pyedb 0.30.0
-        Use :func:`pyedb.grpc.extended_nets.generate_extended_nets` instead.
+        .. deprecated:: pyedb 0.30.0
+            Use :func:`pyedb.grpc.extended_nets.generate_extended_nets` instead.
 
         Parameters
         ----------
-        resistor_below : int, float, optional
-            Threshold of resistor value. Search extended net across resistors which has value lower than the threshold.
-        inductor_below : int, float, optional
-            Threshold of inductor value. Search extended net across inductances which has value lower than the
-            threshold.
-        capacitor_above : int, float, optional
-            Threshold of capacitor value. Search extended net across capacitors which has value higher than the
-            threshold.
+        resistor_below : int | float, optional
+            Resistor threshold value. Components below this value are considered.
+        inductor_below : int | float, optional
+            Inductor threshold value. Components below this value are considered.
+        capacitor_above : int | float, optional
+            Capacitor threshold value. Components above this value are considered.
         exception_list : list, optional
-            List of components to bypass when performing threshold checks. Components
-            in the list are considered as serial components. The default is ``None``.
-        include_signal : str, optional
-            Whether to generate extended signal nets. The default is ``True``.
-        include_power : str, optional
-            Whether to generate extended power nets. The default is ``True``.
+            List of components to bypass during threshold checks.
+        include_signal : bool, optional
+            Whether to include signal nets in extended net generation.
+        include_power : bool, optional
+            Whether to include power nets in extended net generation.
 
         Returns
         -------
         list
-            List of all extended nets.
-
-        Examples
-        --------
-        >>> from pyedb import Edb
-        >>> app = Edb()
-        >>> app.nets.get_extended_nets()
+            List of generated extended nets.
         """
         warnings.warn("Use new method :func:`edb.extended_nets.generate_extended_nets` instead.", DeprecationWarning)
         self._pedb.extended_nets.generate_extended_nets(
@@ -262,9 +267,18 @@ class Nets(CommonNets):
         )
 
     @staticmethod
-    def _get_points_for_plot(self, my_net_points):
-        """
-        Get the points to be plotted.
+    def _get_points_for_plot(my_net_points):
+        """Get points for plotting.
+
+        Parameters
+        ----------
+        my_net_points : list
+            List of points defining the net.
+
+        Returns
+        -------
+        tuple
+            X and Y coordinates of the points.
         """
         # fmt: off
         x = []
@@ -288,19 +302,19 @@ class Nets(CommonNets):
         return x, y
 
     def classify_nets(self, power_nets=None, signal_nets=None):
-        """Reassign power/ground or signal nets based on list of nets.
+        """Reassign net classifications as power/ground or signal.
 
         Parameters
         ----------
-        power_nets : str, list, optional
-            List of power nets to assign. Default is `None`.
-        signal_nets : str, list, optional
-            List of signal nets to assign. Default is `None`.
+        power_nets : str | list[str], optional
+            Nets to classify as power/ground.
+        signal_nets : str | list[str], optional
+            Nets to classify as signal.
 
         Returns
         -------
         bool
-            ``True`` when successful, ``False`` when failed.
+            True if successful, False otherwise.
         """
         if isinstance(power_nets, str):
             power_nets = []
@@ -319,17 +333,17 @@ class Nets(CommonNets):
         return True
 
     def is_power_gound_net(self, netname_list):
-        """Determine if one of the  nets in a list is power or ground.
+        """Check if any net in a list is a power/ground net.
 
         Parameters
         ----------
-        netname_list : list
-            List of net names.
+        netname_list : str | list[str]
+            Net name or list of net names to check.
 
         Returns
         -------
         bool
-            ``True`` when one of the net names is ``"power"`` or ``"ground"``, ``False`` otherwise.
+            True if any net is power/ground, False otherwise.
         """
         if isinstance(netname_list, str):
             netname_list = [netname_list]
@@ -340,20 +354,19 @@ class Nets(CommonNets):
         return False
 
     def get_dcconnected_net_list(self, ground_nets=["GND"], res_value=0.001):
-        """Get the nets connected to the direct current through inductors.
-
-        .. note::
-           Only inductors are considered.
+        """Get nets connected to DC through inductors and low-value resistors.
 
         Parameters
         ----------
-        ground_nets : list, optional
-            List of ground nets. The default is ``["GND"]``.
+        ground_nets : tuple, optional
+            Ground net names. Default is ("GND",).
+        res_value : float, optional
+            Resistance threshold value. Default is 0.001 ohms.
 
         Returns
         -------
-        list
-            List of nets connected to DC through inductors.
+        list[set]
+            List of sets of connected nets.
         """
         temp_list = []
         for _, comp_obj in self._pedb.components.inductors.items():
@@ -390,18 +403,19 @@ class Nets(CommonNets):
         return dcconnected_net_list
 
     def get_powertree(self, power_net_name, ground_nets):
-        """Retrieve the power tree.
+        """Retrieve power tree for a given power net.
 
         Parameters
         ----------
         power_net_name : str
             Name of the power net.
-        ground_nets :
-
+        ground_nets : list
+            List of ground net names.
 
         Returns
         -------
-
+        tuple
+            (component_list, component_list_columns, net_group)
         """
         flag_in_ng = False
         net_group = []
@@ -449,27 +463,37 @@ class Nets(CommonNets):
         return component_list, component_list_columns, net_group
 
     def get_net_by_name(self, net_name):
-        """Find a net by name."""
+        """Find a net by name.
+
+        Parameters
+        ----------
+        net_name : str
+            Name of the net to find.
+
+        Returns
+        -------
+        pyedb.grpc.database.net.net.Net
+            Net object if found, otherwise None.
+        """
         edb_net = Net.find_by_name(self._active_layout, net_name)
         if edb_net is not None:
             return edb_net
 
     def delete(self, netlist):
-        """Delete one or more nets from EDB.
+        """Delete one or more nets from the layout.
 
         Parameters
         ----------
-        netlist : str or list
-            One or more nets to delete.
+        netlist : str | list[str]
+            Net name or list of net names to delete.
 
         Returns
         -------
-        list
-            List of nets that were deleted.
+        list[str]
+            Names of nets that were deleted.
 
         Examples
         --------
-
         >>> deleted_nets = database.nets.delete(["Net1","Net2"])
         """
         if isinstance(netlist, str):
@@ -487,26 +511,23 @@ class Nets(CommonNets):
         return nets_deleted
 
     def find_or_create_net(self, net_name="", start_with="", contain="", end_with=""):
-        """Find or create the net with the given name in the layout.
+        """Find or create a net based on given criteria.
 
         Parameters
         ----------
         net_name : str, optional
-            Name of the net to find or create. The default is ``""``.
-
+            Exact name of the net to find or create.
         start_with : str, optional
-            All net name starting with the string. Not case-sensitive.
-
+            Find nets starting with this string.
         contain : str, optional
-            All net name containing the string. Not case-sensitive.
-
+            Find nets containing this string.
         end_with : str, optional
-            All net name ending with the string. Not case-sensitive.
+            Find nets ending with this string.
 
         Returns
         -------
-        object
-            Net Object.
+        pyedb.grpc.database.net.net.Net | list[pyedb.grpc.database.net.net.Net]
+            Net object or list of matching net objects.
         """
         if not net_name and not start_with and not contain and not end_with:
             net_name = generate_unique_name("NET_")
@@ -569,8 +590,7 @@ class Nets(CommonNets):
         Returns
         -------
         bool
-            ``True`` if the net is found in component pins.
-
+            True if the net is found in the component, False otherwise.
         """
         if component_name not in self._pedb.components.instances:
             return False
@@ -582,51 +602,48 @@ class Nets(CommonNets):
     def find_and_fix_disjoint_nets(
         self, net_list=None, keep_only_main_net=False, clean_disjoints_less_than=0.0, order_by_area=False
     ):
-        """Find and fix disjoint nets from a given netlist.
+        """Find and fix disjoint nets.
 
-        .. deprecated::
-           Use new property :func:`edb.layout_validation.disjoint_nets` instead.
+        .. deprecated:: pyedb 0.30.0
+            Use :func:`edb.layout_validation.disjoint_nets` instead.
 
         Parameters
         ----------
-        net_list : str, list, optional
-            List of nets on which check disjoints. If `None` is provided then the algorithm will loop on all nets.
+        net_list : list[str], optional
+            List of nets to check. Checks all nets if None.
         keep_only_main_net : bool, optional
-            Remove all secondary nets other than principal one (the one with more objects in it). Default is `False`.
-        clean_disjoints_less_than : bool, optional
-            Clean all disjoint nets with area less than specified area in square meters. Default is `0.0` to disable it.
+            Keep only the main net segment if True.
+        clean_disjoints_less_than : float, optional
+            Clean disjoint nets smaller than this area (in m²).
         order_by_area : bool, optional
-            Whether if the naming order has to be by number of objects (fastest) or area (slowest but more accurate).
-            Default is ``False``.
+            Order naming by area instead of object count.
 
         Returns
         -------
-        List
-            New nets created.
+        list
+            New ne
 
-        Examples
-        --------
+            New nets created.
 
-        >>> renamed_nets = database.nets.find_and_fix_disjoint_nets(["GND","Net2"])
         """
+
         warnings.warn("Use new function :func:`edb.layout_validation.disjoint_nets` instead.", DeprecationWarning)
         return self._pedb.layout_validation.disjoint_nets(
             net_list, keep_only_main_net, clean_disjoints_less_than, order_by_area
         )
 
     def merge_nets_polygons(self, net_names_list):
-        """Convert paths from net into polygons, evaluate all connected polygons and perform the merge.
+        """Merge polygons for specified nets on each layer.
 
         Parameters
         ----------
-        net_names_list : str or list[str]
-            Net name of list of net name.
+        net_names_list : str | list[str]
+            Net name or list of net names.
 
         Returns
         -------
         bool
-            ``True`` when successful, ``False`` when failed.
-
+            True if successful, False otherwise.
         """
         if isinstance(net_names_list, str):
             net_names_list = [net_names_list]