PyPI - reactpy_django - Versions diffs - 3.8.1__py2.py3-none-any.whl - Mend

reactpy_django 3.8.1__py2.py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

js/node_modules/flatted/python/flatted.py +149 -0
js/node_modules/flatted/python/test.py +63 -0
reactpy_django/__init__.py +28 -0
reactpy_django/apps.py +11 -0
reactpy_django/checks.py +542 -0
reactpy_django/clean.py +141 -0
reactpy_django/components.py +286 -0
reactpy_django/config.py +135 -0
reactpy_django/database.py +31 -0
reactpy_django/decorators.py +101 -0
reactpy_django/exceptions.py +34 -0
reactpy_django/hooks.py +496 -0
reactpy_django/http/__init__.py +0 -0
reactpy_django/http/urls.py +18 -0
reactpy_django/http/views.py +62 -0
reactpy_django/management/__init__.py +0 -0
reactpy_django/management/commands/__init__.py +0 -0
reactpy_django/management/commands/clean_reactpy.py +37 -0
reactpy_django/migrations/0001_initial.py +25 -0
reactpy_django/migrations/0002_rename_created_at_componentparams_last_accessed.py +17 -0
reactpy_django/migrations/0003_componentsession_delete_componentparams.py +28 -0
reactpy_django/migrations/0004_config.py +27 -0
reactpy_django/migrations/0005_alter_componentsession_last_accessed.py +17 -0
reactpy_django/migrations/0006_userdatamodel.py +28 -0
reactpy_django/migrations/__init__.py +0 -0
reactpy_django/models.py +48 -0
reactpy_django/py.typed +1 -0
reactpy_django/router/__init__.py +5 -0
reactpy_django/router/converters.py +7 -0
reactpy_django/router/resolvers.py +58 -0
reactpy_django/static/reactpy_django/client.js +1630 -0
reactpy_django/templates/reactpy/component.html +27 -0
reactpy_django/templatetags/__init__.py +0 -0
reactpy_django/templatetags/reactpy.py +221 -0
reactpy_django/types.py +121 -0
reactpy_django/utils.py +384 -0
reactpy_django/websocket/__init__.py +0 -0
reactpy_django/websocket/consumer.py +218 -0
reactpy_django/websocket/paths.py +17 -0
reactpy_django-3.8.1.dist-info/LICENSE.md +9 -0
reactpy_django-3.8.1.dist-info/METADATA +152 -0
reactpy_django-3.8.1.dist-info/RECORD +44 -0
reactpy_django-3.8.1.dist-info/WHEEL +6 -0
reactpy_django-3.8.1.dist-info/top_level.txt +2 -0

reactpy_django/templates/reactpy/component.html ADDED Viewed

@@ -0,0 +1,27 @@
+{% load static %}
+{% if reactpy_failure and reactpy_debug_mode %}
+<pre>{% firstof reactpy_error "UnknownError" %}: "{% firstof reactpy_dotted_path "UnknownPath" %}"</pre>
+{% endif %}
+{% if not reactpy_failure %}
+{% if reactpy_class %}<div id="{{reactpy_uuid}}" class="{{reactpy_class}}"></div>{% endif %}
+{% if not reactpy_class %}<div id="{{reactpy_uuid}}"></div>{% endif %}
+{% if reactpy_prerender_html %}<div id="{{reactpy_uuid}}-prerender">{{reactpy_prerender_html|safe}}</div>{% endif %}
+{% if reactpy_offline_html %}<div id="{{reactpy_uuid}}-offline" hidden>{{reactpy_offline_html|safe}}</div>{% endif %}
+<script type="module" crossorigin="anonymous">
+  import { mountComponent } from "{% static 'reactpy_django/client.js' %}";
+  const mountElement = document.getElementById("{{reactpy_uuid}}");
+  mountComponent(
+    mountElement,
+    "{{reactpy_host}}",
+    "{{reactpy_url_prefix}}",
+    "{{reactpy_component_path}}",
+    "{{reactpy_resolved_web_modules_path}}",
+    Number("{{reactpy_reconnect_interval}}"),
+    Number("{{reactpy_reconnect_max_interval}}"),
+    Number("{{reactpy_reconnect_max_retries}}"),
+    Number("{{reactpy_reconnect_backoff_multiplier}}"),
+  );
+</script>
+{% endif %}

reactpy_django/templatetags/__init__.py ADDED Viewed

File without changes

reactpy_django/templatetags/reactpy.py ADDED Viewed

@@ -0,0 +1,221 @@
+from __future__ import annotations
+from logging import getLogger
+from uuid import uuid4
+import dill as pickle
+from django import template
+from django.http import HttpRequest
+from django.urls import NoReverseMatch, reverse
+from reactpy.backend.hooks import ConnectionContext
+from reactpy.backend.types import Connection, Location
+from reactpy.core.types import ComponentConstructor
+from reactpy.utils import vdom_to_html
+from reactpy_django import config, models
+from reactpy_django.exceptions import (
+    ComponentCarrierError,
+    ComponentDoesNotExistError,
+    ComponentParamError,
+    InvalidHostError,
+    OfflineComponentMissing,
+)
+from reactpy_django.types import ComponentParams
+from reactpy_django.utils import SyncLayout, strtobool, validate_component_args
+try:
+    RESOLVED_WEB_MODULES_PATH = reverse("reactpy:web_modules", args=["/"]).strip("/")
+except NoReverseMatch:
+    RESOLVED_WEB_MODULES_PATH = ""
+register = template.Library()
+_logger = getLogger(__name__)
+@register.inclusion_tag("reactpy/component.html", takes_context=True)
+def component(
+    context: template.RequestContext,
+    dotted_path: str,
+    *args,
+    host: str | None = None,
+    prerender: str = str(config.REACTPY_PRERENDER),
+    offline: str = "",
+    **kwargs,
+):
+    """This tag is used to embed an existing ReactPy component into your HTML template.
+    Args:
+        dotted_path: The dotted path to the component to render.
+        *args: The positional arguments to provide to the component.
+    Keyword Args:
+        class: The HTML class to apply to the top-level component div.
+        key: Force the component's root node to use a specific key value. Using \
+            key within a template tag is effectively useless.
+        host: The host to use for the ReactPy connections. If set to `None`, \
+            the host will be automatically configured. \
+            Example values include: `localhost:8000`, `example.com`, `example.com/subdir`
+        prerender: Configures whether to pre-render this component, which \
+            enables SEO compatibility and reduces perceived latency.
+        offline: The dotted path to the component to render when the client is offline.
+        **kwargs: The keyword arguments to provide to the component.
+    Example ::
+        {% load reactpy %}
+        <!DOCTYPE html>
+        <html>
+        <body>
+            {% component "example_project.my_app.components.hello_world" recipient="World" %}
+        </body>
+        </html>
+    """
+    request: HttpRequest | None = context.get("request")
+    perceived_host = (request.get_host() if request else "").strip("/")
+    host = (
+        host
+        or (next(config.REACTPY_DEFAULT_HOSTS) if config.REACTPY_DEFAULT_HOSTS else "")
+    ).strip("/")
+    is_local = not host or host.startswith(perceived_host)
+    uuid = str(uuid4())
+    class_ = kwargs.pop("class", "")
+    has_args = bool(args or kwargs)
+    user_component: ComponentConstructor | None = None
+    _prerender_html = ""
+    _offline_html = ""
+    # Validate the host
+    if host and config.REACTPY_DEBUG_MODE:
+        try:
+            validate_host(host)
+        except InvalidHostError as e:
+            return failure_context(dotted_path, e)
+    # Fetch the component
+    if is_local:
+        user_component = config.REACTPY_REGISTERED_COMPONENTS.get(dotted_path)
+        if not user_component:
+            msg = f"Component '{dotted_path}' is not registered as a root component. "
+            _logger.error(msg)
+            return failure_context(dotted_path, ComponentDoesNotExistError(msg))
+    # Validate the component args & kwargs
+    if is_local and config.REACTPY_DEBUG_MODE:
+        try:
+            validate_component_args(user_component, *args, **kwargs)
+        except ComponentParamError as e:
+            _logger.error(str(e))
+            return failure_context(dotted_path, e)
+    # Store args & kwargs in the database (fetched by our websocket later)
+    if has_args:
+        try:
+            save_component_params(args, kwargs, uuid)
+        except Exception as e:
+            _logger.exception(
+                "An unknown error has occurred while saving component params for '%s'.",
+                dotted_path,
+            )
+            return failure_context(dotted_path, e)
+    # Pre-render the component, if requested
+    if strtobool(prerender):
+        if not is_local:
+            msg = "Cannot pre-render non-local components."
+            _logger.error(msg)
+            return failure_context(dotted_path, ComponentDoesNotExistError(msg))
+        if not user_component:
+            msg = "Cannot pre-render component that is not registered."
+            _logger.error(msg)
+            return failure_context(dotted_path, ComponentDoesNotExistError(msg))
+        if not request:
+            msg = (
+                "Cannot pre-render component without a HTTP request. Are you missing the "
+                "request context processor in settings.py:TEMPLATES['OPTIONS']['context_processors']?"
+            )
+            _logger.error(msg)
+            return failure_context(dotted_path, ComponentCarrierError(msg))
+        _prerender_html = prerender_component(
+            user_component, args, kwargs, uuid, request
+        )
+    # Fetch the offline component's HTML, if requested
+    if offline:
+        offline_component = config.REACTPY_REGISTERED_COMPONENTS.get(offline)
+        if not offline_component:
+            msg = f"Cannot render offline component '{offline}'. It is not registered as a component."
+            _logger.error(msg)
+            return failure_context(dotted_path, OfflineComponentMissing(msg))
+        if not request:
+            msg = (
+                "Cannot render an offline component without a HTTP request. Are you missing the "
+                "request context processor in settings.py:TEMPLATES['OPTIONS']['context_processors']?"
+            )
+            _logger.error(msg)
+            return failure_context(dotted_path, ComponentCarrierError(msg))
+        _offline_html = prerender_component(offline_component, [], {}, uuid, request)
+    # Return the template rendering context
+    return {
+        "reactpy_class": class_,
+        "reactpy_uuid": uuid,
+        "reactpy_host": host or perceived_host,
+        "reactpy_url_prefix": config.REACTPY_URL_PREFIX,
+        "reactpy_component_path": f"{dotted_path}/{uuid}/{int(has_args)}/",
+        "reactpy_resolved_web_modules_path": RESOLVED_WEB_MODULES_PATH,
+        "reactpy_reconnect_interval": config.REACTPY_RECONNECT_INTERVAL,
+        "reactpy_reconnect_max_interval": config.REACTPY_RECONNECT_MAX_INTERVAL,
+        "reactpy_reconnect_backoff_multiplier": config.REACTPY_RECONNECT_BACKOFF_MULTIPLIER,
+        "reactpy_reconnect_max_retries": config.REACTPY_RECONNECT_MAX_RETRIES,
+        "reactpy_prerender_html": _prerender_html,
+        "reactpy_offline_html": _offline_html,
+    }
+def failure_context(dotted_path: str, error: Exception):
+    return {
+        "reactpy_failure": True,
+        "reactpy_debug_mode": config.REACTPY_DEBUG_MODE,
+        "reactpy_dotted_path": dotted_path,
+        "reactpy_error": type(error).__name__,
+    }
+def save_component_params(args, kwargs, uuid):
+    params = ComponentParams(args, kwargs)
+    model = models.ComponentSession(uuid=uuid, params=pickle.dumps(params))
+    model.full_clean()
+    model.save()
+def validate_host(host: str):
+    if "://" in host:
+        protocol = host.split("://")[0]
+        msg = (
+            f"Invalid host provided to component. Contains a protocol '{protocol}://'."
+        )
+        _logger.error(msg)
+        raise InvalidHostError(msg)
+def prerender_component(
+    user_component: ComponentConstructor, args, kwargs, uuid, request: HttpRequest
+):
+    search = request.GET.urlencode()
+    scope = getattr(request, "scope", {})
+    scope["reactpy"] = {"id": str(uuid)}
+    with SyncLayout(
+        ConnectionContext(
+            user_component(*args, **kwargs),
+            value=Connection(
+                scope=scope,
+                location=Location(
+                    pathname=request.path, search=f"?{search}" if search else ""
+                ),
+                carrier=request,
+            ),
+        )
+    ) as layout:
+        vdom_tree = layout.render()["model"]
+    return vdom_to_html(vdom_tree)

