ex4nicegui 0.6.5__tar.gz → 0.6.6__tar.gz

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ex4nicegui
-Version: 0.6.5
+Version: 0.6.6
 Summary: Extension library based on nicegui, providing data responsive,BI functionality modules
 Home-page: 
 Author: carson_jia
@@ -420,6 +420,31 @@ ui.button("change b", on_click=change_b)
 
 ---
 
+### `new_scope`
+
+By default, all watch functions are automatically destroyed when the client connection is disconnected. For finer-grained control, the `new_scope` function can be utilized.
+
+```python
+from nicegui import ui
+from ex4nicegui import rxui, to_ref, effect, new_scope
+
+a = to_ref(0.0)
+
+scope1 = new_scope()
+
+@scope1.run
+def _():
+    @effect
+    def _():
+        print(f"scope 1:{a.value}")
+
+
+rxui.number(value=a)
+rxui.button("dispose scope 1", on_click=scope1.dispose)
+```
+
+---
+
 ## functionality
 
 ### vmodel

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/README.md

@@ -414,6 +414,31 @@ ui.button("change b", on_click=change_b)
 
 ---
 
+### `new_scope`
+
+默认情况下，所有检测函数在客户端连接断开时自动销毁。如果需要更细粒度的控制，可以使用 `new_scope`
+
+```python
+from nicegui import ui
+from ex4nicegui import rxui, to_ref, effect, new_scope
+
+a = to_ref(0.0)
+
+scope1 = new_scope()
+
+@scope1.run
+def _():
+    @effect
+    def _():
+        print(f"scope 1:{a.value}")
+
+
+rxui.number(value=a)
+rxui.button("dispose scope 1", on_click=scope1.dispose)
+```
+
+---
+
 
 ## 组件功能
 

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/ex4nicegui/__init__.py

@@ -20,7 +20,7 @@ from ex4nicegui.utils.signals import (
     is_reactive,
 )
 from ex4nicegui.utils.asyncComputed import async_computed
