najaeda 0.1.0__cp311-cp311-macosx_11_0_arm64.whl → 0.1.3__cp311-cp311-macosx_11_0_arm64.whl

najaeda/netlist.py

@@ -1,53 +1,181 @@
-# SPDX-FileCopyrightText: 2024 The Naja authors <https://github.com/najaeda/naja/blob/main/AUTHORS>
+# SPDX-FileCopyrightText: 2024 The Naja authors
+# <https://github.com/najaeda/naja/blob/main/AUTHORS>
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import itertools
 import logging
+
 from najaeda import snl
 
 
 class Equipotential:
-    """Class that represents the term and wraps some of the snl occurrence API."""
-
-    def __init__(self, inst_term):
-        ito = snl.SNLNetComponentOccurrence(inst_term.path, inst_term.term)
+    """Class that represents the term and wraps
+    some of the snl occurrence API.
+    """
+
+    def __init__(self, term):
+        if isinstance(term.term, snl.SNLBusTerm):
+            raise ValueError("Equipotential cannot be constructed on bus term")
+        ito = snl.SNLNetComponentOccurrence(
+            term.path.getHeadPath(), term.path.getTailInstance().getInstTerm(term.term)
+        )
         self.equi = snl.SNLEquipotential(ito)
 
+    def __eq__(self, value):
+        return self.equi == value.equi
+
     def get_inst_terms(self):
         for term in self.equi.getInstTermOccurrences():
-            yield InstTerm(term.getPath(), term.getInstTerm())
+            yield Term(
+                snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
+                term.getInstTerm().getBitTerm(),
+            )
 
     def get_top_terms(self):
         for term in self.equi.getTerms():
-            yield TopTerm(snl.SNLPath(), term.getBitTerm())
+            yield Term(snl.SNLPath(), term.getBitTerm())
 
     def get_all_leaf_readers(self):
         for term in self.equi.getInstTermOccurrences():
-            if term.getInstTerm().getDirection() == snl.SNLTerm.Direction.Output:
-                yield InstTerm(term.getPath(), term.getInstTerm())
+            direction = term.getInstTerm().getDirection()
+            if direction != snl.SNLTerm.Direction.Output:
+                if term.getInstTerm().getInstance().getModel().isPrimitive():
+                    yield Term(
+                        snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
+                        term.getInstTerm().getBitTerm(),
+                    )
 
 
 class Net:
-    def __init__(self, path, net):
+    def __init__(self, path, net=None, net_concat=None):
+        if net is not None and net_concat is not None:
+            raise ValueError(
+                "Only one of `net` or `net_concat` should be provided, not both."
+            )
         self.path = path
-        self.net = net
+        if net is not None:
+            self.net = net
+        elif net_concat is not None:
+            self.net_concat = net_concat
+
+    def __eq__(self, other):
+        if not isinstance(other, Net):
+            return NotImplemented
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        eq_result = self.__eq__(other)
+        if eq_result is NotImplemented:
+            return NotImplemented
+        return not eq_result
+
+    def __str__(self):
+        if hasattr(self, "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}"
+        return net_str
 
     def get_name(self) -> str:
-        return self.net.getName()
+        """Return the name of the net."""
+        if hasattr(self, "net"):
+            return self.net.getName()
+        return "{" + ",".join(map(str, self.net_concat)) + "}"
+
+    def get_msb(self) -> int:
+        """Return the most significant bit of the net if it is a bus."""
+        if hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet):
+            return self.net.getMSB()
+        return None
+
+    def get_lsb(self) -> int:
+        """Return the least significant bit of the net if it is a bus."""
+        if hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet):
+            return self.net.getLSB()
+        return None
+
+    def is_bus(self) -> bool:
+        """Return True if the net is a bus."""
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet)
+
+    def is_bus_bit(self) -> bool:
+        """Return True if the net is a bit of a bus."""
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLBusNetBit)
+
+    def is_scalar(self) -> bool:
+        """Return True if the net is a scalar."""
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLScalarNet)
+
+    def is_bit(self) -> bool:
+        """Return True if the net is a bit."""
+        return self.is_scalar() or self.is_bus_bit()
+
+    def is_concat(self) -> bool:
+        """Return True if the net is a concatenation."""
+        return hasattr(self, "net_concat")
+
+    def is_const(self) -> bool:
+        """Return True if the net is a constant generator."""
+        if hasattr(self, "net"):
+            return self.net.isConstant()
+        for net in self.net_concat:
+            if not net.isConstant():
+                return False
+        return True
+
+    def get_width(self) -> int:
+        """Return the width of the net."""
+        if hasattr(self, "net"):
+            return self.net.getWidth()
+        return sum(1 for _ in self.net_concat)
+
+    def get_bits(self):
+        if hasattr(self, "net"):
+            if isinstance(self.net, snl.SNLBusNet):
+                for bit in self.net.getBits():
+                    yield Net(self.path, bit)
+            else:
+                yield self
+        else:
+            for net in self.net_concat:
+                yield 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))
+            else:
+                return None
+        if 0 <= index < len(self.net_concat):
+            return Net(self.path, 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():
-            yield InstTerm(self.path, term)
+            path = snl.SNLPath(self.path, term.getInstance())
+            yield Term(path, term.getBitTerm())
 
-    def get_top_terms(self):
+    def get_terms(self):
+        if hasattr(self, "net_concat"):
+            raise ValueError("Cannot get terms from a net_concat")
         for term in self.net.getBitTerms():
-            yield TopTerm(self.path, term)
+            yield Term(self.path, term)
 
-    def __eq__(self, value):
-        return self.net == value.net and self.path == value.path
+    def get_components(self):
+        for term in itertools.chain(self.get_terms(), self.get_inst_terms()):
+            yield term
 
 
-class TopTerm:
+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
@@ -72,86 +200,188 @@ class TopTerm:
     def __ge__(self, other) -> bool:
         return not self < other
 
-    def get_name(self) -> str:
-        return self.term.getName()
-
-    def get_direction(self) -> snl.SNLTerm.Direction:
-        return self.term.getDirection()
-
-    def get_net(self) -> Net:
-        return Net(self.path, self.term.getNet())
-
-    def get_equipotential(self) -> Equipotential:
-        return Equipotential(self)
-
-    def is_input(self) -> bool:
-        return self.term.getDirection() == snl.SNLTerm.Direction.Input
-
-    def is_output(self) -> bool:
-        return self.term.getDirection() == snl.SNLTerm.Direction.Output
-
-
-class InstTerm:
-    def __init__(self, path, term):
-        self.path = path
-        self.term = term
-
-    def __eq__(self, other) -> bool:
-        return self.path == other.path and self.term == other.term
-
-    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
-
-    def __le__(self, other) -> bool:
-        return self < other or self == other
+    def __str__(self):
+        if self.path.size() == 0:
+            return self.term.getName()
+        else:
+            return f"{self.path}/{self.term}"
+
+    def __repr__(self) -> str:
+        return f"Term({self.path}, {self.term})"
+
+    def __make_unique(self):
+        if self.path.size() > 1:
+            path = self.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)
+
+    def is_bus_bit(self) -> bool:
+        """Return True if the term is a bit of a bus."""
+        return isinstance(self.term, snl.SNLBusTermBit)
+
+    def is_scalar(self) -> bool:
+        """Return True if the term is a scalar."""
+        return isinstance(self.term, snl.SNLScalarTerm)
+
+    def is_bit(self) -> bool:
+        """Return True if the term is a bit."""
+        return self.is_scalar() or self.is_bus_bit()
+
+    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()
+        return None
 
-    def __gt__(self, other) -> bool:
-        return not self <= other
+    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()
+        return None
 
-    def __ge__(self, other) -> bool:
-        return not self < other
+    def get_width(self) -> int:
+        """Return the width of the term. 1 if scalar."""
+        return self.term.getWidth()
 
     def get_name(self) -> str:
+        """Return the name of the term."""
         return self.term.getName()
 
+    def get_direction(self) -> snl.SNLTerm.Direction:
+        """Return the direction of the term."""
+        if self.term.getDirection() == snl.SNLTerm.Direction.Input:
+            return Term.INPUT
+        elif self.term.getDirection() == snl.SNLTerm.Direction.Output:
+            return Term.OUTPUT
+        elif self.term.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)
+            return instTerm.getNet()
+        else:
+            return bit.getNet()
+
+    def __get_snl_lower_bitnet(self, bit) -> Net:
+        return bit.getNet()
+
+    def __get_snl_busnet(self, snl_nets) -> snl.SNLBusNet:
+        # iterate on all elements of the list and check if
+        # a full SNLBusNet can be reconstructed
+        snl_bus_net = None
+        for i in range(len(snl_nets)):
+            snl_net = snl_nets[i]
+            if not isinstance(snl_net, snl.SNLBusNetBit):
+                return None
+            bit_bus = snl_net.getBus()
+            if bit_bus.getWidth() != len(snl_nets):
+                return None
+            if snl_bus_net is None:
+                snl_bus_net = bit_bus
+            if snl_bus_net != bit_bus:
+                return None
+            if snl_bus_net.getBitAtPosition(i) != snl_net:
+                return None
+        return snl_bus_net
+
+    def __get_net(self, path, snl_term_net_accessor) -> Net:
+        if isinstance(self.term, snl.SNLBusTerm):
+            snl_nets = []
+            for bit in self.term.getBits():
+                snl_net = snl_term_net_accessor(bit)
+                snl_nets.append(snl_net)
+            snl_bus_net = self.__get_snl_busnet(snl_nets)
+            if snl_bus_net is not None:
+                return Net(path, snl_bus_net)
+            else:
+                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)
+            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)
+
     def get_net(self) -> Net:
-        return Net(self.path, self.term.getNet())
+        """Return the net of the term."""
+        if self.path.empty():
+            return None
+        # path is one level up
+        path = self.path.getHeadPath()
+        return self.__get_net(path, self.__get_snl_bitnet)
 
     def get_instance(self):
-        inst = self.term.getInstance()
-        path = snl.SNLPath(self.path, inst)
-        return Instance(path, inst)
+        """Return the instance of the term."""
+        return Instance(self.path)
 
-    def get_flat_fanout(self) -> Equipotential:
+    def get_flat_fanout(self):
         return self.get_equipotential().get_all_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
 
     def is_output(self) -> bool:
+        """Return True if the term is an output."""
         return self.term.getDirection() == snl.SNLTerm.Direction.Output
 
-    def get_string(self) -> str:
-        return str(snl.SNLInstTermOccurrence(self.path, self.term))
+    def get_bits(self):
+        if isinstance(self.term, snl.SNLBusTerm):
+            for bit in self.term.getBits():
+                yield Term(self.path, bit)
+        else:
+            yield self
+
+    def get_bit(self, index: int):
+        if isinstance(self.term, snl.SNLBusTerm):
+            return Term(self.path, self.term.getBit(index))
+        return None
 
     def disconnect(self):
-        uniq = snl.SNLUniquifier(self.path)
-        self.term.setNet(snl.SNLNet())
+        self.__make_unique()
+        inst = self.path.getTailInstance()
+        for bit in self.term.getBits():
+            iterm = inst.getInstTerm(bit)
+            iterm.setNet(None)
 
     def connect(self, net: Net):
-        uniq = snl.SNLUniquifier(self.path)
-        self.term.setNet(net.net)
+        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()):
+                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()):
+                iterm = inst.getInstTerm(bterm)
+                iterm.setNet(bnet)
 
 
 def get_instance_by_path(names: list):
+    assert len(names) > 0
     path = snl.SNLPath()
     instance = None
     top = snl.SNLUniverse.get().getTopDesign()
@@ -159,122 +389,341 @@ def get_instance_by_path(names: list):
     for name in names:
         path = snl.SNLPath(path, design.getInstance(name))
         instance = design.getInstance(name)
+        assert instance is not None
+        design = instance.getModel()
+    return Instance(path)
+
+
+def refresh_path(path: snl.SNLPath):
+    pathlist = []
+    pathTemp = path
+    while pathTemp.size() > 0:
+        pathlist.append(pathTemp.getHeadInstance().getName())
+        pathTemp = pathTemp.getTailPath()
+    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)
+        assert instance is not None
         design = instance.getModel()
-    return Instance(path, instance)
+    return path
 
 
 class Instance:
-    """Class that represents the instance and wraps some of the snl occurrence API."""
+    """Class that represents the instance and wraps some
+    of the snl occurrence API.
+    """
 
-    def __init__(self, path, inst):
-        self.inst = inst
+    def __init__(self, path=snl.SNLPath()):
         self.path = path
 
     def __eq__(self, other) -> bool:
-        return self.inst == other.inst and self.path == other.path
+        return self.path == other.path
+
+    def __str__(self):
+        if self.is_top():
+            top = self.__get_snl_model()
+            if top is not None:
+                return top.getName()
+            else:
+                return ""
+        else:
+            return str(self.path)
+
+    def __repr__(self) -> str:
+        return f"Instance({self.path})"
+
+    def __hash__(self):
+        return hash(self.path)
+
+    def is_top(self) -> bool:
+        """Return True if this is the top design."""
+        return self.path.size() == 0
+
+    def is_assign(self) -> bool:
+        return self.__get_snl_model().isAssign()
+
+    def is_blackbox(self) -> bool:
+        """Return True if this is a blackbox."""
+        return self.__get_snl_model().isBlackBox()
+
+    def is_const0(self) -> bool:
+        """Return True if this is a constant 0 generator."""
+        return self.__get_snl_model().isConst0()
+
+    def is_const1(self) -> bool:
+        """Return True if this is a constant 1 generator."""
+        return self.__get_snl_model().isConst1()
+
+    def is_const(self) -> bool:
+        """Return True if this is a constant generator."""
+        return self.__get_snl_model().isConst()
+
+    def is_buf(self) -> bool:
+        """Return True if this is a buffer."""
+        return self.__get_snl_model().isBuf()
+
+    def is_inv(self) -> bool:
+        """Return True if this is an inverter."""
+        return self.__get_snl_model().isInv()
+
+    def __get_snl_model(self):
+        """Return the model of the instance."""
+        if self.is_top():
+            return snl.SNLUniverse.get().getTopDesign()
+        return self.path.getTailInstance().getModel()
+
+    def __find_snl_model(self, name: str) -> snl.SNLDesign:
+        u = snl.SNLUniverse.get()
+        for db in u.getUserDBs():
+            for lib in db.getLibraries():
+                found_model = lib.getDesign(name)
+                if found_model is not None:
+                    return found_model
+        return None
 
     def get_child_instance(self, name: str):
-        return Instance(snl.SNLPath(self.path, self.inst.getModel().getInstance(name)),
-                        self.inst.getModel().getInstance(name))
+        childInst = self.__get_snl_model().getInstance(name)
+        if childInst is None:
+            return None
+        return Instance(snl.SNLPath(self.path, childInst))
 
     def get_child_instances(self):
-        for inst in self.inst.getModel().getInstances():
+        for inst in self.__get_snl_model().getInstances():
             path = snl.SNLPath(self.path, inst)
-            yield Instance(path, inst)
+            yield Instance(path)
 
     def get_number_of_child_instances(self) -> int:
-        return len(tuple(self.inst.getModel().getInstances()))
+        return sum(1 for _ in self.__get_snl_model().getInstances())
+
+    # def get_flat_primitive_instances(self):
+    #    FIXME: concat first local path with the path of the instance
+    #    model = self.__get_snl_model()
+    #    for inst in model.getInstances():
+    #        path = snl.SNLPath(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().isPrimitive():
+    #                    yield Instance(path_child)
+    #                stack.append([inst_child, path_child])
+
+    def get_nets(self):
+        for net in self.__get_snl_model().getNets():
+            yield Net(self.path, net)
+
+    def get_flat_nets(self):
+        for net in self.__get_snl_model().getNets():
+            if isinstance(net, snl.SNLBusNet):
+                for bit in net.getBits():
+                    yield Net(self.path, bit)
+            else:
+                yield Net(self.path, net)
+
+    def get_net(self, name: str) -> Net:
+        net = self.__get_snl_model().getNet(name)
+        if net is not None:
+            return Net(self.path, net)
+        return None
 
-    def get_inst_terms(self):
-        if self.inst is None:
-            return
-        for term in self.inst.getInstTerms():
-            yield InstTerm(self.path.getHeadPath(), term)
+    def is_primitive(self) -> bool:
+        """Return True if this is a primitive."""
+        return self.__get_snl_model().isPrimitive()
 
-    def get_inst_term(self, name: str) -> InstTerm:
-        if self.inst is None:
-            return None
-        for term in self.inst.getInstTerms():
-            if term.getBitTerm().getName() == name:
-                return InstTerm(self.path.getHeadPath(), term)
+    def get_terms(self):
+        for term in self.__get_snl_model().getTerms():
+            yield Term(self.path, term)
+
+    def get_flat_terms(self):
+        for term in self.__get_snl_model().getBitTerms():
+            yield Term(self.path, term)
+
+    def get_term(self, name: str) -> Term:
+        term = self.__get_snl_model().getTerm(name)
+        if term is not None:
+            return Term(self.path, self.__get_snl_model().getTerm(name))
         return None
 
-    def is_primitive(self) -> bool:
-        return self.inst.getModel().isPrimitive()
+    def get_input_terms(self):
+        for term in self.__get_snl_model().getTerms():
+            if term.getDirection() == snl.SNLTerm.Direction.Input:
+                yield Term(self.path, term)
+
+    def get_flat_input_terms(self):
+        for term in self.__get_snl_model().getTerms():
+            if term.getDirection() == snl.SNLTerm.Direction.Input:
+                if isinstance(term, snl.SNLBusTerm):
+                    for bit in term.getBits():
+                        yield Term(self.path, bit)
+                else:
+                    yield Term(self.path, term)
+
+    def get_output_terms(self):
+        for term in self.__get_snl_model().getTerms():
+            if term.getDirection() == snl.SNLTerm.Direction.Output:
+                yield Term(self.path, term)
 
-    def get_output_inst_terms(self):
-        for term in self.inst.getInstTerms():
+    def get_flat_output_terms(self):
+        for term in self.__get_snl_model().getTerms():
             if term.getDirection() == snl.SNLTerm.Direction.Output:
-                yield InstTerm(self.path.getHeadPath(), term)
+                if isinstance(term, snl.SNLBusTerm):
+                    for bit in term.getBits():
+                        yield Term(self.path, bit)
+                else:
+                    yield Term(self.path, term)
 
     def delete_instance(self, name: str):
-        path = snl.SNLPath(self.path, self.inst.getModel().getInstance(name))
-        uniq = snl.SNLUniquifier(path)
-        uniq_path = uniq.getPathUniqCollection()
+        path = snl.SNLPath(self.path, self.__get_snl_model().getInstance(name))
+        snl.SNLUniquifier(path)
+        if self.path.size() > 0:
+            self.path = refresh_path(self.path)
         # Delete the last instance in uniq_path
-        tuple(uniq_path)[len(tuple(uniq_path)) - 1].destroy()
+        self.__get_snl_model().getInstance(name).destroy()
 
     def get_name(self) -> str:
-        return self.inst.getName()
-    
-    def create_child_instance(self, model, name):
-        uniq = snl.SNLUniquifier(self.path)
-        design = self.inst.getModel()
-        newSNLInstance = snl.SNLInstance.create(design, model, name)
+        """Return the name of the instance or name of the top is this is the top."""
+        if self.is_top():
+            return self.get_model_name()
+        else:
+            return self.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]:
+        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
+            snl.SNLUniquifier(path)
+            self.path = refresh_path(self.path)
+        design = self.__get_snl_model()
+        new_instance_model = self.__find_snl_model(model)
+        if new_instance_model is None:
+            raise ValueError(
+                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)
-        return Instance(snl.SNLPath(self.path, newSNLInstance), newSNLInstance)
+        return Instance(path)
+
+    def create_term(self, name: str, direction: snl.SNLTerm.Direction) -> Term:
+        if self.path.size() > 0:
+            path = self.path
+            snl.SNLUniquifier(path)
+            self.path = refresh_path(self.path)
+        design = self.__get_snl_model()
+        newSNLTerm = snl.SNLScalarTerm.create(design, direction, name)
+        return Term(self.path, newSNLTerm)
+
+    def create_output_term(self, name: str) -> Term:
+        return self.create_term(name, snl.SNLTerm.Direction.Output)
+
+    def create_input_term(self, name: str) -> Term:
+        return self.create_term(name, snl.SNLTerm.Direction.Input)
+
+    def create_inout_term(self, name: str) -> Term:
+        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
+            snl.SNLUniquifier(path)
+            self.path = refresh_path(self.path)
+        design = self.__get_snl_model()
+        newSNLTerm = snl.SNLBusTerm.create(design, direction, msb, lsb, name)
+        return Term(self.path, newSNLTerm)
+
+    def create_inout_bus_term(self, name: str, msb: int, lsb: int) -> Term:
+        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:
+        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:
+        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
+            snl.SNLUniquifier(path)
+            self.path = refresh_path(self.path)
+        model = self.__get_snl_model()
+        newSNLNet = snl.SNLScalarNet.create(model, name)
+        return Net(self.path, newSNLNet)
+
+    def create_bus_net(self, name: str, msb: int, lsb: int) -> Net:
+        if self.path.size() > 0:
+            path = self.path
+            snl.SNLUniquifier(path)
+            self.path = refresh_path(self.path)
+        model = self.__get_snl_model()
+        newSNLNet = snl.SNLBusNet.create(model, msb, lsb, name)
+        return Net(self.path, newSNLNet)
+
+    def dump_verilog(self, path: str, name: str):
+        self.__get_snl_model().dumpVerilog(path, name)
+
+
+def get_top_db() -> snl.SNLDB:
+    if snl.SNLUniverse.get() is None:
+        snl.SNLUniverse.create()
+    if snl.SNLUniverse.get().getTopDB() is None:
+        db = snl.SNLDB.create(snl.SNLUniverse.get())
+        snl.SNLUniverse.get().setTopDB(db)
+    return snl.SNLUniverse.get().getTopDB()
 
 
-class Loader:
-    def __init__(self):
-        self.db_ = None
-        self.primitives_library_ = None
+def get_top():
+    return Instance(snl.SNLPath())
 
-    def init(self):
-        snl.SNLUniverse.create()
-        self.db_ = snl.SNLDB.create(snl.SNLUniverse.get())
-
-    def get_db(self) -> snl.SNLDB:
-        return self.db_
-
-    def get_primitives_library(self) -> snl.SNLLibrary:
-        if self.primitives_library_ is None:
-            self.primitives_library_ = snl.SNLLibrary.createPrimitives(self.db_)
-        return self.primitives_library_
-
-    def load_verilog(self, files: list):
-        self.db_.loadVerilog(files)
-
-    def verify(self):
-        universe = snl.SNLUniverse.get()
-        if universe is None:
-            logging.critical('No loaded SNLUniverse')
-            return 1
-        top = universe.getTopDesign()
-        if top is None:
-            logging.critical('SNLUniverse does not contain any top SNLDesign')
-            return 1
-        else:
-            logging.info('Found top design ' + str(top))
 
-    def load_liberty_primitives(self, files):
-        self.db_.loadLibertyPrimitives(files)
+def create_top(name: str) -> Instance:
+    # init
+    db = get_top_db()
+    # create top design
+    lib = snl.SNLLibrary.create(db)
+    top = snl.SNLDesign.create(lib, name)
+    snl.SNLUniverse.get().setTopDesign(top)
+    return Instance()
 
 
-def get_all_primitive_instances() -> list:
-    top = snl.SNLUniverse.get().getTopDesign()
-    primitives = []
-
-    for inst in top.getInstances():
-        path = snl.SNLPath(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().isPrimitive():
-                    primitives.append(Instance(path_child, inst_child))
-                stack.append([inst_child, path_child])
-    return primitives
+def load_verilog(files: list):
+    get_top_db().loadVerilog(files)
+    return get_top()
+
+
+def load_liberty(files: list):
+    get_top_db().loadLibertyPrimitives(files)
+
+
+def get_primitives_library() -> snl.SNLLibrary:
+    lib = get_top_db().getLibrary("PRIMS")
+    if lib is None:
+        lib = snl.SNLLibrary.createPrimitives(get_top_db())
+    return lib
+
+
+def get_model_name(id: tuple[int, int, int]) -> str:
+    """Return the name of the model given its id."""
+    u = snl.SNLUniverse.get()
+    if u:
+        db = u.getDB(id[0])
+        if db:
+            lib = db.getLibrary(id[1])
+            if lib:
+                model = lib.getDesign(id[2])
+                if model:
+                    return model.getName()
+    return None

najaeda-0.1.3.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: najaeda
+Version: 0.1.3
+Summary: Naja EDA Python package
+Author-Email: Naja Authors <contact@keplertech.io>
+License: Apache License 2.0
+Project-URL: Homepage, https://github.com/najaeda/naja
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+
+Naja EDA Python Package
+=======================
+
+Naja EDA is a Python package that provides data structures and APIs for developing post-synthesis Electronic Design Automation (EDA) algorithms.
+It serves as the Python counterpart to the `Naja C++ project <https://github.com/najaeda/naja>`_.
+
+Installation
+------------
+
+Install Naja EDA using pip:
+
+.. code-block:: bash
+
+    pip install najaeda
+
+Examples
+--------
+
+Load a design from a liberty file and a Verilog file
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Following snippet shows how to load primitive cells from a liberty file and
+a netlist from a Verilog file.
+
+.. code-block:: python
+
+    from os import path
+    import sys
+    from najaeda import netlist
+    
+    benchmarks = path.join('..','benchmarks')
+    liberty_files = [
+        'NangateOpenCellLibrary_typical.lib',
+        'fakeram45_1024x32.lib',
+        'fakeram45_64x32.lib'
+    ]
+    liberty_files = list(map(lambda p:path.join(benchmarks, 'liberty', p), liberty_files))
+        
+    netlist.load_liberty(liberty_files)
+    top = netlist.load_verilog([path.join(benchmarks, 'verilog', 'tinyrocket.v')])
+    
+    top.dump_verilog('.', 'tinyrocket_naja.v')
+
+Print all the instances in the netlist
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Next example shows how to browse all the netlist and print all its content.
+
+.. code-block:: python
+
+    def print_netlist(instance):
+        for child_instance in instance.get_child_instances():
+            print(f"{child_instance}:{child_instance.get_model_name()}")
+            print_netlist(child_instance)
+
+Documentation
+-------------
+
+Naja documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
+
+License
+-------
+
+This project is licensed under the Apache License 2.0. See the `LICENSE <https://github.com/najaeda/naja/blob/main/LICENSE>`_ file for details.

najaeda-0.1.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+najaeda-0.1.3.dist-info/RECORD,,
+najaeda-0.1.3.dist-info/WHEEL,sha256=vqMBchNIsmW0K9HInUQuY_xePW9YD3coNJy6G1Yfto8,114
+najaeda-0.1.3.dist-info/METADATA,sha256=cUsTBMA9mhbFVF1WSI0wQYb3hc9-ThpBYShih2Yru6E,2147
+najaeda-0.1.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+najaeda-0.1.3.dist-info/licenses/AUTHORS,sha256=e4DCPGHo6wKMyQz24V59EP7zMwalK-KBDBHHlMLFxHY,330
+najaeda/netlist.py,sha256=sKIacJE8olG3-NxUru0ntAnzeU-enJNocnvJ3O0Jnp0,25102
+najaeda/libnaja_snl_python.dylib,sha256=LIQrK5KTyR9DxmVTHJZHcw6-hN3i1sOlx1HHJ5fGKpQ,740160
+najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
+najaeda/snl.so,sha256=qBdtIcQsyMywHa-xUMdCJaTwG6yl189Bm6Zr96ZR6pU,97888
+najaeda/.dylibs/Python,sha256=Gju99qyqKDZ_AHI35mL42rySLjq0Ww_yvHDxtQSu7Kw,14303584

najaeda-0.1.0.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.1
-Name: najaeda
-Version: 0.1.0
-Summary: Naja EDA Python package
-Author-Email: Naja Authors <contact@keplertech.io>
-License: Apache License 2.0
-Project-URL: Homepage, https://github.com/najaeda/naja
-Requires-Python: >=3.8
-Description-Content-Type: text/x-rst
-
-Welcome to Naja Python package

najaeda-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-najaeda-0.1.0.dist-info/RECORD,,
-najaeda-0.1.0.dist-info/WHEEL,sha256=vqMBchNIsmW0K9HInUQuY_xePW9YD3coNJy6G1Yfto8,114
-najaeda-0.1.0.dist-info/METADATA,sha256=SIsMgouolOzryWWoChYTHcGT2-ul8f9u9mLYyIOf-VA,309
-najaeda-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-najaeda-0.1.0.dist-info/licenses/AUTHORS,sha256=e4DCPGHo6wKMyQz24V59EP7zMwalK-KBDBHHlMLFxHY,330
-najaeda/netlist.py,sha256=XyNigH-I1cKjTVcMn-eo45BgYjI7NFDhYEYlnEiOwQ8,8741
-najaeda/libnaja_snl_python.dylib,sha256=Mbxrw8_DiVzbMF3zXfIY18KdeYoeCKyR-pmDYZtVprA,705744
-najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/libnaja_snl.dylib,sha256=P60Bn-hOArZrLqcdQUL0J6NzPHUV4V8Jf0StrJpTXgg,573808
-najaeda/snl.so,sha256=K2PMfUZKoKaFA5K438t0FrM-60K7IlTYXkSQgZFaaSY,97616
-najaeda/.dylibs/Python,sha256=Gju99qyqKDZ_AHI35mL42rySLjq0Ww_yvHDxtQSu7Kw,14303584