instaui 0.1.19__py2.py3-none-any.whl → 0.2.1__py2.py3-none-any.whl

instaui/arco/components/input.py

@@ -15,7 +15,7 @@ class Input(Element):
         value: typing.Optional[TMaybeRef[str]] = None,
         **kwargs: Unpack[component_types.TInput],
     ):
-        tag = f"a-input{'-'+ self._exten_name if self._exten_name else ''}"
+        tag = f"a-input{'-' + self._exten_name if self._exten_name else ''}"
         super().__init__(tag)
         try_setup_vmodel(self, value)
         self.props(handle_props(kwargs))  # type: ignore

instaui/arco/components/typography.py

@@ -17,7 +17,7 @@ class Typography(Element):
         text: typing.Optional[TMaybeRef[str]] = None,
         **kwargs: Unpack[component_types.TTypography],
     ):
-        tag = f"a-typography{'-'+ self._exten_name if self._exten_name else ''}"
+        tag = f"a-typography{'-' + self._exten_name if self._exten_name else ''}"
         super().__init__(tag)
 
         if text is not None:

instaui/boot_info.py

@@ -11,14 +11,14 @@ _colors = {
 
 
 def zero_boot_info(file: Path):
-    message = f"""{_app_message('zero')}
+    message = f"""{_app_message("zero")}
 {_arrow_right()}file: {_with_color(str(file))}
 """
     print(message)
 
 
 def web_boot_info(ip: str):
-    message = f"""{_app_message('web')}
+    message = f"""{_app_message("web")}
 {_arrow_right()}Local: {_with_color(str(ip), "blue")}
 """
     print(message)

instaui/components/component.py

@@ -11,16 +11,19 @@ from instaui.runtime import (
     check_default_app_slot_or_error,
 )
 from instaui.components.slot import SlotManager
-from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import (
+    ElementBindingMixin,
+    ElementBindingProtocol,
+)
 
 
 class Component(Jsonable):
-    def __init__(self, tag: Optional[Union[str, ElementBindingMixin]] = None):
+    def __init__(self, tag: Optional[Union[str, ElementBindingProtocol]] = None):
         check_default_app_slot_or_error(
             "Not allowed to create element outside of ui.page"
         )
 
-        self.tag = (
+        self._tag = (
             "div"
             if tag is None or tag == ""
             else (
@@ -41,7 +44,6 @@ class Component(Jsonable):
         self._slot_manager.default.__exit__(*_)
 
     def _to_json_dict(self) -> Dict:
-        data = super()._to_json_dict()
-        data["tag"] = self.tag
-
-        return data
+        return {
+            "tag": self._tag,
+        }

instaui/components/element.py

@@ -34,7 +34,10 @@ from .slot import SlotManager, Slot
 from instaui import consts
 from instaui.components.component import Component
 
-from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import (
+    ElementBindingMixin,
+    ElementBindingProtocol,
+)
 
 if TYPE_CHECKING:
     from instaui.event.event_mixin import EventMixin
@@ -79,7 +82,7 @@ class Element(Component):
     _default_classes: ClassVar[List[str]] = []
     _default_style: ClassVar[Dict[str, str]] = {}
 
-    def __init__(self, tag: Optional[Union[str, ElementBindingMixin]] = None):
+    def __init__(self, tag: Optional[Union[str, ElementBindingProtocol]] = None):
         if self.dependency:
             tag = self.dependency.tag_name or ""
 
@@ -100,7 +103,7 @@ class Element(Component):
         self._directives: Dict[Directive, None] = {}
 
         self._slot_manager = SlotManager()
-        self._element_ref: Optional[ElementRef] = None
+        self.__element_ref: Optional[ElementRef] = None
 
     def __init_subclass__(
         cls,
@@ -336,7 +339,7 @@ class Element(Component):
         self._directives[directive] = None
         return self
 
-    def display(self, value: Union[ElementBindingMixin[bool], bool]) -> Self:
+    def display(self, value: Union[ElementBindingProtocol, bool]) -> Self:
         return self.directive(Directive(is_sys=False, name="vshow", value=value))
 
     def event_dataset(self, data: Any, name: str = "event-data") -> Self:
@@ -347,7 +350,7 @@ class Element(Component):
         return self
 
     def element_ref(self, ref: ElementRef):
-        self._element_ref = ref
+        self.__element_ref = ref
         return self
 
     def update_dependencies(
@@ -464,10 +467,10 @@ class Element(Component):
                 app_slot.get_temp_component_dependency(tag_name, self.dependency)
             )
 
-        if self._element_ref:
+        if self.__element_ref:
             scope = get_current_scope()
-            data["eRef"] = self._element_ref._to_element_config()
-            scope.register_element_ref(self._element_ref)
+            data["eRef"] = self.__element_ref._to_element_config()
+            scope.register_element_ref(self.__element_ref)
 
         return data
 

instaui/components/html/button.py

@@ -5,15 +5,15 @@ from typing import (
     Optional,
 )
 from instaui.components.element import Element
-
 from instaui.event.event_mixin import EventMixin
 from instaui.vars.types import TMaybeRef
+from instaui.components.mixins import CanDisabledMixin
 
 if TYPE_CHECKING:
     pass
 
 
-class Button(Element):
+class Button(Element, CanDisabledMixin):
     def __init__(
         self,
         text: Optional[TMaybeRef[str]] = None,

instaui/components/html/input.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Union
 from instaui.components.element import Element
 from instaui.components.value_element import ValueElement
-
+from instaui.components.mixins import CanDisabledMixin
 from ._mixins import InputEventMixin
 
 if TYPE_CHECKING:
     from instaui.vars.types import TMaybeRef
 
 
-class Input(InputEventMixin, ValueElement[str]):
+class Input(InputEventMixin, CanDisabledMixin, ValueElement[str]):
     def __init__(
         self,
         value: Union[str, TMaybeRef[str], None] = None,

instaui/components/html/range.py

@@ -4,7 +4,7 @@ from instaui.components.element import Element
 from instaui.components.value_element import ValueElement
 from instaui import consts
 from instaui.vars.types import TMaybeRef
-from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingProtocol
 from ._mixins import InputEventMixin
 
 _T_value = Union[int, float]
@@ -31,7 +31,7 @@ class Range(InputEventMixin, ValueElement[_T_value]):
 
     def vmodel(
         self,
-        value: ElementBindingMixin,
+        value: ElementBindingProtocol,
         modifiers: Union[consts.TModifier, List[consts.TModifier], None] = None,
         *,
         prop_name: str = "value",

instaui/components/html/select.py

@@ -9,11 +9,12 @@ from instaui.components.element import Element
 from instaui.event.event_mixin import EventMixin
 from instaui.vars.types import TMaybeRef
 from instaui.components.vfor import VFor
+from instaui.components.mixins import CanDisabledMixin
 
 _T_Select_Value = Union[List[str], str]
 
 
-class Select(ValueElement[Union[List[str], str]]):
+class Select(CanDisabledMixin, ValueElement[Union[List[str], str]]):
     def __init__(
         self,
         value: Union[_T_Select_Value, TMaybeRef[_T_Select_Value], None] = None,
@@ -48,7 +49,7 @@ class Select(ValueElement[Union[List[str], str]]):
 
         return select
 
-    class Option(Element):
+    class Option(Element, CanDisabledMixin):
         def __init__(
             self,
             text: Optional[TMaybeRef[str]] = None,

instaui/components/html/textarea.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Union
 from instaui.components.element import Element
 from instaui.components.value_element import ValueElement
-
+from instaui.components.mixins import CanDisabledMixin
 from ._mixins import InputEventMixin
 
 if TYPE_CHECKING:
     from instaui.vars.types import TMaybeRef
 
 
-class Textarea(InputEventMixin, ValueElement[str]):
+class Textarea(InputEventMixin, CanDisabledMixin, ValueElement[str]):
     def __init__(
         self,
         value: Union[str, TMaybeRef[str], None] = None,

instaui/components/html/ul.py

@@ -4,7 +4,7 @@ from instaui.components.element import Element
 from .li import Li
 from instaui.components.vfor import VFor
 
-from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingProtocol
 
 
 class Ul(Element):
@@ -12,7 +12,7 @@ class Ul(Element):
         super().__init__("ul")
 
     @classmethod
-    def from_list(cls, data: Union[List, ElementBindingMixin[List]]) -> Ul:
+    def from_list(cls, data: Union[List, ElementBindingProtocol]) -> Ul:
         with Ul() as ul:
             with VFor(data) as items:
                 Li(items)

instaui/components/match.py

@@ -4,11 +4,11 @@ import typing
 from instaui.components.component import Component
 from instaui.runtime._app import new_scope
 
-from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingProtocol
 
 
 class Match(Component):
-    def __init__(self, on: ElementBindingMixin):
+    def __init__(self, on: ElementBindingProtocol):
         super().__init__("match")
         self._on = on
         self._default_case = None

instaui/components/mixins.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Any, Dict, Protocol, TYPE_CHECKING, Union
+from typing_extensions import Self
+from instaui.vars.types import TMaybeRef
+
+if TYPE_CHECKING:
+    from instaui.components.element import Element
+
+
+class PropsProtocol(Protocol):
+    def props(self, add: Union[str, Dict[str, Any], TMaybeRef]) -> Self: ...
+
+
+class CanDisabledMixin:
+    def disabled(self: PropsProtocol, disabled: TMaybeRef[bool] = True) -> Element:
+        return self.props({"disabled": disabled})  # type: ignore

instaui/components/vfor.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 from typing import (
     Dict,
-    List,
     Literal,
     Mapping,
     Optional,
@@ -17,7 +16,10 @@ from instaui.components.component import Component
 from instaui.vars.vfor_item import VForItem, VForDict, VForWithIndex
 from instaui.runtime._app import get_app_slot, new_scope
 
-from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import (
+    ElementBindingMixin,
+    ElementBindingProtocol,
+)
 
 _T = TypeVar("_T")
 
@@ -25,7 +27,7 @@ _T = TypeVar("_T")
 class VFor(Component, Generic[_T]):
     def __init__(
         self,
-        data: Union[Sequence[_T], ElementBindingMixin[List[_T]]],
+        data: Union[Sequence[_T], ElementBindingProtocol],
         *,
         key: Union[Literal["item", "index"], str] = "index",
     ):
@@ -117,10 +119,10 @@ class VFor(Component, Generic[_T]):
 
     @overload
     @classmethod
-    def range(cls, end: ElementBindingMixin[int]) -> VFor[int]: ...
+    def range(cls, end: ElementBindingProtocol) -> VFor[int]: ...
 
     @classmethod
-    def range(cls, end: Union[int, ElementBindingMixin[int]]) -> VFor[int]:
+    def range(cls, end: Union[int, ElementBindingProtocol]) -> VFor[int]:
         obj = cls(None)  # type: ignore
 
         num = (  # type: ignore
@@ -135,6 +137,6 @@ class VFor(Component, Generic[_T]):
 
     @classmethod
     def from_dict(
-        cls, data: Union[Mapping, pydantic.BaseModel, ElementBindingMixin[Dict]]
+        cls, data: Union[Mapping, pydantic.BaseModel, ElementBindingProtocol]
     ):
         return VForDict(VFor(data))  # type: ignore

instaui/event/web_event.py

@@ -5,15 +5,15 @@ from instaui.common.jsonable import Jsonable
 from instaui.runtime._app import get_current_scope, get_app_slot
 from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
 from instaui.handlers import event_handler
+from instaui import pre_setup as _pre_setup
 from .event_mixin import EventMixin
 
+
 _SYNC_TYPE = "sync"
 _ASYNC_TYPE = "async"
 
 P = ParamSpec("P")
 R = typing.TypeVar("R")
-_T_input = typing.TypeVar("_T_input")
-_T_output = typing.TypeVar("_T_output")
 
 
 class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
@@ -22,10 +22,15 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
         fn: typing.Callable[P, R],
         inputs: typing.Sequence[CanInputMixin],
         outputs: typing.Sequence[CanOutputMixin],
+        pre_setup: typing.Optional[typing.Dict] = None,
     ):
+        if pre_setup:
+            _pre_setup._check_args(pre_setup)
+
         self._inputs = inputs
         self._outputs = outputs
         self._fn = fn
+        self._pre_setup = pre_setup
 
         scope = get_current_scope()
         self._sid = scope.id
@@ -73,6 +78,9 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
         if self._outputs:
             data["set"] = [ref._to_output_config() for ref in self._outputs]
 
+        if self._pre_setup:
+            data["preSetup"] = _pre_setup.convert_config(self._pre_setup)
+
         return data
 
 
@@ -80,6 +88,7 @@ def event(
     *,
     inputs: typing.Optional[typing.Sequence] = None,
     outputs: typing.Optional[typing.Sequence] = None,
+    pre_setup: typing.Optional[typing.Dict] = None,
 ):
     """
     Creates an event handler decorator for binding reactive logic to component events.
@@ -92,6 +101,8 @@ def event(
         outputs (typing.Optional[typing.Sequence], optional): Targets (state variables, UI elements) that should
                                     update when this handler executes. Used for coordinating
                                     interface updates after the event is processed.
+        pre_setup (typing.Optional[typing.Dict], optional): A dictionary of pre-setup actions to be executed before the event executes.
+
 
     # Example:
     .. code-block:: python
@@ -106,6 +117,17 @@ def event(
         html.button("click me").on_click(plus_one)
         html.paragraph(a)
 
+    use pre_setup:
+    .. code-block:: python
+        a = ui.state(0)
+        task_running = ui.state(False)
+
+        @ui.event(inputs=[a], outputs=[a], pre_setup={task_running: True})
+        async def long_running_task(a):
+            await asyncio.sleep(3)
+            return a + 1
+
+        html.button("click me").on_click(long_running_task).disabled(task_running)
     """
 
     def wrapper(func: typing.Callable[P, R]):
@@ -113,6 +135,7 @@ def event(
             func,
             inputs or [],
             outputs=outputs or [],
+            pre_setup=pre_setup,
         )
 
     return wrapper

instaui/fastapi_server/_utils.py

@@ -1,12 +1,12 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Sequence
 from instaui.runtime._app import get_app_slot
-from instaui.skip import is_skip_output
+from instaui.response import response_data
 import pydantic
 
 
 class ResponseData(pydantic.BaseModel):
     values: Optional[List[Any]] = None
-    skips: Optional[List[int]] = None
+    types: Optional[Sequence[int]] = None
 
 
 def update_app_page_info(data: Dict):
@@ -22,21 +22,5 @@ def update_app_page_info(data: Dict):
         app._query_params = page_info["queryParams"]
 
 
-def response_data(outputs_binding_count: int, result: Any):
-    data = ResponseData()
-    if outputs_binding_count > 0:
-        if not isinstance(result, tuple):
-            result = [result]
-
-        result_infos = [(r, int(is_skip_output(r))) for r in result]
-
-        if len(result_infos) == 1 and result_infos[0][1] == 1:
-            return data
-
-        data.values = [0 if info[1] == 1 else info[0] for info in result_infos]
-        skips = [info[1] for info in result_infos]
-
-        if sum(skips) > 0:
-            data.skips = skips
-
-    return data
+def response_web_data(outputs_binding_count: int, result: Any):
+    return ResponseData(**response_data(outputs_binding_count, result))

instaui/fastapi_server/dependency_router.py

@@ -16,7 +16,11 @@ def _dependency_handler(app: FastAPI):
     def _(hash_part: str, file_name: str) -> FileResponse:
         hash_part_with_extend_paths = hash_part.split("/", maxsplit=1)
         hash_part = hash_part_with_extend_paths[0]
-        extend_path = None if len(hash_part_with_extend_paths) == 1 else hash_part_with_extend_paths[1]
+        extend_path = (
+            None
+            if len(hash_part_with_extend_paths) == 1
+            else hash_part_with_extend_paths[1]
+        )
 
         folder = resource.get_folder_path(hash_part)
         if extend_path:

instaui/fastapi_server/event_router.py

@@ -20,14 +20,14 @@ def _async_handler(app: FastAPI):
         if handler is None:
             return {"error": "event handler not found"}
 
-        assert inspect.iscoroutinefunction(
-            handler.fn
-        ), "handler must be a coroutine function"
+        assert inspect.iscoroutinefunction(handler.fn), (
+            "handler must be a coroutine function"
+        )
 
         _utils.update_app_page_info(data)
 
         result = await handler.fn(*handler.get_handler_args(_get_binds_from_data(data)))
-        return _utils.response_data(handler.outputs_binding_count, result)
+        return _utils.response_web_data(handler.outputs_binding_count, result)
 
 
 def _sync_handler(app: FastAPI):
@@ -41,7 +41,7 @@ def _sync_handler(app: FastAPI):
 
         result = handler.fn(*handler.get_handler_args(_get_binds_from_data(data)))
 
-        return _utils.response_data(handler.outputs_binding_count, result)
+        return _utils.response_web_data(handler.outputs_binding_count, result)
 
     if get_context().debug_mode:
 

instaui/fastapi_server/middlewares.py

@@ -17,3 +17,15 @@ class RequestContextMiddleware(BaseHTTPMiddleware):
             reset_app_slot(system_slot_token)
 
         return response
+
+
+class NoCacheDebugModeMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: Callable) -> Any:
+        response = await call_next(request)
+
+        if request.url.path.endswith((".js", ".css")):
+            response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
+            response.headers["Pragma"] = "no-cache"
+            response.headers["Expires"] = "0"
+
+        return response

instaui/fastapi_server/request_context.py

@@ -3,17 +3,18 @@ from typing import Optional
 from fastapi import Request
 from contextvars import ContextVar, Token
 
-current_request_ctx :ContextVar[Optional[Request]]= ContextVar("current_request", default=None)
+current_request_ctx: ContextVar[Optional[Request]] = ContextVar(
+    "current_request", default=None
+)
 
 
-
-def set_current_request(request: Request) :
+def set_current_request(request: Request):
     return current_request_ctx.set(request)
 
+
 def reset_current_request(token: Token) -> None:
     current_request_ctx.reset(token)
 
 
 def get_current_request() -> Request:
     return current_request_ctx.get()  # type: ignore
-

instaui/fastapi_server/server.py

@@ -22,6 +22,7 @@ from instaui.page_info import PageInfo
 
 from instaui import consts
 from instaui.runtime._app import get_app_slot, get_default_app_slot
+from instaui.runtime.context import get_context
 from instaui.runtime.dataclass import JsLink, VueAppComponent
 from instaui.template import web_template
 
@@ -30,7 +31,7 @@ from . import dependency_router
 from . import event_router
 from . import watch_router
 from . import debug_mode_router
-from .middlewares import RequestContextMiddleware
+from .middlewares import RequestContextMiddleware, NoCacheDebugModeMiddleware
 from ._uvicorn import UvicornServer
 from . import resource
 from instaui.version import __version__ as _INSTA_VERSION
@@ -55,6 +56,8 @@ class Server:
     ):
         self.app = FastAPI()
         self.app.add_middleware(RequestContextMiddleware)
+        if get_context().debug_mode:
+            self.app.add_middleware(NoCacheDebugModeMiddleware)
 
         if use_gzip:
             self.app.add_middleware(
@@ -130,6 +133,7 @@ class Server:
                 favicon_url = resource.record_resource(default_html_resource.favicon)
 
         model = web_template.WebTemplateModel(
+            version=_INSTA_VERSION,
             vue_js_link=VUE_JS_HASH_LINK,
             instaui_js_link=INSTAUI_JS_HASH_LINK,
             css_links=[

instaui/fastapi_server/watch_router.py

@@ -24,7 +24,7 @@ def _async_handler(app: FastAPI):
         result = await handler_info.fn(
             *handler_info.get_handler_args(_get_binds_from_data(data))
         )
-        return _utils.response_data(handler_info.outputs_binding_count, result)
+        return _utils.response_web_data(handler_info.outputs_binding_count, result)
 
 
 def _sync_handler(app: FastAPI):
@@ -40,7 +40,7 @@ def _sync_handler(app: FastAPI):
         result = handler_info.fn(
             *handler_info.get_handler_args(_get_binds_from_data(data))
         )
-        return _utils.response_data(handler_info.outputs_binding_count, result)
+        return _utils.response_web_data(handler_info.outputs_binding_count, result)
 
     if get_context().debug_mode:
 

instaui/js/fn.py

@@ -21,12 +21,13 @@ class JsFn(Jsonable, CanInputMixin):
         ui.label(result)
     """
 
-    def __init__(self, code: str):
+    def __init__(self, code: str, *, execute_immediately=False):
         self.code = code
         self.__type = "jsFn"
         app = get_app_slot()
         app.register_js_fn(self)
         self.__id = app.generate_js_fn_id()
+        self._execute_immediately = execute_immediately
 
     def _to_input_config(self):
         return {
@@ -39,4 +40,7 @@ class JsFn(Jsonable, CanInputMixin):
         data["type"] = self.__type
         data["id"] = self.__id
 
+        if self._execute_immediately is True:
+            data["immediately"] = 1
+
         return data

instaui/patch_update.py

@@ -0,0 +1,54 @@
+from typing import Any, Iterable, Sequence, Union
+from instaui.common.jsonable import Jsonable
+
+
+class PatchSetRecord:
+    def __init__(self, *, path: Sequence[Union[str, int]], value: Any):
+        self.path = list(path)
+        self.value = value
+
+
+class PatchSet(Jsonable):
+    def __init__(self, records: Iterable[PatchSetRecord]):
+        self._records = list(records)
+
+    def patch_set(self, *, path: Sequence[Union[str, int]], value: Any):
+        return PatchSet([*self._records, PatchSetRecord(path=path, value=value)])
+
+    def _to_json_dict(self):
+        return [[r.path, r.value] for r in self._records]
+
+
+def patch_set(*, path: Sequence[Union[str, int]], value: Any):
+    """
+    Generates a patch to specify how data should be updated.
+
+    This function is typically used within the return value of functions
+    used in `ui.event` or `ui.watch`, indicating the way data modifications are applied.
+
+    Args:
+        path (Sequence[Union[str, int]]): A sequence representing the path to the item that needs to be updated.
+                                           Each element can either be a string (for dictionary keys) or an integer
+                                           (for list indices).
+        value (Any): The new value to set at the specified path. Can be of any type.
+
+    Example:
+    .. code-block:: python
+
+        data = ui.state(
+            {
+                "v1": ["a", "b", "c"],
+                "v2": ["x", "y", "z"],
+            }
+        )
+
+        @ui.event(outputs=[data])
+        def update_data():
+            # update the second element of "v1" to "foo"
+            return ui.patch_set(path=["v1", 1], value="foo")
+
+        html.button("update data").on_click(update_data)
+        ui.label(data)
+    """
+
+    return PatchSet([PatchSetRecord(path=path, value=value)])