hypie 0.1.1.dev2__py3-none-any.whl

hypie/hs_ast/features.py

@@ -0,0 +1,181 @@
+from typing import Iterable, Literal
+from textwrap import indent, dedent
+from dataclasses import dataclass
+
+from hypie.hs_ast.constants import INDENT
+from hypie.hs_ast.commands import Command
+from hypie.hs_ast.expressions import *
+from hypie.hs_ast import helpers
+
+
+class Feature:
+    def render(self): ...
+    def __html__(self):
+        return self.render()
+
+    # __html__ = __str__
+    __str__ = __html__
+
+
+@dataclass
+class InitF(Feature):
+    commands: tuple[Command] = None
+    immediately: bool = False
+
+    def __getitem__(self, commands):
+        if not isinstance(commands, Iterable):
+            commands = (commands,)
+        # self.commands = commands
+        return InitF(
+            commands=[
+                c for c in helpers.flatten_iterable(commands) if isinstance(c, Command)
+            ],
+            immediately=self.immediately,
+        )
+
+    def render(self):
+        lines = []
+        header = "init" + (" immediately" if self.immediately else "")
+        lines.append(header)
+        end = "end"
+        for c in self.commands:
+            lines.append(indent(c.render(), INDENT, lambda _: True))
+        lines.append(end)
+        return "\n".join(lines)
+
+    def __call__(self, immediately: bool = False):
+        return InitF(immediately=immediately)
+
+
+type ON_QUEUE = Literal["none", "all", "first", "last", "concurrent"]
+
+
+@dataclass
+class OnF(Feature):
+    event_specs: tuple[str | EventSpecLiteral]
+    queue: ON_QUEUE = None
+    commands: tuple[Command] = None
+    finally_commands: tuple[Command] = None
+
+    def __getitem__(self, commands):
+        if not isinstance(commands, Iterable):
+            commands = (commands,)
+        self.commands = [
+            c for c in helpers.flatten_iterable(commands) if isinstance(c, Command)
+        ]
+        # print("ON FEATURE GOT COMMANDS: ", self.commands)
+        return self
+
+    def render(self):
+        header = "on"
+        events = []
+        for e in self.event_specs:
+            events.append(e.render() if isinstance(e, Expr) else e)
+        header += f" {'\nor '.join(events)}"
+        if self.queue == "concurrent":
+            header = "every " + header
+        elif self.queue:
+            header += f"\nqueue {self.queue}"
+        lines = []
+        lines.append(header)
+        # print("LOOPING OVER: ", self.commands)
+        for c in self.commands:
+            lines.append(indent(c.render(), INDENT, lambda _: True))
+        if self.finally_commands:
+            lines.append("finally")
+            for c in self.finally_commands:
+                lines.append(indent(c.render(), INDENT, lambda _: True))
+        lines.append("end")
+        return "\n".join(lines)
+
+    @property
+    def Finally(self):
+        return _Finally(self)
+
+
+@dataclass
+class _Finally:
+    feature: Feature
+
+    def __getitem__(self, commands):
+        if not isinstance(commands, Iterable):
+            commands = (commands,)
+        self.feature.finally_commands = [
+            c for c in helpers.flatten_iterable(commands) if isinstance(c, Command)
+        ]
+        return self.feature
+
+
+@dataclass
+class LiveF(Feature):
+    commands: tuple[Command] = None
+
+    def __getitem__(self, commands):
+        if not isinstance(commands, Iterable):
+            commands = (commands,)
+        # self.commands = commands
+        return LiveF(
+            commands=[
+                c for c in helpers.flatten_iterable(commands) if isinstance(c, Command)
+            ]
+        )
+
+    def render(self):
+        lines = []
+        header = "live"
+        lines.append(header)
+        end = "end"
+        for c in self.commands:
+            lines.append(indent(c.render(), INDENT, lambda _: True))
+        lines.append(end)
+        return "\n".join(lines)
+
+    def __call__(self):
+        return LiveF()
+
+
+@dataclass
+class WhenF(Feature):
+    exprs: tuple[Expr] = None
+    commands: tuple[Command] = None
+
+    def __getitem__(self, commands):
+        if not isinstance(commands, Iterable):
+            commands = (commands,)
+        self.commands = [
+            c for c in helpers.flatten_iterable(commands) if isinstance(c, Command)
+        ]
+        return self
+
+    def render(self):
+        header = "when"
+        parts = []
+        for e in self.exprs:
+            parts.append(e.render())
+        header += " " + "\nor ".join(parts) + " changes"
+        lines = [header]
+        for c in self.commands:
+            lines.append(indent(c.render(), INDENT, lambda _: True))
+        lines.append("end")
+        return "\n".join(lines)
+
+
+@dataclass
+class BindF(Feature):
+    exprA: Expr
+    exprB: Expr
+
+    def render(self):
+        return f"bind {self.exprA.render()} to {self.exprB.render()}"
+
+
+@dataclass
+class JsF(Feature):
+    javascript: str
+
+    def render(self):
+        header = "js"
+        end = "end"
+        js = dedent(self.javascript.strip("\n"))
+
+        return "\n".join([header, indent(js, INDENT, lambda _: True), end])

hypie/hs_ast/helpers.py

@@ -0,0 +1,85 @@
+import re
+from typing import Iterable
+import htpy
+from hypie.hs_ast.expressions import Expr
+
+
+def flatten_iterable(iterable):
+    if not isinstance(iterable, Iterable):
+        return [iterable]
+    out = []
+    for i in iterable:
+        out.extend(flatten_iterable(i))
+    return out
+
+
+def kebab_case_name(name):
+    return re.sub(r"(?<!^)([A-Z])", r"-\1", name).lower()
+
+
+def htpy_to_tree(el: htpy.Element):
+    if isinstance(el, htpy.Fragment):
+        element_type = "_fragment"
+        nodes = el._node or []
+        children = []
+        attrs = ""
+    elif not isinstance(el, htpy.Element) and not hasattr(el, "_hs_dsl_component"):
+        return el
+    # print(type(el))
+    else:
+        if hasattr(el, "_hs_dsl_component") and el._hs_dsl_component == True:
+            print("found component")
+            try:
+                el = el.__html__()
+            except TypeError:
+                el = el().__html__()
+        nodes = getattr(el, "_children", [])
+        children = []
+        element_type = el._name
+        attrs = el._attrs
+    tree = {element_type: {"children": children, "attrs": attrs}}
+    # print(tree)
+    # if hasattr(el, "_children") and el._children:
+    if (
+        nodes is None
+        or isinstance(nodes, (htpy.Element, str, int, float, bool, Expr))
+        or hasattr(nodes, "_hs_dsl_component")
+    ):
+        children.append(htpy_to_tree(nodes))
+    else:
+        for c in nodes:
+            # print(type(c))
+            children.append(htpy_to_tree(c))
+    return tree
+
+
+def tranform_tree(tree: dict, rules: dict):
+    # print(tree)
+    if isinstance(tree, str):
+        # print(tree)
+        if rules.get("text"):
+            tree = rules["text"](tree)
+        return tree
+    elif not isinstance(tree, dict):
+        return tree
+    new_tree = {}
+    k, v = next(iter(tree.items()))
+    new_tree[k] = {
+        "attrs": v["attrs"],
+        "children": [tranform_tree(c, rules) for c in v["children"]],
+    }
+    return new_tree
+
+
+def tree_to_htpy(tree):
+    if not isinstance(tree, dict):
+        return tree
+    k, v = next(iter(tree.items()))
+    children = []
+    for c in v["children"]:
+        children.append(tree_to_htpy(c))
+    return (
+        htpy.Element(k, children=children, attrs_str=v["attrs"])
+        if k != "_fragment"
+        else htpy.fragment[children]
+    )

hypie/literals.py

@@ -0,0 +1,76 @@
+from enum import Enum
+
+from hypie.hs_ast.expressions import *
+
+
+def id(id_: str, /):
+    return IdDOMLiteral(id_=str(id_).lstrip("#"))
+
+
+def cls(class_: str, /):
+    return ClassDOMLiteral(class_=str(class_).lstrip("."))
+
+
+def q(query: str, /):
+    if query.startswith(">"):
+        query = query[1:]
+    if query.endswith("/>"):
+        query = query[:-2]
+    return QueryDOMLiteral(query=query)
+
+
+def attr(attr_name, attr_value=None, /):
+    return AttrLiteral(attr_name=attr_name, attr_value=attr_value)
+
+
+def var(symbol: str, /):
+    return VariableLiteral(symbol=symbol)
+
+
+def t(value: str, /):
+    return TemplateLiteral(value=value)
+
+
+def time(time: int, resolution: TIME_RES = "ms", /):
+    return TimeLiteral(time=time, resolution=resolution)
+
+
+def event(event_name: str, /, bind: dict[str, Expr] = None):
+    return EventLiteral(event_name=event_name, bind=bind)
+
+
+def event_spec(
+    event_name: str,
+    args: list[str] = None,
+    filter: Expr = None,
+    count: int = None,
+    from_: Expr | Literal["elsewhere"] = None,
+    in_: Expr = None,
+    debounce: TimeLiteral = None,
+    throttle: TimeLiteral = None,
+):
+    if isinstance(event_name, Enum):
+        event_name = event_name.value
+    return EventSpecLiteral(
+        event_name=event_name,
+        args=args,
+        filter=filter,
+        count=count,
+        from_=from_,
+        in_=in_,
+        debounce=debounce,
+        throttle=throttle,
+    )
+
+
+def as_type(expr: Expr, t: Literal["JSON", "JSONString"], /):
+    return AsType(expr, type=t)
+
+
+# magic values
+me = var("me")
+I = var("I")
+my = var("my")
+result = var("result")
+it = var("it")
+body = var("body")