refactor(max_speed_hz): validate property in Python class

Author: yochem

spidev/_cspi.c

@@ -1211,27 +1211,14 @@ SpiDev_get_max_speed_hz(SpiDevObject *self, void *closure)
 static int
 SpiDev_set_max_speed_hz(SpiDevObject *self, PyObject *val, void *closure)
 {
-	uint32_t max_speed_hz;
 
 	if (val == NULL) {
 		PyErr_SetString(PyExc_TypeError,
 			"Cannot delete attribute");
 		return -1;
 	}
-#if PY_MAJOR_VERSION < 3
-	if (PyInt_Check(val)) {
-		max_speed_hz = PyInt_AS_LONG(val);
-	} else
-#endif
-	{
-		if (PyLong_Check(val)) {
-			max_speed_hz = PyLong_AS_LONG(val);
-		} else {
-			PyErr_SetString(PyExc_TypeError,
-				"The max_speed_hz attribute must be an integer");
-			return -1;
-		}
-	}
+
+	uint32_t max_speed_hz = PyLong_AS_LONG(val);
 
 	if (self->max_speed_hz != max_speed_hz) {
 		if (ioctl(self->fd, SPI_IOC_WR_MAX_SPEED_HZ, &max_speed_hz) == -1) {

spidev/_spi.py

@@ -5,12 +5,20 @@
 if TYPE_CHECKING:
     from os import PathLike
     from types import TracebackType
-    from typing import Self, Union, Sequence, overload
+    from typing import Self, Union, Sequence, overload, Any
     from collections.abc import Buffer
 
     StrPath = Union[str, PathLike[str]]
 
 
+def as_int(val: Any, name: str = "Value") -> int:
+    try:
+        v = int(val)
+    except (TypeError, ValueError):
+        raise TypeError(f"{name} must be an integer, but is {type(val)}")
+    return v
+
+
 class SpiDev(_cspi.SpiDev):
     def __init__(
         self,
@@ -20,22 +28,26 @@ def __init__(
         path: StrPath | None = None,
         mode: int | None = None,
         bits_per_word: int | None = None,
+        max_speed_hz: int | None = None,
     ):
         super().__init__(bus, client)
+
         self.bus = bus
         self.client = client
         self.device = device
-        if mode is not None:
-            self.mode = mode
-        if bits_per_word is not None:
-            self.bits_per_word = bits_per_word
-
         if path and (bus or device):
             raise ValueError(
                 "both path and bus/device number of SPI device are provided"
             )
         self.path = path
 
+        if mode is not None:
+            self.mode = mode
+        if bits_per_word is not None:
+            self.bits_per_word = bits_per_word
+        if max_speed_hz is not None:
+            self.max_speed_hz = max_speed_hz
+
     @property
     def mode(self) -> int:
         """SPI mode.
@@ -47,10 +59,7 @@ def mode(self) -> int:
 
     @mode.setter
     def mode(self, value: int, /) -> None:
-        try:
-            v = int(value)
-        except (TypeError, ValueError):
-            raise TypeError(f"mode must be an integer, but is {type(value)}")
+        v = as_int(value, "mode")
 
         if not 0 <= v <= 3:
             raise ValueError(f"mode must be between 0 and 3, but is {v}")
@@ -64,16 +73,23 @@ def bits_per_word(self) -> int:
 
     @bits_per_word.setter
     def bits_per_word(self, value: int, /) -> None:
-        try:
-            v = int(value)
-        except (TypeError, ValueError):
-            raise TypeError(f"bits_per_word must be an integer, but is {type(value)}")
+        v = as_int(value, "bits_per_word")
 
         if not (8 <= value <= 32):
             raise ValueError(f"bits_per_word must be between 8 and 32, but is {v}")
 
         super().__setattr__("bits_per_word", v)
 
+    @property
+    def max_speed_hz(self) -> int:
+        """Max speed (in Hertz)."""
+        return super().max_speed_hz
+
+    @max_speed_hz.setter
+    def max_speed_hz(self, value: int, /) -> None:
+        v = as_int(value, "max_speed_hz")
+        super().__setattr__("max_speed_hz", v)
+
     def closed(self) -> bool:
         """True if the connection is closed."""
         try: