instaui 0.1.0__py3-none-any.whl

instaui/vars/web_computed.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+import inspect
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Optional,
+    Sequence,
+    TypeVar,
+)
+from typing_extensions import ParamSpec
+
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_app_slot, get_current_scope
+from instaui.handlers import watch_handler
+
+from instaui.vars.path_var import PathVar
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.common_type import TObservableInput
+from instaui._helper import observable_helper
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class WebComputed(
+    Jsonable,
+    PathVar,
+    CanInputMixin,
+    ObservableMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin[R],
+    Generic[P, R],
+):
+    VAR_TYPE = "webComputed"
+
+    def __init__(
+        self,
+        func: Callable[P, R],
+        inputs: Optional[Sequence[TObservableInput]] = None,
+        extend_outputs: Optional[Sequence[CanOutputMixin]] = None,
+        init_value: Optional[R] = None,
+        evaluating: Optional[CanOutputMixin] = None,
+    ) -> None:
+        scope = get_current_scope()
+
+        self._sid = scope.id
+        self._id = scope.generate_vars_id()
+        get_current_scope().register_web_computed(self)
+
+        self._inputs, self._is_slient_inputs, self._is_data = (
+            observable_helper.analyze_observable_inputs(list(inputs or []))
+        )
+        self._outputs = [output._to_output_config() for output in extend_outputs or []]
+        self._fn = func
+        self._init_value = init_value
+        self._evaluating = evaluating
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        return self._fn(*args, **kwargs)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        app = get_app_slot()
+
+        if app.mode == "web":
+            hkey = watch_handler.create_handler_key(
+                page_path=app.page_path,
+                handler=self._fn,
+            )
+
+            watch_handler.register_handler(hkey, self._fn, len(self._outputs) + 1)
+
+            url = (
+                watch_handler.ASYNC_URL
+                if inspect.iscoroutinefunction(self._fn)
+                else watch_handler.SYNC_URL
+            )
+
+            data["id"] = self._id
+            data["sid"] = self._sid
+            data["type"] = self.VAR_TYPE
+
+            if self._inputs:
+                data["inputs"] = self._inputs
+
+            if self._outputs:
+                data["outputs"] = self._outputs
+
+            if sum(self._is_slient_inputs) > 0:
+                data["slient"] = self._is_slient_inputs
+
+            if sum(self._is_data) > 0:
+                data["data"] = self._is_data
+
+            data["url"] = url
+            data["key"] = hkey
+            if self._init_value is not None:
+                data["init"] = self._init_value
+
+            if self._evaluating:
+                data["running"] = self._evaluating._to_output_config()
+
+            return data
+
+        return {}
+
+    def __to_binding_config(self):
+        return {
+            "type": self.VAR_TYPE,
+            "id": self._id,
+            "sid": self._sid,
+        }
+
+    def _to_pathable_binding_config(self) -> Dict:
+        return self.__to_binding_config()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return self.__to_binding_config()
+
+    def _to_input_config(self):
+        return self.__to_binding_config()
+
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
+
+    def _to_observable_config(self):
+        return self.__to_binding_config()
+
+
+def web_computed(
+    *,
+    inputs: Optional[Sequence] = None,
+    extend_outputs: Optional[Sequence] = None,
+    init_value: Optional[Any] = None,
+    evaluating: Optional[Any] = None,
+):
+    def wrapper(func: Callable[P, R]):
+        return WebComputed(
+            func,
+            inputs=inputs,
+            extend_outputs=extend_outputs,
+            init_value=init_value,
+            evaluating=evaluating,
+        )
+
+    return wrapper
+
+
+TComputed = WebComputed

instaui/vars/web_view_computed.py

@@ -0,0 +1 @@
+from __future__ import annotations

instaui/version.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__: str = importlib.metadata.version("instaui")

instaui/watch/_types.py

@@ -0,0 +1,4 @@
+from typing import Literal
+
+
+TFlush = Literal["pre", "post", "sync"]

instaui/watch/_utils.py

@@ -0,0 +1,3 @@
+def assert_deep(deep):
+    if isinstance(deep, int):
+        assert deep >= 0, "deep must be greater than or equal to 0"

instaui/watch/js_watch.py

@@ -0,0 +1,74 @@
+import typing
+from . import _types
+from . import _utils
+
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_current_scope
+
+from instaui.vars.mixin_types.py_binding import CanOutputMixin
+from instaui.vars.mixin_types.common_type import TObservableInput
+from instaui._helper import observable_helper
+
+
+class JsWatch(Jsonable):
+    def __init__(
+        self,
+        code: str,
+        inputs: typing.Optional[typing.Sequence[TObservableInput]] = None,
+        outputs: typing.Optional[typing.Sequence[CanOutputMixin]] = None,
+        immediate: bool = True,
+        deep: typing.Union[bool, int] = False,
+        once: bool = False,
+        flush: typing.Optional[_types.TFlush] = None,
+    ) -> None:
+        get_current_scope().register_js_watch(self)
+
+        self.code = code
+
+        self._inputs, self._is_slient_inputs, self._is_data = (
+            observable_helper.analyze_observable_inputs(list(inputs or []))
+        )
+        self._outputs = [output._to_output_config() for output in outputs or []]
+
+        if immediate is not True:
+            self.immediate = immediate
+
+        if deep is not False:
+            _utils.assert_deep(deep)
+            self.deep = deep
+
+        if once is not False:
+            self.once = once
+
+        if flush is not None:
+            self.flush = flush
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        if self._inputs:
+            data["inputs"] = self._inputs
+
+        if sum(self._is_slient_inputs) > 0:
+            data["slient"] = self._is_slient_inputs
+
+        if sum(self._is_data) > 0:
+            data["data"] = self._is_data
+
+        if self._outputs:
+            data["outputs"] = self._outputs
+
+        return data
+
+
+def js_watch(
+    *,
+    inputs: typing.Optional[typing.Sequence] = None,
+    outputs: typing.Optional[typing.Sequence] = None,
+    code: str = "",
+    immediate: bool = True,
+    deep: typing.Union[bool, int] = False,
+    once: bool = False,
+    flush: typing.Optional[_types.TFlush] = None,
+):
+    return JsWatch(code, inputs, outputs, immediate, deep, once, flush)

instaui/watch/vue_watch.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from typing import (
+    Any,
+    Dict,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from instaui.vars.mixin_types.observable import ObservableMixin
+
+from . import _types
+from . import _utils
+
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_current_scope
+
+
+class VueWatch(Jsonable):
+    def __init__(
+        self,
+        sources: Union[Any, Sequence],
+        callback: str,
+        *,
+        bindings: Optional[Dict[str, Any]] = None,
+        immediate: bool = False,
+        deep: Union[bool, int] = False,
+        once: bool = False,
+        flush: Optional[_types.TFlush] = None,
+    ) -> None:
+        get_current_scope().register_vue_watch(self)
+
+        self.code = callback
+
+        if isinstance(sources, Sequence):
+            self.on = [
+                cast(ObservableMixin, varObj)._to_observable_config()
+                for varObj in sources
+            ]
+        else:
+            self.on = cast(ObservableMixin, sources)._to_observable_config()
+
+        if bindings:
+            self.bind = {
+                k: cast(ObservableMixin, v)._to_observable_config()
+                for k, v in bindings.items()
+            }
+
+        if immediate is not False:
+            self.immediate = immediate
+
+        if deep is not False:
+            _utils.assert_deep(deep)
+            self.deep = deep
+
+        if once is not False:
+            self.once = once
+
+        if flush is not None:
+            self.flush = flush

instaui/watch/web_watch.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+import inspect
+import typing
+from typing_extensions import ParamSpec
+from . import _types
+from . import _utils
+
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_app_slot, get_current_scope
+from instaui.handlers import watch_handler
+
+from instaui.vars.mixin_types.py_binding import CanOutputMixin
+from instaui.vars.mixin_types.common_type import TObservableInput
+from instaui._helper import observable_helper
+
+P = ParamSpec("P")
+R = typing.TypeVar("R")
+
+
+class WebWatch(Jsonable, typing.Generic[P, R]):
+    def __init__(
+        self,
+        func: typing.Callable[P, R],
+        inputs: typing.Optional[typing.Sequence[TObservableInput]] = None,
+        outputs: typing.Optional[typing.Sequence[CanOutputMixin]] = None,
+        immediate: bool = True,
+        deep: typing.Union[bool, int] = True,
+        once: bool = False,
+        flush: typing.Optional[_types.TFlush] = None,
+        _debug: typing.Optional[typing.Any] = None,
+    ) -> None:
+        get_current_scope().register_web_watch(self)
+
+        self._inputs, self._is_slient_inputs, self._is_data = (
+            observable_helper.analyze_observable_inputs(list(inputs or []))
+        )
+
+        self._outputs = [output._to_output_config() for output in outputs or []]
+        self._fn = func
+        self._immediate = immediate
+        self._deep = deep
+        self._once = once
+        self._flush = flush
+        self._debug = _debug
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        return self._fn(*args, **kwargs)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        app = get_app_slot()
+
+        if app.mode == "web":
+            hkey = watch_handler.create_handler_key(
+                page_path=app.page_path,
+                handler=self._fn,
+            )
+
+            watch_handler.register_handler(hkey, self._fn, len(self._outputs))
+
+            url = (
+                watch_handler.ASYNC_URL
+                if inspect.iscoroutinefunction(self._fn)
+                else watch_handler.SYNC_URL
+            )
+
+            data["url"] = url
+            data["key"] = hkey
+            if self._inputs:
+                data["inputs"] = self._inputs
+
+            if sum(self._is_slient_inputs) > 0:
+                data["slient"] = self._is_slient_inputs
+
+            if sum(self._is_data) > 0:
+                data["data"] = self._is_data
+
+            if self._debug:
+                data["debug"] = self._debug
+
+            if self._outputs:
+                data["outputs"] = self._outputs
+
+            if self._immediate is not True:
+                data["immediate"] = self._immediate
+
+            if self._deep is not True:
+                _utils.assert_deep(self._deep)
+                data["deep"] = self._deep
+            if self._once is not False:
+                data["once"] = self._once
+            if self._flush is not None:
+                data["flush"] = self._flush
+
+            return data
+
+        return {}
+
+
+def watch(
+    *,
+    inputs: typing.Optional[typing.Sequence] = None,
+    outputs: typing.Optional[typing.Sequence] = None,
+    immediate: bool = True,
+    deep: typing.Union[bool, int] = True,
+    once: bool = False,
+    flush: typing.Optional[_types.TFlush] = None,
+    _debug: typing.Optional[typing.Any] = None,
+):
+    def wrapper(func: typing.Callable[P, R]):
+        return WebWatch(
+            func,
+            inputs,
+            outputs=outputs,
+            immediate=immediate,
+            deep=deep,
+            once=once,
+            flush=flush,
+            _debug=_debug,
+        )
+
+    return wrapper

instaui/zero/__init__.py

@@ -0,0 +1,3 @@
+from .scope import scope
+
+__all__ = ["scope"]

instaui/zero/scope.py

@@ -0,0 +1,9 @@
+from instaui.runtime import new_app_slot, reset_app_slot
+from contextlib import contextmanager
+
+
+@contextmanager
+def scope():
+    token = new_app_slot("zero")
+    yield
+    reset_app_slot(token)

instaui-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CrystalWindSnake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

instaui-0.1.0.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.3
+Name: instaui
+Version: 0.1.0
+Summary: insta-ui is a Python-based UI library for rapidly building user interfaces.
+License: MIT
+Author: CrystalWindSnake
+Author-email: 568166495@qq.com
+Requires-Python: >=3.8,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: web
+Provides-Extra: webview
+Requires-Dist: fastapi ; extra == "web"
+Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: orjson (>=3.10.15,<4.0.0)
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Requires-Dist: pywebview ; extra == "webview"
+Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
+Requires-Dist: uvicorn ; extra == "web"
+Description-Content-Type: text/markdown
+
+# insta-ui
+
+<div align="center">
+
+English| [简体中文](./README.md)
+
+</div>
+
+ 
+## 📖 Introduction
+insta-ui is a Python-based UI library for rapidly building user interfaces.
+
+
+## ⚙️ Features
+
+Three modes are provided:
+
+- Zero mode: Generates pure HTML files, requiring no dependencies. Simply open in a browser to run.
+- Web mode: Generates web applications.
+- Web view mode: Generates web view applications that can be packaged into local applications (without needing to start a web server).
+
+ 
+## 📦 Installation
+
+For zero mode:
+
+```
+pip install instaui -U
+```
+
+For web mode:
+
+```
+pip install instaui[web] -U
+```
+
+For web view mode:
+```
+pip install instaui[webview] -U
+```
+
+
+
+## 🖥️ Quick Start
+
+Here's a Counter example where clicking the button will display the current count value on the button text.
+
+zore mode:
+
+```python
+from instaui import ui, html, zero
+
+with zero():
+    count = ui.ref(0)
+    text = ui.str_format("Count: {}", count)
+
+    html.button(text).on_click(
+        "()=> count.value++", bindings={"count": count}
+    )
+
+    ui.to_html("./test.html")
+
+```
+
+Running the above code will generate a test.html file, which you can open in a browser to see the effect.
+
+
+
+Web mode:
+
+```python
+from instaui import ui, html
+
+@ui.page("/")
+def counter():
+    count = ui.ref(0)
+    text = ui.str_format("Count: {}", count)
+
+    html.button(text).on_click("()=> count.value++", bindings={"count": count})
+
+
+ui.server().run()
+```
+
+In web mode, we can define interaction functions for complex computations.
+
+```python
+from instaui import ui, html
+
+@ui.page("/")
+def counter():
+    count = ui.ref(0)
+    # text = ui.str_format("Count: {}", count)
+
+    @ui.computed(inputs=[count])
+    def text(count: int):
+        # Any Python operation
+        return f"Current Count: {count}"
+
+
+    html.button(text).on_click("()=> count.value++", bindings={"count": count})
+
+
+ui.server().run()
+```
+
+- The computation of `text` will generate network requests.
+- Button clicks, due to using JS binding, do not require network requests.
+
+You can choose to handle any computation with either Python or JavaScript. Below is an example of handling the button click event using Python.
+
+```python
+@ui.page("/")
+def counter():
+    count = ui.ref(0)
+
+    @ui.computed(inputs=[count])
+    def text(count: int):
+        return f"Current Count: {count}"
+
+    @ui.event(inputs=[count], outputs=[count])
+    def add_count(count: int):
+        return count + 1
+
+    html.button(text).on_click(add_count)
+
+```
+