peakrdl-python 0.8.1__tar.gz → 0.9.0rc1__tar.gz

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/.github/workflows/action.yaml

@@ -153,9 +153,12 @@ jobs:
 
           peakrdl python tests/testcases/basic.rdl -o peakrdl_out/raw/
           peakrdl python tests/testcases/simple.xml tests/testcases/multifile.rdl -o peakrdl_out/raw
+          peakrdl python tests/testcases/extended_memories.rdl -o peakrdl_out/raw/
           python -m unittest discover -s peakrdl_out/raw
           peakrdl python tests/testcases/basic.rdl -o peakrdl_out/raw_async/ --async
           python -m unittest discover -s peakrdl_out/raw_async
+          peakrdl python tests/testcases/basic.rdl -o peakrdl_out/raw_legacy/ --legacy_block_access
+          python -m unittest discover -s peakrdl_out/raw_legacy
 
           peakrdl python tests/testcases/basic.rdl -o peakrdl_out/no_test/ --skip_test_case_generation
 
@@ -248,17 +251,58 @@ jobs:
 
         python -m unittest discover -s testcase_output
 
-    - name: Test Autoformating
+  autoformating:
+    needs:
+      - integration_tests
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # reduced matrix because the autoformatter was having issues with python 3.8 so we will
+        # limit this to modern versions of python only
+        python-version: [3.8, 3.9, "3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
       run: |
+        python -m pip install --upgrade pip
+        python -m pip install .
+        python -m pip install mypy
+        # one of the test cases uses IPxact so we need the importer
+        python -m pip install peakrdl-ipxact
+        # black is the autoformatter used for this this testing
         python -m pip install black
-        cp testcase_output autoformatted_testcase_output -r
-        black autoformatted_testcase_output --line-length 120
-        python -m unittest discover -s autoformatted_testcase_output
+
+        # retrieve the example code from the systemRDL compiler
+        wget -L https://raw.githubusercontent.com/SystemRDL/systemrdl-compiler/main/examples/accelera-generic_example.rdl -O tests/testcases/accelera-generic_example.rdl
+
+    - name: Generate testcases
+      run: |
+        # black will ignore files in the .gitingore by default, so we need to ensure that the
+        # content is generated with a different name
+        python generate_testcases.py --output autoformatted_output --test_case accelera-generic_example.rdl
+        # no need to check them as they are tested in the previous test
+
+    - name: Test Autoformating
+      run: |
+        # run the autoformatting
+        black autoformatted_output --line-length 120
+        # check the files are correct with mypy and unittesting
+        mypy autoformatted_output --config-file=tests/.mypy.ini
+        python -m unittest discover -s autoformatted_output
 
   #-------------------------------------------------------------------------------
   build:
     needs:
       - integration_tests
+      - autoformating
       - dev_runner
       - peakrdl_integration
     name: Build source distribution

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: peakrdl-python
-Version: 0.8.1
+Version: 0.9.0rc1
 Summary: Generate Python Register Access Layer (RAL) from SystemRDL
 Author: Keith Brady
 License:                     GNU GENERAL PUBLIC LICENSE

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/docs/design_decisions.rst

@@ -20,4 +20,12 @@ Integer Data Types
 ===================
 
 All the APIs present memory, register and field entries as python integers. This abstracts, the
-complexity of byte ordering and reversed registers.
+complexity of byte ordering and reversed registers.
+
+Blocks of Data
+==============
+
+.. versionchanged:: 0.9.0
+
+    blocks of data (for example memories were accessed as python array.array previously. This
+    did not support width of larger than 128 bits therefore this was changed to list.

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/docs/generated_package.rst

@@ -104,6 +104,25 @@ The callbacks are passed into the register access layer using either:
 * ``AsyncCallbackSet`` for async python function callbacks, these are called from the library using
   ``await``
 
+Legacy Callback
+---------------
+
+.. versionchanged:: 0.9.0
+
+   Previous versions of peakrdl python used the python ``array.array`` for efficently moving blocks
+   of data. This was changed in version 0.9.0 in order to accommodate memories which were larger
+   than 64 bit wide which could not be supported as the array type only support enties of up to
+   64 bit.
+
+   In order to minimise the issues with older code the following types remain but require the
+   package to be built with the ``legacy_block_access`` option turned on
+
+   The callbacks are passed into the register access layer using either:
+
+   * ``NormalCallbackSetLegacy`` for standard python function callbacks
+   * ``AsyncCallbackSetLegacy`` for async python function callbacks, these are called from the library using
+     ``await``
+
 Using the Register Access Layer
 ===============================
 

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/example/optimised_access/demo_optimised_array_access.py

@@ -1,8 +1,6 @@
 """
 PeakRDL Python example to show the different methods to access the a register array
 """
-from array import array as Array
-
 from optimised_array_access.reg_model.optimised_array_access import optimised_array_access_cls
 from optimised_array_access.sim.optimised_array_access import optimised_array_access_simulator_cls
 

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/generate_and_test.py

@@ -35,11 +35,11 @@ from unittest import TestLoader
 from unittest import TestSuite
 from unittest import TextTestRunner
 
-#from coverage import Coverage
+from coverage import Coverage
 
 from systemrdl import RDLCompiler
 
-#from peakrdl_ipxact import IPXACTImporter
+from peakrdl_ipxact import IPXACTImporter
 
 sys.path.append('src')
 from peakrdl_python import PythonExporter
@@ -79,6 +79,11 @@ CommandLineParser.add_argument('--copy_libraries', action='store_true', dest='co
                                     'and debugging as multiple copies of the libraries can cause'
                                     'confusion. Therefore by default this script does not copy '
                                     'them over.')
+CommandLineParser.add_argument('--legacy_block_access', action='store_true',
+                               dest='legacy_block_access',
+                               help='peakrdl python has two methods to hold blocks of data, the '
+                                    'legacy mode based on Array or the new mode using lists')
+
 
 def build_logging_cong(logfilepath:str):
     return {
@@ -127,6 +132,7 @@ def build_logging_cong(logfilepath:str):
         }
     }
 
+
 if __name__ == '__main__':
 
     CommandLineArgs = CommandLineParser.parse_args()
@@ -161,7 +167,8 @@ if __name__ == '__main__':
     exporter.export(node=spec, path=str(CommandLineArgs.output_path / 'generate_and_test_output'),
                     asyncoutput=CommandLineArgs.asyncoutput,
                     delete_existing_package_content=not CommandLineArgs.suppress_cleanup,
-                    skip_library_copy=not CommandLineArgs.copy_libraries)
+                    skip_library_copy=not CommandLineArgs.copy_libraries,
+                    legacy_block_access=CommandLineArgs.legacy_block_access)
     print(f'generation time {time.time() - start_time}s')
 
     if not CommandLineArgs.export_only:
@@ -190,9 +197,15 @@ if __name__ == '__main__':
                                                 globals(), locals(), ['CallbackSet'], 0)
 
         if CommandLineArgs.asyncoutput is True:
-            callbackset_cls = getattr(peakrdl_python_package, 'AsyncCallbackSet')
+            if CommandLineArgs.legacy_block_access is True:
+                callbackset_cls = getattr(peakrdl_python_package, 'AsyncCallbackSetLegacy')
+            else:
+                callbackset_cls = getattr(peakrdl_python_package, 'AsyncCallbackSet')
         else:
-            callbackset_cls = getattr(peakrdl_python_package, 'NormalCallbackSet')
+            if CommandLineArgs.legacy_block_access is True:
+                callbackset_cls = getattr(peakrdl_python_package, 'NormalCallbackSetLegacy')
+            else:
+                callbackset_cls = getattr(peakrdl_python_package, 'NormalCallbackSet')
 
         sim_cls = getattr(sim_module, sim_class_name)
         sim = sim_cls(address=0)
@@ -210,6 +223,4 @@ if __name__ == '__main__':
             cov.stop()
             cov.html_report(directory=str(CommandLineArgs.coverage_report_path / CommandLineArgs.root_node))
 
-        sim.memory_for_address(64)
-
 

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/generate_testcases.py

@@ -25,6 +25,8 @@ import os
 
 from glob import glob
 from typing import Optional, List
