reactpy_django 5.0.0__py3-none-any.whl

js/node_modules/@pyscript/core/src/stdlib/pyscript/websocket.py

@@ -0,0 +1,71 @@
+import js
+from pyscript.ffi import create_proxy
+from pyscript.util import as_bytearray
+
+code = "code"
+protocols = "protocols"
+reason = "reason"
+methods = ["onclose", "onerror", "onmessage", "onopen"]
+
+
+class EventMessage:
+    def __init__(self, event):
+        self._event = event
+
+    def __getattr__(self, attr):
+        value = getattr(self._event, attr)
+
+        if attr == "data" and not isinstance(value, str):
+            if hasattr(value, "to_py"):
+                return value.to_py()
+            # shims in MicroPython
+            return memoryview(as_bytearray(value))
+
+        return value
+
+
+class WebSocket(object):
+    CONNECTING = 0
+    OPEN = 1
+    CLOSING = 2
+    CLOSED = 3
+
+    def __init__(self, **kw):
+        url = kw["url"]
+        if protocols in kw:
+            socket = js.WebSocket.new(url, kw[protocols])
+        else:
+            socket = js.WebSocket.new(url)
+        object.__setattr__(self, "_ws", socket)
+
+        for t in methods:
+            if t in kw:
+                # Pyodide fails at setting socket[t] directly
+                setattr(socket, t, create_proxy(kw[t]))
+
+    def __getattr__(self, attr):
+        return getattr(self._ws, attr)
+
+    def __setattr__(self, attr, value):
+        if attr in methods:
+            m = lambda e: value(EventMessage(e))
+            setattr(self._ws, attr, create_proxy(m))
+        else:
+            setattr(self._ws, attr, value)
+
+    def close(self, **kw):
+        if code in kw and reason in kw:
+            self._ws.close(kw[code], kw[reason])
+        elif code in kw:
+            self._ws.close(kw[code])
+        else:
+            self._ws.close()
+
+    def send(self, data):
+        if isinstance(data, str):
+            self._ws.send(data)
+        else:
+            buffer = js.Uint8Array.new(len(data))
+            for pos, b in enumerate(data):
+                buffer[pos] = b
+            self._ws.send(buffer)

js/node_modules/@pyscript/core/src/stdlib/pyscript/workers.py

@@ -0,0 +1,43 @@
+import js as _js
+from polyscript import workers as _workers
+
+_get = _js.Reflect.get
+
+
+def _set(script, name, value=""):
+    script.setAttribute(name, value)
+
+
+# this solves an inconsistency between Pyodide and MicroPython
+# @see https://github.com/pyscript/pyscript/issues/2106
+class _ReadOnlyProxy:
+    def __getitem__(self, name):
+        return _get(_workers, name)
+
+    def __getattr__(self, name):
+        return _get(_workers, name)
+
+
+workers = _ReadOnlyProxy()
+
+
+async def create_named_worker(src="", name="", config=None, type="py"):
+    from json import dumps
+
+    if not src:
+        raise ValueError("Named workers require src")
+
+    if not name:
+        raise ValueError("Named workers require a name")
+
+    s = _js.document.createElement("script")
+    s.type = type
+    s.src = src
+    _set(s, "worker")
+    _set(s, "name", name)
+
+    if config:
+        _set(s, "config", isinstance(config, str) and config or dumps(config))
+
+    _js.document.body.append(s)
+    return await workers[name]

js/node_modules/flatted/python/flatted.py

@@ -0,0 +1,149 @@
+# ISC License
+#
+# Copyright (c) 2018-2021, Andrea Giammarchi, @WebReflection
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+
+import json as _json
+
+class _Known:
+    def __init__(self):
+        self.key = []
+        self.value = []
+
+class _String:
+    def __init__(self, value):
+        self.value = value
+
+
+def _array_keys(value):
+    keys = []
+    i = 0
+    for _ in value:
+        keys.append(i)
+        i += 1
+    return keys
+
+def _object_keys(value):
+    keys = []
+    for key in value:
+        keys.append(key)
+    return keys
+
+def _is_array(value):
+    return isinstance(value, list) or isinstance(value, tuple)
+
+def _is_object(value):
+    return isinstance(value, dict)
+
+def _is_string(value):
+    return isinstance(value, str)
+
+def _index(known, input, value):
+    input.append(value)
+    index = str(len(input) - 1)
+    known.key.append(value)
+    known.value.append(index)
+    return index
+
+def _loop(keys, input, known, output):
+    for key in keys:
+        value = output[key]
+        if isinstance(value, _String):
+            _ref(key, input[int(value.value)], input, known, output)
+
+    return output
+
+def _ref(key, value, input, known, output):
+    if _is_array(value) and not value in known:
+        known.append(value)
+        value = _loop(_array_keys(value), input, known, value)
+    elif _is_object(value) and not value in known:
+        known.append(value)
+        value = _loop(_object_keys(value), input, known, value)
+
+    output[key] = value
+
+def _relate(known, input, value):
+    if _is_string(value) or _is_array(value) or _is_object(value):
+        try:
+            return known.value[known.key.index(value)]
+        except:
+            return _index(known, input, value)
+
+    return value
+
+def _transform(known, input, value):
+    if _is_array(value):
+        output = []
+        for val in value:
+            output.append(_relate(known, input, val))
+        return output
+
+    if _is_object(value):
+        obj = {}
+        for key in value:
+            obj[key] = _relate(known, input, value[key])
+        return obj
+
+    return value
+
+def _wrap(value):
+    if _is_string(value):
+        return _String(value)
+
+    if _is_array(value):
+        i = 0
+        for val in value:
+            value[i] = _wrap(val)
+            i += 1
+
+    elif _is_object(value):
+        for key in value:
+            value[key] = _wrap(value[key])
+
+    return value
+
+def parse(value, *args, **kwargs):
+    json = _json.loads(value, *args, **kwargs)
+    wrapped = []
+    for value in json:
+        wrapped.append(_wrap(value))
+
+    input = []
+    for value in wrapped:
+        if isinstance(value, _String):
+            input.append(value.value)
+        else:
+            input.append(value)
+
+    value = input[0]
+
+    if _is_array(value):
+        return _loop(_array_keys(value), input, [value], value)
+
+    if _is_object(value):
+        return _loop(_object_keys(value), input, [value], value)
+
+    return value
+
+
+def stringify(value, *args, **kwargs):
+    known = _Known()
+    input = []
+    output = []
+    i = int(_index(known, input, value))
+    while i < len(input):
+        output.append(_transform(known, input, input[i]))
+        i += 1
+    return _json.dumps(output, *args, **kwargs)

js/node_modules/flatted/python/test.py

@@ -0,0 +1,63 @@
+from flatted import stringify as _stringify, parse
+
+def stringify(value):
+    return _stringify(value, separators=(',', ':'))
+
+assert stringify([None, None]) == '[[null,null]]'
+
+a = []
+o = {}
+
+assert stringify(a) == '[[]]'
+assert stringify(o) == '[{}]'
+
+a.append(a)
+o['o'] = o
+
+assert stringify(a) == '[["0"]]'
+assert stringify(o) == '[{"o":"0"}]'
+
+b = parse(stringify(a))
+assert isinstance(b, list) and b[0] == b
+
+a.append(1)
+a.append('two')
+a.append(True)
+o['one'] = 1
+o['two'] = 'two'
+o['three'] = True
+
+assert stringify(a) == '[["0",1,"1",true],"two"]'
+assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true},"two"]'
+
+a.append(o)
+o['a'] = a
+
+assert stringify(a) == '[["0",1,"1",true,"2"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0"}]'
+assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2"},"two",["2",1,"1",true,"0"]]'
+
+a.append({'test': 'OK'})
+a.append([1, 2, 3])
+
+o['test'] = {'test': 'OK'}
+o['array'] = [1, 2, 3]
+
+assert stringify(a) == '[["0",1,"1",true,"2","3","4"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0","test":"3","array":"4"},{"test":"5"},[1,2,3],"OK"]'
+assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2","test":"3","array":"4"},"two",["2",1,"1",true,"0","3","4"],{"test":"5"},[1,2,3],"OK"]'
+
+a2 = parse(stringify(a));
+o2 = parse(stringify(o));
+
+assert a2[0] == a2
+assert o2['o'] == o2
+
+assert a2[1] == 1 and a2[2] == 'two' and a2[3] == True and isinstance(a2[4], dict)
+assert a2[4] == a2[4]['o'] and a2 == a2[4]['o']['a']
+
+str = parse('[{"prop":"1","a":"2","b":"3"},{"value":123},["4","5"],{"e":"6","t":"7","p":4},{},{"b":"8"},"f",{"a":"9"},["10"],"sup",{"a":1,"d":2,"c":"7","z":"11","h":1},{"g":2,"a":"7","b":"12","f":6},{"r":4,"u":"7","c":5}]')
+assert str['b']['t']['a'] == 'sup' and str['a'][1]['b'][0]['c'] == str['b']['t']
+
+oo = parse('[{"a":"1","b":"0","c":"2"},{"aa":"3"},{"ca":"4","cb":"5","cc":"6","cd":"7","ce":"8","cf":"9"},{"aaa":"10"},{"caa":"4"},{"cba":"5"},{"cca":"2"},{"cda":"4"},"value2","value3","value1"]');
+assert oo['a']['aa']['aaa'] == 'value1' and oo == oo['b'] and oo['c']['ca']['caa'] == oo['c']['ca']
+
+print('OK')

