blu-react 0.0.1__py3-none-any.whl

blu/_utils/asyncio.py

@@ -0,0 +1,60 @@
+import asyncio
+from collections.abc import Awaitable, Callable, Coroutine
+import functools
+
+from blu._exceptions import WrongEnvironmentError
+from blu._utils.typing import Any, cast
+from blu._utils.client import is_client
+
+if not is_client:
+    from concurrent.futures import Executor, ProcessPoolExecutor, ThreadPoolExecutor
+else:
+    from blu._utils.typing import type_place_holder
+
+    Executor = type_place_holder
+    ProcessPoolExecutor = type_place_holder
+    ThreadPoolExecutor = type_place_holder
+
+
+async def awaitable[T](input: T | Awaitable[T]) -> T:
+    if isinstance(input, Awaitable):
+        return await cast(Awaitable[T], input)
+    else:
+        return input
+
+
+def to_sync[**P, R](fn: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, R]:
+    def ret(*args: P.args, **kwargs: P.kwargs) -> R:
+        return asyncio.run(fn(*args, **kwargs))
+
+    return ret
+
+
+def io_bound[
+    **P, R
+](fn: Callable[P, R],) -> Callable[P, Coroutine[Any, Any, R]]:
+    return _asyncify(fn, ThreadPoolExecutor)  # type: ignore
+
+
+def cpu_bound[
+    **P, R
+](fn: Callable[P, R],) -> Callable[P, Coroutine[Any, Any, R]]:
+    return _asyncify(fn, ProcessPoolExecutor)  # type: ignore
+
+
+def _asyncify[
+    **P, R
+](fn: Callable[P, R], executor: type[Executor]) -> Callable[  # type: ignore
+    P, Awaitable[R]
+]:
+    async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+        if is_client:
+            raise WrongEnvironmentError(
+                f"{fn} can only be called in a server environment."
+            )
+        loop = asyncio.get_running_loop()
+        bound = functools.partial(fn, *args, **kwargs)
+        with executor() as pool:  # type: ignore
+            return await loop.run_in_executor(pool, bound)
+
+    return wrapped

blu/_utils/client.py

@@ -0,0 +1,3 @@
+import platform
+
+is_client: bool = platform.system() == "Emscripten"

blu/_utils/json.py

@@ -0,0 +1,30 @@
+from collections.abc import Iterable, Mapping
+import json
+
+from blu._utils.asyncio import io_bound
+from blu._utils.client import is_client
+
+type JsonData = (
+    None | bool | int | float | str | Iterable["JsonData"] | Mapping[str, "JsonData"]
+)
+
+
+if is_client:
+
+    from js import JSON  # type: ignore
+
+    async def loads(json_string: str) -> JsonData:  # type: ignore
+        return JSON.parse(json_string)  # type: ignore
+
+    async def dumps(json_data: JsonData) -> str:  # type: ignore
+        return JSON.stringify(json_data)  # type: ignore
+
+else:
+
+    @io_bound
+    def loads(json_string: str) -> JsonData:
+        return json.loads(json_string)
+
+    @io_bound
+    def dumps(json_data: JsonData) -> str:
+        return json.dumps(json_data)

blu/_utils/typing.py

@@ -0,0 +1,33 @@
+class TypePlaceHolder:
+    def __getitem__(self, index):  # type: ignore
+        return None
+
+
+type_place_holder = TypePlaceHolder()
+
+try:
+    from typing import *  # type: ignore
+except ImportError:
+
+    for type_name in [
+        "Any",
+        "AsyncGenerator",
+        "AsyncIterable",
+        "AsyncIterator",
+        "Callable",
+        "Corouotine",
+        "Generator",
+        "Iterable",
+        "Iterator",
+        "Literal",
+        "Mapping",
+        "NotRequired",
+        "Optional",
+        "Protocol",
+        "Sequence",
+        "TypedDict",
+    ]:
+        globals()[type_name] = type_place_holder
+
+    def cast(_, x):  # type: ignore
+        return x  # type: ignore

blu/html.py

@@ -0,0 +1,91 @@
+"""
+React HTML elements.
+
+.. code-block:: python
+
+    from blu.html import div, p
+
+    div(className='my-div')[
+        p['Hello!'],
+        p['Hi.'],
+    ]
+
+.. code-block:: html
+
+    <div className='my-div'>
+        <p>Hello!</p>
+        <p>Hi.</p>
+    </div>
+"""
+
+from blu._nodes import HTMLElement as _HTMLElement
+
+
+def __getattr__(import_name: str) -> _HTMLElement:
+    """
+    Creates a :class:`blu.HTMLElement` with the given
+    HTML tag name.
+
+    .. code-block:: python
+
+        from blu.html import div, p
+
+        div(className='my-div')[
+            p['Hello!'],
+            p['Hi.'],
+        ]
+
+    .. code-block:: html
+
+        <div className='my-div'>
+            <p>Hello!</p>
+            <p>Hi.</p>
+        </div>
+
+
+    Use a trailing underscore to import tag names that are reserved
+    words in Python (the trailing underscore won't show up in the
+    resulting html):
+
+    .. code-block:: python
+
+        from blu.html import del_
+
+        del_['Hello, World!']
+
+    .. code-block:: html
+
+        <del>Hello, World!</del>
+
+    Non-trailing underscores will be converted to dashes:
+
+    .. code-block:: python
+
+        from blu.html import my_custom_element
+
+        my_custom_element['Hello!']
+
+    .. code-block:: html
+
+        <my-custom-element>Hello!</my-custom-element>
+
+    For the rare case where your desired HTML tag name cannot be
+    imported from :mod:`blu.html`, use
+    :func:`blu.create_rare_html_element`.
+
+    :param import_name: An HTML tag name.
+
+    :return: A :class:`blu.HTMLElement` whose tag name is
+        ``import_name`` with the last trailing underscore (if any)
+        removed and any other underscores converted to dashes. The
+        :class:`HTMLElement <blu.HTMLElement>` won't have any props or
+        children.
+    """
+    from blu._nodes import py_to_html_name
+
+    if import_name == "__mro__":
+        raise AttributeError(
+            "module 'blu.html' has no attribute '__mro__'",
+        )
+
+    return _HTMLElement(py_to_html_name(import_name), {}, [])

blu/util.js

