sdwire 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

sdwire/backend/detect.py

@@ -1,23 +1,38 @@
+"""SDWire device detection module.
+
+This module provides functions to detect and enumerate SDWire devices
+connected to the system via USB, including both SDWire3 and SDWireC variants.
+"""
+
 import logging
-from typing import List
+from typing import List, Union
 
 from sdwire import constants
-from .device.sdwire import SDWire, SDWIRE_GENERATION_SDWIRE3
-from .device.sdwirec import SDWireC
-from .device.usb_device import PortInfo
+from sdwire.backend.device.sdwire import SDWire, SDWIRE_GENERATION_SDWIRE3
+from sdwire.backend.device.sdwirec import SDWireC
+from sdwire.backend.device.usb_device import PortInfo
 
-import pyudev
 import usb.core
 import usb.util
-from usb.core import Device
 
 log = logging.getLogger(__name__)
 
 
 def get_sdwirec_devices() -> List[SDWireC]:
-    devices: List[Device] = usb.core.find(find_all=True)
+    """Detect and return all connected SDWireC devices.
+
+    Returns:
+        List of SDWireC device instances found on the system
+    """
+    try:
+        found_devices = usb.core.find(find_all=True)
+        devices = list(found_devices or [])
+    except Exception as e:
+        log.debug("Error finding USB devices: %s", e)
+        return []
+
     if not devices:
-        log.info("no usb devices found while searching for SDWireC..")
+        log.debug("No USB devices found while searching for SDWireC")
         return []
 
     device_list = []
@@ -26,9 +41,10 @@ def get_sdwirec_devices() -> List[SDWireC]:
         serial = None
         manufacturer = None
         try:
