ekfsm 1.1.0a15.post1__py3-none-any.whl → 1.3.0__py3-none-any.whl

ekfsm/boards/oem/hitron/hdrc-300s.yaml

@@ -2,7 +2,7 @@ id: HDRC300S.*
 name: "Hitron HDRC-300S"
 slot_type: CPCI_S0_PSU
 children:
-    - device_type: PmBus
+    - device_type: PMBus
       name: "PMBUS"
       addr: 0x18
       slot_coding_mask: 0x07

ekfsm/cli.py

@@ -1,15 +1,15 @@
 #! /usr/bin/env python3
 # import os
 # import sys
-import click
+# pyright: reportOptionalMemberAccess = false
 import logging
 from pathlib import Path
 
-from ekfsm.system import System
-from ekfsm.log import ekfsm_logger
-from ekfsm.simctrl import enable_simulation
-from ekfsm.simctrl import register_gpio_simulations
+import click
 
+from ekfsm.log import ekfsm_logger
+from ekfsm.simctrl import enable_simulation, register_gpio_simulations
+from ekfsm.system import System
 
 logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
 logger = ekfsm_logger(__name__)
@@ -87,9 +87,7 @@ def cli(verbose, debug, sysfs, config):
     type=int,
     help="Write chassis serial number",
 )
-@click.option(
-    "--unit", "-u", is_flag=False, prompt=True, type=int, help="Write chassis unit"
-)
+@click.option("--unit", "-u", is_flag=False, prompt=True, type=int, help="Write chassis unit")
 @click.option(
     "--vendor",
     "-n",

ekfsm/config.py

@@ -1,8 +1,10 @@
+from typing import Any, List, Tuple
+
+import munch
 import yamale  # type: ignore
 import yaml
-import munch
 
-from typing import Any, List, Tuple
+from ekfsm.exceptions import ConfigError
 
 schema_str = """
 system_config:
@@ -22,13 +24,19 @@ slot:
 def _validate_config(config_file: str) -> None:
     schema = yamale.make_schema(content=schema_str)
     data = yamale.make_data(config_file)
-    yamale.validate(schema, data)
+    try:
+        yamale.validate(schema, data)
+    except yamale.YamaleError:
+        raise ConfigError("Error in configuration file")
 
 
 def _parse_config(config_file: str) -> Any | munch.Munch | List | Tuple:
-    with open(config_file) as file:
-        config = yaml.safe_load(file)
-        munchified_config = munch.munchify(config)
+    try:
+        with open(config_file) as file:
+            config = yaml.safe_load(file)
+            munchified_config = munch.munchify(config)
+    except OSError:
+        raise ConfigError("Failed to open configuration file: {config_file}")
     return munchified_config
 
 

ekfsm/core/__init__.py

@@ -1,14 +1,14 @@
-from .slots import Slot, SlotType, Slots  # noqa: F401
-from .sysfs import SysFSDevice, SysFSAttribute  # noqa: F401
-from .components import HwModule  # noqa: F401
+from .components import HWModule  # noqa: F401
 from .probe import ProbeableDevice  # noqa: F401
+from .slots import Slot, Slots, SlotType  # noqa: F401
+from .sysfs import SysFSAttribute, SysfsDevice  # noqa: F401
 
 __all__ = [
     "Slot",
     "SlotType",
     "Slots",
-    "SysFSDevice",
+    "SysfsDevice",
     "SysFSAttribute",
-    "HwModule",
+    "HWModule",
     "ProbeableDevice",
 ]

ekfsm/core/components.py

@@ -36,9 +36,9 @@ class SysTree(NodeMixin):
         print(self)
 
 
-class HwModule(SysTree):
+class HWModule(SysTree):
     """
-    A HwModule represents an instantiation of a specifc hw board type,
+    A HWModule represents an instantiation of a specifc hw board type,
     for example an instance of an EKF SC9 board.
     """
 
@@ -119,13 +119,13 @@ class HwModule(SysTree):
     @property
     def instance_name(self) -> str:
         if self.name is None:
-            raise RuntimeError("instance name not set")
+            raise RuntimeError("Instance name not set")
         return self.name
 
     @property
     def slot(self) -> Slot:
         if self._slot is None:
-            raise RuntimeError("slot not set")
+            raise RuntimeError("Slot not set")
         return self._slot
 
     def __repr__(self) -> str:

ekfsm/core/slots.py

@@ -1,11 +1,9 @@
 from enum import Enum
-from ekfsm.core.components import HwModule
-
+from typing import Any
 
 from munch import Munch
 
-
-from typing import Any
+from ekfsm.core.components import HWModule
 
 
 class SlotType(Enum):
@@ -66,8 +64,8 @@ class Slot:
         desired_hwmodule_type: str,
         desired_hwmodule_name: str,
         number: int,
-        hwmodule: HwModule | None = None,
-        master: HwModule | None = None,
+        hwmodule: HWModule | None = None,
+        master: HWModule | None = None,
         attributes: Munch | None = None,
     ) -> None:
         self._name = name
@@ -104,9 +102,7 @@ class Slot:
         }
 
     def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}(name={self._name}, slot_type={self.slot_type})"
-        )
+        return f"{self.__class__.__name__}(name={self._name}, slot_type={self.slot_type})"
 
     @property
     def name(self) -> str:
@@ -127,10 +123,7 @@ class Slot:
         """
         Return True if the slot is populated with the desired hardware module type, False otherwise.
         """
-        return (
-            self.hwmodule is not None
-            and self.hwmodule.board_type.lower() == self._desired_hwmodule_type.lower()
-        )
+        return self.hwmodule is not None and self.hwmodule.board_type.lower() == self._desired_hwmodule_type.lower()
 
 
 class Slots(Munch):

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,31 +26,41 @@ class SysFSAttribute:
     """
     A SysFSAttribute is a singular sysfs attribute located somewhere in */sys*.
 
-    Attributes
+    Parameters
     ----------
-    path
+    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)
+            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)
@@ -60,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
@@ -71,11 +122,130 @@ 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 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, 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 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,132 @@
 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_board(logger: logging.Logger, data, parent=None, abort: bool = False):
+    from .components import HWModule
 
-    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)
+    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(self, 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}")
+    if provides := data.get("provides"):
+        for p in provides:
+            interfaces = data["provides"][p]
 
-        children = data.pop("children", [])
-        if parent is not None and isinstance(parent, HwModule):
-            # ???
-            pass
+            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")
 
-        node = nodecls(parent=parent, **data)
+    node = nodecls(parent=parent, abort=abort, **data)
 
-        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 children is not None:
+        for child in children:
+            try:
+                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 sub device {pformat(child)}: {e}. Aborting.")
+                    raise e
+                else:
+                    logger.error(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("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_hardware_tree(
-    logger: logging.Logger, data: dict, parent: "HwModule"
+    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`")
+    module_schema.validate(data)
+
+    id, name, slot_type = (data.pop(key) for key in ["id", "name", "slot_type"])
 
     children = data.pop("children", None)
+    if not children:
+        return id, name, slot_type, []
+
     devices = []
-    if children:
-        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)
-            except Exception as e:
-                if abort:
-                    logger.error(
-                        f"Failed to import top level device {child}: {e}. aborting"
-                    )
-                    raise e
-                else:
-                    logger.error(
-                        f"Failed to import top level device {child}: {e}. continue anyway"
-                    )
+    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 id, name, slot_type, devices

ekfsm/devices/__init__.py

@@ -1,13 +1,14 @@
-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 .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
 
 CLASS_MAP = {
     "GenericDevice": Device,
@@ -20,8 +21,8 @@ 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,