ex4nicegui 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

ex4nicegui/reactive/__init__.py

@@ -70,7 +70,7 @@ from .mermaid.mermaid import Mermaid as mermaid
 from .officials.dialog import DialogBindableUi as dialog
 from .vfor import vfor, VforStore
 from .vmodel import vmodel
-from .view_model import ViewModel, var, cached_var
+from .view_model import ViewModel, var, cached_var, list_var
 
 pagination = q_pagination
 
@@ -97,6 +97,7 @@ __all__ = [
     "ViewModel",
     "var",
     "cached_var",
+    "list_var",
     "html",
     "aggrid",
     "button",

ex4nicegui/reactive/base.py

@@ -48,6 +48,8 @@ _T_bind_classes_type = Union[
     _T_bind_classes_type_ref_dict,
     _T_bind_classes_type_single,
     _T_bind_classes_type_array,
+    Dict[str, bool],
+    List[str],
 ]
 
 
@@ -150,6 +152,56 @@ class BindableUi(Generic[TWidget]):
         """
         return self.element.remove(element)
 
+    @overload
+    def bind_props(self, props: Dict[str, TMaybeRef[Any]]) -> Self: ...
+
+    @overload
+    def bind_props(self, props: TMaybeRef[str]) -> Self: ...
+
+    def bind_props(self, props: Union[Dict[str, TMaybeRef[Any]], TMaybeRef[str]]):
+        """data binding is manipulating an element's props
+
+        Args:
+            props (Union[Dict[str, TMaybeRef[Any]], TMaybeRef[str]]): dict of prop name and ref value
+
+        ## usage
+
+        .. code-block:: python
+            outlined = to_ref(True)
+            size = to_ref("xs")
+
+            def props_str():
+                return f'{"flat" if flat.value else ""} {"size=" + size.value}'
+
+            rxui.button("click me").bind_props(props_str)
+            rxui.button("click me").bind_props({
+                "outlined": outlined,
+                "size": size,
+            })
+
+        """
+        if isinstance(props, dict):
+
+            def props_str():
+                props_dict = (
+                    f"""{name if isinstance(raw_value,bool) else f"{name}='{raw_value}'"}"""
+                    for name, value in props.items()
+                    if (raw_value := to_value(value))
+                )
+
+                return " ".join(props_dict)
+
+            self._bind_props_for_str_fn(props_str)
+        else:
+            self._bind_props_for_str_fn(props)
+
+        return self
+
+    def _bind_props_for_str_fn(self, props_str: TMaybeRef[str]):
+        @self._ui_signal_on(props_str, onchanges=False, deep=False)
+        def _(state: WatchedState):
+            self.props(add=state.current, remove=state.previous)
+
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef[Any]):
         """data binding is manipulating an element's property
 
@@ -179,7 +231,7 @@ class BindableUi(Generic[TWidget]):
 
         return self
 
-    def bind_visible(self, value: TGetterOrReadonlyRef[bool]):
+    def bind_visible(self, value: TMaybeRef[bool]):
         @self._ui_effect
         def _():
             element = cast(ui.element, self.element)
@@ -187,7 +239,7 @@ class BindableUi(Generic[TWidget]):
 
         return self
 
-    def bind_not_visible(self, value: TGetterOrReadonlyRef[bool]):
+    def bind_not_visible(self, value: TMaybeRef[bool]):
         return self.bind_visible(lambda: not to_value(value))
 
     def on(
@@ -216,26 +268,28 @@ class BindableUi(Generic[TWidget]):
         cast(ui.element, self.element).clear()
 
     @overload
-    def bind_classes(self, classes: Dict[str, TGetterOrReadonlyRef[bool]]) -> Self:
-        ...
+    def bind_classes(self, classes: Dict[str, TGetterOrReadonlyRef[bool]]) -> Self: ...
+
+    @overload
+    def bind_classes(self, classes: Dict[str, bool]) -> Self: ...
 
     @overload
-    def bind_classes(self, classes: TGetterOrReadonlyRef[Dict[str, bool]]) -> Self:
-        ...
+    def bind_classes(self, classes: TGetterOrReadonlyRef[Dict[str, bool]]) -> Self: ...
 
     @overload
-    def bind_classes(self, classes: List[TGetterOrReadonlyRef[str]]) -> Self:
-        ...
+    def bind_classes(self, classes: List[TGetterOrReadonlyRef[str]]) -> Self: ...
 
     @overload
-    def bind_classes(self, classes: TGetterOrReadonlyRef[str]) -> Self:
-        ...
+    def bind_classes(self, classes: List[str]) -> Self: ...
+
+    @overload
+    def bind_classes(self, classes: TGetterOrReadonlyRef[str]) -> Self: ...
 
     def bind_classes(self, classes: _T_bind_classes_type) -> Self:
         """data binding is manipulating an element's class list
 
-        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind-class-names
-        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#%E7%BB%91%E5%AE%9A%E7%B1%BB%E5%90%8D
+        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind_classes
+        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#bind_classes
 
         Args:
             classes (_T_bind_classes_type): dict of refs | ref to dict | str ref | list of refs
@@ -271,52 +325,51 @@ class BindableUi(Generic[TWidget]):
 
         """
         if isinstance(classes, dict):
-            for name, ref_obj in classes.items():
-
-                @self._ui_effect
-                def _(name=name, ref_obj=ref_obj):
-                    if to_value(ref_obj):
-                        self.classes(add=name)
-                    else:
-                        self.classes(remove=name)
+            self._bind_classes_for_str_fn(
+                lambda: " ".join(
+                    name for name, value in classes.items() if to_value(value)
+                )
+            )
 
+        elif isinstance(classes, list):
+            self._bind_classes_for_str_fn(
+                lambda: " ".join(to_value(c) for c in classes)
+            )
         elif is_ref(classes) or isinstance(classes, Callable):
             ref_obj = to_value(classes)  # type: ignore
 
             if isinstance(ref_obj, dict):
 
-                @self._ui_effect
-                def _():
-                    for name, value in cast(Dict, to_value(classes)).items():  # type: ignore
-                        if value:
-                            self.classes(add=name)
-                        else:
-                            self.classes(remove=name)
-            else:
-                self._bind_single_class(cast(_T_bind_classes_type_single, classes))
+                def classes_str():
+                    return " ".join(
+                        name
+                        for name, value in to_value(classes).items()  # type: ignore
+                        if to_value(value)
+                    )
 
-        elif isinstance(classes, list):
-            for ref_name in classes:
-                self._bind_single_class(ref_name)
+                self._bind_classes_for_str_fn(classes_str)
+
+            else:
+                self._bind_classes_for_str_fn(classes)  # type: ignore
 
         return self
 
-    def _bind_single_class(self, class_name: _T_bind_classes_type_single):
-        if is_ref(class_name) or isinstance(class_name, Callable):
+    def _bind_classes_for_str_fn(self, classes_str: TGetterOrReadonlyRef[str]):
+        @self._ui_signal_on(classes_str, onchanges=False, deep=False)
+        def _(state: WatchedState):
+            self.classes(add=state.current, remove=state.previous)
 
-            @on(class_name)
-            def _(state: WatchedState):
-                self.classes(add=state.current, remove=state.previous)
-        else:
-            self.classes(class_name)  # type: ignore
+    @overload
+    def bind_style(self, style: TMaybeRef[str]) -> Self: ...
 
-        return self
+    @overload
+    def bind_style(self, style: Dict[str, TMaybeRef[Any]]) -> Self: ...
 
-    def bind_style(self, style: Dict[str, TGetterOrReadonlyRef[Any]]):
+    def bind_style(self, style: Union[TMaybeRef[str], Dict[str, TMaybeRef[Any]]]):
         """data binding is manipulating an element's style
 
-        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind-style
-        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#bind-style
+        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind_style
+        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#bind_style
 
         Args:
             style (Dict[str, Union[ReadonlyRef[str], Ref[str]]]): dict of style name and ref value
@@ -337,16 +390,21 @@ class BindableUi(Generic[TWidget]):
 
         """
         if isinstance(style, dict):
-            for name, ref_obj in style.items():
-                if is_ref(ref_obj) or isinstance(ref_obj, Callable):
-
-                    @self._ui_effect
-                    def _(name=name, ref_obj=ref_obj):
-                        self.element._style[name] = str(to_value(ref_obj))
-                        self.element.update()
+            self._bind_style_for_str_fn(
+                lambda: ";".join(
+                    f"{name}:{to_value(value)}" for name, value in style.items()
+                )
+            )
+        else:
+            self._bind_style_for_str_fn(style)
 
         return self
 
+    def _bind_style_for_str_fn(self, style_str: TMaybeRef[str]):
+        @self._ui_signal_on(style_str, onchanges=False, deep=False)
+        def _(state: WatchedState):
+            self.style(add=state.current, remove=state.previous)
+
     def scoped_style(self, selector: str, style: Union[str, Path]):
         """add scoped style to the element
 

ex4nicegui/reactive/mixins/backgroundColor.py

@@ -5,10 +5,7 @@ from typing import (
 )
 
 import signe
-from ex4nicegui.utils.signals import (
-    TGetterOrReadonlyRef,
-    WatchedState,
-)
+from ex4nicegui.utils.signals import WatchedState, TMaybeRef
 from nicegui import ui
 from ex4nicegui.reactive.systems import color_system
 
@@ -17,10 +14,9 @@ class BackgroundColorableMixin(Protocol):
     _ui_signal_on: Callable[[Callable[..., Any]], signe.Effect[None]]
 
     @property
-    def element(self) -> ui.element:
-        ...
+    def element(self) -> ui.element: ...
 
-    def _bind_background_color(self, value: TGetterOrReadonlyRef[str]):
+    def _bind_background_color(self, value: TMaybeRef[str]):
         @self._ui_signal_on(value, onchanges=False)  # type: ignore
         def _(state: WatchedState):
             if state.previous is not None:
@@ -30,7 +26,7 @@ class BackgroundColorableMixin(Protocol):
 
             self.element.update()
 
-    def bind_color(self, color: TGetterOrReadonlyRef[str]):
+    def bind_color(self, color: TMaybeRef[str]):
         """bind color to the element
 
         Args:

ex4nicegui/reactive/mixins/disableable.py

@@ -8,10 +8,7 @@ from typing import (
 )
 
 import signe
-from ex4nicegui.utils.signals import (
-    TGetterOrReadonlyRef,
-    to_value,
-)
+from ex4nicegui.utils.signals import to_value, TMaybeRef
 from nicegui.elements.mixins.disableable_element import DisableableElement
 
 
@@ -22,10 +19,9 @@ class DisableableMixin(Protocol):
     _ui_effect: Callable[[Callable[..., Any]], signe.Effect[None]]
 
     @property
-    def element(self) -> DisableableElement:
-        ...
+    def element(self) -> DisableableElement: ...
 
-    def bind_enabled(self, value: TGetterOrReadonlyRef[bool]):
+    def bind_enabled(self, value: TMaybeRef[bool]):
         @self._ui_effect
         def _():
             raw_value = to_value(value)
@@ -34,7 +30,7 @@ class DisableableMixin(Protocol):
 
         return self
 
-    def bind_disable(self, value: TGetterOrReadonlyRef[bool]):
+    def bind_disable(self, value: TMaybeRef[bool]):
         @self._ui_effect
         def _():
             raw_value = not to_value(value)

ex4nicegui/reactive/mixins/textColor.py

@@ -9,6 +9,7 @@ import signe
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     WatchedState,
+    TMaybeRef,
 )
 from nicegui import ui
 from ex4nicegui.reactive.systems import color_system
@@ -18,10 +19,9 @@ class TextColorableMixin(Protocol):
     _ui_signal_on: Callable[[Callable[[TGetterOrReadonlyRef[str]], Any]], signe.Effect]
 
     @property
-    def element(self) -> ui.element:
-        ...
+    def element(self) -> ui.element: ...
 
-    def _bind_text_color(self, color: TGetterOrReadonlyRef[str]):
+    def _bind_text_color(self, color: TMaybeRef[str]):
         @self._ui_signal_on(color, onchanges=False)  # type: ignore
         def _(state: WatchedState):
             if state.previous is not None:
@@ -31,7 +31,7 @@ class TextColorableMixin(Protocol):
 
             self.element.update()
 
-    def bind_color(self, color: TGetterOrReadonlyRef[str]):
+    def bind_color(self, color: TMaybeRef[str]):
         """bind text color to the element
 
         Args:
@@ -46,16 +46,14 @@ class HtmlTextColorableMixin(Protocol):
     _ui_signal_on: Callable[[Callable[[TGetterOrReadonlyRef[str]], Any]], signe.Effect]
 
     @property
-    def element(self) -> ui.element:
-        ...
+    def element(self) -> ui.element: ...
 
-    def bind_style(self, style: Dict[str, TGetterOrReadonlyRef[Any]]):
-        ...
+    def bind_style(self, style: Dict[str, TMaybeRef[Any]]): ...
 
-    def _bind_text_color(self, value: TGetterOrReadonlyRef[str]):
+    def _bind_text_color(self, value: TMaybeRef[str]):
         return self.bind_style({"color": value})
 
-    def bind_color(self, color: TGetterOrReadonlyRef[str]):
+    def bind_color(self, color: TMaybeRef[str]):
         """bind text color to the element
 
         Args:

ex4nicegui/reactive/officials/checkbox.py

@@ -35,7 +35,6 @@ class CheckboxBindableUi(
         )
 
         value_kws = pc.get_values_kws()
-
         element = ui.checkbox(**value_kws)
         super().__init__(element)  # type: ignore
 

ex4nicegui/reactive/officials/input.py

@@ -90,7 +90,7 @@ class LazyInputBindableUi(InputBindableUi):
         password_toggle_button: TMaybeRef[bool] = False,
         on_change: Optional[Callable[..., Any]] = None,
         autocomplete: Optional[TMaybeRef[List[str]]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[Dict[str, Callable[..., bool]]] = None,
     ) -> None:
         org_value = value
         is_setter_value = is_setter_ref(value)

ex4nicegui/reactive/officials/textarea.py

@@ -27,7 +27,7 @@ class TextareaBindableUi(BindableUi[ui.textarea], ValueElementMixin[str]):
         placeholder: Optional[TMaybeRef[str]] = None,
         value: TMaybeRef[str] = "",
         on_change: Optional[Callable[..., Any]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[Dict[str, Callable[..., bool]]] = None,
     ) -> None:
         pc = ParameterClassifier(
             locals(),
@@ -68,7 +68,7 @@ class LazyTextareaBindableUi(TextareaBindableUi):
         placeholder: Optional[TMaybeRef[str]] = None,
         value: TMaybeRef[str] = "",
         on_change: Optional[Callable[..., Any]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[Dict[str, Callable[..., bool]]] = None,
     ) -> None:
         org_value = value
         is_setter_value = is_setter_ref(value)

ex4nicegui/reactive/services/reactive_service.py

@@ -15,6 +15,7 @@ from ex4nicegui.reactive.systems.reactive_system import (
     convert_kws_ref2value,
     inject_method,
 )
+from ex4nicegui.utils.proxy import is_base_type_proxy
 
 
 class ParameterClassifier:
@@ -34,7 +35,7 @@ class ParameterClassifier:
             exclude.append(extend_kws)
 
         self._args: Dict[str, Any] = {
-            k: v
+            k: v._ref if is_base_type_proxy(v) else v
             for k, v in args.items()
             if k != "self" and k[0] != "_" and (k not in exclude)
         }

ex4nicegui/reactive/vfor.py

@@ -28,6 +28,8 @@ from dataclasses import dataclass
 from signe.core.scope import Scope
 from ex4nicegui.reactive.systems.object_system import get_attribute
 from ex4nicegui.reactive.empty import Empty
+from ex4nicegui.utils.proxy import to_ref_if_base_type_proxy
+
 
 _T = TypeVar("_T")
 _T_data = Union[List[Any], TGetterOrReadonlyRef[List[Any]], RefWrapper]
@@ -178,6 +180,8 @@ class vfor(Generic[_T]):
         *,
         key: Optional[Union[str, Callable[[int, Any], Any]]] = None,
     ) -> None:
+        data = to_ref_if_base_type_proxy(data)
+
         self._data = to_ref_wrapper(lambda: data) if is_reactive(data) else data
         self._get_key = vfor.index_key
         self._transition_props = {}

ex4nicegui/reactive/view_model.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Callable, Union, Type, TypeVar
+from typing import Any, Callable, List, Optional, Union, Type, TypeVar, overload
 from ex4nicegui.utils.signals import (
     deep_ref,
     is_ref,
@@ -13,8 +13,16 @@ from ex4nicegui.utils.signals import (
 from ex4nicegui.utils.types import ReadonlyRef
 from functools import partial
 from signe.core.reactive import NoProxy
+from ex4nicegui.utils.proxy.descriptor import class_var_setter
+from ex4nicegui.utils.proxy.bool import BoolProxy
+from ex4nicegui.utils.proxy.int import IntProxy
+from ex4nicegui.utils.proxy.float import FloatProxy
+from ex4nicegui.utils.proxy.base import Proxy
+from ex4nicegui.utils.proxy import to_value_if_base_type_proxy
+from ex4nicegui.utils.proxy.descriptor import ProxyDescriptor
 
 _CACHED_VARS_FLAG = "__vm_cached__"
+_LIST_VAR_FLAG = "__vm_list_var__"
 
 _T = TypeVar("_T")
 
@@ -31,15 +39,30 @@ class ViewModel(NoProxy):
         from ex4nicegui import rxui
 
         class MyVm(rxui.ViewModel):
-            count = rxui.var(0)
-            data = rxui.var(lambda: [1,2,3])
+            count = 0
+            data = []
+            nums = rxui.list_var(lambda: [1, 2, 3])
+
+            def __init__(self):
+                super().__init__()
+                self.data = [1, 2, 3]
+
+            def increment(self):
+                self.count += 1
+
+            def add_data(self):
+                self.data.append(4)
+
 
         vm = MyVm()
 
         rxui.label(vm.count)
         rxui.number(value=vm.count)
 
-
+        ui.button("Increment", on_click=vm.increment)
+        ui.button("Add Data", on_click=vm.add_data)
+        rxui.label(vm.data)
+        rxui.label(vm.nums)
     """
 
     def __init__(self):
@@ -49,8 +72,86 @@ class ViewModel(NoProxy):
             if callable(value) and hasattr(value, _CACHED_VARS_FLAG):
                 setattr(self, name, computed(partial(value, self)))
 
+    def __init_subclass__(cls) -> None:
+        need_vars = (
+            (name, value)
+            for name, value in vars(cls).items()
+            if not name.startswith("_")
+        )
+
+        for name, value in need_vars:
+            class_var_setter(cls, name, value, _LIST_VAR_FLAG)
+
+    @overload
+    @staticmethod
+    def on_refs_changed(vm: ViewModel): ...
+
+    @overload
+    @staticmethod
+    def on_refs_changed(
+        vm: ViewModel, callback: Optional[Callable[[], Any]] = None
+    ): ...
+
+    @staticmethod
+    def on_refs_changed(vm: ViewModel, callback: Optional[Callable[[], Any]] = None):
+        if callback is None:
+
+            def wrapper(fn: Callable[[], Any]):
+                return ViewModel.on_refs_changed(vm, fn)
+
+            return wrapper
+
+        refs = ViewModel.get_refs(vm)
+
+        @on(refs, onchanges=True, deep=False)
+        def _():
+            callback()
+
+    @staticmethod
+    def get_refs(vm: ViewModel):
+        """Get all the refs of a ViewModel.
+
+        Args:
+            vm (ViewModel): The ViewModel to get refs from.
+
+
+        """
+        var_names = [
+            name
+            for name, value in vm.__class__.__dict__.items()
+            if isinstance(value, ProxyDescriptor)
+        ]
+
+        return [getattr(vm, name) for name in var_names]
+
+    @staticmethod
+    def to_value(value: Union[ViewModel, Proxy, List, dict]):
+        """Convert a ViewModel, Proxy, List, or dict to a value.
+
+        Args:
+            value (Union[ViewModel, Proxy, List, dict]):  The value to convert.
+
+        """
+        if isinstance(value, list):
+            return [ViewModel.to_value(v) for v in value]
+
+        if isinstance(value, dict):
+            return {k: ViewModel.to_value(v) for k, v in value.items()}
+
+        if isinstance(value, ViewModel):
+            return {
+                k: ViewModel.to_value(v)
+                for k, v in value.__dict__.items()
+                if not k.startswith("_")
+            }
+
+        if isinstance(value, Proxy):
+            return to_value_if_base_type_proxy(value)
+
+        return value
+
     @staticmethod
-    def display(model: Union[ViewModel, Type]):
+    def _display(model: Union[ViewModel, Type]):
         result = to_ref("")
 
         watch_refs = _recursive_to_refs(model)
@@ -67,6 +168,18 @@ class ViewModel(NoProxy):
 
         return result
 
+    @staticmethod
+    def is_bool(value: Any):
+        return isinstance(value, bool) or isinstance(value, BoolProxy)
+
+    @staticmethod
+    def is_int(value: Any):
+        return isinstance(value, int) or isinstance(value, IntProxy)
+
+    @staticmethod
+    def is_float(value: Any):
+        return isinstance(value, float) or isinstance(value, FloatProxy)
+
 
 def _recursive_to_value(value_or_model):
     value = to_raw(to_value(value_or_model))
@@ -139,6 +252,34 @@ def var(value: Union[_T_Var_Value, Callable[[], _T_Var_Value]]) -> Ref[_T_Var_Va
     return deep_ref(value)
 
 
+def list_var(factory: Callable[[], List[_T_Var_Value]]) -> List[_T_Var_Value]:
+    """Create implicitly proxied reactive variables for lists. Use them just like ordinary lists while maintaining reactivity. Only use within rxui.ViewModel.
+
+    Args:
+        factory (Callable[[], List[_T_Var_Value]]): A factory function that returns a new list.
+
+    Example:
+    .. code-block:: python
+        from ex4nicegui import rxui
+        class State(rxui.ViewModel):
+            data = rxui.list_var(lambda: [1, 2, 3])
+
+            def append_data(self):
+                self.data.append(len(self.data) + 1)
+
+            def display_data(self):
+                return ",".join(map(str, self.data))
+
+        state = State()
+        ui.button("Append", on_click=state.append_data)
+        rxui.label(state.display_data)
+
+    """
+    assert callable(factory), "factory must be a callable"
+    setattr(factory, _LIST_VAR_FLAG, None)
+    return factory  # type: ignore
+
+
 def cached_var(func: Callable[..., _T]) -> ReadonlyRef[_T]:
     """A decorator to cache the result of a function. Only use within rxui.ViewModel.
 
@@ -149,7 +290,7 @@ def cached_var(func: Callable[..., _T]) -> ReadonlyRef[_T]:
     .. code-block:: python
         from ex4nicegui import rxui
         class MyVm(rxui.ViewModel):
-            name = rxui.var("John")
+            name = "John"
 
             @rxui.cached_var
             def uppper_name(self):

ex4nicegui/utils/proxy/__init__.py

@@ -0,0 +1,19 @@
+from .base import Proxy
+
+
+def is_base_type_proxy(obj):
+    return isinstance(obj, Proxy)
+
+
+def to_ref_if_base_type_proxy(obj):
+    if is_base_type_proxy(obj):
+        return obj._ref
+    else:
+        return obj
+
+
+def to_value_if_base_type_proxy(obj):
+    if is_base_type_proxy(obj):
+        return obj._ref.value
+    else:
+        return obj

ex4nicegui/utils/proxy/base.py

@@ -0,0 +1,9 @@
+from typing import Any, Protocol
+
+
+class ProxyProtocol(Protocol):
+    _ref: Any
+
+
+class Proxy(ProxyProtocol):
+    pass