instaui 0.1.19__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 (
@@ -41,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/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/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/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/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"