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

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.52.0"
+__version__ = "0.54.0"
 version = __version__
 
 #

pyedb/configuration/cfg_common.py

@@ -20,6 +20,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from typing import List, Optional, Union
+
+from pydantic import BaseModel
+
 
 class CfgBase:
     protected_attributes = ["pedb", "pyedb_obj", "api"]
@@ -41,21 +45,14 @@ class CfgBase:
             setattr(pedb_object, attr, value)
 
 
-class CfgVar:
-    def __init__(self, **kwargs):
-        self.name = kwargs["name"]
-        self.value = kwargs["value"]
-        self.description = kwargs.get("description", "")
+class CfgVar(BaseModel):
+    name: str
+    value: Union[int, float, str]
+    description: Optional[str] = ""
 
 
-class CfgVariables:
-    def __init__(self, pedb, data):
-        self._pedb = pedb
-        self.variables = [CfgVar(**i) for i in data]
+class CfgVariables(BaseModel):
+    variables: List[CfgVar] = []
 
-    def apply(self):
-        for i in self.variables:
-            if i.name.startswith("$"):
-                self._pedb.add_project_variable(i.name, i.value)
-            else:
-                self._pedb.add_design_variable(i.name, i.value)
+    def add_variable(self, name, value, description=""):
+        self.variables.append(CfgVar(name=name, value=value, description=description))

pyedb/configuration/cfg_data.py

@@ -63,7 +63,7 @@ class CfgData(object):
 
         self.setups = CfgSetups(self._pedb, setups_data=kwargs.get("setups", []))
 
-        self.stackup = CfgStackup(self._pedb, data=kwargs.get("stackup", {}))
+        self.stackup = CfgStackup(**kwargs.get("stackup", {}))
 
         self.s_parameters = CfgSParameters(self._pedb, kwargs.get("s_parameters", []), self.general.s_parameter_library)
 
@@ -77,6 +77,6 @@ class CfgData(object):
 
         self.modeler = CfgModeler(self._pedb, data=kwargs.get("modeler", {}))
 
-        self.variables = CfgVariables(self._pedb, data=kwargs.get("variables", []))
+        self.variables = CfgVariables(variables=kwargs.get("variables", []))
 
         self.probes = CfgProbes(self._pedb, data=kwargs.get("probes", []))

pyedb/configuration/cfg_modeler.py

@@ -20,254 +20,183 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, TypedDict, Union
+
 from pyedb.configuration.cfg_components import CfgComponent
 from pyedb.configuration.cfg_padstacks import CfgPadstackDefinition, CfgPadstackInstance
-from pyedb.dotnet.database.edb_data.padstacks_data import EDBPadstack
 
 
+@dataclass
 class CfgTrace:
-    def __init__(self, **kwargs):
-        self.name = kwargs.get("name", "")
-        self.layer = kwargs["layer"]
-        self.path = kwargs.get("path")
-        self.width = kwargs["width"]
-        self.net_name = kwargs.get("net_name", "")
-        self.start_cap_style = kwargs.get("start_cap_style", "round")
-        self.end_cap_style = kwargs.get("end_cap_style", "round")
-        self.corner_style = kwargs.get("corner_style", "sharp")
-
-        self.incremental_path = kwargs.get("incremental_path")
+    name: str
+    layer: str
+    path: List[List[Union[float, str]]]
+    width: str
+    net_name: str
+    start_cap_style: str
+    end_cap_style: str
+    corner_style: str
+    incremental_path: List[List[Union[float, str]]]
+
+
+@dataclass
+class CfgPlane:
+    name: str = ""
+    layer: str = ""
+    net_name: str = ""
+    type: str = "rectangle"
 
+    # rectangle
+    lower_left_point: List[Union[float, str]] = field(default_factory=list)
+    upper_right_point: List[Union[float, str]] = field(default_factory=list)
+    corner_radius: Union[float, str] = 0
+    rotation: Union[float, str] = 0
+    voids: List[Any] = field(default_factory=list)
 
-class CfgPlane:
-    def __init__(self, **kwargs):
-        self.name = kwargs.get("name", "")
-        self.layer = kwargs["layer"]
-        self.net_name = kwargs.get("net_name", "")
-        self.type = kwargs.get("type", "rectangle")
+    # polygon
+    points: List[List[float]] = field(default_factory=list)
 
-        # rectangle
-        self.lower_left_point = kwargs.get("lower_left_point", [])
-        self.upper_right_point = kwargs.get("upper_right_point", [])
-        self.corner_radius = kwargs.get("corner_radius", 0)
-        self.rotation = kwargs.get("rotation", 0)
-        self.voids = kwargs.get("voids", [])
+    # circle
+    radius: Union[float, str] = 0
+    position: List[float] = field(default_factory=lambda: [0, 0])
 
-        # polygon
-        self.points = kwargs.get("points", [])
 
-        # circle
-        self.radius = kwargs.get("radius", 0)
-        self.position = kwargs.get("position", [0, 0])
+class PrimitivesToDeleteDict(TypedDict, total=False):
+    layer_name: List[str]
+    name: List[str]
+    net_name: List[str]
 
 
+@dataclass
 class CfgModeler:
     """Manage configuration general settings."""
 
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def set_parameter_to_edb(self):
-            from ansys.edb.core.definition.padstack_def import (
-                PadstackDef as GrpcPadstackDef,
-            )
-            from ansys.edb.core.definition.padstack_def_data import (
-                PadstackDefData as GrpcPadstackDefData,
-            )
-
-            from pyedb.grpc.database.definition.padstack_def import PadstackDef
-
-            if self.parent.traces:
-                for t in self.parent.traces:
-                    obj = self._pedb.modeler.create_trace(
-                        path_list=t.path,
-                        layer_name=t.layer,
-                        net_name=t.net_name,
-                        width=t.width,
-                        start_cap_style=t.start_cap_style,
-                        end_cap_style=t.end_cap_style,
-                        corner_style=t.corner_style,
-                    )
-                    obj.aedt_name = t.name
-
-            if self.parent.padstack_defs:
-                for p in self.parent.padstack_defs:
-                    pdata = GrpcPadstackDefData.create()
-                    pdef = GrpcPadstackDef.create(self._pedb.active_db, p.name)
-                    pdef.data = pdata
-                    pdef = PadstackDef(self._pedb, pdef)
-                    p.pyedb_obj = pdef
-                    p.api.set_parameters_to_edb()
-
-            if self.parent.padstack_instances:
-                for p in self.parent.padstack_instances:
-                    p_inst = self._pedb.padstacks.place(
-                        via_name=p.name,
-                        net_name=p.net_name,
-                        position=p.position,
-                        definition_name=p.definition,
-                    )
-                    p.pyedb_obj = p_inst
-                    p.api.set_parameters_to_edb()
-
-            if self.parent.planes:
-                for p in self.parent.planes:
-                    if p.type == "rectangle":
-                        obj = self._pedb.modeler.create_rectangle(
-                            layer_name=p.layer,
-                            net_name=p.net_name,
-                            lower_left_point=p.lower_left_point,
-                            upper_right_point=p.upper_right_point,
-                            corner_radius=p.corner_radius,
-                            rotation=p.rotation,
-                        )
-                        obj.aedt_name = p.name
-                    elif p.type == "polygon":
-                        obj = self._pedb.modeler.create_polygon(
-                            points=p.points, layer_name=p.layer, net_name=p.net_name
-                        )
-                        obj.aedt_name = p.name
-
-                    for v in p.voids:
-                        for i in self._pedb.layout.primitives:
-                            if i.aedt_name == v:
-                                self._pedb.modeler.add_void(obj, i)
+    traces: List[CfgTrace] = field(default_factory=list)
+    planes: List[CfgPlane] = field(default_factory=list)
 
-            if self.parent.components:
-                pedb_p_inst = self._pedb.padstacks.instances_by_name
-                for c in self.parent.components:
-                    obj = self._pedb.components.create(
-                        [pedb_p_inst[i] for i in c.pins],
-                        component_name=c.reference_designator,
-                        placement_layer=c.placement_layer,
-                        component_part_name=c.definition,
-                    )
-                    c.pyedb_obj = obj
-                    c.api.set_parameters_to_edb()
-
-        def delete_primitives(self):
-            primitives = self._pedb.layout.find_primitive(**self.parent.primitives_to_delete)
-            for i in primitives:
-                i.delete()
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def set_parameter_to_edb(self):
-            if self.parent.traces:
-                for t in self.parent.traces:
-                    if t.path:
-                        obj = self._pedb.modeler.create_trace(
-                            path_list=t.path,
-                            layer_name=t.layer,
-                            net_name=t.net_name,
-                            width=t.width,
-                            start_cap_style=t.start_cap_style,
-                            end_cap_style=t.end_cap_style,
-                            corner_style=t.corner_style,
-                        )
-                        obj.aedt_name = t.name
-                    else:
-                        obj = self._pedb.modeler.create_trace(
-                            path_list=[t.incremental_path[0]],
-                            layer_name=t.layer,
-                            net_name=t.net_name,
-                            width=t.width,
-                            start_cap_style=t.start_cap_style,
-                            end_cap_style=t.end_cap_style,
-                            corner_style=t.corner_style,
-                        )
-                        obj.aedt_name = t.name
-                        for x, y in t.incremental_path[1:]:
-                            obj.add_point(x, y, True)
-
-            if self.parent.padstack_defs:
-                for p in self.parent.padstack_defs:
-                    pdata = self._pedb._edb.Definition.PadstackDefData.Create()
-                    pdef = self._pedb._edb.Definition.PadstackDef.Create(self._pedb.active_db, p.name)
-                    pdef.SetData(pdata)
-                    pdef = EDBPadstack(pdef, self._pedb.padstacks)
-                    p.pyedb_obj = pdef
-                    p.api.set_parameters_to_edb()
-
-            if self.parent.padstack_instances:
-                for p in self.parent.padstack_instances:
-                    p_inst = self._pedb.padstacks.place(
-                        via_name=p.name,
-                        net_name=p.net_name,
-                        position=p.position,
-                        definition_name=p.definition,
-                        rotation=p.rotation if p.rotation is not None else 0,
-                    )
-                    p.pyedb_obj = p_inst
-                    p.api.set_parameters_to_edb()
-
-            if self.parent.planes:
-                for p in self.parent.planes:
-                    if p.type == "rectangle":
-                        obj = self._pedb.modeler.create_rectangle(
-                            layer_name=p.layer,
-                            net_name=p.net_name,
-                            lower_left_point=p.lower_left_point,
-                            upper_right_point=p.upper_right_point,
-                            corner_radius=p.corner_radius,
-                            rotation=p.rotation,
-                        )
-                        obj.aedt_name = p.name
-                    elif p.type == "polygon":
-                        obj = self._pedb.modeler.create_polygon(
-                            main_shape=p.points, layer_name=p.layer, net_name=p.net_name
-                        )
-                        obj.aedt_name = p.name
-                    elif p.type == "circle":
-                        obj = self._pedb.modeler.create_circle(
-                            layer_name=p.layer,
-                            net_name=p.net_name,
-                            x=p.position[0],
-                            y=p.position[1],
-                            radius=p.radius,
-                        )
-                        obj.aedt_name = p.name
-                    else:
-                        raise
-
-                    for v in p.voids:
-                        for i in self._pedb.layout.primitives:
-                            if i.aedt_name == v:
-                                self._pedb.modeler.add_void(obj, i)
-
-            if self.parent.components:
-                pedb_p_inst = self._pedb.padstacks.instances_by_name
-                for c in self.parent.components:
-                    obj = self._pedb.components.create(
-                        [pedb_p_inst[i] for i in c.pins],
-                        component_name=c.reference_designator,
-                        placement_layer=c.placement_layer,
-                        component_part_name=c.definition,
-                    )
-                    c.pyedb_obj = obj
-                    c.api.set_parameters_to_edb()
-
-    def __init__(self, pedb, data):
+    def __init__(self, pedb, data: Dict):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
-        self.traces = [CfgTrace(**i) for i in data.get("traces", [])]
-        self.padstack_defs = [
-            CfgPadstackDefinition(self._pedb, None, **i) for i in data.get("padstack_definitions", [])
-        ]
-        self.padstack_instances = [
-            CfgPadstackInstance(self._pedb, None, **i) for i in data.get("padstack_instances", [])
-        ]
-        self.planes = [CfgPlane(**i) for i in data.get("planes", [])]
-        self.components = [CfgComponent(self._pedb, None, **i) for i in data.get("components", [])]
-        self.primitives_to_delete = data.get("primitives_to_delete", {"layer_name": [], "name": [], "net_name": []})
-
-    def apply(self):
-        self.api.set_parameter_to_edb()
-        self.api.delete_primitives()
+        self.traces = []
+        self.planes = []
+
+        self.padstack_defs = [CfgPadstackDefinition(pedb, None, **i) for i in data.get("padstack_definitions", [])]
+        self.padstack_instances = [CfgPadstackInstance(pedb, None, **i) for i in data.get("padstack_instances", [])]
+
+        self.components = [CfgComponent(pedb, None, **i) for i in data.get("components", [])]
+        self.primitives_to_delete: PrimitivesToDeleteDict = data.get(
+            "primitives_to_delete", {"layer_name": [], "name": [], "net_name": []}
+        )
+
+        for trace_data in data.get("traces", []):
+            self.add_trace(**trace_data)
+
+        for plane_data in data.get("planes", []):
+            shape = plane_data.pop("type")
+            if shape == "rectangle":
+                self.add_rectangular_plane(**plane_data)
+            elif shape == "circle":
+                self.add_circular_plane(**plane_data)
+            elif shape == "polygon":
+                self.add_polygon_plane(**plane_data)
+
+    def add_trace(
+        self,
+        layer: str,
+        width: str,
+        name: str,
+        net_name: str = "",
+        start_cap_style: str = "round",
+        end_cap_style: str = "round",
+        corner_style: str = "sharp",
+        path: Optional[Any] = None,
+        incremental_path: Optional[Any] = None,
+    ):
+        """Add a trace from a dictionary of parameters."""
+
+        trace_obj = CfgTrace(
+            name,
+            layer,
+            path,
+            width,
+            net_name,
+            start_cap_style,
+            end_cap_style,
+            corner_style,
+            incremental_path,
+        )
+        self.traces.append(trace_obj)
+        return name
+
+    def add_rectangular_plane(
+        self,
+        layer: str,
+        name: str = "",
+        net_name: str = "",
+        lower_left_point: List[float] = "",
+        upper_right_point: List[float] = "",
+        corner_radius: float = 0,
+        rotation: float = 0,
+        voids: Optional[List[Any]] = "",
+    ):
+        plane_obj = CfgPlane(
+            name=name,
+            layer=layer,
+            net_name=net_name,
+            type="rectangle",
+            lower_left_point=lower_left_point,
+            upper_right_point=upper_right_point,
+            corner_radius=corner_radius,
+            rotation=rotation,
+            voids=voids,
+        )
+        self.planes.append(plane_obj)
+        return name
+
+    def add_circular_plane(
+        self,
+        layer: str,
+        name: str = "",
+        net_name: str = "",
+        corner_radius: float = 0,
+        rotation: float = 0,
+        voids: Optional[List[Any]] = "",
+        radius: Union[float, str] = 0,
+        position: List[Union[float, str]] = "",
+    ):
+        plane_obj = CfgPlane(
+            name=name,
+            layer=layer,
+            net_name=net_name,
+            type="circle",
+            corner_radius=corner_radius,
+            rotation=rotation,
+            voids=voids,
+            radius=radius,
+            position=position,
+        )
+        self.planes.append(plane_obj)
+        return name
+
+    def add_polygon_plane(
+        self,
+        layer: str,
+        name: str = "",
+        net_name: str = "",
+        corner_radius: float = 0,
+        rotation: float = 0,
+        voids: Optional[List[Any]] = "",
+        points: List[List[float]] = "",
+    ):
+        plane_obj = CfgPlane(
+            name=name,
+            layer=layer,
+            net_name=net_name,
+            type="polygon",
+            corner_radius=corner_radius,
+            rotation=rotation,
+            voids=voids,
+            points=points,
+        )
+        self.planes.append(plane_obj)
+        return name

