najaeda 0.1.6__cp311-cp311-macosx_11_0_arm64.whl → 0.1.8__cp311-cp311-macosx_11_0_arm64.whl

najaeda/netlist.py

@@ -6,8 +6,61 @@
 import itertools
 import time
 import logging
-
+import hashlib
+# import json
 from najaeda import snl
+import struct
+
+
+def consistent_hash(obj):
+    def default_serializer(o):
+        if isinstance(o, (str, int, float, bool, type(None))):
+            return o
+        elif isinstance(o, (list, tuple)):
+            return [default_serializer(i) for i in o]
+        else:
+            return str(o)
+
+    def hash_value(value):
+        if isinstance(value, int):
+            return struct.pack('!q', value)
+        else:
+            raise TypeError(f"Unsupported type: {type(value)}")
+
+    def hash_object(o):
+        if isinstance(o, (list, tuple)):
+            return b''.join(hash_object(i) for i in o)
+        else:
+            return hash_value(o)
+    serialized_obj = default_serializer(obj)
+    obj_bytes = hash_object(serialized_obj)
+    return int(hashlib.sha256(obj_bytes).hexdigest(), 16)
+
+
+def get_snl_instance_from_id_list(id_list: list) -> snl.SNLInstance:
+    top = snl.SNLUniverse.get().getTopDesign()
+    design = top
+    instance = None
+    for id in id_list:
+        instance = design.getInstanceByID(id)
+        assert instance is not None
+        design = instance.getModel()
+    return instance
+
+
+def get_snl_path_from_id_list(id_list: list) -> snl.SNLPath:
+    top = snl.SNLUniverse.get().getTopDesign()
+    design = top
+    path = snl.SNLPath()
+    for id in id_list:
+        instance = design.getInstanceByID(id)
+        assert instance is not None
+        path = snl.SNLPath(path, instance)
+        assert path.getTailInstance() is not None
+        design = instance.getModel()
+    if len(id_list) > 0:
+        assert path.getTailInstance() is not None
+    return path
 
 
 class Equipotential:
@@ -16,36 +69,84 @@ class Equipotential:
     """
 
     def __init__(self, term):
-        if isinstance(term.term, snl.SNLBusTerm):
+        snl_term = get_snl_term_for_ids(term.pathIDs, term.termIDs)
+        inst_term = None
+        if isinstance(snl_term, snl.SNLBusTerm):
             raise ValueError("Equipotential cannot be constructed on bus term")
+        if len(term.pathIDs) == 0:
+            net = term.get_lower_net()
+            if net is None:
+                self.equi = None
+                return
+            inst_term = next(net.get_inst_terms(), None)
+            if inst_term is None:
+                self.equi = None
+                return
+            else:
+                snl_term = get_snl_term_for_ids(inst_term.pathIDs, inst_term.termIDs)
+        else:
+            inst_term = term
+        path = get_snl_path_from_id_list(inst_term.pathIDs)
         ito = snl.SNLNetComponentOccurrence(
-            term.path.getHeadPath(), term.path.getTailInstance().getInstTerm(term.term)
+            path.getHeadPath(),
+            path.getTailInstance().getInstTerm(snl_term)
         )
         self.equi = snl.SNLEquipotential(ito)
 
     def __eq__(self, value):
         return self.equi == value.equi
 
+    def dump_dot(self, path: str):
+        self.equi.dumpDotFile(path)
+
     def get_inst_terms(self):
-        for term in self.equi.getInstTermOccurrences():
-            yield Term(
-                snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
-                term.getInstTerm().getBitTerm(),
-            )
+        if self.equi is not None:
+            for term in self.equi.getInstTermOccurrences():
+                yield Term(
+                    snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
+                    term.getInstTerm().getBitTerm(),
+                )
 
     def get_top_terms(self):
-        for term in self.equi.getTerms():
-            yield Term(snl.SNLPath(), term)
-
-    def get_all_leaf_readers(self):
-        for term in self.equi.getInstTermOccurrences():
-            direction = term.getInstTerm().getDirection()
-            if direction != snl.SNLTerm.Direction.Output:
-                if term.getInstTerm().getInstance().getModel().isLeaf():
-                    yield Term(
-                        snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
-                        term.getInstTerm().getBitTerm(),
-                    )
+        if self.equi is not None:
+            for term in self.equi.getTerms():
+                yield Term([], term)
+
+    def get_leaf_readers(self):
+        if self.equi is not None:
+            for term in self.equi.getInstTermOccurrences():
+                direction = term.getInstTerm().getDirection()
+                if direction != snl.SNLTerm.Direction.Output:
+                    if term.getInstTerm().getInstance().getModel().isLeaf():
+                        yield Term(
+                            snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
+                            term.getInstTerm().getBitTerm(),
+                        )
+
+    def get_leaf_drivers(self):
+        if self.equi is not None:
+            for term in self.equi.getInstTermOccurrences():
+                direction = term.getInstTerm().getDirection()
+                if direction != snl.SNLTerm.Direction.Input:
+                    if term.getInstTerm().getInstance().getModel().isLeaf():
+                        yield Term(
+                            snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
+                            term.getInstTerm().getBitTerm(),
+                        )
+
+    def get_top_readers(self):
+        if self.equi is not None:
+            for term in self.equi.getTerms():
+                direction = term.getDirection()
+                if direction != snl.SNLTerm.Direction.Input:
+                    yield Term(snl.SNLPath(), term)
+
+    def get_top_drivers(self):
+        if self.equi is not None:
+            for term in self.equi.getTerms():
+                direction = term.getDirection()
+                if direction != snl.SNLTerm.Direction.Output:
+                    yield Term(snl.SNLPath(), term)
 
 
 class Net:
@@ -54,7 +155,13 @@ class Net:
             raise ValueError(
                 "Only one of `net` or `net_concat` should be provided, not both."
             )
-        self.path = path
+        if isinstance(path, snl.SNLPath):
+            if path.size() > 0:
+                self.pathIDs = path.getPathIDs()
+            else:
+                self.pathIDs = []
+        elif isinstance(path, list):
+            self.pathIDs = path.copy()
         if net is not None:
             self.net = net
         elif net_concat is not None:
@@ -76,8 +183,9 @@ class Net:
             net_str = str(self.net)
         elif hasattr(self, "net_concat"):
             net_str = "{" + ",".join(map(str, self.net_concat)) + "}"
-        if self.path.size() > 0:
-            return f"{self.path}/{net_str}"
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
+            return f"{path}/{net_str}"
         return net_str
 
     def get_name(self) -> str:
@@ -137,7 +245,7 @@ class Net:
         if hasattr(self, "net"):
             if isinstance(self.net, snl.SNLBusNet):
                 for bit in self.net.getBits():
-                    yield Net(self.path, bit)
+                    yield Net(self.pathIDs, bit)
             else:
                 yield self
         else:
@@ -147,50 +255,79 @@ class Net:
     def get_bit(self, index: int):
         if hasattr(self, "net"):
             if isinstance(self.net, snl.SNLBusNet):
-                return Net(self.path, self.net.getBit(index))
+                return Net(self.pathIDs, self.net.getBit(index))
             else:
                 return None
         if 0 <= index < len(self.net_concat):
-            return Net(self.path, self.net_concat[index])
+            return Net(self.pathIDs, self.net_concat[index])
         return None
 
     def get_inst_terms(self):
         if hasattr(self, "net_concat"):
             raise ValueError("Cannot get inst terms from a net_concat")
         for term in self.net.getInstTerms():
-            path = snl.SNLPath(self.path, term.getInstance())
+            path = self.pathIDs.copy()
+            path.append(term.getInstance().getID())
             yield Term(path, term.getBitTerm())
 
     def get_design_terms(self):
         if hasattr(self, "net_concat"):
             raise ValueError("Cannot get terms from a net_concat")
         for term in self.net.getBitTerms():
-            yield Term(self.path, term)
+            yield Term(self.pathIDs, term)
 
     def get_terms(self):
         for term in itertools.chain(self.get_design_terms(), self.get_inst_terms()):
             yield term
 
 
+def get_snl_term_for_ids(pathIDs, termIDs):
+    path = get_snl_path_from_id_list(pathIDs)
+    model = None
+    if len(pathIDs) == 0:
+        model = snl.SNLUniverse.get().getTopDesign()
+    else:
+        model = path.getTailInstance().getModel()
+    if termIDs[1] == -1:
+        return model.getTermByID(termIDs[0])
+    else:
+        snlterm = model.getTermByID(termIDs[0])
+        if isinstance(snlterm, snl.SNLBusTerm):
+            return snlterm.getBit(termIDs[1])
+        else:
+            return snlterm
+
+
 class Term:
     INPUT = snl.SNLTerm.Direction.Input
     OUTPUT = snl.SNLTerm.Direction.Output
     INOUT = snl.SNLTerm.Direction.InOut
 
     def __init__(self, path, term):
-        self.path = path
-        self.term = term
+        self.termIDs = []
+        if isinstance(term, snl.SNLBusTerm):
+            self.termIDs = [term.getID(), -1]
+        else:
+            self.termIDs = [term.getID(), term.getBit()]
+
+        if isinstance(path, snl.SNLPath):
+            if path.size() > 0:
+                self.pathIDs = path.getPathIDs()
+            else:
+                self.pathIDs = []
+        elif isinstance(path, list):
+            self.pathIDs = path.copy()
 
     def __eq__(self, other) -> bool:
-        return self.path == other.path and self.term == other.term
+        return self.pathIDs == other.pathIDs and self.termIDs == other.termIDs
 
     def __ne__(self, other) -> bool:
         return not self == other
 
     def __lt__(self, other) -> bool:
-        if self.path != other.path:
-            return self.path < other.path
-        return self.term < other.term
+        if self.pathIDs != other.pathIDs:
+            return self.pathIDs < other.pathIDs
+        return self.termIDs < other.termIDs
 
     def __le__(self, other) -> bool:
         return self < other or self == other
@@ -201,40 +338,43 @@ class Term:
     def __ge__(self, other) -> bool:
         return not self < other
 
+    def __hash__(self):
+        termIDs = []
+        snlterm = get_snl_term_for_ids(self.pathIDs, self.termIDs)
+        if isinstance(snlterm, snl.SNLBusTerm):
+            termIDs = [snlterm.getID(), -1]
+        else:
+            termIDs = [snlterm.getID(), snlterm.getBit()]
+        return consistent_hash((self.pathIDs, termIDs))
+
     def __str__(self):
-        if self.path.size() == 0:
-            return self.term.getName()
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() == 0:
+            return get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()
         else:
-            return f"{self.path}/{self.term}"
+            return f"{path}/{get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()}"
 
     def __repr__(self) -> str:
-        return f"Term({self.path}, {self.term})"
+        path = get_snl_path_from_id_list(self.pathIDs)
+        return f"Term({path}, {get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()})"
 
     def __make_unique(self):
-        if self.path.size() > 1:
-            path = self.path.getHeadPath()
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 1:
+            path = path.getHeadPath()
             snl.SNLUniquifier(path)
-            if self.is_bus_bit():
-                term = (
-                    self.path.getTailInstance().getModel().getTerm(self.term.getName())
-                )
-                self.term = term.getBit(self.term.getBit())
-            else:
-                self.term = (
-                    self.path.getTailInstance().getModel().getTerm(self.term.getName())
-                )
 
     def is_bus(self) -> bool:
         """Return True if the term is a bus."""
-        return isinstance(self.term, snl.SNLBusTerm)
+        return isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm)
 
     def is_bus_bit(self) -> bool:
         """Return True if the term is a bit of a bus."""
-        return isinstance(self.term, snl.SNLBusTermBit)
+        return isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTermBit)
 
     def is_scalar(self) -> bool:
         """Return True if the term is a scalar."""
-        return isinstance(self.term, snl.SNLScalarTerm)
+        return isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLScalarTerm)
 
     def is_bit(self) -> bool:
         """Return True if the term is a bit."""
@@ -242,37 +382,39 @@ class Term:
 
     def get_msb(self) -> int:
         """Return the most significant bit of the term if it is a bus."""
-        if isinstance(self.term, snl.SNLBusTerm):
-            return self.term.getMSB()
+        if isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm):
+            return get_snl_term_for_ids(self.pathIDs, self.termIDs).getMSB()
         return None
 
     def get_lsb(self) -> int:
         """Return the least significant bit of the term if it is a bus."""
-        if isinstance(self.term, snl.SNLBusTerm):
-            return self.term.getLSB()
+        if isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm):
+            return get_snl_term_for_ids(self.pathIDs, self.termIDs).getLSB()
         return None
 
     def get_width(self) -> int:
         """Return the width of the term. 1 if scalar."""
-        return self.term.getWidth()
+        return get_snl_term_for_ids(self.pathIDs, self.termIDs).getWidth()
 
     def get_name(self) -> str:
         """Return the name of the term."""
-        return self.term.getName()
+        return get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()
 
     def get_direction(self) -> snl.SNLTerm.Direction:
         """Return the direction of the term."""
-        if self.term.getDirection() == snl.SNLTerm.Direction.Input:
+        snlterm = get_snl_term_for_ids(self.pathIDs, self.termIDs)
+        if snlterm.getDirection() == snl.SNLTerm.Direction.Input:
             return Term.INPUT
-        elif self.term.getDirection() == snl.SNLTerm.Direction.Output:
+        elif snlterm.getDirection() == snl.SNLTerm.Direction.Output:
             return Term.OUTPUT
-        elif self.term.getDirection() == snl.SNLTerm.Direction.InOut:
+        elif snlterm.getDirection() == snl.SNLTerm.Direction.InOut:
             return Term.INOUT
 
     def __get_snl_bitnet(self, bit) -> Net:
         # single bit
-        if self.path.size() > 0:
-            instTerm = self.path.getTailInstance().getInstTerm(bit)
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
+            instTerm = path.getTailInstance().getInstTerm(bit)
             return instTerm.getNet()
         else:
             return bit.getNet()
@@ -300,9 +442,9 @@ class Term:
         return snl_bus_net
 
     def __get_net(self, path, snl_term_net_accessor) -> Net:
-        if isinstance(self.term, snl.SNLBusTerm):
+        if isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm):
             snl_nets = []
-            for bit in self.term.getBits():
+            for bit in get_snl_term_for_ids(self.pathIDs, self.termIDs).getBits():
                 snl_net = snl_term_net_accessor(bit)
                 snl_nets.append(snl_net)
             snl_bus_net = self.__get_snl_busnet(snl_nets)
@@ -312,57 +454,62 @@ class Term:
                 if all(element is not None for element in snl_nets):
                     return Net(path, net_concat=snl_nets)
         else:
-            snl_net = snl_term_net_accessor(self.term)
+            snl_net = snl_term_net_accessor(get_snl_term_for_ids(self.pathIDs, self.termIDs))
             if snl_net is not None:
                 return Net(path, snl_net)
         return None
 
     def get_lower_net(self) -> Net:
         """Return the lower net of the term."""
-        return self.__get_net(self.path, self.__get_snl_lower_bitnet)
+        return self.__get_net(self.pathIDs, self.__get_snl_lower_bitnet)
 
     def get_net(self) -> Net:
         """Return the net of the term."""
-        if self.path.empty():
+        head_path = self.pathIDs.copy()
+        if len(head_path) == 0:
             return None
         # path is one level up
-        path = self.path.getHeadPath()
-        return self.__get_net(path, self.__get_snl_bitnet)
+        head_path.pop()
+        return self.__get_net(head_path, self.__get_snl_bitnet)
 
     def get_instance(self):
         """Return the instance of the term."""
-        return Instance(self.path)
+        return Instance(self.pathIDs)
 
     def get_flat_fanout(self):
-        return self.get_equipotential().get_all_leaf_readers()
+        return self.get_equipotential().get_leaf_readers()
 
     def get_equipotential(self) -> Equipotential:
         return Equipotential(self)
 
     def is_input(self) -> bool:
         """Return True if the term is an input."""
-        return self.term.getDirection() == snl.SNLTerm.Direction.Input
+        snlterm = get_snl_term_for_ids(self.pathIDs, self.termIDs)
+        return snlterm.getDirection() == snl.SNLTerm.Direction.Input
 
     def is_output(self) -> bool:
         """Return True if the term is an output."""
-        return self.term.getDirection() == snl.SNLTerm.Direction.Output
+        snlterm = get_snl_term_for_ids(self.pathIDs, self.termIDs)
+        return snlterm.getDirection() == snl.SNLTerm.Direction.Output
 
     def get_bits(self):
-        if isinstance(self.term, snl.SNLBusTerm):
-            for bit in self.term.getBits():
-                yield Term(self.path, bit)
+        if isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm):
+            for bit in get_snl_term_for_ids(self.pathIDs, self.termIDs).getBits():
+                yield Term(self.pathIDs, bit)
         else:
             yield self
 
     def get_bit(self, index: int):
-        if isinstance(self.term, snl.SNLBusTerm):
-            return Term(self.path, self.term.getBit(index))
+        if isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm):
+            return Term(self.pathIDs, get_snl_term_for_ids(
+                        self.pathIDs, self.termIDs).getBit(index))
         return None
 
     def disconnect(self):
+        path = get_snl_path_from_id_list(self.pathIDs)
         self.__make_unique()
-        inst = self.path.getTailInstance()
-        for bit in self.term.getBits():
+        inst = path.getTailInstance()
+        for bit in get_snl_term_for_ids(self.pathIDs, self.termIDs).getBits():
             iterm = inst.getInstTerm(bit)
             iterm.setNet(None)
 
@@ -370,13 +517,18 @@ class Term:
         if self.get_width() != net.get_width():
             raise ValueError("Width mismatch")
         if self.get_instance().is_top():
-            for bterm, bnet in zip(self.term.getBits(), net.net.getBits()):
+            for bterm, bnet in zip(get_snl_term_for_ids(self.pathIDs,
+                                                        self.termIDs).getBits(),
+                                   net.net.getBits()):
                 logging.debug(f"Connecting {bterm} to {bnet}")
                 bterm.setNet(bnet)
         else:
             self.__make_unique()
-            inst = self.path.getTailInstance()
-            for bterm, bnet in zip(self.term.getBits(), net.net.getBits()):
+            path = get_snl_path_from_id_list(self.pathIDs)
+            inst = path.getTailInstance()
+            for bterm, bnet in zip(get_snl_term_for_ids(self.pathIDs,
+                                                        self.termIDs).getBits(),
+                                   net.net.getBits()):
                 iterm = inst.getInstTerm(bterm)
                 iterm.setNet(bnet)
 
@@ -396,19 +548,15 @@ def get_instance_by_path(names: list):
 
 
 def refresh_path(path: snl.SNLPath):
-    pathlist = []
-    pathTemp = path
-    while pathTemp.size() > 0:
-        pathlist.append(pathTemp.getHeadInstance().getName())
-        pathTemp = pathTemp.getTailPath()
+    pathlist = path.getPathIDs()
     assert len(pathlist) > 0
     path = snl.SNLPath()
     instance = None
     top = snl.SNLUniverse.get().getTopDesign()
     design = top
-    for name in pathlist:
-        path = snl.SNLPath(path, design.getInstance(name))
-        instance = design.getInstance(name)
+    for id in pathlist:
+        path = snl.SNLPath(path, design.getInstanceByID(id))
+        instance = design.getInstanceByID(id)
         assert instance is not None
         design = instance.getModel()
     return path
@@ -420,10 +568,16 @@ class Instance:
     """
 
     def __init__(self, path=snl.SNLPath()):
