reflex 0.5.10a2__py3-none-any.whl → 0.6.0__py3-none-any.whl

reflex/utils/format.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
 
 from reflex import constants
 from reflex.utils import exceptions, types
-from reflex.vars import BaseVar, Var
+from reflex.utils.console import deprecate
 
 if TYPE_CHECKING:
     from reflex.components.component import ComponentStyle
@@ -263,32 +263,6 @@ def format_string(string: str) -> str:
     return _wrap_js_string(_escape_js_string(string))
 
 
-def format_f_string_prop(prop: BaseVar) -> str:
-    """Format the string in a given prop as an f-string.
-
-    Args:
-        prop: The prop to format.
-
-    Returns:
-        The formatted string.
-    """
-    s = prop._var_full_name
-    var_data = prop._var_data
-    interps = var_data.interpolations if var_data else []
-    parts: List[str] = []
-
-    if interps:
-        for i, (start, end) in enumerate(interps):
-            prev_end = interps[i - 1][1] if i > 0 else 0
-            parts.append(_escape_js_string(s[prev_end:start]))
-            parts.append(s[start:end])
-        parts.append(_escape_js_string(s[interps[-1][1] :]))
-    else:
-        parts.append(_escape_js_string(s))
-
-    return _wrap_js_string("".join(parts))
-
-
 def format_var(var: Var) -> str:
     """Format the given Var as a javascript value.
 
@@ -298,13 +272,7 @@ def format_var(var: Var) -> str:
     Returns:
         The formatted Var.
     """
-    if not var._var_is_local or var._var_is_string:
-        return str(var)
-    if types._issubclass(var._var_type, str):
-        return format_string(var._var_full_name)
-    if is_wrapped(var._var_full_name, "{"):
-        return var._var_full_name
-    return json_dumps(var._var_full_name)
+    return str(var)
 
 
 def format_route(route: str, format_case=True) -> str:
@@ -329,46 +297,11 @@ def format_route(route: str, format_case=True) -> str:
     return route
 
 
-def format_cond(
+def format_match(
     cond: str | Var,
-    true_value: str | Var,
-    false_value: str | Var = '""',
-    is_prop=False,
+    match_cases: List[List[Var]],
+    default: Var,
 ) -> str:
-    """Format a conditional expression.
-
-    Args:
-        cond: The cond.
-        true_value: The value to return if the cond is true.
-        false_value: The value to return if the cond is false.
-        is_prop: Whether the cond is a prop
-
-    Returns:
-        The formatted conditional expression.
-    """
-    # Use Python truthiness.
-    cond = f"isTrue({cond})"
-
-    def create_var(cond_part):
-        return Var.create_safe(cond_part, _var_is_string=isinstance(cond_part, str))
-
-    # Format prop conds.
-    if is_prop:
-        true_value = create_var(true_value)
-        prop1 = true_value._replace(
-            _var_is_local=True,
-        )
-
-        false_value = create_var(false_value)
-        prop2 = false_value._replace(_var_is_local=True)
-        # unwrap '{}' to avoid f-string semantics for Var
-        return f"{cond} ? {prop1._var_name_unwrapped} : {prop2._var_name_unwrapped}"
-
-    # Format component conds.
-    return wrap(f"{cond} ? {true_value} : {false_value}", "{")
-
-
-def format_match(cond: str | Var, match_cases: List[BaseVar], default: Var) -> str:
     """Format a match expression whose return type is a Var.
 
     Args:
@@ -387,17 +320,12 @@ def format_match(cond: str | Var, match_cases: List[BaseVar], default: Var) -> s
         return_value = case[-1]
 
         case_conditions = " ".join(
-            [
-                f"case JSON.stringify({condition._var_name_unwrapped}):"
-                for condition in conditions
-            ]
-        )
-        case_code = (
-            f"{case_conditions}  return ({return_value._var_name_unwrapped});  break;"
+            [f"case JSON.stringify({str(condition)}):" for condition in conditions]
         )
+        case_code = f"{case_conditions}  return ({str(return_value)});  break;"
         switch_code += case_code
 
-    switch_code += f"default:  return ({default._var_name_unwrapped});  break;"
+    switch_code += f"default:  return ({str(default)});  break;"
     switch_code += "};})()"
 
     return switch_code
@@ -421,20 +349,15 @@ def format_prop(
     # import here to avoid circular import.
     from reflex.event import EventChain
     from reflex.utils import serializers
+    from reflex.vars import Var
 
     try:
         # Handle var props.
         if isinstance(prop, Var):
-            if not prop._var_is_local or prop._var_is_string:
-                return str(prop)
-            if isinstance(prop, BaseVar) and types._issubclass(prop._var_type, str):
-                if prop._var_data and prop._var_data.interpolations:
-                    return format_f_string_prop(prop)
-                return format_string(prop._var_full_name)
-            prop = prop._var_full_name
+            return str(prop)
 
         # Handle event props.
-        elif isinstance(prop, EventChain):
+        if isinstance(prop, EventChain):
             sig = inspect.signature(prop.args_spec)  # type: ignore
             if sig.parameters:
                 arg_def = ",".join(f"_{p}" for p in sig.parameters)
@@ -483,11 +406,15 @@ def format_props(*single_props, **key_value_props) -> list[str]:
         The formatted props list.
     """
     # Format all the props.
+    from reflex.vars.base import LiteralVar, Var
+
     return [
-        f"{name}={format_prop(prop)}"
+        (
+            f"{name}={{{format_prop(prop if isinstance(prop, Var) else LiteralVar.create(prop))}}}"
+        )
         for name, prop in sorted(key_value_props.items())
         if prop is not None
-    ] + [str(prop) for prop in single_props]
+    ] + [(f"{str(LiteralVar.create(prop))}") for prop in single_props]
 
 
 def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
