instaui 0.1.18__py2.py3-none-any.whl → 0.2.0__py2.py3-none-any.whl

instaui/components/component.py

@@ -20,7 +20,7 @@ class Component(Jsonable):
             "Not allowed to create element outside of ui.page"
         )
 
-        self.tag = (
+        self._tag = (
             "div"
             if tag is None or tag == ""
             else (
@@ -29,8 +29,6 @@ class Component(Jsonable):
                 else str(tag)
             )
         )
-        if isinstance(tag, ElementBindingMixin):
-            tag._mark_used()
         self._slot_manager = SlotManager()
 
         get_app_slot().append_component_to_container(self)
@@ -43,7 +41,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

@@ -271,28 +271,18 @@ class Element(Component):
 
         if isinstance(add, dict):
             self._dict_classes.update(**add)  # type: ignore
-            for value in (
-                v for v in add.values() if isinstance(v, ElementBindingMixin)
-            ):
-                value._mark_used()
 
         if isinstance(add, ElementBindingMixin):
             self._bind_str_classes.append(add)  # type: ignore
-            add._mark_used()
 
         return self
 
     def style(self, add: Union[str, Dict[str, Any], TMaybeRef[str]]) -> Self:
         if isinstance(add, dict):
             add = {key: value for key, value in add.items()}
-            for value in (
-                v for v in add.values() if isinstance(v, ElementBindingMixin)
-            ):
-                value._mark_used()
 
         if isinstance(add, ElementBindingMixin):
             self._style_str_binds.append(add)
-            add._mark_used()
             return self
 
         new_style = self._parse_style(add)
@@ -302,17 +292,11 @@ class Element(Component):
     def props(self, add: Union[str, Dict[str, Any], TMaybeRef]) -> Self:
         if isinstance(add, ElementBindingMixin):
             self._proxy_props.append(add)
-            add._mark_used()
             return self
 
         if isinstance(add, dict):
             add = {key: value for key, value in add.items() if value is not None}
 
-            for value in (
-                v for v in add.values() if isinstance(v, ElementBindingMixin)
-            ):
-                value._mark_used()
-
         new_props = self._parse_props(add)
         self._props.update(new_props)
         return self

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/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/match.py

@@ -11,8 +11,6 @@ class Match(Component):
     def __init__(self, on: ElementBindingMixin):
         super().__init__("match")
         self._on = on
-        if isinstance(on, ElementBindingMixin):
-            on._mark_used()
         self._default_case = None
 
     def _to_json_dict(self):
@@ -52,7 +50,7 @@ class Case(Component):
     def __init__(self, value: typing.Any):
         super().__init__("case")
         self._value = value
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
 
     def __enter__(self):
@@ -70,7 +68,7 @@ class Case(Component):
         }
         props = data["props"]
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager
@@ -83,7 +81,7 @@ class DefaultCase(Component):
     def __init__(self):
         super().__init__("default-case")
 
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
 
     def __enter__(self):
@@ -99,7 +97,7 @@ class DefaultCase(Component):
         data["props"] = {}
         props = data["props"]
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager

instaui/components/mixins.py

@@ -0,0 +1,12 @@
+from typing import Dict, Protocol
+from typing_extensions import Self
+from instaui.vars.types import TMaybeRef
+
+
+class PropsProtocol(Protocol):
+    def props(self, props: Dict) -> Self: ...
+
+
+class CanDisabledMixin:
+    def disabled(self: PropsProtocol, disabled: TMaybeRef[bool] = True):
+        return self.props({"disabled": disabled})

instaui/components/vfor.py

@@ -50,11 +50,9 @@ class VFor(Component, Generic[_T]):
 
         super().__init__("vfor")
         self._data = data
-        if isinstance(self._data, ElementBindingMixin):
-            self._data._mark_used()
         self._key = key
         self._fid = get_app_slot().generate_vfor_id()
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
         self._num = None
         self._transition_group_setting = None
@@ -104,7 +102,7 @@ class VFor(Component, Generic[_T]):
                 k: v for k, v in self._transition_group_setting.items() if v is not None
             }
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager

instaui/components/vif.py

@@ -10,9 +10,7 @@ class VIf(Component):
     def __init__(self, on: TMaybeRef[bool]):
         super().__init__("vif")
         self._on = cast(ElementBindingMixin, on)
-        if isinstance(on, ElementBindingMixin):
-            on._mark_used()
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
 
     def __enter__(self):
@@ -32,7 +30,7 @@ class VIf(Component):
         }
         props: Dict = data["props"]
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager

instaui/event/js_event.py

@@ -1,6 +1,5 @@
 import typing
 from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
-from instaui.vars.mixin_types.element_binding import _try_mark_inputs_used
 from instaui.common.jsonable import Jsonable
 from .event_mixin import EventMixin
 
@@ -27,7 +26,6 @@ class JsEvent(Jsonable, EventMixin):
     def _to_json_dict(self):
         data = super()._to_json_dict()
         data["type"] = self.event_type()
-        _try_mark_inputs_used(self._org_inputs)
 
         if self._inputs:
             data["inputs"] = self._inputs

instaui/event/vue_event.py

@@ -1,7 +1,6 @@
 import typing
 from instaui.common.jsonable import Jsonable
 from instaui.vars.mixin_types.observable import ObservableMixin
-from instaui.vars.mixin_types.element_binding import _try_mark_inputs_used
 from .event_mixin import EventMixin
 
 
@@ -60,8 +59,6 @@ class VueEvent(Jsonable, EventMixin):
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-
-        _try_mark_inputs_used((self._bindings or {}).values())
         data["type"] = self.event_type()
         return data
 

instaui/event/web_event.py

@@ -4,17 +4,16 @@ from typing_extensions import ParamSpec
 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.vars.mixin_types.element_binding import _try_mark_inputs_used
 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]):
@@ -23,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
@@ -47,8 +51,6 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
     def _to_json_dict(self):
         app = get_app_slot()
 
-        _try_mark_inputs_used(self._inputs)
-
         hkey = event_handler.create_handler_key(
             page_path=app.page_path, handler=self._fn
         )
@@ -76,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
 
 
@@ -83,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.
@@ -95,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
@@ -109,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]):
@@ -116,6 +135,7 @@ def event(
             func,
             inputs or [],
             outputs=outputs or [],
+            pre_setup=pre_setup,
         )
 
     return wrapper

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/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/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/pre_setup.py

@@ -0,0 +1,45 @@
+from typing import Dict, Sequence, cast
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.py_binding import CanOutputMixin, CanInputMixin
+
+
+def _check_args(config: Dict):
+    for key in config.keys():
+        if not isinstance(key, CanOutputMixin):
+            raise TypeError(f"key {key} is not a CanOutputMixin")
+
+
+def convert_config(config: Dict):
+    return [
+        {
+            "target": cast(CanInputMixin, key)._to_input_config(),
+            **value._to_json_dict(),
+        }
+        if isinstance(value, PreSetupAction)
+        else {
+            "type": "const",
+            "target": cast(CanInputMixin, key)._to_input_config(),
+            "value": value,
+        }
+        for key, value in config.items()
+    ]
+
+
+class PreSetupAction(Jsonable):
+    def __init__(self, *, inputs: Sequence, code: str, reset: bool = True):
+        self.type = "action"
+        self._inputs = inputs
+        self.code = code
+        self.reset = reset
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        if self._inputs:
+            data["inputs"] = [
+                binding._to_input_config()
+                if isinstance(binding, CanInputMixin)
+                else binding
+                for binding in self._inputs
+            ]
+
+        return data

instaui/runtime/_app.py

@@ -30,7 +30,7 @@ class App(Jsonable):
         self._vfor_id_counter = 0
         self._slot_id_counter = 0
         self._js_fn_id_counter = 0
-        self.mode: _T_App_Mode = mode
+        self._mode: _T_App_Mode = mode
         self.items: List[Component] = []
         self.meta = meta
         self._slots_stacks: List[Slot] = []
@@ -49,6 +49,10 @@ class App(Jsonable):
         self._route_collector: Optional[RouteCollector] = None
         self._js_fns: List[JsFn] = []
 
+    @property
+    def mode(self) -> _T_App_Mode:
+        return self._mode
+
     @property
     def page_path(self) -> str:
         assert self._page_path is not None, "Page path is not set"
@@ -126,8 +130,8 @@ class App(Jsonable):
 
             data["url"] = url_info
 
-        assert len(self._scopes) == 1, "Only one scope is allowed"
-        data["scope"] = self._scopes[0]
+        data["scopeId"] = self._scopes[0].id
+        data["scopes"] = self._scopes
 
         if self._route_collector is not None:
             data["router"] = self._route_collector.model_dump(

instaui/runtime/scope.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List
+import functools
+import weakref
 from instaui.common.jsonable import Jsonable
 
 
@@ -58,21 +60,6 @@ class Scope(Jsonable):
             "on": [v._to_input_config() for v in on],
         }
 
-    def register_ref(self, var: VarMixin) -> None:
-        self._refs.append(var)
-
-    def register_data(self, data: ConstData) -> None:
-        self._const_data.append(data)
-
-    def register_js_computed(self, computed: JsComputed) -> None:
-        self._js_computeds.append(computed)
-
-    def register_vue_computed(self, computed: VueComputed) -> None:
-        self._vue_computeds.append(computed)
-
-    def register_web_computed(self, computed: WebComputed) -> None:
-        self._web_computeds.append(computed)
-
     def register_web_watch(self, watch: WebWatch) -> None:
         self._web_watchs.append(watch)
 
@@ -82,6 +69,51 @@ class Scope(Jsonable):
     def register_vue_watch(self, watch: VueWatch) -> None:
         self._vue_watchs.append(watch)
 
+    def register_data_task(self, data: ConstData):
+        weak_obj = weakref.ref(data)
+
+        def register_fn():
+            self._const_data.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_ref_task(self, ref: VarMixin):
+        weak_obj = weakref.ref(ref)
+
+        def register_fn():
+            self._refs.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_js_computed_task(self, computed: JsComputed):
+        weak_obj = weakref.ref(computed)
+
+        def register_fn():
+            self._js_computeds.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_computed_task(self, computed: WebComputed):
+        weak_obj = weakref.ref(computed)
+
+        def register_fn():
+            self._web_computeds.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_vue_computed_task(self, computed: VueComputed):
+        weak_obj = weakref.ref(computed)
+
+        def register_fn():
+            self._vue_computeds.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
     def _to_json_dict(self):
         data = super()._to_json_dict()
         if self._refs:
@@ -97,23 +129,12 @@ class Scope(Jsonable):
         if self._element_refs:
             data["eRefs"] = self._element_refs
 
-        # web computeds
-        _web_computeds = [
-            computed for computed in self._web_computeds if computed._is_used()
-        ]
-
-        if _web_computeds:
-            data["web_computed"] = _web_computeds
+        if self._web_computeds:
+            data["web_computed"] = self._web_computeds
 
-        # js computeds
-        _js_computeds = [
-            computed for computed in self._js_computeds if computed._is_used()
-        ]
+        if self._js_computeds:
+            data["js_computed"] = self._js_computeds
 
-        if _js_computeds:
-            data["js_computed"] = _js_computeds
-
-        # vue computeds
         if self._vue_computeds:
             data["vue_computed"] = self._vue_computeds
         if self._const_data:
@@ -126,12 +147,18 @@ class GlobalScope(Scope):
     def __init__(self, id: str) -> None:
         super().__init__(id)
 
-    def register_ref(self, var: VarMixin) -> None:
+    def register_ref_task(self, var: VarMixin) -> None:
         raise ValueError("Can not register ref in global scope")
 
-    def register_web_computed(self, computed: WebComputed) -> None:
+    def register_computed_task(self, computed: WebComputed) -> None:
         raise ValueError("Can not register web_computeds  in global scope")
 
+    def register_js_computed_task(self, computed: JsComputed):
+        raise ValueError("Can not register js_computeds  in global scope")
+
+    def register_vue_computed_task(self, computed: VueComputed):
+        raise ValueError("Can not register vue_computeds  in global scope")
+
     def register_web_watch(self, watch: WebWatch) -> None:
         raise ValueError("Can not register web_watchs  in global scope")
 
@@ -140,3 +167,17 @@ class GlobalScope(Scope):
 
     def register_vue_watch(self, watch: VueWatch) -> None:
         raise ValueError("Can not register vue_watchs  in global scope")
+
+
+class VarRegisterTask:
+    def __init__(self, scope_id: str, register_fn: Callable[[], str]) -> None:
+        self._scope_id = scope_id
+        self._id_gen_fn = functools.lru_cache(maxsize=1)(register_fn)
+
+    @property
+    def scope_id(self) -> str:
+        return self._scope_id
+
+    @property
+    def var_id(self) -> str:
+        return self._id_gen_fn()