hypie 0.1.1.dev2__py3-none-any.whl

hypie/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from hypie.hs_ast.features import Feature
+from hypie.commands import Set
+
+
+@dataclass
+class Hs:
+    features: tuple[Feature] = field(default_factory=lambda: [])
+
+    def render(self):
+        return "\n".join(f.render() for f in self.features)
+
+    def add_features(self, *feats: Hs | Feature):
+        features = []
+
+        for f in feats:
+            if isinstance(f, Hs):
+                features.extend(f.features)
+            elif isinstance(f, (Feature, Set)):
+                features.append(f)
+        self.features = tuple([*self.features, *features])
+        return self
+
+    def __str__(self):
+        return self.render()
+
+    __html__ = __str__
+
+
+def hs(*features):
+    return Hs(features)

hypie/cli/build_components.py

@@ -0,0 +1,148 @@
+import importlib
+import pathlib
+import sys
+import inspect
+
+import argparse
+from pathlib import Path
+
+from hypie.experimental.components import Component
+from hypie.experimental.templates import Template
+from hypie.experimental.client_components import ClientComponent
+from hypie.experimental.hyperscript import HyperScript
+
+import watchfiles
+
+
+def find_components_register_artifacts(in_path, out_path, out_files_prefix=""):
+    IGNORE_LIST = [".venv", ".pyc", ".pyo"]
+    MODULES = set()
+
+    COMPONENTS: set[Component] = set()
+    TEMPLATES: set[Template] = set()
+    CLIENT_COMPONENTS: set[ClientComponent] = set()
+    HYPERSCRIPT: set[HyperScript] = set()
+
+    path = pathlib.Path(in_path).resolve()
+    if not path.exists():
+        raise Exception("Input path does not exist")
+    # print(path, path.parent.resolve())
+    outdir = pathlib.Path(out_path).resolve()
+    if outdir.is_file():
+        raise Exception("--output must be a dir")
+    outdir.mkdir(exist_ok=True, parents=True)
+    # print(outdir)
+    sys.path.insert(0, str(path.parent.resolve()))
+    path_parts_len = len(path.parts)
+    python_files = pathlib.Path(path).glob("**/*.py")
+    for file_path in python_files:
+        if any(p in file_path.parts for p in IGNORE_LIST):
+            continue
+        module_name_parts = list(file_path.parts[path_parts_len - 1 : -1]) + [
+            file_path.stem
+        ]
+        module_name = ".".join(module_name_parts)
+        mod = importlib.import_module(module_name)
+        MODULES.add(module_name)
+        for _, obj in inspect.getmembers(mod):
+            if hasattr(obj, "_hs_dsl_component") and obj._hs_dsl_component == True:
+                COMPONENTS.add(obj)
+            elif hasattr(obj, "_hs_dsl_template") and obj._hs_dsl_template == True:
+                TEMPLATES.add(obj)
+            elif (
+                hasattr(obj, "_hs_dsl_client_component")
+                and obj._hs_dsl_client_component == True
+            ):
+                CLIENT_COMPONENTS.add(obj)
+            elif (
+                hasattr(obj, "_hs_dsl_hyperscript") and obj._hs_dsl_hyperscript == True
+            ):
+                HYPERSCRIPT.add(obj)
+
+    # create css files
+    styles = []
+    scripts = []
+    hs_files = []
+    html = []
+    print(
+        f"Done Proccessing: {len(COMPONENTS)} Component, {len(TEMPLATES)} Templates, {len(CLIENT_COMPONENTS)} Client Components {len(HYPERSCRIPT)} HS Scripts"
+    )
+    for c in COMPONENTS:
+        style = c.generate_style(with_style_tags=False)
+        if style:
+            styles.append(style)
+
+    for c_comp in CLIENT_COMPONENTS:
+        template = c_comp.register_template()
+        if template:
+            html.append(str(template))
+
+    for h in HYPERSCRIPT:
+        script = h.register_hyperscript()
+        if script:
+            hs_files.append(script)
+
+    style_contents = "\n".join(styles)
+    if style_contents:
+        with open(outdir / f"{out_files_prefix}_hypie_styles.css", "w") as f:
+            f.write(style_contents)
+
+    html_contents = "\n".join(html)
+    if html_contents:
+        with open(outdir / f"{out_files_prefix}_hypie_templates.html", "w") as f:
+            f.write(html_contents)
+
+    hs_contents = "\n".join(h.render() for h in hs_files)
+    if hs_contents:
+        with open(outdir / f"{out_files_prefix}_hypie_hyperscript._hs", "w") as f:
+            f.write(hs_contents)
+
+    # clean up
+    sys.path.pop(0)
+    for mod_name in MODULES:
+        del sys.modules[mod_name]
+
+
+def main():
+    cli_parser = argparse.ArgumentParser(prog="hypie")
+
+    subparsers = cli_parser.add_subparsers(dest="command", required=True)
+    build_parser = subparsers.add_parser("build", help="Build components")
+    build_parser.add_argument(
+        "--input", "-i", type=Path, required=True, help="Path to components dir"
+    )
+    build_parser.add_argument(
+        "--output", "-o", type=Path, required=True, help="Output path for file"
+    )
+    build_parser.add_argument(
+        "--prefix",
+        "-p",
+        type=str,
+        required=False,
+        default="",
+        help="output files prefix",
+    )
+    build_parser.add_argument(
+        "--watch",
+        "-w",
+        action="store_true",
+        required=False,
+        default=False,
+        help="watch dir and re-run build",
+    )
+    args = cli_parser.parse_args()
+
+    if args.command == "build":
+        find_components_register_artifacts(
+            out_files_prefix=args.prefix, in_path=args.input, out_path=args.output
+        )
+        if args.watch:
+            print("[hypie]: waiting for changes...")
+            for _ in watchfiles.watch(args.input):
+                print("[hypie]: detected changes, re-running build...")
+                find_components_register_artifacts(
+                    out_files_prefix=args.prefix,
+                    in_path=args.input,
+                    out_path=args.output,
+                )
+                print("[hypie]: waiting for changes...")

hypie/commands.py

@@ -0,0 +1,220 @@
+from typing import overload
+
+from hypie.hs_ast.commands import *
+from hypie.hs_ast.expressions import *
+from hypie.events import Event
+from hypie.experimental.templates import Template
+# from hypie.experimental.client_components import ClientComponent
+
+
+@overload
+def add(*class_refs, to: Expr = None, when: Expr = None): ...
+
+
+@overload
+def add(*attr_ref, to: Expr = None, when: Expr = None): ...
+
+
+def add(*exprs: Expr, to: Expr = None, when: Expr = None):
+    if len(exprs) == 1 and not isinstance(exprs[0], ClassDOMLiteral):
+        return Add(attr_ref=exprs[0], to=to, when=when)
+    else:
+        return Add(class_refs=exprs, to=to, when=when)
+
+
+@overload
+def remove(*class_refs, from_: Expr = None, when: Expr = None): ...
+
+
+@overload
+def remove(attr_ref, from_: Expr = None, when: Expr = None): ...
+
+
+def remove(*exprs: Expr, from_: Expr = None, when: Expr = None):
+    if len(exprs) == 1 and not isinstance(exprs[0], ClassDOMLiteral):
+        return Remove(attr_ref=exprs[0], from_=from_, when=when)
+    else:
+        return Remove(class_refs=exprs, from_=from_, when=when)
+
+
+def take(
+    *class_refs,
+    from_: Expr = None,
+    giving: Expr = None,
+    for_: Expr = None,
+):
+    return Take(class_refs=class_refs, from_=from_, giving=giving, for_=for_)
+
+
+def call(expr: str, /):
+    # using variable literal as it puts the expr as is
+    return Call(VariableLiteral(expr))
+
+
+def fetch(
+    url: str, /, as_: FetchAs = None, with_: FetchOptions = None, throw: bool = True
+):
+    # # print(pattern.search(url))
+    # if pattern.search(url):
+    #     url = f"`{url}`"
+    return Fetch(url=str(url), as_=as_, with_=with_, throw=throw)
+
+
+def halt_event(
+    halt_bubbling: bool = True, halt_default: bool = True, exit_handler: bool = False
+):
+    return HaltEvent(
+        halt_bubbling=halt_bubbling,
+        halt_default=halt_default,
+        exit_handler=exit_handler,
+    )
+
+
+def if_(condition: Expr, /):
+    return If(condition=condition)
+
+
+def log(*exprs):
+    return Log(exprs=tuple(coerce_python_type_to_hs(e) for e in exprs))
+
+
+def send(event_name: str, bind: dict = None, to: Expr = None):
+    if isinstance(event_name, Event):
+        _event = event_name
+        event_name = _event.event_name
+        bind = _event._bounded_args
+    event = EventLiteral(event_name=event_name, bind=bind)
+    return SendEvent(kind="send", event=event, target=to)
+
+
+def trigger(event_name: str | Event, bind: dict = None, on: Expr = None):
+    if isinstance(event_name, type) and issubclass(event_name, Event):
+        _event = event_name()
+        event_name = _event.event_name
+        bind = _event._bounded_args
+    elif isinstance(event_name, Event):
+        _event = event_name
+        event_name = _event.event_name
+        bind = _event._bounded_args
+    event = EventLiteral(event_name=event_name, bind=bind)
+    return SendEvent(kind="trigger", event=event, target=on)
+
+
+def repeat(
+    for_: VariableLiteral = None,
+    in_: Expr = None,
+    forever: bool = False,
+    number_of_times: int = None,
+    while_: Expr = None,
+    until: Expr = None,
+    at_least_once: bool = False,
+):
+    return Repeat(
+        loop_var=for_,
+        loop_expression=in_,
+        forever_condition=forever,
+        while_condition=while_,
+        until_condition=until,
+        at_least_once=at_least_once,
+        number_times=number_of_times,
+    )
+
+
+def set_(set_expr: VariableLiteral, /, to: Expr):
+    return Set(
+        set_expr=set_expr,
+        to_expr=coerce_python_type_to_hs(wrap_if_not_literal(to)),
+    )
+
+
+def put(expr: Expr, /, placement: PUT_PLACEMENTS, target: Expr):
+    if (
+        hasattr(expr, "_hs_dsl_client_component")
+        and expr._hs_dsl_client_component == True
+    ):
+        # expr = TemplateLiteral(expr.__html__())
+        tag = f"<{expr.component_name}/>"
+        # f:python_to_hs(getattr(self, f)) for f in self.field_names
+        commands = [make(tag)]
+        # for f in expr.field_names
+        return [
+            make(tag),
+            [
+                set_(
+                    VariableLiteral(f"result's @{f}"),
+                    to=VariableLiteral(f"`'${{{getattr(expr, f)}}}'`"),
+                )
+                for f in expr.field_names
+            ],
+            Put(expr=VariableLiteral("result"), placement=placement, target=target),
+        ]
+    return Put(expr=expr, placement=placement, target=target)
+
+
+@overload
+def toggle(*class_refs: ClassDOMLiteral, on: Expr = None): ...
+
+
+@overload
+def toggle(attr_ref: AttrLiteral, /, on: Expr = None): ...
+
+
+def toggle(*exprs: Expr, on: Expr = None):
+    if len(exprs) == 1 and not isinstance(exprs[0], ClassDOMLiteral):
+        return Toggle(attr_ref=exprs[0], on=on)
+    else:
+        return Toggle(class_refs=exprs, on=on)
+
+
+def scroll(
+    target: Expr,
+    /,
+    by: int,
+    direction: SCROLL_DIRS = None,
+    transition: SCROLL_TRANSITIONS = None,
+):
+    return Scroll(by=by, target=target, direction=direction, transition=transition)
+
+
+def scroll_to(
+    to: Expr,
+    /,
+    vertical_direction: SCROLL_TO_V_DIRS = None,
+    horizontal_direction: SCROLL_TO_H_DIRS = None,
+    offset: int = None,
+    in_: Expr = None,
+    transition: SCROLL_TRANSITIONS = None,
+):
+    return ScrollTo(
+        to=to,
+        vertical_direction=vertical_direction,
+        horizontal_direction=horizontal_direction,
+        offset=offset,
+        in_=in_,
+        transition=transition,
+    )
+
+
+def morph(expr: Expr, /, to: Expr):
+    return Morph(expr=expr, to=to)
+
+
+def wait(time: TimeLiteral):
+    return Wait(time=time)
+
+
+def focus(expr: Expr, /):
+    return Focus(expr=expr)
+
+
+def make(object_name: str, /, *from_: Expr | list[Expr], called: str = None):
+    return Make(object_name=object_name, from_=from_, called=called)
+
+
+def render(template: Template):
+    if isinstance(template, Template):
+        return Render(
+            template_id=template.id,
+            with_={f: getattr(template, f) for f in template.field_names},
+        )
+    raise Exception("render only accepts Template objects")