pyedb/configuration/cfg_ports_sources.py

@@ -58,7 +58,7 @@ class CfgTerminalInfo(CfgBase):
         self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
         contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
 
-        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
+        self.contact_radius = self._pedb.value(contact_radius)
         self.num_of_contact = kwargs.get("num_of_contact", 4)
         self.contact_expansion = kwargs.get("contact_expansion", 1)
 
@@ -678,11 +678,9 @@ class CfgEdgePort:
     def set_parameters_to_edb(self):
         point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
         primitive = self._pedb.layout.primitives_by_aedt_name[self.primitive_name]
-        pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
-            primitive._edb_object, point_on_edge._edb_object
-        )
-        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
-        edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
+        pos_edge = self._pedb.core.cell.terminal.PrimitiveEdge.Create(primitive._edb_object, point_on_edge._edb_object)
+        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.core.cell.terminal.Edge)
+        edge_term = self._pedb.core.cell.terminal.EdgeTerminal.Create(
             primitive._edb_object.GetLayout(),
             primitive._edb_object.GetNet(),
             self.name,
@@ -755,9 +753,9 @@ class CfgDiffWavePort:
         pos_term = self.positive_port.set_parameters_to_edb()
         neg_term = self.negative_port.set_parameters_to_edb()
         edb_list = convert_py_list_to_net_list(
-            [pos_term._edb_object, neg_term._edb_object], self._pedb.edb_api.cell.terminal.Terminal
+            [pos_term._edb_object, neg_term._edb_object], self._pedb.core.cell.terminal.Terminal
         )
-        _edb_boundle_terminal = self._pedb.edb_api.cell.terminal.BundleTerminal.Create(edb_list)
+        _edb_boundle_terminal = self._pedb.core.cell.terminal.BundleTerminal.Create(edb_list)
         _edb_boundle_terminal.SetName(self.name)
         pos, neg = list(_edb_boundle_terminal.GetTerminals())
         pos.SetName(self.name + ":T1")