reflex 0.6.8__tar.gz → 0.6.8a1__tar.gz

{reflex-0.6.8 → reflex-0.6.8a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflex
-Version: 0.6.8
+Version: 0.6.8a1
 Summary: Web apps in pure Python.
 Home-page: https://reflex.dev
 License: Apache-2.0
@@ -15,7 +15,9 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: proxy
 Requires-Dist: alembic (>=1.11.1,<2.0)
+Requires-Dist: asgiproxy (==0.1.1) ; extra == "proxy"
 Requires-Dist: build (>=1.0.3,<2.0)
 Requires-Dist: charset-normalizer (>=3.3.2,<4.0)
 Requires-Dist: distro (>=1.8.0,<2.0) ; sys_platform == "linux"

{reflex-0.6.8 → reflex-0.6.8a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "reflex"
-version = "0.6.8"
+version = "0.6.8a1"
 description = "Web apps in pure Python."
 license = "Apache-2.0"
 authors = [
@@ -49,6 +49,7 @@ setuptools = ">=75.0"
 httpx = ">=0.25.1,<1.0"
 twine = ">=4.0.0,<7.0"
 tomlkit = ">=0.12.4,<1.0"
+asgiproxy = { version = "==0.1.1", optional = true }
 lazy_loader = ">=0.4"
 reflex-chakra = ">=0.6.0"
 typing_extensions = ">=4.6.0"
@@ -72,10 +73,14 @@ selenium = ">=4.11.0,<5.0"
 pytest-benchmark = ">=4.0.0,<6.0"
 playwright = ">=1.46.0"
 pytest-playwright = ">=0.5.1"
+asgiproxy = "==0.1.1"
 
 [tool.poetry.scripts]
 reflex = "reflex.reflex:cli"
 
+[tool.poetry.extras]
+proxy = ["asgiproxy"]
+
 [build-system]
 requires = ["poetry-core>=1.5.1"]
 build-backend = "poetry.core.masonry.api"

{reflex-0.6.8 → reflex-0.6.8a1}/reflex/app.py

@@ -331,6 +331,12 @@ class App(MiddlewareMixin, LifespanMixin):
 
             self.register_lifespan_task(windows_hot_reload_lifespan_hack)
 
+        # Enable proxying to frontend server.
+        if not environment.REFLEX_BACKEND_ONLY.get():
+            from reflex.proxy import proxy_middleware
+
+            self.register_lifespan_task(proxy_middleware)
+
     def _enable_state(self) -> None:
         """Enable state for the app."""
         if not self.state:

{reflex-0.6.8 → reflex-0.6.8a1}/reflex/config.py

@@ -26,6 +26,7 @@ from typing import (
 
 from typing_extensions import Annotated, get_type_hints
 
+from reflex.utils.console import set_log_level
 from reflex.utils.exceptions import ConfigError, EnvironmentVarValueError
 from reflex.utils.types import GenericType, is_union, value_inside_optional
 
@@ -599,6 +600,7 @@ class Config(Base):
     class Config:
         """Pydantic config for the config."""
 
+        use_enum_values = False
         validate_assignment = True
 
     # The name of the app (should match the name of the app directory).
@@ -718,6 +720,9 @@ class Config(Base):
         self._non_default_attributes.update(kwargs)
         self._replace_defaults(**kwargs)
 
+        # Set the log level for this process
+        set_log_level(self.loglevel)
+
         if (
             self.state_manager_mode == constants.StateManagerMode.REDIS
             and not self.redis_url

{reflex-0.6.8 → reflex-0.6.8a1}/reflex/event.py

@@ -437,7 +437,6 @@ class EventChain(EventActionsMixin):
         value: EventType,
         args_spec: ArgsSpec | Sequence[ArgsSpec],
         key: Optional[str] = None,
-        **event_chain_kwargs,
     ) -> Union[EventChain, Var]:
         """Create an event chain from a variety of input types.
 
@@ -445,7 +444,6 @@ class EventChain(EventActionsMixin):
             value: The value to create the event chain from.
             args_spec: The args_spec of the event trigger being bound.
             key: The key of the event trigger being bound.
-            **event_chain_kwargs: Additional kwargs to pass to the EventChain constructor.
 
         Returns:
             The event chain.
@@ -464,7 +462,6 @@ class EventChain(EventActionsMixin):
                     value=value.guess_type(),
                     args_spec=args_spec,
                     key=key,
-                    **event_chain_kwargs,
                 )
             else:
                 raise ValueError(
@@ -504,9 +501,7 @@ class EventChain(EventActionsMixin):
             result = call_event_fn(value, args_spec, key=key)
             if isinstance(result, Var):
                 # Recursively call this function if the lambda returned an EventChain Var.
-                return cls.create(
-                    value=result, args_spec=args_spec, key=key, **event_chain_kwargs
-                )
+                return cls.create(value=result, args_spec=args_spec, key=key)
             events = [*result]
 
         # Otherwise, raise an error.
@@ -523,7 +518,7 @@ class EventChain(EventActionsMixin):
         return cls(
             events=events,
             args_spec=args_spec,
-            **event_chain_kwargs,
+            event_actions={},
         )
 
 

reflex-0.6.8a1/reflex/proxy.py

@@ -0,0 +1,119 @@
+"""Handle proxying frontend requests from the backend server."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator
+from urllib.parse import urlparse
+
+from fastapi import FastAPI
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from .config import get_config
+from .utils import console
+
+try:
+    import aiohttp
+    from asgiproxy.config import BaseURLProxyConfigMixin, ProxyConfig
+    from asgiproxy.context import ProxyContext
+    from asgiproxy.proxies.http import proxy_http
+    from asgiproxy.simple_proxy import make_simple_proxy_app
+except ImportError:
+
+    @asynccontextmanager
+    async def proxy_middleware(*args, **kwargs) -> AsyncGenerator[None, None]:
+        """A no-op proxy middleware for when asgiproxy is not installed.
+
+        Args:
+            *args: The positional arguments.
+            **kwargs: The keyword arguments.
+
+        Yields:
+            None
+        """
+        yield
+else:
+    MAX_PROXY_RETRY = 25
+
+    async def proxy_http_with_retry(
+        *,
+        context: ProxyContext,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> Any:
+        """Proxy an HTTP request with retries.
+
+        Args:
+            context: The proxy context.
+            scope: The request scope.
+            receive: The receive channel.
+            send: The send channel.
+
+        Returns:
+            The response from `proxy_http`.
+        """
+        for _attempt in range(MAX_PROXY_RETRY):
+            try:
+                return await proxy_http(
+                    context=context,
+                    scope=scope,
+                    receive=receive,
+                    send=send,
+                )
+            except aiohttp.ClientError as err:  # noqa: PERF203
+                console.debug(
+                    f"Retrying request {scope['path']} due to client error {err!r}."
+                )
+                await asyncio.sleep(0.3)
+            except Exception as ex:
+                console.debug(
+                    f"Retrying request {scope['path']} due to unhandled exception {ex!r}."
+                )
+                await asyncio.sleep(0.3)
+
+    def _get_proxy_app_with_context(frontend_host: str) -> tuple[ProxyContext, ASGIApp]:
+        """Get the proxy app with the given frontend host.
+
+        Args:
+            frontend_host: The frontend host to proxy requests to.
+
+        Returns:
+            The proxy context and app.
+        """
+
+        class LocalProxyConfig(BaseURLProxyConfigMixin, ProxyConfig):
+            upstream_base_url = frontend_host
+            rewrite_host_header = urlparse(upstream_base_url).netloc
+
+        proxy_context = ProxyContext(LocalProxyConfig())
+        proxy_app = make_simple_proxy_app(
+            proxy_context, proxy_http_handler=proxy_http_with_retry
+        )
+        return proxy_context, proxy_app
+
+    @asynccontextmanager
+    async def proxy_middleware(  # pyright: ignore[reportGeneralTypeIssues]
+        app: FastAPI,
+    ) -> AsyncGenerator[None, None]:
+        """A middleware to proxy requests to the separate frontend server.
+
+        The proxy is installed on the / endpoint of the FastAPI instance.
+
+        Args:
+            app: The FastAPI instance.
+
+        Yields:
+            None
+        """
+        config = get_config()
+        backend_port = config.backend_port
+        frontend_host = f"http://localhost:{config.frontend_port}"
+        proxy_context, proxy_app = _get_proxy_app_with_context(frontend_host)
+        app.mount("/", proxy_app)
+        console.debug(
+            f"Proxying '/' requests on port {backend_port} to {frontend_host}"
+        )
+        async with proxy_context:
+            yield

{reflex-0.6.8 → reflex-0.6.8a1}/reflex/testing.py

@@ -44,6 +44,7 @@ import reflex.utils.format
 import reflex.utils.prerequisites
 import reflex.utils.processes
 from reflex.config import environment
+from reflex.proxy import proxy_middleware
 from reflex.state import (
     BaseState,
     StateManager,
@@ -298,6 +299,9 @@ class AppHarness:
             self.state_manager = StateManagerRedis.create(self.app_instance.state)
         else:
             self.state_manager = self.app_instance._state_manager
+        # Disable proxy for app harness tests.
+        if proxy_middleware in self.app_instance.lifespan_tasks:
+            self.app_instance.lifespan_tasks.remove(proxy_middleware)
 
     def _reload_state_module(self):
         """Reload the rx.State module to avoid conflict when reloading."""
@@ -365,9 +369,12 @@ class AppHarness:
     def _start_frontend(self):
         # Set up the frontend.
         with chdir(self.app_path):
+            backend_host, backend_port = self._poll_for_servers().getsockname()
             config = reflex.config.get_config()
+            config.backend_port = backend_port
             config.api_url = "http://{0}:{1}".format(
-                *self._poll_for_servers().getsockname(),
+                backend_host,
+                backend_port,
             )
             reflex.utils.build.setup_frontend(self.app_path)
 
@@ -392,6 +399,7 @@ class AppHarness:
                 self.frontend_url = m.group(1)
                 config = reflex.config.get_config()
                 config.deploy_url = self.frontend_url
+                config.frontend_port = int(self.frontend_url.rpartition(":")[2])
                 break
         if self.frontend_url is None:
             raise RuntimeError("Frontend did not start")
@@ -915,17 +923,20 @@ class AppHarnessProd(AppHarness):
             root=web_root,
             error_page_map=error_page_map,
         ) as self.frontend_server:
-            self.frontend_url = "http://localhost:{1}".format(
-                *self.frontend_server.socket.getsockname()
-            )
+            config = reflex.config.get_config()
+            config.frontend_port = self.frontend_server.server_address[1]
+            self.frontend_url = f"http://localhost:{config.frontend_port}"
             self.frontend_server.serve_forever()
 
     def _start_frontend(self):
         # Set up the frontend.
         with chdir(self.app_path):
+            backend_host, backend_port = self._poll_for_servers().getsockname()
             config = reflex.config.get_config()
+            config.backend_port = backend_port
             config.api_url = "http://{0}:{1}".format(
-                *self._poll_for_servers().getsockname(),
+                backend_host,
+                backend_port,
             )
             reflex.reflex.export(
                 zipping=False,

{reflex-0.6.8 → reflex-0.6.8a1}/reflex/utils/console.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import os
+
 from rich.console import Console
 from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
 from rich.prompt import Prompt
@@ -12,7 +14,7 @@ from reflex.constants import LogLevel
 _console = Console()
 
 # The current log level.
-_LOG_LEVEL = LogLevel.INFO
+_LOG_LEVEL = LogLevel.DEFAULT
 
 # Deprecated features who's warning has been printed.
 _EMITTED_DEPRECATION_WARNINGS = set()
@@ -61,6 +63,9 @@ def set_log_level(log_level: LogLevel):
             raise ValueError(f"Invalid log level: {log_level}") from ae
 
     global _LOG_LEVEL
+    if log_level != _LOG_LEVEL:
+        # Set the loglevel persistently for subprocesses
+        os.environ["LOGLEVEL"] = log_level.value
     _LOG_LEVEL = log_level
 
 

{reflex-0.6.8 → reflex-0.6.8a1}/reflex/vars/base.py

@@ -581,7 +581,7 @@ class Var(Generic[VAR_TYPE]):
 
         # Try to pull the imports and hooks from contained values.
         if not isinstance(value, str):
-            return LiteralVar.create(value, _var_data=_var_data)
+            return LiteralVar.create(value)
 
         if _var_is_string is False or _var_is_local is True:
             return cls(