reflex 0.7.0a4__py3-none-any.whl → 0.7.1__py3-none-any.whl

reflex/utils/exec.py

@@ -10,6 +10,7 @@ import re
 import subprocess
 import sys
 from pathlib import Path
+from typing import Sequence
 from urllib.parse import urljoin
 
 import psutil
@@ -242,29 +243,63 @@ def run_backend(
         run_uvicorn_backend(host, port, loglevel)
 
 
-def get_reload_dirs() -> list[Path]:
-    """Get the reload directories for the backend.
+def get_reload_paths() -> Sequence[Path]:
+    """Get the reload paths for the backend.
 
     Returns:
-        The reload directories for the backend.
+        The reload paths for the backend.
     """
     config = get_config()
-    reload_dirs = [Path(config.app_name)]
+    reload_paths = [Path(config.app_name).parent]
     if config.app_module is not None and config.app_module.__file__:
         module_path = Path(config.app_module.__file__).resolve().parent
 
-        while module_path.parent.name:
-            if any(
-                sibling_file.name == "__init__.py"
-                for sibling_file in module_path.parent.iterdir()
-            ):
-                # go up a level to find dir without `__init__.py`
-                module_path = module_path.parent
-            else:
-                break
+        while module_path.parent.name and any(
+            sibling_file.name == "__init__.py"
+            for sibling_file in module_path.parent.iterdir()
+        ):
+            # go up a level to find dir without `__init__.py`
+            module_path = module_path.parent
 
-        reload_dirs = [module_path]
-    return reload_dirs
+        reload_paths = [module_path]
+
+    include_dirs = tuple(
+        map(Path.absolute, environment.REFLEX_HOT_RELOAD_INCLUDE_PATHS.get())
+    )
+    exclude_dirs = tuple(
+        map(Path.absolute, environment.REFLEX_HOT_RELOAD_EXCLUDE_PATHS.get())
+    )
+
+    def is_excluded_by_default(path: Path) -> bool:
+        if path.is_dir():
+            if path.name.startswith("."):
+                # exclude hidden directories
+                return True
+            if path.name.startswith("__"):
+                # ignore things like __pycache__
+                return True
+        return path.name in (".gitignore", "uploaded_files")
+
+    reload_paths = (
+        tuple(
+            path.absolute()
+            for dir in reload_paths
+            for path in dir.iterdir()
+            if not is_excluded_by_default(path)
+        )
+        + include_dirs
+    )
+
+    if exclude_dirs:
+        reload_paths = tuple(
+            path
+            for path in reload_paths
+            if all(not path.samefile(exclude) for exclude in exclude_dirs)
+        )
+
+    console.debug(f"Reload paths: {list(map(str, reload_paths))}")
+
+    return reload_paths
 
 
 def run_uvicorn_backend(host: str, port: int, loglevel: LogLevel):
@@ -283,7 +318,7 @@ def run_uvicorn_backend(host: str, port: int, loglevel: LogLevel):
         port=port,
         log_level=loglevel.value,
         reload=True,
-        reload_dirs=list(map(str, get_reload_dirs())),
+        reload_dirs=list(map(str, get_reload_paths())),
     )
 
 
@@ -310,8 +345,7 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
             interface=Interfaces.ASGI,
             log_level=LogLevels(loglevel.value),
             reload=True,
-            reload_paths=get_reload_dirs(),
-            reload_ignore_dirs=[".web", ".states"],
+            reload_paths=get_reload_paths(),
         ).serve()
     except ImportError:
         console.error(
@@ -368,34 +402,49 @@ def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
 
     app_module = get_app_module()
 
-    run_backend_prod = f"gunicorn --worker-class {config.gunicorn_worker_class} --max-requests {config.gunicorn_max_requests} --max-requests-jitter {config.gunicorn_max_requests_jitter} --preload --timeout {config.timeout} --log-level critical".split()
-    run_backend_prod_windows = f"uvicorn --limit-max-requests {config.gunicorn_max_requests} --timeout-keep-alive {config.timeout}".split()
     command = (
         [
-            *run_backend_prod_windows,
-            "--host",
-            host,
-            "--port",
-            str(port),
+            "uvicorn",
+            *(
+                [
+                    "--limit-max-requests",
+                    str(config.gunicorn_max_requests),
+                ]
+                if config.gunicorn_max_requests > 0
+                else []
+            ),
+            *("--timeout-keep-alive", str(config.timeout)),
+            *("--host", host),
+            *("--port", str(port)),
+            *("--workers", str(_get_backend_workers())),
             app_module,
         ]
         if constants.IS_WINDOWS
         else [
-            *run_backend_prod,
-            "--bind",
-            f"{host}:{port}",
-            "--threads",
-            str(_get_backend_workers()),
+            "gunicorn",
+            *("--worker-class", config.gunicorn_worker_class),
+            *(
+                [
+                    "--max-requests",
+                    str(config.gunicorn_max_requests),
+                    "--max-requests-jitter",
+                    str(config.gunicorn_max_requests_jitter),
+                ]
+                if config.gunicorn_max_requests > 0
+                else []
+            ),
+            "--preload",
+            *("--timeout", str(config.timeout)),
+            *("--bind", f"{host}:{port}"),
+            *("--threads", str(_get_backend_workers())),
             f"{app_module}()",
         ]
     )
 
     command += [
-        "--log-level",
-        loglevel.value,
-        "--workers",
-        str(_get_backend_workers()),
+        *("--log-level", loglevel.value),
     ]
+
     processes.new_process(
         command,
         run=True,
@@ -535,3 +584,12 @@ def is_prod_mode() -> bool:
     """
     current_mode = environment.REFLEX_ENV_MODE.get()
     return current_mode == constants.Env.PROD
+
+
+def get_compile_context() -> constants.CompileContext:
+    """Check if the app is compiled for deploy.
+
+    Returns:
+        Whether the app is being compiled for deploy.
+    """
+    return environment.REFLEX_COMPILE_CONTEXT.get()

reflex/utils/format.py

@@ -27,6 +27,36 @@ WRAP_MAP = {
 }
 
 
+def length_of_largest_common_substring(str1: str, str2: str) -> int:
+    """Find the length of the largest common substring between two strings.
+
+    Args:
+        str1: The first string.
+        str2: The second string.
+
+    Returns:
+        The length of the largest common substring.
+    """
+    if not str1 or not str2:
+        return 0
+
+    # Create a matrix of size (len(str1) + 1) x (len(str2) + 1)
+    dp = [[0] * (len(str2) + 1) for _ in range(len(str1) + 1)]
+
+    # Variables to keep track of maximum length and ending position
+    max_length = 0
+
+    # Fill the dp matrix
+    for i in range(1, len(str1) + 1):
+        for j in range(1, len(str2) + 1):
+            if str1[i - 1] == str2[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1] + 1
+                if dp[i][j] > max_length:
+                    max_length = dp[i][j]
+
+    return max_length
+
+
 def get_close_char(open: str, close: str | None = None) -> str:
     """Check if the given character is a valid brace.
 
@@ -138,7 +168,7 @@ def to_snake_case(text: str) -> str:
     return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower().replace("-", "_")
 
 
-def to_camel_case(text: str, allow_hyphens: bool = False) -> str:
+def to_camel_case(text: str, treat_hyphens_as_underscores: bool = True) -> str:
     """Convert a string to camel case.
 
     The first word in the text is converted to lowercase and
@@ -146,17 +176,16 @@ def to_camel_case(text: str, allow_hyphens: bool = False) -> str:
 
     Args:
         text: The string to convert.
-        allow_hyphens: Whether to allow hyphens in the string.
+        treat_hyphens_as_underscores: Whether to allow hyphens in the string.
 
     Returns:
         The camel case string.
     """
-    char = "_" if allow_hyphens else "-_"
-    words = re.split(f"[{char}]", text.lstrip(char))
-    leading_underscores_or_hyphens = "".join(re.findall(rf"^[{char}]+", text))
+    char = "_" if not treat_hyphens_as_underscores else "-_"
+    words = re.split(f"[{char}]", text)
     # Capitalize the first letter of each word except the first one
     converted_word = words[0] + "".join(x.capitalize() for x in words[1:])
-    return leading_underscores_or_hyphens + converted_word
+    return converted_word
 
 
 def to_title_case(text: str, sep: str = "") -> str:

reflex/utils/path_ops.py

@@ -6,6 +6,7 @@ import json
 import os
 import re
 import shutil
+import stat
 from pathlib import Path
 
 from reflex import constants
@@ -15,6 +16,19 @@ from reflex.config import environment, get_config
 join = os.linesep.join
 
 
+def chmod_rm(path: Path):
+    """Remove a file or directory with chmod.
+
+    Args:
+        path: The path to the file or directory.
+    """
+    path.chmod(stat.S_IWRITE)
+    if path.is_dir():
+        shutil.rmtree(path)
+    elif path.is_file():
+        path.unlink()
+
+
 def rm(path: str | Path):
     """Remove a file or directory.
 
@@ -23,7 +37,8 @@ def rm(path: str | Path):
     """
     path = Path(path)
     if path.is_dir():
-        shutil.rmtree(path)
+        # In Python 3.12, onerror is deprecated in favor of onexc
+        shutil.rmtree(path, onerror=lambda _func, _path, _info: chmod_rm(path))
     elif path.is_file():
         path.unlink()
 
@@ -247,6 +262,22 @@ def find_replace(directory: str | Path, find: str, replace: str):
             filepath.write_text(text, encoding="utf-8")
 
 
+def samefile(file1: Path, file2: Path) -> bool:
+    """Check if two files are the same.
+
+    Args:
+        file1: The first file.
+        file2: The second file.
+
+    Returns:
+        Whether the files are the same. If either file does not exist, returns False.
+    """
+    if file1.exists() and file2.exists():
+        return file1.samefile(file2)
+
+    return False
+
+
 def update_directory_tree(src: Path, dest: Path):
     """Recursively copies a directory tree from src to dest.
     Only copies files if the destination file is missing or modified earlier than the source file.

reflex/utils/prerequisites.py

@@ -23,7 +23,8 @@ import zipfile
 from datetime import datetime
 from pathlib import Path
 from types import ModuleType
-from typing import Any, Callable, List, NamedTuple, Optional
+from typing import Callable, List, NamedTuple, Optional
+from urllib.parse import urlparse
 
 import httpx
 import typer
@@ -98,6 +99,15 @@ def get_states_dir() -> Path:
     return environment.REFLEX_STATES_WORKDIR.get()
 
 
+def get_backend_dir() -> Path:
+    """Get the working directory for the backend.
+
+    Returns:
+        The working directory.
+    """
+    return get_web_dir() / constants.Dirs.BACKEND
+
+
 def check_latest_package_version(package_name: str):
     """Check if the latest version of the package is installed.
 
@@ -836,6 +846,7 @@ def _compile_package_json():
         },
         dependencies=constants.PackageJson.DEPENDENCIES,
         dev_dependencies=constants.PackageJson.DEV_DEPENDENCIES,
+        overrides=constants.PackageJson.OVERRIDES,
     )
 
 
@@ -1225,6 +1236,21 @@ def install_frontend_packages(packages: set[str], config: Config):
         )
 
 
+def check_running_mode(frontend: bool, backend: bool) -> tuple[bool, bool]:
+    """Check if the app is running in frontend or backend mode.
+
+    Args:
+        frontend: Whether to run the frontend of the app.
+        backend: Whether to run the backend of the app.
+
+    Returns:
+        The running modes.
+    """
+    if not frontend and not backend:
+        return True, True
+    return frontend, backend
+
+
 def needs_reinit(frontend: bool = True) -> bool:
     """Check if an app needs to be reinitialized.
 
@@ -1293,10 +1319,13 @@ def validate_bun():
     """
     bun_path = path_ops.get_bun_path()
 
-    if bun_path and not bun_path.samefile(constants.Bun.DEFAULT_PATH):
+    if bun_path is None:
+        return
+
+    if not path_ops.samefile(bun_path, constants.Bun.DEFAULT_PATH):
         console.info(f"Using custom Bun path: {bun_path}")
         bun_version = get_bun_version()
-        if not bun_version:
+        if bun_version is None:
             console.error(
                 "Failed to obtain bun version. Make sure the specified bun path in your config is correct."
             )
@@ -1661,9 +1690,11 @@ def validate_and_create_app_using_remote_template(
 
         template_url = templates[template].code_url
     else:
+        template_parsed_url = urlparse(template)
         # Check if the template is a github repo.
-        if template.startswith("https://github.com"):
-            template_url = f"{template.strip('/').replace('.git', '')}/archive/main.zip"
+        if template_parsed_url.hostname == "github.com":
+            path = template_parsed_url.path.strip("/").removesuffix(".git")
+            template_url = f"https://github.com/{path}/archive/main.zip"
         else:
             console.error(f"Template `{template}` not found or invalid.")
             raise typer.Exit(1)
@@ -1980,38 +2011,17 @@ def is_generation_hash(template: str) -> bool:
     return re.match(r"^[0-9a-f]{32,}$", template) is not None
 
 
-def check_config_option_in_tier(
-    option_name: str,
-    allowed_tiers: list[str],
-    fallback_value: Any,
-    help_link: str | None = None,
-):
-    """Check if a config option is allowed for the authenticated user's current tier.
+def get_user_tier():
+    """Get the current user's tier.
 
-    Args:
-        option_name: The name of the option to check.
-        allowed_tiers: The tiers that are allowed to use the option.
-        fallback_value: The fallback value if the option is not allowed.
-        help_link: The help link to show to a user that is authenticated.
+    Returns:
+        The current user's tier.
     """
     from reflex_cli.v2.utils import hosting
 
-    config = get_config()
     authenticated_token = hosting.authenticated_token()
-    if not authenticated_token[0]:
-        the_remedy = (
-            "You are currently logged out. Run `reflex login` to access this option."
-        )
-        current_tier = "anonymous"
-    else:
-        current_tier = authenticated_token[1].get("tier", "").lower()
-        the_remedy = (
-            f"Your current subscription tier is `{current_tier}`. "
-            f"Please upgrade to {allowed_tiers} to access this option. "
-        )
-        if help_link:
-            the_remedy += f"See {help_link} for more information."
-    if current_tier not in allowed_tiers:
-        console.warn(f"Config option `{option_name}` is restricted. {the_remedy}")
-        setattr(config, option_name, fallback_value)
-        config._set_persistent(**{option_name: fallback_value})
+    return (
+        authenticated_token[1].get("tier", "").lower()
+        if authenticated_token[0]
+        else "anonymous"
+    )

reflex/utils/processes.py

@@ -116,17 +116,14 @@ def change_port(port: int, _type: str) -> int:
     return new_port
 
 
-def handle_port(service_name: str, port: int, default_port: int) -> int:
+def handle_port(service_name: str, port: int, auto_increment: bool) -> int:
     """Change port if the specified port is in use and is not explicitly specified as a CLI arg or config arg.
-    otherwise tell the user the port is in use and exit the app.
-
-    We make an assumption that when port is the default port,then it hasn't been explicitly set since its not straightforward
-    to know whether a port was explicitly provided by the user unless its any other than the default.
+    Otherwise tell the user the port is in use and exit the app.
 
     Args:
         service_name: The frontend or backend.
         port: The provided port.
-        default_port: The default port number associated with the specified service.
+        auto_increment: Whether to automatically increment the port.
 
     Returns:
         The port to run the service on.
@@ -134,13 +131,15 @@ def handle_port(service_name: str, port: int, default_port: int) -> int:
     Raises:
         Exit:when the port is in use.
     """
-    if is_process_on_port(port):
-        if port == int(default_port):
-            return change_port(port, service_name)
-        else:
-            console.error(f"{service_name.capitalize()} port: {port} is already in use")
-            raise typer.Exit()
-    return port
+    if (process := get_process_on_port(port)) is None:
+        return port
+    if auto_increment:
+        return change_port(port, service_name)
+    else:
+        console.error(
+            f"{service_name.capitalize()} port: {port} is already in use by PID: {process.pid}."
+        )
+        raise typer.Exit()
 
 
 def new_process(

reflex/utils/serializers.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import dataclasses
 import functools
 import json
@@ -24,6 +25,9 @@ from typing import (
     overload,
 )
 
+from pydantic import BaseModel as BaseModelV2
+from pydantic.v1 import BaseModel as BaseModelV1
+
 from reflex.base import Base
 from reflex.constants.colors import Color, format_color
 from reflex.utils import types
@@ -270,43 +274,24 @@ def serialize_base(value: Base) -> dict:
     }
 
 
-try:
-    from pydantic.v1 import BaseModel as BaseModelV1
-
-    @serializer(to=dict)
-    def serialize_base_model_v1(model: BaseModelV1) -> dict:
-        """Serialize a pydantic v1 BaseModel instance.
-
-        Args:
-            model: The BaseModel to serialize.
-
-        Returns:
-            The serialized BaseModel.
-        """
-        return model.dict()
-
-    from pydantic import BaseModel as BaseModelV2
+@serializer(to=dict)
+def serialize_base_model_v1(model: BaseModelV1) -> dict:
+    """Serialize a pydantic v1 BaseModel instance.
 
-    if BaseModelV1 is not BaseModelV2:
+    Args:
+        model: The BaseModel to serialize.
 
-        @serializer(to=dict)
-        def serialize_base_model_v2(model: BaseModelV2) -> dict:
-            """Serialize a pydantic v2 BaseModel instance.
+    Returns:
+        The serialized BaseModel.
+    """
+    return model.dict()
 
-            Args:
-                model: The BaseModel to serialize.
 
-            Returns:
-                The serialized BaseModel.
-            """
-            return model.model_dump()
-except ImportError:
-    # Older pydantic v1 import
-    from pydantic import BaseModel as BaseModelV1
+if BaseModelV1 is not BaseModelV2:
 
     @serializer(to=dict)
-    def serialize_base_model_v1(model: BaseModelV1) -> dict:
-        """Serialize a pydantic v1 BaseModel instance.
+    def serialize_base_model_v2(model: BaseModelV2) -> dict:
+        """Serialize a pydantic v2 BaseModel instance.
 
         Args:
             model: The BaseModel to serialize.
@@ -314,7 +299,7 @@ except ImportError:
         Returns:
             The serialized BaseModel.
         """
-        return model.dict()
+        return model.model_dump()
 
 
 @serializer
@@ -382,7 +367,7 @@ def serialize_color(color: Color) -> str:
     return format_color(color.color, color.shade, color.alpha)
 
 
-try:
+with contextlib.suppress(ImportError):
     from pandas import DataFrame
 
     def format_dataframe_values(df: DataFrame) -> List[List[Any]]:
@@ -414,10 +399,8 @@ try:
             "data": format_dataframe_values(df),
         }
 
-except ImportError:
-    pass
 
-try:
+with contextlib.suppress(ImportError):
     from plotly.graph_objects import Figure, layout
     from plotly.io import to_json
 
@@ -448,11 +431,8 @@ try:
             "layout": json.loads(str(to_json(template.layout))),
         }
 
-except ImportError:
-    pass
 
-
-try:
+with contextlib.suppress(ImportError):
     import base64
     import io
 
@@ -489,6 +469,3 @@ try:
                 mime_type = "image/png"
 
         return f"data:{mime_type};base64,{base64_image}"
-
-except ImportError:
-    pass

reflex/utils/telemetry.py

@@ -8,23 +8,17 @@ import multiprocessing
 import platform
 import warnings
 from contextlib import suppress
-
-from reflex.config import environment
-
-try:
-    from datetime import UTC, datetime
-except ImportError:
-    from datetime import datetime
-
-    UTC = None
+from datetime import datetime, timezone
 
 import httpx
 import psutil
 
 from reflex import constants
+from reflex.config import environment
 from reflex.utils import console
 from reflex.utils.prerequisites import ensure_reflex_installation_id, get_project_hash
 
+UTC = timezone.utc
 POSTHOG_API_URL: str = "https://app.posthog.com/capture/"
 
 
@@ -121,12 +115,7 @@ def _prepare_event(event: str, **kwargs) -> dict:
         )
         return {}
 
-    if UTC is None:
-        # for python 3.10
-        stamp = datetime.utcnow().isoformat()
-    else:
-        # for python 3.11 & 3.12
-        stamp = datetime.now(UTC).isoformat()
+    stamp = datetime.now(UTC).isoformat()
 
     cpuinfo = get_cpu_info()