@@ -0,0 +1,334 @@
+import React from 'https://esm.sh/react';
+import { createElement as $, Fragment } from 'https://esm.sh/react';
+import { createRoot } from 'https://esm.sh/react-dom/client';
+import * as PyScript from 'https://pyscript.net/releases/2026.1.1/core.js';
+
+let create_proxy;
+let blu;
+let builtins;
+let abc;
+let sys;
+let renderClientElement;
+let useEffectInvoke;
+let operator;
+let useEffectCleanupAsyncGen;
+
+export function init(innerPyImport) {
+  const ffi = innerPyImport('pyscript.ffi');
+  create_proxy = ffi.create_proxy(ffi.create_proxy);
+  function pyImport(location) {
+    return create_proxy(innerPyImport(location))
+  }
+  blu = pyImport('blu');
+  builtins = pyImport('builtins');
+  abc = pyImport('collections.abc');
+  sys = pyImport('sys');
+  operator = pyImport('operator');
+  renderClientElement = pyImport('blu._nodes')._render_client_element;
+  const hooksMod = pyImport('blu._hooks');
+  useEffectInvoke = getProxy(hooksMod._use_effect_invoke);
+  useEffectCleanupAsyncGen = getProxy(hooksMod._use_effect_cleanup_async_gen);
+}
+
+const idToProxyInfo = new Map();
+const proxyToId = new Map();
+
+const PRIMITIVE_TYPES = ['undefined', 'boolean', 'number', 'bigint', 'string', 'symbol'];
+
+function getProxy(obj) {
+  if (obj === null || PRIMITIVE_TYPES.includes(typeof obj)) {
+    return obj;
+  }
+  const id = builtins.id(obj);
+  if (!idToProxyInfo.has(id)) {
+    const proxy = create_proxy(obj)
+    idToProxyInfo.set(id, {
+      proxy,
+      count: 0
+    });
+    proxyToId.set(proxy, id);
+  }
+  const proxyInfo = idToProxyInfo.get(id);
+  proxyInfo.count++;
+  return proxyInfo.proxy;
+}
+
+function destroy(pyProxy) {
+  if (pyProxy === null || PRIMITIVE_TYPES.includes(typeof pyObj)) {
+    return;
+  }
+  const id = proxyToId(pyProxy);
+  const proxyInfo = idToProxyInfo(id);
+  const { proxy, count } = proxyInfo;
+  if (count < 1) {
+    throw new Error(`Too few existing copies (${count}) when destroying ${proxy}`);
+  }
+  proxyInfo.count--;
+  if (proxyInfo.count === 0) {
+    proxyToId.delete(proxy);
+    idToProxyInfo.delete(id);
+    proxy.destroy();
+  }
+}
+
+function unwrap(thing) {
+  if ([undefined, null].includes(thing)) {
+    return thing;
+  }
+  while (thing.type === 'pyodide.ffi.JsProxy') {
+    thing = thing.unwrap();
+  }
+  return thing;
+}
+
+export function renderRoot(pyRoot) {
+  const jsNode = getReactNode(pyRoot);
+  const renderTarget = jsNode.type === 'html' ? document : document.body;
+  createRoot(renderTarget).render(jsNode);
+}
+
+function getReactNode(pyNode) {
+  if (isOfType(pyNode, blu.ClientElement)) {
+    return $(PythonElement, {
+        renderer: getProxy(pyNode._renderer),
+        args: getProxy(pyNode._args),
+        kwargs: getProxy(pyNode._kwargs),
+        pyChildren: getProxy(pyNode._children)
+    })
+  } else if (isOfType(pyNode, blu.Key)) {
+    return $(MemManagedFragment, { key: getProxy(pyNode._key) }, ...getArray(pyNode._children));
+  } else if (isOfType(pyNode, builtins.tuple)) {
+    return $(React.Fragment, null, ...getArray(pyNode));
+  } else if (typeof pyNode === 'string') {
+    return pyNode;
+  } else if (builtins.hasattr(pyNode, '__iter__')) {
+    return getArray(pyNode);
+  } else if (isOfType(pyNode, blu.HTMLElement)) {
+    const attrs = {};
+    let hasRef = false;
+    for (const [k, v] of pyNode._attrs.items()) {
+      if (k == 'ref') {
+        hasRef = true;
+        continue;
+      }
+      attrs[k] = getProxy(v);
+    }
+    if (hasRef) {
+      attrs['ref'] = pyNode._attrs['ref']._ref_proxy;
+    }
+    return $(MemManagedHTMLElement, { _blu_tagname: pyNode._tagname, ...attrs },
+      ...getArray(pyNode._children),
+    );
+  } else if (pyNode === undefined) {
+    return undefined;
+  } else {
+    return pyNode.toString();
+  }
+}
+
+function getProxies(items) {
+  const ret = [];
+  for (const item of items) {
+    ret.push(getProxy(item));
+  }
+  return ret
+}
+
+function PythonElement(proxies) {
+  React.useEffect(() => () => {
+    destroy(proxies.renderer);
+    destroy(proxies.args);
+    destroy(proxies.kwargs);
+    destroy(proxies.pyChildren);
+  }, []);
+  const { renderer, args, kwargs, pyChildren } = unwrapProxyProps(proxies);
+  const result = renderer.callKwargs(...args, kwargs.toJs({ depth: 1 }));
+  let pyNode;
+  if (builtins.isinstance(result, abc.Generator)) {
+    result.next();
+    try {
+      if (pyChildren.length === 1) {
+        result.send(pyChildren[0]);
+      } else {
+        result.send(pyChildren);
+      }
+    } catch(e) {
+      if (e.name === 'PythonError') {
+        const pyExc = sys.last_exc;
+        if (isOfType(pyExc, builtins.StopIteration)) {
+          pyNode = pyExc.value;
+        } else {
+          throw e;
+        }
+      } else {
+        throw e;
+      }
+    }
+  } else {
+    pyNode = result;
+  }
+  return getReactNode(pyNode);
+}
+
+function unwrapProxyProps(proxies) {
+  const ret = {}
+  for (const [k, v] of Object.entries(proxies)) {
+    ret[k] = unwrap(v);
+  }
+  return ret
+}
+
+function MemManagedFragment({ key, children }) {
+  const childrenArray = getChildrenArray(children);
+  React.useEffect(() => () => {
+    destroy(key);
+  }, []);
+  return $(React.Fragment, { key }, ...childrenArray);
+}
+
+function getChildrenArray(children) {
+  return children instanceof Array ? children : [children];
+}
+
+function unwrapChildren(children) {
+  if (children instanceof Array) {
+    return children.map(x => unwrap(x));
+  } else {
+    return unwrap(children);
+  }
+}
+
+function destroyChildren(children) {
+  if (children instanceof Array) {
+    for (const child of children) {
+      destroy(child);
+    }
+  } else {
+    destroy(children);
+  }
+}
+
+function MemManagedHTMLElement({ _blu_tagname, children, ...attrs }) {
+  const childrenArray = getChildrenArray(children);
+  React.useEffect(() => () => {
+    for (const attr_value of Object.values(attrs)) {
+      destroy(attr_value);
+    }
+  }, []);
+  return $(_blu_tagname, attrs, ...childrenArray);
+}
+
+function childrenReactArray(children) {
+  const childrenArray = children instanceof Array ? children : [children];
+  return childrenArray.map(x => getReactNode(x));
+}
+
+function getArray(pyIterable) {
+  pyIterable = unwrap(pyIterable);
+  const ret = [];
+  for (const item of pyIterable) {
+    ret.push(getReactNode(item));
+  }
+  return ret;
+}
+
+export function useState(init) {
+  const initUsedRef = React.useRef(false);
+  const wrapped = getProxy(init);
+  const valueRef = React.useRef(wrapped);
+  React.useEffect(() => () => {
+    destroy(valueRef.current);
+  });
+  const [value, setValue] = React.useState(wrapped);
+  if (initUsedRef.current) {
+    destroy(wrapped);
+  }
+  initUsedRef.current = true;
+  function setter(newValue) {
+    destroy(valueRef.current);
+    const newProxy = getProxy(newValue);
+    valueRef.current = newProxy;
+    setValue(newProxy);
+  }
+  return [value, setter];
+}
+
+export function useRefObj(pyRef) {
+  const refProxiedRef = React.useRef(false);
+  pyRef = getProxy(pyRef);
+  pyRef._ref_proxy = refProxy(pyRef);
+  const refRef = React.useRef(pyRef);
+  if (refProxiedRef.current) {
+    destroy(pyRef);
+  }
+  refProxiedRef.current = true;
+  React.useEffect(() => () => {
+    destroy(refRef.current);
+  }, []);
+  return refRef.current;
+}
+
+function refProxy(pyRef) {
+  return {
+    set current(newValue) {
+      pyRef._value = newValue;
+    }
+  }
+}
+
+export function useEffect(callback) {
+  const callbackProxy = getProxy(callback);
+  React.useEffect(() => {
+    const packed = useEffectInvoke(callbackProxy);
+    const tag = operator.getitem(packed, 0).toString();
+    const result = operator.getitem(packed, 1);
+    if (tag === 'async_generator') {
+      const agen = getProxy(result);
+      return () => {
+        const onDone = create_proxy(() => {
+          destroy(agen);
+          onDone.destroy();
+        });
+        useEffectCleanupAsyncGen(agen, onDone);
+        destroy(callbackProxy);
+      };
+    } else if (tag === 'coroutine') {
+      const coro = getProxy(result);
+      return () => {
+        try {
+          coro.close();
+        } catch (e) {
+          // ignore close errors during unmount
+        }
+        destroy(coro);
+        destroy(callbackProxy);
+      };
+    } else if (tag === 'generator') {
+      const generator = getProxy(result);
+      generator.next();
+      return () => {
+        generator.next();
+        destroy(generator);
+        destroy(callbackProxy);
+      };
+    } else {
+      return () => {
+        destroy(callbackProxy);
+      };
+    }
+  });
+}
+
+function isOfType(obj, pyClass) {
+  if (pyClass === undefined || !pyClass.toString().match(/^<class '[_A-Za-z0-9\.]+'>$/g)) {
+    throw Error('Second argument must be a Python class.')
+  }
+  if (obj?.__class__ === undefined) {
+    return false;
+  }
+  return obj.__class__.toString() === pyClass.toString();
+}
+
+function pyIs(obj1, obj2) {
+  return obj1.__repr__() === obj2.__repr__()
+}

blu_react-0.0.1.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: blu-react
+Version: 0.0.1
+Summary: A full stack React framework for Python
+Project-URL: Homepage, https://github.com/johnlarson/blu
+Project-URL: Issues, https://github.com/johnlarson/blu/issues
+Author-email: John Larson <john.robert.larson@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.14
+Requires-Dist: aiofiles
+Requires-Dist: uvicorn
+Description-Content-Type: text/markdown
+
+
+
+# Blu
+
+*Blu is still in early testing and should not be used in production applications.*
+
+A full stack React framework for Python.
+
+
+```python
+from blu import client
+from blu.html import html, head, body, h1, button
+
+__client__ = True
+
+
+def __page__():
+    return html[
+        head,
+        body[
+            h1[
+                ClickCounter
+            ]
+        ]
+    ]
+    return ClickCounter
+
+
+@client
+def ClickCounter():
+    count, set_count = use_state(0)
+
+    def handle_click(e):
+        set_count(count + 1)
+    
+    return button(onClick=handle_click)[f"Clicks: {count}"]
+```
+
+## Installation
+
+```bash
+pip install -U blu
+```
+
+## Documentation
+
+Documentation available on readthedocs.io {TODO add link here.}

blu_react-0.0.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+blu/__init__.py,sha256=2Pjx9WUM_g5LQQnTvArVahMCslSruf4LUcr3ACrhMSM,1595
+blu/_cli.py,sha256=DeavgvZQ1J-OFTx3YexscS99F21XN2Ju3Y-wPyWqCoo,381
+blu/_exceptions.py,sha256=OuQXjkYQoaNqqN95Du3ZPI-cv8rLoIY7vhkfi0n2xLU,181
+blu/_hooks.py,sha256=COw0KYo715H-7bqJmnLwtJv0FL9cJt6B7ZtTVdHH9q8,9373
+blu/_http.py,sha256=KUJo4xaHr_cWtb9AASQHe4mdRqukWSQx0KcoJrbkQpc,6709
+blu/_nodes.py,sha256=h_ZBJ0yz9Y4r4f5H9Ptz8oX-vMmq3NNwSiU9UuRsoio,20658
+blu/_server_functions.py,sha256=eo6n9PGAHPf0j7S8nVzBR_LEs5YwCMmrXlkcdKKw2VM,12379
+blu/_settings.py,sha256=N641QuUVF0gxi8lmwnUz7DgsDdCqGcVHIWY_P9wCLRU,756
+blu/html.py,sha256=6DNA8gZvSHOnXz2LeMTpmOuSmMnpV-vH_hen68PzsjE,2015
+blu/util.js,sha256=YKZDhi5JVbTEdUvT7NUrqP9mleSf0hdogNnoe18OxhQ,8726
+blu/_app/__init__.py,sha256=RcbC3sJy9vqslKFD5Gn6YMay0NmOXr01WCH8m10LyJI,13497
+blu/_app/client_main.py,sha256=eRDPsGIk5jL9JSyJsvcZCxBv33CL_JhJ5WFKYloDSzg,4526
+blu/_app/render.py,sha256=_1co_teF1DfGrHkYCFJI8O5sRcERn3LCft5o8VIsXeY,2862
+blu/_app/router.py,sha256=wgWFyq0Y7kgYpCsUrzAvBVOGLaOiwbqSEQMWDjtXfXg,8463
+blu/_utils/__init__.py,sha256=jpwYug4Uo1azEq2F8rKa1QGXZDgyWlC_X3Hr11Afw1o,948
+blu/_utils/asgi.py,sha256=pp5D7mP9PnilE7g1sGA3zRc2fDmq21Rbm-i_bNVrKw8,5214
+blu/_utils/asyncio.py,sha256=AdDT1ZwJatjcC0uJAPxpSvCOSKw8Hg2eORe4_mvK62M,1740
+blu/_utils/client.py,sha256=T395O9ZBIz-T9C6A7XT1kA2cstl7sivp_KWpDhVkzx8,69
+blu/_utils/json.py,sha256=NA-HXBrnyRf9gtRePsnmNVYONxCumYHfD9JzCoFvrTE,750
+blu/_utils/typing.py,sha256=gqFGkNlLfd5L7r3t_ldXsr7xuj5YRz7MsCCW-BqyDhA,686
+blu_react-0.0.1.dist-info/METADATA,sha256=yl0_6kznmNfQhfD4s8vr4Kg_sfldZJXtLBtHv6Eq0PY,1252
+blu_react-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+blu_react-0.0.1.dist-info/entry_points.txt,sha256=ImwX7vYP0FyTuSw1SM1BdO0JjXGHlTFGtdKY_5-tMF0,37
+blu_react-0.0.1.dist-info/licenses/LICENSE,sha256=hy3N593ZwXshyckVnTMO0zLPijS5B6rinI-jNoA3PrE,1067
+blu_react-0.0.1.dist-info/RECORD,,

blu_react-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

blu_react-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blu = blu._cli:cli

blu_react-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.