reflex 0.7.4a2__py3-none-any.whl → 0.7.5__py3-none-any.whl

reflex/utils/prerequisites.py

@@ -115,11 +115,13 @@ def check_latest_package_version(package_name: str):
     if environment.REFLEX_CHECK_LATEST_VERSION.get() is False:
         return
     try:
+        console.debug(f"Checking for the latest version of {package_name}...")
         # Get the latest version from PyPI
         current_version = importlib.metadata.version(package_name)
         url = f"https://pypi.org/pypi/{package_name}/json"
         response = net.get(url)
         latest_version = response.json()["info"]["version"]
+        console.debug(f"Latest version of {package_name}: {latest_version}")
         if get_or_set_last_reflex_version_check_datetime():
             # Versions were already checked and saved in reflex.json, no need to warn again
             return
@@ -129,6 +131,7 @@ def check_latest_package_version(package_name: str):
                 f"Your version ({current_version}) of {package_name} is out of date. Upgrade to {latest_version} with 'pip install {package_name} --upgrade'"
             )
     except Exception:
+        console.debug(f"Failed to check for the latest version of {package_name}.")
         pass
 
 
@@ -507,6 +510,9 @@ def compile_or_validate_app(compile: bool = False) -> bool:
         else:
             validate_app()
     except Exception as e:
+        if isinstance(e, typer.Exit):
+            return False
+
         import traceback
 
         sys_exception = sys.exception()
@@ -902,11 +908,12 @@ def initialize_app_directory(
 
     console.debug(f"Using {template_name=} {template_dir=} {template_code_dir_name=}.")
 
-    # Remove all pyc and __pycache__ dirs in template directory.
-    for pyc_file in template_dir.glob("**/*.pyc"):
-        pyc_file.unlink()
-    for pycache_dir in template_dir.glob("**/__pycache__"):
-        pycache_dir.rmdir()
+    # Remove __pycache__ dirs in template directory and current directory.
+    for pycache_dir in [
+        *template_dir.glob("**/__pycache__"),
+        *Path.cwd().glob("**/__pycache__"),
+    ]:
+        shutil.rmtree(pycache_dir, ignore_errors=True)
 
     for file in template_dir.iterdir():
         # Copy the file to current directory but keep the name the same.
@@ -950,16 +957,25 @@ def initialize_web_directory():
     # Reuse the hash if one is already created, so we don't over-write it when running reflex init
     project_hash = get_project_hash()
 
+    console.debug(f"Copying {constants.Templates.Dirs.WEB_TEMPLATE} to {get_web_dir()}")
     path_ops.cp(constants.Templates.Dirs.WEB_TEMPLATE, str(get_web_dir()))
 
+    console.debug("Initializing the web directory.")
     initialize_package_json()
 
+    console.debug("Initializing the bun config file.")
     initialize_bun_config()
 
+    console.debug("Initializing the .npmrc file.")
+    initialize_npmrc()
+
+    console.debug("Initializing the public directory.")
     path_ops.mkdir(get_web_dir() / constants.Dirs.PUBLIC)
 
+    console.debug("Initializing the next.config.js file.")
     update_next_config()
 
+    console.debug("Initializing the reflex.json file.")
     # Initialize the reflex json file.
     init_reflex_json(project_hash=project_hash)
 
@@ -1002,6 +1018,20 @@ def initialize_bun_config():
     bun_config_path.write_text(bunfig_content)
 
 
+def initialize_npmrc():
+    """Initialize the .npmrc file."""
+    npmrc_path = get_web_dir() / constants.Node.CONFIG_PATH
+
+    if (custom_npmrc := Path(constants.Node.CONFIG_PATH)).exists():
+        npmrc_content = custom_npmrc.read_text()
+        console.info(f"Copying custom .npmrc inside {get_web_dir()} folder")
+    else:
+        best_registry = get_npm_registry()
+        npmrc_content = constants.Node.DEFAULT_CONFIG.format(registry=best_registry)
+
+    npmrc_path.write_text(npmrc_content)
+
+
 def init_reflex_json(project_hash: int | None):
     """Write the hash of the Reflex project to a REFLEX_JSON.
 
@@ -1057,6 +1087,7 @@ def _update_next_config(
         "compress": config.next_compression,
         "trailingSlash": True,
         "staticPageGenerationTimeout": config.static_page_generation_timeout,
+        "devIndicators": config.next_dev_indicators,
     }
     if transpile_packages:
         next_config["transpilePackages"] = list(
@@ -1170,26 +1201,39 @@ def _clear_cached_procedure_file(cache_file: str | Path):
         cache_file.unlink()
 
 
-def cached_procedure(cache_file: str, payload_fn: Callable[..., str]):
+def cached_procedure(
+    cache_file: str | None,
+    payload_fn: Callable[..., str],
+    cache_file_fn: Callable[[], str] | None = None,
+):
     """Decorator to cache the runs of a procedure on disk. Procedures should not have
        a return value.
 
     Args:
         cache_file: The file to store the cache payload in.
-        payload_fn: Function that computes cache payload from function args
+        payload_fn: Function that computes cache payload from function args.
+        cache_file_fn: Function that computes the cache file name at runtime.
 
     Returns:
         The decorated function.
+
+    Raises:
+        ValueError: If both cache_file and cache_file_fn are provided.
     """
+    if cache_file and cache_file_fn is not None:
+        raise ValueError("cache_file and cache_file_fn cannot both be provided.")
 
     def _inner_decorator(func: Callable):
         def _inner(*args, **kwargs):
-            payload = _read_cached_procedure_file(cache_file)
+            _cache_file = cache_file_fn() if cache_file_fn is not None else cache_file
+            if not _cache_file:
+                raise ValueError("Unknown cache file, cannot cache result.")
+            payload = _read_cached_procedure_file(_cache_file)
             new_payload = payload_fn(*args, **kwargs)
             if payload != new_payload:
-                _clear_cached_procedure_file(cache_file)
+                _clear_cached_procedure_file(_cache_file)
                 func(*args, **kwargs)
-                _write_cached_procedure_file(new_payload, cache_file)
+                _write_cached_procedure_file(new_payload, _cache_file)
 
         return _inner
 
@@ -1197,8 +1241,11 @@ def cached_procedure(cache_file: str, payload_fn: Callable[..., str]):
 
 
 @cached_procedure(
-    cache_file=str(get_web_dir() / "reflex.install_frontend_packages.cached"),
+    cache_file_fn=lambda: str(
+        get_web_dir() / "reflex.install_frontend_packages.cached"
+    ),
     payload_fn=lambda p, c: f"{sorted(p)!r},{c.json()}",
+    cache_file=None,
 )
 def install_frontend_packages(packages: set[str], config: Config):
     """Installs the base and custom frontend packages.
@@ -1214,6 +1261,14 @@ def install_frontend_packages(packages: set[str], config: Config):
         raise_on_none=True
     )
 
+    env = (
+        {
+            "NODE_TLS_REJECT_UNAUTHORIZED": "0",
+        }
+        if environment.SSL_NO_VERIFY.get()
+        else {}
+    )
+
     primary_package_manager = install_package_managers[0]
     fallbacks = install_package_managers[1:]
 
@@ -1224,6 +1279,7 @@ def install_frontend_packages(packages: set[str], config: Config):
         show_status_message="Installing base frontend packages",
         cwd=get_web_dir(),
         shell=constants.IS_WINDOWS,
+        env=env,
     )
 
     if config.tailwind is not None:
@@ -1241,6 +1297,7 @@ def install_frontend_packages(packages: set[str], config: Config):
             show_status_message="Installing tailwind",
             cwd=get_web_dir(),
             shell=constants.IS_WINDOWS,
+            env=env,
         )
 
     # Install custom packages defined in frontend_packages
@@ -1252,6 +1309,7 @@ def install_frontend_packages(packages: set[str], config: Config):
             show_status_message="Installing frontend packages from config and components",
             cwd=get_web_dir(),
             shell=constants.IS_WINDOWS,
+            env=env,
         )
 
 
@@ -1392,6 +1450,7 @@ def ensure_reflex_installation_id() -> int | None:
         Distinct id.
     """
     try:
+        console.debug("Ensuring reflex installation id.")
         initialize_reflex_user_directory()
         installation_id_file = environment.REFLEX_DIR.get() / "installation_id"
 
@@ -1418,6 +1477,7 @@ def ensure_reflex_installation_id() -> int | None:
 
 def initialize_reflex_user_directory():
     """Initialize the reflex user directory."""
+    console.debug(f"Creating {environment.REFLEX_DIR.get()}")
     # Create the reflex directory.
     path_ops.mkdir(environment.REFLEX_DIR.get())
 
@@ -1425,9 +1485,11 @@ def initialize_reflex_user_directory():
 def initialize_frontend_dependencies():
     """Initialize all the frontend dependencies."""
     # validate dependencies before install
+    console.debug("Validating frontend dependencies.")
     validate_frontend_dependencies()
     # Install the frontend dependencies.
-    processes.run_concurrently(install_bun)
+    console.debug("Installing or validating bun.")
+    install_bun()
     # Set up the web directory.
     initialize_web_directory()
 
@@ -1496,6 +1558,9 @@ def prompt_for_template_options(templates: list[Template]) -> str:
 
     Returns:
         The template name the user selects.
+
+    Raises:
+        Exit: If the user does not select a template.
     """
     # Show the user the URLs of each template to preview.
     console.print("\nGet started with a template:")
@@ -1520,8 +1585,22 @@ def prompt_for_template_options(templates: list[Template]) -> str:
         default="0",
     )
 
+    if not template:
+        console.error("No template selected.")
+        raise typer.Exit(1)
+
+    try:
+        template_index = int(template)
+    except ValueError:
+        console.error("Invalid template selected.")
+        raise typer.Exit(1) from None
+
+    if template_index < 0 or template_index >= len(templates):
+        console.error("Invalid template selected.")
+        raise typer.Exit(1)
+
     # Return the template.
-    return templates[int(template)].name  # pyright: ignore [reportArgumentType]
+    return templates[template_index].name
 
 
 def fetch_app_templates(version: str) -> dict[str, Template]:

reflex/utils/processes.py

@@ -20,6 +20,7 @@ from rich.progress import Progress
 from reflex import constants
 from reflex.config import environment
 from reflex.utils import console, path_ops, prerequisites
+from reflex.utils.registry import get_npm_registry
 
 
 def kill(pid: int):
@@ -276,6 +277,7 @@ def stream_logs(
     progress: Progress | None = None,
     suppress_errors: bool = False,
     analytics_enabled: bool = False,
+    prior_logs: Tuple[tuple[str, ...], ...] = (),
 ):
     """Stream the logs for a process.
 
@@ -285,6 +287,7 @@ def stream_logs(
         progress: The ongoing progress bar if one is being used.
         suppress_errors: If True, do not exit if errors are encountered (for fallback).
         analytics_enabled: Whether analytics are enabled for this command.
+        prior_logs: The logs of the prior processes that have been run.
 
     Yields:
         The lines of the process output.
@@ -312,8 +315,31 @@ def stream_logs(
     accepted_return_codes = [0, -2, 15] if constants.IS_WINDOWS else [0, -2]
     if process.returncode not in accepted_return_codes and not suppress_errors:
         console.error(f"{message} failed with exit code {process.returncode}")
-        for line in logs:
-            console.error(line, end="")
+        if "".join(logs).count("CERT_HAS_EXPIRED") > 0:
+            bunfig = prerequisites.get_web_dir() / constants.Bun.CONFIG_PATH
+            npm_registry_line = next(
+                (
+                    line
+                    for line in bunfig.read_text().splitlines()
+                    if line.startswith("registry")
+                ),
+                None,
+            )
+            if not npm_registry_line or "=" not in npm_registry_line:
+                npm_registry = get_npm_registry()
+            else:
+                npm_registry = npm_registry_line.split("=")[1].strip()
+            console.error(
+                f"Failed to fetch securely from [bold]{npm_registry}[/bold]. Please check your network connection. "
+                "You can try running the command again or changing the registry by setting the "
+                "NPM_CONFIG_REGISTRY environment variable. If TLS is the issue, and you know what "
+                "you are doing, you can disable it by setting the SSL_NO_VERIFY environment variable."
+            )
+            raise typer.Exit(1)
+        for set_of_logs in (*prior_logs, tuple(logs)):
+            for line in set_of_logs:
+                console.error(line, end="")
+            console.error("\n\n")
         if analytics_enabled:
             telemetry.send("error", context=message)
         console.error("Run with [bold]--loglevel debug [/bold] for the full log.")
@@ -336,8 +362,8 @@ def show_status(
     process: subprocess.Popen,
     suppress_errors: bool = False,
     analytics_enabled: bool = False,
-    prior_processes: Tuple[subprocess.Popen, ...] = (),
-):
+    prior_logs: Tuple[tuple[str, ...], ...] = (),
+) -> list[str]:
     """Show the status of a process.
 
     Args:
@@ -345,17 +371,24 @@ def show_status(
         process: The process.
         suppress_errors: If True, do not exit if errors are encountered (for fallback).
         analytics_enabled: Whether analytics are enabled for this command.
-        prior_processes: The prior processes that have been run.
+        prior_logs: The logs of the prior processes that have been run.
+
+    Returns:
+        The lines of the process output.
     """
-    for one_process in (*prior_processes, process):
-        with console.status(message) as status:
-            for line in stream_logs(
-                message,
-                one_process,
-                suppress_errors=suppress_errors,
-                analytics_enabled=analytics_enabled,
-            ):
-                status.update(f"{message} {line}")
+    lines = []
+
+    with console.status(message) as status:
+        for line in stream_logs(
+            message,
+            process,
+            suppress_errors=suppress_errors,
+            analytics_enabled=analytics_enabled,
+            prior_logs=prior_logs,
+        ):
+            status.update(f"{message} {line}")
+            lines.append(line)
+        return lines
 
 
 def show_progress(message: str, process: subprocess.Popen, checkpoints: list[str]):
@@ -409,7 +442,7 @@ def run_process_with_fallbacks(
     show_status_message: str,
     fallbacks: str | Sequence[str] | Sequence[Sequence[str]] | None = None,
     analytics_enabled: bool = False,
-    prior_processes: Tuple[subprocess.Popen, ...] = (),
+    prior_logs: Tuple[tuple[str, ...], ...] = (),
     **kwargs,
 ):
     """Run subprocess and retry using fallback command if initial command fails.
@@ -419,7 +452,7 @@ def run_process_with_fallbacks(
         show_status_message: The status message to be displayed in the console.
         fallbacks: The fallback command to run if the initial command fails.
         analytics_enabled: Whether analytics are enabled for this command.
-        prior_processes: The prior processes that have been run.
+        prior_logs: The logs of the prior processes that have been run.
         **kwargs: Kwargs to pass to new_process function.
     """
     process = new_process(get_command_with_loglevel(args), **kwargs)
@@ -429,11 +462,11 @@ def run_process_with_fallbacks(
             show_status_message,
             process,
             analytics_enabled=analytics_enabled,
-            prior_processes=prior_processes,
+            prior_logs=prior_logs,
         )
     else:
         # Suppress errors for initial command, because we will try to fallback
-        show_status(show_status_message, process, suppress_errors=True)
+        logs = show_status(show_status_message, process, suppress_errors=True)
 
         current_fallback = fallbacks[0] if not isinstance(fallbacks, str) else fallbacks
         next_fallbacks = fallbacks[1:] if not isinstance(fallbacks, str) else None
@@ -453,7 +486,7 @@ def run_process_with_fallbacks(
                 show_status_message=show_status_message,
                 fallbacks=next_fallbacks,
                 analytics_enabled=analytics_enabled,
-                prior_processes=(*prior_processes, process),
+                prior_logs=(*prior_logs, tuple(logs)),
                 **kwargs,
             )
 

reflex/utils/pyi_generator.py

@@ -55,6 +55,10 @@ EXCLUDED_PROPS = [
     "State",
 ]
 
+OVERWRITE_TYPES = {
+    "style": "Sequence[Mapping[str, Any]] | Mapping[str, Any] | Var[Mapping[str, Any]] | Breakpoints | None",
+}
+
 DEFAULT_TYPING_IMPORTS = {
     "overload",
     "Any",
@@ -62,6 +66,7 @@ DEFAULT_TYPING_IMPORTS = {
     "Dict",
     # "List",
     "Sequence",
+    "Mapping",
     "Literal",
     "Optional",
     "Union",
@@ -377,7 +382,9 @@ def _extract_class_props_as_ast_nodes(
                     ast.arg(
                         arg=name,
                         annotation=ast.Name(
-                            id=_get_type_hint(value, type_hint_globals)
+                            id=OVERWRITE_TYPES.get(
+                                name, _get_type_hint(value, type_hint_globals)
+                            )
                         ),
                     ),
                     ast.Constant(value=default),
@@ -386,7 +393,7 @@ def _extract_class_props_as_ast_nodes(
     return kwargs
 
 
-def type_to_ast(typ: Any, cls: type) -> ast.AST:
+def type_to_ast(typ: Any, cls: type) -> ast.expr:
     """Converts any type annotation into its AST representation.
     Handles nested generic types, unions, etc.
 
@@ -439,11 +446,11 @@ def type_to_ast(typ: Any, cls: type) -> ast.AST:
     if len(arg_nodes) == 1:
         slice_value = arg_nodes[0]
     else:
-        slice_value = ast.Tuple(elts=arg_nodes, ctx=ast.Load())  # pyright: ignore [reportArgumentType]
+        slice_value = ast.Tuple(elts=arg_nodes, ctx=ast.Load())
 
     return ast.Subscript(
         value=ast.Name(id=base_name),
-        slice=ast.Index(value=slice_value),  # pyright: ignore [reportArgumentType]
+        slice=slice_value,
         ctx=ast.Load(),
     )
 
@@ -463,16 +470,18 @@ def _get_parent_imports(func: Callable):
 
 
 def _generate_component_create_functiondef(
-    node: ast.FunctionDef | None,
-    clz: type[Component] | type[SimpleNamespace],
+    clz: type[Component],
     type_hint_globals: dict[str, Any],
+    lineno: int,
+    decorator_list: Sequence[ast.expr] = (ast.Name(id="classmethod"),),
 ) -> ast.FunctionDef:
     """Generate the create function definition for a Component.
 
     Args:
-        node: The existing create functiondef node from the ast
         clz: The Component class to generate the create functiondef for.
         type_hint_globals: The globals to use to resolving a type hint str.
+        lineno: The line number to use for the ast nodes.
+        decorator_list: The list of decorators to apply to the create functiondef.
 
     Returns:
         The create functiondef node for the ast.
@@ -584,28 +593,26 @@ def _generate_component_create_functiondef(
                 arg=trigger,
                 annotation=ast.Subscript(
                     ast.Name("Optional"),
-                    ast.Index(  # pyright: ignore [reportArgumentType]
-                        value=ast.Name(
-                            id=ast.unparse(
-                                figure_out_return_type(
-                                    inspect.signature(event_specs).return_annotation
-                                )
-                                if not isinstance(
-                                    event_specs := event_triggers[trigger], Sequence
-                                )
-                                else ast.Subscript(
-                                    ast.Name("Union"),
-                                    ast.Tuple(
-                                        [
-                                            figure_out_return_type(
-                                                inspect.signature(
-                                                    event_spec
-                                                ).return_annotation
-                                            )
-                                            for event_spec in event_specs
-                                        ]
-                                    ),
-                                )
+                    ast.Name(
+                        id=ast.unparse(
+                            figure_out_return_type(
+                                inspect.signature(event_specs).return_annotation
+                            )
+                            if not isinstance(
+                                event_specs := event_triggers[trigger], Sequence
+                            )
+                            else ast.Subscript(
+                                ast.Name("Union"),
+                                ast.Tuple(
+                                    [
+                                        figure_out_return_type(
+                                            inspect.signature(
+                                                event_spec
+                                            ).return_annotation
+                                        )
+                                        for event_spec in event_specs
+                                    ]
+                                ),
                             )
                         )
                     ),
@@ -630,7 +637,7 @@ def _generate_component_create_functiondef(
     definition = ast.FunctionDef(  # pyright: ignore [reportCallIssue]
         name="create",
         args=create_args,
-        body=[  # pyright: ignore [reportArgumentType]
+        body=[
             ast.Expr(
                 value=ast.Constant(
                     value=_generate_docstrings(
@@ -644,25 +651,19 @@ def _generate_component_create_functiondef(
         ],
         decorator_list=[
             ast.Name(id="overload"),
-            *(
-                node.decorator_list
-                if node is not None
-                else [ast.Name(id="classmethod")]
-            ),
+            *decorator_list,
         ],
-        lineno=node.lineno if node is not None else None,  # pyright: ignore [reportArgumentType]
+        lineno=lineno,
         returns=ast.Constant(value=clz.__name__),
     )
     return definition
 
 
 def _generate_staticmethod_call_functiondef(
-    node: ast.FunctionDef | None,
+    node: ast.ClassDef,
     clz: type[Component] | type[SimpleNamespace],
     type_hint_globals: dict[str, Any],
 ) -> ast.FunctionDef | None:
-    ...
-
     fullspec = getfullargspec(clz.__call__)
 
     call_args = ast.arguments(
@@ -699,7 +700,7 @@ def _generate_staticmethod_call_functiondef(
             ),
         ],
         decorator_list=[ast.Name(id="staticmethod")],
-        lineno=node.lineno if node is not None else None,  # pyright: ignore [reportArgumentType]
+        lineno=node.lineno,
         returns=ast.Constant(
             value=_get_type_hint(
                 typing.get_type_hints(clz.__call__).get("return", None),
@@ -712,7 +713,7 @@ def _generate_staticmethod_call_functiondef(
 
 
 def _generate_namespace_call_functiondef(
-    node: ast.ClassDef | None,
+    node: ast.ClassDef,
     clz_name: str,
     classes: dict[str, type[Component] | type[SimpleNamespace]],
     type_hint_globals: dict[str, Any],
@@ -736,7 +737,7 @@ def _generate_namespace_call_functiondef(
     clz = classes[clz_name]
 
     if not hasattr(clz.__call__, "__self__"):
-        return _generate_staticmethod_call_functiondef(node, clz, type_hint_globals)  # pyright: ignore [reportArgumentType]
+        return _generate_staticmethod_call_functiondef(node, clz, type_hint_globals)
 
     # Determine which class is wrapped by the namespace __call__ method
     component_clz = clz.__call__.__self__
@@ -744,10 +745,14 @@ def _generate_namespace_call_functiondef(
     if clz.__call__.__func__.__name__ != "create":  # pyright: ignore [reportFunctionMemberAccess]
         return None
 
+    if not issubclass(component_clz, Component):
+        return None
+
     definition = _generate_component_create_functiondef(
-        node=None,
-        clz=component_clz,  # pyright: ignore [reportArgumentType]
+        clz=component_clz,
         type_hint_globals=type_hint_globals,
+        lineno=node.lineno,
+        decorator_list=[],
     )
     definition.name = "__call__"
 
@@ -804,17 +809,18 @@ class StubGenerator(ast.NodeTransformer):
             node.body.pop(0)
         return node
 
-    def _current_class_is_component(self) -> bool:
+    def _current_class_is_component(self) -> type[Component] | None:
         """Check if the current class is a Component.
 
         Returns:
             Whether the current class is a Component.
         """
-        return (
+        if (
             self.current_class is not None
             and self.current_class in self.classes
-            and issubclass(self.classes[self.current_class], Component)
-        )
+            and issubclass((clz := self.classes[self.current_class]), Component)
+        ):
+            return clz
 
     def visit_Module(self, node: ast.Module) -> ast.Module:
         """Visit a Module node and remove docstring from body.
@@ -916,14 +922,14 @@ class StubGenerator(ast.NodeTransformer):
                 isinstance(child, ast.FunctionDef) and child.name == "create"
                 for child in node.body
             )
-            and self._current_class_is_component()
+            and (clz := self._current_class_is_component()) is not None
         ):
             # Add a new .create FunctionDef since one does not exist.
             node.body.append(
                 _generate_component_create_functiondef(
-                    node=None,
-                    clz=self.classes[self.current_class],
+                    clz=clz,
                     type_hint_globals=self.type_hint_globals,
+                    lineno=node.lineno,
                 )
             )
         if call_definition is not None:
@@ -949,9 +955,16 @@ class StubGenerator(ast.NodeTransformer):
         Returns:
             The modified FunctionDef node (or None).
         """
-        if node.name == "create" and self.current_class in self.classes:
+        if (
+            node.name == "create"
+            and self.current_class in self.classes
+            and issubclass((clz := self.classes[self.current_class]), Component)
+        ):
             node = _generate_component_create_functiondef(
-                node, self.classes[self.current_class], self.type_hint_globals
+                clz=clz,
+                type_hint_globals=self.type_hint_globals,
+                lineno=node.lineno,
+                decorator_list=node.decorator_list,
             )
         else:
             if node.name.startswith("_") and node.name != "__call__":

reflex/utils/redir.py

@@ -5,6 +5,8 @@ import webbrowser
 
 import httpx
 
+from reflex.utils import net
+
 from .. import constants
 from . import console
 
@@ -38,7 +40,7 @@ def open_browser_and_wait(
     console.info("[b]Complete the workflow in the browser to continue.[/b]")
     while True:
         try:
-            response = httpx.get(poll_url, follow_redirects=True)
+            response = net.get(poll_url, follow_redirects=True)
             if response.is_success:
                 break
         except httpx.RequestError as err: