instaui 0.1.0__tar.gz

instaui-0.1.0/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/PKG-INFO

@@ -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)
+
+```
+

instaui-0.1.0/README.md

@@ -0,0 +1,127 @@
+# 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)
+
+```

instaui-0.1.0/instaui/__init__.py

@@ -0,0 +1,9 @@
+from .version import __version__
+from .components import html
+from .zero import scope as zero
+
+__all__ = [
+    "__version__",
+    "html",
+    "zero",
+]

instaui-0.1.0/instaui/_helper/observable_helper.py

@@ -0,0 +1,35 @@
+import typing
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.py_binding import CanInputMixin
+from instaui.ui_functions.input_slient_data import InputSilentData
+
+from instaui.vars.mixin_types.common_type import TObservableInput
+
+
+def analyze_observable_inputs(inputs: typing.List[TObservableInput]):
+    """
+    Returns:
+        inputs, slients, datas
+    """
+
+    slients: typing.List[int] = [0] * len(inputs)
+    datas: typing.List[int] = [0] * len(inputs)
+    result_inputs = []
+
+    for idx, input in enumerate(inputs):
+        if isinstance(input, ObservableMixin):
+            result_inputs.append(input._to_observable_config())
+            continue
+
+        if isinstance(input, CanInputMixin):
+            slients[idx] = 1
+            result_inputs.append(input._to_input_config())
+
+            if isinstance(input, InputSilentData) and input.is_const_value():
+                datas[idx] = 1
+
+        else:
+            datas[idx] = 1
+            result_inputs.append(input)
+
+    return result_inputs, slients, datas

instaui-0.1.0/instaui/boot_info.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+from typing import Literal
+from instaui.version import __version__
+
+_colors = {
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+}
+
+
+def zero_boot_info(file: Path):
+    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')}
+{_arrow_right()}Local: {_with_color(str(ip), "blue")}
+"""
+    print(message)
+
+
+def webview_boot_info():
+    pass
+
+
+def _app_message(mode: str) -> str:
+    return f"""{_with_color(f"InstaUI {__version__}")}
+mode: {_with_color(mode)}"""
+
+
+def _with_color(
+    text: str, color: Literal["red", "green", "yellow", "blue"] = "green"
+) -> str:
+    return f"{_colors[color]}{text}\033[0m"
+
+
+def _arrow_right() -> str:
+    return _with_color("➜ ")

instaui-0.1.0/instaui/common/jsonable.py

@@ -0,0 +1,37 @@
+import orjson as json
+import datetime
+from enum import Enum
+
+
+class Jsonable:
+    def _to_json_dict(self):
+        data = {k: v for k, v in self.__dict__.items() if k[:1] != "_"}
+
+        return data
+
+
+def json_default(obj):
+    if isinstance(obj, float):
+        return None
+    if isinstance(obj, (datetime.date, datetime.datetime)):
+        return obj.isoformat()
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, Jsonable):
+        return obj._to_json_dict()
+
+
+def dumps(obj, indent=False):
+    def json_default_wrapper(obj):
+        for fn in [json_default]:
+            res = fn(obj)
+            if res is not None:
+                return res
+
+    return json.dumps(
+        obj, default=json_default_wrapper, option=json.OPT_INDENT_2 if indent else 0
+    ).decode("utf-8")
+
+
+def dumps2dict(obj):
+    return json.loads(dumps(obj))

instaui-0.1.0/instaui/components/column.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from typing import Literal
+from instaui.components.element import Element
+from instaui.vars.types import TMaybeRef
+
+
+class Column(Element):
+    def __init__(self):
+        super().__init__("div")
+        self.style("display: flex; flex-direction: column;gap:var(--insta-column-gap)")
+
+    def gap(self, value: TMaybeRef[str]) -> Column:
+        return self.style({"gap": value})
+
+    def align_items(
+        self, value: TMaybeRef[Literal["start", "end", "center", "stretch", "revert"]]
+    ) -> Column:
+        return self.style({"align-items": value})

instaui-0.1.0/instaui/components/component.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import (
+    Dict,
+    Optional,
+    Union,
+)
+from instaui.common.jsonable import Jsonable
+from instaui.runtime import (
+    get_app_slot,
+    check_default_app_slot_or_error,
+)
+from instaui.components.slot import SlotManager
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+
+class Component(Jsonable):
+    def __init__(self, tag: Optional[Union[str, ElementBindingMixin]] = None):
+        check_default_app_slot_or_error(
+            "Not allowed to create element outside of ui.page"
+        )
+
+        self.tag = (
+            "div"
+            if tag is None
+            else (
+                tag._to_element_binding_config()
+                if isinstance(tag, ElementBindingMixin)
+                else str(tag)
+            )
+        )
+        self._slot_manager = SlotManager()
+
+        get_app_slot().append_component_to_container(self)
+
+    def __enter__(self):
+        self._slot_manager.default.__enter__()
+        return self
+
+    def __exit__(self, *_) -> None:
+        self._slot_manager.default.__exit__(*_)
+
+    def _to_json_dict(self) -> Dict:
+        data = super()._to_json_dict()
+        data["tag"] = self.tag
+
+        return data

instaui-0.1.0/instaui/components/content.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from typing import Dict
+from instaui.components.component import Component
+from instaui.vars.types import TMaybeRef
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+
+class Content(Component):
+    def __init__(self, content: TMaybeRef[str]):
+        """Content to be displayed on the page, typically used for pure text content within slots.
+
+        Args:
+            content (TMaybeRef[str]): The textual content to display.
+
+        Example:
+        .. code-block:: python
+            with html.div():
+                ui.content("Hello, world!")
+        """
+        super().__init__("content")
+        self._content = content
+
+    def _to_json_dict(self) -> Dict:
+        data = super()._to_json_dict()
+        props = {}
+        data["props"] = props
+
+        if isinstance(self._content, ElementBindingMixin):
+            props["content"] = self._content._to_element_binding_config()
+            props["r"] = 1
+        else:
+            props["content"] = self._content
+
+        return data

instaui-0.1.0/instaui/components/directive.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    List,
+    Optional,
+)
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+
+class Directive(Jsonable):
+    def __init__(
+        self,
+        *,
+        is_sys: bool,
+        name: str,
+        arg: Optional[str] = None,
+        modifiers: Optional[List[Any]] = None,
+        value: Optional[Any] = None,
+    ) -> None:
+        super().__init__()
+        self.name = name
+        self._arg = arg
+        self._is_sys = is_sys
+        self._modifiers = modifiers
+        self._value = value
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Directive):
+            return False
+        return self.name == other.name
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        if self._arg:
+            data["arg"] = self._arg
+
+        if self._value:
+            data["value"] = (
+                self._value._to_element_binding_config()
+                if isinstance(self._value, ElementBindingMixin)
+                else self._value
+            )
+
+        if self._modifiers:
+            data["mf"] = list(dict.fromkeys(self._modifiers).keys())
+
+        data["sys"] = int(self._is_sys)
+
+        return data