reactpy_django 3.8.1__py2.py3-none-any.whl

reactpy_django/utils.py

@@ -0,0 +1,384 @@
+from __future__ import annotations
+
+import contextlib
+import inspect
+import logging
+import os
+import re
+from asyncio import iscoroutinefunction
+from fnmatch import fnmatch
+from importlib import import_module
+from typing import Any, Callable, Sequence
+
+from asgiref.sync import async_to_sync
+from channels.db import database_sync_to_async
+from django.db.models import ManyToManyField, ManyToOneRel, prefetch_related_objects
+from django.db.models.base import Model
+from django.db.models.query import QuerySet
+from django.http import HttpRequest, HttpResponse
+from django.template import engines
+from django.utils.encoding import smart_str
+from django.views import View
+from reactpy.core.layout import Layout
+from reactpy.types import ComponentConstructor
+
+from reactpy_django.exceptions import (
+    ComponentDoesNotExistError,
+    ComponentParamError,
+    ViewDoesNotExistError,
+)
+
+_logger = logging.getLogger(__name__)
+_component_tag = r"(?P<tag>component)"
+_component_path = r"""(?P<path>"[^"'\s]+"|'[^"'\s]+')"""
+_component_offline_kwarg = (
+    rf"""(\s*offline\s*=\s*{_component_path.replace(r"<path>", r"<offline_path>")})"""
+)
+_component_generic_kwarg = r"""(\s*.*?)"""
+COMMENT_REGEX = re.compile(r"<!--[\s\S]*?-->")
+COMPONENT_REGEX = re.compile(
+    r"{%\s*"
+    + _component_tag
+    + r"\s*"
+    + _component_path
+    + rf"({_component_offline_kwarg}|{_component_generic_kwarg})*?"
+    + r"\s*%}"
+)
+
+
+async def render_view(
+    view: Callable | View,
+    request: HttpRequest,
+    args: Sequence,
+    kwargs: dict,
+) -> HttpResponse:
+    """Ingests a Django view (class or function) and returns an HTTP response object."""
+    # Convert class-based view to function-based view
+    if getattr(view, "as_view", None):
+        view = view.as_view()  # type: ignore[union-attr]
+
+    # Async function view
+    if iscoroutinefunction(view):
+        response = await view(request, *args, **kwargs)
+
+    # Sync function view
+    else:
+        response = await database_sync_to_async(view)(request, *args, **kwargs)
+
+    # TemplateView
+    if getattr(response, "render", None):
+        response = await database_sync_to_async(response.render)()
+
+    return response
+
+
+def register_component(component: ComponentConstructor | str):
+    """Adds a component to the list of known registered components.
+
+    Args:
+        component: The component to register. Can be a component function or dotted path to a component.
+
+    """
+    from reactpy_django.config import (
+        REACTPY_FAILED_COMPONENTS,
+        REACTPY_REGISTERED_COMPONENTS,
+    )
+
+    dotted_path = (
+        component if isinstance(component, str) else generate_obj_name(component)
+    )
+    try:
+        REACTPY_REGISTERED_COMPONENTS[dotted_path] = import_dotted_path(dotted_path)
+    except AttributeError as e:
+        REACTPY_FAILED_COMPONENTS.add(dotted_path)
+        raise ComponentDoesNotExistError(
+            f"Error while fetching '{dotted_path}'. {(str(e).capitalize())}."
+        ) from e
+
+
+def register_iframe(view: Callable | View | str):
+    """Registers a view to be used as an iframe component.
+
+    Args:
+        view: The view to register. Can be a function or class based view, or a dotted path to a view.
+    """
+    from reactpy_django.config import REACTPY_REGISTERED_IFRAME_VIEWS
+
+    if hasattr(view, "view_class"):
+        view = view.view_class
+    dotted_path = view if isinstance(view, str) else generate_obj_name(view)
+    try:
+        REACTPY_REGISTERED_IFRAME_VIEWS[dotted_path] = import_dotted_path(dotted_path)
+    except AttributeError as e:
+        raise ViewDoesNotExistError(
+            f"Error while fetching '{dotted_path}'. {(str(e).capitalize())}."
+        ) from e
+
+
+def import_dotted_path(dotted_path: str) -> Callable:
+    """Imports a dotted path and returns the callable."""
+    module_name, component_name = dotted_path.rsplit(".", 1)
+
+    try:
+        module = import_module(module_name)
+    except ImportError as error:
+        raise RuntimeError(
+            f"Failed to import {module_name!r} while loading {component_name!r}"
+        ) from error
+
+    return getattr(module, component_name)
+
+
+class RootComponentFinder:
+    """Searches Django templates to find and register all root components.
+    This should only be `run` once on startup to maintain synchronization during mulitprocessing.
+    """
+
+    def run(self):
+        """Registers all ReactPy components found within Django templates."""
+        # Get all template folder paths
+        paths = self.get_paths()
+        # Get all HTML template files
+        templates = self.get_templates(paths)
+        # Get all components
+        components = self.get_components(templates)
+        # Register all components
+        self.register_components(components)
+
+    def get_loaders(self):
+        """Obtains currently configured template loaders."""
+        template_source_loaders = []
+        for e in engines.all():
+            if hasattr(e, "engine"):
+                template_source_loaders.extend(
+                    e.engine.get_template_loaders(e.engine.loaders)
+                )
+        loaders = []
+        for loader in template_source_loaders:
+            if hasattr(loader, "loaders"):
+                loaders.extend(loader.loaders)
+            else:
+                loaders.append(loader)
+        return loaders
+
+    def get_paths(self) -> set[str]:
+        """Obtains a set of all template directories."""
+        paths: set[str] = set()
+        for loader in self.get_loaders():
+            with contextlib.suppress(ImportError, AttributeError, TypeError):
+                module = import_module(loader.__module__)
+                get_template_sources = getattr(module, "get_template_sources", None)
+                if get_template_sources is None:
+                    get_template_sources = loader.get_template_sources
+                paths.update(smart_str(origin) for origin in get_template_sources(""))
+        return paths
+
+    def get_templates(self, paths: set[str]) -> set[str]:
+        """Obtains a set of all HTML template paths."""
+        extensions = [".html"]
+        templates: set[str] = set()
+        for path in paths:
+            for root, _, files in os.walk(path, followlinks=False):
+                templates.update(
+                    os.path.join(root, name)
+                    for name in files
+                    if not name.startswith(".")
+                    and any(fnmatch(name, f"*{glob}") for glob in extensions)
+                )
+
+        return templates
+
+    def get_components(self, templates: set[str]) -> set[str]:
+        """Obtains a set of all ReactPy components by parsing HTML templates."""
+        components: set[str] = set()
+        for template in templates:
+            with contextlib.suppress(Exception):
+                with open(template, "r", encoding="utf-8") as template_file:
+                    clean_template = COMMENT_REGEX.sub("", template_file.read())
+                    regex_iterable = COMPONENT_REGEX.finditer(clean_template)
+                    new_components: list[str] = []
+                    for match in regex_iterable:
+                        new_components.append(
+                            match.group("path").replace('"', "").replace("'", "")
+                        )
+                        offline_path = match.group("offline_path")
+                        if offline_path:
+                            new_components.append(
+                                offline_path.replace('"', "").replace("'", "")
+                            )
+                    components.update(new_components)
+        if not components:
+            _logger.warning(
+                "\033[93m"
+                "ReactPy did not find any components! "
+                "You are either not using any ReactPy components, "
+                "using the template tag incorrectly, "
+                "or your HTML templates are not registered with Django."
+                "\033[0m"
+            )
+        return components
+
+    def register_components(self, components: set[str]) -> None:
+        """Registers all ReactPy components in an iterable."""
+        if components:
+            _logger.debug("Auto-detected ReactPy root components:")
+        for component in components:
+            try:
+                _logger.debug("\t+ %s", component)
+                register_component(component)
+            except Exception:
+                _logger.exception(
+                    "\033[91m"
+                    "ReactPy failed to register component '%s'!\n"
+                    "This component path may not be valid, "
+                    "or an exception may have occurred while importing.\n"
+                    "See the traceback below for more information."
+                    "\033[0m",
+                    component,
+                )
+
+
+def generate_obj_name(obj: Any) -> str:
+    """Makes a best effort to create a name for an object.
+    Useful for JSON serialization of Python objects."""
+
+    # First attempt: Dunder methods
+    if hasattr(obj, "__module__"):
+        if hasattr(obj, "__name__"):
+            return f"{obj.__module__}.{obj.__name__}"
+        if hasattr(obj, "__class__") and hasattr(obj.__class__, "__name__"):
+            return f"{obj.__module__}.{obj.__class__.__name__}"
+
+    # Second attempt: String representation
+    with contextlib.suppress(Exception):
+        return str(obj)
+
+    # Fallback: Empty string
+    return ""
+
+
+def django_query_postprocessor(
+    data: QuerySet | Model, many_to_many: bool = True, many_to_one: bool = True
+) -> QuerySet | Model:
+    """Recursively fetch all fields within a `Model` or `QuerySet` to ensure they are not performed lazily.
+
+    Behaviors can be modified through `QueryOptions` within your `use_query` hook.
+
+    Args:
+        data: The `Model` or `QuerySet` to recursively fetch fields from.
+
+    Keyword Args:
+        many_to_many: Whether or not to recursively fetch `ManyToManyField` relationships.
+        many_to_one: Whether or not to recursively fetch `ForeignKey` relationships.
+
+    Returns:
+        The `Model` or `QuerySet` with all fields fetched.
+    """
+
+    # `QuerySet`, which is an iterable of `Model`/`QuerySet` instances
+    # https://github.com/typeddjango/django-stubs/issues/704
+    if isinstance(data, QuerySet):  # type: ignore[misc]
+        for model in data:
+            django_query_postprocessor(
+                model,
+                many_to_many=many_to_many,
+                many_to_one=many_to_one,
+            )
+
+    # `Model` instances
+    elif isinstance(data, Model):
+        prefetch_fields: list[str] = []
+        for field in data._meta.get_fields():
+            # Force the query to execute
+            getattr(data, field.name, None)
+
+            if many_to_one and type(field) == ManyToOneRel:  # noqa: E721
+                prefetch_fields.append(field.related_name or f"{field.name}_set")
+
+            elif many_to_many and isinstance(field, ManyToManyField):
+                prefetch_fields.append(field.name)
+
+        if prefetch_fields:
+            prefetch_related_objects([data], *prefetch_fields)
+            for field_str in prefetch_fields:
+                django_query_postprocessor(
+                    getattr(data, field_str).get_queryset(),
+                    many_to_many=many_to_many,
+                    many_to_one=many_to_one,
+                )
+
+    # Unrecognized type
+    else:
+        raise TypeError(
+            f"Django query postprocessor expected a Model or QuerySet, got {data!r}.\n"
+            "One of the following may have occurred:\n"
+            "  - You are using a non-Django ORM.\n"
+            "  - You are attempting to use `use_query` to fetch non-ORM data.\n\n"
+            "If these situations seem correct, you may want to consider disabling the postprocessor via `QueryOptions`."
+        )
+
+    return data
+
+
+def validate_component_args(func, *args, **kwargs):
+    """
+    Validate whether a set of args/kwargs would work on the given component.
+
+    Raises `ComponentParamError` if the args/kwargs are invalid.
+    """
+    signature = inspect.signature(func)
+
+    try:
+        signature.bind(*args, **kwargs)
+    except TypeError as e:
+        name = generate_obj_name(func)
+        raise ComponentParamError(
+            f"Invalid args for '{name}'. {str(e).capitalize()}."
+        ) from e
+
+
+def create_cache_key(*args):
+    """Creates a cache key string that starts with `reactpy_django` contains
+    all *args separated by `:`."""
+
+    if not args:
+        raise ValueError("At least one argument is required to create a cache key.")
+
+    return f"reactpy_django:{':'.join(str(arg) for arg in args)}"
+
+
+class SyncLayout(Layout):
+    """Sync adapter for ReactPy's `Layout`. Allows it to be used in Django template tags.
+    This can be removed when Django supports async template tags.
+    """
+
+    def __enter__(self):
+        async_to_sync(self.__aenter__)()
+        return self
+
+    def __exit__(self, *_):
+        async_to_sync(self.__aexit__)(*_)
+
+    def render(self):
+        return async_to_sync(super().render)()
+
+
+def get_pk(model):
+    """Returns the value of the primary key for a Django model."""
+    return getattr(model, model._meta.pk.name)
+
+
+def strtobool(val):
+    """Convert a string representation of truth to true (1) or false (0).
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return 1
+    elif val in ("n", "no", "f", "false", "off", "0"):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))

reactpy_django/websocket/consumer.py

@@ -0,0 +1,218 @@
+"""Anything used to construct a websocket endpoint"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import traceback
+from concurrent.futures import Future
+from datetime import timedelta
+from threading import Thread
+from typing import TYPE_CHECKING, Any, MutableMapping, Sequence
+from urllib.parse import parse_qs
+
+import dill as pickle
+import orjson
+from channels.auth import login
+from channels.db import database_sync_to_async
+from channels.generic.websocket import AsyncJsonWebsocketConsumer
+from django.utils import timezone
+from reactpy.backend.hooks import ConnectionContext
+from reactpy.backend.types import Connection, Location
+from reactpy.core.layout import Layout
+from reactpy.core.serve import serve_layout
+
+from reactpy_django.clean import clean
+from reactpy_django.types import ComponentParams
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser
+
+_logger = logging.getLogger(__name__)
+BACKHAUL_LOOP = asyncio.new_event_loop()
+
+
+def start_backhaul_loop():
+    """Starts the asyncio event loop that will perform component rendering tasks."""
+    asyncio.set_event_loop(BACKHAUL_LOOP)
+    BACKHAUL_LOOP.run_forever()
+
+
+BACKHAUL_THREAD = Thread(
+    target=start_backhaul_loop, daemon=True, name="ReactPyBackhaul"
+)
+
+
+class ReactpyAsyncWebsocketConsumer(AsyncJsonWebsocketConsumer):
+    """Communicates with the browser to perform actions on-demand."""
+
+    async def connect(self) -> None:
+        """The browser has connected."""
+        from reactpy_django import models
+        from reactpy_django.config import (
+            REACTPY_AUTH_BACKEND,
+            REACTPY_AUTO_RELOGIN,
+            REACTPY_BACKHAUL_THREAD,
+        )
+
+        await super().connect()
+
+        # Automatically re-login the user, if needed
+        user: AbstractUser | None = self.scope.get("user")
+        if REACTPY_AUTO_RELOGIN and user and user.is_authenticated and user.is_active:
+            try:
+                await login(self.scope, user, backend=REACTPY_AUTH_BACKEND)
+            except Exception:
+                await asyncio.to_thread(
+                    _logger.error,
+                    "ReactPy websocket authentication has failed!\n"
+                    f"{traceback.format_exc()}",
+                )
+            try:
+                await database_sync_to_async(self.scope["session"].save)()
+            except Exception:
+                await asyncio.to_thread(
+                    _logger.error,
+                    "ReactPy has failed to save scope['session']!\n"
+                    f"{traceback.format_exc()}",
+                )
+
+        # Start the component dispatcher
+        self.dispatcher: Future | asyncio.Task
+        self.threaded = REACTPY_BACKHAUL_THREAD
+        self.component_session: models.ComponentSession | None = None
+        if self.threaded:
+            if not BACKHAUL_THREAD.is_alive():
+                await asyncio.to_thread(
+                    _logger.debug, "Starting ReactPy backhaul thread."
+                )
+                BACKHAUL_THREAD.start()
+            self.dispatcher = asyncio.run_coroutine_threadsafe(
+                self.run_dispatcher(), BACKHAUL_LOOP
+            )
+        else:
+            self.dispatcher = asyncio.create_task(self.run_dispatcher())
+
+    async def disconnect(self, code: int) -> None:
+        """The browser has disconnected."""
+        from reactpy_django.config import REACTPY_CLEAN_INTERVAL
+
+        self.dispatcher.cancel()
+
+        # Update the component's last_accessed timestamp
+        if self.component_session:
+            try:
+                await self.component_session.asave()
+            except Exception:
+                await asyncio.to_thread(
+                    _logger.error,
+                    "ReactPy has failed to save component session!\n"
+                    f"{traceback.format_exc()}",
+                )
+
+        # Queue a cleanup, if needed
+        if REACTPY_CLEAN_INTERVAL is not None:
+            try:
+                await database_sync_to_async(clean)()
+            except Exception:
+                await asyncio.to_thread(
+                    _logger.error,
+                    "ReactPy cleaning failed!\n" f"{traceback.format_exc()}",
+                )
+
+        await super().disconnect(code)
+
+    async def receive_json(self, content: Any, **_) -> None:
+        """Receive a message from the browser. Typically, messages are event signals."""
+        if self.threaded:
+            asyncio.run_coroutine_threadsafe(
+                self.recv_queue.put(content), BACKHAUL_LOOP
+            )
+        else:
+            await self.recv_queue.put(content)
+
+    @classmethod
+    async def decode_json(cls, text_data):
+        return orjson.loads(text_data)
+
+    @classmethod
+    async def encode_json(cls, content):
+        return orjson.dumps(content).decode()
+
+    async def run_dispatcher(self):
+        """Runs the main loop that performs component rendering tasks."""
+        from reactpy_django import models
+        from reactpy_django.config import (
+            REACTPY_REGISTERED_COMPONENTS,
+            REACTPY_SESSION_MAX_AGE,
+        )
+
+        scope = self.scope
+        self.dotted_path = dotted_path = scope["url_route"]["kwargs"]["dotted_path"]
+        uuid = scope["url_route"]["kwargs"].get("uuid")
+        has_args = scope["url_route"]["kwargs"].get("has_args")
+        scope["reactpy"] = {"id": str(uuid)}
+        query_string = parse_qs(scope["query_string"].decode(), strict_parsing=True)
+        http_pathname = query_string.get("http_pathname", [""])[0]
+        http_search = query_string.get("http_search", [""])[0]
+        self.recv_queue: asyncio.Queue = asyncio.Queue()
+        connection = Connection(  # For `use_connection`
+            scope=scope,
+            location=Location(pathname=http_pathname, search=http_search),
+            carrier=self,
+        )
+        now = timezone.now()
+        component_session_args: Sequence[Any] = ()
+        component_session_kwargs: MutableMapping[str, Any] = {}
+
+        # Verify the component has already been registered
+        try:
+            root_component_constructor = REACTPY_REGISTERED_COMPONENTS[dotted_path]
+        except KeyError:
+            await asyncio.to_thread(
+                _logger.warning,
+                f"Attempt to access invalid ReactPy component: {dotted_path!r}",
+            )
+            return
+
+        # Construct the component. This may require fetching the component's args/kwargs from the database.
+        try:
+            if has_args:
+                self.component_session = await models.ComponentSession.objects.aget(
+                    uuid=uuid,
+                    last_accessed__gt=now - timedelta(seconds=REACTPY_SESSION_MAX_AGE),
+                )
+                params: ComponentParams = pickle.loads(self.component_session.params)
+                component_session_args = params.args
+                component_session_kwargs = params.kwargs
+
+            # Generate the initial component instance
+            root_component = root_component_constructor(
+                *component_session_args, **component_session_kwargs
+            )
+        except models.ComponentSession.DoesNotExist:
+            await asyncio.to_thread(
+                _logger.warning,
+                f"Component session for '{dotted_path}:{uuid}' not found. The "
+                "session may have already expired beyond REACTPY_SESSION_MAX_AGE. "
+                "If you are using a custom `host`, you may have forgotten to provide "
+                "args/kwargs.",
+            )
+            return
+        except Exception:
+            await asyncio.to_thread(
+                _logger.error,
+                f"Failed to construct component {root_component_constructor} "
+                f"with args='{component_session_args}' kwargs='{component_session_kwargs}'!\n"
+                f"{traceback.format_exc()}",
+            )
+            return
+
+        # Start the ReactPy component rendering loop
+        with contextlib.suppress(Exception):
+            await serve_layout(
+                Layout(ConnectionContext(root_component, value=connection)),
+                self.send_json,
+                self.recv_queue.get,
+            )

reactpy_django/websocket/paths.py

@@ -0,0 +1,17 @@
+from django.urls import path
+
+from reactpy_django.config import REACTPY_URL_PREFIX
+
+from .consumer import ReactpyAsyncWebsocketConsumer
+
+REACTPY_WEBSOCKET_ROUTE = path(
+    f"{REACTPY_URL_PREFIX}/<str:dotted_path>/<uuid:uuid>/<int:has_args>/",
+    ReactpyAsyncWebsocketConsumer.as_asgi(),
+)
+"""A URL path for :class:`ReactpyAsyncWebsocketConsumer`.
+
+Required since the `reverse()` function does not exist for Django Channels, but we need
+to know the websocket path.
+"""
+
+REACTPY_WEBSOCKET_PATH = REACTPY_WEBSOCKET_ROUTE

reactpy_django-3.8.1.dist-info/LICENSE.md

@@ -0,0 +1,9 @@
+## The MIT License (MIT)
+
+#### Copyright (c) Reactive Python and affiliates.
+
+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.