@@ -502,13 +429,13 @@ def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
     # Get the class that defines the event handler.
     parts = handler.fn.__qualname__.split(".")
 
-    # If there's no enclosing class, just return the function name.
-    if len(parts) == 1:
-        return ("", parts[-1])
-
     # Get the state full name
     state_full_name = handler.state_full_name
 
+    # If there's no enclosing class, just return the function name.
+    if not state_full_name:
+        return ("", parts[-1])
+
     # Get the function name
     name = parts[-1]
 
@@ -548,14 +475,14 @@ def format_event(event_spec: EventSpec) -> str:
         [
             ":".join(
                 (
-                    name._var_name,
+                    name._js_expr,
                     (
                         wrap(
-                            json.dumps(val._var_name).strip('"').replace("`", "\\`"),
+                            json.dumps(val._js_expr).strip('"').replace("`", "\\`"),
                             "`",
                         )
                         if val._var_is_string
-                        else val._var_full_name
+                        else str(val)
                     ),
                 )
             )
@@ -572,52 +499,49 @@ def format_event(event_spec: EventSpec) -> str:
     return f"Event({', '.join(event_args)})"
 
 
+if TYPE_CHECKING:
+    from reflex.vars import Var
+
+
 def format_event_chain(
     event_chain: EventChain | Var[EventChain],
     event_arg: Var | None = None,
 ) -> str:
-    """Format an event chain as a javascript invocation.
+    """DEPRECATED: format an event chain as a javascript invocation.
+
+    Use str(rx.Var.create(event_chain)) instead.
 
     Args:
-        event_chain: The event chain to queue on the frontend.
-        event_arg: The browser-native event (only used to preventDefault).
+        event_chain: The event chain to format.
+        event_arg: this argument is ignored.
 
     Returns:
         Compiled javascript code to queue the given event chain on the frontend.
+    """
+    deprecate(
+        feature_name="format_event_chain",
+        reason="Use str(rx.Var.create(event_chain)) instead",
+        deprecation_version="0.6.0",
+        removal_version="0.7.0",
+    )
 
-    Raises:
-        ValueError: When the given event chain is not a valid event chain.
-    """
-    if isinstance(event_chain, Var):
-        from reflex.event import EventChain
-
-        if event_chain._var_type is not EventChain:
-            raise ValueError(f"Invalid event chain: {event_chain}")
-        return "".join(
-            [
-                "(() => {",
-                format_var(event_chain),
-                f"; preventDefault({format_var(event_arg)})" if event_arg else "",
-                "})()",
-            ]
-        )
+    from reflex.vars import Var
+    from reflex.vars.function import ArgsFunctionOperation
 
-    chain = ",".join([format_event(event) for event in event_chain.events])
-    return "".join(
-        [
-            f"addEvents([{chain}]",
-            f", {format_var(event_arg)}" if event_arg else "",
-            ")",
-        ]
-    )
+    result = Var.create(event_chain)
+    if isinstance(result, ArgsFunctionOperation):
+        result = result._return_expr
+    return str(result)
 
 
 def format_queue_events(
-    events: EventSpec
-    | EventHandler
-    | Callable
-    | List[EventSpec | EventHandler | Callable]
-    | None = None,
+    events: (
+        EventSpec
+        | EventHandler
+        | Callable
+        | List[EventSpec | EventHandler | Callable]
+        | None
+    ) = None,
     args_spec: Optional[ArgsSpec] = None,
 ) -> Var[EventChain]:
     """Format a list of event handler / event spec as a javascript callback.
@@ -645,11 +569,10 @@ def format_queue_events(
         call_event_fn,
         call_event_handler,
     )
+    from reflex.vars import FunctionVar, Var
 
     if not events:
-        return Var.create_safe(
-            "() => null", _var_is_string=False, _var_is_local=False
-        ).to(EventChain)
+        return Var("(() => null)").to(FunctionVar, EventChain)  # type: ignore
 
     # If no spec is provided, the function will take no arguments.
     def _default_args_spec():
@@ -682,12 +605,10 @@ def format_queue_events(
 
     # Return the final code snippet, expecting queueEvents, processEvent, and socket to be in scope.
     # Typically this snippet will _only_ run from within an rx.call_script eval context.
-    return Var.create_safe(
+    return Var(
         f"{arg_def} => {{queueEvents([{','.join(payloads)}], {constants.CompileVars.SOCKET}); "
         f"processEvent({constants.CompileVars.SOCKET})}}",
-        _var_is_string=False,
-        _var_is_local=False,
-    ).to(EventChain)
+    ).to(FunctionVar, EventChain)  # type: ignore
 
 
 def format_query_params(router_data: dict[str, Any]) -> dict[str, str]:
@@ -774,41 +695,6 @@ def format_ref(ref: str) -> str:
     return f"ref_{clean_ref}"
 
 
-def format_array_ref(refs: str, idx: Var | None) -> str:
-    """Format a ref accessed by array.
-
-    Args:
-        refs : The ref array to access.
-        idx : The index of the ref in the array.
-
-    Returns:
-        The formatted ref.
-    """
-    clean_ref = re.sub(r"[^\w]+", "_", refs)
-    if idx is not None:
-        idx._var_is_local = True
-        return f"refs_{clean_ref}[{idx}]"
-    return f"refs_{clean_ref}"
-
-
-def format_breadcrumbs(route: str) -> list[tuple[str, str]]:
-    """Take a route and return a list of tuple for use in breadcrumb.
-
-    Args:
-        route: The route to transform.
-
-    Returns:
-        list[tuple[str, str]]: the list of tuples for the breadcrumb.
-    """
-    route_parts = route.lstrip("/").split("/")
-
-    # create and return breadcrumbs
-    return [
-        (part, "/".join(["", *route_parts[: i + 1]]))
-        for i, part in enumerate(route_parts)
-    ]
-
-
 def format_library_name(library_fullname: str):
     """Format the name of a library.
 
@@ -839,42 +725,6 @@ def json_dumps(obj: Any) -> str:
     return json.dumps(obj, ensure_ascii=False, default=serializers.serialize)
 
 
-def unwrap_vars(value: str) -> str:
-    """Unwrap var values from a JSON string.
-
-    For example, "{var}" will be unwrapped to "var".
-
-    Args:
-        value: The JSON string to unwrap.
-
-    Returns:
-        The unwrapped JSON string.
-    """
-
-    def unescape_double_quotes_in_var(m: re.Match) -> str:
-        prefix = m.group(1) or ""
-        # Since the outer quotes are removed, the inner escaped quotes must be unescaped.
-        return prefix + re.sub('\\\\"', '"', m.group(2))
-
-    # This substitution is necessary to unwrap var values.
-    return (
-        re.sub(
-            pattern=r"""
-            (?<!\\)      # must NOT start with a backslash
-            "            # match opening double quote of JSON value
-            (<reflex.Var>.*?</reflex.Var>)?  # Optional encoded VarData (non-greedy)
-            {(.*?)}      # extract the value between curly braces (non-greedy)
-            "            # match must end with an unescaped double quote
-        """,
-            repl=unescape_double_quotes_in_var,
-            string=value,
-            flags=re.VERBOSE,
-        )
-        .replace('"`', "`")
-        .replace('`"', "`")
-    )
-
-
 def collect_form_dict_names(form_dict: dict[str, Any]) -> dict[str, Any]:
     """Collapse keys with consecutive suffixes into a single list value.
 
@@ -897,6 +747,23 @@ def collect_form_dict_names(form_dict: dict[str, Any]) -> dict[str, Any]:
     return collapsed
 
 
+def format_array_ref(refs: str, idx: Var | None) -> str:
+    """Format a ref accessed by array.
+
+    Args:
+        refs : The ref array to access.
+        idx : The index of the ref in the array.
+
+    Returns:
+        The formatted ref.
+    """
+    clean_ref = re.sub(r"[^\w]+", "_", refs)
+    if idx is not None:
+        # idx._var_is_local = True
+        return f"refs_{clean_ref}[{str(idx)}]"
+    return f"refs_{clean_ref}"
+
+
 def format_data_editor_column(col: str | dict):
     """Format a given column into the proper format.
 
@@ -909,6 +776,8 @@ def format_data_editor_column(col: str | dict):
     Returns:
         The formatted column.
     """
+    from reflex.vars import Var
+
     if isinstance(col, str):
         return {"title": col, "id": col.lower(), "type": "str"}
 
@@ -921,7 +790,7 @@ def format_data_editor_column(col: str | dict):
             col["overlayIcon"] = None
         return col
 
-    if isinstance(col, BaseVar):
+    if isinstance(col, Var):
         return col
 
     raise ValueError(
@@ -938,7 +807,9 @@ def format_data_editor_cell(cell: Any):
     Returns:
         The formatted cell.
     """
+    from reflex.vars.base import Var
+
     return {
-        "kind": Var.create(value="GridCellKind.Text", _var_is_string=False),
+        "kind": Var(_js_expr="GridCellKind.Text"),
         "data": cell,
     }

reflex/utils/imports.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
+import dataclasses
 from collections import defaultdict
-from typing import Dict, List, Optional, Tuple, Union
-
-from reflex.base import Base
+from typing import DefaultDict, Dict, List, Optional, Tuple, Union
 
 
 def merge_imports(
@@ -19,12 +18,22 @@ def merge_imports(
     Returns:
         The merged import dicts.
     """
-    all_imports = defaultdict(list)
+    all_imports: DefaultDict[str, List[ImportVar]] = defaultdict(list)
     for import_dict in imports:
         for lib, fields in (
             import_dict if isinstance(import_dict, tuple) else import_dict.items()
         ):
-            all_imports[lib].extend(fields)
+            if isinstance(fields, (list, tuple, set)):
+                all_imports[lib].extend(
+                    (
+                        ImportVar(field) if isinstance(field, str) else field
+                        for field in fields
+                    )
+                )
+            else:
+                all_imports[lib].append(
+                    ImportVar(fields) if isinstance(fields, str) else fields
+                )
     return all_imports
 
 
@@ -75,7 +84,8 @@ def collapse_imports(
     }
 
 
-class ImportVar(Base):
+@dataclasses.dataclass(order=True, frozen=True)
+class ImportVar:
     """An import var."""
 
     # The name of the import tag.
@@ -111,73 +121,6 @@ class ImportVar(Base):
         else:
             return self.tag or ""
 
-    def __lt__(self, other: ImportVar) -> bool:
-        """Compare two ImportVar objects.
-
-        Args:
-            other: The other ImportVar object to compare.
-
-        Returns:
-            Whether this ImportVar object is less than the other.
-        """
-        return (
-            self.tag,
-            self.is_default,
-            self.alias,
-            self.install,
-            self.render,
-            self.transpile,
-        ) < (
-            other.tag,
-            other.is_default,
-            other.alias,
-            other.install,
-            other.render,
-            other.transpile,
-        )
-
-    def __eq__(self, other: ImportVar) -> bool:
-        """Check if two ImportVar objects are equal.
-
-        Args:
-            other: The other ImportVar object to compare.
-
-        Returns:
-            Whether the two ImportVar objects are equal.
-        """
-        return (
-            self.tag,
-            self.is_default,
-            self.alias,
-            self.install,
-            self.render,
-            self.transpile,
-        ) == (
-            other.tag,
-            other.is_default,
-            other.alias,
-            other.install,
-            other.render,
-            other.transpile,
-        )
-
-    def __hash__(self) -> int:
-        """Hash the ImportVar object.
-
-        Returns:
-            The hash of the ImportVar object.
-        """
-        return hash(
-            (
-                self.tag,
-                self.is_default,
-                self.alias,
-                self.install,
-                self.render,
-                self.transpile,
-            )
-        )
-
 
 ImportTypes = Union[str, ImportVar, List[Union[str, ImportVar]], List[ImportVar]]
 ImportDict = Dict[str, ImportTypes]

reflex/utils/net.py

@@ -0,0 +1,43 @@
+"""Helpers for downloading files from the network."""
+
+import os
+
+import httpx
+
+from . import console
+
+
+def _httpx_verify_kwarg() -> bool:
+    """Get the value of the HTTPX verify keyword argument.
+
+    Returns:
+        True if SSL verification is enabled, False otherwise
+    """
+    ssl_no_verify = os.environ.get("SSL_NO_VERIFY", "").lower() in ["true", "1", "yes"]
+    return not ssl_no_verify
+
+
+def get(url: str, **kwargs) -> httpx.Response:
+    """Make an HTTP GET request.
+
+    Args:
+        url: The URL to request.
+        **kwargs: Additional keyword arguments to pass to httpx.get.
+
+    Returns:
+        The response object.
+
+    Raises:
+        httpx.ConnectError: If the connection cannot be established.
+    """
+    kwargs.setdefault("verify", _httpx_verify_kwarg())
+    try:
+        return httpx.get(url, **kwargs)
+    except httpx.ConnectError as err:
+        if "CERTIFICATE_VERIFY_FAILED" in str(err):
+            # If the error is a certificate verification error, recommend mitigating steps.
+            console.error(
+                f"Certificate verification failed for {url}. Set environment variable SSL_CERT_FILE to the "
+                "path of the certificate file or SSL_NO_VERIFY=1 to disable verification."
+            )
+        raise

reflex/utils/path_ops.py

@@ -81,6 +81,18 @@ def mkdir(path: str | Path):
     Path(path).mkdir(parents=True, exist_ok=True)
 
 
+def ls(path: str | Path) -> list[Path]:
+    """List the contents of a directory.
+
+    Args:
+        path: The path to the directory.
+
+    Returns:
+        A list of paths to the contents of the directory.
+    """
+    return list(Path(path).iterdir())
+
+
 def ln(src: str | Path, dest: str | Path, overwrite: bool = False) -> bool:
     """Create a symbolic link.
 
@@ -197,4 +209,4 @@ def find_replace(directory: str | Path, find: str, replace: str):
             filepath = Path(root, file)
             text = filepath.read_text(encoding="utf-8")
             text = re.sub(find, replace, text)
-            filepath.write_text(text)
+            filepath.write_text(text, encoding="utf-8")