difonlib 0.4.3__tar.gz → 0.4.4__tar.gz

{difonlib-0.4.3 → difonlib-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: difonlib
-Version: 0.4.3
+Version: 0.4.4
 Summary: python libraries
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{difonlib-0.4.3 → difonlib-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "difonlib"
-version = "0.4.3"
+version = "0.4.4"
 description = "python libraries"
 readme = "README.md"
 requires-python = ">=3.12"

{difonlib-0.4.3 → difonlib-0.4.4}/src/difonlib/ng_lib.py

@@ -2,7 +2,7 @@ from nicegui import ui
 import inspect
 import asyncio
 from typing import Any, Callable, Awaitable, Literal
-
+import threading
 from difonlib.utils import logdbg
 
 dbg = logdbg
@@ -28,6 +28,103 @@ ui.add_css(
 
 
 class DialogBox:
+
+    async def dialog_processing(
+        self,
+        proc: Callable,
+        proc_cancel_event: bool = False,
+        label_txt: str = "Processing...",
+        label_txt_color: str = "green",
+        timeout: int | None = None,
+    ) -> tuple[Literal["Canceled", "Timeout"] | None, Any | None]:
+        """
+        See examples in ng_lib_test3.py
+        def proc_dummy2(cancel_event: threading.Event) -> None:
+            for i in range(10, 0, -1):
+                if cancel_event.is_set():
+                    print(f"Exit")
+                    return
+                print(f"Remaining: {i}")
+                time.sleep(1)
+        async def aproc_dummy(cnt: int = 20):
+            for i in range(cnt, 0, -1):
+                print(f"aRemaining: {i}")
+                await asyncio.sleep(1)
+            return 125
+
+        async def proc_dialog():
+            err, result = await dialog_box.dialog_processing(
+                functools.partial(aproc_dummy, cnt=4), timeout=5
+            )
+        dbg(f"ERROR: {err}; Result: {result}")  # //Dima
+        ui.button(
+           "Test processing dialog",
+           on_click=proc_dialog,
+        )
+        """
+        task_proc: asyncio.Task | None = None
+        cancel_event = None
+        if proc_cancel_event:
+            cancel_event = threading.Event()
+
+        async def countdown(timeout: int, label: ui.label) -> None:
+            for counter in range(timeout, 0, -1):
+                label.text = f"{label_txt}{counter}"
+                await asyncio.sleep(1)
+
+        canceled = False
+        ret_value: Any | None = None
+        err: Literal["Canceled", "Timeout"] | None = None
+
+        async def on_cancel() -> None:
+            nonlocal canceled
+            canceled = True
+            if cancel_event:
+                cancel_event.set()
+            if task_proc:
+                task_proc.cancel()
+            dialog.close()
+
+        text_color = f"text-{label_txt_color}-500"
+        with (
+            ui.dialog().props("persistent") as dialog,
+            ui.card().classes("p-4 items-center justify-center"),
+        ):
+            with ui.row().classes("items-center gap-3"):
+                ui.spinner(size="md")
+                label = ui.label(f"{label_txt}").classes(f"{text_color} text-2xl")
+                ui.button("Cancel", on_click=on_cancel)
+        dialog.open()
+        task_count: asyncio.Task | None = None
+        if timeout:
+            task_count = asyncio.create_task(countdown(timeout=timeout, label=label))
+
+        if proc_cancel_event:
+            if inspect.iscoroutinefunction(getattr(proc, "func", proc)):
+                task_proc = asyncio.create_task(proc(cancel_event))
+            else:
+                task_proc = asyncio.create_task(asyncio.to_thread(proc, cancel_event))
+        else:
+            if inspect.iscoroutinefunction(getattr(proc, "func", proc)):
+                task_proc = asyncio.create_task(proc())
+            else:
+                task_proc = asyncio.create_task(asyncio.to_thread(proc))
+
+        try:
+            ret_value = await asyncio.wait_for(task_proc, timeout=timeout)
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            if cancel_event:
+                cancel_event.set()
+            err = "Canceled" if canceled else "Timeout"
+            ui.notify(err)
+
+        finally:
+            if task_count and not task_count.cancelled():
+                task_count.cancel()
+            dialog.close()
+
+            return (err, ret_value)
+
     async def dialog_ok(self, text: str = "Hello!)") -> None:
         with ui.dialog().props("persistent") as dialog, ui.card():
             ui.label(text=text)
@@ -155,33 +252,32 @@ class CardTable:
         """Add field 'name', needed for Quasar GUI"""
         return [{**col, "name": col.get("name", col["field"])} for col in columns]
 
-    def set_row_display_filter(self, field_name: str, field_value: str | bool) -> None:
+    def set_row_display_filter(self, **field: str | bool) -> None:
         """
-        card_table.set_row_display_filter("id","123456")
-         Show rows with field id='123456':
-        card_table.row_display_filter(state_on=True)
-         Show all rows:
-        card_table.row_display_filter()
+        card_table.set_row_display_filter(id="123456")
+        card_table.set_row_display_filter(_marked=True)
         """
+        assert len(field) == 1, "❌ Exactly one field expected"
+        field_name, field_value = next(iter(field.items()))
         if isinstance(field_value, bool):
-            self.filter_value = field_value
+            self.filter_value = str(field_value).lower()  # "true" / "false" для JS
         else:
             self.filter_value = f"\\'{field_value}\\'"
-
         self.table.props(rf"""
             :filter-method="(rows, terms) => !terms ? rows : rows.filter(r => r.{field_name} === terms)"
             """)
 
     def row_display_filter(self, state_on: bool = False) -> None:
         """
-        card_table.set_row_display_filter(field_name="id", field_value="123456")
+          Show rows with field id='123456' :
+        card_table.set_row_display_filter(id="123456")
         card_table.row_display_filter(state_on=True)
-         Show rows with field id='123456'
-        card_table.set_row_display_filter("_marked", True)
+          Show rows with field _marked=True :
+        card_table.set_row_display_filter(_marked=True)
         card_table.row_display_filter(True)
-         Show rows with field _marked=True
+          Show all rows:
+        card_table.row_display_filter()
         """
-        dbg(f"self.filter_value: {self.filter_value}")  # //Dima
         if state_on:
             self.table.props(f':filter="{self.filter_value}"')
         else:

{difonlib-0.4.3 → difonlib-0.4.4}/src/difonlib/ng_lib_test3.py

@@ -1,12 +1,37 @@
+import asyncio
 from nicegui import ui
 from ng_lib import CardTable, DialogBox
 import functools
+import threading
+import time
 
 from difonlib.bt_utils import logdbg
 
 dbg = logdbg
 
 
+def proc_dummy2(cancel_event: threading.Event) -> None:
+    for i in range(10, 0, -1):
+        if cancel_event.is_set():
+            print("Exit")
+            return
+        print(f"Remaining: {i}")
+        time.sleep(1)
+
+
+def proc_dummy(cnt: int = 20) -> None:
+    for i in range(cnt, 0, -1):
+        print(f"Remaining: {i}")
+        time.sleep(1)
+
+
+async def aproc_dummy(cnt: int = 20) -> int:
+    for i in range(cnt, 0, -1):
+        print(f"aRemaining: {i}")
+        await asyncio.sleep(1)
+    return 125
+
+
 @ui.page("/", dark=True)
 def main() -> None:
 
@@ -33,8 +58,8 @@ def main() -> None:
     found = card_table.mark_row(id="129956")
     print(f" ==> found: {found}")  # //Dima
 
-    card_table.set_row_display_filter("_marked", True)
-    # card_table.set_row_display_filter(field_name="id", field_value="123456")
+    card_table.set_row_display_filter(_marked=True)
+    # card_table.set_row_display_filter(id="123456")
 
     # self.table.props(':filter="\'online\'"')
     # self.table.update()
@@ -100,5 +125,24 @@ def main() -> None:
         on_click=dialog_input,
     )
 
+    async def proc_dialog() -> None:
+        err, result = await dialog_box.dialog_processing(
+            functools.partial(aproc_dummy, cnt=4), timeout=5
+        )
+        dbg(f"ERROR: {err}; Result: {result}")  # //Dima
+        ui.notify(f"ERROR: {err}; Result: {result}")
+
+    ui.button(
+        "Test processing dialog",
+        on_click=proc_dialog,
+        # on_click=lambda: dialog_box.dialog_processing(proc_dummy, timeout=4),
+        # on_click=lambda: dialog_box.dialog_processing(
+        #     functools.partial(aproc_dummy, cnt=5), timeout=6
+        # ),
+        # on_click=lambda: dialog_box.dialog_processing(
+        #     proc_dummy2, proc_cancel_event=True, timeout=4
+        # ),
+    )
+
 
 ui.run(port=1111)

{difonlib-0.4.3 → difonlib-0.4.4}/src/difonlib/tuya_devs.py

@@ -126,6 +126,11 @@ class TuyaDevs:
     #     return con_devs
 
     def dev_is_connected(self, dev_id: str, timeout: int = 8, rescan: bool = False) -> bool:
+        """
+        if rescan:
+           self.scan(timeout=timeout)
+        Check if dev_id in last scan list (self.devs_online)
+        """
         if rescan:
             # update self.devs_online
             self.scan(timeout=timeout)
@@ -178,9 +183,10 @@ class TuyaDevs:
         return dev
 
     def outlet_dev(self, dev_id: str, local_key: str) -> Optional[OutletDevice]:
-        """TurnOn/Off:
+        """TurnOn/Off & toggle:
         odev.turn_on()
         odev.turn_off()
+        odev.toggle()
         """
         try:
             dev = OutletDeviceM(

{difonlib-0.4.3 → difonlib-0.4.4}/src/difonlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: difonlib
-Version: 0.4.3
+Version: 0.4.4
 Summary: python libraries
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown