ekfsm 0.13.0a183__py3-none-any.whl → 1.5.0__py3-none-any.whl

ekfsm/core/sysfs.py

@@ -1,4 +1,10 @@
+from collections.abc import MutableMapping
 from pathlib import Path
+from typing import Callable
+
+from more_itertools import first_true
+
+from ekfsm.exceptions import ConversionError, DriverError, SysFSError
 
 SYSFS_ROOT = Path("/sys")
 
@@ -20,41 +26,41 @@ class SysFSAttribute:
     """
     A SysFSAttribute is a singular sysfs attribute located somewhere in */sys*.
 
-    Attributes
+    Parameters
     ----------
-    path : Path
-        path to the underlying file for the SysFSAttribute instance
-    name : str
-        attribute name, or the last part of self.path
-
-    Methods
-    -------
-    read() -> Optional[str]
-        Reads the file attribute if it exists
-    write(data: Union[str, int]) -> None
-        Writes data to the file attribute
-
+    path: Path
+        Path to the underlying file for the SysFSAttribute instance.
     """
 
     def __init__(self, path: Path):
-        self.path = path
         if not path.exists() or not path.is_file():
             raise FileNotFoundError("Invalid sysfs attribute path")
 
+        self.path = path
         self.name: str = path.name
 
     def read_utf8(self) -> str:
-        return self.path.read_text()
+        try:
+            return self.path.read_text()
+        except OSError as e:
+            raise SysFSError("Error accessing SysFS attribute") from e
 
     def read_bytes(self) -> bytes:
-        return self.path.read_bytes()
+        try:
+            return self.path.read_bytes()
+        except OSError as e:
+            raise SysFSError("Error accessing SysFS attribute") from e
 
+    # FIXME: This cannot work due to sysfs attributes not supporting seek().
     def write(self, data: str | bytes | None, offset: int = 0) -> None:
         if self.is_sysfs_attr() and data is not None:
-            mode = 'r+' if isinstance(data, str) else 'rb+'
-            with open(self.path, mode) as f:
-                f.seek(offset)
-                f.write(data)
+            mode = "r+" if isinstance(data, str) else "rb+"
+            try:
+                with open(self.path, mode) as f:
+                    f.seek(offset)
+                    f.write(data)
+            except OSError as e:
+                raise SysFSError("Error accessing SysFS attribute") from e
 
     def is_sysfs_attr(self) -> bool:
         return file_is_sysfs_attr(self.path)
@@ -70,10 +76,45 @@ def list_sysfs_attributes(path: Path) -> list[SysFSAttribute]:
     return [SysFSAttribute(item) for item in path.iterdir() if file_is_sysfs_attr(item)]
 
 
-class SysFSDevice:
-    def __init__(self, base_dir: Path):
+class SysfsDevice(MutableMapping):
+    def __init__(
+        self, base_dir: Path, driver_required=True, find_driver: Callable | None = None
+    ):
         self.path: Path = base_dir
-        self.attributes: list[SysFSAttribute] = list_sysfs_attributes(self.path)
+        self.driver_required = driver_required
+
+        try:
+            self.driver = self.get_driver()
+        except Exception:
+            self.driver = None
+
+            if driver_required:
+                raise DriverError(f"No driver found for device at {base_dir}")
+
+        try:
+            self.attributes: list[SysFSAttribute] = list_sysfs_attributes(self.path)
+        except FileNotFoundError as e:
+            raise SysFSError(f"SysFS entry for {base_dir} does not exist") from e
+
+    def __getitem__(self, key):
+        if (
+            attr := first_true(self.attributes, pred=lambda a: a.name == key)
+        ) is not None:
+            return attr
+
+        raise KeyError(f"'{key}' is not a valid sysfs attribute in {self.path}")
+
+    def __setitem__(self, key, value):
+        self[key].write(value)
+
+    def __delitem__(self, key):
+        del self.attributes[key]
+
+    def __iter__(self):
+        return iter(self.attributes)
+
+    def __len__(self):
+        return len(self.attributes)
 
     def pre(self) -> None:
         pass
@@ -81,11 +122,160 @@ class SysFSDevice:
     def post(self) -> None:
         pass
 
-    def write_attr(self, attr: str, data: str | bytes, offset: int = 0) -> None:
-        next(x for x in self.attributes if x.name == attr).write(data, offset)
+    def write_attr(self, attr: str, data: str | bytes) -> None:
+        next(x for x in self.attributes if x.name == attr).write(data)
+
+    def write_attr_bytes(self, attr: str, data: str) -> None:
+        # TODO: This
+        pass
 
     def read_attr_utf8(self, attr: str) -> str:
         return next(x for x in self.attributes if x.name == attr).read_utf8()
 
+    def read_float(self, attr: str) -> float:
+        """
+        Read a sysfs attribute as a floating-point number
+
+        Parameters
+        ----------
+        attr: str
+            The sysfs attribute to read
+
+        Returns
+        -------
+        The sysfs attribute as a floating-point number
+
+        Raises
+        ------
+        SysFSError
+            If the sysfs attribute does not exist
+        ConversionError
+            If the sysfs attribute could not be converted to a floating-point number
+        """
+        try:
+            value = self.read_attr_utf8(attr)
+            return float(value)
+        except StopIteration as e:
+            raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
+        except SysFSError:
+            raise
+        except ValueError as e:
+            raise ConversionError(
+                "Failed to convert sysfs value to floating-point value"
+            ) from e
+
+    def read_int(self, attr) -> int:
+        """
+        Read a sysfs attribute stored as a string as an integer
+
+        Parameters
+        ----------
+        attr: str
+            The sysfs attribute to read
+
+        Returns
+        -------
+        The sysfs attribute as an integer
+
+        Raises
+        ------
+        SysFSError
+            If the sysfs attribute does not exist
+        ConversionError
+            If the sysfs attribute could not be converted to an integer
+        """
+        try:
+            value = self.read_attr_utf8(attr).strip()
+            return int(value)
+        except StopIteration as e:
+            raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
+        except SysFSError:
+            raise
+        except ValueError as e:
+            raise ConversionError("Failed to convert sysfs value to int") from e
+
+    def read_hex(self, attr) -> int:
+        """
+        Read a sysfs attribute stored as a hexadecimal integer as integer
+
+        Parameters
+        ----------
+        attr: str
+            The sysfs attribute to read
+
+        Returns
+        -------
+        The sysfs attribute as a hexadecimal integer
+
+        Raises
+        ------
+        SysFSError
+            If the sysfs attribute does not exist
+        ConversionError
+            If the sysfs attribute could not be converted to a hexadecimal integer
+        """
+        try:
+            value = self.read_attr_utf8(attr).strip()
+            return int(value, 16)
+        except StopIteration as e:
+            raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
+        except SysFSError:
+            raise
+        except ValueError as e:
+            raise ConversionError("Failed to convert sysfs value to hex int") from e
+
+    def read_utf8(self, attr, strip=True) -> str:
+        """
+        Read a sysfs attribute as a UTF-8 encoded string
+
+        Parameters
+        ----------
+        attr: str
+            The sysfs attribute to read
+        strip: bool
+            Strip whitespace, defaults to true
+
+        Returns
+        -------
+        The sysfs attribute as a UTF-8 encoded string
+
+        Raises
+        ------
+        SysFSError
+            If the sysfs attribute does not exist
+        """
+        try:
+            value = self.read_attr_utf8(attr)
+            if strip:
+                value = value.strip()
+
+            return value
+        except StopIteration as e:
+            raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
+        except SysFSError:
+            raise
+
     def read_attr_bytes(self, attr: str) -> bytes:
         return next(x for x in self.attributes if x.name == attr).read_bytes()
+
+    def read_bytes(self, attr) -> bytes:
+        try:
+            value = self.read_attr_bytes(attr)
+            return value
+        except StopIteration as e:
+            raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
+        except SysFSError:
+            raise
+
+    def extend_attributes(self, attributes: list[SysFSAttribute]):
+        self.attributes.extend(attributes)
+
+    def get_driver(self) -> str | None:
+        path = self.path
+
+        if self.path.joinpath("device").exists():
+            path = self.path.joinpath("device")
+        elif not path.joinpath("driver").exists():
+            raise DriverError("Failed to retrieve driver info")
+
+        return path.joinpath("driver").readlink().name

ekfsm/core/utils.py

@@ -1,92 +1,156 @@
 from __future__ import annotations
+
 import logging
-from typing import TYPE_CHECKING
-from anytree import AnyNode
+from pprint import pformat
+from typing import TYPE_CHECKING, Any
+
+from schema import Optional, Or, Schema, SchemaError, Use
+from termcolor import colored
 
 from ekfsm.devices import CLASS_MAP
 from ekfsm.exceptions import ConfigError
 
 if TYPE_CHECKING:
-    from .components import HwModule
     from ekfsm.devices.generic import Device
 
+    from .components import HWModule
 
-class BoardDictImporter:
-
-    def __init__(self, nodecls=AnyNode):
-        self.nodecls = nodecls
-
-    def import_(self, logger: logging.Logger, data, parent=None, abort: bool = False):
-        """Import tree from `data`."""
-        return self.__import(logger, data, parent=parent, abort=abort)
-
-    def __import(self, logger: logging.Logger, data, parent=None, abort: bool = False):
-        from .components import HwModule
 
-        device_type = data.get("device_type")
-        nodecls = CLASS_MAP.get(device_type)
-        if nodecls is None:
-            raise ConfigError(f"Unknown device type: {device_type}")
+def import_board(logger: logging.Logger, data, parent=None, abort: bool = False):
+    from .components import HWModule
 
-        children = data.pop("children", [])
-        if parent is not None and isinstance(parent, HwModule):
-            # ???
-            pass
+    device_type = data.get("device_type")
+    nodecls = CLASS_MAP.get(device_type)
+    if nodecls is None:
+        raise ConfigError(f"Unknown device type: {device_type}")
 
-        node = nodecls(parent=parent, **data)
+    children = data.pop("children", [])
+    if parent is not None and isinstance(parent, HWModule):
+        # ???
+        pass
 
-        if children is not None:
-            for child in children:
-                try:
-                    logger.debug(f"Importing sub device {child}")
-                    self.__import(logger, child, parent=node, abort=abort)
-                except Exception as e:
-                    if abort:
-                        logger.error(
-                            f"Failed to import sub device {child}: {e}. aborting"
-                        )
-                        raise e
-                    else:
-                        logger.error(
-                            f"Failed to import sub device {child}: {e}. continue anyway"
-                        )
-        return node
+    if provides := data.get("provides"):
+        for p in provides:
+            interfaces = data["provides"][p]
 
+            for interface in interfaces:
+                if isinstance(interface, str):
+                    if attr := getattr(nodecls, interface, None):
+                        if not callable(attr) and not abort:
+                            raise ConfigError("No such method")
+                elif isinstance(interface, dict):
+                    for key, value in interface.items():
+                        if attr := getattr(nodecls, value, None):
+                            if not callable(attr) and not abort:
+                                raise ConfigError("No such method")
+                else:
+                    raise ConfigError("Error in board configuration")
 
-def deserialize_hardware_tree(
-    logger: logging.Logger, data: dict, parent: "HwModule"
-) -> tuple[str, str, str, list["Device"]]:
-    importer = BoardDictImporter()
-    abort = parent.abort
-
-    # better use schema extension for this
-    id = data.pop("id", None)
-    if id is None:
-        raise ConfigError("Board configuration must contain `id`")
-    name = data.pop("name", None)
-    if name is None:
-        raise ConfigError("Board configuration must contain `name`")
-    slot_type = data.pop("slot_type")
-    if slot_type is None:
-        raise ConfigError("Board configuration must contain `board_type`")
+    node = nodecls(parent=parent, abort=abort, **data)
 
-    children = data.pop("children", None)
-    devices = []
-    if children:
+    if children is not None:
         for child in children:
             try:
-                logger.debug(f"Importing top level device {child}")
-                node = importer.import_(logger, child, parent=parent, abort=abort)
-                devices.append(node)
+                logger.debug(f"Importing sub device {pformat(child)}")
+                import_board(logger, data=child, parent=node, abort=abort)
             except Exception as e:
                 if abort:
                     logger.error(
-                        f"Failed to import top level device {child}: {e}. aborting"
+                        f"Failed to import sub device {pformat(child)}: {e}. Aborting."
                     )
                     raise e
                 else:
                     logger.error(
-                        f"Failed to import top level device {child}: {e}. continue anyway"
+                        f"Failed to import sub device {pformat(child)}: {e}. Continuing anyway."
                     )
+    return node
+
+
+def provides_validator(x: Any) -> Any:
+    if isinstance(x, str):
+        return x
+    elif isinstance(x, dict) and len(x) == 1:
+        key, value = next(iter(x.items()))
+        if isinstance(key, str) and isinstance(value, str):
+            return x
+    raise SchemaError(
+        "Each provides item must be either a string or a dictionary with one string key/value pair"
+    )
+
+
+device_schema = Schema({})
+
+_device_structure = Schema(
+    {
+        "device_type": str,
+        "name": str,
+        Optional("addr"): int,
+        Optional("slot_coding_mask"): int,
+        Optional("channel_id"): int,
+        Optional("service_suffix"): str,
+        Optional("keepaliveInterval"): int,
+        Optional("provides"): {
+            Optional(str): [Use(provides_validator)],
+        },
+        Optional("children"): Or(None, [device_schema]),
+    }
+)
+
+device_schema._schema = _device_structure
+
+module_schema = Schema(
+    {
+        "id": Or(int, str),
+        "name": str,
+        "slot_type": str,
+        Optional("children"): [device_schema],
+        Optional("bus_masters"): {
+            Optional("i2c"): dict,
+        },
+    }
+)
+
+
+def deserialize_module(logger: logging.Logger, data: dict) -> tuple[str, str, str]:
+    """
+    docstring
+    """
+    module_schema.validate(data)
+
+    id, name, slot_type = (data[key] for key in ["id", "name", "slot_type"])
+    logger.debug(colored(f"Importing top level module {pformat(name)}", "green"))
+
+    return id, name, slot_type
+
+
+def deserialize_hardware_tree(
+    logger: logging.Logger, data: dict, parent: "HWModule"
+) -> list["Device"]:
+    abort = parent.abort
 
-    return id, name, slot_type, devices
+    module_schema.validate(data)
+
+    children = data.pop("children", None)
+    if not children:
+        return []
+
+    devices = []
+    for child in children:
+        try:
+            logger.debug(
+                colored(f"Importing top level device {pformat(child)}", "green")
+            )
+
+            node = import_board(logger, child, parent=parent, abort=abort)
+            devices.append(node)
+        except Exception as e:
+            logger.error(
+                colored(
+                    f"Failed to import top-level device {pformat(child)}: {e}", "red"
+                )
+            )
+            logger.error(colored("Aborting." if abort else "Continuing anyway", "red"))
+            if abort:
+                raise
+
+    return devices

ekfsm/devices/__init__.py

@@ -1,13 +1,23 @@
-from ekfsm.devices.generic import Device
 from ekfsm.devices.coretemp import CoreTemp
+from ekfsm.devices.generic import Device
 from ekfsm.devices.smbios import SMBIOS
-from .eeprom import EEPROM, EKF_EEPROM, EKF_CCU_EEPROM
-from .pmbus import PmBus, PsuStatus
-from .gpio import GPIO, EKFIdentificationIOExpander, GPIOExpander
-from .ekf_sur_led import EKFSurLed
+from ekfsm.devices.thermal_humidity import ThermalHumidity
+
+from .eeprom import EEPROM, EKF_CCU_EEPROM, EKF_EEPROM
 from .ekf_ccu_uc import EKFCcuUc
+from .ekf_sur_led import EKFSurLed
+from .gpio import GPIO, EKFIdentificationIOExpander, GPIOExpander
 from .iio_thermal_humidity import IIOThermalHumidity
 from .mux import I2CMux, MuxChannel
+from .pmbus import PMBus, PSUStatus
+from .io4edge import IO4Edge, GPIOArray
+from .pixelDisplay import PixelDisplay
+from .buttons import ButtonArray
+from .buttons import Button
+from .colorLed import ColorLED
+from .ledArray import LEDArray
+from .watchdog import Watchdog
+from .toggles import BinaryToggle
 
 CLASS_MAP = {
     "GenericDevice": Device,
@@ -20,10 +30,20 @@ CLASS_MAP = {
     "EKF_EEPROM": EKF_EEPROM,
     "EKF_CCU_EEPROM": EKF_CCU_EEPROM,
     "EKFCcuUc": EKFCcuUc,
-    "PmBus": PmBus,
-    "PsuStatus": PsuStatus,
+    "PMBus": PMBus,
+    "PSUStatus": PSUStatus,
     "SMBIOS": SMBIOS,
     "HWMON": CoreTemp,
     "EKFSurLed": EKFSurLed,
     "IIOThermalHumidity": IIOThermalHumidity,
+    "ThermalHumidity": ThermalHumidity,
+    "IO4Edge": IO4Edge,
+    "PixelDisplay": PixelDisplay,
+    "ButtonArray": ButtonArray,
+    "Button": Button,
+    "ColorLED": ColorLED,
+    "LEDArray": LEDArray,
+    "Watchdog": Watchdog,
+    "GPIOArray": GPIOArray,
+    "BinaryToggle": BinaryToggle,
 }