reflex 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

reflex/utils/lazy_loader.py

@@ -1,16 +1,32 @@
-"""Module to implement lazy loading in reflex."""
+"""Module to implement lazy loading in reflex.
+
+BSD 3-Clause License
+
+Copyright (c) 2022--2023, Scientific Python project All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+    Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
 
 from __future__ import annotations
 
 import copy
-
-import lazy_loader as lazy
+import importlib
+import os
+import sys
 
 
 def attach(
     package_name: str,
-    submodules: set | None = None,
-    submod_attrs: dict | None = None,
+    submodules: set[str] | None = None,
+    submod_attrs: dict[str, list[str]] | None = None,
 ):
     """Replaces a package's __getattr__, __dir__, and __all__ attributes using lazy.attach.
     The lazy loader __getattr__ doesn't support tuples as list values. We needed to add
@@ -27,14 +43,49 @@ def attach(
     Returns:
         __getattr__, __dir__, __all__
     """
-    _submod_attrs = copy.deepcopy(submod_attrs)
-    if _submod_attrs:
-        for k, v in _submod_attrs.items():
+    submod_attrs = copy.deepcopy(submod_attrs)
+    if submod_attrs:
+        for k, v in submod_attrs.items():
             # when flattening the list, only keep the alias in the tuple(mod[1])
-            _submod_attrs[k] = [
+            submod_attrs[k] = [
                 mod if not isinstance(mod, tuple) else mod[1] for mod in v
             ]
 
-    return lazy.attach(
-        package_name=package_name, submodules=submodules, submod_attrs=_submod_attrs
-    )
+    if submod_attrs is None:
+        submod_attrs = {}
+
+    submodules = set(submodules) if submodules is not None else set()
+
+    attr_to_modules = {
+        attr: mod for mod, attrs in submod_attrs.items() for attr in attrs
+    }
+
+    __all__ = sorted(submodules | attr_to_modules.keys())
+
+    def __getattr__(name: str):  # noqa: N807
+        if name in submodules:
+            return importlib.import_module(f"{package_name}.{name}")
+        elif name in attr_to_modules:
+            submod_path = f"{package_name}.{attr_to_modules[name]}"
+            submod = importlib.import_module(submod_path)
+            attr = getattr(submod, name)
+
+            # If the attribute lives in a file (module) with the same
+            # name as the attribute, ensure that the attribute and *not*
+            # the module is accessible on the package.
+            if name == attr_to_modules[name]:
+                pkg = sys.modules[package_name]
+                pkg.__dict__[name] = attr
+
+            return attr
+        else:
+            raise AttributeError(f"No {package_name} attribute {name}")
+
+    def __dir__():  # noqa: N807
+        return __all__
+
+    if os.environ.get("EAGER_IMPORT", ""):
+        for attr in set(attr_to_modules.keys()) | submodules:
+            __getattr__(attr)
+
+    return __getattr__, __dir__, list(__all__)

reflex/utils/prerequisites.py

@@ -254,7 +254,7 @@ def get_nodejs_compatible_package_managers(
 
     package_managers = list(filter(None, package_managers))
 
-    if not package_managers and not raise_on_none:
+    if not package_managers and raise_on_none:
         raise FileNotFoundError(
             "Bun or npm not found. You might need to rerun `reflex init` or install either."
         )
@@ -831,44 +831,48 @@ def initialize_gitignore(
     gitignore_file.write_text("\n".join(files_to_ignore) + "\n")
 
 
-def initialize_requirements_txt():
+def initialize_requirements_txt() -> bool:
     """Initialize the requirements.txt file.
     If absent, generate one for the user.
     If the requirements.txt does not have reflex as dependency,
     generate a requirement pinning current version and append to
     the requirements.txt file.
+
+    Returns:
+        True if the requirements.txt file was created or updated, False otherwise.
+
+    Raises:
+        Exit: If the requirements.txt file cannot be read or written to.
     """
-    fp = Path(constants.RequirementsTxt.FILE)
-    encoding = "utf-8"
-    if not fp.exists():
-        fp.touch()
+    requirements_file_path = Path(constants.RequirementsTxt.FILE)
+    requirements_file_path.touch(exist_ok=True)
+
+    for encoding in [None, "utf-8"]:
+        try:
+            content = requirements_file_path.read_text(encoding)
+            break
+        except UnicodeDecodeError:
+            continue
+        except Exception as e:
+            console.error(f"Failed to read {requirements_file_path}.")
+            raise typer.Exit(1) from e
     else:
-        # Detect the encoding of the original file
-        import charset_normalizer
+        return False
 
-        charset_matches = charset_normalizer.from_path(fp)
-        maybe_charset_match = charset_matches.best()
-        if maybe_charset_match is None:
-            console.debug(f"Unable to detect encoding for {fp}, exiting.")
-            return
-        encoding = maybe_charset_match.encoding
-        console.debug(f"Detected encoding for {fp} as {encoding}.")
-    try:
-        other_requirements_exist = False
-        with fp.open("r", encoding=encoding) as f:
-            for req in f:
-                # Check if we have a package name that is reflex
-                if re.match(r"^reflex[^a-zA-Z0-9]", req):
-                    console.debug(f"{fp} already has reflex as dependency.")
-                    return
-                other_requirements_exist = True
-        with fp.open("a", encoding=encoding) as f:
-            preceding_newline = "\n" if other_requirements_exist else ""
-            f.write(
-                f"{preceding_newline}{constants.RequirementsTxt.DEFAULTS_STUB}{constants.Reflex.VERSION}\n"
-            )
-    except Exception:
-        console.info(f"Unable to check {fp} for reflex dependency.")
+    for line in content.splitlines():
+        if re.match(r"^reflex[^a-zA-Z0-9]", line):
+            console.debug(f"{requirements_file_path} already has reflex as dependency.")
+            return True
+
+    console.debug(
+        f"Appending {constants.RequirementsTxt.DEFAULTS_STUB} to {requirements_file_path}"
+    )
+    with requirements_file_path.open("a", encoding=encoding) as f:
+        f.write(
+            "\n" + constants.RequirementsTxt.DEFAULTS_STUB + constants.Reflex.VERSION
+        )
+
+    return True
 
 
 def initialize_app_directory(
@@ -1087,8 +1091,10 @@ def _update_next_config(
         "compress": config.next_compression,
         "trailingSlash": True,
         "staticPageGenerationTimeout": config.static_page_generation_timeout,
-        "devIndicators": config.next_dev_indicators,
     }
+    if not config.next_dev_indicators:
+        next_config["devIndicators"] = False
+
     if transpile_packages:
         next_config["transpilePackages"] = list(
             {format_library_name(p) for p in transpile_packages}
@@ -1409,7 +1415,7 @@ def validate_bun():
             raise typer.Exit(1)
         elif bun_version < version.parse(constants.Bun.MIN_VERSION):
             console.error(
-                f"Reflex requires bun version {constants.Bun.VERSION} or higher to run, but the detected version is "
+                f"Reflex requires bun version {constants.Bun.MIN_VERSION} or higher to run, but the detected version is "
                 f"{bun_version}. If you have specified a custom bun path in your config, make sure to provide one "
                 f"that satisfies the minimum version requirement."
             )

reflex/utils/processes.py

@@ -294,6 +294,7 @@ def stream_logs(
 
     Raises:
         Exit: If the process failed.
+        ValueError: If the process stdout pipe is closed, but the process remains running.
     """
     from reflex.utils import telemetry
 
@@ -303,10 +304,18 @@ def stream_logs(
         console.debug(message, progress=progress)
         if process.stdout is None:
             return
-        for line in process.stdout:
-            console.debug(line, end="", progress=progress)
-            logs.append(line)
-            yield line
+        try:
+            for line in process.stdout:
+                console.debug(line, end="", progress=progress)
+                logs.append(line)
+                yield line
+        except ValueError:
+            # The stream we were reading has been closed,
+            if process.poll() is None:
+                # But if the process is still running that is weird.
+                raise
+            # If the process exited, break out of the loop for post processing.
+            pass
 
     # Check if the process failed (not printing the logs for SIGINT).
 

reflex/utils/pyi_generator.py

@@ -6,11 +6,13 @@ import ast
 import contextlib
 import importlib
 import inspect
+import json
 import logging
 import re
 import subprocess
 import typing
 from fileinput import FileInput
+from hashlib import md5
 from inspect import getfullargspec
 from itertools import chain
 from multiprocessing import Pool, cpu_count
@@ -1058,9 +1060,9 @@ class PyiGenerator:
     modules: list = []
     root: str = ""
     current_module: Any = {}
-    written_files: list[str] = []
+    written_files: list[tuple[str, str]] = []
 
-    def _write_pyi_file(self, module_path: Path, source: str):
+    def _write_pyi_file(self, module_path: Path, source: str) -> str:
         relpath = str(_relative_to_pwd(module_path)).replace("\\", "/")
         pyi_content = (
             "\n".join(
@@ -1078,6 +1080,7 @@ class PyiGenerator:
         pyi_path = module_path.with_suffix(".pyi")
         pyi_path.write_text(pyi_content)
         logger.info(f"Wrote {relpath}")
+        return md5(pyi_content.encode()).hexdigest()
 
     def _get_init_lazy_imports(self, mod: tuple | ModuleType, new_tree: ast.AST):
         # retrieve the _SUBMODULES and _SUBMOD_ATTRS from an init file if present.
@@ -1118,7 +1121,7 @@ class PyiGenerator:
         text += ast.unparse(new_tree) + "\n"
         return text
 
-    def _scan_file(self, module_path: Path) -> str | None:
+    def _scan_file(self, module_path: Path) -> tuple[str, str] | None:
         module_import = (
             _relative_to_pwd(module_path)
             .with_suffix("")
@@ -1132,7 +1135,10 @@ class PyiGenerator:
             name: obj
             for name, obj in vars(module).items()
             if inspect.isclass(obj)
-            and (issubclass(obj, Component) or issubclass(obj, SimpleNamespace))
+            and (
+                rx_types.safe_issubclass(obj, Component)
+                or rx_types.safe_issubclass(obj, SimpleNamespace)
+            )
             and obj != Component
             and inspect.getmodule(obj) == module
         }
@@ -1147,13 +1153,13 @@ class PyiGenerator:
             init_imports = self._get_init_lazy_imports(module, new_tree)
             if not init_imports:
                 return
-            self._write_pyi_file(module_path, init_imports)
+            content_hash = self._write_pyi_file(module_path, init_imports)
         else:
             new_tree = StubGenerator(module, class_names).visit(
                 ast.parse(inspect.getsource(module))
             )
-            self._write_pyi_file(module_path, ast.unparse(new_tree))
-        return str(module_path.with_suffix(".pyi").resolve())
+            content_hash = self._write_pyi_file(module_path, ast.unparse(new_tree))
+        return str(module_path.with_suffix(".pyi").resolve()), content_hash
 
     def _scan_files_multiprocess(self, files: list[Path]):
         with Pool(processes=cpu_count()) as pool:
@@ -1165,12 +1171,18 @@ class PyiGenerator:
             if pyi_path:
                 self.written_files.append(pyi_path)
 
-    def scan_all(self, targets: list, changed_files: list[Path] | None = None):
+    def scan_all(
+        self,
+        targets: list,
+        changed_files: list[Path] | None = None,
+        use_json: bool = False,
+    ):
         """Scan all targets for class inheriting Component and generate the .pyi files.
 
         Args:
             targets: the list of file/folders to scan.
             changed_files (optional): the list of changed files since the last run.
+            use_json: whether to use json to store the hashes.
         """
         file_targets = []
         for target in targets:
@@ -1212,17 +1224,82 @@ class PyiGenerator:
         else:
             self._scan_files_multiprocess(file_targets)
 
+        file_paths, hashes = (
+            [f[0] for f in self.written_files],
+            [f[1] for f in self.written_files],
+        )
+
         # Fix generated pyi files with ruff.
-        if self.written_files:
-            subprocess.run(["ruff", "format", *self.written_files])
-            subprocess.run(["ruff", "check", "--fix", *self.written_files])
+        if file_paths:
+            subprocess.run(["ruff", "format", *file_paths])
+            subprocess.run(["ruff", "check", "--fix", *file_paths])
 
         # For some reason, we need to format the __init__.pyi files again after fixing...
-        init_files = [f for f in self.written_files if "/__init__.pyi" in f]
+        init_files = [f for f in file_paths if "/__init__.pyi" in f]
         subprocess.run(["ruff", "format", *init_files])
 
+        if use_json:
+            if file_paths and changed_files is None:
+                file_paths = list(map(Path, file_paths))
+                top_dir = file_paths[0].parent
+                for file_path in file_paths:
+                    file_parent = file_path.parent
+                    while len(file_parent.parts) > len(top_dir.parts):
+                        file_parent = file_parent.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(
+                                [
+                                    str(f.relative_to(pyi_hashes_file.parent))
+                                    for f in file_paths
+                                ],
+                                hashes,
+                                strict=True,
+                            )
+                        ),
+                        indent=2,
+                        sort_keys=True,
+                    )
+                    + "\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()
+                ):
+                    pyi_hashes_parent = pyi_hashes_parent.parent
+
+                pyi_hashes_file = pyi_hashes_parent / "pyi_hashes.json"
+                if pyi_hashes_file.exists():
+                    pyi_hashes = json.loads(pyi_hashes_file.read_text())
+                    for file_path, hashed_content in zip(
+                        file_paths, hashes, strict=False
+                    ):
+                        pyi_hashes[str(file_path.relative_to(pyi_hashes_parent))] = (
+                            hashed_content
+                        )
+
+                    pyi_hashes_file.write_text(
+                        json.dumps(pyi_hashes, indent=2, sort_keys=True) + "\n"
+                    )
+
         # Post-process the generated pyi files to add hacky type: ignore comments
-        for file_path in self.written_files:
+        for file_path in file_paths:
             with FileInput(file_path, inplace=True) as f:
                 for line in f:
                     # Hack due to ast not supporting comments in the tree.
@@ -1233,3 +1310,15 @@ class PyiGenerator:
                     ):
                         line = line.rstrip() + "  # type: ignore\n"
                     print(line, end="")  # noqa: T201
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    logging.getLogger("blib2to3.pgen2.driver").setLevel(logging.INFO)
+
+    gen = PyiGenerator()
+    gen.scan_all(
+        ["reflex/components", "reflex/experimental", "reflex/__init__.py"],
+        None,
+        use_json=True,
+    )

