reflex 0.7.13a1__py3-none-any.whl → 0.7.14__py3-none-any.whl

reflex/utils/pyi_generator.py

@@ -30,6 +30,8 @@ logger = logging.getLogger("pyi_generator")
 
 PWD = Path.cwd()
 
+PYI_HASHES = "pyi_hashes.json"
+
 EXCLUDED_FILES = [
     "app.py",
     "component.py",
@@ -157,9 +159,8 @@ def _get_type_hint(
             res_args.sort()
             if len(res_args) == 1:
                 return f"{res_args[0]} | None"
-            else:
-                res = f"{' | '.join(res_args)}"
-                return f"{res} | None"
+            res = f"{' | '.join(res_args)}"
+            return f"{res} | None"
 
         res_args = [
             _get_type_hint(arg, type_hint_globals, rx_types.is_optional(arg))
@@ -183,10 +184,11 @@ def _get_type_hint(
             value.__module__ not in ["builtins", "__builtins__"]
             and value.__name__ not in type_hint_globals
         ):
-            raise TypeError(
+            msg = (
                 f"{value.__module__ + '.' + value.__name__} is not a default import, "
                 "add it to DEFAULT_IMPORTS in pyi_generator.py"
             )
+            raise TypeError(msg)
 
         res = f"{value.__name__}[{', '.join(inner_container_type_args)}]"
 
@@ -445,7 +447,7 @@ def type_to_ast(typ: Any, cls: type) -> ast.expr:
 
                 return ast.Name(id=typ.__module__ + "." + typ.__name__)
             return ast.Name(id=typ.__name__)
-        elif hasattr(typ, "_name"):
+        if hasattr(typ, "_name"):
             return ast.Name(id=typ._name)
         return ast.Name(id=str(typ))
 
@@ -510,7 +512,8 @@ def _generate_component_create_functiondef(
         TypeError: If clz is not a subclass of Component.
     """
     if not issubclass(clz, Component):
-        raise TypeError(f"clz must be a subclass of Component, not {clz!r}")
+        msg = f"clz must be a subclass of Component, not {clz!r}"
+        raise TypeError(msg)
 
     # add the imports needed by get_type_hint later
     type_hint_globals.update(
@@ -654,7 +657,7 @@ def _generate_component_create_functiondef(
         defaults=[],
     )
 
-    definition = ast.FunctionDef(  # pyright: ignore [reportCallIssue]
+    return ast.FunctionDef(  # pyright: ignore [reportCallIssue]
         name="create",
         args=create_args,
         body=[
@@ -676,7 +679,6 @@ def _generate_component_create_functiondef(
         lineno=lineno,
         returns=ast.Constant(value=clz.__name__),
     )
-    return definition
 
 
 def _generate_staticmethod_call_functiondef(
@@ -710,7 +712,7 @@ def _generate_staticmethod_call_functiondef(
             else []
         ),
     )
-    definition = ast.FunctionDef(  # pyright: ignore [reportCallIssue]
+    return ast.FunctionDef(  # pyright: ignore [reportCallIssue]
         name="__call__",
         args=call_args,
         body=[
@@ -729,7 +731,6 @@ def _generate_staticmethod_call_functiondef(
             )
         ),
     )
-    return definition
 
 
 def _generate_namespace_call_functiondef(
@@ -841,6 +842,7 @@ class StubGenerator(ast.NodeTransformer):
             and issubclass((clz := self.classes[self.current_class]), Component)
         ):
             return clz
+        return None
 
     def visit_Module(self, node: ast.Module) -> ast.Module:
         """Visit a Module node and remove docstring from body.
@@ -1021,7 +1023,7 @@ class StubGenerator(ast.NodeTransformer):
             if isinstance(target, ast.Tuple):
                 for name in target.elts:
                     if isinstance(name, ast.Name) and name.id.startswith("_"):
-                        return
+                        return None
 
         return node
 
@@ -1107,7 +1109,7 @@ class PyiGenerator:
         pyright_ignore_imports = getattr(mod, "_PYRIGHT_IGNORE_IMPORTS", [])
 
         if not sub_mods and not sub_mod_attrs:
-            return
+            return None
         sub_mods_imports = []
         sub_mod_attrs_imports = []
 
@@ -1162,7 +1164,7 @@ class PyiGenerator:
         }
         is_init_file = _relative_to_pwd(module_path).name == "__init__.py"
         if not class_names and not is_init_file:
-            return
+            return None
 
         if is_init_file:
             new_tree = InitStubGenerator(module, class_names).visit(
@@ -1170,7 +1172,7 @@ class PyiGenerator:
             )
             init_imports = self._get_init_lazy_imports(module, new_tree)
             if not init_imports:
-                return
+                return None
             content_hash = self._write_pyi_file(module_path, init_imports)
         else:
             new_tree = StubGenerator(module, class_names).visit(
@@ -1264,45 +1266,48 @@ class PyiGenerator:
                     file_parent = file_path.parent
                     while len(file_parent.parts) > len(top_dir.parts):
                         file_parent = file_parent.parent
+                    while len(top_dir.parts) > len(file_parent.parts):
+                        top_dir = top_dir.parent
                     while not file_parent.samefile(top_dir):
                         file_parent = file_parent.parent
                         top_dir = top_dir.parent
 
-                pyi_hashes_file = top_dir / "pyi_hashes.json"
-                if not pyi_hashes_file.exists():
-                    while top_dir.parent and not (top_dir / "pyi_hashes.json").exists():
-                        top_dir = top_dir.parent
-                    another_pyi_hashes_file = top_dir / "pyi_hashes.json"
-                    if another_pyi_hashes_file.exists():
-                        pyi_hashes_file = another_pyi_hashes_file
-
-                pyi_hashes_file.write_text(
-                    json.dumps(
-                        dict(
-                            zip(
-                                [
-                                    f.relative_to(pyi_hashes_file.parent).as_posix()
-                                    for f in file_paths
-                                ],
-                                hashes,
-                                strict=True,
-                            )
-                        ),
-                        indent=2,
-                        sort_keys=True,
+                while (
+                    not top_dir.samefile(top_dir.parent)
+                    and not (top_dir / PYI_HASHES).exists()
+                ):
+                    top_dir = top_dir.parent
+
+                pyi_hashes_file = top_dir / PYI_HASHES
+
+                if pyi_hashes_file.exists():
+                    pyi_hashes_file.write_text(
+                        json.dumps(
+                            dict(
+                                zip(
+                                    [
+                                        f.relative_to(pyi_hashes_file.parent).as_posix()
+                                        for f in file_paths
+                                    ],
+                                    hashes,
+                                    strict=True,
+                                )
+                            ),
+                            indent=2,
+                            sort_keys=True,
+                        )
+                        + "\n",
                     )
-                    + "\n",
-                )
             elif file_paths:
                 file_paths = list(map(Path, file_paths))
                 pyi_hashes_parent = file_paths[0].parent
                 while (
-                    pyi_hashes_parent.parent
-                    and not (pyi_hashes_parent / "pyi_hashes.json").exists()
+                    not pyi_hashes_parent.samefile(pyi_hashes_parent.parent)
+                    and not (pyi_hashes_parent / PYI_HASHES).exists()
                 ):
                     pyi_hashes_parent = pyi_hashes_parent.parent
 
-                pyi_hashes_file = pyi_hashes_parent / "pyi_hashes.json"
+                pyi_hashes_file = pyi_hashes_parent / PYI_HASHES
                 if pyi_hashes_file.exists():
                     pyi_hashes = json.loads(pyi_hashes_file.read_text())
                     for file_path, hashed_content in zip(

reflex/utils/redir.py

@@ -5,9 +5,9 @@ import webbrowser
 
 import httpx
 
+from reflex import constants
 from reflex.utils import net
 
-from .. import constants
 from . import console
 
 

reflex/utils/registry.py

@@ -2,7 +2,7 @@
 
 import httpx
 
-from reflex.config import environment
+from reflex.environment import environment
 from reflex.utils import console, net
 from reflex.utils.decorator import once
 

reflex/utils/serializers.py

@@ -76,7 +76,8 @@ def serializer(
 
         # Make sure the function takes a single argument.
         if len(args) != 1:
-            raise ValueError("Serializer must take a single argument.")
+            msg = "Serializer must take a single argument."
+            raise ValueError(msg)
 
         # Get the type of the argument.
         type_ = type_hints[args[0]]
@@ -166,8 +167,7 @@ def serialize(
     # Return the serialized value and the type.
     if get_type:
         return serialized, get_serializer_type(type(value))
-    else:
-        return serialized
+    return serialized
 
 
 @functools.lru_cache
@@ -427,7 +427,7 @@ with contextlib.suppress(ImportError):
         """
         return [
             [str(d) if isinstance(d, (list, tuple)) else d for d in data]
-            for data in list(df.values.tolist())
+            for data in list(df.to_numpy().tolist())
         ]
 
     @serializer

reflex/utils/telemetry.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import dataclasses
+import importlib.metadata
 import multiprocessing
 import platform
 import warnings
@@ -15,11 +16,16 @@ import httpx
 import psutil
 
 from reflex import constants
-from reflex.config import environment
+from reflex.environment import environment
 from reflex.utils import console
 from reflex.utils.decorator import once_unless_none
 from reflex.utils.exceptions import ReflexError
-from reflex.utils.prerequisites import ensure_reflex_installation_id, get_project_hash
+from reflex.utils.prerequisites import (
+    ensure_reflex_installation_id,
+    get_bun_version,
+    get_node_version,
+    get_project_hash,
+)
 
 UTC = timezone.utc
 POSTHOG_API_URL: str = "https://app.posthog.com/capture/"
@@ -71,6 +77,18 @@ def get_cpu_count() -> int:
     return multiprocessing.cpu_count()
 
 
+def get_reflex_enterprise_version() -> str | None:
+    """Get the version of reflex-enterprise if installed.
+
+    Returns:
+        The version string if installed, None if not installed.
+    """
+    try:
+        return importlib.metadata.version("reflex-enterprise")
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
 def get_memory() -> int:
     """Get the total memory in MB.
 
@@ -106,6 +124,9 @@ class _Properties(TypedDict):
     user_os_detail: str
     reflex_version: str
     python_version: str
+    node_version: str | None
+    bun_version: str | None
+    reflex_enterprise_version: str | None
     cpu_count: int
     memory: int
     cpu_info: dict
@@ -153,6 +174,13 @@ def _get_event_defaults() -> _DefaultEvent | None:
             "user_os_detail": get_detailed_platform_str(),
             "reflex_version": get_reflex_version(),
             "python_version": get_python_version(),
+            "node_version": (
+                str(node_version) if (node_version := get_node_version()) else None
+            ),
+            "bun_version": (
+                str(bun_version) if (bun_version := get_bun_version()) else None
+            ),
+            "reflex_enterprise_version": get_reflex_enterprise_version(),
             "cpu_count": get_cpu_count(),
             "memory": get_memory(),
             "cpu_info": dataclasses.asdict(cpuinfo) if cpuinfo else {},
@@ -232,6 +260,9 @@ def _send(event: str, telemetry_enabled: bool | None, **kwargs) -> bool:
     return False
 
 
+background_tasks = set()
+
+
 def send(event: str, telemetry_enabled: bool | None = None, **kwargs):
     """Send anonymous telemetry for Reflex.
 
@@ -246,7 +277,9 @@ def send(event: str, telemetry_enabled: bool | None = None, **kwargs):
 
     try:
         # Within an event loop context, send the event asynchronously.
-        asyncio.create_task(async_send(event, telemetry_enabled, **kwargs))
+        task = asyncio.create_task(async_send(event, telemetry_enabled, **kwargs))
+        background_tasks.add(task)
+        task.add_done_callback(background_tasks.discard)
     except RuntimeError:
         # If there is no event loop, send the event synchronously.
         warnings.filterwarnings("ignore", category=RuntimeWarning)

reflex/utils/types.py

@@ -263,8 +263,12 @@ def is_classvar(a_type: Any) -> bool:
     Returns:
         Whether the type is a ClassVar.
     """
-    return a_type is ClassVar or (
-        type(a_type) is _GenericAlias and a_type.__origin__ is ClassVar
+    return (
+        a_type is ClassVar
+        or (type(a_type) is _GenericAlias and a_type.__origin__ is ClassVar)
+        or (
+            type(a_type) is ForwardRef and a_type.__forward_arg__.startswith("ClassVar")
+        )
     )
 
 
@@ -378,7 +382,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
     if hasattr(cls, "__fields__") and name in cls.__fields__:
         # pydantic models
         return get_field_type(cls, name)
-    elif isinstance(cls, type) and issubclass(cls, DeclarativeBase):
+    if isinstance(cls, type) and issubclass(cls, DeclarativeBase):
         insp = sqlalchemy.inspect(cls)
         if name in insp.columns:
             # check for list types
@@ -410,8 +414,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
                 if isinstance(prop, Relationship):
                     type_ = prop.mapper.class_
                     # TODO: check for nullable?
-                    type_ = list[type_] if prop.uselist else type_ | None
-                    return type_
+                    return list[type_] if prop.uselist else type_ | None
             if isinstance(attr, AssociationProxyInstance):
                 return list[
                     get_attribute_access_type(
@@ -444,7 +447,6 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
                 return hints[name]
         except exceptions as e:
             console.warn(f"Failed to resolve ForwardRefs for {cls}.{name} due to {e}")
-            pass
     return None  # Attribute is not accessible.
 
 
@@ -465,7 +467,8 @@ def get_base_class(cls: GenericType) -> type:
         # only literals of the same type are supported.
         arg_type = type(get_args(cls)[0])
         if not all(type(arg) is arg_type for arg in get_args(cls)):
-            raise TypeError("only literals of the same type are supported")
+            msg = "only literals of the same type are supported"
+            raise TypeError(msg)
         return type(get_args(cls)[0])
 
     if is_union(cls):
@@ -493,13 +496,13 @@ def _breakpoints_satisfies_typing(cls_check: GenericType, instance: Any) -> bool
                 if not isinstance(value, str) or value not in get_args(expected_type):
                     return False
         return True
-    elif isinstance(cls_check_base, tuple):
+    if isinstance(cls_check_base, tuple):
         # union type, so check all types
         return any(
             _breakpoints_satisfies_typing(type_to_check, instance)
             for type_to_check in get_args(cls_check)
         )
-    elif cls_check_base == reflex.vars.Var and "__args__" in cls_check.__dict__:
+    if cls_check_base == reflex.vars.Var and "__args__" in cls_check.__dict__:
         return _breakpoints_satisfies_typing(get_args(cls_check)[0], instance)
 
     return False
@@ -551,7 +554,8 @@ def _issubclass(cls: GenericType, cls_check: GenericType, instance: Any = None)
     except TypeError as te:
         # These errors typically arise from bad annotations and are hard to
         # debug without knowing the type that we tried to compare.
-        raise TypeError(f"Invalid type for issubclass: {cls_base}") from te
+        msg = f"Invalid type for issubclass: {cls_base}"
+        raise TypeError(msg) from te
 
 
 def does_obj_satisfy_typed_dict(obj: Any, cls: GenericType) -> bool:
@@ -909,9 +913,8 @@ def validate_literal(key: str, value: Any, expected_type: type, comp_name: str):
                 [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
-            raise ValueError(
-                f"prop value for {key!s} of the `{comp_name}` component should be one of the following: {allowed_value_str}. Got {value_str} instead"
-            )
+            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)
 
 
 def validate_parameter_literals(func: Callable):