pytest-libiio 0.0.22__py3-none-any.whl

pytest_libiio/__init__.py

@@ -0,0 +1,3 @@
+"""A pytest plugin for managing libiio contexts."""
+
+__version__ = "0.0.22"

pytest_libiio/coverage.py

@@ -0,0 +1,192 @@
+"""Coverage tracking for iio attributes using monkey patching."""
+
+import json
+import os
+from pprint import pprint
+
+import iio
+
+
+class MultiContextTracker:
+    """Class to track coverage across multiple DUTs."""
+
+    def __init__(self):
+        self.trackers = {}
+        self.track_debug_props = False
+        self.results_folder = "iio_coverage_results"
+
+    def do_monkey_patch(self):
+        """Apply monkey patch to iio.py."""
+        from . import mkpatch
+        from .mkpatch import reset_coverage_tracker
+
+        reset_coverage_tracker()
+
+    def add_instance(self, name, uri):
+        """Add a new context to track.
+
+        Args:
+            name (str): Name of the context. Just a label, not used in iio.
+            uri (str): URI of the context.
+        """
+        if uri not in self.trackers:
+            self.trackers[name] = CoverageTracker(name, uri, self.track_debug_props)
+
+    def set_tracker(self, name):
+        from .mkpatch import set_coverage_tracker
+
+        if name not in self.trackers:
+            raise ValueError(f"{name} not tracked.")
+
+        set_coverage_tracker(tracker=self.trackers[name])
+
+
+class CoverageTracker:
+    """Class to track coverage of iio attributes."""
+
+    def __init__(self, name, uri, track_debug_props=False, results_folder=None):
+        self.name = name
+        self.context_attr_reads_writes = {}
+        self.device_attr_reads_writes = {}
+        self.channel_attr_reads_writes = {}
+        self.debug_attr_reads_writes = {}
+        self.uri = uri
+        self.ctx = iio.Context(uri)
+        self.track_debug_props = track_debug_props
+        self.results_folder = results_folder or "iio_coverage_results"
+        self.build_context_map()
+
+    def reset(self):
+        """Reset the coverage tracker."""
+        self.context_attr_reads_writes.clear()
+        self.device_attr_reads_writes.clear()
+        self.channel_attr_reads_writes.clear()
+        self.debug_attr_reads_writes.clear()
+
+    def build_context_map(self):
+        """Build a map of context attributes."""
+        self.context_attr_reads_writes = {attr: 0 for attr in self.ctx.attrs}
+        for dev in self.ctx.devices:
+            self.device_attr_reads_writes[dev.name] = {attr: 0 for attr in dev.attrs}
+            self.channel_attr_reads_writes[dev.name] = {
+                chn.id: {attr: 0 for attr in chn.attrs} for chn in dev.channels
+            }
+            if self.track_debug_props:
+                self.debug_attr_reads_writes[dev.name] = {
+                    attr: 0 for attr in dev.debug_attrs
+                }
+
+    def export(self):
+        """Export raw coverage data."""
+        out = {
+            "context_attr_reads_writes": self.context_attr_reads_writes,
+            "device_attr_reads_writes": self.device_attr_reads_writes,
+            "channel_attr_reads_writes": self.channel_attr_reads_writes,
+        }
+        if self.track_debug_props:
+            out["debug_attr_reads_writes"] = self.debug_attr_reads_writes
+        return out
+
+    def export_to_file(self, filename=None):
+        """Export coverage data to a file.
+
+        Args:
+            filename (str, optional): Name of the file to save the coverage data.
+            If None, defaults to "{self.name}_coverage.json".
+        """
+        if filename is None:
+            filename = f"{self.name}_coverage.json"
+        if not os.path.exists(self.results_folder):
+            os.makedirs(self.results_folder)
+        filename = os.path.join(os.getcwd(), self.results_folder, filename)
+        with open(filename, "w") as f:
+            json.dump(self.export(), f, indent=4)
+        print(f"Coverage data exported to {filename}")
+
+    def print_context_map(self):
+        print("Context Attribute Reads:")
+        pprint(self.context_attr_reads_writes)
+        print("Device Attribute Reads:")
+        pprint(self.device_attr_reads_writes)
+        print("Channel Attribute Reads:")
+        pprint(self.channel_attr_reads_writes)
+        if self.track_debug_props:
+            print("Debug Attribute Reads:")
+            pprint(self.debug_attr_reads_writes)
+
+    def calculate_coverage(self):
+        """Calculate coverage based on attribute reads and writes."""
+
+        total_context_reads_writes = sum(self.context_attr_reads_writes.values())
+        total_context_attributes = len(self.context_attr_reads_writes)
+
+        total_device_reads_writes = sum(
+            sum(device.values()) for device in self.device_attr_reads_writes.values()
+        )
+        total_device_attributes = sum(
+            len(device) for device in self.device_attr_reads_writes.values()
+        )
+        if self.track_debug_props:
+            total_debug_reads_writes = sum(
+                self.debug_attr_reads_writes[dev].values()
+                for dev in self.debug_attr_reads_writes
+            )
+            total_device_attributes = sum(
+                len(self.debug_attr_reads_writes[dev])
+                for dev in self.debug_attr_reads_writes
+            )
+
+        total_channel_reads_writes = 0
+        total_channel_attributes = 0
+        for device in self.channel_attr_reads_writes:
+            for channel in self.channel_attr_reads_writes[device]:
+                total_channel_reads_writes += sum(
+                    self.channel_attr_reads_writes[device][channel].values()
+                )
+                total_channel_attributes += len(
+                    self.channel_attr_reads_writes[device][channel]
+                )
+
+        out = {
+            "context_coverage": (
+                total_context_reads_writes / total_context_attributes
+                if total_context_attributes
+                else 0
+            ),
+            "device_coverage": (
+                total_device_reads_writes / total_device_attributes
+                if total_device_attributes
+                else 0
+            ),
+            "channel_coverage": (
+                total_channel_reads_writes / total_channel_attributes
+                if total_channel_attributes
+                else 0
+            ),
+            "total_coverage": (
+                total_context_reads_writes
+                + total_device_reads_writes
+                + total_channel_reads_writes
+            )
+            / (
+                total_context_attributes
+                + total_device_attributes
+                + total_channel_attributes
+            ),
+            "total_context_reads_writes": total_context_reads_writes,
+            "total_device_reads_writes": total_device_reads_writes,
+            "total_channel_reads_writes": total_channel_reads_writes,
+            "total_context_attributes": total_context_attributes,
+            "total_device_attributes": total_device_attributes,
+            "total_channel_attributes": total_channel_attributes,
+        }
+
+        if self.track_debug_props:
+            out["total_debug_reads_writes"] = total_debug_reads_writes
+            out["total_debug_attributes"] = total_device_attributes
+            out["debug_coverage"] = (
+                total_debug_reads_writes / total_device_attributes
+                if total_device_attributes
+                else 0
+            )
+        return out

pytest_libiio/meta.py

@@ -0,0 +1,255 @@
+"""This is a set of function to help extract metadata from tests and hardware"""
+
+import os
+import re
+import xml.etree.ElementTree as ET
+from io import BytesIO, StringIO
+from pprint import pprint
+
+import iio
+
+import lxml.etree as etree
+
+try:
+    import paramiko
+
+    useSSH = True
+except ImportError:
+    useSSH = False
+
+
+def __get_value_from_hw(
+    ctx, attrib, ptype, attr_name, dev_name=None, ch_name=None, is_output=False
+):
+    if "value" in attrib:
+        value = attrib["value"]
+    else:
+        if ptype == "context":
+            value = ctx.attrs[attr_name].value
+        elif ptype == "device":
+            dev = ctx.find_device(str(dev_name))
+            try:
+                value = dev.attrs[attr_name].value
+            except OSError:
+                value = "ERROR"
+        elif ptype == "channel":
+            dev = ctx.find_device(str(dev_name))
+            ch = dev.find_channel(str(ch_name), is_output)
+            if hasattr(ch, "attrs") and attr_name in ch.attrs:
+                try:
+                    value = ch.attrs[attr_name].value
+                except OSError:
+                    value = "ERROR"
+            else:
+                value = "NO ATTRS FOR CHANNEL"
+        elif ptype == "debug":
+            dev = ctx.find_device(str(dev_name))
+            try:
+                value = dev.debug_attrs[attr_name].value
+            except OSError:
+                value = "ERROR"
+        elif ptype == "buffer":
+            dev = ctx.find_device(str(dev_name))
+            try:
+                value = dev.buffer_attrs[attr_name].value
+            except OSError:
+                value = "ERROR"
+        else:
+            raise Exception("Unknown property type")
+
+    return value
+
+
+def __get_name_id(item):
+    return item.attrib["name"] if "name" in item.attrib else item.attrib["id"]
+
+
+def dprint(*args, **kwargs):
+    """Debug print"""
+    if os.environ.get("DEBUG"):
+        print(*args, **kwargs)
+
+
+def get_emulated_context(ctx: iio.Context):
+    cxml = ctx.xml
+    cxml = str(cxml)
+
+    # Convert string to xml
+    root = ET.fromstring(cxml)
+
+    context_fields = list(root.attrib.keys())
+
+    # loop through items
+    for item in root:
+        if item.tag == "context-attribute":
+            dprint("Context-attribute---")
+            attr_name_id = __get_name_id(item)
+            value = __get_value_from_hw(ctx, item.attrib, "context", attr_name_id)
+            dprint("CONTEXT", attr_name_id, value)
+            item.attrib["value"] = value
+        elif item.tag == "device":
+            dprint("Device---")
+            device_name_id = __get_name_id(item)
+            # Devices
+            for sitem in item:
+                attr_name_id = __get_name_id(sitem)
+                # Device attributes
+                if sitem.tag == "attribute":
+                    value = __get_value_from_hw(
+                        ctx, sitem.attrib, "device", attr_name_id, device_name_id
+                    )
+                    dprint("DEVICE", device_name_id, attr_name_id, value)
+                    sitem.attrib["value"] = value
+                # Channel attributes
+                elif sitem.tag == "channel":
+                    channel_name_id = attr_name_id
+                    if sitem.attrib["type"] == "output":
+                        is_output = True
+                    elif sitem.attrib["type"] == "input":
+                        is_output = False
+                    else:
+                        raise Exception("Unknown channel type")
+                    for ssitem in sitem:
+                        if ssitem.tag == "scan-element":
+                            continue  # FIXME
+                        channel_attr_name_id = __get_name_id(ssitem)
+                        value = __get_value_from_hw(
+                            ctx,
+                            ssitem.attrib,
+                            "channel",
+                            channel_attr_name_id,
+                            device_name_id,
+                            channel_name_id,
+                            is_output,
+                        )
+                        dprint(
+                            "CHANNEL",
+                            device_name_id,
+                            channel_name_id,
+                            is_output,
+                            channel_attr_name_id,
+                            value,
+                        )
+                        ssitem.attrib["value"] = value
+
+                elif sitem.tag == "debug-attribute":
+                    value = __get_value_from_hw(
+                        ctx, sitem.attrib, "debug", attr_name_id, device_name_id
+                    )
+                    dprint("DEBUG", device_name_id, attr_name_id, value)
+                    sitem.attrib["value"] = value
+
+                elif sitem.tag == "buffer-attribute":
+                    value = __get_value_from_hw(
+                        ctx, sitem.attrib, "buffer", attr_name_id, device_name_id
+                    )
+                    dprint("BUFFER", device_name_id, attr_name_id, value)
+                    sitem.attrib["value"] = value
+                else:
+                    raise Exception("Unknown device item")
+        else:
+            raise Exception("Unknown item")
+
+    # Update context ATTLIST of DOCTYPE to include all context fields
+    context_fields += ["description"]
+    context_fields = list(set(context_fields))
+    template = "<!ATTLIST context "
+    context_fields_list = [
+        f"{field.replace(',','').replace(' ','_')} CDATA #IMPLIED "
+        for field in context_fields
+    ]
+    full = template + "".join(context_fields_list)
+    full = f"{full[:-1]}>"
+
+    doctype = f"<!DOCTYPE context [\n\
+        <!ELEMENT context (device | context-attribute)*>\n\
+        <!ELEMENT context-attribute EMPTY>\n\
+        <!ELEMENT device (channel | attribute | debug-attribute | buffer-attribute)*>\n\
+        <!ELEMENT channel (scan-element?, attribute*)>\n\
+        <!ELEMENT attribute EMPTY><!ELEMENT scan-element EMPTY>\n\
+        <!ELEMENT debug-attribute EMPTY>\n\
+        <!ELEMENT buffer-attribute EMPTY>\n\
+        {full}\n\
+        <!ATTLIST context-attribute name CDATA #REQUIRED value CDATA #REQUIRED>\n\
+        <!ATTLIST device id CDATA #REQUIRED name CDATA #IMPLIED>\n\
+        <!ATTLIST channel id CDATA #REQUIRED type (input|output) #REQUIRED name CDATA #IMPLIED>\n\
+        <!ATTLIST scan-element index CDATA #REQUIRED format CDATA #REQUIRED scale CDATA #IMPLIED>\n\
+        <!ATTLIST attribute name CDATA #REQUIRED filename CDATA #IMPLIED value CDATA #IMPLIED>\n\
+        <!ATTLIST debug-attribute name CDATA #REQUIRED value CDATA #IMPLIED>\n\
+        <!ATTLIST buffer-attribute name CDATA #REQUIRED value CDATA #IMPLIED>\n\
+    ]>"
+
+    xml_str = ET.tostring(root, encoding="unicode")
+
+    tree = etree.parse(StringIO(xml_str))
+    xml_str = etree.tostring(
+        tree, pretty_print=True, xml_declaration=True, doctype=doctype, encoding="utf-8"
+    )
+    xml_str = str(xml_str, "utf-8")  # type: ignore
+    return xml_str
+
+
+def get_ssh_session(ctx: iio.Context):
+    """Get ssh session"""
+    uri = ctx.attrs["uri"].split(":")
+    if not useSSH:
+        print("Paramiko is not installed, cannot use SSH")
+        return None
+    if uri[0] == "ip":
+        print(f"Starting SSH session for uri: {ctx.attrs['uri']}")
+        ip = uri[1]
+        ssh = paramiko.SSHClient()
+        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy)
+        ssh.connect(ip, username="root", password="analog")
+        return ssh
+    else:
+        print(f"URI: {ctx.attrs['uri']} is not supported for SSH telemetry")
+        return None
+
+
+def get_hardware_info(ctx: iio.Context, ssh=None):
+    """Get hardware information from the context"""
+    local = {}
+    remote = {}
+
+    local["libiio"] = iio.version
+
+    # Get context xml and values from HW
+    remote["iio_context"] = get_emulated_context(ctx)
+
+    # Get telemetry data from remote linux system
+    uri = ctx.attrs["uri"].split(":")
+    if uri[0] == "ip" and ssh is not None:
+        stdin, stdout, stderr = ssh.exec_command("dmesg")
+        remote["dmesg"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("uname -a")
+        remote["uname"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("cat /proc/cpuinfo")
+        remote["cpuinfo"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("cat /proc/meminfo")
+        remote["meminfo"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("cat /proc/version")
+        remote["version"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("cat /etc/os-release")
+        remote["os-release"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("df -h")
+        remote["df"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command(
+            'python -c "import iio; print(iio.version)"'
+        )
+        remote["libiio"] = stdout.read().decode()
+        stdin, stdout, stderr = ssh.exec_command("iio_info")
+        remote["iio_info"] = stdout.read().decode()
+        # ssh.close()
+
+    metadata = {}
+    metadata["local"] = local
+    metadata["remote"] = remote
+
+    return metadata
+
+
+if __name__ == "__main__":
+    ctx = iio.Context("ip:analog.local")
+    # root = get_hardware_info(ctx)
+    root = get_emulated_context(ctx)

pytest_libiio/mkpatch.py

@@ -0,0 +1,113 @@
+import logging
+from pprint import pprint
+
+import iio
+from iio import ChannelAttr as _Attr
+
+logger = logging.getLogger(__name__)
+
+coverage_tracker = None
+
+
+def _check_tracker():
+    """Check if the coverage tracker is set."""
+    global coverage_tracker  # noqa: F824
+    if coverage_tracker is None:
+        raise RuntimeError(
+            "Coverage tracker is not set. Call set_coverage_tracker first."
+        )
+
+
+def _read(self):
+    """MP Read method to capture attribute reads"""
+    attr_name = self.name
+    if self._channel:
+        name_raw = iio._c_get_id(self._channel)
+        channel_name = name_raw.decode("ascii") if name_raw is not None else None
+        dev_ptr = iio._channel_get_device(self._channel)
+        name_raw = iio._d_get_name(dev_ptr)
+        device_name = name_raw.decode("ascii") if name_raw is not None else None
+    else:
+        channel_name = None
+        device_name = self._name
+
+    _check_tracker()
+
+    global coverage_tracker  # noqa: F824
+    if channel_name and device_name:
+        coverage_tracker.channel_attr_reads_writes[device_name][channel_name][
+            attr_name
+        ] += 1
+    elif device_name:
+        coverage_tracker.device_attr_reads_writes[device_name][attr_name] += 1
+    else:
+        coverage_tracker.context_attr_reads_writes[attr_name] += 1
+
+    logger.debug(
+        f"Reading attribute: {attr_name}, Channel: {channel_name}, Device: {device_name}"
+    )
+    return self._read_org()
+
+
+def _write(self, value):
+    """MP Write method to capture attribute writes"""
+    attr_name = self.name
+    if self._channel:
+        name_raw = iio._c_get_id(self._channel)
+        channel_name = name_raw.decode("ascii") if name_raw is not None else None
+        dev_ptr = iio._channel_get_device(self._channel)
+        name_raw = iio._d_get_name(dev_ptr)
+        device_name = name_raw.decode("ascii") if name_raw is not None else None
+    else:
+        channel_name = None
+        device_name = self._name
+
+    _check_tracker()
+
+    global coverage_tracker  # noqa: F824
+    if channel_name and device_name:
+        coverage_tracker.channel_attr_reads_writes[device_name][channel_name][
+            attr_name
+        ] += 1
+    elif device_name:
+        coverage_tracker.device_attr_reads_writes[device_name][attr_name] += 1
+    else:
+        coverage_tracker.context_attr_reads_writes[attr_name] += 1
+
+    logger.debug(
+        f"Writing attribute: {attr_name}, Channel: {channel_name}, Device: {device_name}, Value: {value}"
+    )
+    self._write_org(value)
+
+
+_Attr._read_org = _Attr._read
+_Attr._read = _read
+
+_Attr._write_org = _Attr._write
+_Attr._write = _write
+
+
+def set_coverage_tracker(tracker):
+    """Set up the coverage tracker for iio attributes."""
+    global coverage_tracker
+
+    coverage_tracker = tracker
+
+
+def reset_coverage_tracker():
+    """Reset the coverage tracker."""
+    global coverage_tracker
+    coverage_tracker = None
+
+
+def unset_monkey_patch():
+    """Unset the monkey patch for iio attributes."""
+    global coverage_tracker
+    if coverage_tracker:
+        coverage_tracker = None
+
+    _Attr._read = _Attr._read_org
+    _Attr._write = _Attr._write_org
+
+
+logger.debug("iio.py monkey patch applied")