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

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

@@ -0,0 +1,64 @@
+from typing import Any, List, Sequence, TypedDict
+from enum import IntEnum
+from instaui.common.jsonable import Jsonable
+from instaui.skip import is_skip_output
+from instaui.patch_update import PatchSet
+
+
+class TResponse(TypedDict, total=False):
+    values: List[Any]
+    types: Sequence[int]
+
+
+class ValueType(IntEnum):
+    VALUE = 0
+    SKIP = 1
+    Patch = 2
+
+
+def response_data(outputs_binding_count: int, result: Any):
+    data: TResponse = {}
+    if outputs_binding_count > 0:
+        if not isinstance(result, tuple):
+            result = [result]
+
+        returns_count = len(result)
+
+        # [(value, 1), (value, 0)]
+        result_infos = [
+            (_try_get_value_from_jsonable(r), convert_type(r)) for r in result
+        ]
+
+        if returns_count == 1 and result_infos[0][1] == ValueType.SKIP:
+            return data
+
+        # fill missing values with None
+        if returns_count < outputs_binding_count:
+            result_infos.extend(
+                [(None, ValueType.SKIP)] * (outputs_binding_count - returns_count)
+            )
+
+        data["values"] = [
+            0 if info[1] == ValueType.SKIP else info[0] for info in result_infos
+        ]
+        types = [info[1] for info in result_infos]
+
+        if sum(types) > 0:
+            data["types"] = types
+
+    return data
+
+
+def convert_type(value: Any):
+    if is_skip_output(value):
+        return ValueType.SKIP
+    if isinstance(value, PatchSet):
+        return ValueType.Patch
+    return ValueType.VALUE
+
+
+def _try_get_value_from_jsonable(value: Any) -> Any:
+    if isinstance(value, Jsonable):
+        return value._to_json_dict()
+
+    return value

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"

instaui/spa_router/_file_base_utils.py

@@ -113,7 +113,7 @@ class _model_utils:
             if not self.fn_path:
                 return ""
 
-            return f"from .{self.fn_path.replace(' ','_')} import main as {self.main_fn_name()}"
+            return f"from .{self.fn_path.replace(' ', '_')} import main as {self.main_fn_name()}"
 
         def main_fn_name(self):
             if not self.fn_path: