Merge pull request #90 from krcb197/fix_async_callback_naming

Fix async callback naming

Author: krcb197

.gitignore

@@ -54,3 +54,6 @@ __pycache__/
 
 # Vim swapfiles
 .*.sw[a-p]
+/example/overridden_names/over_ridden_names/
+/example/simulating_callbacks/mychip/
+/example/tranversing_address_map/chip_with_registers/

docs/generated_package.rst

@@ -207,7 +207,7 @@ Callback Set
 The callbacks are passed into the register abstraction layer using either:
 
 * ``NormalCallbackSet`` for standard python function callbacks
-* ``AysncCallbackSet`` for async python function callbacks, these are called from the library using
+* ``AsyncCallbackSet`` for async python function callbacks, these are called from the library using
   ``await``
 
 Using the Register Abstraction Layer

src/peakrdl_python/__about__.py

@@ -1,4 +1,4 @@
 """
 Variables that describes the PeakRDL Python Package
 """
-__version__ = "0.4.0"
+__version__ = "0.4.1"

src/peakrdl_python/lib/__init__.py

@@ -8,7 +8,7 @@
 from .callbacks import WriteCallback
 from .callbacks import WriteBlockCallback
 from .callbacks import NormalCallbackSet
-from .callbacks import AysncCallbackSet
+from .callbacks import AsyncCallbackSet
 from .callbacks import CallbackSet
 
 from .base import AddressMap

src/peakrdl_python/lib/callbacks.py

@@ -157,7 +157,7 @@ def write_block_callback(self) -> Optional[WriteBlockCallback]:
         """
         return self.__write_block_callback
 
-class AysncCallbackSet:
+class AsyncCallbackSet:
     """
     Class to hold a set of callbacks, this reduces the number of callback that need to be passed
     around
@@ -217,4 +217,4 @@ def write_block_callback(self) -> Optional[AsyncWriteBlockCallback]:
         """
         return self.__write_block_callback
 
-CallbackSet = Union[AysncCallbackSet, NormalCallbackSet]
+CallbackSet = Union[AsyncCallbackSet, NormalCallbackSet]

src/peakrdl_python/lib/memory.py

@@ -8,7 +8,7 @@
 
 from .base import Node, AddressMap, BaseArray, get_array_typecode
 
-from .callbacks import CallbackSet, NormalCallbackSet, AysncCallbackSet
+from .callbacks import CallbackSet, NormalCallbackSet, AsyncCallbackSet
 
 if TYPE_CHECKING:
     from .register import ReadableRegister, WritableRegister
@@ -371,7 +371,7 @@ class MemoryAsyncReadOnly(Memory, ABC):
 
     # pylint: disable=too-many-arguments
     def __init__(self,
-                 callbacks: AysncCallbackSet,
+                 callbacks: AsyncCallbackSet,
                  address: int,
                  width: int,
                  accesswidth: int,
@@ -380,7 +380,7 @@ def __init__(self,
                  inst_name: str,
                  parent: AddressMap):
 
-        if not isinstance(callbacks, AysncCallbackSet):
+        if not isinstance(callbacks, AsyncCallbackSet):
             raise TypeError(f'callback set type is wrong, got {type(callbacks)}')
 
         super().__init__(callbacks=callbacks,
@@ -394,9 +394,9 @@ def __init__(self,
 
     # pylint: enable=too-many-arguments
     @property
-    def _callbacks(self) -> AysncCallbackSet:
+    def _callbacks(self) -> AsyncCallbackSet:
         # This cast is OK because the type was checked in the __init__
-        return cast(AysncCallbackSet, super()._callbacks)
+        return cast(AsyncCallbackSet, super()._callbacks)
 
     async def read(self, start_entry: int, number_entries: int) -> Array:
         """
@@ -480,7 +480,7 @@ class MemoryAsyncWriteOnly(Memory, ABC):
 
     # pylint: disable=too-many-arguments
     def __init__(self,
-                 callbacks: AysncCallbackSet,
+                 callbacks: AsyncCallbackSet,
                  address: int,
                  width: int,
                  accesswidth: int,
@@ -489,7 +489,7 @@ def __init__(self,
                  inst_name: str,
                  parent: AddressMap):
 
-        if not isinstance(callbacks, AysncCallbackSet):
+        if not isinstance(callbacks, AsyncCallbackSet):
             raise TypeError(f'callback set type is wrong, got {type(callbacks)}')
 
         super().__init__(callbacks=callbacks,
@@ -503,9 +503,9 @@ def __init__(self,
 
     # pylint: enable=too-many-arguments
     @property
-    def _callbacks(self) -> AysncCallbackSet:
+    def _callbacks(self) -> AsyncCallbackSet:
         # This cast is OK because the type was checked in the __init__
-        return cast(AysncCallbackSet, super()._callbacks)
+        return cast(AsyncCallbackSet, super()._callbacks)
 
     async def write(self, start_entry: int, data: Array) -> None:
         """

src/peakrdl_python/lib/register.py

@@ -11,7 +11,7 @@
 
 from .base import Node, AddressMap, RegFile, BaseArray, get_array_typecode
 from .memory import Memory
-from .callbacks import CallbackSet, NormalCallbackSet, AysncCallbackSet
+from .callbacks import CallbackSet, NormalCallbackSet, AsyncCallbackSet
 
 if TYPE_CHECKING:
     from .fields import FieldReadOnly, FieldWriteOnly, FieldReadWrite
@@ -404,15 +404,15 @@ class for an async read only register
 
     # pylint: disable=too-many-arguments, duplicate-code
     def __init__(self,
-                 callbacks: AysncCallbackSet,
+                 callbacks: AsyncCallbackSet,
                  address: int,
                  width: int,
                  accesswidth: int,
                  logger_handle: str,
                  inst_name: str,
                  parent: Union[AddressMap, RegFile, Memory]):
 
-        if not isinstance(callbacks, AysncCallbackSet):
+        if not isinstance(callbacks, AsyncCallbackSet):
             raise TypeError(f'callback set type is wrong, got {type(callbacks)}')
 
         super().__init__(callbacks=callbacks,
@@ -425,9 +425,9 @@ def __init__(self,
         self.__register_state: int = 0
 
     @property
-    def _callbacks(self) -> AysncCallbackSet:
+    def _callbacks(self) -> AsyncCallbackSet:
         # This cast is OK because the type was checked in the __init__
-        return cast(AysncCallbackSet, super()._callbacks)
+        return cast(AsyncCallbackSet, super()._callbacks)
 
     # pylint: enable=too-many-arguments, duplicate-code
 
@@ -502,15 +502,15 @@ class for an asynchronous write only register
 
     # pylint: disable=too-many-arguments, duplicate-code
     def __init__(self,
-                 callbacks: AysncCallbackSet,
+                 callbacks: AsyncCallbackSet,
                  address: int,
                  width: int,
                  accesswidth: int,
                  logger_handle: str,
                  inst_name: str,
                  parent: Union[AddressMap, RegFile, Memory]):
 
-        if not isinstance(callbacks, AysncCallbackSet):
+        if not isinstance(callbacks, AsyncCallbackSet):
             raise TypeError(f'callback set type is wrong, got {type(callbacks)}')
 
         super().__init__(callbacks=callbacks,
@@ -520,9 +520,9 @@ def __init__(self,
                          parent=parent, width=width, accesswidth=accesswidth)
 
     @property
-    def _callbacks(self) -> AysncCallbackSet:
+    def _callbacks(self) -> AsyncCallbackSet:
         # This cast is OK because the type was checked in the __init__
-        return cast(AysncCallbackSet, super()._callbacks)
+        return cast(AsyncCallbackSet, super()._callbacks)
 
     # pylint: enable=too-many-arguments, duplicate-code
 
@@ -596,7 +596,7 @@ class for an async read and write only register
 
     # pylint: disable=too-many-arguments, duplicate-code
     def __init__(self,
-                 callbacks: AysncCallbackSet,
+                 callbacks: AsyncCallbackSet,
                  address: int,
                  width: int,
                  accesswidth: int,

src/peakrdl_python/templates/addrmap.py.jinja

@@ -44,7 +44,7 @@ from ..lib import ReadableRegisterArray, WritableRegisterArray
 from ..lib import FieldSizeProps, FieldMiscProps
 
 {% if asyncoutput %}
-from ..lib import AysncCallbackSet
+from ..lib import AsyncCallbackSet
 {% else %}
 from ..lib import NormalCallbackSet
 {% endif %}
@@ -112,10 +112,10 @@ class {{get_fully_qualified_type_name(node)}}_cls(RegFile):
 
     __slots__ : List[str] = [{%- for child_node in node.children(unroll=False) -%}'__{{child_node.inst_name}}'{% if not loop.last %}, {% endif %}{%- endfor %}]
 
-    {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %}
+    {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %}
 
     def __init__(self,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %},
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %},
                  address: int,
                  logger_handle:str,
                  inst_name:str,
@@ -191,7 +191,7 @@ class {{get_fully_qualified_type_name(node)}}_array_cls(RegFileArray):
                  address: int,
                  length: int,
                  stride: int,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %}):
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %}):
 
         elements = tuple([{{get_fully_qualified_type_name(node)}}_cls(callbacks=callbacks,address=address+(index * stride),
                           logger_handle=f'{logger_handle}.{inst_name}[{index:d}]',
@@ -217,7 +217,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(AddressMap):
     __slots__ : List[str] = [{%- for child_node in node.children(unroll=False) -%}{%- if isinstance(child_node, systemrdlRegNode) or isinstance(child_node, systemrdlRegfileNode) or isinstance(child_node, systemrdlAddrmapNode) or isinstance(child_node, systemrdlMemNode) -%}'__{{child_node.inst_name}}'{% if not loop.last %}, {% endif %}{% endif %}{%- endfor %}]
 
     def __init__(self,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %},
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %},
                  address:int {%- if node == top_node -%}={{top_node.absolute_address}}{%- endif -%},
                  logger_handle:str {%- if node == top_node -%}='reg_model.{{top_node.get_path()}}'{%- endif -%},
                  inst_name:str{%- if node == top_node -%}='{{node.inst_name}}'{%- endif -%},
@@ -300,7 +300,7 @@ class {{get_fully_qualified_type_name(node)}}_array_cls(AddressMapArray):
                  address: int,
                  length: int,
                  stride: int,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %}):
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %}):
 
         elements = tuple([{{get_fully_qualified_type_name(node)}}_cls(callbacks=callbacks,address=address+(index * stride),
                           logger_handle=f'{logger_handle}.{inst_name}[{index:d}]',
@@ -425,5 +425,5 @@ if __name__ == '__main__':
         print('write data:0x%X to address:0x%X'%(data, addr))
 
     # create an instance of the class
-    {{top_node.inst_name}} = {{get_fully_qualified_type_name(top_node)}}_cls(callbacks = {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %}(read_callback=read_addr_space,
+    {{top_node.inst_name}} = {{get_fully_qualified_type_name(top_node)}}_cls(callbacks = {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %}(read_callback=read_addr_space,
                                                                                                      write_callback=write_addr_space))

src/peakrdl_python/templates/addrmap_memory.py.jinja

@@ -20,7 +20,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(Memory{% if asyncoutput %}Asyn
     __slots__ : List[str] = [{%- for child_node in node.children(unroll=False) -%}{%- if isinstance(child_node, systemrdlRegNode) -%}'__{{child_node.inst_name}}'{% if not loop.last %}, {% endif %}{% endif %}{%- endfor %}]
 
     def __init__(self,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %},
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %},
                  address: int,
                  logger_handle: str,
                  inst_name: str,
@@ -95,7 +95,7 @@ class {{get_fully_qualified_type_name(node)}}_array_cls(Memory{% if asyncoutput
                  address: int,
                  length: int,
                  stride: int,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %}):
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %}):
 
         elements = tuple([{{get_fully_qualified_type_name(node)}}_cls(callbacks=callbacks,address=address+(index * stride),
                           logger_handle=f'{logger_handle}.{inst_name}[{index:d}]',

src/peakrdl_python/templates/addrmap_register.py.jinja

@@ -16,7 +16,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(Reg{% if asyncoutput %}Async{%
     __slots__ : List[str] = [{%- for child_node in node.children(unroll=False) -%}'__{{child_node.inst_name}}'{% if not loop.last %}, {% endif %}{%- endfor %}]
 
     def __init__(self,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %},
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %},
                  address: int,
                  logger_handle: str,
                  inst_name: str,
@@ -197,7 +197,7 @@ class {{get_fully_qualified_type_name(node)}}_array_cls(Reg{% if asyncoutput %}A
                  address: int,
                  length: int,
                  stride: int,
-                 callbacks: {% if asyncoutput %}AysncCallbackSet{% else %}NormalCallbackSet{% endif %}):
+                 callbacks: {% if asyncoutput %}AsyncCallbackSet{% else %}NormalCallbackSet{% endif %}):
 
 
         elements = tuple([{{get_fully_qualified_type_name(node)}}_cls(callbacks=callbacks,address=address+(index * stride),