-            product = device.product
-            serial = device.serial_number
-            manufacturer = device.manufacturer
+            # Safe attribute access
+            product = getattr(device, "product", None)
+            serial = getattr(device, "serial_number", None)
+            manufacturer = getattr(device, "manufacturer", None)
         except Exception as e:
             log.debug(
                 "not able to get usb product, serial_number and manufacturer information, err: %s",
@@ -44,48 +60,64 @@ def get_sdwirec_devices() -> List[SDWireC]:
     return device_list
 
 
-def get_sdwire_devices() -> List[SDWire]:
-    # Badgerd SDWire3
-    # VID = 0bda PID = 0316
-    # Badgerd SDWireC
-    # VID = 0x04e8 PID = 0x6001
-    result = []
-    devices: List[Device] = pyudev.Context().list_devices(
-        subsystem="usb",
-        ID_VENDOR_ID=f"{constants.SDWIRE3_VID:04x}",
-        ID_MODEL_ID=f"{constants.SDWIRE3_PID:04x}",
-    )
+def get_sdwire_devices() -> List[Union[SDWire, SDWireC]]:
+    """Detect and return all connected SDWire devices (both SDWire3 and SDWireC).
+
+    This function searches for:
+    - SDWire3 devices (VID: 0x0bda, PID: 0x0316)
+    - SDWireC devices (VID: 0x04e8, PID: 0x6001)
+
+    Returns:
+        List of SDWire device instances (SDWire or SDWireC) found on the system
+    """
+    result: List[Union[SDWire, SDWireC]] = []
+    try:
+        found_devices = usb.core.find(
+            find_all=True,
+            idVendor=constants.SDWIRE3_VID,
+            idProduct=constants.SDWIRE3_PID,
+        )
+        devices = list(found_devices or [])
+    except Exception as e:
+        log.debug("Error finding SDWire3 devices: %s", e)
+        devices = []
+
     if not devices:
         log.info("no usb devices found while searching for SDWire..")
-        return []
-
-    for device in devices:
-        product = None
-        serial = None
-        bus = None
-        address = None
-        try:
-            product = int(f"0x{device.get('ID_MODEL_ID')}", 16)
-            vendor = int(f"0x{device.get('ID_VENDOR_ID')}", 16)
-            bus = int(device.get("BUSNUM"))
-            address = int(device.get("DEVNUM"))
-            serial = f"{device.get('ID_USB_SERIAL_SHORT')}:{bus}.{address}"
-        except Exception as e:
-            log.debug(
-                "not able to get usb product, serial_number and manufacturer information, err: %s",
-                e,
-            )
+    else:
+        for device in devices:
+            product = None
+            serial = None
+            vendor = None
+            bus = None
+            address = None
+            try:
+                # Safe attribute access
+                product = getattr(device, "idProduct", None)
+                vendor = getattr(device, "idVendor", None)
+                bus = getattr(device, "bus", None)
+                address = getattr(device, "address", None)
+                serial_num = getattr(device, "serial_number", None) or "unknown"
+                port_numbers = getattr(device, "port_numbers", None)
+                serial = (
+                    f"{serial_num}.{'.'.join(map(str, port_numbers))}"
+                    if port_numbers
+                    else f"{serial_num}:{bus}.{address}"
+                )
+            except Exception as e:
+                log.debug(
+                    "not able to get usb product, serial_number and manufacturer information, err: %s",
+                    e,
+                )
 
-        if product == constants.SDWIRE3_PID and vendor == constants.SDWIRE3_VID:
-            usb_device: List[Device] = usb.core.find(
-                idVendor=vendor, idProduct=product, bus=bus, address=address
-            )
-            result.append(
-                SDWire(
-                    port_info=PortInfo(device, product, vendor, serial, usb_device),
-                    generation=SDWIRE_GENERATION_SDWIRE3,
+            if product == constants.SDWIRE3_PID and vendor == constants.SDWIRE3_VID:
+                result.append(
+                    SDWire(
+                        port_info=PortInfo(device, product, vendor, serial, device),
+                        generation=SDWIRE_GENERATION_SDWIRE3,
+                    )
                 )
-            )
+
     # Search for legacy SDWireC devices
     legacy_devices = get_sdwirec_devices()
 

sdwire/backend/device/sdwire.py

@@ -1,5 +1,8 @@
 import logging
-from .usb_device import USBDevice, PortInfo
+from typing import Optional
+import usb.core
+from sdwire.backend.device.usb_device import USBDevice, PortInfo
+from sdwire.backend.block_device_utils import map_usb_device_to_block_device
 
 log = logging.getLogger(__name__)
 
@@ -12,15 +15,13 @@ class SDWire(USBDevice):
     def __init__(self, port_info: PortInfo, generation: int):
         super().__init__(port_info)
         self.generation = generation
-        for child in self.dev_string.children:
-            if (
-                self.dev_string.device_path != child.device_path
-                and child.device_type == "disk"
-            ):
-                self.__block_dev = f"/dev/{child.device_path.split('/')[-1]}"
-                break
-
-    def switch_ts(self):
+        self._update_block_device()
+
+    def switch_ts(self) -> None:
+        if not self.usb_device:
+            log.error("USB device not available")
+            return
+
         try:
             self.usb_device.attach_kernel_driver(0)
             self.usb_device.reset()
@@ -30,7 +31,11 @@ class SDWire(USBDevice):
                 e,
             )
 
-    def switch_dut(self):
+    def switch_dut(self) -> None:
+        if not self.usb_device:
+            log.error("USB device not available")
+            return
+
         try:
             self.usb_device.detach_kernel_driver(0)
             self.usb_device.reset()
@@ -40,12 +45,41 @@ class SDWire(USBDevice):
                 e,
             )
 
+    def _update_block_device(self) -> None:
+        """Update block device detection based on current device state."""
+        if not self.usb_device:
+            self.__block_dev = None
+            return
+
+        try:
+            storage_device = self.storage_device
+            if storage_device is not None:
+                self.__block_dev = map_usb_device_to_block_device(storage_device)
+                log.debug(f"SDWire3: Found block device: {self.__block_dev}")
+            else:
+                self.__block_dev = None
+        except Exception as e:
+            log.debug(f"SDWire3: Block device detection failed: {e}")
+            self.__block_dev = None
+
     @property
-    def block_dev(self):
+    def block_dev(self) -> Optional[str]:
         return self.__block_dev
 
-    def __str__(self):
-        return f"{self.serial_string}\t[{int(self.manufacturer_string):04x}::{int(self.product_string):04x}]\t\t{self.block_dev}"
+    @property
+    def storage_device(self) -> Optional[usb.core.Device]:
+        """Return the USB device that corresponds to the storage interface.
+
+        For SDWire3, this is the same device we control (direct media controller).
+
+        Returns:
+            usb.core.Device: The USB device for storage, or None if not available
+        """
+        return self.usb_device
+
+    def __str__(self) -> str:
+        block_dev_str = self.block_dev if self.block_dev is not None else "None"
+        return f"{self.serial_string:<30}[{int(self.manufacturer_string):04x}::{int(self.product_string):04x}]\t\t{block_dev_str}"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.__str__()

sdwire/backend/device/sdwirec.py

@@ -1,6 +1,12 @@
 import logging
+from typing import Optional
 from pyftdi.ftdi import Ftdi
-from .usb_device import USBDevice, PortInfo
+import usb.core
+from sdwire.backend.device.usb_device import USBDevice, PortInfo
+from sdwire.backend.block_device_utils import (
+    map_usb_device_to_block_device,
+    find_sibling_storage_device,
+)
 
 log = logging.getLogger(__name__)
 
@@ -10,35 +16,63 @@ class SDWireC(USBDevice):
 
     def __init__(self, port_info: PortInfo):
         super().__init__(port_info)
-        for d in self._pyudev_context.list_devices(ID_MODEL="sd-wire"):
-            d_serial = d.get("ID_USB_SERIAL_SHORT", None)
-            if d_serial is not None and d_serial == self.serial_string:
-                for sibling in d.parent.children:
-                    if (
-                        d.device_path != sibling.device_path
-                        and sibling.device_type == "disk"
-                    ):
-                        self.__block_dev = f"/dev/{sibling.device_path.split('/')[-1]}"
-                        break
-                break
-
-    def __str__(self):
-        return f"{self.serial_string}\t[{self.product_string}::{self.manufacturer_string}]\t{self.block_dev}"
-
-    def __repr__(self):
+        self._update_block_device()
+
+    def _update_block_device(self) -> None:
+        """Update block device detection for SDWireC."""
+        if not self.usb_device:
+            self.__block_dev = None
+            return
+
+        try:
+            storage_device = self.storage_device
+            if storage_device is not None:
+                self.__block_dev = map_usb_device_to_block_device(storage_device)
+                log.debug(f"SDWireC: Found block device: {self.__block_dev}")
+            else:
+                self.__block_dev = None
+        except Exception as e:
+            log.debug(f"SDWireC: Block device detection failed: {e}")
+            self.__block_dev = None
+
+    def __str__(self) -> str:
+        block_dev_str = self.block_dev if self.block_dev is not None else "None"
+        return f"{self.serial_string:<30}[{self.product_string}::{self.manufacturer_string}]\t\t{block_dev_str}"
+
+    def __repr__(self) -> str:
         return self.__str__()
 
     @property
-    def block_dev(self):
+    def block_dev(self) -> Optional[str]:
         return self.__block_dev
 
-    def switch_ts(self):
+    @property
+    def storage_device(self) -> Optional[usb.core.Device]:
+        """Return the USB device that corresponds to the storage interface.
+
+        For SDWireC, this is a sibling mass storage device under the same hub,
+        not the FTDI device we control.
+
+        Returns:
+            USB device object for the sibling mass storage device, or None if
+            not found
+        """
+        return find_sibling_storage_device(self.usb_device)
+
+    def switch_ts(self) -> None:
         self._set_sdwire(1)
 
-    def switch_dut(self):
+    def switch_dut(self) -> None:
         self._set_sdwire(0)
 
-    def _set_sdwire(self, target):
+    def _set_sdwire(self, target: int) -> None:
+        if not self.usb_device:
+            log.error("USB device not available")
+            import sys
+
+            print("USB device not available")
+            sys.exit(1)
+
         try:
             ftdi = Ftdi()
             ftdi.open_from_device(self.usb_device)
@@ -48,6 +82,6 @@ class SDWireC(USBDevice):
         except Exception as e:
             import sys
 
-            log.debug("error while updating ftdi device", exc_info=1)
+            log.debug("error while updating ftdi device: %s", e, exc_info=True)
             print("couldnt switch sdwire device")
             sys.exit(1)

sdwire/backend/device/usb_device.py

@@ -1,5 +1,7 @@
 from collections import namedtuple
-import pyudev
+from typing import Optional
+import usb.core
+
 
 PortInfo = namedtuple(
     "PortInfo", ("device", "product", "manufacturer", "serial", "usb_device")
@@ -7,29 +9,39 @@ PortInfo = namedtuple(
 
 
 class USBDevice:
-    __port_info = None
-    _pyudev_context = None
+    __port_info: Optional[PortInfo] = None
+
 
     def __init__(self, port_info: PortInfo):
         self.__port_info = port_info
-        self._pyudev_context = pyudev.Context()
+
 
     @property
-    def usb_device(self):
-        return self.__port_info.usb_device
+    def usb_device(self) -> Optional[usb.core.Device]:
+        if self.__port_info:
+            return self.__port_info.usb_device
+        return None
 
     @property
     def dev_string(self) -> str:
-        return self.__port_info.device
+        if self.__port_info and self.__port_info.device:
+            return self.__port_info.device
+        return ""
 
     @property
     def product_string(self) -> str:
-        return self.__port_info.product
+        if self.__port_info and self.__port_info.product:
+            return str(self.__port_info.product)
+        return ""
 
     @property
     def manufacturer_string(self) -> str:
-        return self.__port_info.manufacturer
+        if self.__port_info and self.__port_info.manufacturer:
+            return str(self.__port_info.manufacturer)
+        return ""
 
     @property
     def serial_string(self) -> str:
-        return self.__port_info.serial
+        if self.__port_info and self.__port_info.serial:
+            return str(self.__port_info.serial)
+        return ""

sdwire/backend/utils.py

@@ -1,30 +1,62 @@
+"""Utility functions for SDWire CLI operations."""
 import sys
 import logging
+
 import click
-from .device.sdwire import SDWire
-from .device.sdwirec import SDWireC
-from . import detect
+from sdwire.backend.device.sdwire import SDWire
+from sdwire.backend.device.sdwirec import SDWireC
+from sdwire.backend import detect
 
 log = logging.getLogger(__name__)
 
 
-def handle_switch_host_command(ctx):
-    device = ctx.obj["device"]
-    device.switch_ts()
+def handle_switch_host_command(ctx: click.Context) -> None:
+    """Handle switching device to host/TS mode.
+
+    Args:
+        ctx: Click context containing device information
+    """
+    try:
+        device = ctx.obj["device"]
+        device.switch_ts()
+    except Exception as e:
+        log.error(f"Failed to switch to host mode: {e}")
+        print(f"Error: Failed to switch device to host mode: {e}")
+        sys.exit(1)
 
 
-def handle_switch_target_command(ctx):
-    device = ctx.obj["device"]
-    device.switch_dut()
+def handle_switch_target_command(ctx: click.Context) -> None:
+    """Handle switching device to target/DUT mode.
 
+    Args:
+        ctx: Click context containing device information
+    """
+    try:
+        device = ctx.obj["device"]
+        device.switch_dut()
+    except Exception as e:
+        log.error(f"Failed to switch to target mode: {e}")
+        print(f"Error: Failed to switch device to target mode: {e}")
+        sys.exit(1)
 
-def handle_switch_off_command(ctx):
-    device = ctx.obj["device"]
-    if isinstance(device, SDWireC) or isinstance(device, SDWire):
-        log.info(
-            "SDWire3, SDWireC or legacy sdwire devices dont have off functionality"
-        )
-        print("SDWireC and SDWire3 dont have off functionality implemented")
+
+def handle_switch_off_command(ctx: click.Context) -> None:
+    """Handle switching device to off mode.
+
+    Args:
+        ctx: Click context containing device information
+    """
+    try:
+        device = ctx.obj["device"]
+        if isinstance(device, (SDWireC, SDWire)):
+            log.info(
+                "SDWire3, SDWireC or legacy sdwire devices don't have off functionality"
+            )
+            print("SDWireC and SDWire3 don't have off functionality implemented")
+            sys.exit(1)
+    except Exception as e:
+        log.error(f"Failed to process off command: {e}")
+        print(f"Error: Failed to process off command: {e}")
         sys.exit(1)
 
 

sdwire/constants.py

@@ -3,3 +3,5 @@ SDWIRE3_PID = 0x0316
 SDWIREC_VID = 0x04E8
 SDWIREC_PID = 0x6001
 SDWIREC_PRODUCT_STRING = "sd-wire"
+
+USB_MASS_STORAGE_CLASS_ID = 8

sdwire/main.py

@@ -1,20 +1,30 @@
 #!/usr/bin/env python
+"""SDWire CLI main entry point.
+
+This module provides the command-line interface for controlling SDWire devices,
+including listing devices and switching between host and DUT modes.
+"""
 import logging
+from typing import Optional
+import importlib.metadata
 import click
-from .backend import utils
-from .backend import detect
+from sdwire.backend import utils
+from sdwire.backend import detect
 
 
 @click.group()
 @click.option("--debug", required=False, is_flag=True, help="Enable debug output")
-def main(debug=None):
+@click.version_option(version=importlib.metadata.version("sdwire"), prog_name="sdwire")
+def main(debug: Optional[bool] = None) -> None:
+    """SDWire CLI - Control SDWire devices from command line."""
     if debug:
         logging.basicConfig(level=logging.DEBUG)
 
 
 @main.command()
-def list():
-    print("Serial\t\t\tProduct Info\t\tBlock Dev")
+def list() -> None:
+    """List all connected SDWire devices with their block device information."""
+    print(f"{'Serial':<30}Product Info\t\tBlock Dev")
     for sdwire in detect.get_sdwire_devices():
         print(sdwire)
 

{sdwire-0.2.5.dist-info → sdwire-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdwire
-Version: 0.2.5
+Version: 0.3.0
 Summary: CLI application to interact with Badgerd SDWire devices
 License: GPL-3
 Author: Talha Can Havadar
@@ -11,7 +11,6 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: pyftdi (>=0.56.0,<0.57.0)
-Requires-Dist: pyudev (>=0.24.3,<0.25.0)
 Requires-Dist: pyusb (>=1.2.1,<2.0.0)
 Description-Content-Type: text/markdown
 

sdwire-0.3.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+sdwire/__init__.py,sha256=ioDFD-3xGgXt2IdyywicNr8TgeYrdSV8EAunyXBiqIo,86
+sdwire/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdwire/backend/block_device_utils.py,sha256=1V9c8Edzwazu7-nWZ9o7l4tUBChvuuRB8UtAXLTyZhI,30585
+sdwire/backend/detect.py,sha256=k_ByGolWXFpF9ajbWuTeenkOOR7T-bmKe_GovqBybcA,4165
+sdwire/backend/device/sdwire.py,sha256=SXItShyfJZN3Jn4kRGDdgz3QPnnkyNgBzrz_HRpIOPQ,2767
+sdwire/backend/device/sdwirec.py,sha256=S_J6RY002bco0gKn3ybd-8-dK5URwdGsjZADz3hv1ZM,2759
+sdwire/backend/device/usb_device.py,sha256=FHgBE9rdpH8Ie8Y_tJlaJp-LV3677QG0uUQUf18bEAk,1206
+sdwire/backend/utils.py,sha256=8oPvoDBsjvIHFWLN5oCui_V03oASkyYlkHVGyQV_6XM,2603
+sdwire/constants.py,sha256=pBHotAmBpvhiCKBkFYOB5eMOeNulWxr98epFTJRUVz4,150
+sdwire/main.py,sha256=n7W1uDUlkJ4f80xS5YLvMq0bjLuiO1P-ePpfAaA9Eew,2654
+sdwire-0.3.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+sdwire-0.3.0.dist-info/METADATA,sha256=U55zUtw8G49BLoqGY_Zyc4Swvh78L_1qm8LIzO55kZo,3063
+sdwire-0.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+sdwire-0.3.0.dist-info/entry_points.txt,sha256=pxy0zJKVcNWXPk5PtNjTLExOBpqFNth37wtdYdYRXCE,43
+sdwire-0.3.0.dist-info/RECORD,,

sdwire-0.2.5.dist-info/RECORD

@@ -1,14 +0,0 @@
-sdwire/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sdwire/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sdwire/backend/detect.py,sha256=jiQ2JS9sMGUuymwyUO4FaGzIkXK3J7Ci45V1X8c94b4,2931
-sdwire/backend/device/sdwire.py,sha256=nhjBjmxjjaM_rGYyXXdjr_85lEGny7c7-BC3KVcWoz4,1503
-sdwire/backend/device/sdwirec.py,sha256=imkj2ObrgowiM7DP9TnVbCES-8bju0T69Qzdw5OURgE,1657
-sdwire/backend/device/usb_device.py,sha256=5sdyOyPikIpFydKywzDkvvgLHFdMcsBC8tKosHRhfvQ,808
-sdwire/backend/utils.py,sha256=kMEyBbRO91REgvgICuBONGiImO6jTr6EpqkZaxQH4aU,1507
-sdwire/constants.py,sha256=s5mCx5NlJUM3aBbCPq2y3oOFoPPJ5wA3BR1snyK-cMg,119
-sdwire/main.py,sha256=G1WaVd4kBR3bTfbmHekjx1yObiz4f1NLGqznFepd2NY,2132
-sdwire-0.2.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-sdwire-0.2.5.dist-info/METADATA,sha256=OfCzihIvL2GUz8NhN-brLXW2EjUBZrp5Ov8HeUOXX4Q,3104
-sdwire-0.2.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-sdwire-0.2.5.dist-info/entry_points.txt,sha256=pxy0zJKVcNWXPk5PtNjTLExOBpqFNth37wtdYdYRXCE,43
-sdwire-0.2.5.dist-info/RECORD,,