hypie 0.1.1.dev4__tar.gz → 0.1.1.dev5__tar.gz

hypie-0.1.1.dev5/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: hypie
+Version: 0.1.1.dev5
+Summary: Add your description here
+Author: Yasser Ahmed
+Author-email: Yasser Ahmed <yasserfawzi1029@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: htpy>=26.5.1
+Requires-Dist: watchfiles>=1.2.0
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/Infrared1029/hypie
+Description-Content-Type: text/markdown
+
+<p align="center">
+    <img src="https://raw.githubusercontent.com/Infrared1029/hypie/main/assets/hypie_logo.jpg" alt="Logo" width="400">
+</p>
+
+## Intro
+Hypie, pronounced "high-pie", is a python library for building web frontends, built on top of [_hyperscript](https://github.com/bigskysoftware/_hyperscript), a scripting language for the web made by the [htmx](https://github.com/bigskysoftware/htmx) folks, and [htpy](https://github.com/pelme/htpy), a library for generating HTML in python.  
+
+The goal of hypie is to be able to code powerful web frontends, server-side rendered or client-side rendered (or a mix of both), without having to leave python, or switch your favorite backend, using relatively little abstractions and no reactivity.
+
+New README in the process, for now enjoy this counter example:
+```python
+import htpy
+import hypie as hp
+
+
+class CounterWidget(hp.ServerComponent):
+    initial_count: int = 0
+
+    def template(self):
+        count_var = hp.var(":count")
+
+        return htpy.div[
+            htpy.button(
+                _=hp.hs(
+                    hp.set_(count_var, to=self.initial_count),
+                    hp.On("click")[
+                        hp.set_(count_var, to=count_var + 1),
+                        hp.set_(hp.me.textContent, to=f"Count is: {count_var}"),
+                    ],
+                )
+            )[f"Count is: {self.initial_count}"]
+        ]
+
+
+@hp.style(CounterWidget)
+def counter_style():
+    return {
+        "button": {
+            "background-color": "#4A90D9",
+            "color": "#ffffff",
+            "border": "none",
+            "border-radius": "6px",
+            "padding": "10px 20px",
+            "font-size": "16px",
+            "font-weight": "600",
+            "cursor": "pointer",
+            "transition": "background-color 0.2s ease",
+        },
+        "button:hover": {"background-color": "#3A7BC8"},
+    }
+
+```
+```sh
+hypie build -i ./app/CounterWidget.py -o ./app/static
+```
+(or your favourite backend)
+```python
+import pathlib
+
+import htpy
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+
+
+from .CounterWidget import CounterWidget
+
+
+app = FastAPI()
+
+app.mount(
+    "/static", StaticFiles(directory=pathlib.Path(__file__).parent.resolve() / "static")
+)
+
+
+@app.get("/")
+def counter_example(count: int = 0):
+    return HTMLResponse(
+        htpy.html[
+            htpy.head[
+                htpy.link(),
+                htpy.link(rel="stylesheet", href="/static/_hypie_styles.css"),
+                htpy.script(src="https://cdn.jsdelivr.net/npm/hyperscript.org@0.9.93"),
+                htpy.title["Counter Example"],
+            ],
+            htpy.body[CounterWidget(count)],
+        ]
+    )
+
+```

hypie-0.1.1.dev5/README.md

@@ -0,0 +1,90 @@
+<p align="center">
+    <img src="https://raw.githubusercontent.com/Infrared1029/hypie/main/assets/hypie_logo.jpg" alt="Logo" width="400">
+</p>
+
+## Intro
+Hypie, pronounced "high-pie", is a python library for building web frontends, built on top of [_hyperscript](https://github.com/bigskysoftware/_hyperscript), a scripting language for the web made by the [htmx](https://github.com/bigskysoftware/htmx) folks, and [htpy](https://github.com/pelme/htpy), a library for generating HTML in python.  
+
+The goal of hypie is to be able to code powerful web frontends, server-side rendered or client-side rendered (or a mix of both), without having to leave python, or switch your favorite backend, using relatively little abstractions and no reactivity.
+
+New README in the process, for now enjoy this counter example:
+```python
+import htpy
+import hypie as hp
+
+
+class CounterWidget(hp.ServerComponent):
+    initial_count: int = 0
+
+    def template(self):
+        count_var = hp.var(":count")
+
+        return htpy.div[
+            htpy.button(
+                _=hp.hs(
+                    hp.set_(count_var, to=self.initial_count),
+                    hp.On("click")[
+                        hp.set_(count_var, to=count_var + 1),
+                        hp.set_(hp.me.textContent, to=f"Count is: {count_var}"),
+                    ],
+                )
+            )[f"Count is: {self.initial_count}"]
+        ]
+
+
+@hp.style(CounterWidget)
+def counter_style():
+    return {
+        "button": {
+            "background-color": "#4A90D9",
+            "color": "#ffffff",
+            "border": "none",
+            "border-radius": "6px",
+            "padding": "10px 20px",
+            "font-size": "16px",
+            "font-weight": "600",
+            "cursor": "pointer",
+            "transition": "background-color 0.2s ease",
+        },
+        "button:hover": {"background-color": "#3A7BC8"},
+    }
+
+```
+```sh
+hypie build -i ./app/CounterWidget.py -o ./app/static
+```
+(or your favourite backend)
+```python
+import pathlib
+
+import htpy
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+
+
+from .CounterWidget import CounterWidget
+
+
+app = FastAPI()
+
+app.mount(
+    "/static", StaticFiles(directory=pathlib.Path(__file__).parent.resolve() / "static")
+)
+
+
+@app.get("/")
+def counter_example(count: int = 0):
+    return HTMLResponse(
+        htpy.html[
+            htpy.head[
+                htpy.link(),
+                htpy.link(rel="stylesheet", href="/static/_hypie_styles.css"),
+                htpy.script(src="https://cdn.jsdelivr.net/npm/hyperscript.org@0.9.93"),
+                htpy.title["Counter Example"],
+            ],
+            htpy.body[CounterWidget(count)],
+        ]
+    )
+
+```

{hypie-0.1.1.dev4 → hypie-0.1.1.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hypie"
-version = "0.1.1.dev4"
+version = "0.1.1.dev5"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -30,6 +30,7 @@ dev = [
 ]
 examples = [
     "fastapi[standard]>=0.139.0",
+    "requests>=2.34.2",
 ]
 
 [[tool.uv.index]]

hypie-0.1.1.dev5/src/hypie/__init__.py

@@ -0,0 +1,6 @@
+from hypie.literals import *
+from hypie.commands import *
+from hypie.features import *
+from hypie.experimental.server_component import ServerComponent
+from hypie.experimental.client_component import ClientComponent
+from hypie.experimental.style import style

hypie-0.1.1.dev5/src/hypie/cli/build_components.py

@@ -0,0 +1,142 @@
+import importlib
+import pathlib
+import sys
+import inspect
+import traceback
+
+import argparse
+from pathlib import Path
+
+from hypie.hs_ast.expressions import Expr
+from hypie.experimental.style import generate_scoped_css
+
+import watchfiles
+
+
+def find_components_register_artifacts(in_path, out_path, out_files_prefix=""):
+    IGNORE_LIST = [".venv", ".pyc", ".pyo"]
+    MODULES = set()
+
+    BEHAVIORS = set()
+    STYLES = set()
+    try:
+        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)
+        if path.is_file():
+            python_files = [path]
+        else:
+            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 isinstance(obj, Expr):
+                    continue
+                elif getattr(obj, "_hs_behavior", False) == True:
+                    BEHAVIORS.add(obj)
+                elif getattr(obj, "_hypie_style", False) == True:
+                    STYLES.add(obj)
+
+
+        # create css files
+        styles = []
+        hs_files = []
+        html = []
+        print(
+            f"Done Proccessing: {len(STYLES)} Styles, {len(BEHAVIORS)} Behaviors."
+        )
+
+        for s in STYLES:
+            style = s._style
+            if style:
+                styles.append(generate_scoped_css(", ".join(s._components), style))
+        
+        for b in BEHAVIORS:
+            script = b._behavior
+            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)
+    finally:
+        # 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...")
+                try:
+                    find_components_register_artifacts(
+                        out_files_prefix=args.prefix,
+                        in_path=args.input,
+                        out_path=args.output,
+                    )
+                except KeyboardInterrupt:
+                    exit()
+                except Exception as e:
+                    traceback.print_exc()
+                print("[hypie]: waiting for changes...")

{hypie-0.1.1.dev4 → hypie-0.1.1.dev5}/src/hypie/commands.py

@@ -3,8 +3,7 @@ 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
+from hypie.experimental.client_component import ClientComponent
 
 
 @overload
@@ -128,26 +127,6 @@ def set_(set_expr: VariableLiteral, /, to: Expr):
 
 
 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)
 
 
@@ -211,10 +190,25 @@ 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):
+def render(template: ClientComponent):
+    def extract_expr(v):
+        if isinstance(v, TemplatedVariableLiteral):
+            return v.symbol
+    if isinstance(template, (ClientComponent)):
         return Render(
-            template_id=template.id,
-            with_={f: getattr(template, f) for f in template.field_names},
+            template_id=template._template_id,
+            with_={f: extract_expr(getattr(template, f)) for f in template.field_names},
         )
-    raise Exception("render only accepts Template objects")
+    raise Exception("render only accepts Client Fragments")
+
+def append(expr: Expr, / , to):
+    return Append(expr=expr, to=to)
+
+def js(*vars):
+    _vars = []
+    for v in vars:
+        if isinstance(v, VariableLiteral):
+            _vars.append(v.symbol)
+        else:
+            _vars.append(v)
+    return Js(vars=_vars)

{hypie-0.1.1.dev4 → hypie-0.1.1.dev5}/src/hypie/events.py

@@ -1,77 +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__,
-            },
-        )
+from hypie.literals import var, Expr, TimeLiteral, python_to_hs
+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__,
+            },
+        )