hypie/dom_position.py

@@ -0,0 +1,39 @@
+from hypie.hs_ast.expressions import *
+
+
+def next_(
+    css_selector: CSSExpr,
+    from_: Expr = None,
+    within: Expr = None,
+    with_wrapping: bool = False,
+):
+    return RelativetDOM(
+        kind="next",
+        css_selector=css_selector,
+        from_=from_,
+        within=within,
+        with_wrapping=with_wrapping,
+    )
+
+
+def previous(
+    css_selector: CSSExpr,
+    from_: Expr = None,
+    within: Expr = None,
+    with_wrapping: bool = False,
+):
+    return RelativetDOM(
+        kind="previous",
+        css_selector=css_selector,
+        from_=from_,
+        within=within,
+        with_wrapping=with_wrapping,
+    )
+
+
+def closest(css_selector: CSSExpr, to: Expr = None):
+    return ClosestDOM(kind="closest", css_selector=css_selector, to=to)
+
+
+def closest_parent(css_selector: CSSExpr, to: Expr = None):
+    return ClosestDOM(kind="closest parent", css_selector=css_selector, to=to)

hypie/events.py

@@ -0,0 +1,77 @@
+from hypie.literals import var, Expr, TimeLiteral
+from typing import Literal, dataclass_transform
+from dataclasses import fields, dataclass, is_dataclass
+
+
+@dataclass
+class EventSpec:
+    filter: Expr = (None,)
+    count: int = (None,)
+    from_: Expr | Literal["elsewhere"] = (None,)
+    in_: Expr = (None,)
+    debounce: TimeLiteral = (None,)
+    throttle: TimeLiteral = (None,)
+
+
+@dataclass_transform()
+class Event:
+    event_spec: EventSpec = None
+    event_name: str = None
+    event_args: list = None
+
+    def __init_subclass__(cls):
+        if not is_dataclass(cls):
+            dataclass_cls = dataclass(cls)
+        else:
+            dataclass_cls = cls
+        dataclass_cls.event_name = cls.__name__
+        args = []
+        for f in fields(dataclass_cls):
+            setattr(cls, f.name, var(f"{cls.event_name}__{f.name}"))
+            args.append(f"{cls.event_name}__{f.name}")
+        cls.event_args = args
+
+    @property
+    def _bounded_args(self):
+        # if not TEMPLATE_CONTEXT.get():
+        return {
+            f"{self.event_name}__{f.name}": getattr(self, f.name) for f in fields(self)
+        }
+        # template
+        # out = {}
+        # for f in fields(self):
+        #     v = getattr(self, f.name)
+        #     if isinstance(v, VariableLiteral):
+        #         out[f"{self.event_name}__{f.name}"] = VariableLiteral(f"${{{v.render()}}}")
+        #     else:
+        #         out[f"{self.event_name}__{f.name}"] = v
+
+        # return out
+
+    @classmethod
+    def with_spec(
+        cls,
+        filter=None,
+        count: int = None,
+        from_: Expr | Literal["elsewhere"] = None,
+        in_: Expr = None,
+        debounce: TimeLiteral = None,
+        throttle: TimeLiteral = None,
+    ):
+        spec = EventSpec(
+            filter=filter,
+            count=count,
+            from_=from_,
+            in_=in_,
+            debounce=debounce,
+            throttle=throttle,
+        )
+        return type(cls)(
+            cls.__name__,
+            (cls,),
+            {
+                "event_spec": spec,
+                "__qualname__": cls.__qualname__,
+                "__module__": cls.__module__,
+            },
+        )

hypie/experimental/client_components.py

@@ -0,0 +1,78 @@
+import dataclasses
+from typing import dataclass_transform
+
+import htpy
+
+from hypie import hs
+from hypie.literals import var
+from hypie.hs_ast.helpers import (
+    kebab_case_name,
+    htpy_to_tree,
+    tranform_tree,
+    tree_to_htpy,
+)
+from hypie.hs_ast.expressions import VarTemplateString, python_to_hs
+from hypie.commands import set_
+
+
+@dataclass_transform()
+class ClientComponent:
+    field_names = None
+
+    def __init_subclass__(cls):
+        dataclasses.dataclass(cls)
+        cls._hs_dsl_client_component = True
+        for f in dataclasses.fields(cls):
+            setattr(cls, f.name, var(f"^{f.name}"))
+        setattr(cls, "field_names", [f.name for f in dataclasses.fields(cls)])
+        cls.component_name = kebab_case_name(cls.__name__)
+        if "-" not in cls.component_name:
+            cls.component_name += "-view"
+        cls.script = hs()
+        for f in dataclasses.fields(cls):
+            cls.script.add_features(set_(var(f"^{f.name}"), to=var(f"attrs.{f.name}")))
+
+    @classmethod
+    def template(cls):
+        pass
+
+    @classmethod
+    def register_template(cls):
+        template = cls.template()
+        tree = htpy_to_tree(template)
+        transformed_tree = tranform_tree(tree, rules={"text": cls.handle_text_nodes})
+        transformed_htpy = tree_to_htpy(transformed_tree)
+        return htpy.script(
+            type="text/hyperscript-template", component=cls.component_name, _=cls.script
+        )[transformed_htpy]
+
+    @staticmethod
+    def handle_text_nodes(text):
+        # print(text)
+        exp_template = VarTemplateString(text)
+        if not exp_template.interpolations:
+            return text
+        return exp_template.transform(interp_func=lambda x: "${" + x + "}")
+
+    def __html__(self):
+        attrs = {f: python_to_hs(getattr(self, f)) for f in self.field_names}
+        # print(attrs)
+        return htpy.Element(name=self.component_name)(**attrs)
+
+    def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes:
+        return str(self).encode(encoding, errors)
+
+    def __str__(self):
+        return str(self.__html__())
+
+
+class Modal(ClientComponent):
+    message: str = "some test"
+    todo_id: int = 1
+
+    @classmethod
+    def template(cls):
+        return htpy.div[
+            # "hello",
+            cls.todo_id
+        ]