instaui 0.1.15__py2.py3-none-any.whl

instaui/arco/types.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict, Literal
+
+
+TLocale = Literal[
+    "zh-CN",
+    "en-US",
+    "ja-JP",
+    "zh-TW",
+    "pt-PT",
+    "es-ES",
+    "id-ID",
+    "fr-FR",
+    "de-DE",
+    "ko-KR",
+    "it-IT",
+    "ms-MY",
+    "th-TH",
+    "vi-VN",
+    "km-KH",
+    "ar-EG",
+    "ru-RU",
+]
+
+TCustomizeLocale = Dict[str, Any]

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,26 @@
+from __future__ import annotations
+from typing import Literal
+from instaui.components.element import Element
+from instaui.vars.types import TMaybeRef
+from instaui.vars.js_computed import JsComputed
+
+
+class Column(Element):
+    def __init__(self, *, inline: TMaybeRef[bool] = False):
+        super().__init__("div")
+
+        flex = JsComputed(
+            inputs=[inline], code="inline => inline? 'inline-flex' : 'flex'"
+        )
+
+        self.style("flex-direction: column;gap:var(--insta-column-gap)").style(
+            {"display": flex}
+        )
+
+    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 or tag == ""
+            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 Any, 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[Any]):
+        """Content to be displayed on the page, typically used for pure text content within slots.
+
+        Args:
+            content (TMaybeRef[Any]): The textual content to display.
+
+        Examples:
+        .. 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