blu-react 0.0.1__py3-none-any.whl

blu/__init__.py

@@ -0,0 +1,74 @@
+"""A full stack React framework for Python."""
+
+from typing import Callable
+
+from blu._utils.client import is_client
+from blu._utils.typing import Protocol, Any
+from blu import html
+from blu._exceptions import WrongEnvironmentError
+from blu._nodes import (
+    ClientRenderer,
+    HTMLElement,
+    Key,
+    ClientElement,
+    Node,
+    client,
+    create_html_element as create_rare_html_element,
+)
+from blu._hooks import Ref, use_effect, use_ref, use_state
+from blu._server_functions import server
+
+
+class ServerOnlyClientInterface:
+    _name: str
+
+    def __init__(self, name: str):
+        self._name = name
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        raise WrongEnvironmentError(
+            f"Cannot instantiate {self._name} in client environment."
+        )
+
+    def __getattr__(self, name: str) -> Any:
+        raise WrongEnvironmentError(f"Cannot use {self._name} in client environment.")
+
+
+if is_client:
+    Response = ServerOnlyClientInterface("Response")
+    app = ServerOnlyClientInterface("app")
+else:
+    from blu._http import Response
+    from blu._app import app
+
+
+__all__ = [
+    "ClientElement",
+    "ClientRenderer",
+    "HTMLElement",
+    "Key",
+    "Node",
+    "Ref",
+    "Response",
+    "WrongEnvironmentError",
+    "app",
+    "client",
+    "create_rare_html_element",
+    "html",
+    "is_client",
+    "server",
+    "use_effect",
+    "use_state",
+    "use_ref",
+]
+
+
+noop: Callable[[Any], None] = lambda x: x
+
+
+class Settings(Protocol):
+    """
+    Interface for the app.__settings__ module (app/__settings__.py).
+    """
+
+    CLIENT_REQUIREMENTS: list[str]

blu/_app/__init__.py

@@ -0,0 +1,463 @@
+import ast
+from collections.abc import Generator
+from functools import cache
+import mimetypes
+from pathlib import Path
+import shutil
+from tempfile import TemporaryDirectory
+from zipfile import ZipFile
+
+import aiofiles
+
+from blu._exceptions import WrongEnvironmentError
+from blu._utils import asgi
+from blu._app.router import NotFound, router_from_root_package
+from blu._http import QueryParams, Request, Response
+from blu._server_functions import (
+    collect_blu_server_import_bindings,
+    decorator_is_server,
+)
+from blu._utils import asgi
+from blu._nodes import ClientElement, HTMLElement, Key, Node
+from blu._utils.typing import Iterable
+from blu import _utils
+from .render import render_to_str
+
+
+async def app(scope: asgi.Scope, receive: asgi.Receiver, send: asgi.Sender):
+    """
+    An `ASGI <https://asgi.readthedocs.io/en/latest/>`_ app that runs
+    the Blu application defined in your current Python environment's
+    ``app`` package (for most ASGI servers, running the server in the
+    parent directory of your project's ``app`` directory will put your
+    project's ``app`` package in the Python environment).
+
+    .. code-block:: console
+
+        $ uvicorn blu:app
+
+    .. code-block:: console
+
+        $ hypercorn blu:app
+
+    .. code-block:: console
+
+        $ daphne blu:app
+    """
+    if _utils.is_client:
+        raise WrongEnvironmentError(
+            "Cannot call Blu ASGI app in a client environment.",
+        )
+    if scope["type"] == "lifespan":
+        await _lifespan(scope, receive, send)
+    elif scope["type"] == "http":
+        await _http(scope, receive, send)
+    else:
+        await _websocket(scope, receive, send)
+
+
+async def _lifespan(
+    scope: asgi.LifespanScope, receive: asgi.Receiver, send: asgi.Sender
+):
+    event = await receive()
+    assert event["type"] == "lifespan.startup"
+    from blu._server_functions import refresh_server_function_registry
+
+    refresh_server_function_registry()
+    await send({"type": "lifespan.startup.complete"})
+    event = await receive()
+    assert event["type"] == "lifespan.shutdown"
+    await send({"type": "lifespan.shutdown.complete"})
+
+
+PYTHON_MIME = "text/x-python"
+ZIP_MIME = "text/zip"
+JS_MIME = "text/javascript"
+
+
+async def _http(
+    scope: asgi.HTTPConnectionScope, receive: asgi.Receiver, send: asgi.Sender
+):
+    if scope["path"] == "/_blu_internal/app_pkg.zip":
+        path = _python_zip_dir() / "app.zip"
+        await _serve_file(path, ZIP_MIME, send)
+        return
+    if scope["path"] == "/_blu_internal/blu_pkg.zip":
+        path = _python_zip_dir() / "blu.zip"
+        await _serve_file(path, ZIP_MIME, send)
+        return
+    if scope["path"] == "/_blu_internal/client_main.py":
+        path = Path(__file__).parent / "client_main.py"
+        await _serve_file(path, PYTHON_MIME, send)
+        return
+    if scope["path"] == "/_blu_internal/util.js":
+        path = Path(__file__).parent.parent / "util.js"
+        await _serve_file(path, JS_MIME, send)
+        return
+    if scope["path"] == "/_blu_internal/server_function":
+        if scope["method"] != "POST":
+            await _serve_405(send)
+            return
+        headers = _get_asgi_headers(scope)
+        if headers.get("host", None) is None:
+            await _serve_400(send)
+            return
+        if headers.get("origin", None) is None:
+            await _serve_400(send)
+            return
+        if not _host_origin_match(headers["host"], headers["origin"]):
+            await _serve_400(send)
+            return
+        from blu._server_functions import handle_server_function_request
+
+        await handle_server_function_request(receive, send)
+        return
+    try:
+        await _serve_static(scope, send)
+    except NotFound:
+        pass
+    else:
+        return
+    request = await _create_request(scope)
+    try:
+        response = await _get_router().handle(request)
+    except NotFound:
+        await _serve_404("Not Found: " + scope["path"], send)
+        return
+    await send(
+        {
+            "type": "http.response.start",
+            "status": response._status,
+            "headers": _get_headers(response),
+        }
+    )
+    body_str = await render_to_str(response._body)
+    await send(
+        {
+            "type": "http.response.body",
+            "body": body_str.encode("utf-8"),
+        }
+    )
+
+
+def _host_origin_match(host: str, origin: str) -> bool:
+    if origin.startswith("https://"):
+        exp_host = origin.replace("https://", "")
+    elif origin.startswith("http://"):
+        exp_host = origin.replace("http://", "")
+    else:
+        return False
+    return host == exp_host
+
+
+def _get_asgi_headers(scope: asgi.HTTPConnectionScope) -> dict[str, str]:
+    return {k.decode("utf-8"): v.decode("utf-8") for k, v in scope["headers"]}
+
+
+async def _serve_404(message: str, send: asgi.Sender):
+    await send(
+        {
+            "type": "http.response.start",
+            "status": 404,
+        }
+    )
+    await send(
+        {
+            "type": "http.response.body",
+            "body": message.encode(),
+        }
+    )
+
+
+async def _serve_405(send: asgi.Sender):
+    await send(
+        {
+            "type": "http.response.start",
+            "status": 405,
+        }
+    )
+    await send(
+        {
+            "type": "http.response.body",
+            "body": b"",
+        }
+    )
+
+
+async def _serve_400(send: asgi.Sender):
+    await send(
+        {
+            "type": "http.response.start",
+            "status": 400,
+        }
+    )
+    await send(
+        {
+            "type": "http.response.body",
+            "body": b"",
+        }
+    )
+
+
+async def _serve_static(
+    scope: asgi.HTTPConnectionScope,
+    send: asgi.Sender,
+):
+    if not _is_static_file(scope["path"]):
+        raise NotFound
+    app_def = _get_app_def()
+    assert hasattr(app_def, "__path__")
+    path_str = app_def.__path__[0]
+    app_def_path = Path(path_str)
+    file_path = app_def_path / scope["path"].strip("/")
+    content_type, _ = mimetypes.guess_type(file_path)
+    try:
+        await _serve_file(file_path, content_type, send)
+    except (FileNotFoundError, IsADirectoryError):
+        raise NotFound
+
+
+async def _serve_file(path: Path, content_type: str | None, send: asgi.Sender):
+    headers = (
+        []
+        if content_type is None
+        else [(b"Content-Type", content_type.encode("utf-8"))]
+    )
+    async with aiofiles.open(path, "rb") as file:
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 200,
+                "headers": headers,
+                "trailers": False,
+            }
+        )
+        async for chunk in file:
+            await send(
+                {
+                    "type": "http.response.body",
+                    "body": chunk,
+                    "more_body": True,
+                }
+            )
+        await send(
+            {
+                "type": "http.response.body",
+                "body": b"",
+                "more_body": False,
+            }
+        )
+
+
+def _is_static_file(url_path: str):
+    if "__pycache__" in url_path:
+        return False
+    if url_path.strip().endswith(".py"):
+        return False
+    return True
+
+
+def _get_headers(response: Response) -> Iterable[tuple[bytes, bytes]]:
+    return [
+        (b"Access-Control-Allow-Origin", b"https://micropython.org"),
+        *[(k.encode("utf-8"), v.encode("utf-8")) for k, v in response._headers.items()],
+    ]
+
+
+async def _create_request(scope: asgi.HTTPConnectionScope) -> Request:
+    return Request(
+        scope["path"],
+        query=QueryParams.from_query_string(
+            scope["query_string"].decode(),
+        ),
+        headers={k.decode(): v.decode() for k, v in scope["headers"]},
+    )
+
+
+async def _websocket(
+    scope: asgi.WSConnectionScope, receive: asgi.Receiver, send: asgi.Sender
+): ...
+
+
+async def get_page_node(path: str):
+    response = await get_page_response(path)
+    return response._body  # type: ignore
+
+
+async def get_page_rendered(path: str):
+    unrendered = await get_page_node(path)
+    return render_page_node(unrendered)
+
+
+async def get_page_response(path: str):
+    if "?" in path:
+        url_path, query_str = path.strip().split("?")
+        request = Request(url_path, QueryParams.from_query_string(query_str))
+    else:
+        request = Request(path)
+    return await _get_router().handle(request)
+
+
+type RenderedNode = (HTMLElement | str | int | float | bool | None)
+
+
+def render_page_node(root: Node) -> Node:
+    ret_tuple = _render_page_node_rec(root)
+    return ret_tuple[0] if len(ret_tuple) == 1 else ret_tuple
+
+
+def _render_page_node_rec(root: Node) -> tuple[Node, ...]:
+    uncollapsed = _render_page_nodes_rec(root)
+    return _collapse_nodes(uncollapsed)
+
+
+def _collapse_nodes(uncollapsed: Iterable[Node]) -> tuple[Node, ...]:
+    current_str = ""
+    collapsed: list[Node] = []
+    for item in uncollapsed:
+        if isinstance(item, str):
+            current_str += item
+        else:
+            if current_str:
+                collapsed.append(current_str)
+                current_str = ""
+            collapsed.append(item)
+    if current_str:
+        collapsed.append(current_str)
+    return tuple(collapsed)
+
+
+def _render_page_nodes_rec(root: Node) -> tuple[Node, ...]:
+    if isinstance(root, ClientElement):
+        return _render_client_element(root)
+    if isinstance(root, HTMLElement):
+        return _render_html_element(root)
+    if isinstance(root, Key):
+        return _render_key(root)
+    if isinstance(root, Iterable) and not isinstance(root, str):
+        return _render_iterable(root)
+    if root is True:
+        return ("true",)
+    if root is False:
+        return ("false",)
+    if root is None:
+        return ()
+    return (str(root),)
+
+
+def _render_client_element(element: ClientElement) -> tuple[Node, ...]:
+    render_return = element._renderer(*element._args, **element._kwargs)  # type: ignore
+    if isinstance(render_return, Generator):
+        next(render_return)
+        try:
+            render_return.send(element._children)
+        except StopIteration as e:
+            render_return = e.value
+    return _render_page_node_rec(render_return)
+
+
+def _render_html_element(element: HTMLElement) -> tuple[Node, ...]:
+    return (element[_render_iterable(element._children)],)
+
+
+def _render_key(key: Key) -> tuple[Node, ...]:
+    return _render_iterable(key._children)  # type: ignore
+
+
+def _render_iterable(root: Node) -> tuple[Node, ...]:
+    tuples = [_render_page_node_rec(x) for x in root]  # type: ignore
+    return _collapse_nodes(y for x in tuples for y in x)
+
+
+@cache
+def _get_router():
+    app_def = _get_app_def()
+    return router_from_root_package(app_def)
+
+
+@cache
+def _get_app_def():
+    import app
+
+    return app
+
+
+@cache
+def _python_zip_dir():
+    ret = Path(TemporaryDirectory().name)
+    _blu_pkg_zip(ret)
+    _app_pkg_zip(ret)
+    return ret
+
+
+def _blu_pkg_zip(zips_root: Path):
+    src_dir = Path(__file__).parent.parent
+    base_name = str(zips_root / "blu")
+    shutil.make_archive(base_name, "zip", src_dir, src_dir)
+
+
+def _app_pkg_zip(zips_root: Path):
+    import app
+
+    assert app.__spec__ is not None
+    app_pkg_locations = app.__spec__.submodule_search_locations
+    assert app_pkg_locations
+    src_path = Path(app_pkg_locations[0])
+    dest_path = zips_root / "app.zip"
+    with ZipFile(dest_path, "w") as dest_f:
+        added_py: set[str] = set()
+        for path in src_path.rglob("*"):
+            if not path.is_file() or "__pycache__" in path.parts:
+                continue
+            rel_posix = path.relative_to(src_path).as_posix()
+            if path.suffix == ".py":
+                if _is_client_module(path):
+                    dest_f.write(path, arcname=rel_posix)
+                    added_py.add(rel_posix)
+        for path in src_path.rglob("*.py"):
+            if "__pycache__" in path.parts:
+                continue
+            rel_posix = path.relative_to(src_path).as_posix()
+            if rel_posix in added_py:
+                continue
+            stub_src = _client_stub_source_for_server_module(path)
+            if stub_src is not None:
+                dest_f.writestr(rel_posix, stub_src.encode("utf-8"))
+
+
+def _client_stub_source_for_server_module(path: Path) -> str | None:
+    try:
+        source = path.read_text()
+    except OSError:
+        return None
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return None
+    blu_pkg, server_dec = collect_blu_server_import_bindings(tree.body)
+    chunks: list[str] = []
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if not any(
+                decorator_is_server(d, blu_pkg, server_dec) for d in node.decorator_list
+            ):
+                continue
+            async_kw = "async " if isinstance(node, ast.AsyncFunctionDef) else ""
+            args_src = ast.unparse(node.args)
+            chunks.append(f"@server\n{async_kw}def {node.name}({args_src}):\n    ...")
+    if not chunks:
+        return None
+    return "from blu import server\n\n" + "\n\n".join(chunks) + "\n"
+
+
+def _is_client_module(path: Path) -> bool:
+    if path.suffix != ".py":
+        return False
+    source_code = path.read_text()
+    parsed = ast.parse(source_code)
+    for stmt in ast.iter_child_nodes(parsed):
+        if isinstance(stmt, ast.Assign):
+            stmt_source = ast.get_source_segment(source_code, stmt)
+            if stmt_source == "__client__ = True":
+                return True
+    return False

blu/_app/client_main.py

@@ -0,0 +1,159 @@
+import base64
+from collections.abc import AsyncGenerator, Generator, Iterable
+import importlib
+from importlib import import_module
+import logging
+import pickle
+from typing import Any, TypedDict, cast
+
+from js import document  # type: ignore
+from pyscript.ffi import create_proxy, to_js  # type: ignore
+from pyscript.js_modules import _blu_react as react
+from pyscript.js_modules import _blu_js_utils
+
+from blu._nodes import ClientRenderer, ClientElement, HTMLElement, Jsonable, Node, Key
+from blu._utils.typing import Generator
+
+logging.basicConfig(level=logging.DEBUG)
+
+PYTHON_TYPES = create_proxy(  # type: ignore
+    {
+        "ClientElement": ClientElement,
+        "Key": Key,
+        "tuple": tuple,
+        "HTMLElement": HTMLElement,
+    }
+)
+
+
+async def main():
+    _blu_js_utils.init(import_module)  # type: ignore
+    b64_str: str = cast(str, document.querySelector('script[type="react-data"]').textContent)  # type: ignore
+    b64_bytes = b64_str.encode("ascii")
+    pickled = base64.b64decode(b64_bytes)
+    unpickled = pickle.loads(pickled)
+    _blu_js_utils.renderRoot(unpickled)  # type: ignore
+
+
+def get_node(data: Any):
+    if isinstance(data, ClientElement):
+        return react.createElement(
+            PythonElement,
+            to_js(
+                {
+                    "renderer": create_proxy(data._renderer),
+                    "args": data._args,
+                    "kwargs": data._kwargs,
+                    "py_children": data._children,
+                }
+            ),
+        )
+    elif isinstance(data, Key):
+        props = {"key": data["key"]}
+        return react.createElement(
+            react.Fragment,
+            to_js({"key": data._key}),
+            *get_array(data._children),
+        )
+    elif isinstance(data, tuple):
+        return react.createElement(
+            react.Fragment,
+            to_js({}),
+            *get_array(data),
+        )
+    elif isinstance(data, str):
+        return data
+    elif isinstance(data, Iterable):
+        return get_array(data)
+    elif isinstance(data, HTMLElement):
+        props = {k: v for k, v in data._attrs.items() if k != "ref"}
+        if "ref" in data._attrs.keys():
+            props["ref"] = data._attrs["ref"]._js_ref
+        return react.createElement(
+            data._tagname,
+            to_js(props),
+            *get_array(data._children),
+        )
+    elif data is None:
+        return None
+    else:
+        return str(data)
+
+
+def get_obj(obj: dict[str, Any]):
+    return {k: get_node(v) for k, v in obj.items()}
+
+
+def get_dict(my_dict: dict):
+    return {k: get_node(v) for k, v in my_dict.items()}
+
+
+def get_array(array: Any):
+    return to_js([get_node(x) for x in array])
+
+
+class PythonElementProps(TypedDict):
+    renderer: ClientRenderer
+    args: tuple[Jsonable, ...]
+    kwargs: dict[str, Jsonable]
+    py_children: list[Node]
+
+
+@create_proxy
+def PythonElement(props: PythonElementProps, extra: Any = None):
+    result = props.renderer(*props.args, **props.kwargs.as_object_map())
+    if isinstance(result, Generator):
+        next(result)
+        try:
+            result.send(props.py_children)
+        except StopIteration as e:
+            return get_node(e.value)
+    elif isinstance(result, AsyncGenerator):
+        raise TypeError(
+            "ClientElements cannot be created from async rendering functions."
+        )
+    else:
+        return get_node(result)
+
+
+def py_to_js_node(py_node: Node):
+    if isinstance(py_node, ClientElement):
+        return react.createElement(
+            PythonElement,
+            to_js(
+                {
+                    "renderer": create_proxy(py_node.renderer),
+                    "args": py_node.args,
+                    "kwargs": py_node.kwargs,
+                    "py_children": py_node.children,
+                }
+            ),
+        )
+    elif isinstance(py_node, HTMLElement):
+        return react.createElement(
+            py_node.tagname,
+            to_js(
+                {
+                    k: create_proxy(v) if k.startswith("on") else v
+                    for k, v in py_node.props.items()
+                }
+            ),
+            *py_node.children,
+        )
+
+
+def parse_py_element(data: dict[str, Any]):
+    return ClientElement(
+        get_renderer(data),
+        get_array(data["args"]),
+        get_obj(data["kwargs"]),
+        get_node(data["children"]),
+    )
+
+
+def get_renderer(data: Any) -> ClientRenderer:
+    module = importlib.import_module(data["module"])
+    return getattr(module, data["name"])
+
+
+await main()