-
+from ex4nicegui.utils.clientScope import new_scope
 
 __all__ = [
     "async_computed",
@@ -43,6 +43,7 @@ __all__ = [
     "batch",
     "to_raw",
     "is_setter_ref",
+    "new_scope",
 ]
 
-__version__ = "0.6.5"
+__version__ = "0.6.6"

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/ex4nicegui/bi/elements/ui_echarts.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Callable, Dict, Union, cast
 from nicegui.events import UiEventArguments
 from ex4nicegui.reactive import rxui
-from ex4nicegui.reactive.EChartsComponent.ECharts import (
-    EChartsMouseEventArguments,
-    echarts,
-)
+from ex4nicegui.reactive.EChartsComponent.ECharts import echarts
 from nicegui import ui
 from ex4nicegui.bi.dataSource import DataSource
 from .models import UiResult
@@ -21,7 +18,7 @@ class EChartsResult(UiResult[echarts]):
         super().__init__(element, dataSource)
         self.chart_update = chart_update
 
-    def on_chart_click(self, handler: Callable[[EChartsMouseEventArguments], Any]):
+    def on_chart_click(self, handler: Callable[[UiEventArguments], Any]):
         return self.element.echarts_on("click", handler)
 
     def on_chart_click_blank(self, handler: Callable[[UiEventArguments], Any]):

ex4nicegui-0.6.6/ex4nicegui/reactive/EChartsComponent/ECharts.js

@@ -0,0 +1,112 @@
+import { convertDynamicProperties } from "../../static/utils/dynamic_properties.js";
+
+function collectMapRegisterTask() {
+  const tasks = new Map();
+
+  if (typeof window.ex4ngEchartsMapTasks !== "undefined") {
+
+    for (const [mapName, src] of window.ex4ngEchartsMapTasks.entries()) {
+
+      const registerPromise = new Promise((resolve, reject) => {
+        fetch(src)
+          .then((response) => response.json())
+          .then((data) => {
+            echarts.registerMap(mapName, data);
+            resolve();
+          });
+
+      });
+
+      tasks.set(mapName, registerPromise);
+    }
+  }
+
+  return tasks;
+}
+
+function hasMapOrGeo(options) {
+  if (options) {
+    const hasMapSeries = options.series && Array.isArray(options.series) &&
+      options.series.some(seriesItem =>
+        seriesItem.type === 'map' ||
+        seriesItem.type === 'lines'
+      );
+
+    const hasGeoConfig = options.geo && (typeof options.geo === 'object' || Array.isArray(options.geo));
+
+    return hasMapSeries || hasGeoConfig;
+  }
+  return false;
+}
+
+const mapRegisterTasks = collectMapRegisterTask();
+
+export default {
+  template: "<div></div>",
+  async mounted() {
+    await this.$nextTick(); // wait for Tailwind classes to be applied
+
+    if (hasMapOrGeo(this.options)) {
+      await Promise.all(Array.from(mapRegisterTasks.values()));
+    }
+
+    this.chart = echarts.init(this.$el, this.theme);
+
+    this.resizeObs = new ResizeObserver(this.chart.resize)
+
+    // Prevent interruption of chart animations due to resize operations.
+    // It is recommended to register the callbacks for such an event before setOption.
+    const createResizeObserver = () => {
+      this.resizeObs.observe(this.$el);
+      this.chart.off("finished", createResizeObserver);
+    };
+    this.chart.on("finished", createResizeObserver);
+
+    if (this.options) {
+      this.update_chart();
+    } else {
+      const fn = new Function('return ' + this.code)()
+      fn(this.chart)
+      this.$emit("__update_options_from_client", this.chart.getOption())
+    }
+    this.chart.getZr().on("click", (e) => {
+      if (!e.target) {
+        this.$emit("clickBlank")
+      }
+    });
+
+  },
+  beforeDestroy() {
+    this.chart.dispose();
+    this.resizeObs.unobserve();
+  },
+  beforeUnmount() {
+    this.chart.dispose();
+    this.resizeObs.unobserve();
+  },
+  methods: {
+    update_chart(opts) {
+      convertDynamicProperties(this.options, true);
+      this.chart.setOption(this.options, opts ?? { notMerge: this.chart.options?.series.length != this.options.series.length });
+    },
+
+    echarts_on(eventName, query) {
+      this.chart.on(eventName.replace(/^chart:/, ''), query, (e) => {
+        this.$emit(eventName, e);
+      });
+    },
+
+    run_chart_method(name, ...args) {
+      if (name.startsWith(":")) {
+        name = name.slice(1);
+        args = args.map((arg) => new Function("return " + arg)());
+      }
+      return runMethod(this.chart, name, args);
+    },
+  },
+  props: {
+    options: Object | undefined,
+    theme: String | Object | undefined,
+    code: String | undefined,
+  },
+};

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/ex4nicegui/reactive/EChartsComponent/ECharts.py

@@ -3,70 +3,26 @@ from typing import (
     Any,
     Callable,
     Dict,
-    List,
     Optional,
     Union,
 )
-from typing_extensions import Literal
-from dataclasses import dataclass
-from nicegui.dataclasses import KWONLY_SLOTS
-from nicegui.events import (
-    handle_event,
-    UiEventArguments,
-)
+
+from nicegui.events import handle_event, UiEventArguments, GenericEventArguments
 from nicegui.element import Element
 from nicegui.awaitable_response import AwaitableResponse
-from nicegui import ui
 from pathlib import Path
 import nicegui
-import uuid
+
+from .types import (
+    _T_event_name,
+)
+from ex4nicegui.reactive.deferredTask import DeferredTask
+from .utils import get_bound_event_args, create_event_handler_args
 
 NG_ROOT = Path(nicegui.__file__).parent / "elements"
 libraries = [NG_ROOT / "lib/echarts/echarts.min.js"]
 
 
-_Chart_Click_Args = [
-    "componentType",
-    "seriesType",
-    "seriesIndex",
-    "seriesName",
-    "name",
-    "dataIndex",
-    "data",
-    "dataType",
-    "value",
-    "color",
-]
-
-
-@dataclass(**KWONLY_SLOTS)
-class EChartsMouseEventArguments(UiEventArguments):
-    componentType: str
-    seriesType: str
-    seriesIndex: int
-    seriesName: str
-    name: str
-    dataIndex: int
-    data: dict
-    dataType: Optional[str]
-    value: Any
-    color: str
-
-
-_T_echats_on_callback = Callable[[EChartsMouseEventArguments], Any]
-_T_mouse_event_name = Literal[
-    "click",
-    "dblclick",
-    "mousedown",
-    "mousemove",
-    "mouseup",
-    "mouseover",
-    "mouseout",
-    "globalout",
-    "contextmenu",
-]
-
-
 class echarts(Element, component="ECharts.js", libraries=libraries):  # type: ignore
     def __init__(
         self,
@@ -74,6 +30,7 @@ class echarts(Element, component="ECharts.js", libraries=libraries):  # type: ig
         code: Optional[str] = None,
     ) -> None:
         super().__init__()
+        self.__deferred_task = DeferredTask()
 
         if (options is None) and (bool(code) is False):
             raise ValueError("At least one of options and code must be valid.")
@@ -89,36 +46,6 @@ class echarts(Element, component="ECharts.js", libraries=libraries):  # type: ig
         self._props["options"] = options
         self._props["code"] = code
 
-        self._echarts_on_tasks: List[Callable] = []
-        self._echarts_on_callback_map: Dict[str, _T_echats_on_callback] = {}
-
-        async def on_client_connect(
-            client: nicegui.Client,
-        ) -> Any:
-            await client.connected()
-
-            for func in self._echarts_on_tasks:
-                func()
-
-            client.connect_handlers.remove(on_client_connect)  # type: ignore
-
-        ui.context.client.on_connect(on_client_connect)
-
-        def echartsOn_handler(e):
-            callbackId = e.args["callbackId"]
-            params: Dict = e.args["params"]
-            params["dataType"] = params.get("dataType")
-
-            if callbackId in self._echarts_on_callback_map:
-                event_args = EChartsMouseEventArguments(
-                    sender=e.sender, client=e.client, **params
-                )
-                handler = self._echarts_on_callback_map[callbackId]
-
-                handle_event(handler, event_args)
-
-        self.on("event_on", echartsOn_handler)
-
     def update_chart(
         self,
         merge_opts: Optional[dict] = None,
@@ -164,34 +91,24 @@ class echarts(Element, component="ECharts.js", libraries=libraries):  # type: ig
                 ),
             )
 
