najaeda 0.1.3__cp313-cp313t-macosx_11_0_arm64.whl → 0.1.5__cp313-cp313t-macosx_11_0_arm64.whl

najaeda/instance_visitor.py

@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors
+# <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Callable
+from najaeda import netlist
+
+
+class VisitorConfig:
+    def __init__(
+        self,
+        enter_condition: Callable[[netlist.Instance], bool] = lambda node: True,
+        callback: Callable[[netlist.Instance], None] = lambda node: None,
+    ):
+        """
+        :param enter_condition: A function that determines whether to visit
+        the children of an instance.
+        :param callback: The callback to be executed when an instance is visited.
+        """
+        self.callback = callback
+        self.enter_condition = enter_condition
+
+
+class Visitor:
+    def __init__(self, instance: netlist.Instance):
+        """
+        :param netlist: The hierarchical netlist to be traversed.
+        """
+        self.instance = instance
+
+    def visit(self, instance: netlist.Instance, config: VisitorConfig):
+        """
+        Recursively visits nodes in the netlist hierarchy.
+
+        :param instance: The current node in the netlist instance hierarchy.
+        :param config: VisitorConfig object defining conditions and callbacks.
+        """
+        # Execute the callback
+        config.callback(instance)
+
+        # Check if we should proceed to children
+        if config.enter_condition(instance):
+            for child in instance.get_child_instances():
+                self.visit(child, config)

najaeda/netlist.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import itertools
+import time
 import logging
 
 from najaeda import snl
@@ -34,13 +35,13 @@ class Equipotential:
 
     def get_top_terms(self):
         for term in self.equi.getTerms():
-            yield Term(snl.SNLPath(), term.getBitTerm())
+            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().isPrimitive():
+                if term.getInstTerm().getInstance().getModel().isLeaf():
                     yield Term(
                         snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
                         term.getInstTerm().getBitTerm(),
@@ -160,14 +161,14 @@ class Net:
             path = snl.SNLPath(self.path, term.getInstance())
             yield Term(path, term.getBitTerm())
 
-    def get_terms(self):
+    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)
 
-    def get_components(self):
-        for term in itertools.chain(self.get_terms(), self.get_inst_terms()):
+    def get_terms(self):
+        for term in itertools.chain(self.get_design_terms(), self.get_inst_terms()):
             yield term
 
 
@@ -451,6 +452,10 @@ class Instance:
         """Return True if this is a blackbox."""
         return self.__get_snl_model().isBlackBox()
 
+    def is_leaf(self) -> bool:
+        """Return True if this is a leaf."""
+        return self.__get_snl_model().isLeaf()
+
     def is_const0(self) -> bool:
         """Return True if this is a constant 0 generator."""
         return self.__get_snl_model().isConst0()
@@ -700,14 +705,29 @@ def create_top(name: str) -> Instance:
 
 
 def load_verilog(files: list):
+    start_time = time.time()
+    logging.info(f"Loading verilog: {', '.join(files)}")
     get_top_db().loadVerilog(files)
+    execution_time = time.time() - start_time
+    logging.info(f"Loading done in {execution_time:.2f} seconds")
     return get_top()
 
 
 def load_liberty(files: list):
+    logging.info(f"Loading liberty: {', '.join(files)}")
     get_top_db().loadLibertyPrimitives(files)
 
 
+def load_primitives(name: str):
+    if name == "xilinx":
+        logging.info("Loading xilinx primitives")
+        from najaeda.primitives import xilinx
+
+        xilinx.load(get_top_db())
+    else:
+        raise ValueError(f"Unknown primitives library: {name}")
+
+
 def get_primitives_library() -> snl.SNLLibrary:
     lib = get_top_db().getLibrary("PRIMS")
     if lib is None:

najaeda/primitives/xilinx.py

@@ -0,0 +1,452 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from najaeda import snl
+
+
+def constructIBUF(lib):
+    ibuf = snl.SNLDesign.createPrimitive(lib, "IBUF")
+    i = snl.SNLScalarTerm.create(ibuf, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(ibuf, snl.SNLTerm.Direction.Output, "O")
+    ibuf.addCombinatorialArcs(i, o)
+
+
+def constructOBUF(lib):
+    obuf = snl.SNLDesign.createPrimitive(lib, "OBUF")
+    i = snl.SNLScalarTerm.create(obuf, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(obuf, snl.SNLTerm.Direction.Output, "O")
+    obuf.addCombinatorialArcs(i, o)
+
+
+def constructBUFG(lib):
+    bufg = snl.SNLDesign.createPrimitive(lib, "BUFG")
+    i = snl.SNLScalarTerm.create(bufg, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(bufg, snl.SNLTerm.Direction.Output, "O")
+    bufg.addCombinatorialArcs(i, o)
+
+
+def constructDSP48E1(lib):
+    dsp48e1 = snl.SNLDesign.createPrimitive(lib, "DSP48E1")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 29, 0, "ACOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 17, 0, "BCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "CARRYCASCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "MULTSIGNOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "PCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "OVERFLOW")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "PATTERNBDETECT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "PATTERNDETECT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "UNDERFLOW")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 3, 0, "CARRYOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 47, 0, "P")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 29, 0, "ACIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 17, 0, "BCIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CARRYCASCIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "MULTSIGNIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "PCIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 3, 0, "ALUMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 2, 0, "CARRYINSEL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CLK")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 4, 0, "INMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 6, 0, "OPMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 29, 0, "A")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 17, 0, "B")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "C")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CARRYIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 24, 0, "D")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEA1")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEA2")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEAD")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEALUMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEB1")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEB2")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEC")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CECARRYIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CECTRL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CED")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEINMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEM")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEP")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTA")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTALLCARRYIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTALUMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTB")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTC")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTCTRL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTD")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTINMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTM")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTP")
+    snl.SNLParameter.create_decimal(dsp48e1, "ACASCREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "ADREG", 1)
+    snl.SNLParameter.create_string(dsp48e1, "A_INPUT", "DIRECT")
+    snl.SNLParameter.create_decimal(dsp48e1, "ALUMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "AREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "BCASCREG", 1)
+    snl.SNLParameter.create_string(dsp48e1, "B_INPUT", "DIRECT")
+    snl.SNLParameter.create_decimal(dsp48e1, "BREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CARRYINREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CARRYINSELREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "DREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "INMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "MREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "OPMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "PREG", 1)
+    snl.SNLParameter.create_boolean(dsp48e1, "USE_DPORT", False)
+    snl.SNLParameter.create_string(dsp48e1, "USE_MULT", "MULTIPLY")
+    snl.SNLParameter.create_string(dsp48e1, "USE_SIMD", "ONE48")
+
+
+def constructINV(lib):
+    inv = snl.SNLDesign.createPrimitive(lib, "INV")
+    i = snl.SNLScalarTerm.create(inv, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(inv, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs(i, o)
+
+
+def constructCARRY4(lib):
+    carry4 = snl.SNLDesign.createPrimitive(lib, "CARRY4")
+    o = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Output, 3, 0, "O")
+    co = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Output, 3, 0, "CO")
+    di = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Input, 3, 0, "DI")
+    s = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Input, 3, 0, "S")
+    cyinit = snl.SNLScalarTerm.create(carry4, snl.SNLTerm.Direction.Input, "CYINIT")
+    ci = snl.SNLScalarTerm.create(carry4, snl.SNLTerm.Direction.Input, "CI")
+    o_bits = [b for b in o.getBits()]
+    co_bits = [b for b in co.getBits()]
+    di_bits = [b for b in di.getBits()]
+    s_bits = [b for b in s.getBits()]
+    # cyinit and ci are in combinatorial dependency with o and co outputs
+    snl.SNLDesign.addCombinatorialArcs([cyinit, ci], [o, co])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[0], [o, co])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[1], [o_bits[1], o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[1], [co_bits[1], co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[2], [o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[2], [co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[3], o_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[3], co_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[0], [o_bits[1], o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[0], co)
+    snl.SNLDesign.addCombinatorialArcs(di_bits[1], [o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[1], [co_bits[1], co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[2], o_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[2], [co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[3], co_bits[3])
+
+
+def constructLUT1(lib):
+    lut1 = snl.SNLDesign.createPrimitive(lib, "LUT1")
+    i0 = snl.SNLScalarTerm.create(lut1, snl.SNLTerm.Direction.Input, "I0")
+    o = snl.SNLScalarTerm.create(lut1, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs(i0, o)
+    snl.SNLParameter.create_binary(lut1, "INIT", 2, 0b00)
+
+
+def constructLUT2(lib):
+    lut2 = snl.SNLDesign.createPrimitive(lib, "LUT2")
+    i0 = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1], o)
+    snl.SNLParameter.create_binary(lut2, "INIT", 4, 0x0)
+
+
+def constructLUT3(lib):
+    lut3 = snl.SNLDesign.createPrimitive(lib, "LUT3")
+    i0 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I2")
+    o = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2], o)
+    snl.SNLParameter.create_binary(lut3, "INIT", 8, 0x00)
+
+
+def constructLUT4(lib):
+    lut4 = snl.SNLDesign.createPrimitive(lib, "LUT4")
+    i0 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I3")
+    o = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3], o)
+    snl.SNLParameter.create_binary(lut4, "INIT", 16, 0x0000)
+
+
+def constructLUT5(lib):
+    lut5 = snl.SNLDesign.createPrimitive(lib, "LUT5")
+    i0 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I3")
+    i4 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I4")
+    o = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3, i4], o)
+    snl.SNLParameter.create_binary(lut5, "INIT", 32, 0x00000000)
+
+
+def constructLUT6(lib):
+    lut6 = snl.SNLDesign.createPrimitive(lib, "LUT6")
+    i0 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I3")
+    i4 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I4")
+    i5 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I5")
+    o = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3, i4, i5], o)
+    snl.SNLParameter.create_binary(lut6, "INIT", 64, 0x0000000000000000)
+
+
+def constructMUXF7(lib):
+    muxf7 = snl.SNLDesign.createPrimitive(lib, "MUXF7")
+    i0 = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Output, "O")
+    s = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "S")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, s], o)
+
+
+def constructMUXF8(lib):
+    muxf8 = snl.SNLDesign.createPrimitive(lib, "MUXF8")
+    i0 = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Output, "O")
+    s = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "S")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, s], o)
+
+
+def constructSRL16E(lib):
+    srl16e = snl.SNLDesign.createPrimitive(lib, "SRL16E")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "CE")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "CLK")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Output, "Q")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A0")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A1")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A2")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A3")
+    snl.SNLParameter.create_binary(srl16e, "INIT", 16, 0x0000)
+    snl.SNLParameter.create_binary(srl16e, "IS_CLK_INVERTED", 1, 0)
+
+
+def constructFDCE(lib):
+    fdce = snl.SNLDesign.createPrimitive(lib, "FDCE")
+    q = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "CE")
+    clr = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "CLR")
+    d = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdce, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, clr, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDPE(lib):
+    fdpe = snl.SNLDesign.createPrimitive(lib, "FDPE")
+    q = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "CE")
+    pre = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "PRE")
+    d = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdpe, "INIT", 1, 0b1)
+    snl.SNLDesign.addInputsToClockArcs([ce, pre, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDRE(lib):
+    fdre = snl.SNLDesign.createPrimitive(lib, "FDRE")
+    q = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "CE")
+    r = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "R")
+    d = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdre, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, r, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDSE(lib):
+    fdse = snl.SNLDesign.createPrimitive(lib, "FDSE")
+    q = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "CE")
+    s = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "S")
+    d = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdse, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, s, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructRAM32M(lib):
+    ram32m = snl.SNLDesign.createPrimitive(lib, "RAM32M")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOD")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRD")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DID")
+    snl.SNLScalarTerm.create(ram32m, snl.SNLTerm.Direction.Input, "WCLK")
+    snl.SNLScalarTerm.create(ram32m, snl.SNLTerm.Direction.Input, "WE")
+    snl.SNLParameter.create_binary(ram32m, "INIT_A", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_B", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_C", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_D", 64, 0)
+
+
+def constructRAM64M(lib):
+    ram64m = snl.SNLDesign.createPrimitive(lib, "RAM64M")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOA")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOB")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOC")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOD")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRA")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRB")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRC")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRD")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIA")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIB")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIC")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DID")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "WCLK")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "WE")
+    snl.SNLParameter.create_binary(ram64m, "INIT_A", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_B", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_C", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_D", 64, 0)
+
+
+def constructRAMB18E1(lib):
+    ramb18e1 = snl.SNLDesign.createPrimitive(lib, "RAMB18E1")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 13, 0, "ADDRARDADDR")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 13, 0, "ADDRBWRADDR")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "CLKARDCLK")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "CLKBWRCLK")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 15, 0, "DIADI")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 15, 0, "DIBDI")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "DIPADIP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "DIPBDIP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 15, 0, "DOADO")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 15, 0, "DOBDO")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 1, 0, "DOPADOP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 1, 0, "DOPBDOP")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "ENARDEN")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "ENBWREN")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "REGCEAREGCE")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "REGCEB")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTRAMARSTRAM")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTRAMB")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTREGARSTREG")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTREGB")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "WEA")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 3, 0, "WEBWE")
+    snl.SNLParameter.create_decimal(ramb18e1, "DOA_REG", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "DOB_REG", 0)
+    snl.SNLParameter.create_binary(ramb18e1, "INIT_A", 18, 0x00000)
+    snl.SNLParameter.create_binary(ramb18e1, "INIT_B", 18, 0x00000)
+    for i in range(64):
+        paramName = "INIT_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb18e1, paramName, 256, 0)
+    for i in range(8):
+        paramName = "INITP_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb18e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb18e1, "RAM_MODE", "TDP")
+    snl.SNLParameter.create_decimal(ramb18e1, "READ_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "READ_WIDTH_B", 0)
+    snl.SNLParameter.create_binary(ramb18e1, "SRVAL_A", 18, 0)
+    snl.SNLParameter.create_binary(ramb18e1, "SRVAL_B", 18, 0)
+    snl.SNLParameter.create_string(ramb18e1, "WRITE_MODE_A", "WRITE_FIRST")
+    snl.SNLParameter.create_string(ramb18e1, "WRITE_MODE_B", "WRITE_FIRST")
+    snl.SNLParameter.create_decimal(ramb18e1, "WRITE_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "WRITE_WIDTH_B", 0)
+
+
+def constructRAMB36E1(lib):
+    ramb36e1 = snl.SNLDesign.createPrimitive(lib, "RAMB36E1")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 15, 0, "ADDRARDADDR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 15, 0, "ADDRBWRADDR")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CASCADEINA")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CASCADEINB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "CASCADEOUTA")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "CASCADEOUTB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CLKARDCLK")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CLKBWRCLK")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "DBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 31, 0, "DIADI")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 31, 0, "DIBDI")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "DIPADIP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "DIPBDIP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 31, 0, "DOADO")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 31, 0, "DOBDO")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 3, 0, "DOPADOP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 3, 0, "DOPBDOP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 7, 0, "ECCPARITY")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "ENARDEN")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "ENBWREN")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "INJECTDBITERR")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "INJECTSBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 8, 0, "RDADDRECC")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "REGCEAREGCE")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "REGCEB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTRAMARSTRAM")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTRAMB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTREGARSTREG")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTREGB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "SBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "WEA")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 7, 0, "WEBWE")
+
+    snl.SNLParameter.create_decimal(ramb36e1, "DOA_REG", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "DOB_REG", 0)
+    snl.SNLParameter.create_binary(ramb36e1, "INIT_A", 36, 0)
+    snl.SNLParameter.create_binary(ramb36e1, "INIT_B", 36, 0)
+    for i in range(128):
+        paramName = "INIT_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb36e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb36e1, "RAM_EXTENSION_A", "NONE")
+    snl.SNLParameter.create_string(ramb36e1, "RAM_EXTENSION_B", "NONE")
+    for i in range(16):
+        paramName = "INITP_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb36e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb36e1, "RAM_MODE", "TDP")
+    snl.SNLParameter.create_decimal(ramb36e1, "READ_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "READ_WIDTH_B", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "WRITE_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "WRITE_WIDTH_B", 0)
+    snl.SNLParameter.create_binary(ramb36e1, "SRVAL_A", 36, 0)
+    snl.SNLParameter.create_binary(ramb36e1, "SRVAL_B", 36, 0)
+    snl.SNLParameter.create_string(ramb36e1, "WRITE_MODE_A", "WRITE_FIRST")
+    snl.SNLParameter.create_string(ramb36e1, "WRITE_MODE_B", "WRITE_FIRST")
+
+
+def load(db):
+    lib = snl.SNLLibrary.createPrimitives(db, "xilinx")
+    constructIBUF(lib)
+    constructOBUF(lib)
+    constructBUFG(lib)
+    constructDSP48E1(lib)
+    constructINV(lib)
+    constructCARRY4(lib)
+    constructLUT1(lib)
+    constructLUT2(lib)
+    constructLUT3(lib)
+    constructLUT4(lib)
+    constructLUT5(lib)
+    constructLUT6(lib)
+    constructMUXF7(lib)
+    constructMUXF8(lib)
+    constructSRL16E(lib)
+    constructFDCE(lib)
+    constructFDPE(lib)
+    constructFDRE(lib)
+    constructFDSE(lib)
+    constructRAM32M(lib)
+    constructRAM64M(lib)
+    constructRAMB18E1(lib)
+    constructRAMB36E1(lib)

{najaeda-0.1.3.dist-info → najaeda-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: najaeda
-Version: 0.1.3
+Version: 0.1.5
 Summary: Naja EDA Python package
 Author-Email: Naja Authors <contact@keplertech.io>
 License: Apache License 2.0
@@ -33,10 +33,6 @@ 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',
@@ -50,9 +46,25 @@ a netlist from a Verilog file.
     
     top.dump_verilog('.', 'tinyrocket_naja.v')
 
+Load a design with pre-existing libraries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In FPGA design environments, Liberty files are often unavailable.
+To address this, the following example demonstrates how to load primitives
+without relying on Liberty files.
+
+najaeda comes with pre-configured libraries to simplify this process.
+Currently, it includes support for partial Xilinx primitives, but this can be
+easily extended in the future. Don't hesitate to reach out if you need help.
+
+.. code-block:: python
+
+    netlist.load_primitives('xilinx')
+    benchmarks = path.join('..','benchmarks')
+    top = netlist.load_verilog([path.join(benchmarks, 'verilog', 'arm_core_netlist.v')])
+
 Print all the instances in the netlist
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Next example shows how to browse all the netlist and print all its content.
+Next example shows how to browse all the netlist and print all its content recursively.
 
 .. code-block:: python
 
@@ -61,12 +73,30 @@ Next example shows how to browse all the netlist and print all its content.
             print(f"{child_instance}:{child_instance.get_model_name()}")
             print_netlist(child_instance)
 
+Similar to the previous example, but utilizing an instance visitor.
+This approach allows you to perform operations on each instance while
+also defining conditions for stopping or continuing exploration.
+
+.. code-block:: python
+
+    def print_instance(instance):
+        print(f"{instance}:{instance.get_model_name()}")
+    visitor_config = instance_visitor.VisitorConfig(callback=print_instance)
+    instance_visitor.Visitor(top).visit(top, visitor_config)
+
 Documentation
 -------------
+najaeda is a work in progress, and the documentation is still under development.
 
 Naja documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
 
-License
+Support
 -------
+Please put up issues on the Delocate issue tracker.
+If you encounter any issues or have questions, please report them on the
+`Naja issue tracker <https://github.com/najaeda/naja/issues>`_.
 
-This project is licensed under the Apache License 2.0. See the `LICENSE <https://github.com/najaeda/naja/blob/main/LICENSE>`_ file for details.
+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.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+najaeda-0.1.5.dist-info/RECORD,,
+najaeda-0.1.5.dist-info/WHEEL,sha256=WOiMFvo9bzNKIh5Rxx7xDwR4DzXJ4VAFWxSvvQdE_uA,115
+najaeda-0.1.5.dist-info/METADATA,sha256=WuZMeLEC6yRy9aEA4UiQ5Bg9RA_NtPplvGclOEt6h7c,3511
+najaeda-0.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+najaeda-0.1.5.dist-info/licenses/AUTHORS,sha256=7NYEGDAX_1QZvCCHfq8YVXC5ZbwH_pbNI8DcSmm70GU,377
+najaeda/netlist.py,sha256=jzpnmhGdkXRmSYmMNv3YGe3KC9BB9eoQc0Y3zlMh3ag,25748
+najaeda/libnaja_snl_python.dylib,sha256=S64GfIw9I7Lj391D9ZVwZjFAXeTB0VCbXsq5euw3zGA,740288
+najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
+najaeda/snl.so,sha256=Og454YB20jBXM9_5w2YG0e-yDHX95KaJxdGK-6FvjW4,97888
+najaeda/instance_visitor.py,sha256=HrrOnCSuw5Lh1HSp2R-ckYP4gEbqdxp_rw3Sl0GpGHE,1479
+najaeda/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/primitives/xilinx.py,sha256=fuu4KxEIuC0ueCK4C_gds6hzgtJsLE3tjDtOHtY9McM,25947

{najaeda-0.1.3.dist-info → najaeda-0.1.5.dist-info}/licenses/AUTHORS

@@ -3,4 +3,5 @@
 # This does not necessarily list everyone who has contributed code, since in
 # some cases, their employer may be the copyright holder.  To see the full list
 # of contributors, see the revision history in source control.
-Christophe Alexandre <christophe.alex@gmail.com>
+Christophe Alexandre <christophe.alexandre@keplertech.io>
+Noam Cohen <noam.cohen@keplertech.io>

najaeda-0.1.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-najaeda-0.1.3.dist-info/RECORD,,
-najaeda-0.1.3.dist-info/WHEEL,sha256=WOiMFvo9bzNKIh5Rxx7xDwR4DzXJ4VAFWxSvvQdE_uA,115
-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=NufBTjIC-14Ailajr63ycpoHng0PONuZY3y26c9aehw,740272
-najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
-najaeda/snl.so,sha256=Pm6IrWbo5sJ7VbokbTf36Q_tVlttrtXkNT4A_b4X1Pg,97888
-najaeda/.dylibs/PythonT,sha256=PKxrOOyA9Wrc11wkOBZVdQachBkACXp9879F1jMycxc,13116640