js/node_modules/polyscript/python/mip.py

@@ -0,0 +1,288 @@
+from uio import StringIO
+import sys
+
+class Response:
+    def __init__(self, f):
+        self.raw = f
+        self.encoding = "utf-8"
+        self._cached = None
+
+    def close(self):
+        if self.raw:
+            self.raw.close()
+            self.raw = None
+        self._cached = None
+
+    @property
+    def content(self):
+        if self._cached is None:
+            try:
+                self._cached = self.raw.read()
+            finally:
+                self.raw.close()
+                self.raw = None
+        return self._cached
+
+    @property
+    def text(self):
+        return str(self.content, self.encoding)
+
+    def json(self):
+        import ujson
+
+        return ujson.loads(self.content)
+
+
+# TODO try to support streaming xhr requests, a-la pyodide-http
+HEADERS_TO_IGNORE = ("user-agent",)
+
+
+try:
+    import js
+except Exception as err:
+    raise OSError("This version of urequests can only be used in the browser")
+
+# TODO try to support streaming xhr requests, a-la pyodide-http
+
+HEADERS_TO_IGNORE = ("user-agent",)
+
+
+def request(
+    method,
+    url,
+    data=None,
+    json=None,
+    headers={},
+    stream=None,
+    auth=None,
+    timeout=None,
+    parse_headers=True,
+):
+    from js import XMLHttpRequest
+
+    xhr = XMLHttpRequest.new()
+    xhr.withCredentials = False
+
+    if auth is not None:
+        import ubinascii
+
+        username, password = auth
+        xhr.open(method, url, False, username, password)
+    else:
+        xhr.open(method, url, False)
+
+    for name, value in headers.items():
+        if name.lower() not in HEADERS_TO_IGNORE:
+            xhr.setRequestHeader(name, value)
+
+    if timeout:
+        xhr.timeout = int(timeout * 1000)
+
+    if json is not None:
+        assert data is None
+        import ujson
+
+        data = ujson.dumps(json)
+        # s.write(b"Content-Type: application/json\r\n")
+        xhr.setRequestHeader("Content-Type", "application/json")
+
+    xhr.send(data)
+
+    # Emulates the construction process in the original urequests
+    resp = Response(StringIO(xhr.responseText))
+    resp.status_code = xhr.status
+    resp.reason = xhr.statusText
+    resp.headers = xhr.getAllResponseHeaders()
+
+    return resp
+
+
+# Other methods - head, post, put, patch, delete - are not used by
+# mip and therefore not included
+
+
+def get(url, **kw):
+    return request("GET", url, **kw)
+
+
+# Content below this line is from the Micropython MIP package and is covered
+# by the applicable MIT license:
+# 
+# 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.
+
+# MicroPython package installer
+# MIT license; Copyright (c) 2022 Jim Mussared
+
+
+_PACKAGE_INDEX = const("https://micropython.org/pi/v2")
+_CHUNK_SIZE = 128
+
+
+# This implements os.makedirs(os.dirname(path))
+def _ensure_path_exists(path):
+    import os
+
+    split = path.split("/")
+
+    # Handle paths starting with "/".
+    if not split[0]:
+        split.pop(0)
+        split[0] = "/" + split[0]
+
+    prefix = ""
+    for i in range(len(split) - 1):
+        prefix += split[i]
+        try:
+            os.stat(prefix)
+        except:
+            os.mkdir(prefix)
+        prefix += "/"
+
+
+# Copy from src (stream) to dest (function-taking-bytes)
+def _chunk(src, dest):
+    buf = memoryview(bytearray(_CHUNK_SIZE))
+    while True:
+        n = src.readinto(buf)
+        if n == 0:
+            break
+        dest(buf if n == _CHUNK_SIZE else buf[:n])
+
+
+# Check if the specified path exists and matches the hash.
+def _check_exists(path, short_hash):
+    import os
+
+    try:
+        import binascii
+        import hashlib
+
+        with open(path, "rb") as f:
+            hs256 = hashlib.sha256()
+            _chunk(f, hs256.update)
+            existing_hash = str(binascii.hexlify(hs256.digest())[: len(short_hash)], "utf-8")
+            return existing_hash == short_hash
+    except:
+        return False
+
+
+def _rewrite_url(url, branch=None):
+    if not branch:
+        branch = "HEAD"
+    if url.startswith("github:"):
+        url = url[7:].split("/")
+        url = (
+            "https://raw.githubusercontent.com/"
+            + url[0]
+            + "/"
+            + url[1]
+            + "/"
+            + branch
+            + "/"
+            + "/".join(url[2:])
+        )
+    return url
+
+
+def _download_file(url, dest):
+    response = get(url)
+    try:
+        if response.status_code != 200:
+            print("Error", response.status_code, "requesting", url)
+            return False
+
+        print("Copying:", dest)
+        _ensure_path_exists(dest)
+        with open(dest, "wb") as f:
+            _chunk(response.raw, f.write)
+
+        return True
+    finally:
+        response.close()
+
+
+def _install_json(package_json_url, index, target, version, mpy):
+    response = get(_rewrite_url(package_json_url, version))
+    try:
+        if response.status_code != 200:
+            print("Package not found:", package_json_url)
+            return False
+
+        package_json = response.json()
+    finally:
+        response.close()
+    for target_path, short_hash in package_json.get("hashes", ()):
+        fs_target_path = target + "/" + target_path
+        if _check_exists(fs_target_path, short_hash):
+            print("Exists:", fs_target_path)
+        else:
+            file_url = "{}/file/{}/{}".format(index, short_hash[:2], short_hash)
+            if not _download_file(file_url, fs_target_path):
+                print("File not found: {} {}".format(target_path, short_hash))
+                return False
+    for target_path, url in package_json.get("urls", ()):
+        fs_target_path = target + "/" + target_path
+        if not _download_file(_rewrite_url(url, version), fs_target_path):
+            print("File not found: {} {}".format(target_path, url))
+            return False
+    for dep, dep_version in package_json.get("deps", ()):
+        if not _install_package(dep, index, target, dep_version, mpy):
+            return False
+    return True
+
+
+def _install_package(package, index, target, version, mpy):
+    if (
+        package.startswith("http://")
+        or package.startswith("https://")
+        or package.startswith("github:")
+    ):
+        if package.endswith(".py") or package.endswith(".mpy"):
+            print("Downloading {} to {}".format(package, target))
+            return _download_file(
+                _rewrite_url(package, version), target + "/" + package.rsplit("/")[-1]
+            )
+        else:
+            if not package.endswith(".json"):
+                if not package.endswith("/"):
+                    package += "/"
+                package += "package.json"
+            print("Installing {} to {}".format(package, target))
+    else:
+        if not version:
+            version = "latest"
+        print("Installing {} ({}) from {} to {}".format(package, version, index, target))
+
+        mpy_version = (
+            sys.implementation._mpy & 0xFF if mpy and hasattr(sys.implementation, "_mpy") else "py"
+        )
+
+        # WARNING: mpy_version fails miserably with 1.22.0-380
+        package = "{}/package/{}/{}/{}.json".format(index, "py", package, version)
+
+    return _install_json(package, index, target, version, mpy)
+
+
+def install(package, index=None, target=None, version=None, mpy=True):
+    if not target:
+        for p in sys.path:
+            if p.endswith("/lib"):
+                target = p
+                break
+        else:
+            print("Unable to find lib dir in sys.path")
+            return
+
+    if not index:
+        index = _PACKAGE_INDEX
+
+    if _install_package(package, index.rstrip("/"), target, version, mpy):
+        print("Done")
+    else:
+        print("Package may be partially installed")

reactpy_django/__init__.py

@@ -0,0 +1,32 @@
+import contextlib
+
+import nest_asyncio
+
+from reactpy_django import (
+    components,
+    decorators,
+    hooks,
+    html,
+    router,
+    types,
+    utils,
+)
+from reactpy_django.websocket.paths import REACTPY_WEBSOCKET_ROUTE
+
+__version__ = "5.0.0"
+__all__ = [
+    "REACTPY_WEBSOCKET_ROUTE",
+    "html",
+    "hooks",
+    "components",
+    "decorators",
+    "types",
+    "utils",
+    "router",
+]
+
+# Fixes bugs with REACTPY_BACKHAUL_THREAD + built-in asyncio event loops.
+# Previously, Uvicorn could generate `assert f is self._write_fut` exceptions, and Daphne
+# had jittery rendering behaviors. Demonstrated using our "Renders Per Second" test page.
+with contextlib.suppress(ValueError):
+    nest_asyncio.apply()

reactpy_django/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+from reactpy_django.utils import RootComponentFinder
+
+
+class ReactPyConfig(AppConfig):
+    name = "reactpy_django"
+
+    def ready(self):
+        # Populate the ReactPy component registry when Django is ready
+        RootComponentFinder().run()