-        self.path = path
+        if isinstance(path, snl.SNLPath):
+            if path.size() > 0:
+                self.pathIDs = path.getPathIDs()
+            else:
+                self.pathIDs = []
+        elif isinstance(path, list):
+            self.pathIDs = path.copy()
 
     def __eq__(self, other) -> bool:
-        return self.path == other.path
+        return self.pathIDs == other.pathIDs
 
     def __str__(self):
         if self.is_top():
@@ -433,17 +587,36 @@ class Instance:
             else:
                 return ""
         else:
-            return str(self.path)
+            path = get_snl_path_from_id_list(self.pathIDs)
+            return str(path)
 
     def __repr__(self) -> str:
-        return f"Instance({self.path})"
+        path = get_snl_path_from_id_list(self.pathIDs)
+        return f"Instance({path})"
 
-    # def __hash__(self):
-    #    return hash(self.path)
+    def __hash__(self):
+        return consistent_hash(self.pathIDs)
+
+    def get_leaf_children(self):
+        initial_path = get_snl_path_from_id_list(self.pathIDs)
+        for inst in self.__get_snl_model().getInstances():
+            if inst.getModel().isLeaf():
+                yield Instance(snl.SNLPath(initial_path, inst))
+            path = snl.SNLPath(initial_path, inst)
+            stack = [[inst, path]]
+            while stack:
+                current = stack.pop()
+                current_inst = current[0]
+                current_path = current[1]
+                for inst_child in current_inst.getModel().getInstances():
+                    path_child = snl.SNLPath(current_path, inst_child)
+                    if inst_child.getModel().isLeaf():
+                        yield Instance(path_child)
+                    stack.append([inst_child, path_child])
 
     def is_top(self) -> bool:
         """Return True if this is the top design."""
-        return self.path.size() == 0
+        return len(self.pathIDs) == 0
 
     def is_assign(self) -> bool:
         return self.__get_snl_model().isAssign()
@@ -480,7 +653,8 @@ class Instance:
         """Return the model of the instance."""
         if self.is_top():
             return snl.SNLUniverse.get().getTopDesign()
-        return self.path.getTailInstance().getModel()
+        instance = get_snl_instance_from_id_list(self.pathIDs)
+        return instance.getModel()
 
     def __find_snl_model(self, name: str) -> snl.SNLDesign:
         u = snl.SNLUniverse.get()
@@ -491,15 +665,26 @@ class Instance:
                     return found_model
         return None
 
+    def dump_full_dot(self, path: str):
+        """Dump the full dot file of this instance."""
+        self.__get_snl_model().dumpFullDotFile(path)
+
+    def dump_context_dot(self, path: str):
+        self.__get_snl_model().dumpContextDotFile(path)
+
     def get_child_instance(self, name: str):
+        """Return the child instance with the given name."""
         childInst = self.__get_snl_model().getInstance(name)
         if childInst is None:
             return None
-        return Instance(snl.SNLPath(self.path, childInst))
+        path = self.pathIDs.copy()
+        path.append(childInst.getID())
+        return Instance(path)
 
     def get_child_instances(self):
         for inst in self.__get_snl_model().getInstances():
-            path = snl.SNLPath(self.path, inst)
+            path = self.pathIDs.copy()
+            path.append(inst.getID())
             yield Instance(path)
 
     def get_number_of_child_instances(self) -> int:
@@ -522,21 +707,28 @@ class Instance:
     #                stack.append([inst_child, path_child])
 
     def get_nets(self):
+        """Return the nets of the instance.
+        This will iterate over all scalar nets and bus nets.
+        """
         for net in self.__get_snl_model().getNets():
-            yield Net(self.path, net)
+            yield Net(self.pathIDs, net)
 
     def get_flat_nets(self):
+        """Return the nets of the instance.
+        This will iterate over all scalar nets and bus net bits.
+        """
         for net in self.__get_snl_model().getNets():
             if isinstance(net, snl.SNLBusNet):
                 for bit in net.getBits():
-                    yield Net(self.path, bit)
+                    yield Net(self.pathIDs, bit)
             else:
-                yield Net(self.path, net)
+                yield Net(self.pathIDs, net)
 
     def get_net(self, name: str) -> Net:
+        """Return the net with the given name."""
         net = self.__get_snl_model().getNet(name)
         if net is not None:
-            return Net(self.path, net)
+            return Net(self.pathIDs, net)
         return None
 
     def is_primitive(self) -> bool:
@@ -544,75 +736,124 @@ class Instance:
         return self.__get_snl_model().isPrimitive()
 
     def get_terms(self):
+        """Return the terms of the instance.
+        This will iterate over all scalar terms and bus terms.
+        """
         for term in self.__get_snl_model().getTerms():
-            yield Term(self.path, term)
+            yield Term(self.pathIDs, term)
 
     def get_flat_terms(self):
+        """Return the flat terms of the instance.
+        This will iterate over all scalar terms and bus term bits.
+        """
         for term in self.__get_snl_model().getBitTerms():
-            yield Term(self.path, term)
+            yield Term(self.pathIDs, term)
 
     def get_term(self, name: str) -> Term:
+        """Return the term with the given name."""
         term = self.__get_snl_model().getTerm(name)
         if term is not None:
-            return Term(self.path, self.__get_snl_model().getTerm(name))
+            return Term(self.pathIDs, self.__get_snl_model().getTerm(name))
         return None
 
     def get_input_terms(self):
+        """Return the input terms of the instance.
+        This will iterate over all scalar input terms and bus input terms.
+        """
         for term in self.__get_snl_model().getTerms():
-            if term.getDirection() == snl.SNLTerm.Direction.Input:
-                yield Term(self.path, term)
+            if term.getDirection() != snl.SNLTerm.Direction.Output:
+                yield Term(self.pathIDs, term)
 
     def get_flat_input_terms(self):
+        """Return the flat input terms of the instance.
+        This will iterate over all scalar input terms and bus input term bits.
+        """
         for term in self.__get_snl_model().getTerms():
-            if term.getDirection() == snl.SNLTerm.Direction.Input:
+            if term.getDirection() != snl.SNLTerm.Direction.Output:
                 if isinstance(term, snl.SNLBusTerm):
                     for bit in term.getBits():
-                        yield Term(self.path, bit)
+                        yield Term(self.pathIDs, bit)
                 else:
-                    yield Term(self.path, term)
+                    yield Term(self.pathIDs, term)
 
     def get_output_terms(self):
+        """Return the output terms of the instance.
+        This will iterate over all scalar output terms and bus output terms.
+        """
         for term in self.__get_snl_model().getTerms():
-            if term.getDirection() == snl.SNLTerm.Direction.Output:
-                yield Term(self.path, term)
+            if term.getDirection() != snl.SNLTerm.Direction.Input:
+                yield Term(self.pathIDs, term)
 
     def get_flat_output_terms(self):
+        """Return the flat output terms of the instance.
+        This will iterate over all scalar output terms and bus output term bits.
+        """
         for term in self.__get_snl_model().getTerms():
-            if term.getDirection() == snl.SNLTerm.Direction.Output:
+            if term.getDirection() != snl.SNLTerm.Direction.Input:
                 if isinstance(term, snl.SNLBusTerm):
                     for bit in term.getBits():
-                        yield Term(self.path, bit)
+                        yield Term(self.pathIDs, bit)
                 else:
-                    yield Term(self.path, term)
+                    yield Term(self.pathIDs, term)
 
     def delete_instance(self, name: str):
-        path = snl.SNLPath(self.path, self.__get_snl_model().getInstance(name))
+        """Delete the child instance with the given name."""
+        if name == "":
+            raise ValueError(
+                "Cannot delete instance with empty name. Try delete_instance_by_id instead."
+            )
+        init_path = get_snl_path_from_id_list(self.pathIDs)
+        path = snl.SNLPath(init_path, self.__get_snl_model().getInstance(name))
+        snl.SNLUniquifier(path)
+        if init_path.size() > 0:
+            # Delete the last instance in uniq_path
+            self.__get_snl_model().getInstance(name).destroy()
+
+    def delete_instance_by_id(self, id: str):
+        """Delete the child instance with the given ID."""
+        init_path = get_snl_path_from_id_list(self.pathIDs)
+        path = snl.SNLPath(init_path, self.__get_snl_model().getInstanceByID(id))
         snl.SNLUniquifier(path)
-        if self.path.size() > 0:
-            self.path = refresh_path(self.path)
         # Delete the last instance in uniq_path
-        self.__get_snl_model().getInstance(name).destroy()
+        self.__get_snl_model().getInstanceByID(id).destroy()
+
+    def get_design(self):
+        """Return the Instance containing this instance."""
+        path = self.pathIDs.copy()
+        if len(self.pathIDs) == 1:
+            return get_top()
+        path.pop()
+        return Instance(path)
+
+    def delete(self):
+        """Delete this instance."""
+        path = get_snl_path_from_id_list(self.pathIDs)
+        snl.SNLUniquifier(path)
+        self.get_design().delete_instance_by_id(path.getTailInstance().getID())
 
     def get_name(self) -> str:
         """Return the name of the instance or name of the top is this is the top."""
+        path = get_snl_path_from_id_list(self.pathIDs)
         if self.is_top():
             return self.get_model_name()
         else:
-            return self.path.getTailInstance().getName()
+            return path.getTailInstance().getName()
 
     def get_model_name(self) -> str:
         """Return the name of the model of the instance or name of the top is this is the top."""
         return self.__get_snl_model().getName()
 
     def get_model_id(self) -> tuple[int, int, int]:
+        """Return the ID of the model of the instance or ID of the top is this is the top."""
         model = self.__get_snl_model()
         return model.getDB().getID(), model.getLibrary().getID(), model.getID()
 
     def create_child_instance(self, model: str, name: str):
-        if self.path.size() > 0:
-            path = self.path
+        """Create a child instance with the given model and name."""
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
             snl.SNLUniquifier(path)
-            self.path = refresh_path(self.path)
+            path = get_snl_path_from_id_list(self.pathIDs)
         design = self.__get_snl_model()
         new_instance_model = self.__find_snl_model(model)
         if new_instance_model is None:
@@ -620,64 +861,75 @@ class Instance:
                 f"Cannot create instance {name} in {self}: model {model} cannot be found"
             )
         newSNLInstance = snl.SNLInstance.create(design, new_instance_model, name)
-        path = snl.SNLPath(self.path, newSNLInstance)
+        path = snl.SNLPath(path, newSNLInstance)
         return Instance(path)
 
     def create_term(self, name: str, direction: snl.SNLTerm.Direction) -> Term:
-        if self.path.size() > 0:
-            path = self.path
+        """Create a Term  in this Instance with the given name and direction."""
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
             snl.SNLUniquifier(path)
-            self.path = refresh_path(self.path)
+            path = get_snl_path_from_id_list(self.pathIDs)
         design = self.__get_snl_model()
         newSNLTerm = snl.SNLScalarTerm.create(design, direction, name)
-        return Term(self.path, newSNLTerm)
+        return Term(path, newSNLTerm)
 
     def create_output_term(self, name: str) -> Term:
+        """Create an output Term in this Instance with the given name."""
         return self.create_term(name, snl.SNLTerm.Direction.Output)
 
     def create_input_term(self, name: str) -> Term:
+        """Create an input Term in this Instance with the given name."""
         return self.create_term(name, snl.SNLTerm.Direction.Input)
 
     def create_inout_term(self, name: str) -> Term:
+        """Create an inout Term in this Instance with the given name."""
         return self.create_term(name, snl.SNLTerm.Direction.InOut)
 
     def create_bus_term(self, name: str, msb: int, lsb: int, direction) -> Term:
-        if self.path.size() > 0:
-            path = self.path
+        """Create a bus Term in this Instance with the given name, msb, lsb and direction."""
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
             snl.SNLUniquifier(path)
-            self.path = refresh_path(self.path)
+            path = get_snl_path_from_id_list(self.pathIDs)
         design = self.__get_snl_model()
         newSNLTerm = snl.SNLBusTerm.create(design, direction, msb, lsb, name)
-        return Term(self.path, newSNLTerm)
+        return Term(path, newSNLTerm)
 
     def create_inout_bus_term(self, name: str, msb: int, lsb: int) -> Term:
+        """Create an inout bus Term in this Instance with the given name, msb and lsb."""
         return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.InOut)
 
     def create_output_bus_term(self, name: str, msb: int, lsb: int) -> Term:
+        """Create an output bus Term in this Instance with the given name, msb and lsb."""
         return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.Output)
 
     def create_input_bus_term(self, name: str, msb: int, lsb: int) -> Term:
+        """Create an input bus Term in this Instance with the given name, msb and lsb."""
         return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.Input)
 
     def create_net(self, name: str) -> Net:
-        if self.path.size() > 0:
-            path = self.path
+        """Create a scalar Net in this Instance with the given name."""
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
             snl.SNLUniquifier(path)
-            self.path = refresh_path(self.path)
+            path = get_snl_path_from_id_list(self.pathIDs)
         model = self.__get_snl_model()
         newSNLNet = snl.SNLScalarNet.create(model, name)
-        return Net(self.path, newSNLNet)
+        return Net(path, newSNLNet)
 
     def create_bus_net(self, name: str, msb: int, lsb: int) -> Net:
-        if self.path.size() > 0:
-            path = self.path
+        """Create a bus Net in this Instance with the given name, msb and lsb."""
+        path = get_snl_path_from_id_list(self.pathIDs)
+        if path.size() > 0:
             snl.SNLUniquifier(path)
-            self.path = refresh_path(self.path)
+            path = get_snl_path_from_id_list(self.pathIDs)
         model = self.__get_snl_model()
         newSNLNet = snl.SNLBusNet.create(model, msb, lsb, name)
-        return Net(self.path, newSNLNet)
+        return Net(path, newSNLNet)
 
     def dump_verilog(self, path: str, name: str):
+        """Dump the verilog of this instance."""
         self.__get_snl_model().dumpVerilog(path, name)
 
 
@@ -731,7 +983,7 @@ def load_primitives(name: str):
 def get_primitives_library() -> snl.SNLLibrary:
     lib = get_top_db().getLibrary("PRIMS")
     if lib is None:
-        lib = snl.SNLLibrary.createPrimitives(get_top_db())
+        lib = snl.SNLLibrary.createPrimitives(get_top_db(), "PRIMS")
     return lib