reflex/utils/telemetry.py

@@ -9,6 +9,7 @@ import platform
 import warnings
 from contextlib import suppress
 from datetime import datetime, timezone
+from typing import TypedDict
 
 import httpx
 import psutil
@@ -16,6 +17,8 @@ import psutil
 from reflex import constants
 from reflex.config 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
 
 UTC = timezone.utc
@@ -94,15 +97,39 @@ def _raise_on_missing_project_hash() -> bool:
     return not environment.REFLEX_SKIP_COMPILE.get()
 
 
-def _prepare_event(event: str, **kwargs) -> dict:
-    """Prepare the event to be sent to the PostHog server.
+class _Properties(TypedDict):
+    """Properties type for telemetry."""
 
-    Args:
-        event: The event name.
-        kwargs: Additional data to send with the event.
+    distinct_id: int
+    distinct_app_id: int
+    user_os: str
+    user_os_detail: str
+    reflex_version: str
+    python_version: str
+    cpu_count: int
+    memory: int
+    cpu_info: dict
+
+
+class _DefaultEvent(TypedDict):
+    """Default event type for telemetry."""
+
+    api_key: str
+    properties: _Properties
+
+
+class _Event(_DefaultEvent):
+    """Event type for telemetry."""
+
+    event: str
+    timestamp: str
+
+
+def _get_event_defaults() -> _DefaultEvent | None:
+    """Get the default event data.
 
     Returns:
-        The event data.
+        The default event data.
     """
     from reflex.utils.prerequisites import get_cpu_info
 
@@ -113,19 +140,12 @@ def _prepare_event(event: str, **kwargs) -> dict:
         console.debug(
             f"Could not get installation_id or project_hash: {installation_id}, {project_hash}"
         )
-        return {}
-
-    stamp = datetime.now(UTC).isoformat()
+        return None
 
     cpuinfo = get_cpu_info()
 
-    additional_keys = ["template", "context", "detail", "user_uuid"]
-    additional_fields = {
-        key: value for key in additional_keys if (value := kwargs.get(key)) is not None
-    }
     return {
         "api_key": "phc_JoMo0fOyi0GQAooY3UyO9k0hebGkMyFJrrCw1Gt5SGb",
-        "event": event,
         "properties": {
             "distinct_id": installation_id,
             "distinct_app_id": project_hash,
@@ -136,13 +156,55 @@ def _prepare_event(event: str, **kwargs) -> dict:
             "cpu_count": get_cpu_count(),
             "memory": get_memory(),
             "cpu_info": dataclasses.asdict(cpuinfo) if cpuinfo else {},
-            **additional_fields,
         },
+    }
+
+
+@once_unless_none
+def get_event_defaults() -> _DefaultEvent | None:
+    """Get the default event data.
+
+    Returns:
+        The default event data.
+    """
+    return _get_event_defaults()
+
+
+def _prepare_event(event: str, **kwargs) -> _Event | None:
+    """Prepare the event to be sent to the PostHog server.
+
+    Args:
+        event: The event name.
+        kwargs: Additional data to send with the event.
+
+    Returns:
+        The event data.
+    """
+    event_data = get_event_defaults()
+    if not event_data:
+        return None
+
+    additional_keys = ["template", "context", "detail", "user_uuid"]
+
+    properties = event_data["properties"]
+
+    for key in additional_keys:
+        if key in properties or key not in kwargs:
+            continue
+
+        properties[key] = kwargs[key]
+
+    stamp = datetime.now(UTC).isoformat()
+
+    return {
+        "api_key": event_data["api_key"],
+        "event": event,
+        "properties": properties,
         "timestamp": stamp,
     }
 
 
-def _send_event(event_data: dict) -> bool:
+def _send_event(event_data: _Event) -> bool:
     try:
         httpx.post(POSTHOG_API_URL, json=event_data)
     except Exception:
@@ -151,7 +213,7 @@ def _send_event(event_data: dict) -> bool:
         return True
 
 
-def _send(event: str, telemetry_enabled: bool | None, **kwargs):
+def _send(event: str, telemetry_enabled: bool | None, **kwargs) -> bool:
     from reflex.config import get_config
 
     # Get the telemetry_enabled from the config if it is not specified.
@@ -167,6 +229,7 @@ def _send(event: str, telemetry_enabled: bool | None, **kwargs):
         if not event_data:
             return False
         return _send_event(event_data)
+    return False
 
 
 def send(event: str, telemetry_enabled: bool | None = None, **kwargs):
@@ -196,8 +259,6 @@ def send_error(error: Exception, context: str):
     Args:
         error: The error to send.
         context: The context of the error (e.g. "frontend" or "backend")
-
-    Returns:
-        Whether the telemetry was sent successfully.
     """
-    return send("error", detail=type(error).__name__, context=context)
+    if isinstance(error, ReflexError):
+        send("error", detail=type(error).__name__, context=context)

reflex/utils/types.py

@@ -607,7 +607,7 @@ def _isinstance(
     if cls is None or cls is type(None):
         return obj is None
 
-    if cls and is_union(cls):
+    if cls is not None and is_union(cls):
         return any(
             _isinstance(obj, arg, nested=nested, treat_var_as_type=treat_var_as_type)
             for arg in get_args(cls)
@@ -643,6 +643,16 @@ def _isinstance(
         # cls is a simple generic class
         return isinstance(obj, origin)
 
+    if origin is Var and args:
+        # cls is a Var
+        return _isinstance(
+            obj,
+            args[0],
+            nested=nested,
+            treat_var_as_type=treat_var_as_type,
+            treat_mutable_obj_as_immutable=treat_mutable_obj_as_immutable,
+        )
+
     if nested > 0 and args:
         if origin is list:
             expected_class = Sequence if treat_mutable_obj_as_immutable else list
@@ -986,6 +996,18 @@ def typehint_issubclass(
             for arg in args
         )
 
+    if is_literal(possible_subclass):
+        args = get_args(possible_subclass)
+        return all(
+            _isinstance(
+                arg,
+                possible_superclass,
+                treat_mutable_obj_as_immutable=treat_mutable_superclasss_as_immutable,
+                nested=2,
+            )
+            for arg in args
+        )
+
     # Remove this check when Python 3.10 is the minimum supported version
     if hasattr(types, "UnionType"):
         provided_type_origin = (

{reflex-0.7.5.dist-info → reflex-0.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.7.5
+Version: 0.7.6
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex
@@ -19,34 +19,25 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <4.0,>=3.10
 Requires-Dist: alembic<2.0,>=1.11.1
-Requires-Dist: build<2.0,>=1.0.3
-Requires-Dist: charset-normalizer<4.0,>=3.3.2
 Requires-Dist: distro<2.0,>=1.8.0; platform_system == 'Linux'
 Requires-Dist: fastapi!=0.111.0,!=0.111.1,>=0.96.0
 Requires-Dist: granian[reload]>=2.2.0
 Requires-Dist: gunicorn<24.0.0,>=23.0.0
 Requires-Dist: httpx<1.0,>=0.25.1
 Requires-Dist: jinja2<4.0,>=3.1.2
-Requires-Dist: lazy-loader>=0.4
 Requires-Dist: packaging<25.0,>=23.1
 Requires-Dist: platformdirs<5.0,>=3.10.0
 Requires-Dist: psutil<8.0,>=5.9.4
 Requires-Dist: pydantic<3.0,>=1.10.21
-Requires-Dist: python-engineio!=4.6.0
-Requires-Dist: python-multipart<0.1,>=0.0.5
+Requires-Dist: python-multipart<1.0,>=0.0.20
 Requires-Dist: python-socketio<6.0,>=5.7.0
 Requires-Dist: redis<6.0,>=4.3.5
 Requires-Dist: reflex-hosting-cli>=0.1.29
 Requires-Dist: rich<14.0,>=13.0.0
-Requires-Dist: setuptools>=75.0
 Requires-Dist: sqlmodel<0.1,>=0.0.14
-Requires-Dist: starlette-admin<1.0,>=0.11.0
-Requires-Dist: tomlkit<1.0,>=0.12.4
-Requires-Dist: twine<7.0,>=4.0.0
 Requires-Dist: typer<1.0,>=0.15.1
 Requires-Dist: typing-extensions>=4.6.0
 Requires-Dist: uvicorn>=0.20.0
-Requires-Dist: wheel<1.0,>=0.42.0
 Requires-Dist: wrapt<2.0,>=1.17.0
 Description-Content-Type: text/markdown