pystructtype 0.2.0__tar.gz → 0.4.0__tar.gz

{pystructtype-0.2.0 → pystructtype-0.4.0}/.github/workflows/build.yml

@@ -14,13 +14,13 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: 3.13
+          python-version: 3.14
 
       - name: Run Tests
         run: |
           uv sync
           uv tool install tox
-          tox -e py313
+          tox -e py314
   check:
     runs-on: ubuntu-latest
     steps:
@@ -33,7 +33,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: 3.13
+          python-version: 3.14
 
       - name: Check Formatting
         run: |
@@ -53,7 +53,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: 3.13
+          python-version: 3.14
 
       - name: Check Formatting
         run: |

{pystructtype-0.2.0 → pystructtype-0.4.0}/.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: 3.13
+          python-version: 3.14
 
       - name: Release
         run: |

{pystructtype-0.2.0 → pystructtype-0.4.0}/.gitignore

@@ -10,7 +10,11 @@ wheels/
 .venv
 
 # Coverage
+.coverage
 .coverage.*
 
 # PyCharm
 .idea*
+
+# Extra
+.DS_Store

{pystructtype-0.2.0 → pystructtype-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystructtype
-Version: 0.2.0
+Version: 0.4.0
 Summary: Leverage Python Types to Define C-Struct Interfaces
 Project-URL: Homepage, https://github.com/fchorney/pystructtype
 Project-URL: Documentation, https://pystructtype.readthedocs.io/en/latest/
@@ -15,10 +15,9 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Utilities
-Requires-Python: >=3.13
-Requires-Dist: loguru>=0.7.3
+Requires-Python: <4.0,>=3.14
 Description-Content-Type: text/markdown
 
 # PyStructTypes
@@ -57,7 +56,6 @@ struct MyStruct {
 ```
 
 ```python
-@struct_dataclass
 class MyStruct(StructDataclass):
     myNum: int16_t
     myLetter: char_t
@@ -84,7 +82,6 @@ struct MyStruct {
 };
 ```
 ```python
-@struct_dataclass
 class MyStruct(StructDataclass):
     myInts: Annotated[list[uint8_t], TypeMeta(size=4)]
     myBiggerInts: Annotated[list[uint16_t], TypeMeta(size=2)]
@@ -110,7 +107,6 @@ struct MyStruct {
 ```
 
 ```python
-@struct_dataclass
 class MyStruct(StructDataclass):
     myInt: uint8_t = 5
     myInts: Annnotated[list[uint8_t], TypeMeta(size=2, default=1)]
@@ -121,6 +117,39 @@ s.decode([10, 5, 6])
 # MyStruct(myInt=10, myInts=[5, 6])
 ```
 
+# String / char[] Type
+
+Defining c-string types is a little different. Instead of using
+`size` in the `TypeMeta`, we need to instead use `chunk_size`.
+
+This is because the way the struct format is defined for c-strings needs
+to know how big the string data is expected to be so that it can put the
+whole string in a single variable. 
+
+The `chunk_size` is also introduced to allow for `char[][]` for converting
+a list of strings.
+
+```c
+struct MyStruct {
+    char myStr[3];
+    char myStrList[2][3];
+};
+```
+```python
+class MyStruct(StructDataclass):
+    myStr: Annotated[string_t, TypeMeta[str](chunk_size=3)]
+    myStrList: Annotated[list[string_t], TypeMeta[str](size=2, chunk_size=3)]
+
+
+s = MyStruct()
+s.decode([65, 66, 67, 68, 69, 70, 71, 72, 73])
+# MyStruct(myStr=b"ABC", myStrList=[b"DEF", b"GHI"])
+```
+
+If you instead try to define this as a list of `char_t` types,
+you would only be able to end up with 
+`MyStruct(myStr=[b"A", b"B", b"C"], myStrList=[b"D", b"E", b"F", b"G", b"H", b"I"])`
+
 # The Bits Abstraction
 
 This library includes a `bits` abstraction to map bits to variables for easier access.
@@ -136,8 +165,9 @@ enum ConfigFlags {
 ```
 
 ```python
-@bits(uint8_t, {"lights_flag": 0, "platform_flag": 1})
-class FlagsType(BitsType): ...
+class FlagsType(BitsType):
+    __bits_type__ = uint8_t
+    __bits_definition__ = {"lights_flag": 0, "platform_flag": 1}
 
 f = FlagsType()
 f.decode([3])
@@ -167,7 +197,6 @@ struct MyStruct {
 ```
 
 ```python
-@struct_dataclass
 class EnabledSensors(StructDataclass):
     # We can define the actual data we are ingesting here
     # This mirrors the `uint8_t enabledSensors[5]` data
@@ -228,7 +257,6 @@ s.decode([15, 15, 15, 15, 0])
 #   [False, False, False, False],
 #   [True, True, True, True],
 #   [False, False, False, False],
-#   [False, False, False, False]
 # ]
 
 # With the get/set functioned defined, we can access the data
@@ -254,15 +282,13 @@ struct LEDS {
 ```
 
 ```python
-@struct_dataclass
 class RGB(StructDataclass):
     r: uint8_t
     g: uint8_t
     b: uint8_t
 
-@struct_dataclass
 class LEDS(StructDataclass):
-    lights: Annotated[list[RGB], TypeMeta(size=3])]
+    lights: Annotated[list[RGB], TypeMeta(size=3)]
 
 l = LEDS()
 l.decode([1, 2, 3, 4, 5, 6, 7, 8, 9])
@@ -272,11 +298,10 @@ l.decode([1, 2, 3, 4, 5, 6, 7, 8, 9])
 # Future Updates
 
 - Bitfield: Similar to the `Bits` abstraction. An easy way to define bitfields
-- C-Strings: Make a base class to handle C strings (arrays of chars)
 - Potentially more ways to define bits (dicts/lists/etc).
 - Potentially allowing list defaults to be entire pre-defined lists.
 - ???
 
 # Examples
 
-You can see a more fully fledged example in the `test/examples.py` file. 
+You can see a more fully fledged example in the `test/examples.py` file.

{pystructtype-0.2.0 → pystructtype-0.4.0}/README.md

@@ -34,7 +34,6 @@ struct MyStruct {
 ```
 
 ```python
-@struct_dataclass
 class MyStruct(StructDataclass):
     myNum: int16_t
     myLetter: char_t
@@ -61,7 +60,6 @@ struct MyStruct {
 };
 ```
 ```python
-@struct_dataclass
 class MyStruct(StructDataclass):
     myInts: Annotated[list[uint8_t], TypeMeta(size=4)]
     myBiggerInts: Annotated[list[uint16_t], TypeMeta(size=2)]
@@ -87,7 +85,6 @@ struct MyStruct {
 ```
 
 ```python
-@struct_dataclass
 class MyStruct(StructDataclass):
     myInt: uint8_t = 5
     myInts: Annnotated[list[uint8_t], TypeMeta(size=2, default=1)]
@@ -98,6 +95,39 @@ s.decode([10, 5, 6])
 # MyStruct(myInt=10, myInts=[5, 6])
 ```
 
+# String / char[] Type
+
+Defining c-string types is a little different. Instead of using
+`size` in the `TypeMeta`, we need to instead use `chunk_size`.
+
+This is because the way the struct format is defined for c-strings needs
+to know how big the string data is expected to be so that it can put the
+whole string in a single variable. 
+
+The `chunk_size` is also introduced to allow for `char[][]` for converting
+a list of strings.
+
+```c
+struct MyStruct {
+    char myStr[3];
+    char myStrList[2][3];
+};
+```
+```python
+class MyStruct(StructDataclass):
+    myStr: Annotated[string_t, TypeMeta[str](chunk_size=3)]
+    myStrList: Annotated[list[string_t], TypeMeta[str](size=2, chunk_size=3)]
+
+
+s = MyStruct()
+s.decode([65, 66, 67, 68, 69, 70, 71, 72, 73])
+# MyStruct(myStr=b"ABC", myStrList=[b"DEF", b"GHI"])
+```
+
+If you instead try to define this as a list of `char_t` types,
+you would only be able to end up with 
+`MyStruct(myStr=[b"A", b"B", b"C"], myStrList=[b"D", b"E", b"F", b"G", b"H", b"I"])`
+
 # The Bits Abstraction
 
 This library includes a `bits` abstraction to map bits to variables for easier access.
@@ -113,8 +143,9 @@ enum ConfigFlags {
 ```
 
 ```python
-@bits(uint8_t, {"lights_flag": 0, "platform_flag": 1})
-class FlagsType(BitsType): ...
+class FlagsType(BitsType):
+    __bits_type__ = uint8_t
+    __bits_definition__ = {"lights_flag": 0, "platform_flag": 1}
 
 f = FlagsType()
 f.decode([3])
@@ -144,7 +175,6 @@ struct MyStruct {
 ```
 
 ```python
-@struct_dataclass
 class EnabledSensors(StructDataclass):
     # We can define the actual data we are ingesting here
     # This mirrors the `uint8_t enabledSensors[5]` data
@@ -205,7 +235,6 @@ s.decode([15, 15, 15, 15, 0])
 #   [False, False, False, False],
 #   [True, True, True, True],
 #   [False, False, False, False],
-#   [False, False, False, False]
 # ]
 
 # With the get/set functioned defined, we can access the data
@@ -231,15 +260,13 @@ struct LEDS {
 ```
 
 ```python
-@struct_dataclass
 class RGB(StructDataclass):
     r: uint8_t
     g: uint8_t
     b: uint8_t
 
-@struct_dataclass
 class LEDS(StructDataclass):
-    lights: Annotated[list[RGB], TypeMeta(size=3])]
+    lights: Annotated[list[RGB], TypeMeta(size=3)]
 
 l = LEDS()
 l.decode([1, 2, 3, 4, 5, 6, 7, 8, 9])
@@ -249,11 +276,10 @@ l.decode([1, 2, 3, 4, 5, 6, 7, 8, 9])
 # Future Updates
 
 - Bitfield: Similar to the `Bits` abstraction. An easy way to define bitfields
-- C-Strings: Make a base class to handle C strings (arrays of chars)
 - Potentially more ways to define bits (dicts/lists/etc).
 - Potentially allowing list defaults to be entire pre-defined lists.
 - ???
 
 # Examples
 
-You can see a more fully fledged example in the `test/examples.py` file. 
+You can see a more fully fledged example in the `test/examples.py` file.

{pystructtype-0.2.0 → pystructtype-0.4.0}/docs/conf.py

@@ -1,6 +1,8 @@
 import tomllib
 from datetime import datetime
 
+from sphinx.application import Sphinx
+
 # Sphinx Base --------------------------------------------------------------------------
 # Extensions
 extensions = [
@@ -61,7 +63,7 @@ exclude_patterns = ["autoapi_templates"]
 
 
 # Add any Sphinx plugin settings here that don't have global variables exposed.
-def setup(app):
+def setup(app: Sphinx) -> None:
     # App Settings ---------------------------------------------------------------------
     # Set source filetype(s)
     # Allow .rst files

{pystructtype-0.2.0 → pystructtype-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pystructtype"
-version = "0.2.0"
+version = "0.4.0"
 description = "Leverage Python Types to Define C-Struct Interfaces"
 readme = "README.md"
 authors = [{name = "fchorney", email = "github@djsbx.com"}]
@@ -13,13 +13,11 @@ classifiers = [
     "Operating System :: OS Independent",
     "Intended Audience :: Developers",
     "Topic :: Utilities",
-    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 keywords = ["struct", "cstruct", "type"]
-requires-python = ">=3.13"
-dependencies = [
-    "loguru>=0.7.3",
-]
+requires-python = ">=3.14,<4.0"
+dependencies = []
 
 [project.urls]
 Homepage = "https://github.com/fchorney/pystructtype"
@@ -29,22 +27,28 @@ Issues = "https://github.com/fchorney/pystructtype/issues"
 
 [dependency-groups]
 dev = [
-    "coverage[toml]",
-    "mypy",
-    "pytest",
-    "pytest-cov",
-    "ruff",
-    "sphinx",
-    "sphinx-autoapi",
-    "sphinx-rtd-theme",
-    "tox",
-    "tox-uv",
+    "coverage[toml]>=7.6.12",
+    "mypy>=1.19.1",
+    "pre-commit>=4.5.1",
+    "pytest>=9.0.2",
+    "pytest-cov>=6.3.0",
+    "ruff>=0.15.6",
+    "sphinx>=9.1.0",
+    "sphinx-autoapi>=3.8.0",
+    "sphinx-rtd-theme>=3.1.0",
+    "tox>=4.49.1",
+    "tox-uv>=1.33.4",
 ]
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.mypy]
+strict = false
+check_untyped_defs = true
+exclude = ["venv", ".venv"]
+
 [tool.coverage.run]
 relative_files = true
 
@@ -58,30 +62,39 @@ exclude_lines = ["if __name__ == .__main__.:", "def __str__", "def __repr__", "p
 package = true
 
 [tool.ruff]
+target-version = "py314"
 line-length = 120
 indent-width = 4
-
-target-version = "py313"
+exclude = []
 
 [tool.ruff.lint]
 select = [
-    "F",   # PyFlakes
-    "E",   # Error
-    "I",   # iSort
-    "N",   # Pep8-Naming
-    "B",   # Flake8-BugBear
-    "UP",  # PyUpgrade
-    "RUF", # Ruff Specific Rules
+    "E",        # pycodestyle errors
+    "W",        # pycodestyle warnings
+    "F",        # pyflakes
+    "I",        # isort
+    "N",        # pep8-naming
+    "B",        # flake8-bugbear
+    "C4",       # flake8-comprehensions
+    "UP",       # pyupgrade
+    "ARG001",   # unused arguments in functions
+    "RUF",      # ruff specific rules
+]
+ignore = [
+    "B008",  # do not perform function calls in argument defaults
+    "W191",  # indentation contains tabs
 ]
-ignore = []
 fixable = ["ALL"]
 unfixable = []
 
 [tool.ruff.format]
-# Like Black
 quote-style = "double"
 indent-style = "space"
 skip-magic-trailing-comma = false
 line-ending = "auto"
 docstring-code-format = true
 docstring-code-line-length = "dynamic"
+
+[tool.ruff.lint.pyupgrade]
+# Preserve types, even if a file imports `from __future__ import annotations`.
+keep-runtime-typing = true

{pystructtype-0.2.0 → pystructtype-0.4.0}/src/pystructtype/__init__.py

@@ -1,5 +1,5 @@
-from pystructtype.bitstype import BitsType, bits
-from pystructtype.structdataclass import StructDataclass, struct_dataclass
+from pystructtype.bitstype import BitsType
+from pystructtype.structdataclass import StructDataclass
 from pystructtype.structtypes import (
     TypeInfo,
     TypeMeta,
@@ -10,6 +10,7 @@ from pystructtype.structtypes import (
     int16_t,
     int32_t,
     int64_t,
+    string_t,
     uint8_t,
     uint16_t,
     uint32_t,
@@ -21,7 +22,6 @@ __all__ = [
     "StructDataclass",
     "TypeInfo",
     "TypeMeta",
-    "bits",
     "char_t",
     "double_t",
     "float_t",
@@ -29,7 +29,7 @@ __all__ = [
     "int16_t",
     "int32_t",
     "int64_t",
-    "struct_dataclass",
+    "string_t",
     "uint8_t",
     "uint16_t",
     "uint32_t",

pystructtype-0.4.0/src/pystructtype/bitstype.py

@@ -0,0 +1,86 @@
+import itertools
+from collections.abc import Mapping
+from dataclasses import field
+from types import MappingProxyType
+from typing import Annotated, ClassVar
+
+from pystructtype.structdataclass import StructDataclass
+from pystructtype.structtypes import TypeMeta
+from pystructtype.utils import int_to_bool_list
+
+
+class BitsType(StructDataclass):
+    """
+    Base class for bitfield structs. Subclasses must define __bits_type__ and __bits_definition__.
+    """
+
+    __bits_type__: ClassVar[type]
+    __bits_definition__: ClassVar[dict[str, int | list[int]] | Mapping[str, int | list[int]]]
+
+    _raw: int
+    _meta: dict[str, int | list[int]]
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # Check for required attributes
+        if not hasattr(cls, "__bits_type__") or not hasattr(cls, "__bits_definition__"):
+            raise TypeError(
+                "Subclasses of BitsType must define __bits_type__ and __bits_definition__ class attributes."
+            )
+        bits_type = cls.__bits_type__
+        definition = cls.__bits_definition__
+
+        # Automatically wrap in MappingProxyType if it's a dict and not already immutable
+        if isinstance(definition, dict) and not isinstance(definition, MappingProxyType):
+            definition = MappingProxyType(definition)
+            cls.__bits_definition__ = definition
+
+        # # Remove __bits_type__ and __bits_definition__ from __annotations__ if present
+        # cls.__annotations__.pop("__bits_type__", None)
+        # cls.__annotations__.pop("__bits_definition__", None)
+
+        # Set the correct type for the raw data
+        cls._raw = 0
+        cls.__annotations__["_raw"] = bits_type
+
+        cls._meta = field(default_factory=dict)
+
+        # Create the defined attributes, defaults, and annotations in the class
+        for key, value in definition.items():
+            if isinstance(value, list):
+                setattr(
+                    cls,
+                    key,
+                    field(default_factory=lambda v=len(value): [False for _ in range(v)]),  # type: ignore
+                )
+                cls.__annotations__[key] = Annotated[list[bool], TypeMeta(size=len(value))]
+            else:
+                setattr(cls, key, False)
+                cls.__annotations__[key] = bool
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self._meta = dict(self.__bits_definition__)
+
+    def _decode(self, data: list[int]) -> None:
+        super()._decode(data)
+        bin_data = int_to_bool_list(self._raw, self._byte_length)
+        for k, v in self._meta.items():
+            if isinstance(v, list):
+                steps = [bin_data[idx] for idx in v]
+                setattr(self, k, steps)
+            else:
+                setattr(self, k, bin_data[v])
+
+    def _encode(self) -> list[int]:
+        bin_data = list(itertools.repeat(False, self._byte_length * 8))
+        for k, v in self._meta.items():
+            if isinstance(v, list):
+                steps = getattr(self, k)
+                for idx, bit_idx in enumerate(v):
+                    bin_data[bit_idx] = steps[idx]
+            else:
+                bin_data[v] = getattr(self, k)
+        self._raw = sum(int(v) << i for i, v in enumerate(bin_data))
+        # Return _raw as a list of bytes (little-endian)
+        return super()._encode()