difonlib 0.2.2__py3-none-any.whl

difonlib/input_devs.py

@@ -0,0 +1,209 @@
+from pathlib import Path
+from evdev import InputDevice, categorize
+from evdev.events import KeyEvent
+from typing import Dict, Any, List, Optional
+from difonlib.utils import logdbg
+from dataclasses import dataclass
+import re
+import asyncio
+
+dbg = logdbg
+
+# import asyncio
+
+KEY_LONG_PRESSED = 1000
+KEY_LONG_TIME_HOLD = 0.7
+
+
+@dataclass
+class IDevKbd:
+    """event: /dev/input/eventX"""
+
+    name: str = ""
+    uniq: str = ""
+    event = ""
+
+
+@dataclass
+class IDevKbdKey:
+    scancode: int = 0
+    hold_time: float = 0
+    keycode: str | tuple = ""
+
+
+def get_connected_input_devices() -> List[Dict[str, Any]]:
+    path = Path("/proc/bus/input/devices")
+    devices: List[Dict[str, Any]] = []
+    dev: Dict[str, Any] = {}
+
+    with open(path, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line:  # пустая строка -> новый девайс
+                if dev:
+                    devices.append(dev)
+                    dev = {}
+                continue
+
+            key = line[0]
+            value = line[3:]  # пропускаем "X: "
+
+            if key == "I":
+                # I: Bus=0003 Vendor=05ac Product=024f Version=0111
+                dev["I"] = dict(item.split("=") for item in value.split())
+            elif key in ("N", "P", "S", "U", "H"):
+                # Строковые поля
+                k, v = value.strip().split("=", 1)
+                dev[k] = v.strip('"')
+            elif key == "B":
+                # B: PROP=0 или B: KEY=... B: EV=...
+                bkey, bval = value.split("=", 1)
+                if "B" not in dev:
+                    dev["B"] = {}
+                dev["B"][bkey] = bval
+            else:
+                dev[key] = value
+
+        # не забыть последний блок, так, на всякий случай. Обычно его там нет.
+        if dev:
+            devices.append(dev)
+
+    return devices
+
+
+def idev_get_by_field(field: str, field_value: str) -> Optional[List[IDevKbd]]:
+    """If device connected by bluetooth - field 'Uniq' is mac address"""
+    conn_devs = get_connected_input_devices()
+    # dbg(f" = conn_devs: {conn_devs}")  # //Dima
+    try:
+        devs = [dev for dev in conn_devs if dev[field] == field_value]
+    except Exception:
+        return None
+    kdevs = None
+    if devs:
+        kdevs = []
+        for dev in devs:
+            kdev = IDevKbd()
+            kdev.name = dev["Name"]
+            kdev.uniq = dev["Uniq"]
+            kdev.event = re.findall(r"event\d+", dev["Handlers"])[0]
+            kdevs.append(kdev)
+    return kdevs
+
+
+def idev_key_monitor(dev_event: str) -> Optional[IDevKbdKey]:
+    """
+    Wait for any pressed key on dev_event
+    Return: ( key_event.scancode, hold_time, key_event.keycode )"""
+
+    press_time: float | None = None  # timer key down timestamp
+    key: IDevKbdKey | None = None
+
+    dev = InputDevice(f"/dev/input/{dev_event}")
+    dbg(f"Listening on: {dev.name}")
+
+    for event in dev.read_loop():
+        # if event.type == ecodes.EV_KEY:
+        key_event = categorize(event)
+
+        if not isinstance(key_event, KeyEvent):
+            continue
+
+        if key_event.keystate == KeyEvent.key_down:
+            press_time = key_event.event.timestamp()
+
+        elif key_event.keystate == KeyEvent.key_up and press_time is not None:
+            key = IDevKbdKey()
+            key.hold_time = round(key_event.event.timestamp() - press_time, 2)
+            key.scancode = key_event.scancode
+            key.keycode = (
+                key_event.keycode
+                if not isinstance(key_event.keycode, list)
+                else key_event.keycode[0]
+            )
+            break
+    dev.close()
+    return key
+
+
+async def idev_get_pressed_key(dev_event: str, timeout: int = 5) -> Optional[IDevKbdKey]:
+    """
+    Wait timeout seconds for pressed key on dev_event
+    """
+    dev = InputDevice(f"/dev/input/{dev_event}")
+    dbg(f" - Listening on: {dev.name}")
+    # key = await _get_first_key_event(dev)
+    try:
+        # asyncio.wait_for ограничивает выполнение асинхронной задачи по времени
+        key = await asyncio.wait_for(
+            # Вложенная функция, которая читает loop и возвращает первое событие
+            _get_first_key_event(dev),
+            timeout=timeout,
+        )
+        return key
+    except asyncio.CancelledError:
+        print(" =!= idev_get_pressed_key cancelled")
+        raise
+    except asyncio.TimeoutError:
+        print(f" =!= Timeout ({timeout} sec)")
+    except Exception as e:
+        print(f" =!= Error: {e}")
+
+    finally:
+        dev.close()
+    return None
+
+
+async def _get_first_key_event(dev: InputDevice) -> Optional[IDevKbdKey]:
+    press_time: float | None = None
+
+    async for event in dev.async_read_loop():
+        key_event = categorize(event)
+
+        if not isinstance(key_event, KeyEvent):
+            continue
+
+        if key_event.keystate == KeyEvent.key_down:
+            press_time = key_event.event.timestamp()
+
+        elif key_event.keystate == KeyEvent.key_up and press_time is not None:
+            key = IDevKbdKey()
+            key.hold_time = round(key_event.event.timestamp() - press_time, 2)
+            key.scancode = key_event.scancode
+            key.keycode = (
+                key_event.keycode
+                if not isinstance(key_event.keycode, list)
+                else key_event.keycode[0]
+            )
+            return key
+
+    return None
+
+
+# U: Uniq=40:b4:cd:ce:31:d6
+if __name__ == "__main__":
+    dbg(" == START ==")  # //Dima
+    # devs = get_connected_input_devices()
+    # print_dicts_list(devs)
+    # dbg(f"---------------------------------------------")  # //Dima
+    # exit()
+    devs = idev_get_by_field("Name", "Keychron Keychron K5")
+    if devs:
+        for dev in devs:
+            dbg(f"dev: {dev.__dict__}")  # //Dima
+
+    devs = idev_get_by_field(field="Uniq", field_value="40:b4:cd:ce:31:d6")
+    # print(repr(f"dev: {dev.__dict__}"))
+    if devs:
+        dev = devs[0]
+        dbg(f"Input dev: {dev.__dict__}")
+
+        key = idev_key_monitor(dev.event)
+        dbg(f"Pressed key: {key.__dict__}")
+
+        key = asyncio.run(idev_get_pressed_key(dev.event))
+        if key:
+            dbg(f"Pressed key: {key}")
+            dbg(f"Pressed key: {key.__dict__}")
+
+    dbg(" == FINISH ==")  # //Dima

difonlib/ng_lib.py

@@ -0,0 +1,151 @@
+from nicegui import ui
+import inspect
+import asyncio
+from typing import Any, Callable, Awaitable, Dict, List, Optional, Union, Literal
+
+from difonlib.utils import logdbg
+
+dbg = logdbg
+
+
+class CardTable:
+    _current_yes_handler: Optional[Callable[[], Union[None, Awaitable[None]]]] = None
+
+    def __init__(
+        self,
+        title: str,
+        columns: list,
+        rows: list = [],
+        selection: Optional[Literal["single", "multiple"]] = None,  # single, multiple or None
+        on_selection_change: List[Callable] = [],  # Handlers on_selection_change event
+    ):
+        self.on_selection_change: list = on_selection_change
+        # A list of buttons that change state (active, inactive) when table rows are selected or deselected.
+        self.buttons_on_row_select_changed: list = []
+
+        """Карточка с таблицей и встроенным диалогом подтверждения."""
+        with ui.card().classes("p-4 shadow-lg") as self.card:
+            # --- Заголовок ---
+            with ui.row().classes("items-center justify-between w-full mb-2"):
+                ui.label(f"📋 {title}").classes("text-green-700 text-lg font-bold")
+                with ui.row().classes("gap-2") as self.top_table:
+                    pass
+
+            # --- Таблица ---
+            self.table = ui.table(
+                columns=columns,
+                rows=self.enum_data(rows),
+                row_key="sn",
+                selection=selection,
+                on_select=self._on_selection_change,
+                column_defaults={
+                    "align": "left",
+                    "headerClasses": "uppercase",
+                },
+            ).classes("w-full shadow-lg bg-black-900 text-gray-200")
+
+            # --- Диалог подтверждения ---
+            with ui.dialog() as self.confirm_dialog, ui.card().classes("p-4"):
+                self.dialog_title = ui.label().classes("text-lg font-bold mb-4")
+                with ui.row().classes("justify-end w-full gap-2"):
+                    ui.button("No", color="gray", on_click=self.confirm_dialog.close)
+                    ui.button("Yes", color="red", on_click=self._on_yes_clicked)
+
+            # --- Диалог "Processing..." ---
+            with (
+                ui.dialog() as self.processing_dialog,
+                ui.card().classes("p-4 items-center justify-center"),
+            ):
+                with ui.row().classes("items-center gap-3"):
+                    self.processing_spinner = ui.spinner(size="md")
+                    self.processing_label = ui.label("Processing...").classes("text-base")
+
+    def visible(self, state: Literal[True, False]) -> None:
+        if state:
+            self.table.visible = True
+            self.card.visible = True
+        else:
+            self.table.visible = False
+            self.card.visible = False
+
+    async def _on_selection_change(self, e: Any) -> None:
+        for btn in self.buttons_on_row_select_changed:
+            if e.selection:
+                dbg("Da")  # //Dima
+                btn.classes("!bg-blue-500", remove="!bg-gray-500").enable()
+            else:
+                dbg("Net")  # //Dima
+                btn.classes("!bg-gray-500", remove="!bg-blue-500").disable()
+        dbg(f"** self.on_selection_change: {self.on_selection_change}")  # //Dima
+        for handler in self.on_selection_change:
+            await handler(e)
+
+    async def _on_yes_clicked(self) -> None:
+        """Обработка подтверждения с показом диалога 'Processing...'."""
+        handler: Optional[Callable[[], Union[None, Awaitable[None]]]] = self._current_yes_handler
+        self._current_yes_handler = None
+        self.confirm_dialog.close()
+
+        if not handler:
+            return
+
+        # --- Показать диалог "Processing..." ---
+        self.processing_dialog.open()
+
+        try:
+            if inspect.iscoroutinefunction(handler):
+                await handler()
+                await asyncio.sleep(0.3)  # плавность UX
+            else:
+                handler()
+        finally:
+            self.processing_dialog.close()
+
+    def enum_data(self, data: List[Dict]) -> List[Dict]:
+        return [{"sn": i + 1, **row} for i, row in enumerate(data)]
+
+    def set_rows(self, rows: List[Dict]) -> None:
+        self.table.rows = self.enum_data(rows)
+        self.table.update()
+
+    # def add_handler_on_selection_change(self, handler: Callable[[Any]]) -> None:
+    #     if handler in self.on_selection_change:
+    #         return
+    #     self.on_selection_change.append(handler)
+
+    def add_button(
+        self,
+        btn_txt: str,
+        on_click: Callable,
+        default_enable: bool = True,  # enable the added button by default
+        color: str = "blue",
+        active_on_rows_selected: bool = False,  # activate button when row(s) is selected, if True - always actived
+        use_dialog_confirm: bool = False,
+        confirm_title: Optional[str] = None,
+    ) -> ui.button:
+        """Добавляет кнопку в заголовок таблицы, с опциональным подтверждением."""
+        with self.top_table:
+            btn = ui.button(btn_txt, color=color)
+
+        if active_on_rows_selected:
+            self.buttons_on_row_select_changed.append(btn)
+        if default_enable:
+            btn.classes("!bg-blue-500", remove="!bg-gray-500").enable()
+        else:
+            btn.classes("!bg-gray-500", remove="!bg-blue-500").disable()
+
+        dbg(f"btns: {self.buttons_on_row_select_changed}")  # //Dima
+
+        # --- Без диалога ---
+        if not use_dialog_confirm:
+            btn.on_click(on_click)
+            return btn
+
+        # --- С подтверждением ---
+        async def handle_click() -> None:
+            self.dialog_title.text = confirm_title or f"Confirm {btn_txt}?"
+            self._current_yes_handler = on_click
+            self.confirm_dialog.open()
+
+        btn.on_click(handle_click)
+        return btn

difonlib/remctrl.py

@@ -0,0 +1,157 @@
+import asyncio
+from difonlib.input_devs import idev_get_pressed_key, IDevKbdKey
+from difonlib.utils import logdbg, YamlConfig
+from typing import List, Optional  # Dict, Any, List
+
+dbg = logdbg
+
+KEY_LONG_PRESSED_TIME = 0.7
+KEY_LONG_PRESSED_CONST = 1000
+
+
+class RemoteControls:
+    """
+    Remote Control.
+    1. Learn buttons
+       Bind func_keys with remote control buttons
+    2. Run monitor service of remote control pressed button (async mode)
+    """
+
+    def __init__(self, config_file_name: str) -> None:
+        # Load(create) config file
+        self.config = YamlConfig(config_file_name)
+        if self.config.config == {}:
+            self.config.config["infrared_devs"] = {}  # {dev_id:xxx, dev_local_key:xxx}
+            self.config.config["remctrl_devs"] = {}
+            self.config.config["func_keys"] = []
+            self.config.save()
+
+        self.cfg_ir_devs = self.config.config["infrared_devs"]
+        self.cfg_rc_devs = self.config.config["remctrl_devs"]
+        self.cfg_func_keys = self.config.config["func_keys"]
+
+        # if self.func_keys != self.cfg_func_keys:
+        #     self.cfg_func_keys = self.func_keys
+        #     self.config.save()
+
+    def set_func_keys(self, func_keys: List[str]) -> None:
+        if func_keys != self.cfg_func_keys:
+            self.config.config.update({"func_keys": func_keys})
+            self.cfg_func_keys = self.config.config["func_keys"]
+            self.config.save()
+
+    def remove_func_btn(self, remctrl_name: str, func_key: Optional[str] = None) -> None:
+        if not func_key:
+            # remove remctrl_name from config
+            try:
+                self.config.config.pop(remctrl_name)
+            except Exception:
+                pass
+        else:
+            self.config.config[remctrl_name][func_key] = None
+        self.config.save()
+
+    def get_func_btn(self, rem_ctrl_name: Optional[str] = None) -> list:
+        rem_ctrl = self.cfg_rc_devs.get(rem_ctrl_name)
+        if rem_ctrl:
+            dbg(f" * rem_ctrl: {rem_ctrl}")  # //Dima
+            fs = [{f: rem_ctrl.get(f)} for f in self.cfg_func_keys]
+            return fs
+        fs = [{f: None} for f in self.cfg_func_keys]
+        return fs
+
+    def get_func_btn_format(
+        self,
+        func_field_name: str,
+        btn_field_name: str,
+        rem_ctrl_name: Optional[str] = None,
+    ) -> list:
+        _rows = self.get_func_btn(rem_ctrl_name)
+        rows = [
+            {
+                func_field_name: list(row.keys())[0],
+                btn_field_name: list(row.values())[0],
+            }
+            for row in _rows
+        ]
+        return rows
+
+    async def devs_monitor(self) -> None:
+        """
+        Monitor input event devices for pressed key
+        Detect pressed key and call handler('KEY_XXXXXX')
+        """
+        pass
+
+    async def get_pressed_button(self, dev_event: str, timeout: int = 7) -> Optional[IDevKbdKey]:
+        key = await idev_get_pressed_key(dev_event, timeout=timeout)
+        dbg(f" * Pressed KEY: {key}")  # //Dima
+        return key
+
+    async def learn_button(
+        self, idev_name: str, idev_event: str, func_key: str, timeout: int = 10
+    ) -> Optional[IDevKbdKey]:
+        # dbg(f"self.cfg_func_keys: {self.cfg_func_keys}")  # //Dima
+        if func_key not in self.cfg_func_keys:
+            print(f" =!= func_key: '{func_key}' is not exist")
+            return None
+
+        # dbg(f"*** CONFIG: {self.config.config}")  # //Dima
+        # idev_name = idev["name"]
+        # # dev_uniq = idev["mac"]
+        # idev_event = idev["event"]
+        key = await idev_get_pressed_key(idev_event, timeout=timeout)
+        dbg(f" * Pressed KEY: {key}")  # //Dima
+        if key:
+            key_scan_code = key.scancode
+            if key.hold_time > KEY_LONG_PRESSED_TIME:
+                key_scan_code += KEY_LONG_PRESSED_CONST
+            if not self.cfg_rc_devs.get(idev_name):
+                self.cfg_rc_devs[idev_name] = {}
+            # self.config.config["remctrl_devs"].add(dev_uniq)
+            self.cfg_rc_devs[idev_name].update({func_key: key_scan_code})
+            self.config.save()
+
+        return key
+
+
+if __name__ == "__main__":
+
+    REMOTE_CTRL_CONFIG = "./___remctrl_devs_config.yaml"
+    func_keys = [
+        "KEY_PREV",
+        "KEY_PLAY_ALBUM",
+        "KEY_PAUSE_PLAY",
+        "KEY_NEXT",
+        "KEY_SEEKCUR",
+        "KEY_RADIO",
+        "KEY_JUKEBOX_ON",
+        "KEY_PLAY_LIKE",
+        "KEY_SET_LIKE",
+        "KEY_VOL+",
+        "KEY_VOL-",
+        "KEY_OnOff",
+        "KEY_EXT_DISP",
+    ]
+
+    rc = RemoteControls(REMOTE_CTRL_CONFIG)
+    rc.set_func_keys(func_keys)
+
+    from difonlib.input_devs import idev_get_by_field
+
+    remctrl_name = "Amazon Fire TV Remote Keyboard"
+    idev_kbd = idev_get_by_field(field="Name", field_value=remctrl_name)
+
+    if idev_kbd:
+        key = asyncio.run(
+            rc.learn_button(
+                idev_name=remctrl_name,
+                idev_event=idev_kbd[0].event,
+                func_key="KEY_PAUSE_PLAY",
+            )
+        )
+        dbg(f"key: {key}")  # //Dima
+    else:
+        dbg(f"The Input Device '{remctrl_name}' is not connected.")  # //Dima
+    fb = rc.get_func_btn(remctrl_name)
+    dbg(f"Function-Button: {fb}")  # //Dima