peakrdl-python 0.9.2__tar.gz → 0.9.4__tar.gz

{peakrdl_python-0.9.2 → peakrdl_python-0.9.4}/.github/workflows/action.yaml

@@ -71,7 +71,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ 3.7, 3.8, 3.9, "3.10", "3.11", "3.12", "3.13" ]
+        python-version: [ 3.9, "3.10", "3.11", "3.12", "3.13" ]
 
     steps:
       - uses: actions/checkout@v4
@@ -101,7 +101,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ 3.7, 3.8, 3.9, "3.10", "3.11", "3.12", "3.13" ]
+        python-version: [ 3.9, "3.10", "3.11", "3.12", "3.13" ]
 
     steps:
       - uses: actions/checkout@v4
@@ -150,7 +150,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ 3.7, 3.8, 3.9, "3.10", "3.11", "3.12", "3.13" ]
+        python-version: [ 3.9, "3.10", "3.11", "3.12", "3.13" ]
 
     steps:
       - uses: actions/checkout@v4
@@ -252,7 +252,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.7, 3.8, 3.9, "3.10", "3.11", "3.12", "3.13"]
+        python-version: [3.9, "3.10", "3.11", "3.12", "3.13"]
 
     steps:
     - uses: actions/checkout@v4
@@ -291,9 +291,7 @@ jobs:
     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", "3.13"]
+        python-version: [3.9, "3.10", "3.11", "3.12", "3.13"]
 
     steps:
     - uses: actions/checkout@v4

{peakrdl_python-0.9.2 → peakrdl_python-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: peakrdl-python
-Version: 0.9.2
+Version: 0.9.4
 Summary: Generate Python Register Access Layer (RAL) from SystemRDL
 Author: Keith Brady
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -686,8 +686,6 @@ Keywords: SystemRDL,PeakRDL,CSR,compiler,tool,registers,generator,Python
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -698,12 +696,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: systemrdl-compiler>=1.25.0
 Requires-Dist: jinja2
-Requires-Dist: asynctest; python_version < "3.8"
 Requires-Dist: typing-extensions; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: mypy; extra == "dev"

{peakrdl_python-0.9.2 → peakrdl_python-0.9.4}/pyproject.toml

@@ -5,11 +5,10 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "peakrdl-python"
 dynamic = ["version"]
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 dependencies = [
     "systemrdl-compiler>=1.25.0",
     "jinja2",
-    "asynctest;python_version<'3.8'",
     "typing-extensions;python_version<'3.11'"
 ]
 
@@ -27,8 +26,6 @@ classifiers = [
     "Development Status :: 4 - Beta",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",

{peakrdl_python-0.9.2 → peakrdl_python-0.9.4}/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.9.2"
+__version__ = "0.9.4"

{peakrdl_python-0.9.2 → peakrdl_python-0.9.4}/src/peakrdl_python/lib/__init__.py

@@ -37,52 +37,52 @@ from .base import AsyncRegFile
 from .base import AsyncAddressMapArray
 from .base import AsyncRegFileArray
 
-from .register import Reg
-from .register import RegArray
-from .register import RegisterWriteVerifyError
+from .register_and_field import Reg
+from .register_and_field import RegArray
+from .register_and_field import RegisterWriteVerifyError
 
-from .register import RegReadOnly
-from .register import RegWriteOnly
-from .register import RegReadWrite
-from .register import WritableRegister
-from .register import ReadableRegister
+from .register_and_field import RegReadOnly
+from .register_and_field import RegWriteOnly
+from .register_and_field import RegReadWrite
+from .register_and_field import WritableRegister
+from .register_and_field import ReadableRegister
 
-from .register import RegReadOnlyArray
-from .register import RegWriteOnlyArray
-from .register import RegReadWriteArray
-from .register import ReadableRegisterArray
-from .register import WriteableRegisterArray
+from .register_and_field import RegReadOnlyArray
+from .register_and_field import RegWriteOnlyArray
+from .register_and_field import RegReadWriteArray
+from .register_and_field import ReadableRegisterArray
+from .register_and_field import WriteableRegisterArray
 
-from .async_register import AsyncReg
-from .async_register import AsyncRegArray
-from .async_register import RegAsyncReadOnly
-from .async_register import RegAsyncWriteOnly
-from .async_register import RegAsyncReadWrite
-from .async_register import ReadableAsyncRegister
-from .async_register import WritableAsyncRegister
-from .async_register import RegAsyncReadOnlyArray
-from .async_register import RegAsyncWriteOnlyArray
-from .async_register import RegAsyncReadWriteArray
-from .async_register import ReadableAsyncRegisterArray
-from .async_register import WriteableAsyncRegisterArray
+from .async_register_and_field import AsyncReg
+from .async_register_and_field import AsyncRegArray
+from .async_register_and_field import RegAsyncReadOnly
+from .async_register_and_field import RegAsyncWriteOnly
+from .async_register_and_field import RegAsyncReadWrite
+from .async_register_and_field import ReadableAsyncRegister
+from .async_register_and_field import WritableAsyncRegister
+from .async_register_and_field import RegAsyncReadOnlyArray
+from .async_register_and_field import RegAsyncWriteOnlyArray
+from .async_register_and_field import RegAsyncReadWriteArray
+from .async_register_and_field import ReadableAsyncRegisterArray
+from .async_register_and_field import WriteableAsyncRegisterArray
 
-from .fields import FieldSizeProps
-from .fields import FieldMiscProps
-from .fields import FieldReadOnly
-from .fields import FieldWriteOnly
-from .fields import FieldReadWrite
-from .fields import Field
-from .fields import FieldEnumReadOnly
-from .fields import FieldEnumWriteOnly
-from .fields import FieldEnumReadWrite
-from .fields import FieldEnum
+from .base_field import FieldSizeProps
+from .base_field import FieldMiscProps
+from .register_and_field import FieldReadOnly
+from .register_and_field import FieldWriteOnly
+from .register_and_field import FieldReadWrite
+from .base_field import Field
+from .register_and_field import FieldEnumReadOnly
+from .register_and_field import FieldEnumWriteOnly
+from .register_and_field import FieldEnumReadWrite
+from .base_field import FieldEnum
 
-from .fields import FieldAsyncReadOnly
-from .fields import FieldAsyncWriteOnly
-from .fields import FieldAsyncReadWrite
-from .fields import FieldEnumAsyncReadOnly
-from .fields import FieldEnumAsyncWriteOnly
-from .fields import FieldEnumAsyncReadWrite
+from .async_register_and_field import FieldAsyncReadOnly
+from .async_register_and_field import FieldAsyncWriteOnly
+from .async_register_and_field import FieldAsyncReadWrite
+from .async_register_and_field import FieldEnumAsyncReadOnly
+from .async_register_and_field import FieldEnumAsyncWriteOnly
+from .async_register_and_field import FieldEnumAsyncReadWrite
 
 from .memory import MemoryReadOnly, MemoryReadOnlyLegacy
 from .memory import MemoryWriteOnly, MemoryWriteOnlyLegacy

{peakrdl_python-0.9.2 → peakrdl_python-0.9.4}/src/peakrdl_python/lib/async_memory.py

@@ -40,10 +40,9 @@ else:
 
 
 if TYPE_CHECKING:
-    from .async_register import AsyncReg, AsyncRegArray
-    from .async_register import ReadableAsyncRegister, WritableAsyncRegister
-    from .async_register import ReadableAsyncRegisterArray, WriteableAsyncRegisterArray
-
+    from .async_register_and_field import AsyncReg, AsyncRegArray
+    from .async_register_and_field import ReadableAsyncRegister, WritableAsyncRegister
+    from .async_register_and_field import ReadableAsyncRegisterArray, WriteableAsyncRegisterArray
 # pylint: disable=duplicate-code
 
 
@@ -178,14 +177,12 @@ class _MemoryAsyncReadOnly(AsyncMemory, ABC):
         read_callback = self._callbacks.read_callback
 
         if read_block_callback is not None:
-            # python 3.7 doesn't have the callback defined as protocol so mypy doesn't recognise
-            # the arguments in the call back functions
             addr = self.address_lookup(entry=start_entry)
             data_read = \
-                await read_block_callback(addr=addr,  # type: ignore[call-arg]
-                                          width=self.width,  # type: ignore[call-arg]
-                                          accesswidth=self.width,  # type: ignore[call-arg]
-                                          length=number_entries)  # type: ignore[call-arg]
+                await read_block_callback(addr=addr,
+                                          width=self.width,
+                                          accesswidth=self.width,
+                                          length=number_entries)
 
             if isinstance(self._callbacks, AsyncCallbackSet):
                 if not isinstance(data_read, List):
@@ -205,11 +202,10 @@ class _MemoryAsyncReadOnly(AsyncMemory, ABC):
 
             for entry in range(number_entries):
                 entry_address = self.address_lookup(entry=start_entry+entry)
-                # python 3.7 doesn't have the callback defined as protocol so mypy doesn't
-                # recognise the arguments in the call back functions
-                data_entry = await read_callback(addr=entry_address,  # type: ignore[call-arg]
-                                                 width=self.width,  # type: ignore[call-arg]
-                                                 accesswidth=self.width)  # type: ignore[call-arg]
+
+                data_entry = await read_callback(addr=entry_address,
+                                                 width=self.width,
+                                                 accesswidth=self.width)
 
                 data_read[entry] = data_entry
 
@@ -249,14 +245,12 @@ class _MemoryAsyncReadOnly(AsyncMemory, ABC):
         read_callback = self._callbacks.read_callback
 
         if read_block_callback is not None:
-            # python 3.7 doesn't have the callback defined as protocol so mypy doesn't recognise
-            # the arguments in the call back functions
             addr = self.address_lookup(entry=start_entry)
             data_read = \
-                await read_block_callback(addr=addr,  # type: ignore[call-arg]
-                                          width=self.width,  # type: ignore[call-arg]
-                                          accesswidth=self.width,  # type: ignore[call-arg]
-                                          length=number_entries)  # type: ignore[call-arg]
+                await read_block_callback(addr=addr,
+                                          width=self.width,
+                                          accesswidth=self.width,
+                                          length=number_entries)
 
             if isinstance(self._callbacks, AsyncCallbackSet):
                 if not isinstance(data_read, List):
@@ -276,11 +270,9 @@ class _MemoryAsyncReadOnly(AsyncMemory, ABC):
 
             for entry in range(number_entries):
                 entry_address = self.address_lookup(entry=start_entry + entry)
-                # python 3.7 doesn't have the callback defined as protocol so mypy doesn't
-                # recognise the arguments in the call back functions
-                data_entry = await read_callback(addr=entry_address,  # type: ignore[call-arg]
-                                                 width=self.width,  # type: ignore[call-arg]
-                                                 accesswidth=self.width)  # type: ignore[call-arg]
+                data_entry = await read_callback(addr=entry_address,
+                                                 width=self.width,
+                                                 accesswidth=self.width)
 
                 data_read_block[entry] = data_entry
 
@@ -429,53 +421,41 @@ class _MemoryAsyncWriteOnly(AsyncMemory, ABC):
                              f'but got {len(data):d}')
 
         if self._callbacks.write_block_callback is not None:
-            # python 3.7 doesn't have the callback defined as protocol so mypy doesn't recognise
-            # the arguments in the call back functions
+
             addr = self.address_lookup(entry=start_entry)
             if isinstance(self._callbacks, AsyncCallbackSet):
                 if isinstance(data, Array):
-                    # pylint: disable=line-too-long
-                    await self._callbacks.write_block_callback(addr=addr,  # type: ignore[call-arg]
-                                                               width=self.width,  # type: ignore[call-arg]
-                                                               accesswidth=self.width,  # type: ignore[call-arg]
-                                                               data=data.tolist())  # type: ignore[call-arg]
-                    # pylint: enable=line-too-long
+                    await self._callbacks.write_block_callback(addr=addr,
+                                                               width=self.width,
+                                                               accesswidth=self.width,
+                                                               data=data.tolist())
                 else:
-                    # pylint: disable=line-too-long
-                    await self._callbacks.write_block_callback(addr=addr,  # type: ignore[call-arg]
-                                                               width=self.width,  # type: ignore[call-arg]
-                                                               accesswidth=self.width,  # type: ignore[call-arg]
-                                                               data=data)  # type: ignore[call-arg]
-                    # pylint: enable=line-too-long
+                    await self._callbacks.write_block_callback(addr=addr,
+                                                               width=self.width,
+                                                               accesswidth=self.width,
+                                                               data=data)
             if isinstance(self._callbacks, AsyncCallbackSetLegacy):
                 if isinstance(data, list):
                     # need to convert the data to an array before calling
-                    # pylint: disable=line-too-long
-                    await self._callbacks.write_block_callback(addr=addr,  # type: ignore[call-arg]
-                                                               width=self.width,  # type: ignore[call-arg]
-                                                               accesswidth=self.width,  # type: ignore[call-arg]
-                                                               data=Array(self.array_typecode, data))  # type: ignore[call-arg]
-                    # pylint: enable=line-too-long
+                    await self._callbacks.write_block_callback(
+                        addr=addr,
+                        width=self.width,
+                        accesswidth=self.width,
+                        data=Array(self.array_typecode, data))
                 else:
-                    # pylint: disable=line-too-long
-                    await self._callbacks.write_block_callback(addr=addr,  # type: ignore[call-arg]
-                                                               width=self.width,  # type: ignore[call-arg]
-                                                               accesswidth=self.width,  # type: ignore[call-arg]
-                                                               data=data)  # type: ignore[call-arg]
-                    # pylint: enable=line-too-long
+                    await self._callbacks.write_block_callback(addr=addr,
+                                                               width=self.width,
+                                                               accesswidth=self.width,
+                                                               data=data)
 
         elif self._callbacks.write_callback is not None:
             # there is not write_block_callback defined so we must used individual write
             for entry_index, entry_data in enumerate(data):
                 entry_address = self.address_lookup(entry=start_entry+entry_index)
-                # python 3.7 doesn't have the callback defined as protocol so mypy doesn't
-                # recognise the arguments in the call back functions
-                # pylint: disable=line-too-long
-                await self._callbacks.write_callback(addr=entry_address,  # type: ignore[call-arg]
-                                                     width=self.width,  # type: ignore[call-arg]
-                                                     accesswidth=self.width,  # type: ignore[call-arg]
-                                                     data=entry_data)  # type: ignore[call-arg]
-                # pylint: enable=line-too-long
+                await self._callbacks.write_callback(addr=entry_address,
+                                                     width=self.width,
+                                                     accesswidth=self.width,
+                                                     data=entry_data)
 
         else:
             raise RuntimeError('No suitable callback')