Fix for pdoc

Author: Steve-Tech

cros_ec_python/devices/lpc.py

@@ -15,14 +15,19 @@ class CrosEcLpc(CrosEcClass):
     Class to interact with the EC using the LPC interface.
     """
 
-    def __init__(self, init: bool = True, address: Int32 = None, portio: PortIO = PortIO()):
+    def __init__(
+        self, init: bool = True, address: Int32 = None, portio: PortIO | None = None
+    ):
         """
         Detect and initialise the EC.
         :param init: Whether to initialise the EC on creation. Default is True.
         :param address: Specify a custom memmap address, will be detected if not specified.
         :param portio: PortIO object to use. Default is auto-detected.
         """
 
+        if portio is None:
+            portio = PortIO()
+
         self.portio: PortIO = portio
         """PortIO object to use."""
 
@@ -39,7 +44,10 @@ def detect() -> bool:
         """
         with open("/proc/ioports", "r") as f:
             for line in f:
-                if line.lstrip()[:4] in (format(EC_LPC_ADDR_MEMMAP, "04x"), format(EC_LPC_ADDR_MEMMAP_FWAMD, "04x")):
+                if line.lstrip()[:4] in (
+                    format(EC_LPC_ADDR_MEMMAP, "04x"),
+                    format(EC_LPC_ADDR_MEMMAP_FWAMD, "04x"),
+                ):
                     return True
 
     @staticmethod
@@ -53,10 +61,12 @@ def find_address(*addresses, portio: PortIO = PortIO()) -> int | None:
             if res := portio.ioperm(a, EC_MEMMAP_SIZE, True):
                 if res == errno.EPERM:
                     raise PermissionError("Permission denied. Try running as root.")
-                warnings.warn(f"ioperm returned {errno.errorcode[res]} ({res}), skipping address {a}...")
+                warnings.warn(
+                    f"ioperm returned {errno.errorcode[res]} ({res}), skipping address {a}..."
+                )
                 continue
             # Check for 'EC' in memory map
-            if portio.inw(a + EC_MEMMAP_ID) == int.from_bytes(b'EC', "little"):
+            if portio.inw(a + EC_MEMMAP_ID) == int.from_bytes(b"EC", "little"):
                 # Found it!
                 return a
             else:
@@ -71,15 +81,23 @@ def ec_init(self) -> None:
         """
         # Find memmap address
         if self.address is None:
-            self.address = self.find_address(EC_LPC_ADDR_MEMMAP, EC_LPC_ADDR_MEMMAP_FWAMD, portio=self.portio)
+            self.address = self.find_address(
+                EC_LPC_ADDR_MEMMAP, EC_LPC_ADDR_MEMMAP_FWAMD, portio=self.portio
+            )
             # find_address will leave ioperm enabled for the memmap
             if self.address is None:
                 raise OSError("Could not find EC!")
 
         # Request I/O permissions
-        if (res := self.portio.ioperm(EC_LPC_ADDR_HOST_DATA, EC_MEMMAP_SIZE, True)) or \
-                (res := self.portio.ioperm(EC_LPC_ADDR_HOST_CMD, EC_MEMMAP_SIZE, True)) or \
-                (res := self.portio.ioperm(EC_LPC_ADDR_HOST_PACKET, EC_LPC_HOST_PACKET_SIZE, True)):
+        if (
+            (res := self.portio.ioperm(EC_LPC_ADDR_HOST_DATA, EC_MEMMAP_SIZE, True))
+            or (res := self.portio.ioperm(EC_LPC_ADDR_HOST_CMD, EC_MEMMAP_SIZE, True))
+            or (
+                res := self.portio.ioperm(
+                    EC_LPC_ADDR_HOST_PACKET, EC_LPC_HOST_PACKET_SIZE, True
+                )
+            )
+        ):
             if res == errno.EPERM:
                 raise PermissionError("Permission denied. Try running as root.")
             else:
@@ -95,7 +113,9 @@ def ec_init(self) -> None:
             raise OSError("No EC detected. Invalid status.")
 
         # Check for 'EC' in memory map
-        if self.portio.inw(self.address + EC_MEMMAP_ID) != int.from_bytes(b'EC', "little"):
+        if self.portio.inw(self.address + EC_MEMMAP_ID) != int.from_bytes(
+            b"EC", "little"
+        ):
             raise OSError("Invalid EC signature.")
 
         self.ec_get_cmd_version()
@@ -111,8 +131,15 @@ def wait_for_ec(self, status_addr: Int32 = EC_LPC_ADDR_HOST_CMD) -> None:
         while self.portio.inb(status_addr) & EC_LPC_STATUS_BUSY_MASK:
             pass
 
-    def ec_command_v2(self, version: UInt8, command: UInt32, outsize: UInt16, insize: UInt32, data: bytes = None,
-                      warn: bool = True):
+    def ec_command_v2(
+        self,
+        version: UInt8,
+        command: UInt32,
+        outsize: UInt16,
+        insize: UInt32,
+        data: bytes = None,
+        warn: bool = True,
+    ):
         """
         Send a command to the EC and return the response. Uses the v2 command protocol over LPC. UNTESTED!
         :param version: Command version number (often 0).