-        self.on(
-            "clickBlank",
-            inner_handler,
-            _Chart_Click_Args,
-        )
+        self.on("clickBlank", inner_handler)
 
     def echarts_on(
         self,
-        event_name: _T_mouse_event_name,
-        handler: _T_echats_on_callback,
+        event_name: _T_event_name,
+        handler: Callable[[UiEventArguments], None],
         query: Optional[Union[str, Dict]] = None,
     ):
-        if not ui.context.client.has_socket_connection:
+        def org_handler(e: GenericEventArguments) -> None:
+            event_args = create_event_handler_args(event_name, e)
+            handle_event(handler, event_args)
 
-            def task_func():
-                self.echarts_on(event_name, handler, query)
+        ui_event_name = f"chart:{event_name}"
+        super().on(ui_event_name, org_handler, args=get_bound_event_args(event_name))
 
-            self._echarts_on_tasks.append(task_func)
-            return
-
-        callback_id = uuid.uuid4().hex
-        self.run_method(
-            "echarts_on",
-            event_name,
-            query,
-            callback_id,
-        )
-        self._echarts_on_callback_map[callback_id] = handler
+        @self.__deferred_task.register
+        def _():
+            self.run_method("echarts_on", ui_event_name, query)
 
     def run_chart_method(
         self, name: str, *args, timeout: float = 1, check_interval: float = 0.01

ex4nicegui-0.6.6/ex4nicegui/reactive/EChartsComponent/events.py

@@ -0,0 +1,26 @@
+from typing import (
+    Any,
+    Optional,
+)
+from dataclasses import dataclass, fields
+from nicegui.dataclasses import KWONLY_SLOTS
+from nicegui.events import (
+    UiEventArguments,
+)
+
+
+@dataclass(**KWONLY_SLOTS)
+class EChartsMouseEventArguments(UiEventArguments):
+    componentType: str
+    seriesType: str
+    seriesIndex: int
+    seriesName: str
+    name: str
+    dataIndex: int
+    data: dict
+    dataType: Optional[str]
+    value: Any
+    color: str
+
+
+_Mouse_Event_Arguments_Fields = [f.name for f in fields(EChartsMouseEventArguments)]

ex4nicegui-0.6.6/ex4nicegui/reactive/EChartsComponent/types.py

@@ -0,0 +1,51 @@
+from typing import (
+    Union,
+)
+from typing_extensions import Literal
+
+
+_T_mouse_event_name = Literal[
+    "click",
+    "dblclick",
+    "mousedown",
+    "mousemove",
+    "mouseup",
+    "mouseover",
+    "mouseout",
+    "globalout",
+    "contextmenu",
+]
+
+_T_generic_event_name = Literal[
+    "highlight",
+    "downplay",
+    "selectchanged",
+    "legendselectchanged",
+    "legendselected",
+    "legendunselected",
+    "legendselectall",
+    "legendinverseselect",
+    "legendscroll",
+    "datazoom",
+    "datarangeselected",
+    "graphroam",
+    "georoam",
+    "treeroam",
+    "timelinechanged",
+    "timelineplaychanged",
+    "restore",
+    "dataviewchanged",
+    "magictypechanged",
+    "geoselectchanged",
+    "geoselected",
+    "geounselected",
+    "axisareaselected",
+    "brush",
+    "brushEnd",
+    "brushselected",
+    "globalcursortaken",
+    "rendered",
+    "finished",
+]
+
+_T_event_name = Union[_T_mouse_event_name, _T_generic_event_name]

ex4nicegui-0.6.6/ex4nicegui/reactive/EChartsComponent/utils.py

@@ -0,0 +1,44 @@
+from typing import List, Optional
+import typing
+from .types import _T_event_name, _T_mouse_event_name
+from .events import EChartsMouseEventArguments, _Mouse_Event_Arguments_Fields
+from nicegui.events import UiEventArguments, GenericEventArguments
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def _get_mouse_event_names():
+    return set(typing.get_args(_T_mouse_event_name))
+
+
+def is_mouse_event(event_name: _T_event_name) -> bool:
+    return event_name in _get_mouse_event_names()
+
+
+def get_bound_event_args(event_name: _T_event_name) -> Optional[List[str]]:
+    if is_mouse_event(event_name):
+        return _Mouse_Event_Arguments_Fields
+
+    return None
+
+
+def create_event_handler_args(
+    event_name: _T_event_name, e: GenericEventArguments
+) -> UiEventArguments:
+    if is_mouse_event(event_name):
+        return EChartsMouseEventArguments(
+            sender=e.sender,
+            client=e.client,
+            componentType=e.args["componentType"],
+            seriesType=e.args["seriesType"],
+            seriesIndex=e.args["seriesIndex"],
+            seriesName=e.args["seriesName"],
+            name=e.args["name"],
+            dataIndex=e.args["dataIndex"],
+            data=e.args["data"],
+            dataType=e.args.get("dataType"),
+            value=e.args["value"],
+            color=e.args["color"],
+        )
+
+    return GenericEventArguments(sender=e.sender, client=e.client, args=e.args)

ex4nicegui-0.6.6/ex4nicegui/reactive/deferredTask.py

@@ -0,0 +1,29 @@
+from typing import Callable
+from nicegui import ui, Client as ng_client
+
+
+class DeferredTask:
+    def __init__(self):
+        self._tasks = []
+
+        async def on_client_connect(
+            client: ng_client,
+        ):
+            await client.connected()
+
+            for task in self._tasks:
+                task()
+
+            self._tasks.clear()
+
+            # Avoid events becoming ineffective due to page refresh when sharing the client.
+            if not client.shared:
+                client.connect_handlers.remove(on_client_connect)  # type: ignore
+
+        ui.context.client.on_connect(on_client_connect)
+
+    def register(self, task: Callable[..., None]):
+        if ui.context.client.has_socket_connection:
+            task()
+        else:
+            self._tasks.append(task)

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/ex4nicegui/reactive/officials/echarts.py

@@ -1,9 +1,6 @@
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Union, cast, Optional
-from typing_extensions import Literal
 from ex4nicegui.reactive.utils import ParameterClassifier
-from ex4nicegui.utils.signals import on
-
 from ex4nicegui.utils.signals import (
     ReadonlyRef,
     is_ref,
@@ -11,28 +8,16 @@ from ex4nicegui.utils.signals import (
     _TMaybeRef as TMaybeRef,
     to_value,
     to_raw,
+    on,
 )
 from .base import BindableUi
-from ex4nicegui.reactive.EChartsComponent.ECharts import (
-    echarts,
-    EChartsMouseEventArguments,
-)
+from ex4nicegui.reactive.EChartsComponent.ECharts import echarts
+from ex4nicegui.reactive.EChartsComponent.types import _T_event_name
+from ex4nicegui.reactive.EChartsComponent.events import EChartsMouseEventArguments
 
 from nicegui.awaitable_response import AwaitableResponse
 from nicegui import ui, app
 
-_TEventName = Literal[
-    "click",
-    "dblclick",
-    "mousedown",
-    "mousemove",
-    "mouseup",
-    "mouseover",
-    "mouseout",
-    "globalout",
-    "contextmenu",
-]
-
 
 class EChartsBindableUi(BindableUi[echarts]):
     EChartsMouseEventArguments = EChartsMouseEventArguments
@@ -50,6 +35,7 @@ class EChartsBindableUi(BindableUi[echarts]):
         value_kws = pc.get_values_kws()
 
         element = echarts(**value_kws).classes("grow self-stretch h-[16rem]")
+
         super().__init__(element)  # type: ignore
 
         self.__update_setting = None
@@ -78,17 +64,17 @@ class EChartsBindableUi(BindableUi[echarts]):
         ui.add_body_html(
             rf"""
             <script>
-                window.addEventListener('DOMContentLoaded', () => {{
-                    fetch("{src}")
-                        .then((response) => response.json())
-                        .then((data) => {{
-                            echarts.registerMap('{map_name}', data);
-                        }});
-                }});
+                if (typeof window.ex4ngEchartsMapTasks === "undefined") {{ 
+                    window.ex4ngEchartsMapTasks = new Map();
+                }}
+
+                window.ex4ngEchartsMapTasks.set('{map_name}', '{src}');
             </script>
         """
         )
 
+        return cls
+
     @classmethod
     def from_pyecharts(cls, chart: TMaybeRef):
         if is_ref(chart):
@@ -147,7 +133,7 @@ class EChartsBindableUi(BindableUi[echarts]):
 
     def on(
         self,
-        event_name: _TEventName,
+        event_name: _T_event_name,
         handler: Callable[..., Any],
         query: Optional[Union[str, Dict]] = None,
     ):
@@ -224,6 +210,7 @@ class EChartsBindableUi(BindableUi[echarts]):
         ---
         """
         self.element.echarts_on(event_name, handler, query)
+        return self
 
     def run_chart_method(
         self, name: str, *args, timeout: float = 1, check_interval: float = 0.01

{ex4nicegui-0.6.5 → ex4nicegui-0.6.6}/ex4nicegui/reactive/officials/number.py

@@ -4,6 +4,7 @@ from typing import (
     Optional,
     TypeVar,
     Dict,
+    Union,
 )
 from ex4nicegui.reactive.utils import ParameterClassifier
 from ex4nicegui.utils.apiEffect import ui_effect
@@ -25,7 +26,7 @@ class NumberBindableUi(BindableUi[ui.number]):
         label: Optional[TMaybeRef[str]] = None,
         *,
         placeholder: Optional[TMaybeRef[str]] = None,
-        value: Optional[TMaybeRef[float]] = None,
+        value: Optional[Union[TMaybeRef[float], TMaybeRef[int]]] = None,
         min: Optional[TMaybeRef[float]] = None,
         max: Optional[TMaybeRef[float]] = None,
         step: Optional[TMaybeRef[float]] = None,