difonlib 0.2.2a1__tar.gz → 0.2.4__tar.gz

{difonlib-0.2.2a1 → difonlib-0.2.4}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: difonlib
-Version: 0.2.2a1
+Version: 0.2.4
 Summary: python libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: bleak>=3.0.1
 Requires-Dist: evdev>=1.9.2
+Requires-Dist: hid>=1.0.9
 Requires-Dist: nicegui>=3.2.0
 Requires-Dist: pexpect>=4.9.0
+Requires-Dist: pydbus>=0.6.0
+Requires-Dist: pygobject>=3.56.2
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: tinytuya>=1.17.4
-Requires-Dist: types-pexpect>=4.9.0.20250916
-Requires-Dist: types-PyYAML>=6.0.12.20250915
-Requires-Dist: types-xmltodict>=1.0.1.20250920
 Requires-Dist: xmltodict>=1.0.2
 
 # Python libraries

{difonlib-0.2.2a1 → difonlib-0.2.4}/pyproject.toml

@@ -1,18 +1,19 @@
 [project]
 name = "difonlib"
-version = "0.2.2a1"
+version = "0.2.4"
 description = "python libraries"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
+    "bleak>=3.0.1",
     "evdev>=1.9.2",
+    "hid>=1.0.9",
     "nicegui>=3.2.0",
     "pexpect>=4.9.0",
+    "pydbus>=0.6.0",
+    "pygobject>=3.56.2",
     "pyyaml>=6.0.3",
     "tinytuya>=1.17.4",
-    "types-pexpect>=4.9.0.20250916",
-    "types-PyYAML>=6.0.12.20250915",
-    "types-xmltodict>=1.0.1.20250920",
     "xmltodict>=1.0.2",
 ]
 
@@ -36,9 +37,9 @@ warn_return_any = true
 mypy_path = ["src"]
 
 
-[tool.pytest.ini_options]
-addopts = "-v"
-testpaths = ["tests"]
+# [tool.pytest.ini_options]
+# addopts = "-v"
+# testpaths = ["tests"]
 
 [dependency-groups]
 dev = [
@@ -47,6 +48,9 @@ dev = [
     "black>=24.8.0",
     "mypy>=1.11.0",
     "twine>=5.1.1",
+    "types-pexpect>=4.9.0.20250916",
+    "types-PyYAML>=6.0.12.20250915",
+    "types-xmltodict>=1.0.1.20250920",
 ]
 
 [tool.ruff]

difonlib-0.2.4/src/difonlib/bt_scanner.py

@@ -0,0 +1,277 @@
+"""
+Bluetooth HID Device Scanner
+Requires: pip install bleak hid
+On Linux may also need: sudo apt install libhidapi-hidraw0 libhidapi-libusb0
+Run with: python bt_hid_scanner.py
+https://claude.ai/share/54cf3394-15f2-4ca9-8730-b70bf2973646
+"""
+
+import asyncio
+import hid
+import pydbus
+from bleak import BleakScanner
+from bleak.backends.device import BLEDevice
+from bleak.backends.scanner import AdvertisementData
+from ctypes import LittleEndianStructure, c_uint32
+
+# HID Usage Page 0x01 = Generic Desktop
+# HID Usages: 0x02=Mouse, 0x04=Joystick, 0x05=Gamepad, 0x06=Keyboard, 0x08=Multi-axis
+HID_USAGE_NAMES = {
+    0x01: "Pointer",
+    0x02: "Mouse",
+    0x04: "Joystick",
+    0x05: "Gamepad",
+    0x06: "Keyboard",
+    0x07: "Keypad",
+    0x08: "Multi-axis Controller",
+    0x09: "Tablet PC Controls",
+}
+
+
+# Bluetooth HID Service UUID
+HID_SERVICE_UUID = "00001812-0000-1000-8000-00805f9b34fb"
+
+MAJOR_CLASSES = {
+    0x00: "Miscellaneous",
+    0x01: "Computer",
+    0x02: "Phone",
+    0x03: "LAN/Network Access Point",
+    0x04: "Audio/Video",
+    0x05: "HID Device",
+    0x06: "Imaging",
+    0x07: "Wearable",
+    0x08: "Toy",
+    0x09: "Health",
+    0x1F: "Uncategorized",
+}
+
+
+# === Class of Device (CoD)===
+class CoD(LittleEndianStructure):
+    _fields_ = [
+        ("FormatType", c_uint32, 2),  # 2 бита
+        ("MinorDevClass", c_uint32, 6),  # 6 бит
+        ("MajorDevClass", c_uint32, 5),  # 5 бит
+        ("ServiceClass", c_uint32, 11),  # 11 бит
+        ("Reserved", c_uint32, 8),  # оставшиеся до 32
+    ]
+
+
+def bt_parse_cod(cod_val: int) -> str:
+    """Разобрать Class of Device (CoD) в словарь с описанием"""
+    # cod32 = c_uint32(int(cod_val, 0))
+    cod32 = c_uint32(cod_val)
+    fields = CoD.from_buffer_copy(cod32)
+    major = fields.MajorDevClass
+    return MAJOR_CLASSES.get(major, f"0x{major:02X}")
+
+
+async def adapter_restart(adapter_path: str = "/org/bluez/hci0", duration: float = 0.5) -> None:
+    bus = pydbus.SystemBus()
+    adapter = bus.get("org.bluez", adapter_path)
+    adapter.StartDiscovery()
+    await asyncio.sleep(duration)
+    try:
+        adapter.StopDiscovery()
+    except Exception:
+        pass
+    await asyncio.sleep(0.5)
+
+
+# ─── USB HID Devices (connected right now) ────────────────────────────────────
+
+
+def scan_usb_hid_devices() -> list[dict]:
+    """Return a list of currently connected USB HID devices."""
+    devices = []
+    seen = set()
+
+    for info in hid.enumerate():
+        key = (info["vendor_id"], info["product_id"], info["usage_page"], info["usage"])
+        if key in seen:
+            continue
+        seen.add(key)
+
+        devices.append(
+            {
+                "name": info.get("product_string") or "Unknown",
+                "manufacturer": info.get("manufacturer_string") or "Unknown",
+                "vid": f"0x{info['vendor_id']:04X}",
+                "pid": f"0x{info['product_id']:04X}",
+                "usage_page": f"0x{info['usage_page']:04X}",
+                "usage": HID_USAGE_NAMES.get(info["usage"], f"0x{info['usage']:04X}"),
+                "serial": info.get("serial_number") or "—",
+                "path": info.get("path", b"").decode(errors="replace"),
+                "interface": info.get("interface_number", -1),
+                "transport": "USB / HID",
+            }
+        )
+
+    return devices
+
+
+# ─── Bluetooth LE HID Devices (nearby) ────────────────────────────────────────
+
+
+class BluetoothScanner:
+    def __init__(self, duration: float = 5.0, dev_type: str = ""):
+        self.duration = duration
+        self.found: dict[str, dict] = {}  # addr -> device info
+        self.dev_type = dev_type
+        self.available_types = [v for v in MAJOR_CLASSES.values()]
+
+    def _on_device(self, device: BLEDevice, adv: AdvertisementData) -> None:
+        # print(f"device: {device}")
+        # print(f"Class: {device.details['Class']}")
+        # print(f"adv: {adv}")
+        service_uuids = [u.lower() for u in (adv.service_uuids or [])]
+        ble_hid_dev = HID_SERVICE_UUID in service_uuids
+        dclass = device.details.get("props", {}).get("Class")
+        # print(f" = DETAILS: {device.details}")
+        dev_class = None
+        if ble_hid_dev:
+            dev_class = "HID Device"
+        elif dclass:
+            dev_class = bt_parse_cod(dclass)
+
+        addr = device.address
+        if addr in self.found:
+            # update RSSI
+            self.found[addr]["rssi"] = adv.rssi
+            return
+
+        self.found[addr] = {
+            "name": device.name or "Unknown",
+            "address": addr,
+            "dev_class": dev_class,
+            "rssi": adv.rssi,
+            "services": service_uuids,
+            "tx_power": adv.tx_power,
+        }
+        # print(
+        #     f"  [+] Found: {device.name or 'Unknown':30s}  {addr}  RSSI {adv.rssi} dBm"
+        # )
+        # print(f"      service_uuids: {service_uuids}")
+
+    def _filter(self, devs: list[dict], dev_type: str) -> list[dict]:
+        _devs = []
+        for dev in devs:
+            if dev["dev_class"] == dev_type:
+                _devs.append(dev)
+        return _devs
+
+    async def run(self) -> list[dict]:
+        print(f"   Scanning BLE for {self.duration}s ...")
+        async with BleakScanner(detection_callback=self._on_device):
+            await asyncio.sleep(self.duration)
+        if self.dev_type in self.available_types:
+            return self._filter(list(self.found.values()), self.dev_type)
+        elif self.dev_type != "":
+            print(" =!= Device Type ERROR")
+            print(f"   Type '{self.dev_type}' is not available.")
+            print(f"   Available types: {self.available_types}")
+        return list(self.found.values())
+
+
+# def get_bt_hid_devs(devs:list[dict]) -> list[dict]:
+#     hid_devs = []
+#     for dev in devs:
+#         if HID_SERVICE_UUID in dev["services"] or dev['dev_class'] == "HID Device":
+#             hid_devs.append(dev)
+#     return hid_devs
+
+
+# ─── Pretty printing ───────────────────────────────────────────────────────────
+
+
+def print_separator(char: str = "─", width: int = 60) -> None:
+    print(char * width)
+
+
+def print_usb_devices(devices: list[dict]) -> None:
+    print_separator("═")
+    print(f"  USB HID DEVICES  ({len(devices)} found)")
+    print_separator("═")
+
+    if not devices:
+        print("  No USB HID devices found.\n")
+        return
+
+    for i, d in enumerate(devices, 1):
+        print(f"\n  [{i}] {d['name']}")
+        print(f"       Manufacturer : {d['manufacturer']}")
+        print(f"       VID / PID    : {d['vid']} / {d['pid']}")
+        print(f"       Usage        : {d['usage']}  (page {d['usage_page']})")
+        print(f"       Serial       : {d['serial']}")
+        print(f"       Interface    : {d['interface']}")
+        print(f"       Path         : {d['path']}")
+
+    print()
+
+
+def print_bt_devices(devices: list[dict], type: str = "DEVICES") -> None:
+    print_separator("═")
+    print(f"  BLUETOOTH AVAILABLE {type}  ({len(devices)} found)")
+    print_separator("═")
+
+    if not devices:
+        print("  No devices found.\n")
+        return
+
+    for i, d in enumerate(devices, 1):
+        tx = f"{d['tx_power']} dBm" if d["tx_power"] is not None else "—"
+        print(f"\n  [{i}] {d['name']}")
+        print(f"       Address      : {d['address']}")
+        print(f"       Services     : {d['services']}")
+        print(f"       Device Class : {d['dev_class']}")
+        print(f"       RSSI         : {d['rssi']} dBm")
+        print(f"       TX Power     : {tx}")
+        # print(f"       Transport    : {d['transport']}")
+
+    print()
+
+
+# ─── Main ──────────────────────────────────────────────────────────────────────
+
+
+async def main() -> None:
+    print("\n╔══════════════════════════════════════════════════════════╗")
+    print("║          Bluetooth Device Scanner                        ║")
+    print("╚══════════════════════════════════════════════════════════╝\n")
+
+    # # 1. USB HID
+    # print("Scanning USB HID devices ...")
+    # usb_devices = scan_usb_hid_devices()
+    # print_usb_devices(usb_devices)
+
+    # # Сначала — inquiry, чтобы BlueZ узнал о Classic устройствах
+    # print("Triggering Classic BT inquiry via bluetoothctl...")
+    # await trigger_classic_inquiry(duration=2)
+
+    await adapter_restart()
+
+    # 2. BLE HID
+    try:
+        # bt_scanner = BluetoothScanner(duration=6.0, dev_type="Audio/Video")
+        dev_type = "HID Device"
+        # dev_type = ""
+        bt_scanner = BluetoothScanner(duration=6.0, dev_type=dev_type)
+        bt_devices = await bt_scanner.run()
+        print_bt_devices(bt_devices, type=dev_type)
+    except Exception as e:
+        print(f"  Bluetooth device scan failed: {e}")
+        print("  Make sure Bluetooth is enabled and bleak is installed.\n")
+        bt_devices = []
+
+    # # 3. Summary
+    # print_separator("═")
+    # total = len(usb_devices) + len(ble_devices)
+    # print(
+    #     f"  SUMMARY: {len(usb_devices)} USB HID + {len(ble_devices)} BLE HID = {total} total devices"
+    # )
+    # print_separator("═")
+    # print(f"bt_devices: {bt_devices}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{difonlib-0.2.2a1 → difonlib-0.2.4}/src/difonlib/bt_utils.py

@@ -1,17 +1,26 @@
 #!/usr/bin/env python
 
+import sys
+import time
 import os
 import re
 import pexpect
-import sys
-import time
 from typing import Optional
 from ctypes import LittleEndianStructure, c_uint32
+
+from typing import Any
+
 from difonlib.utils import logdbg
 from difonlib.input_devs import get_connected_input_devices
 
+import asyncio
+import pydbus
+from bleak import BleakScanner
+from bleak.backends.device import BLEDevice
+from bleak.backends.scanner import AdvertisementData
 
 dbg = logdbg
+# dbg = print
 
 MAJOR_CLASSES = {
     0x00: "Miscellaneous",
@@ -39,15 +48,81 @@ class CoD(LittleEndianStructure):
     ]
 
 
-def bt_parse_cod(cod_val: str) -> str:
+def bt_parse_cod(cod_val: Any) -> str:
     """Разобрать Class of Device (CoD) в словарь с описанием"""
-    cod32 = c_uint32(int(cod_val, 0))
+    cod32 = c_uint32(int(cod_val))
     fields = CoD.from_buffer_copy(cod32)
     major = fields.MajorDevClass
     return MAJOR_CLASSES.get(major, f"0x{major:02X}")
 
 
-def bt_scan() -> list:
+# Bluetooth HID Service UUID
+HID_SERVICE_UUID = "00001812-0000-1000-8000-00805f9b34fb"
+
+
+class BluetoothScanner:
+    def __init__(self, duration: float = 5.0, dev_type: str = ""):
+        self.duration = duration
+        self.found: dict[str, dict] = {}  # addr -> device info
+        self.dev_type = dev_type
+        self.available_types = [v for v in MAJOR_CLASSES.values()]
+
+    def _on_device(self, device: BLEDevice, adv: AdvertisementData) -> None:
+        # print(f"device: {device}")
+        # print(f"Class: {device.details['Class']}")
+        # print(f"adv: {adv}")
+        service_uuids = [u.lower() for u in (adv.service_uuids or [])]
+        ble_hid_dev = HID_SERVICE_UUID in service_uuids
+        dclass = device.details.get("props", {}).get("Class")
+        # print(f" = DETAILS: {device.details}")
+        dev_class = None
+        if ble_hid_dev:
+            dev_class = "HID Device"
+        elif dclass:
+            dev_class = bt_parse_cod(dclass)
+
+        addr = device.address
+        if addr in self.found:
+            # update RSSI
+            self.found[addr]["rssi"] = adv.rssi
+            return
+
+        self.found[addr] = {
+            "name": device.name or "Unknown",
+            "address": addr,
+            "dev_class": dev_class,
+            "rssi": adv.rssi,
+            "services": service_uuids,
+            "tx_power": adv.tx_power,
+        }
+        print(".", end="", flush=True)
+        # print(
+        #     f"  [+] Found: {device.name or 'Unknown':30s}  {addr}  RSSI {adv.rssi} dBm"
+        # )
+        # print(f"      service_uuids: {service_uuids}")
+
+    def _filter(self, devs: list[dict], dev_type: str) -> list[dict]:
+        _devs = []
+        for dev in devs:
+            if dev["dev_class"] == dev_type:
+                _devs.append(dev)
+        return _devs
+
+    async def run(self) -> list[dict]:
+        print(f"   Scanning for bluetooth devices {self.duration}s ...", end="")
+        async with BleakScanner(detection_callback=self._on_device):
+            await asyncio.sleep(self.duration)
+        print(" END\n")
+        if self.dev_type in self.available_types:
+            return self._filter(list(self.found.values()), self.dev_type)
+        elif self.dev_type != "":
+            print(" =!= Device Type ERROR")
+            print(f"   Type '{self.dev_type}' is not available.")
+            print(f"   Available types: {self.available_types}")
+        return list(self.found.values())
+
+
+def bt_scan_hcitool_inq() -> list:
     # px = pexpect.spawn("hcitool scan", encoding="utf-8")
     devs = []
     # inquery remote devices
@@ -68,16 +143,7 @@ def bt_scan() -> list:
     return devs
 
 
-def bt_scan_hid_devs() -> list:
-    devs = bt_scan()
-    hid_devs = []
-    for dev in devs:
-        if dev["class"] == "HID Device":
-            hid_devs.append(dev)
-    return hid_devs
-
-
-def bt_scan2() -> list:
+def bt_scan_hcitool_scan() -> list:
     # px = pexpect.spawn("hcitool scan", encoding="utf-8")
     devs = []
     _devs = os.popen("hcitool scan").readlines()
@@ -95,6 +161,40 @@ def bt_scan2() -> list:
     return devs
 
 
+def bt_scan_hid_devs() -> list:
+    devs = bt_scan_hcitool_inq()
+    hid_devs = []
+    for dev in devs:
+        if dev["class"] == "HID Device":
+            hid_devs.append(dev)
+    return hid_devs
+
+
+async def bt_scan_devs(  # universally version for classic and ble devices
+    dev_type: str = "HID Device",
+    inquiry_warmup: float = 4.0,  # время для Classic Inquiry
+    scan_duration: float = 6.0,  # время bleak сканирования
+    adapter_path: str = "/org/bluez/hci0",
+) -> list[dict]:
+    bus = pydbus.SystemBus()
+    adapter = bus.get("org.bluez", adapter_path)
+    adapter.SetDiscoveryFilter({})
+    adapter.StartDiscovery()
+    await asyncio.sleep(inquiry_warmup)
+    try:
+        bt_scanner = BluetoothScanner(duration=scan_duration, dev_type=dev_type)
+        bt_devices = await bt_scanner.run()
+    except Exception as e:
+        print(f"  Bluetooth scan failed: {e}")
+        bt_devices = []
+    finally:
+        try:
+            adapter.StopDiscovery()
+        except Exception as e:
+            print(f"  StopDiscovery() error: {e}")
+    return bt_devices
+
+
 def btctl_add(mac_address: str, timeout: int = 10) -> Optional[dict]:
     """
     Подключает HID или любое Bluetooth устройство по MAC через bluetoothctl.
@@ -319,18 +419,23 @@ def bt_hid_conn_devs() -> list:
 
 if __name__ == "__main__":
 
-    dev_mac = "41:42:68:D8:DA:39"
+    # dev_mac = "41:42:68:D8:DA:39"
+
+    # from difonlib.utils import print_dicts_list
 
-    from difonlib.utils import print_dicts_list
+    # print(" ======== ALL connected devices ==========")
+    # all_connected_devs = get_connected_input_devices()
+    # print_dicts_list(all_connected_devs)
 
-    print(" ======== ALL connected devices ==========")
-    all_connected_devs = get_connected_input_devices()
-    print_dicts_list(all_connected_devs)
+    # print(" ======== HID connected devices ==========")
+    # conn_devs = bt_hid_conn_devs()
+    # print_dicts_list(conn_devs)
 
-    print(" ======== HID connected devices ==========")
-    conn_devs = bt_hid_conn_devs()
-    print_dicts_list(conn_devs)
+    # input("ssssssssssssssssssss")
 
+    # devs = asyncio.run(bt_scan_devs(dev_type=""))
+    devs = asyncio.run(bt_scan_devs())
+    print(f"devs: {devs}")
     # available_bt_devs = bt_scan()
     # print_lists(available_bt_devs)  # //Dima
 

{difonlib-0.2.2a1 → difonlib-0.2.4}/src/difonlib/input_devs.py

@@ -1,7 +1,8 @@
 from pathlib import Path
-from evdev import InputDevice, categorize
+from evdev import InputDevice, categorize, ecodes, list_devices
 from evdev.events import KeyEvent
 from typing import Dict, Any, List, Optional
+
 from difonlib.utils import logdbg
 from dataclasses import dataclass
 import re
@@ -31,6 +32,38 @@ class IDevKbdKey:
     keycode: str | tuple = ""
 
 
+def idev_get_connected_devs() -> List[InputDevice]:
+    return [InputDevice(p) for p in list_devices()]
+
+
+def is_remote_ctrl(dev: InputDevice) -> bool:
+    caps = dev.capabilities()
+    if ecodes.EV_KEY not in caps:
+        return False
+    keys = set(caps[ecodes.EV_KEY])
+    remote_keys = {
+        ecodes.KEY_UP,
+        ecodes.KEY_DOWN,
+        ecodes.KEY_LEFT,
+        ecodes.KEY_RIGHT,
+        ecodes.KEY_OK,
+        ecodes.KEY_SELECT,
+        ecodes.KEY_BACK,
+        ecodes.KEY_PLAYPAUSE,
+        ecodes.KEY_VOLUMEUP,
+        ecodes.KEY_VOLUMEDOWN,
+        ecodes.KEY_HOME,
+        ecodes.KEY_MENU,
+    }
+    return bool(remote_keys & keys)
+
+
+def idev_get_dev_by_uniq(uniq: str) -> Optional[InputDevice]:
+    devs = idev_get_connected_devs()
+    matched = [dev for dev in devs if dev.uniq == uniq and is_remote_ctrl(dev)]
+    return matched[0] if matched else None
+
+
 def get_connected_input_devices() -> List[Dict[str, Any]]:
     path = Path("/proc/bus/input/devices")
     devices: List[Dict[str, Any]] = []

{difonlib-0.2.2a1 → difonlib-0.2.4}/src/difonlib/utils.py

@@ -39,11 +39,23 @@ MSG_COLOR = f"\x1b[{RESET};38;5;{45}m"
 # DEBUG    10
 # NOTSET    0
 
-logging.basicConfig(
-    format=f"{MSG_COLOR}[%(filename)s:%(lineno)d]: %(message)s{COLOR_OFF}",
-    level=logging.DEBUG,
+
+# Глобальные логгеры библиотек — заглушить
+logging.getLogger().setLevel(logging.WARNING)  # root logger
+
+# Свой именованный логгер
+logger = logging.getLogger("DifonLibLogger")
+logger.setLevel(logging.DEBUG)
+
+# Handler только на свой логгер
+handler = logging.StreamHandler()
+handler.setFormatter(
+    logging.Formatter(f"{MSG_COLOR}[%(filename)s:%(lineno)d]: %(message)s{COLOR_OFF}")
 )
-logdbg = logging.debug
+logger.addHandler(handler)
+logger.propagate = False  # не пускать в root logger
+
+logdbg = logger.debug
 
 
 class UtilsError(Exception):
@@ -182,14 +194,14 @@ class YamlConfig:
     def load(self) -> None:
         if not self.config_path.exists():
             self.save()
-        with self.config_path.open() as f:
-            self.config = yaml.safe_load(f) or {}
+        with self.config_path.open() as fcfg:
+            self.config = yaml.safe_load(fcfg) or {}
 
     def save(self) -> None:
-        with self.config_path.open("w") as f:
+        with self.config_path.open("w") as fcfg:
             yaml.safe_dump(
                 self.config,
-                f,
+                fcfg,
                 sort_keys=False,
                 allow_unicode=True,
             )

{difonlib-0.2.2a1 → difonlib-0.2.4}/src/difonlib.egg-info/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: difonlib
-Version: 0.2.2a1
+Version: 0.2.4
 Summary: python libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: bleak>=3.0.1
 Requires-Dist: evdev>=1.9.2
+Requires-Dist: hid>=1.0.9
 Requires-Dist: nicegui>=3.2.0
 Requires-Dist: pexpect>=4.9.0
+Requires-Dist: pydbus>=0.6.0
+Requires-Dist: pygobject>=3.56.2
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: tinytuya>=1.17.4
-Requires-Dist: types-pexpect>=4.9.0.20250916
-Requires-Dist: types-PyYAML>=6.0.12.20250915
-Requires-Dist: types-xmltodict>=1.0.1.20250920
 Requires-Dist: xmltodict>=1.0.2
 
 # Python libraries

{difonlib-0.2.2a1 → difonlib-0.2.4}/src/difonlib.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 src/difonlib/__init__.py
+src/difonlib/bt_scanner.py
 src/difonlib/bt_utils.py
 src/difonlib/input_devs.py
 src/difonlib/ng_lib.py

difonlib-0.2.4/src/difonlib.egg-info/requires.txt

@@ -0,0 +1,10 @@
+bleak>=3.0.1
+evdev>=1.9.2
+hid>=1.0.9
+nicegui>=3.2.0
+pexpect>=4.9.0
+pydbus>=0.6.0
+pygobject>=3.56.2
+pyyaml>=6.0.3
+tinytuya>=1.17.4
+xmltodict>=1.0.2

{difonlib-0.2.2a1 → difonlib-0.2.4}/tests/test_bt_utils.py

@@ -1,11 +1,12 @@
 from difonlib.utils import logdbg
 from difonlib.bt_utils import bt_hid_conn_devs, get_connected_input_devices
 
-# import pytest
+import pytest
 
 dbg = logdbg
 
 
+@pytest.mark.slow
 def test_bt_utils():
     assert type(bt_hid_conn_devs()) is list, "Return value type is not list"
     assert type(get_connected_input_devices()) is list, "Return value type is not list"

difonlib-0.2.4/tests/test_utils.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+import pytest
+from difonlib.utils import (
+    logdbg,
+    is_mac_address,
+    # is_mac_address2,
+    mac_format,
+    UtilsError,
+    to_signed,
+    swap16,
+    swap32,
+    fs_remove_dir_content,
+    file_get_latest,
+    YamlConfig,
+)
+
+
+@pytest.mark.parametrize(
+    "mac",
+    [
+        "AA:BB:CC:DD:EE:FF",
+        "aa:bb:cc:dd:ee:ff",
+        "01:23:45:67:89:aB",
+    ],
+)
+def test_is_mac_address_valid(mac):
+    assert is_mac_address(mac)
+
+
+@pytest.mark.parametrize(
+    "mac",
+    [
+        "AA-BB-CC-DD-EE-FF",
+        "AABBCCDDEEFF",
+        "GG:HH:II:JJ:KK:LL",
+    ],
+)
+def test_is_mac_address_invalid(mac):
+    assert not is_mac_address(mac)
+
+
+def test_mac_format_ok():
+    assert mac_format("112233445566") == "11:22:33:44:55:66"
+
+
+def test_mac_format_invalid():
+    with pytest.raises(UtilsError):
+        mac_format("1234")
+
+
+def test_to_signed_positive():
+    assert to_signed(10, 8) == 10
+
+
+def test_to_signed_negative():
+    assert to_signed(0b11111111, 8) == -1
+
+
+def test_swap16():
+    assert swap16(0x1234) == 0x3412
+
+
+def test_swap32():
+    assert swap32(0x11223344) == 0x44332211
+
+
+def test_fs_remove_dir_content(tmp_dir: Path):
+    f = tmp_dir / "a.txt"
+    f.write_text("hello")
+
+    fs_remove_dir_content(str(tmp_dir))
+
+    assert list(tmp_dir.iterdir()) == []
+
+
+def test_file_get_latest(tmp_dir: Path):
+    f1 = tmp_dir / "a.txt"
+    f2 = tmp_dir / "b.txt"
+    f1.write_text("1")
+    f2.write_text("2")
+
+    latest = file_get_latest(str(tmp_dir), "*.txt")
+    if latest:
+        assert latest.endswith("b.txt")
+
+
+def test_yaml_config_create_and_save(yaml_config_path):
+    cfg = YamlConfig(str(yaml_config_path))
+    cfg.config["a"] = 1
+    cfg.save()
+
+    cfg2 = YamlConfig(str(yaml_config_path))
+    assert cfg2.config["a"] == 1
+
+
+def test_log_dbg():
+    logdbg("hello 12345")
+    assert True
+
+
+def test_show_tmp(tmp_path):
+    # Show value of tmp_path fixture
+    print(f"Show value of tmp_path fixture: {tmp_path}")

difonlib-0.2.2a1/src/difonlib.egg-info/requires.txt

@@ -1,9 +0,0 @@
-evdev>=1.9.2
-nicegui>=3.2.0
-pexpect>=4.9.0
-pyyaml>=6.0.3
-tinytuya>=1.17.4
-types-pexpect>=4.9.0.20250916
-types-PyYAML>=6.0.12.20250915
-types-xmltodict>=1.0.1.20250920
-xmltodict>=1.0.2

difonlib-0.2.2a1/tests/test_utils.py

@@ -1,6 +0,0 @@
-from difonlib.utils import logdbg
-
-
-def test_log_dbg():
-    logdbg("hello 12345")
-    assert True