@@ -123,10 +150,15 @@ def ec_command_v2(self, version: UInt8, command: UInt32, outsize: UInt16, insize
         :param warn: Whether to warn if the response size is not as expected. Default is True.
         :return: Response from the EC.
         """
-        warnings.warn("Support for v2 commands haven't been tested! Open an issue on github if it does "
-                      "or doesn't work: https://github.com/Steve-Tech/CrOS_EC_Python/issues", RuntimeWarning)
+        warnings.warn(
+            "Support for v2 commands haven't been tested! Open an issue on github if it does "
+            "or doesn't work: https://github.com/Steve-Tech/CrOS_EC_Python/issues",
+            RuntimeWarning,
+        )
         csum = 0
-        args = bytearray(struct.pack("BBBB", EC_HOST_ARGS_FLAG_FROM_HOST, version, outsize, csum))
+        args = bytearray(
+            struct.pack("BBBB", EC_HOST_ARGS_FLAG_FROM_HOST, version, outsize, csum)
+        )
         # (flags: UInt8, command_version: UInt8, data_size: UInt8, checksum: UInt8)
 
         # Copy data and start checksum
@@ -138,7 +170,7 @@ def ec_command_v2(self, version: UInt8, command: UInt32, outsize: UInt16, insize
         for i in range(len(args)):
             csum += args[i]
 
-        args[3] = csum & 0xff
+        args[3] = csum & 0xFF
 
         # Copy header
         for i in range(len(args)):
@@ -168,21 +200,31 @@ def ec_command_v2(self, version: UInt8, command: UInt32, outsize: UInt16, insize
             raise IOError("Invalid response!")
 
         if response[2] != insize and warn:
-            warnings.warn(f"Expected {insize} bytes, got {response[2]} back from EC", RuntimeWarning)
+            warnings.warn(
+                f"Expected {insize} bytes, got {response[2]} back from EC",
+                RuntimeWarning,
+            )
 
         # Read back data
         data = bytearray()
         for i in range(response[2]):
             data.append(self.portio.inb(EC_LPC_ADDR_HOST_PARAM + i))
             csum += data[i]
 
-        if response[3] != (csum & 0xff):
+        if response[3] != (csum & 0xFF):
             raise IOError("Checksum error!")
 
         return bytes(data)
 
-    def ec_command_v3(self, version: UInt8, command: UInt32, outsize: UInt16, insize: UInt32, data: bytes = None,
-                      warn: bool = True) -> bytes:
+    def ec_command_v3(
+        self,
+        version: UInt8,
+        command: UInt32,
+        outsize: UInt16,
+        insize: UInt32,
+        data: bytes = None,
+        warn: bool = True,
+    ) -> bytes:
         """
         Send a command to the EC and return the response. Uses the v3 command protocol over LPC.
         :param version: Command version number (often 0).
@@ -194,7 +236,11 @@ def ec_command_v3(self, version: UInt8, command: UInt32, outsize: UInt16, insize
         :return: Response from the EC.
         """
         csum = 0
-        request = bytearray(struct.pack("BBHBxH", EC_HOST_REQUEST_VERSION, csum, command, version, outsize))
+        request = bytearray(
+            struct.pack(
+                "BBHBxH", EC_HOST_REQUEST_VERSION, csum, command, version, outsize
+            )
+        )
         # (struct_version: UInt8, checksum: UInt8, command: UInt16,
         # command_version: UInt8, reserved: UInt8, data_len: UInt16)
 
@@ -211,7 +257,7 @@ def ec_command_v3(self, version: UInt8, command: UInt32, outsize: UInt16, insize
         for i in range(len(request)):
             csum += request[i]
 
-        request[1] = (-csum) & 0xff
+        request[1] = (-csum) & 0xFF
 
         # Copy header
         for i in range(len(request)):
@@ -245,15 +291,18 @@ def ec_command_v3(self, version: UInt8, command: UInt32, outsize: UInt16, insize
             raise IOError("Invalid response!")
 
         if response[3] != insize and warn:
-            warnings.warn(f"Expected {insize} bytes, got {response[3]} back from EC", RuntimeWarning)
+            warnings.warn(
+                f"Expected {insize} bytes, got {response[3]} back from EC",
+                RuntimeWarning,
+            )
 
         # Read back data
         data = bytearray()
         for i in range(response[3]):
             data.append(self.portio.inb(EC_LPC_ADDR_HOST_PACKET + len(data_out) + i))
             csum += data[i]
 
-        if csum & 0xff:
+        if csum & 0xFF:
             raise IOError("Checksum error!")
 
         return bytes(data)

cros_ec_python/ioports/devportio.py

@@ -14,29 +14,29 @@ class DevPortIO(PortIOClass):
     A class to interact with the `/dev/port` device file.
     """
 
-    dev_port = None
+    _dev_port = None
 
     def __init__(self):
         """
         Initialize the `/dev/port` device file.
         """
-        self.dev_port = open("/dev/port", "r+b", buffering=0)
+        self._dev_port = open("/dev/port", "r+b", buffering=0)
 
     def __del__(self):
         """
         Close the `/dev/port` device file.
         """
-        if self.dev_port:
-            self.dev_port.close()
+        if self._dev_port:
+            self._dev_port.close()
 
     def out_bytes(self, data: bytes, port: int) -> None:
         """
         Write data to the specified port.
         :param data: Data to write.
         :param port: Port to write to.
         """
-        self.dev_port.seek(port)
-        self.dev_port.write(data)
+        self._dev_port.seek(port)
+        self._dev_port.write(data)
 
     def outb(self, data: int, port: int) -> None:
         """
@@ -69,8 +69,8 @@ def in_bytes(self, port: int, num: int) -> bytes:
         :param num: Number of bytes to read.
         :return: Data read.
         """
-        self.dev_port.seek(port)
-        return self.dev_port.read(num)
+        self._dev_port.seek(port)
+        return self._dev_port.read(num)
 
     def inb(self, port: int) -> int:
         """

cros_ec_python/ioports/winportio.py

@@ -2,7 +2,7 @@
 This file provides a way to interact with the WinRing0 library for port I/O on Windows.
 
 For this to work, you will need to copy `WinRing0x64.dll` and `WinRing0x64.sys` to either
-the same directory as `python.exe`, or to `C:\Windows\System32`.
+the same directory as `python.exe`, or to `C:\\Windows\\System32`.
 """
 
 from enum import Enum

pyproject.toml

@@ -17,7 +17,7 @@ classifiers = [
 ]
 
 [project.optional-dependencies]
-docs = ["pdoc"]
+docs = ["pdoc", "portio"]
 lpc = ["portio"]
 
 [project.urls]