Lava top-level API

src/lava/__init__.py

@@ -0,0 +1,56 @@
+# Copyright (C) 2023 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+# Creates a pkgutil-style namespace package that extends the namespace over
+# multiple directory structures.
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+
+######
+# IMPORTS
+
+# Import the most common classes and functions to the top level to enable
+# >>> import lava
+# as the only required import for the most common Lava programs.
+
+# MOST COMMON PROCESSES
+from lava.proc.conv.process import Conv
+from lava.proc.dense.process import Dense, DelayDense, LearningDense
+from lava.proc.io.dataloader import SpikeDataloader, StateDataloader
+from lava.proc.io.source import RingBuffer as SourceRingBuffer
+from lava.proc.io.sink import RingBuffer as SinkRingBuffer
+from lava.proc.io.encoder import DeltaEncoder
+from lava.proc.io.injector import Injector
+from lava.proc.io.extractor import Extractor
+from lava.proc.io.reset import Reset
+from lava.proc.learning_rules.r_stdp_learning_rule import RewardModulatedSTDP
+from lava.proc.learning_rules.stdp_learning_rule import STDPLoihi
+from lava.proc.lif.process import LIF, LearningLIF, LIFRefractory
+from lava.proc.monitor.process import Monitor
+from lava.proc.receiver.process import Receiver
+from lava.proc.rf.process import RF
+from lava.proc.rf_iz.process import RF_IZ
+from lava.proc.sdn.process import Sigma, Delta, SigmaDelta, ActivationMode
+from lava.proc.sparse.process import Sparse, LearningSparse, DelaySparse
+
+# RUN CONFIGURATIONS & CONDITIONS
+from lava.magma.core.run_configs import Loihi2SimCfg, Loihi2HwCfg
+from lava.magma.core.run_conditions import RunContinuous, RunSteps
+
+# MAGMA
+from lava.magma.core.process.process import LogConfig
+
+# UTILS
+from lava.utils import loihi
+from lava.utils import plots
+from lava.utils.serialization import save, load
+
+__all__ = ['Conv', 'Dense', 'DelayDense', 'LearningDense', 'SpikeDataloader',
+           'StateDataloader', 'SourceRingBuffer', 'SinkRingBuffer',
+           'DeltaEncoder', 'Injector', 'Extractor', 'Reset',
+           'RewardModulatedSTDP', 'STDPLoihi', 'LIF', 'LearningLIF',
+           'LIFRefractory', 'Monitor', 'Receiver', 'RF', 'RF_IZ',
+           'Sigma', 'Delta', 'SigmaDelta', 'ActivationMode', 'Sparse',
+           'LearningSparse', 'DelaySparse', 'Loihi2HwCfg', 'Loihi2SimCfg',
+           'RunContinuous', 'RunSteps', 'LogConfig', 'loihi', 'plots',
+           'save', 'load']

src/lava/proc/io/__init__.py

@@ -2,6 +2,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # See: https://spdx.org/licenses/
 
-from . import reset, source, sink, dataloader, encoder
+from lava.proc.io import reset, source, sink, dataloader, encoder
 
 __all__ = ['reset', 'source', 'sink', 'dataloader', 'encoder']

tests/lava/test_init_imports.py

@@ -0,0 +1,17 @@
+# Copyright (C) 2023 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import unittest
+import importlib.util
+
+
+class TestInitImports(unittest.TestCase):
+
+    def test_lava_init_file_imports_lif_class(self) -> None:
+        module_spec = importlib.util.find_spec("lava")
+        lava_module = importlib.util.module_from_spec(module_spec)
+        module_spec.loader.exec_module(lava_module)
+
+        lif_importable = hasattr(lava_module, "LIF")
+        self.assertTrue(lif_importable)

tests/lava/tutorials/test_tutorials.py

@@ -1,7 +1,8 @@
 # Copyright (C) 2022 Intel Corporation
 # SPDX-License-Identifier: BSD-3-Clause
-# See: https://spdx.org/licenses/
+# See: https://
 
+import importlib.util
 import glob
 import os
 import platform
@@ -12,11 +13,8 @@
 import unittest
 from test import support
 
-import lava
 import nbformat
 
-import tutorials
-
 
 class TestTutorials(unittest.TestCase):
     """Export notebook, execute to check for errors."""
@@ -75,15 +73,10 @@ def _update_pythonpath(
         os.chdir(base_dir + "/" + dir_name)
 
         env = os.environ.copy()
-        module_path = [lava.__path__.__dict__["_path"][0]]
-
-        module_path.extend(
-            [os.path.dirname(module_path[0]), env.get("PYTHONPATH", "")]
-        )
 
         sys_path = ":".join(map(str, sys.path))
         env_path = env.get("PYTHONPATH", "")
-        mod_path = ":".join(map(str, module_path))
+        mod_path = ":".join(map(str, [get_module_path("lava"), env_path]))
 
         env["PYTHONPATH"] = env_path + ":" + mod_path + ":" + sys_path
 
@@ -157,15 +150,14 @@ def _run_notebook(self, notebook: str, e2e_tutorial: bool = False):
             end to end tutorial, by default False
         """
         cwd = os.getcwd()
-        tutorials_temp_directory = tutorials.__path__.__dict__["_path"][0]
-        tutorials_directory = ""
+        tutorials_module_path = get_module_path("tutorials")
 
         if not e2e_tutorial:
-            tutorials_temp_directory = tutorials_temp_directory + "/in_depth"
+            tutorials_module_path = tutorials_module_path + "/in_depth"
         else:
-            tutorials_temp_directory = tutorials_temp_directory + "/end_to_end"
+            tutorials_module_path = tutorials_module_path + "/end_to_end"
 
-        tutorials_directory = os.path.realpath(tutorials_temp_directory)
+        tutorials_directory = os.path.realpath(tutorials_module_path)
         os.chdir(tutorials_directory)
 
         errors_record = {}
@@ -178,7 +170,7 @@ def _run_notebook(self, notebook: str, e2e_tutorial: bool = False):
 
             self.assertTrue(
                 len(discovered_notebooks) != 0,
-                "Notebook not found. Input to function {}".format(notebook),
+                f"Notebook not found. Input to function {notebook}",
             )
 
             # If the notebook is found execute it and store any errors
@@ -194,10 +186,8 @@ def _run_notebook(self, notebook: str, e2e_tutorial: bool = False):
 
             self.assertFalse(
                 errors_record,
-                "Failed to execute Jupyter Notebooks \
-                                 with errors: \n {}".format(
-                    errors_record
-                ),
+                f"Failed to execute Jupyter Notebooks "
+                f"with errors: \n {errors_record}",
             )
         finally:
             os.chdir(cwd)
@@ -292,5 +282,15 @@ def test_in_depth_clp_01(self):
             "clp/tutorial01_one-shot_learning_with_novelty_detection.ipynb")
 
 
+def get_module_path(module_name: str) -> str:
+    spec = importlib.util.find_spec(module_name)
+
+    # Treat packages with init-files separately.
+    if spec.origin is None:
+        return spec.submodule_search_locations[0]
+
+    return os.path.dirname(spec.origin)
+
+
 if __name__ == "__main__":
     support.run_unittest(TestTutorials)