reactpy_django/types.py ADDED Viewed

@@ -0,0 +1,121 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    MutableMapping,
+    NamedTuple,
+    Protocol,
+    Sequence,
+    TypeVar,
+    Union,
+)
+from django.http import HttpRequest
+from reactpy.types import Connection
+from typing_extensions import ParamSpec
+if TYPE_CHECKING:
+    from reactpy_django.websocket.consumer import ReactpyAsyncWebsocketConsumer
+FuncParams = ParamSpec("FuncParams")
+Inferred = TypeVar("Inferred")
+ConnectionType = Connection[Union["ReactpyAsyncWebsocketConsumer", HttpRequest]]
+@dataclass
+class Query(Generic[Inferred]):
+    """Queries generated by the `use_query` hook."""
+    data: Inferred
+    loading: bool
+    error: Exception | None
+    refetch: Callable[[], None]
+@dataclass
+class Mutation(Generic[FuncParams]):
+    """Mutations generated by the `use_mutation` hook."""
+    execute: Callable[FuncParams, None]
+    loading: bool
+    error: Exception | None
+    reset: Callable[[], None]
+    def __call__(self, *args: FuncParams.args, **kwargs: FuncParams.kwargs) -> None:
+        """Execute the mutation."""
+        self.execute(*args, **kwargs)
+class AsyncPostprocessor(Protocol):
+    async def __call__(self, data: Any) -> Any:
+        ...
+class SyncPostprocessor(Protocol):
+    def __call__(self, data: Any) -> Any:
+        ...
+@dataclass
+class QueryOptions:
+    """Configuration options that can be provided to `use_query`."""
+    from reactpy_django.config import REACTPY_DEFAULT_QUERY_POSTPROCESSOR
+    postprocessor: AsyncPostprocessor | SyncPostprocessor | None = (
+        REACTPY_DEFAULT_QUERY_POSTPROCESSOR
+    )
+    """A callable that can modify the query `data` after the query has been executed.
+    The first argument of postprocessor must be the query `data`. All proceeding arguments
+    are optional `postprocessor_kwargs` (see below). This postprocessor function must return
+    the modified `data`.
+    If unset, REACTPY_DEFAULT_QUERY_POSTPROCESSOR is used.
+    ReactPy's default django_query_postprocessor prevents Django's lazy query execution, and
+    additionally can be configured via `postprocessor_kwargs` to recursively fetch
+    `many_to_many` and `many_to_one` fields."""
+    postprocessor_kwargs: MutableMapping[str, Any] = field(default_factory=lambda: {})
+    """Keyworded arguments directly passed into the `postprocessor` for configuration."""
+    thread_sensitive: bool = True
+    """Whether to run the query in thread-sensitive mode. This setting only applies to sync query functions."""
+@dataclass
+class MutationOptions:
+    """Configuration options that can be provided to `use_mutation`."""
+    thread_sensitive: bool = True
+    """Whether to run the mutation in thread-sensitive mode. This setting only applies to sync mutation functions."""
+@dataclass
+class ComponentParams:
+    """Container used for serializing component parameters.
+    This dataclass is pickled & stored in the database, then unpickled when needed."""
+    args: Sequence
+    kwargs: MutableMapping[str, Any]
+class UserData(NamedTuple):
+    query: Query[dict | None]
+    mutation: Mutation[dict]
+class AsyncMessageReceiver(Protocol):
+    async def __call__(self, message: dict) -> None:
+        ...
+class AsyncMessageSender(Protocol):
+    async def __call__(self, message: dict) -> None:
+        ...