reflex 0.3.2a1__py3-none-any.whl → 0.3.3a1__py3-none-any.whl

reflex/testing.py

@@ -677,7 +677,7 @@ class AppHarnessProd(AppHarness):
     frontend_server: Optional[Subdir404TCPServer] = None
 
     def _run_frontend(self):
-        web_root = self.app_path / reflex.constants.Dirs.WEB / "_static"
+        web_root = self.app_path / reflex.constants.Dirs.WEB_STATIC
         error_page_map = {
             404: web_root / "404.html",
         }

reflex/utils/build.py

@@ -35,21 +35,25 @@ def set_os_env(**kwargs):
         os.environ[key.upper()] = value
 
 
-def generate_sitemap_config(deploy_url: str):
+def generate_sitemap_config(deploy_url: str, export=False):
     """Generate the sitemap config file.
 
     Args:
         deploy_url: The URL of the deployed app.
+        export: If the sitemap are generated for an export.
     """
     # Import here to avoid circular imports.
     from reflex.compiler import templates
 
-    config = json.dumps(
-        {
-            "siteUrl": deploy_url,
-            "generateRobotsTxt": True,
-        }
-    )
+    config = {
+        "siteUrl": deploy_url,
+        "generateRobotsTxt": True,
+    }
+
+    if export:
+        config["outDir"] = constants.Dirs.STATIC
+
+    config = json.dumps(config)
 
     with open(constants.Next.SITEMAP_CONFIG_FILE, "w") as f:
         f.write(templates.SITEMAP_CONFIG(config=config))
@@ -115,7 +119,7 @@ def _zip(
 
     with progress, zipfile.ZipFile(target, "w", zipfile.ZIP_DEFLATED) as zipf:
         for file in files_to_zip:
-            console.debug(f"{target}: {file}")
+            console.debug(f"{target}: {file}", progress=progress)
             progress.advance(task)
             zipf.write(file, os.path.relpath(file, root_dir))
 
@@ -145,22 +149,23 @@ def export(
     command = "export"
 
     if frontend:
-        # Generate a sitemap if a deploy URL is provided.
-        if deploy_url is not None:
-            generate_sitemap_config(deploy_url)
-            command = "export-sitemap"
-
         checkpoints = [
             "Linting and checking ",
-            "Compiled successfully",
+            "Creating an optimized production build",
             "Route (pages)",
+            "prerendered as static HTML",
             "Collecting page data",
-            "automatically rendered as static HTML",
-            'Copying "static build" directory',
-            'Copying "public" directory',
             "Finalizing page optimization",
-            "Export successful",
+            "Collecting build traces",
         ]
+
+        # Generate a sitemap if a deploy URL is provided.
+        if deploy_url is not None:
+            generate_sitemap_config(deploy_url, export=zip)
+            command = "export-sitemap"
+
+            checkpoints.extend(["Loading next-sitemap", "Generation completed"])
+
         # Start the subprocess with the progress bar.
         process = processes.new_process(
             [prerequisites.get_package_manager(), "run", command],
@@ -181,7 +186,7 @@ def export(
                 target=os.path.join(
                     zip_dest_dir, constants.ComponentName.FRONTEND.zip()
                 ),
-                root_dir=".web/_static",
+                root_dir=constants.Dirs.WEB_STATIC,
                 files_to_exclude=files_to_exclude,
                 exclude_venv_dirs=False,
             )

reflex/utils/console.py

@@ -45,7 +45,11 @@ def debug(msg: str, **kwargs):
         kwargs: Keyword arguments to pass to the print function.
     """
     if _LOG_LEVEL <= LogLevel.DEBUG:
-        print(f"[blue]Debug: {msg}[/blue]", **kwargs)
+        msg_ = f"[blue]Debug: {msg}[/blue]"
+        if progress := kwargs.pop("progress", None):
+            progress.console.print(msg_, **kwargs)
+        else:
+            print(msg_, **kwargs)
 
 
 def info(msg: str, **kwargs):

reflex/utils/format.py

@@ -122,7 +122,7 @@ def to_snake_case(text: str) -> str:
         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()
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower().replace("-", "_")
 
 
 def to_camel_case(text: str) -> str:
@@ -137,14 +137,9 @@ def to_camel_case(text: str) -> str:
     Returns:
         The camel case string.
     """
-    if "_" not in text:
-        return text
-    camel = "".join(
-        word.capitalize() if i > 0 else word.lower()
-        for i, word in enumerate(text.lstrip("_").split("_"))
-    )
-    prefix = "_" if text.startswith("_") else ""
-    return prefix + camel
+    words = re.split("[_-]", text)
+    # Capitalize the first letter of each word except the first one
+    return words[0] + "".join(x.capitalize() for x in words[1:])
 
 
 def to_title_case(text: str) -> str:
@@ -627,6 +622,28 @@ def unwrap_vars(value: str) -> str:
     )
 
 
+def collect_form_dict_names(form_dict: dict[str, Any]) -> dict[str, Any]:
+    """Collapse keys with consecutive suffixes into a single list value.
+
+    Separators dash and underscore are removed, unless this would overwrite an existing key.
+
+    Args:
+        form_dict: The dict to collapse.
+
+    Returns:
+        The collapsed dict.
+    """
+    ending_digit_regex = re.compile(r"^(.*?)[_-]?(\d+)$")
+    collapsed = {}
+    for k in sorted(form_dict):
+        m = ending_digit_regex.match(k)
+        if m:
+            collapsed.setdefault(m.group(1), []).append(form_dict[k])
+    # collapsing never overwrites valid data from the form_dict
+    collapsed.update(form_dict)
+    return collapsed
+
+
 def format_data_editor_column(col: str | dict):
     """Format a given column into the proper format.
 

reflex/utils/prerequisites.py

@@ -25,7 +25,7 @@ from redis.asyncio import Redis
 
 from reflex import constants, model
 from reflex.compiler import templates
-from reflex.config import Config, get_config
+from reflex.config import get_config
 from reflex.utils import console, path_ops, processes
 
 
@@ -288,15 +288,7 @@ def initialize_web_directory():
 
     path_ops.mkdir(constants.Dirs.WEB_ASSETS)
 
-    # update nextJS config based on rxConfig
-    next_config_file = os.path.join(constants.Dirs.WEB, constants.Next.CONFIG_FILE)
-
-    with open(next_config_file, "r") as file:
-        next_config = file.read()
-        next_config = update_next_config(next_config, get_config())
-
-    with open(next_config_file, "w") as file:
-        file.write(next_config)
+    update_next_config()
 
     # Initialize the reflex json file.
     init_reflex_json()
@@ -337,27 +329,34 @@ def init_reflex_json():
     path_ops.update_json_file(constants.Reflex.JSON, reflex_json)
 
 
-def update_next_config(next_config: str, config: Config) -> str:
-    """Update Next.js config from Reflex config. Is its own function for testing.
+def update_next_config(export=False):
+    """Update Next.js config from Reflex config.
 
     Args:
-        next_config: Content of next.config.js.
-        config: A reflex Config object.
-
-    Returns:
-        The next_config updated from config.
+        export: if the method run during reflex export.
     """
-    next_config = re.sub(
-        "compress: (true|false)",
-        f'compress: {"true" if config.next_compression else "false"}',
-        next_config,
-    )
-    next_config = re.sub(
-        'basePath: ".*?"',
-        f'basePath: "{config.frontend_path or ""}"',
-        next_config,
-    )
-    return next_config
+    next_config_file = os.path.join(constants.Dirs.WEB, constants.Next.CONFIG_FILE)
+
+    next_config = _update_next_config(get_config(), export=export)
+
+    with open(next_config_file, "w") as file:
+        file.write(next_config)
+        file.write("\n")
+
+
+def _update_next_config(config, export=False):
+    next_config = {
+        "basePath": config.frontend_path or "",
+        "compress": config.next_compression,
+        "reactStrictMode": True,
+        "trailingSlash": True,
+    }
+    if export:
+        next_config["output"] = "export"
+        next_config["distDir"] = constants.Dirs.STATIC
+
+    next_config_json = re.sub(r'"([^"]+)"(?=:)', r"\1", json.dumps(next_config))
+    return f"module.exports = {next_config_json};"
 
 
 def remove_existing_bun_installation():

reflex/utils/processes.py

@@ -193,12 +193,13 @@ def run_concurrently(*fns: Union[Callable, Tuple]) -> None:
         pass
 
 
-def stream_logs(message: str, process: subprocess.Popen):
+def stream_logs(message: str, process: subprocess.Popen, progress=None):
     """Stream the logs for a process.
 
     Args:
         message: The message to display.
         process: The process.
+        progress: The ongoing progress bar if one is being used.
 
     Yields:
         The lines of the process output.
@@ -209,11 +210,11 @@ def stream_logs(message: str, process: subprocess.Popen):
     # Store the tail of the logs.
     logs = collections.deque(maxlen=512)
     with process:
-        console.debug(message)
+        console.debug(message, progress=progress)
         if process.stdout is None:
             return
         for line in process.stdout:
-            console.debug(line, end="")
+            console.debug(line, end="", progress=progress)
             logs.append(line)
             yield line
 
@@ -260,7 +261,7 @@ def show_progress(message: str, process: subprocess.Popen, checkpoints: List[str
     # Iterate over the process output.
     with console.progress() as progress:
         task = progress.add_task(f"{message}: ", total=len(checkpoints))
-        for line in stream_logs(message, process):
+        for line in stream_logs(message, process, progress=progress):
             # Check for special strings and update the progress bar.
             for special_string in checkpoints:
                 if special_string in line:

reflex/vars.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import contextlib
 import dataclasses
 import dis
+import inspect
 import json
 import random
 import string
@@ -1138,17 +1139,76 @@ class Var:
 
         Returns:
             A var representing foreach operation.
+
+        Raises:
+            TypeError: If the var is not a list.
         """
+        inner_types = get_args(self._var_type)
+        if not inner_types:
+            raise TypeError(
+                f"Cannot foreach over non-sequence var {self._var_full_name} of type {self._var_type}."
+            )
         arg = BaseVar(
             _var_name=get_unique_variable_name(),
-            _var_type=self._var_type,
+            _var_type=inner_types[0],
+        )
+        index = BaseVar(
+            _var_name=get_unique_variable_name(),
+            _var_type=int,
         )
+        fn_signature = inspect.signature(fn)
+        fn_args = (arg, index)
+        fn_ret = fn(*fn_args[: len(fn_signature.parameters)])
         return BaseVar(
-            _var_name=f"{self._var_full_name}.map(({arg._var_name}, i) => {fn(arg, key='i')})",
+            _var_name=f"{self._var_full_name}.map(({arg._var_name}, {index._var_name}) => {fn_ret})",
             _var_type=self._var_type,
             _var_is_local=self._var_is_local,
         )
 
+    @classmethod
+    def range(
+        cls,
+        v1: Var | int = 0,
+        v2: Var | int | None = None,
+        step: Var | int | None = None,
+    ) -> Var:
+        """Return an iterator over indices from v1 to v2 (or 0 to v1).
+
+        Args:
+            v1: The start of the range or end of range if v2 is not given.
+            v2: The end of the range.
+            step: The number of numbers between each item.
+
+        Returns:
+            A var representing range operation.
+
+        Raises:
+            TypeError: If the var is not an int.
+        """
+        if not isinstance(v1, Var):
+            v1 = Var.create_safe(v1)
+        if v1._var_type != int:
+            raise TypeError(f"Cannot get range on non-int var {v1._var_full_name}.")
+        if not isinstance(v2, Var):
+            v2 = Var.create(v2)
+        if v2 is None:
+            v2 = Var.create_safe("undefined")
+        elif v2._var_type != int:
+            raise TypeError(f"Cannot get range on non-int var {v2._var_full_name}.")
+
+        if not isinstance(step, Var):
+            step = Var.create(step)
+        if step is None:
+            step = Var.create_safe(1)
+        elif step._var_type != int:
+            raise TypeError(f"Cannot get range on non-int var {step._var_full_name}.")
+
+        return BaseVar(
+            _var_name=f"Array.from(range({v1._var_full_name}, {v2._var_full_name}, {step._var_name}))",
+            _var_type=list[int],
+            _var_is_local=False,
+        )
+
     def to(self, type_: Type) -> Var:
         """Convert the type of the var.
 
@@ -1418,17 +1478,25 @@ class ComputedVar(Var, property):
                 # is referencing an attribute on self
                 self_is_top_of_stack = True
                 continue
-            if self_is_top_of_stack and instruction.opname == "LOAD_ATTR":
-                # direct attribute access
-                d.add(instruction.argval)
-            elif self_is_top_of_stack and instruction.opname == "LOAD_METHOD":
-                # method call on self
-                d.update(
-                    self._deps(
-                        objclass=objclass,
-                        obj=getattr(objclass, instruction.argval),
+            if self_is_top_of_stack and instruction.opname in (
+                "LOAD_ATTR",
+                "LOAD_METHOD",
+            ):
+                try:
+                    ref_obj = getattr(objclass, instruction.argval)
+                except Exception:
+                    ref_obj = None
+                if callable(ref_obj):
+                    # recurse into callable attributes
+                    d.update(
+                        self._deps(
+                            objclass=objclass,
+                            obj=ref_obj,
+                        )
                     )
-                )
+                else:
+                    # normal attribute access
+                    d.add(instruction.argval)
             elif instruction.opname == "LOAD_CONST" and isinstance(
                 instruction.argval, CodeType
             ):

reflex/vars.pyi

@@ -85,6 +85,13 @@ class Var:
     def contains(self, other: Any) -> Var: ...
     def reverse(self) -> Var: ...
     def foreach(self, fn: Callable) -> Var: ...
+    @classmethod
+    def range(
+        cls,
+        v1: Var | int = 0,
+        v2: Var | int | None = None,
+        step: Var | int | None = None,
+    ) -> Var: ...
     def to(self, type_: Type) -> Var: ...
     @property
     def _var_full_name(self) -> str: ...

{reflex-0.3.2a1.dist-info → reflex-0.3.3a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflex
-Version: 0.3.2a1
+Version: 0.3.3a1
 Summary: Web apps in pure Python.
 Home-page: https://reflex.dev
 License: Apache-2.0
@@ -36,7 +36,8 @@ Requires-Dist: sqlmodel (>=0.0.8,<0.0.9)
 Requires-Dist: starlette-admin (>=0.9.0,<0.10.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: typer (>=0.4.2,<1)
-Requires-Dist: uvicorn (>=0.20.0,<0.21.0)
+Requires-Dist: uvicorn (>=0.20.0,<0.21.0) ; python_version < "3.12"
+Requires-Dist: uvicorn (>=0.24.0,<0.25.0) ; python_version >= "3.12"
 Requires-Dist: watchdog (>=2.3.1,<3.0.0)
 Requires-Dist: watchfiles (>=0.19.0,<0.20.0)
 Requires-Dist: websockets (>=10.4,<11.0)