instaui 0.1.0__py3-none-any.whl

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/_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/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/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/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/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/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/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