najaeda 0.3.3__cp314-cp314-win_amd64.whl

najaeda/stats.py

@@ -0,0 +1,410 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import json
+
+from najaeda import netlist
+
+
+class InstancesStats:
+    def __init__(self):
+        self.blackboxes = dict()
+        self.hier_instances = dict()
+
+    def dump_instance_stats_text(self, instance, stats_files):
+        dumped_models = set()
+        self.__dump_instance_stats_text(instance, stats_files, dumped_models)
+
+    def __dump_stats(self, file, value_name, value):
+        file.write(f"{value_name}: {value} \n")
+
+    def __dump_terms_stats_text(self, instance_stats, file):
+        file.write("Terms: ")
+        first = True
+        for terms in instance_stats.terms.items():
+            if not first:
+                file.write(", ")
+            else:
+                first = False
+            file.write(terms[0] + ":" + str(terms[1]))
+        file.write("\n")
+
+    def __dump_instances(self, stats_file, title, instances):
+        if len(instances) == 0:
+            return
+        sorted_instances = sorted(
+            instances.items(), key=lambda item: netlist.get_model_name(item[0])
+        )
+        stats_file.write(title + " " + str(sum(j for i, j in sorted_instances)) + "\n")
+        line_char = 0
+        for instance in sorted_instances:
+            model_name = netlist.get_model_name(instance[0])
+            if line_char != 0:
+                stats_file.write(",")
+                line_char += 1
+            if line_char > 80:
+                stats_file.write("\n")
+                line_char = 0
+            elif line_char != 0:
+                stats_file.write(" ")
+                line_char += 1
+            instance_char = model_name + ":" + str(instance[1])
+            line_char += len(instance_char)
+            stats_file.write(instance_char)
+        stats_file.write("\n\n")
+
+    def __dump_instance_stats_text(self, instance, file, dumped_models):
+        if instance.is_primitive() or instance.is_blackbox():
+            return
+        # Only dump once each model
+        model_id = instance.get_model_id()
+        if model_id in dumped_models:
+            return
+        dumped_models.add(model_id)
+
+        file.write("*** " + instance.get_name() + " ***\n")
+
+        instance_stats = self.hier_instances.get(model_id)
+        if instance_stats is None:
+            print(
+                "Cannot find " + str(instance.get_model_name()) + " in instance_stats"
+            )
+            raise
+
+        if len(instance_stats.terms) > 0:
+            self.__dump_terms_stats_text(instance_stats, file)
+
+        # self.__dump_instances(stats_file, "Instances:", design_stats.ins)
+        nb_primitives = sum(instance_stats.basic_primitives.values()) + sum(
+            instance_stats.primitives.values()
+        )
+        if nb_primitives > 1:
+            self.__dump_stats(file, "Primitives", nb_primitives)
+
+        self.__dump_instances(
+            file, "Simple Primitives:", instance_stats.basic_primitives
+        )
+        self.__dump_instances(file, "Other Primitives:", instance_stats.primitives)
+        self.__dump_instances(file, "Blackboxes:", instance_stats.blackboxes)
+
+        if instance_stats.assigns > 0:
+            self.__dump_stats(file, "Assigns", instance_stats.assigns)
+
+        self.__dump_instances(file, "Flat Instances:", instance_stats.flat_ins)
+        self.__dump_instances(file, "Flat Blackboxes:", instance_stats.flat_blackboxes)
+
+        nb_primitives = sum(instance_stats.flat_basic_primitives.values()) + sum(
+            instance_stats.flat_primitives.values()
+        )
+        if nb_primitives > 1:
+            self.__dump_stats(file, "Flat Primitives", nb_primitives)
+
+        self.__dump_instances(
+            file, "Flat Simple Primitives:", instance_stats.flat_basic_primitives
+        )
+        self.__dump_instances(
+            file, "Flat Other Primitives:", instance_stats.flat_primitives
+        )
+
+        if instance_stats.flat_assigns > 0:
+            self.__dump_stats(file, "Flat Assigns", instance_stats.flat_assigns)
+
+        file.write("\n")
+
+        for child_instance in instance.get_child_instances():
+            self.__dump_instance_stats_text(child_instance, file, dumped_models)
+
+
+class InstanceStats:
+    def __init__(self):
+        self.name = ""
+        self.assigns = 0
+        self.flat_assigns = 0
+        self.basic_primitives = dict()
+        self.primitives = dict()
+        self.flat_basic_primitives = dict()
+        self.flat_primitives = dict()
+        self.blackboxes = dict()
+        self.flat_blackboxes = dict()
+        self.ins = dict()
+        self.flat_ins = dict()
+        self.terms = dict()
+        self.bit_terms = dict()
+        self.net_stats = dict()
+
+    def add_ins_stats(self, ins_stats):
+        self.flat_assigns += ins_stats.flat_assigns
+        for ins, nb in ins_stats.flat_ins.items():
+            self.flat_ins[ins] = self.flat_ins.get(ins, 0) + nb
+        for ins, nb in ins_stats.flat_blackboxes.items():
+            self.flat_blackboxes[ins] = self.flat_blackboxes.get(ins, 0) + nb
+        for primitive, nb in ins_stats.flat_primitives.items():
+            self.flat_primitives[primitive] = (
+                self.flat_primitives.get(primitive, 0) + nb
+            )
+        for primitive, nb in ins_stats.flat_basic_primitives.items():
+            self.flat_basic_primitives[primitive] = (
+                self.flat_basic_primitives.get(primitive, 0) + nb
+            )
+
+
+def is_basic_primitive(instance):
+    return instance.is_const() or instance.is_buf() or instance.is_inv()
+
+
+def compute_instance_stats(instance, instances_stats):
+    if instance.get_model_id() in instances_stats.hier_instances:
+        return instances_stats.hier_instances.get(instance.get_model_id())
+    instance_stats = InstanceStats()
+    instance_stats.name = instance.get_model_name()
+    for ins in instance.get_child_instances():
+        model_id = ins.get_model_id()
+        if ins.is_assign():
+            instance_stats.assigns += 1
+            instance_stats.flat_assigns += 1
+        elif ins.is_primitive():
+            if is_basic_primitive(ins):
+                instance_stats.basic_primitives[model_id] = (
+                    instance_stats.basic_primitives.get(model_id, 0) + 1
+                )
+                instance_stats.flat_basic_primitives[model_id] = (
+                    instance_stats.flat_basic_primitives.get(model_id, 0) + 1
+                )
+            else:
+                instance_stats.primitives[model_id] = (
+                    instance_stats.primitives.get(model_id, 0) + 1
+                )
+                instance_stats.flat_primitives[model_id] = (
+                    instance_stats.flat_primitives.get(model_id, 0) + 1
+                )
+        elif ins.is_blackbox():
+            instance_stats.blackboxes[model_id] = (
+                instance_stats.blackboxes.get(model_id, 0) + 1
+            )
+            instance_stats.flat_blackboxes[model_id] = (
+                instance_stats.flat_blackboxes.get(model_id, 0) + 1
+            )
+            if model_id not in instance_stats.blackboxes:
+                instance_stats.blackboxes[model_id] = dict()
+                compute_instance_terms(model_id, instance_stats.blackboxes[model_id])
+        else:
+            if model_id in instances_stats.hier_instances:
+                model_stats = instances_stats.hier_instances[model_id]
+            else:
+                model_stats = compute_instance_stats(ins, instances_stats)
+            instance_stats.ins[model_id] = instance_stats.ins.get(model_id, 0) + 1
+            instance_stats.flat_ins[model_id] = (
+                instance_stats.flat_ins.get(model_id, 0) + 1
+            )
+            instance_stats.add_ins_stats(model_stats)
+    compute_instance_terms(instance, instance_stats)
+    compute_instance_net_stats(instance, instance_stats)
+    instances_stats.hier_instances[instance.get_model_id()] = instance_stats
+    return instance_stats
+
+
+def compute_instance_terms(instance, instance_stats):
+    for term in instance.get_terms():
+        if term.get_direction() == netlist.Term.Direction.INPUT:
+            instance_stats.terms["inputs"] = instance_stats.terms.get("inputs", 0) + 1
+            bit_terms = sum(1 for _ in term.get_bits())
+            instance_stats.bit_terms["inputs"] = (
+                instance_stats.bit_terms.get("inputs", 0) + bit_terms
+            )
+        elif term.get_direction() == netlist.Term.Direction.OUTPUT:
+            instance_stats.terms["outputs"] = instance_stats.terms.get("outputs", 0) + 1
+            bit_terms = sum(1 for _ in term.get_bits())
+            instance_stats.bit_terms["outputs"] = (
+                instance_stats.bit_terms.get("outputs", 0) + bit_terms
+            )
+        elif term.get_direction() == netlist.Term.Direction.INOUT:
+            instance_stats.terms["inouts"] = instance_stats.terms.get("inouts", 0) + 1
+            bit_terms = sum(1 for _ in term.get_bits())
+            instance_stats.bit_terms["inouts"] = (
+                instance_stats.bit_terms.get("inouts", 0) + bit_terms
+            )
+        else:
+            instance_stats.terms["unknowns"] = (
+                instance_stats.terms.get("unknowns", 0) + 1
+            )
+            bit_terms = sum(1 for _ in term.get_bits())
+            instance_stats.bit_terms["unknowns"] = (
+                instance_stats.bit_terms.get("unknowns", 0) + bit_terms
+            )
+
+
+def compute_instance_net_stats(instance, instance_stats):
+    for net in instance.get_bit_nets():
+        if net.is_const():
+            pass
+        nb_components = sum(1 for c in net.get_terms())
+        instance_stats.net_stats[nb_components] = (
+            instance_stats.net_stats.get(nb_components, 0) + 1
+        )
+        instance_stats.net_stats = dict(sorted(instance_stats.net_stats.items()))
+
+
+def dump_instances(stats_file, title, instances):
+    if len(instances) == 0:
+        return
+    sorted_instances = sorted(
+        instances.items(), key=lambda item: netlist.get_model_name(item[0])
+    )
+    stats_file.write(title + " " + str(sum(j for i, j in sorted_instances)) + "\n")
+    line_char = 0
+    for instance in sorted_instances:
+        model_name = netlist.get_model_name(instance[0])
+        if line_char != 0:
+            stats_file.write(",")
+            line_char += 1
+        if line_char > 80:
+            stats_file.write("\n")
+            line_char = 0
+        elif line_char != 0:
+            stats_file.write(" ")
+            line_char += 1
+        instance_char = model_name + ":" + str(instance[1])
+        line_char += len(instance_char)
+        stats_file.write(instance_char)
+    stats_file.write("\n\n")
+
+
+def dump_blackboxes_stats(stats_file, design_stats):
+    if len(design_stats.blackboxes) > 0:
+        stats_file.write("*** BlackBoxes ***\n")
+        for bbox in design_stats.blackboxes.items():
+            design = bbox[0]
+            design_terms = bbox[1]
+            stats_file.write("*** " + design.getName() + " ***\n")
+            if len(design_terms) > 0:
+                stats_file.write("Terms: ")
+                first = True
+                for terms in design_terms.items():
+                    if not first:
+                        stats_file.write(", ")
+                    else:
+                        first = False
+                    stats_file.write(terms[0] + ":" + str(terms[1]))
+                stats_file.write("\n")
+            stats_file.write("\n")
+
+
+# def dump_pandas(designs_stats):
+#  import pandas
+#  import matplotlib.pyplot as plt
+#
+#  #create a figures directory erase the previous one
+#  if os.path.exists('figures'):
+#    import shutil
+#    shutil.rmtree('figures')
+#  os.makedirs('figures')
+#
+#  data = []
+#  for design, design_stats in designs_stats.hier_designs.items():
+#    data.append([
+#      design.getName(),
+#      sum(design_stats.terms.values()),
+#      sum(design_stats.bit_terms.values()),
+#      sum(design_stats.basic_primitives.values()),
+#      sum(design_stats.primitives.values()),
+#      sum(design_stats.blackboxes.values()),
+#      sum(design_stats.ins.values()),
+#      sum(design_stats.flat_ins.values()),
+#      sum(design_stats.flat_blackboxes.values()),
+#      sum(design_stats.flat_basic_primitives.values()),
+#      sum(design_stats.flat_primitives.values())])
+#  df = pandas.DataFrame(data, columns=[
+#    'Design', 'Terms', 'Bit Terms',
+#    'Basic Primitives', 'Primitives', 'Blackboxes', 'Instances',
+#    'Flat Instances', 'Flat Blackboxes',
+#    'Flat Basic Primitives', 'Flat Primitives'])
+#  df.to_csv('figures/designs_stats.csv', index=False)
+#
+#  net_series = pandas.Series(design_stats.net_stats)
+#  nets_plot = net_series.plot(kind='bar',
+#      title='Number of nets with a given number of components for\n' + design.getName(),
+#      xlabel='number of components', ylabel='number of nets')
+#  nets_plot.set_yscale('log')
+#  nets_plot.xaxis.set_major_locator(plt.MaxNLocator(100))
+#  nets_figure = nets_plot.get_figure()
+#  nets_figure.tight_layout()
+#  nets_figure.savefig('figures/nets_' + design.getName() + '.png')
+#
+#  flat_primitives_series = pandas.Series(design_stats.flat_primitives)
+#  primitives_plot = flat_primitives_series.plot(kind='bar',
+#                  title='Number of  primitives for\n' + design.getName(),
+#                  xlabel='primitive', ylabel='number of flat instances')
+#  primitives_plot.set_yscale('log')
+#  primitives_figure = primitives_plot.get_figure()
+#  primitives_figure.tight_layout()
+#  primitives_figure.savefig('figures/flat_primitives_' + design.getName() + '.png')
+
+
+def convert_instance_stats_to_json(instance_stats):
+    json_top = list()
+    for _, value in instance_stats.hier_instances.items():
+        nb_primitives = sum(value.basic_primitives.values())
+        +sum(value.primitives.values())
+        nb_terms = sum(value.terms.values())
+        nb_nets = sum(value.net_stats.keys())
+        nb_ins = sum(value.ins.values()) + nb_primitives
+        json_top.append(
+            {
+                "Name": value.name,
+                "primitives": nb_primitives,
+                "instances": nb_ins,
+                "terms": nb_terms,
+                "nets": nb_nets,
+                # "primitives": value.primitives,
+                # "flat_basic_primitives": value.flat_basic_primitives,
+                # "flat_primitives": value.flat_primitives,
+                # "blackboxes": value.blackboxes,
+                # "flat_blackboxes": value.flat_blackboxes,
+                # "ins": value.ins,
+                # "flat_ins": value.flat_ins,
+                # "terms": value.terms,
+                # "bit_terms": value.bit_terms,
+                # "net_stats": value.net_stats,
+            }
+        )
+    return json_top
+
+
+def dump_instance_stats_json(instance, path: str):
+    instances_stats = InstancesStats()
+    compute_instance_stats(instance, instances_stats)
+    json_dict = convert_instance_stats_to_json(instances_stats)
+    with open(path, "w") as f:
+        json.dump(json_dict, f, indent=4)
+
+
+def dump_instance_stats_text(instance, path: str):
+    instances_stats = InstancesStats()
+    compute_instance_stats(instance, instances_stats)
+    instances_stats.dump_instance_stats_text(instance, path)
+
+
+def dump_constants(design, analyzed_models):
+    if design.isPrimitive():
+        return
+    if design in analyzed_models:
+        return
+    analyzed_models.add(design)
+    for bitnet in design.getBitNets():
+        if bitnet.isConstant():
+            message = f"In design {design.getName()}, \
+                    constant net {bitnet.getName()} \
+                    of type {bitnet.getTypeAsString()}"
+            logging.info(message)
+            if all(False for _ in bitnet.getComponents()):
+                logging.info(" with zero connections\n")
+            else:
+                logging.info(" connected to:\n")
+                for component in bitnet.getComponents():
+                    logging.info(str(component) + "\n")
+
+    for ins in design.getInstances():
+        model = ins.getModel()
+        dump_constants(model, analyzed_models)

najaeda-0.3.3.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.11.2
+Arguments: ['C:\\hostedtoolcache\\windows\\Python\\3.11.9\\x64\\Scripts\\delvewheel', 'repair', '-v', '--ignore-existing', '--analyze-existing', '--include-imports', '--add-path', 'C:\\Users\\runneradmin\\vcpkg\\installed\\x64-windows\\bin', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-g372w1d8\\cp314-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-g372w1d8\\cp314-win_amd64\\built_wheel\\najaeda-0.3.3-cp314-cp314-win_amd64.whl']

najaeda-0.3.3.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.2
+Name: najaeda
+Version: 0.3.3
+Summary: Naja EDA Python package
+Author-Email: Naja Authors <contact@keplertech.io>
+License: Apache License 2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Project-URL: Homepage, https://github.com/najaeda/naja
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+
+najaeda Python Package
+=======================
+
+najaeda is a Python package that provides data structures and APIs for developing post-synthesis Electronic Design Automation (EDA) algorithms.
+
+najaeda provides a powerful yet simple framework designed to help software
+and hardware developers efficiently navigate and manipulate electronic
+design automation (EDA) workflows.
+
+With najaeda, you can:
+
+* Explore Netlists with Ease:
+
+  * Navigate netlist hierarchy and connectivity effortlessly.
+  * Browse at multiple levels of detail:
+
+    * Bit-level or bus-level granularity.
+    * Instance-by-instance exploration or flattened views at the primitives level.
+    * Localized per-instance connections or comprehensive equipotential views.
+
+* Perform ECO (Engineering Change Order) Transformations:
+
+  * Seamlessly apply and manage changes to your designs.
+
+* Prototype EDA Ideas Quickly:
+
+  * Use an intuitive API to experiment with new EDA concepts and workflows.
+
+* Develop Custom EDA Tools:
+
+  * Build fast, tailored tools for solving specific challenges without relying on costly, proprietary EDA software.
+
+najaeda empowers developers to innovate, adapt, and accelerate their EDA
+processes with minimal overhead.
+
+najaeda is the Python counterpart of the `Naja C++ project <https://github.com/najaeda/naja>`_.
+
+If you find this project useful, please consider `starring it on GitHub <https://github.com/najaeda/naja>`_ to show your support.
+
+Feel free to reach out to us anytime at `contact@keplertech.io <mailto:contact@keplertech.io>`_.
+
+Installation
+------------
+
+Install Naja EDA using pip:
+
+.. code-block:: bash
+
+    pip install najaeda
+
+Quick Start
+-----------
+
+To quickly explore what **najaeda** can do, launch the interactive tutorial notebook on Google Colab:
+
+.. image:: https://colab.research.google.com/assets/colab-badge.svg
+   :target: https://colab.research.google.com/github/najaeda/najaeda-tutorials/blob/main/notebooks/01_getting_started.ipynb
+   :alt: Open in Colab
+
+Documentation
+-------------
+
+Naja EDA online documentation is available `here <https://najaeda.readthedocs.io/en/latest/index.html>`_.
+
+Examples
+--------
+
+A list of examples can be found in this
+documentation `section <https://najaeda.readthedocs.io/en/latest/examples.html>`_.
+
+Support
+-------
+If you encounter any issues or have questions, please report them on the
+`Naja issue tracker <https://github.com/najaeda/naja/issues>`_.
+
+You’re also welcome to join the discussion on Matrix:
+
+.. image:: https://img.shields.io/badge/Matrix-Join%20Chat-success?logo=matrix
+   :target: https://matrix.to/#/#naja:fossi-chat.org
+   :alt: Join the Matrix chat
+
+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.3.3.dist-info/RECORD

@@ -0,0 +1,44 @@
+najaeda/instance_visitor.py,sha256=vwymIJ3_-iIUKdcRt-ZXPcDwmp0UKsNCyDP6Z0ue7zA,1573
+najaeda/naja.pyd,sha256=EekzDdcxLeEUs2lqRl1opncouJb8y_c_vqHZdKzd0wc,210944
+najaeda/naja_bne.dll,sha256=eijuKTpU_tLgQF6ZDsc2-zCsuc2yO9iv1R9SfDocPVs,115200
+najaeda/naja_dnl.dll,sha256=CjvDZZOb9VHcbjf99-lZLyMQxQPHNyvDxY4X_b8VCC4,128000
+najaeda/naja_metrics.dll,sha256=fw3zXBI7c8-_zHKGmYa8yuLxS_3FSWi1hDmSCRrqk6U,198656
+najaeda/naja_nl.dll,sha256=RB6FsB60tSPRkrLUrlqng9g8LM88ZOL9Xr5RhXIh8UA,970752
+najaeda/naja_opt.dll,sha256=6wk2beYaAxX3sNQ9u6RzwBAjBFmFEspbgxsrvBH-yIs,238080
+najaeda/naja_python.dll,sha256=mFdpJQ9GoHtMjx2ij8erOVRXob7VJ70BMSUXGacjqas,976384
+najaeda/netlist.py,sha256=RMdEgQH3n9fXID7No5MAGRK4RATjJtRi3dF9Sg-ZIPk,69191
+najaeda/net_visitor.py,sha256=XrGiT1JKIF8MYc2R-SgUVqxQqIBQgtcfIyYU2yURz6M,1993
+najaeda/pandas_stats.py,sha256=vA3o45sDJ4xNq37fCjofH03aCPjxjuaE2XmT-vbYaAA,1102
+najaeda/stats.py,sha256=pzPNyxxa8H2pwjj9ACN3F7r6OT7OMokNWYAvSCa965E,16517
+najaeda/_version.py,sha256=DzMRseGe_crufJHgXzWOEYnrxnrQJFpBxtvlf17Ey0A,348
+najaeda/__init__.py,sha256=tt9IOQGlxFk3SznR2IKoghuQC9DYxZeWHz2uhFnhaFQ,550
+najaeda/docs/.readthedocs.yaml,sha256=HNNsm-hz7lPVHfsKyEPbMWUHwRVxz9BQp0wIvNVGXQc,815
+najaeda/docs/requirements.txt,sha256=whi2b4ITj5RHuTa9o-63dBlNZS97dflaMwqWdMgEtDs,128
+najaeda/docs/source/api.rst,sha256=XrEya-N-4puXDjhlBcduvVH6Kc4jZWmXxRotv2U0v18,157
+najaeda/docs/source/common_classes.rst,sha256=GYpUAoF9p85dFUaaKhADNA5un2SqsAlsisrzhy-DDCc,191
+najaeda/docs/source/conf.py,sha256=Od3yuAs4UOmwew4ZD9ot7fDt5kkGG64H8vcQruaTzXM,2077
+najaeda/docs/source/equipotential.rst,sha256=9DsSzfqWGC4NPqHoiitMXS6d1cNG2eAPeOkhof6A2NM,349
+najaeda/docs/source/examples.rst.in,sha256=oPIRgGLmDRHbIiShWeM1P_aI5xj18DeLatP1IrdHrho,2156
+najaeda/docs/source/index.rst,sha256=GXd3weCxyOblxj4TCXr43WbH2cRutE7MI0Q4T9Tgbj4,403
+najaeda/docs/source/instance.rst,sha256=11GnhzjTc9ihDrZFXyqV9EbDsP3CM8VO02bCg8xiomo,1043
+najaeda/docs/source/introduction.rst,sha256=fM47hKcMFoNfZoa6i6rfO9hdduSgKjSwCGBCjc1Y9hs,2723
+najaeda/docs/source/net.rst,sha256=mTdZpKhEMAkaZBZXN2rDWJvyiZmlWBJbjlwdwmAEwCk,751
+najaeda/docs/source/netlist_classes.rst,sha256=SsbBoE4z-MxWwJgU5T_iOKK_GKJ29jyYWSd7yhF0F14,142
+najaeda/docs/source/preprocessor.py,sha256=JG_sHgCINp4IJzewz75_fckDMbESTcHrcLWOaL6UM0I,2697
+najaeda/docs/source/term.rst,sha256=y48_Fdert0YCC5Kjoe98t2fczH-w20JfIL9iHzT_MAM,709
+najaeda/docs/source/visitors.rst,sha256=FWcXKVNNjMGjFJR8QHnv1duVpmib2gnXC9HNPM1G6wk,239
+najaeda/native/stats.py,sha256=sTEx4u2QYIrcgZllL2SjQvPXGVhqQERsshOvHWwwLng,13404
+najaeda/native/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/primitives/utils.py,sha256=oC4zRs-RVwghZxNccJCaNFWKvyb46z53AikKWdcSe0U,680
+najaeda/primitives/xilinx.py,sha256=NriL16J52-sSvL8zAqUK4oVYDQ7nadN7JvRVTz10_Pc,31473
+najaeda/primitives/yosys.py,sha256=vDo9e5nPBUKP3B0kUqVKbp4_m-WgdPWFspv4YgaLUYU,13840
+najaeda/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda-0.3.3.dist-info/DELVEWHEEL,sha256=BI9ImydNgL0KSuyh-QfNNFRJYe08mbtRn9IE3f3XrVk,502
+najaeda-0.3.3.dist-info/METADATA,sha256=1jmkb34z4w5HBU-FKEjNgLbf-M9pLT93J8Te2aDKzP0,3759
+najaeda-0.3.3.dist-info/RECORD,,
+najaeda-0.3.3.dist-info/WHEEL,sha256=gWMs92Yhbl9pSGNRFWCXG1mfeuNl7HhxcJG5aLu4nQc,106
+najaeda-0.3.3.dist-info/licenses/AUTHORS,sha256=CCabv7V3a2ngY1f3faiauRBtE9Dp0ba_kGg4-v-E0mw,384
+najaeda-0.3.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+najaeda.libs/msvcp140.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056
+najaeda.libs/tbb12.dll,sha256=iYd4NxYqMA8TnJF__A0o_0kguotJbkbidsBB7yH70iA,347136
+najaeda.libs/tbbmalloc.dll,sha256=7eYciyWpgXZGYhylXyyMkzVCkRsy5OwqAlrlIAnqlaY,113664

najaeda-0.3.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64
+

najaeda-0.3.3.dist-info/licenses/AUTHORS

@@ -0,0 +1,7 @@
+# This is the list of Naja authors for copyright purposes.
+#
+# 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.alexandre@keplertech.io>
+Noam Cohen <noam.cohen@keplertech.io>