reflex 0.8.15a1__py3-none-any.whl → 0.8.16a1__py3-none-any.whl

reflex/utils/codespaces.py

@@ -26,11 +26,40 @@ def redirect_script() -> str:
 const thisUrl = new URL(window.location.href);
 const params = new URLSearchParams(thisUrl.search)
 
+function sameHostnameDifferentPort(one, two) {{
+    const hostnameOne = one.hostname;
+    const hostnameTwo = two.hostname;
+    const partsOne = hostnameOne.split(".");
+    const partsTwo = hostnameTwo.split(".");
+    if (partsOne.length !== partsTwo.length) {{ return false;  }}
+    for (let i = 1; i < partsOne.length; i++) {{
+        if (partsOne[i] !== partsTwo[i]) {{ return false; }}
+    }}
+    const uniqueNameOne = partsOne[0];
+    const uniqueNameTwo = partsTwo[0];
+    const uniqueNamePartsOne = uniqueNameOne.split("-");
+    const uniqueNamePartsTwo = uniqueNameTwo.split("-");
+    if (uniqueNamePartsOne.length !== uniqueNamePartsTwo.length) {{ return false;  }}
+    for (let i = 0; i < uniqueNamePartsOne.length - 1; i++) {{
+        if (uniqueNamePartsOne[i] !== uniqueNamePartsTwo[i]) {{ return false;  }}
+    }}
+    return true;
+}}
+
 function doRedirect(url) {{
     if (!window.sessionStorage.getItem("authenticated_github_codespaces")) {{
         const a = document.createElement("a");
         if (params.has("redirect_to")) {{
-            a.href = params.get("redirect_to")
+            const redirect_to = new URL(params.get("redirect_to"));
+            if (!sameHostnameDifferentPort(thisUrl, redirect_to)) {{
+                console.warn("Reflex: Not redirecting to different hostname");
+                return;
+            }}
+            if (!redirect_to.hostname.endsWith(".app.github.dev")) {{
+                console.warn("Reflex: Not redirecting to non .app.github.dev hostname");
+                return;
+            }}
+            a.href = redirect_to.href;
         }} else if (!window.location.href.startsWith(url)) {{
             a.href = url + `?redirect_to=${{window.location.href}}`
         }} else {{
@@ -75,7 +104,7 @@ def codespaces_auto_redirect() -> list[Component]:
     return []
 
 
-async def auth_codespace(_request: Request) -> HTMLResponse:
+def auth_codespace(_request: Request) -> HTMLResponse:
     """Page automatically redirecting back to the app after authenticating a codespace port forward.
 
     Args:

reflex/utils/compat.py

@@ -74,6 +74,7 @@ if find_spec("pydantic") and find_spec("pydantic.v1"):
             """
             namespace["__annotations__"] = annotations_from_namespace(namespace)
             return super().__new__(mcs, name, bases, namespace, **kwargs)
+
 else:
     ModelMetaclassLazyAnnotations = type  # type: ignore[assignment]
 

reflex/utils/decorator.py

@@ -110,14 +110,14 @@ def cached_procedure(
 
     def _inner_decorator(func: Callable[P, Picklable]) -> Callable[P, Picklable]:
         def _inner(*args: P.args, **kwargs: P.kwargs) -> Picklable:
-            _cache_file = cache_file_path()
+            cache_file = cache_file_path()
 
-            payload, value = _read_cached_procedure_file(_cache_file)
+            payload, value = _read_cached_procedure_file(cache_file)
             new_payload = payload_fn(*args, **kwargs)
 
             if payload != new_payload:
                 new_value = func(*args, **kwargs)
-                _write_cached_procedure_file(new_payload, _cache_file, new_value)
+                _write_cached_procedure_file(new_payload, cache_file, new_value)
                 return new_value
 
             from reflex.utils import console

reflex/utils/format.py

@@ -165,8 +165,8 @@ def to_snake_case(text: str) -> str:
     Returns:
         The snake case string.
     """
-    s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", text)
-    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower().replace("-", "_")
+    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", text)
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower().replace("-", "_")
 
 
 def to_camel_case(text: str, treat_hyphens_as_underscores: bool = True) -> str:
@@ -349,9 +349,9 @@ def format_match(
     for case in match_cases:
         conditions, return_value = case
 
-        case_conditions = " ".join(
-            [f"case JSON.stringify({condition!s}):" for condition in conditions]
-        )
+        case_conditions = " ".join([
+            f"case JSON.stringify({condition!s}):" for condition in conditions
+        ])
         case_code = f"{case_conditions}  return ({return_value!s});  break;"
         switch_code += case_code
 
@@ -493,24 +493,20 @@ def format_event(event_spec: EventSpec) -> str:
     Returns:
         The compiled event.
     """
-    args = ",".join(
-        [
-            ":".join(
-                (
-                    name._js_expr,
-                    (
-                        wrap(
-                            json.dumps(val._js_expr).strip('"').replace("`", "\\`"),
-                            "`",
-                        )
-                        if val._var_is_string
-                        else str(val)
-                    ),
+    args = ",".join([
+        ":".join((
+            name._js_expr,
+            (
+                wrap(
+                    json.dumps(val._js_expr).strip('"').replace("`", "\\`"),
+                    "`",
                 )
-            )
-            for name, val in event_spec.args
-        ]
-    )
+                if val._var_is_string
+                else str(val)
+            ),
+        ))
+        for name, val in event_spec.args
+    ])
     event_args = [
         wrap(format_event_handler(event_spec.handler), '"'),
     ]

reflex/utils/prerequisites.py

@@ -458,7 +458,7 @@ def validate_app_name(app_name: str | None = None) -> str:
     Raises:
         SystemExit: if the app directory name is reflex or if the name is not standard for a python package name.
     """
-    app_name = app_name if app_name else Path.cwd().name.replace("-", "_")
+    app_name = app_name or Path.cwd().name.replace("-", "_")
     # Make sure the app is not named "reflex".
     if app_name.lower() == constants.Reflex.MODULE_NAME:
         console.error(

reflex/utils/pyi_generator.py

@@ -193,9 +193,9 @@ def _get_type_hint(
 
         if value.__name__ == "Var":
             args = list(
-                chain.from_iterable(
-                    [get_args(arg) if rx_types.is_union(arg) else [arg] for arg in args]
-                )
+                chain.from_iterable([
+                    get_args(arg) if rx_types.is_union(arg) else [arg] for arg in args
+                ])
             )
 
             # For Var types, Union with the inner args so they can be passed directly.
@@ -270,7 +270,7 @@ def _generate_docstrings(clzs: list[type[Component]], props: list[str]) -> str:
     comments = []
     for clz in clzs:
         for line in inspect.getsource(clz).splitlines():
-            reached_functions = re.search("def ", line)
+            reached_functions = re.search(r"def ", line)
             if reached_functions:
                 # We've reached the functions, so stop.
                 break
@@ -288,7 +288,7 @@ def _generate_docstrings(clzs: list[type[Component]], props: list[str]) -> str:
                 continue
 
             # Check if this line has a prop.
-            match = re.search("\\w+:", line)
+            match = re.search(r"\w+:", line)
             if match is None:
                 # This line doesn't have a var, so continue.
                 continue
@@ -307,9 +307,9 @@ def _generate_docstrings(clzs: list[type[Component]], props: list[str]) -> str:
     for line in (clz.create.__doc__ or "").splitlines():
         if "**" in line:
             indent = line.split("**")[0]
-            new_docstring.extend(
-                [f"{indent}{n}:{' '.join(c)}" for n, c in props_comments.items()]
-            )
+            new_docstring.extend([
+                f"{indent}{n}:{' '.join(c)}" for n, c in props_comments.items()
+            ])
         new_docstring.append(line)
     return "\n".join(new_docstring)
 
@@ -394,23 +394,21 @@ def _extract_class_props_as_ast_nodes(
             for module in modules:
                 available_vars.update(sys.modules[module].__dict__)
 
-            kwargs.append(
-                (
-                    ast.arg(
-                        arg=name,
-                        annotation=ast.Name(
-                            id=OVERWRITE_TYPES.get(
-                                name,
-                                _get_type_hint(
-                                    value,
-                                    type_hint_globals | available_vars,
-                                ),
-                            )
-                        ),
+            kwargs.append((
+                ast.arg(
+                    arg=name,
+                    annotation=ast.Name(
+                        id=OVERWRITE_TYPES.get(
+                            name,
+                            _get_type_hint(
+                                value,
+                                type_hint_globals | available_vars,
+                            ),
+                        )
                     ),
-                    ast.Constant(value=default),  # pyright: ignore [reportArgumentType]
-                )
-            )
+                ),
+                ast.Constant(value=default),  # pyright: ignore [reportArgumentType]
+            ))
     return kwargs
 
 
@@ -489,7 +487,7 @@ def type_to_ast(typ: Any, cls: type) -> ast.expr:
 
 
 def _get_parent_imports(func: Callable):
-    _imports = {"reflex.vars": ["Var"]}
+    imports_ = {"reflex.vars": ["Var"]}
     for type_hint in inspect.get_annotations(func).values():
         try:
             match = re.match(r"\w+\[([\w\d]+)\]", type_hint)
@@ -498,8 +496,8 @@ def _get_parent_imports(func: Callable):
         if match:
             type_hint = match.group(1)
             if type_hint in importlib.import_module(func.__module__).__dir__():
-                _imports.setdefault(func.__module__, []).append(type_hint)
-    return _imports
+                imports_.setdefault(func.__module__, []).append(type_hint)
+    return imports_
 
 
 def _generate_component_create_functiondef(
@@ -527,13 +525,13 @@ def _generate_component_create_functiondef(
         raise TypeError(msg)
 
     # add the imports needed by get_type_hint later
-    type_hint_globals.update(
-        {name: getattr(typing, name) for name in DEFAULT_TYPING_IMPORTS}
-    )
+    type_hint_globals.update({
+        name: getattr(typing, name) for name in DEFAULT_TYPING_IMPORTS
+    })
 
     if clz.__module__ != clz.create.__module__:
-        _imports = _get_parent_imports(clz.create)
-        for name, values in _imports.items():
+        imports_ = _get_parent_imports(clz.create)
+        for name, values in imports_.items():
             exec(f"from {name} import {','.join(values)}", type_hint_globals)
 
     kwargs = _extract_func_kwargs_as_ast_nodes(clz.create, type_hint_globals)
@@ -637,16 +635,12 @@ def _generate_component_create_functiondef(
                             )
                             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.Tuple([
+                                    figure_out_return_type(
+                                        inspect.signature(event_spec).return_annotation
+                                    )
+                                    for event_spec in event_specs
+                                ]),
                             )
                         )
                     ),
@@ -759,9 +753,9 @@ def _generate_namespace_call_functiondef(
         The create functiondef node for the ast.
     """
     # add the imports needed by get_type_hint later
-    type_hint_globals.update(
-        {name: getattr(typing, name) for name in DEFAULT_TYPING_IMPORTS}
-    )
+    type_hint_globals.update({
+        name: getattr(typing, name) for name in DEFAULT_TYPING_IMPORTS
+    })
 
     clz = classes[clz_name]
 
@@ -1093,15 +1087,13 @@ class PyiGenerator:
     def _write_pyi_file(self, module_path: Path, source: str) -> str:
         relpath = str(_relative_to_pwd(module_path)).replace("\\", "/")
         pyi_content = (
-            "\n".join(
-                [
-                    f'"""Stub file for {relpath}"""',
-                    "# ------------------- DO NOT EDIT ----------------------",
-                    "# This file was generated by `reflex/utils/pyi_generator.py`!",
-                    "# ------------------------------------------------------",
-                    "",
-                ]
-            )
+            "\n".join([
+                f'"""Stub file for {relpath}"""',
+                "# ------------------- DO NOT EDIT ----------------------",
+                "# This file was generated by `reflex/utils/pyi_generator.py`!",
+                "# ------------------------------------------------------",
+                "",
+            ])
             + source
         )
 
@@ -1159,9 +1151,11 @@ class PyiGenerator:
 
         text = (
             "\n"
-            + "\n".join(
-                [*sub_mods_imports, *sub_mod_attrs_imports, *extra_mappings_imports]
-            )
+            + "\n".join([
+                *sub_mods_imports,
+                *sub_mod_attrs_imports,
+                *extra_mappings_imports,
+            ])
             + "\n"
         )
         text += ast.unparse(new_tree) + "\n\n"

reflex/utils/serializers.py

@@ -137,7 +137,7 @@ def serialize(value: Any) -> SerializedType | None: ...
 
 def serialize(
     value: Any, get_type: bool = False
-) -> SerializedType | None | tuple[SerializedType | None, types.GenericType | None]:
+) -> SerializedType | tuple[SerializedType | None, types.GenericType | None] | None:
     """Serialize the value to a JSON string.
 
     Args:

reflex/utils/telemetry.py

@@ -346,7 +346,7 @@ def send(event: str, telemetry_enabled: bool | None = None, **kwargs):
         kwargs: Additional data to send with the event.
     """
 
-    async def async_send(event: str, telemetry_enabled: bool | None, **kwargs):
+    async def async_send(event: str, telemetry_enabled: bool | None, **kwargs):  # noqa: RUF029
         return _send(event, telemetry_enabled, **kwargs)
 
     try:

reflex/utils/templates.py

@@ -285,9 +285,9 @@ def fetch_app_templates(version: str) -> dict[str, Template]:
         if tp["hidden"] or tp["code_url"] is None:
             continue
         known_fields = {f.name for f in dataclasses.fields(Template)}
-        filtered_templates[tp["name"]] = Template(
-            **{k: v for k, v in tp.items() if k in known_fields}
-        )
+        filtered_templates[tp["name"]] = Template(**{
+            k: v for k, v in tp.items() if k in known_fields
+        })
     return filtered_templates
 
 
@@ -383,7 +383,7 @@ def initialize_app(app_name: str, template: str | None = None) -> str | None:
     templates: dict[str, Template] = {}
 
     # Don't fetch app templates if the user directly asked for DEFAULT.
-    if template is not None and (template not in (constants.Templates.DEFAULT,)):
+    if template is not None and template != constants.Templates.DEFAULT:
         template, templates = fetch_remote_templates(template)
 
     if template is None:

reflex/utils/types.py

@@ -443,6 +443,13 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
 
         from reflex.model import Model
 
+        if find_spec("sqlmodel"):
+            from sqlmodel import SQLModel
+
+            sqlmodel_types = (Model, SQLModel)
+        else:
+            sqlmodel_types = (Model,)
+
         if isinstance(cls, type) and issubclass(cls, DeclarativeBase):
             insp = sqlalchemy.inspect(cls)
             if name in insp.columns:
@@ -486,7 +493,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
         elif (
             isinstance(cls, type)
             and not is_generic_alias(cls)
-            and issubclass(cls, Model)
+            and issubclass(cls, sqlmodel_types)
         ):
             # Check in the annotations directly (for sqlmodel.Relationship)
             hints = get_type_hints(cls)  # pyright: ignore [reportArgumentType]
@@ -984,9 +991,9 @@ def validate_literal(key: str, value: Any, expected_type: type, comp_name: str):
     ):
         allowed_values = expected_type.__args__
         if value not in allowed_values:
-            allowed_value_str = ",".join(
-                [str(v) if not isinstance(v, str) else f"'{v}'" for v in allowed_values]
-            )
+            allowed_value_str = ",".join([
+                str(v) if not isinstance(v, str) else f"'{v}'" for v in allowed_values
+            ])
             value_str = f"'{value}'" if isinstance(value, str) else value
             msg = f"prop value for {key!s} of the `{comp_name}` component should be one of the following: {allowed_value_str}. Got {value_str} instead"
             raise ValueError(msg)

reflex/vars/base.py

@@ -233,7 +233,7 @@ class VarData:
             hook: None for var_data in all_var_datas for hook in var_data.hooks
         }
 
-        _imports = imports.merge_imports(
+        imports_ = imports.merge_imports(
             *(var_data.imports for var_data in all_var_datas)
         )
 
@@ -261,7 +261,7 @@ class VarData:
         return VarData(
             state=state,
             field_name=field_name,
-            imports=_imports,
+            imports=imports_,
             hooks=hooks,
             deps=deps,
             position=position,
@@ -488,13 +488,13 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             raise TypeError(msg)
 
         # Decode any inline Var markup and apply it to the instance
-        _var_data, _js_expr = _decode_var_immutable(self._js_expr)
+        var_data_, js_expr_ = _decode_var_immutable(self._js_expr)
 
-        if _var_data or _js_expr != self._js_expr:
+        if var_data_ or js_expr_ != self._js_expr:
             self.__init__(
-                _js_expr=_js_expr,
+                _js_expr=js_expr_,
                 _var_type=self._var_type,
-                _var_data=VarData.merge(self._var_data, _var_data),
+                _var_data=VarData.merge(self._var_data, var_data_),
             )
 
     def __hash__(self) -> int:
@@ -1590,12 +1590,10 @@ class LiteralVar(Var):
             )
 
         if dataclasses.is_dataclass(value) and not isinstance(value, type):
-            return LiteralObjectVar._get_all_var_data_without_creating_var(
-                {
-                    k: (None if callable(v) else v)
-                    for k, v in dataclasses.asdict(value).items()
-                }
-            )
+            return LiteralObjectVar._get_all_var_data_without_creating_var({
+                k: (None if callable(v) else v)
+                for k, v in dataclasses.asdict(value).items()
+            })
 
         if isinstance(value, range):
             return None
@@ -1949,16 +1947,14 @@ class CachedVarOperation:
         Returns:
             The hash of the object.
         """
-        return hash(
-            (
-                type(self).__name__,
-                *[
-                    getattr(self, field.name)
-                    for field in dataclasses.fields(self)
-                    if field.name not in ["_js_expr", "_var_data", "_var_type"]
-                ],
-            )
-        )
+        return hash((
+            type(self).__name__,
+            *[
+                getattr(self, field.name)
+                for field in dataclasses.fields(self)
+                if field.name not in ["_js_expr", "_var_data", "_var_type"]
+            ],
+        ))
 
 
 def and_operation(
@@ -2171,11 +2167,11 @@ class ComputedVar(Var[RETURN_TYPE]):
         if isinstance(deps, dict):
             # Assume a dict is coming from _replace, so no special processing.
             return deps
-        _static_deps = {}
+        static_deps = {}
         if deps is not None:
             for dep in deps:
-                _static_deps = self._add_static_dep(dep, _static_deps)
-        return _static_deps
+                static_deps = self._add_static_dep(dep, static_deps)
+        return static_deps
 
     def _add_static_dep(
         self, dep: str | Var, deps: dict[str | None, set[str]] | None = None
@@ -2494,9 +2490,10 @@ class ComputedVar(Var[RETURN_TYPE]):
                     self._static_deps.setdefault(state_name, set()).add(var_name)
                     objclass.get_root_state().get_class_substate(
                         state_name
-                    )._var_dependencies.setdefault(var_name, set()).add(
-                        (objclass.get_full_name(), self._name)
-                    )
+                    )._var_dependencies.setdefault(var_name, set()).add((
+                        objclass.get_full_name(),
+                        self._name,
+                    ))
                     return
         msg = (
             "ComputedVar dependencies must be Var instances with a state and "
@@ -2538,7 +2535,7 @@ class DynamicRouteVar(ComputedVar[str | list[str]]):
     """A ComputedVar that represents a dynamic route."""
 
 
-async def _default_async_computed_var(_self: BaseState) -> Any:
+async def _default_async_computed_var(_self: BaseState) -> Any:  # noqa: RUF029
     return None
 
 

reflex/vars/color.py

@@ -76,14 +76,12 @@ class LiteralColorVar(CachedVarOperation, LiteralVar, ColorVar):
         Returns:
             The hash of the var.
         """
-        return hash(
-            (
-                self.__class__.__name__,
-                self._var_value.color,
-                self._var_value.alpha,
-                self._var_value.shade,
-            )
-        )
+        return hash((
+            self.__class__.__name__,
+            self._var_value.color,
+            self._var_value.alpha,
+            self._var_value.shade,
+        ))
 
     @cached_property_no_lock
     def _cached_var_name(self) -> str:

reflex/vars/dep_tracking.py

@@ -255,9 +255,11 @@ class DependencyTracker:
         source = inspect.getsource(module).splitlines(True)[start_line - 1 : end_line]
         # Create a python source string snippet.
         if len(source) > 1:
-            snipped_source = "".join(
-                [*source[0][start_column:], *source[1:-1], *source[-1][:end_column]]
-            )
+            snipped_source = "".join([
+                *source[0][start_column:],
+                *source[1:-1],
+                *source[-1][:end_column],
+            ])
         else:
             snipped_source = source[0][start_column:end_column]
         # Evaluate the string in the context of the function's globals and closure.

reflex/vars/function.py

@@ -331,9 +331,9 @@ def format_args_function_operation(
     Returns:
         The formatted args function operation.
     """
-    arg_names_str = ", ".join(
-        [arg if isinstance(arg, str) else arg.to_javascript() for arg in args.args]
-    ) + (f", ...{args.rest}" if args.rest else "")
+    arg_names_str = ", ".join([
+        arg if isinstance(arg, str) else arg.to_javascript() for arg in args.args
+    ]) + (f", ...{args.rest}" if args.rest else "")
 
     return_expr_str = str(LiteralVar.create(return_expr))
 

reflex/vars/object.py

@@ -56,13 +56,11 @@ def _determine_value_type(var_type: GenericType):
     origin_var_type = get_origin(var_type) or var_type
 
     if origin_var_type in types.UnionTypes:
-        return unionize(
-            *[
-                _determine_value_type(arg)
-                for arg in get_args(var_type)
-                if arg is not type(None)
-            ]
-        )
+        return unionize(*[
+            _determine_value_type(arg)
+            for arg in get_args(var_type)
+            if arg is not type(None)
+        ])
 
     if is_typeddict(origin_var_type) or dataclasses.is_dataclass(origin_var_type):
         annotations = get_type_hints(origin_var_type)
@@ -401,12 +399,10 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
         """
         return (
             "({ "
-            + ", ".join(
-                [
-                    f"[{LiteralVar.create(key)!s}] : {LiteralVar.create(value)!s}"
-                    for key, value in self._var_value.items()
-                ]
-            )
+            + ", ".join([
+                f"[{LiteralVar.create(key)!s}] : {LiteralVar.create(value)!s}"
+                for key, value in self._var_value.items()
+            ])
             + " })"
         )