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

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

@@ -24,6 +24,7 @@ from datetime import datetime
 from pathlib import Path
 from types import ModuleType
 from typing import Any, 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.
 
@@ -1225,6 +1235,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 +1318,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 +1689,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,6 +2010,22 @@ def is_generation_hash(template: str) -> bool:
     return re.match(r"^[0-9a-f]{32,}$", template) is not None
 
 
+def get_user_tier():
+    """Get the current user's tier.
+
+    Returns:
+        The current user's tier.
+    """
+    from reflex_cli.v2.utils import hosting
+
+    authenticated_token = hosting.authenticated_token()
+    return (
+        authenticated_token[1].get("tier", "").lower()
+        if authenticated_token[0]
+        else "anonymous"
+    )
+
+
 def check_config_option_in_tier(
     option_name: str,
     allowed_tiers: list[str],
@@ -1994,23 +2040,21 @@ def check_config_option_in_tier(
         fallback_value: The fallback value if the option is not allowed.
         help_link: The help link to show to a user that is authenticated.
     """
-    from reflex_cli.v2.utils import hosting
-
     config = get_config()
-    authenticated_token = hosting.authenticated_token()
-    if not authenticated_token[0]:
+    current_tier = get_user_tier()
+
+    if current_tier == "anonymous":
         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)

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()
 

reflex/utils/types.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-import contextlib
 import dataclasses
 import inspect
 import sys
 import types
 from functools import cached_property, lru_cache, wraps
+from types import GenericAlias
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -25,66 +25,29 @@ from typing import (
     Type,
     Union,
     _GenericAlias,  # pyright: ignore [reportAttributeAccessIssue]
+    _SpecialGenericAlias,  # pyright: ignore [reportAttributeAccessIssue]
     get_args,
     get_type_hints,
 )
 from typing import get_origin as get_origin_og
 
 import sqlalchemy
-from typing_extensions import is_typeddict
-
-import reflex
-from reflex.components.core.breakpoints import Breakpoints
-
-try:
-    from pydantic.v1.fields import ModelField
-except ModuleNotFoundError:
-    from pydantic.fields import (
-        ModelField,  # pyright: ignore [reportAttributeAccessIssue]
-    )
-
+from pydantic.v1.fields import ModelField
 from sqlalchemy.ext.associationproxy import AssociationProxyInstance
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import DeclarativeBase, Mapped, QueryableAttribute, Relationship
+from typing_extensions import Self as Self
+from typing_extensions import is_typeddict
+from typing_extensions import override as override
 
+import reflex
 from reflex import constants
 from reflex.base import Base
+from reflex.components.core.breakpoints import Breakpoints
 from reflex.utils import console
 
-if sys.version_info >= (3, 12):
-    from typing import override as override
-else:
-
-    def override(func: Callable) -> Callable:
-        """Fallback for @override decorator.
-
-        Args:
-            func: The function to decorate.
-
-        Returns:
-            The unmodified function.
-        """
-        return func
-
-
 # Potential GenericAlias types for isinstance checks.
-GenericAliasTypes = [_GenericAlias]
-
-with contextlib.suppress(ImportError):
-    # For newer versions of Python.
-    from types import GenericAlias
-
-    GenericAliasTypes.append(GenericAlias)
-
-with contextlib.suppress(ImportError):
-    # For older versions of Python.
-    from typing import (
-        _SpecialGenericAlias,  # pyright: ignore [reportAttributeAccessIssue]
-    )
-
-    GenericAliasTypes.append(_SpecialGenericAlias)
-
-GenericAliasTypes = tuple(GenericAliasTypes)
+GenericAliasTypes = (_GenericAlias, GenericAlias, _SpecialGenericAlias)
 
 # Potential Union types for isinstance checks (UnionType added in py3.10).
 UnionTypes = (Union, types.UnionType) if hasattr(types, "UnionType") else (Union,)
@@ -95,6 +58,7 @@ GenericType = Union[Type, _GenericAlias]
 # Valid state var types.
 JSONType = {str, int, float, bool}
 PrimitiveType = Union[int, float, bool, str, list, dict, set, tuple]
+PrimitiveTypes = (int, float, bool, str, list, dict, set, tuple)
 StateVar = Union[PrimitiveType, Base, None]
 StateIterVar = Union[list, set, tuple]
 
@@ -127,11 +91,6 @@ RESERVED_BACKEND_VAR_NAMES = {
     "_was_touched",
 }
 
-if sys.version_info >= (3, 11):
-    from typing import Self as Self
-else:
-    from typing_extensions import Self as Self
-
 
 class Unset:
     """A class to represent an unset value.
@@ -551,13 +510,13 @@ def does_obj_satisfy_typed_dict(obj: Any, cls: GenericType) -> bool:
     return required_keys.issubset(required_keys)
 
 
-def _isinstance(obj: Any, cls: GenericType, nested: bool = False) -> bool:
+def _isinstance(obj: Any, cls: GenericType, nested: int = 0) -> bool:
     """Check if an object is an instance of a class.
 
     Args:
         obj: The object to check.
         cls: The class to check against.
-        nested: Whether the check is nested.
+        nested: How many levels deep to check.
 
     Returns:
         Whether the object is an instance of the class.
@@ -565,15 +524,24 @@ def _isinstance(obj: Any, cls: GenericType, nested: bool = False) -> bool:
     if cls is Any:
         return True
 
+    from reflex.vars import LiteralVar, Var
+
+    if cls is Var:
+        return isinstance(obj, Var)
+    if isinstance(obj, LiteralVar):
+        return _isinstance(obj._var_value, cls, nested=nested)
+    if isinstance(obj, Var):
+        return _issubclass(obj._var_type, cls)
+
     if cls is None or cls is type(None):
         return obj is None
 
+    if cls and is_union(cls):
+        return any(_isinstance(obj, arg, nested=nested) for arg in get_args(cls))
+
     if is_literal(cls):
         return obj in get_args(cls)
 
-    if is_union(cls):
-        return any(_isinstance(obj, arg) for arg in get_args(cls))
-
     origin = get_origin(cls)
 
     if origin is None:
@@ -596,38 +564,40 @@ def _isinstance(obj: Any, cls: GenericType, nested: bool = False) -> bool:
         # cls is a simple generic class
         return isinstance(obj, origin)
 
-    if nested and args:
+    if nested > 0 and args:
         if origin is list:
             return isinstance(obj, list) and all(
-                _isinstance(item, args[0]) for item in obj
+                _isinstance(item, args[0], nested=nested - 1) for item in obj
             )
         if origin is tuple:
             if args[-1] is Ellipsis:
                 return isinstance(obj, tuple) and all(
-                    _isinstance(item, args[0]) for item in obj
+                    _isinstance(item, args[0], nested=nested - 1) for item in obj
                 )
             return (
                 isinstance(obj, tuple)
                 and len(obj) == len(args)
                 and all(
-                    _isinstance(item, arg) for item, arg in zip(obj, args, strict=True)
+                    _isinstance(item, arg, nested=nested - 1)
+                    for item, arg in zip(obj, args, strict=True)
                 )
             )
-        if origin in (dict, Breakpoints):
-            return isinstance(obj, dict) and all(
-                _isinstance(key, args[0]) and _isinstance(value, args[1])
+        if origin in (dict, Mapping, Breakpoints):
+            return isinstance(obj, Mapping) and all(
+                _isinstance(key, args[0], nested=nested - 1)
+                and _isinstance(value, args[1], nested=nested - 1)
                 for key, value in obj.items()
             )
         if origin is set:
             return isinstance(obj, set) and all(
-                _isinstance(item, args[0]) for item in obj
+                _isinstance(item, args[0], nested=nested - 1) for item in obj
             )
 
     if args:
         from reflex.vars import Field
 
         if origin is Field:
-            return _isinstance(obj, args[0])
+            return _isinstance(obj, args[0], nested=nested)
 
     return isinstance(obj, get_base_class(cls))
 
@@ -749,7 +719,7 @@ def check_prop_in_allowed_types(prop: Any, allowed_types: Iterable) -> bool:
     """
     from reflex.vars import Var
 
-    type_ = prop._var_type if _isinstance(prop, Var) else type(prop)
+    type_ = prop._var_type if isinstance(prop, Var) else type(prop)
     return type_ in allowed_types