+import argparse
+import pathlib
 
 from systemrdl import RDLCompiler # type: ignore
 from systemrdl.node import Node, AddrmapNode # type: ignore
@@ -33,6 +35,13 @@ from src.peakrdl_python import PythonExporter # type: ignore
 
 test_case_path = os.path.join('tests', 'testcases')
 
+CommandLineParser = argparse.ArgumentParser(description='Test the framework')
+CommandLineParser.add_argument('--output', dest='output_path',
+                               type=pathlib.Path,
+                               default='testcase_output')
+CommandLineParser.add_argument('--test_case', dest='test_case',
+                               type=str)
+
 
 def compile_rdl(infile: str,
                 incl_search_paths: Optional[List[str]] = None,
@@ -67,7 +76,8 @@ def compile_rdl(infile: str,
 
 def generate(root: Node, outdir: str,
              asyncoutput: bool = False,
-             skip_test_case_generation: bool = False) -> List[str]:
+             skip_test_case_generation: bool = False,
+             legacy_block_access: bool = True) -> List[str]:
     """
     Generate a PeakRDL output package from compiled systemRDL
 
@@ -76,8 +86,8 @@ def generate(root: Node, outdir: str,
         outdir: directory to store the result in
         autoformatoutputs: If set to True the code will be run through autopep8 to
                 clean it up. This can slow down large jobs or mask problems
-        asyncoutput: If set to True the code build a register model with async operations to
-                access the harware layer
+        legacy_block_access: If set to True the code build a register model the legacy array block
+                             access as opposed to the newer list based
 
     Returns:
         List of strings with the module names generated
@@ -86,19 +96,24 @@ def generate(root: Node, outdir: str,
     print(f'Info: Generating python for {root.inst_name} in {outdir}')
     modules = PythonExporter().export(root, outdir, # type: ignore[no-untyped-call]
                                       asyncoutput=asyncoutput,
-                                      skip_test_case_generation=skip_test_case_generation)
+                                      skip_test_case_generation=skip_test_case_generation,
+                                      legacy_block_access=legacy_block_access)
 
     return modules
 
 
 if __name__ == '__main__':
-    if len(sys.argv) == 1:
-        testcases = glob(os.path.join(test_case_path,'*.rdl'))
-    else:
-        testcases = glob(os.path.join(test_case_path,'{}.rdl').format(sys.argv[1]))
+
+    CommandLineArgs = CommandLineParser.parse_args()
+
+    output_path = CommandLineArgs.output_path
 
     #-------------------------------------------------------------------------------
     results = {}
+    if CommandLineArgs.test_case:
+        testcases = [os.path.join(test_case_path, CommandLineArgs.test_case)]
+    else:
+        testcases = glob(os.path.join(test_case_path, '*.rdl'))
     for case in testcases:
         print("Case: ", case)
         rdl_file = case
@@ -115,12 +130,24 @@ if __name__ == '__main__':
         else:
             root = compile_rdl(rdl_file)
 
-        for asyncoutput, folder_name in [(False, 'raw'),
-                                         (True, 'raw_async')]:
-            _ = generate(root, os.path.join('testcase_output', folder_name),
-                            asyncoutput=asyncoutput)
+        for build_options, folder_name in \
+                [({'asyncoutput': True, 'legacy':False}, 'raw_async'),
+                 ({'asyncoutput': False, 'legacy':False}, 'raw'),
+                 ({'asyncoutput': True, 'legacy': True}, 'raw_async_legacy'),
+                 ({'asyncoutput': False, 'legacy': True}, 'raw_legacy')
+                 ]:
+
+            # test cases that use the extended widths an not be tested in the non-legacy modes
+            if (testcase_name in ['extended_memories', 'extended_sizes_registers_array']) and \
+                    (build_options['legacy'] is True):
+                continue
+
+            _ = generate(root, str(output_path / folder_name),
+                         asyncoutput=build_options['asyncoutput'],
+                         legacy_block_access=build_options['legacy']
+                         )
 
-            module_fqfn = os.path.join('testcase_output', folder_name, '__init__.py')
+            module_fqfn = output_path / folder_name / '__init__.py'
             with open(module_fqfn, 'w', encoding='utf-8') as fid:
                 fid.write('pass\n')
 

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/src/peakrdl_python/__about__.py

@@ -17,4 +17,4 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Variables that describes the peakrdl-python Package
 """
-__version__ = "0.8.1"
+__version__ = "0.9.0.rc1"

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/src/peakrdl_python/__peakrdl__.py

@@ -68,6 +68,10 @@ class Exporter(ExporterSubcommandPlugin):
                                     'However, if additional python files are added by the user '
                                     '(not recommended) this cleanup will need to be suppressed '
                                     'and managed by the user')
+        arg_group.add_argument('--legacy_block_access', action='store_true',
+                               dest='legacy_block_access',
+                               help='peakrdl python has two methods to hold blocks of data, the '
+                                    'legacy mode based on array.array or the new mode using lists')
 
     def do_export(self, top_node: 'AddrmapNode', options: 'argparse.Namespace') -> None:
         """
@@ -89,5 +93,6 @@ class Exporter(ExporterSubcommandPlugin):
             options.output,
             options.is_async,
             skip_test_case_generation=options.skip_test_case_generation,
-            delete_existing_package_content=not options.suppress_cleanup
+            delete_existing_package_content=not options.suppress_cleanup,
+            legacy_block_access=options.legacy_block_access
         )

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/src/peakrdl_python/exporter.py

@@ -18,11 +18,9 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 Main Classes for the peakrdl-python
 """
 import os
-import warnings
 from pathlib import Path
 from shutil import copy
 from typing import List, NoReturn, Iterable, Tuple, Dict, Any
-import sys
 
 import jinja2 as jj
 from systemrdl import RDLWalker # type: ignore
@@ -291,7 +289,8 @@ class PythonExporter:
                            top_block: AddrmapNode,
                            package: _Package,
                            skip_lib_copy: bool,
-                           asyncoutput: bool) -> None:
+                           asyncoutput: bool,
+                           legacy_block_access: bool) -> None:
 
         context = {
             'print': print,
@@ -324,15 +323,17 @@ class PythonExporter:
             'get_reg_writable_fields': get_reg_writable_fields,
             'get_reg_readable_fields': get_reg_readable_fields,
             'get_memory_max_entry_value_hex_string': get_memory_max_entry_value_hex_string,
-            'get_array_typecode': get_array_typecode,
             'get_memory_width_bytes': get_memory_width_bytes,
             'get_field_default_value': get_field_default_value,
             'raise_template_error' : self._raise_template_error,
             'get_python_path_segments' : get_python_path_segments,
             'safe_node_name' : safe_node_name,
             'skip_lib_copy': skip_lib_copy,
-            'version' : __version__
+            'version' : __version__,
+            'legacy_block_access' : legacy_block_access,
         }
+        if legacy_block_access is True:
+            context['get_array_typecode'] = get_array_typecode
 
         context.update(self.user_template_context)
 
@@ -345,7 +346,8 @@ class PythonExporter:
                            top_block: AddrmapNode,
                            package: _Package,
                            skip_lib_copy: bool,
-                           asyncoutput: bool) -> None:
+                           asyncoutput: bool,
+                           legacy_block_access: bool) -> None:
 
         context = {
             'top_node': top_block,
@@ -354,8 +356,8 @@ class PythonExporter:
             'isinstance': isinstance,
             'asyncoutput': asyncoutput,
             'skip_lib_copy': skip_lib_copy,
-            'version': __version__
-
+            'version': __version__,
+            'legacy_block_access' : legacy_block_access,
             }
 
         context.update(self.user_template_context)
@@ -369,7 +371,8 @@ class PythonExporter:
                          top_block: AddrmapNode,
                          package: _Package,
                          skip_lib_copy: bool,
-                         asyncoutput: bool) -> None:
+                         asyncoutput: bool,
+                         legacy_block_access: bool) -> None:
 
         context = {
             'top_node': top_block,
@@ -378,7 +381,8 @@ class PythonExporter:
             'isinstance': isinstance,
             'asyncoutput': asyncoutput,
             'skip_lib_copy': skip_lib_copy,
-            'version': __version__
+            'version': __version__,
+            'legacy_block_access' : legacy_block_access,
             }
 
         context.update(self.user_template_context)
@@ -392,7 +396,8 @@ class PythonExporter:
                             top_block: AddrmapNode,
                             package: _Package,
                             skip_lib_copy: bool,
-                            asyncoutput: bool) -> None:
+                            asyncoutput: bool,
+                            legacy_block_access: bool) -> None:
         """
 
         Args:
@@ -408,7 +413,8 @@ class PythonExporter:
             'top_node': top_block,
             'asyncoutput': asyncoutput,
             'skip_lib_copy': skip_lib_copy,
-            'version': __version__
+            'version': __version__,
+            'legacy_block_access' : legacy_block_access,
         }
 
         context.update(self.user_template_context)
@@ -427,17 +433,20 @@ class PythonExporter:
                        top_block: AddrmapNode,
                        package: _Package,
                        skip_lib_copy: bool,
-                       asyncoutput: bool) -> None:
+                       asyncoutput: bool,
+                       legacy_block_access: bool) -> None:
         """
 
         Args:
             top_block:
             package:
             asyncoutput:
+            legacy_block_access:
 
         Returns:
 
         """
+        #pylint: disable=too-many-locals
 
         blocks = AddressMaps()
         # running the walker populated the blocks with all the address maps in within the
@@ -463,7 +472,7 @@ class PythonExporter:
             def is_reg_array(item: RegNode) -> bool:
                 return item.is_array
 
-            rolled_owned_reg_array = filter(is_reg_array, rolled_owned_reg)
+            rolled_owned_reg_array = list(filter(is_reg_array, rolled_owned_reg))
 
             fq_block_name = '_'.join(block.get_path_segments(array_suffix='_{index:d}_'))
 
@@ -492,14 +501,16 @@ class PythonExporter:
                 'get_reg_readable_fields': get_reg_readable_fields,
                 'get_memory_max_entry_value_hex_string': get_memory_max_entry_value_hex_string,
                 'get_enum_values': get_enum_values,
-                'get_array_typecode': get_array_typecode,
                 'get_memory_width_bytes': get_memory_width_bytes,
                 'asyncoutput': asyncoutput,
                 'uses_enum': uses_enum(block),
                 'skip_lib_copy': skip_lib_copy,
-                'version': __version__
+                'version': __version__,
+                'get_array_typecode' : get_array_typecode,
+                'legacy_block_access': legacy_block_access,
             }
 
+
             self.__stream_jinja_template(template_name="addrmap_tb.py.jinja",
                                          target_package=package.tests,
                                          target_name='test_' + fq_block_name + '.py',
@@ -514,7 +525,8 @@ class PythonExporter:
                asyncoutput: bool = False,
                skip_test_case_generation: bool = False,
                delete_existing_package_content: bool = True,
-               skip_library_copy: bool = False) -> List[str]:
+               skip_library_copy: bool = False,
+               legacy_block_access: bool = True) -> List[str]:
         """
         Generated Python Code and Testbench
 
@@ -531,13 +543,16 @@ class PythonExporter:
                                       useful to turn off when developing peakrdl python to avoid
                                       editing the wrong copy of the library. However, it is not
                                       recommended in end user cases
+            legacy_block_access (bool): version 0.8 changed the block access methods from using
+                                        arrays to to lists. This allows memory widths of other
+                                        than 8, 16, 32, 64 to be supported which are legal in
+                                        systemRDL. The legacy mode with Arrays is still in
+                                        the tool and will be turned on by default for a few
+                                        releases.
 
         Returns:
             List[str] : modules that have been exported:
         """
-        if sys.version_info < (3, 8):
-            warnings.warn('Support for Python 3.7 will be withdrawn in the next major release',
-                          category=DeprecationWarning)
 
         # If it is the root node, skip to top addrmap
         if isinstance(node, RootNode):
@@ -556,22 +571,27 @@ class PythonExporter:
         self._build_node_type_table(top_block)
 
         self.__export_reg_model(top_block=top_block, package=package, asyncoutput=asyncoutput,
-                                skip_lib_copy=skip_library_copy)
+                                skip_lib_copy=skip_library_copy,
+                                legacy_block_access=legacy_block_access)
 
         self.__export_simulator(top_block=top_block, package=package, asyncoutput=asyncoutput,
-                                skip_lib_copy=skip_library_copy)
+                                skip_lib_copy=skip_library_copy,
+                                legacy_block_access=legacy_block_access)
 
         self.__export_example(top_block=top_block, package=package, asyncoutput=asyncoutput,
-                                skip_lib_copy=skip_library_copy)
+                                skip_lib_copy=skip_library_copy,
+                                legacy_block_access=legacy_block_access)
 
         if not skip_test_case_generation:
 
             # export the baseclasses for the tests
             self.__export_base_tests(top_block=top_block, package=package, asyncoutput=asyncoutput,
-                                skip_lib_copy=skip_library_copy)
+                                skip_lib_copy=skip_library_copy,
+                                legacy_block_access=legacy_block_access)
             # export the tests themselves, these are broken down to one file per addressmap
             self.__export_tests(top_block=top_block, package=package, asyncoutput=asyncoutput,
-                                skip_lib_copy=skip_library_copy)
+                                skip_lib_copy=skip_library_copy,
+                                legacy_block_access=legacy_block_access)
 
         return top_block.inst_name
 

{peakrdl_python-0.8.1 → peakrdl_python-0.9.0rc1}/src/peakrdl_python/lib/__init__.py

@@ -23,8 +23,8 @@ from .callbacks import ReadCallback
 from .callbacks import ReadBlockCallback
 from .callbacks import WriteCallback
 from .callbacks import WriteBlockCallback
-from .callbacks import NormalCallbackSet
-from .callbacks import AsyncCallbackSet
+from .callbacks import NormalCallbackSet, NormalCallbackSetLegacy
+from .callbacks import AsyncCallbackSet, AsyncCallbackSetLegacy
 from .callbacks import CallbackSet
 
 from .base import AddressMap
@@ -84,26 +84,27 @@ from .fields import FieldEnumAsyncReadOnly
 from .fields import FieldEnumAsyncWriteOnly
 from .fields import FieldEnumAsyncReadWrite
 
-from .memory import MemoryReadOnly
-from .memory import MemoryWriteOnly
-from .memory import MemoryReadWrite
+from .memory import MemoryReadOnly, MemoryReadOnlyLegacy
+from .memory import MemoryWriteOnly, MemoryWriteOnlyLegacy
+from .memory import MemoryReadWrite, MemoryReadWriteLegacy
 from .memory import MemoryReadOnlyArray
 from .memory import MemoryWriteOnlyArray
 from .memory import MemoryReadWriteArray
-from .memory import MemoryAsyncReadOnly
-from .memory import MemoryAsyncWriteOnly
-from .memory import MemoryAsyncReadWrite
-from .memory import MemoryAsyncReadOnlyArray
-from .memory import MemoryAsyncWriteOnlyArray
-from .memory import MemoryAsyncReadWriteArray
-from .memory import ReadableMemory
-from .memory import WritableMemory
+from .async_memory import MemoryAsyncReadOnly, MemoryAsyncReadOnlyLegacy
+from .async_memory import MemoryAsyncWriteOnly, MemoryAsyncWriteOnlyLegacy
+from .async_memory import MemoryAsyncReadWrite, MemoryAsyncReadWriteLegacy
+from .async_memory import MemoryAsyncReadOnlyArray
+from .async_memory import MemoryAsyncWriteOnlyArray
+from .async_memory import MemoryAsyncReadWriteArray
+from .memory import ReadableMemory, ReadableMemoryLegacy
+from .memory import WritableMemory, WritableMemoryLegacy
 from .memory import Memory
-from .memory import ReadableAsyncMemory
-from .memory import WritableAsyncMemory
-from .memory import AsyncMemory
+from .async_memory import ReadableAsyncMemory, ReadableAsyncMemoryLegacy
+from .async_memory import WritableAsyncMemory, WritableAsyncMemoryLegacy
+from .async_memory import AsyncMemory
 from .memory import MemoryArray
-from .memory import AsyncMemoryArray
+from .async_memory import AsyncMemoryArray
 
 from .utility_functions import get_array_typecode
+from .utility_functions import UnsupportedWidthError
 from .base import Node