reflex 0.4.6a3__py3-none-any.whl → 0.4.7__py3-none-any.whl

reflex/utils/console.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
-
 from rich.console import Console
 from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
 from rich.prompt import Prompt
@@ -150,7 +148,10 @@ def error(msg: str, **kwargs):
 
 
 def ask(
-    question: str, choices: Optional[List[str]] = None, default: Optional[str] = None
+    question: str,
+    choices: list[str] | None = None,
+    default: str | None = None,
+    show_choices: bool = True,
 ) -> str:
     """Takes a prompt question and optionally a list of choices
      and returns the user input.
@@ -159,11 +160,12 @@ def ask(
         question: The question to ask the user.
         choices: A list of choices to select from.
         default: The default option selected.
+        show_choices: Whether to show the choices.
 
     Returns:
         A string with the user input.
     """
-    return Prompt.ask(question, choices=choices, default=default)  # type: ignore
+    return Prompt.ask(question, choices=choices, default=default, show_choices=show_choices)  # type: ignore
 
 
 def progress():

reflex/utils/exec.py

@@ -7,6 +7,7 @@ import json
 import os
 import platform
 import re
+import subprocess
 import sys
 from pathlib import Path
 from urllib.parse import urljoin
@@ -18,6 +19,9 @@ from reflex.config import get_config
 from reflex.utils import console, path_ops
 from reflex.utils.watch import AssetFolderWatch
 
+# For uvicorn windows bug fix (#2335)
+frontend_process = None
+
 
 def start_watching_assets_folder(root):
     """Start watching assets folder.
@@ -66,6 +70,9 @@ def kill(proc_pid: int):
     process.kill()
 
 
+# run_process_and_launch_url is assumed to be used
+# only to launch the frontend
+# If this is not the case, might have to change the logic
 def run_process_and_launch_url(run_command: list[str]):
     """Run the process and launch the URL.
 
@@ -81,9 +88,17 @@ def run_process_and_launch_url(run_command: list[str]):
 
     while True:
         if process is None:
+            kwargs = {}
+            if constants.IS_WINDOWS:
+                kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
             process = processes.new_process(
-                run_command, cwd=constants.Dirs.WEB, shell=constants.IS_WINDOWS
+                run_command,
+                cwd=constants.Dirs.WEB,
+                shell=constants.IS_WINDOWS,
+                **kwargs,
             )
+            global frontend_process
+            frontend_process = process
         if process.stdout:
             for line in processes.stream_logs("Starting frontend", process):
                 match = re.search(constants.Next.FRONTEND_LISTENING_REGEX, line)
@@ -175,6 +190,7 @@ def run_backend(
         log_level=loglevel.value,
         reload=True,
         reload_dirs=[config.app_name],
+        reload_excludes=[constants.Dirs.WEB],
     )
 
 

reflex/utils/export.py

@@ -46,9 +46,6 @@ def export(
     # Show system info
     exec.output_system_info()
 
-    # Check that the app is initialized.
-    prerequisites.check_initialized(frontend=frontend)
-
     # Compile the app in production mode and export it.
     console.rule("[bold]Compiling production app and preparing for export.")
 

reflex/utils/prerequisites.py

@@ -10,6 +10,7 @@ import os
 import platform
 import random
 import re
+import shutil
 import stat
 import sys
 import tempfile
@@ -30,6 +31,7 @@ from redis.asyncio import Redis
 
 import reflex
 from reflex import constants, model
+from reflex.base import Base
 from reflex.compiler import templates
 from reflex.config import Config, get_config
 from reflex.utils import console, path_ops, processes
@@ -37,6 +39,15 @@ from reflex.utils import console, path_ops, processes
 CURRENTLY_INSTALLING_NODE = False
 
 
+class Template(Base):
+    """A template for a Reflex app."""
+
+    name: str
+    description: str
+    code_url: str
+    demo_url: str
+
+
 def check_latest_package_version(package_name: str):
     """Check if the latest version of the package is installed.
 
@@ -407,17 +418,42 @@ def initialize_requirements_txt():
         console.info(f"Unable to check {fp} for reflex dependency.")
 
 
-def initialize_app_directory(app_name: str, template: constants.Templates.Kind):
+def initialize_app_directory(
+    app_name: str,
+    template_name: str = constants.Templates.DEFAULT,
+    template_code_dir_name: str | None = None,
+    template_dir: Path | None = None,
+):
     """Initialize the app directory on reflex init.
 
     Args:
         app_name: The name of the app.
-        template: The template to use.
+        template_name: The name of the template to use.
+        template_code_dir_name: The name of the code directory in the template.
+        template_dir: The directory of the template source files.
+
+    Raises:
+        Exit: If template_name, template_code_dir_name, template_dir combination is not supported.
     """
     console.log("Initializing the app directory.")
 
-    # Copy the template to the current directory.
-    template_dir = Path(constants.Templates.Dirs.BASE, "apps", template.value)
+    # By default, use the blank template from local assets.
+    if template_name == constants.Templates.DEFAULT:
+        if template_code_dir_name is not None or template_dir is not None:
+            console.error(
+                f"Only {template_name=} should be provided, got {template_code_dir_name=}, {template_dir=}."
+            )
+            raise typer.Exit(1)
+        template_code_dir_name = constants.Templates.Dirs.CODE
+        template_dir = Path(constants.Templates.Dirs.BASE, "apps", template_name)
+    else:
+        if template_code_dir_name is None or template_dir is None:
+            console.error(
+                f"For `{template_name}` template, `template_code_dir_name` and `template_dir` should both be provided."
+            )
+            raise typer.Exit(1)
+
+    console.debug(f"Using {template_name=} {template_dir=} {template_code_dir_name=}.")
 
     # Remove all pyc and __pycache__ dirs in template directory.
     for pyc_file in template_dir.glob("**/*.pyc"):
@@ -430,16 +466,16 @@ def initialize_app_directory(app_name: str, template: constants.Templates.Kind):
         path_ops.cp(str(file), file.name)
 
     # Rename the template app to the app name.
-    path_ops.mv(constants.Templates.Dirs.CODE, app_name)
+    path_ops.mv(template_code_dir_name, app_name)
     path_ops.mv(
-        os.path.join(app_name, template_dir.name + constants.Ext.PY),
+        os.path.join(app_name, template_name + constants.Ext.PY),
         os.path.join(app_name, app_name + constants.Ext.PY),
     )
 
     # Fix up the imports.
     path_ops.find_replace(
         app_name,
-        f"from {constants.Templates.Dirs.CODE}",
+        f"from {template_name}",
         f"from {app_name}",
     )
 
@@ -802,43 +838,42 @@ def install_frontend_packages(packages: set[str], config: Config):
         )
 
 
-def check_initialized(frontend: bool = True):
-    """Check that the app is initialized.
+def needs_reinit(frontend: bool = True) -> bool:
+    """Check if an app needs to be reinitialized.
 
     Args:
         frontend: Whether to check if the frontend is initialized.
 
+    Returns:
+        Whether the app needs to be reinitialized.
+
     Raises:
         Exit: If the app is not initialized.
     """
-    has_config = os.path.exists(constants.Config.FILE)
-    has_reflex_dir = not frontend or os.path.exists(constants.Reflex.DIR)
-    has_web_dir = not frontend or os.path.exists(constants.Dirs.WEB)
-
-    # Check if the app is initialized.
-    if not (has_config and has_reflex_dir and has_web_dir):
+    if not os.path.exists(constants.Config.FILE):
         console.error(
-            f"The app is not initialized. Run [bold]{constants.Reflex.MODULE_NAME} init[/bold] first."
+            f"[cyan]{constants.Config.FILE}[/cyan] not found. Move to the root folder of your project, or run [bold]{constants.Reflex.MODULE_NAME} init[/bold] to start a new project."
         )
         raise typer.Exit(1)
 
-    # Check that the template is up to date.
-    if frontend and not is_latest_template():
-        console.error(
-            "The base app template has updated. Run [bold]reflex init[/bold] again."
-        )
-        raise typer.Exit(1)
+    # Don't need to reinit if not running in frontend mode.
+    if not frontend:
+        return False
+
+    # Make sure the .reflex directory exists.
+    if not os.path.exists(constants.Reflex.DIR):
+        return True
+
+    # Make sure the .web directory exists in frontend mode.
+    if not os.path.exists(constants.Dirs.WEB):
+        return True
 
-    # Print a warning for Windows users.
     if constants.IS_WINDOWS:
         console.warn(
             """Windows Subsystem for Linux (WSL) is recommended for improving initial install times."""
         )
-        if sys.version_info >= (3, 12):
-            console.warn(
-                "Python 3.12 on Windows has known issues with hot reload (reflex-dev/reflex#2335). "
-                "Python 3.11 is recommended with this release of Reflex."
-            )
+    # No need to reinitialize if the app is already initialized.
+    return False
 
 
 def is_latest_template() -> bool:
@@ -1004,33 +1039,35 @@ def check_schema_up_to_date():
                 )
 
 
-def prompt_for_template() -> constants.Templates.Kind:
+def prompt_for_template(templates: list[Template]) -> str:
     """Prompt the user to specify a template.
 
+    Args:
+        templates: The templates to choose from.
+
     Returns:
-        The template the user selected.
+        The template name the user selects.
     """
-    # Show the user the URLs of each temlate to preview.
+    # Show the user the URLs of each template to preview.
     console.print("\nGet started with a template:")
-    console.print("blank (https://blank-template.reflex.run) - A minimal template.")
-    console.print(
-        "sidebar (https://sidebar-template.reflex.run) - A template with a sidebar to navigate pages."
-    )
-    console.print("")
 
     # Prompt the user to select a template.
+    id_to_name = {
+        str(idx): f"{template.name} ({template.demo_url}) - {template.description}"
+        for idx, template in enumerate(templates)
+    }
+    for id in range(len(id_to_name)):
+        console.print(f"({id}) {id_to_name[str(id)]}")
+
     template = console.ask(
         "Which template would you like to use?",
-        choices=[
-            template.value
-            for template in constants.Templates.Kind
-            if template.value != "demo"
-        ],
-        default=constants.Templates.Kind.BLANK.value,
+        choices=[str(i) for i in range(len(id_to_name))],
+        show_choices=False,
+        default="0",
     )
 
     # Return the template.
-    return constants.Templates.Kind(template)
+    return templates[int(template)].name
 
 
 def should_show_rx_chakra_migration_instructions() -> bool:
@@ -1183,3 +1220,166 @@ def migrate_to_reflex():
                 for old, new in updates.items():
                     line = line.replace(old, new)
                 print(line, end="")
+
+
+def fetch_app_templates() -> dict[str, Template]:
+    """Fetch the list of app templates from the Reflex backend server.
+
+    Returns:
+        The name and download URL as a dictionary.
+    """
+    config = get_config()
+    if not config.cp_backend_url:
+        console.info(
+            "Skip fetching App templates. No backend URL is specified in the config."
+        )
+        return {}
+    try:
+        response = httpx.get(
+            f"{config.cp_backend_url}{constants.Templates.APP_TEMPLATES_ROUTE}"
+        )
+        response.raise_for_status()
+        return {
+            template["name"]: Template.parse_obj(template)
+            for template in response.json()
+        }
+    except httpx.HTTPError as ex:
+        console.info(f"Failed to fetch app templates: {ex}")
+        return {}
+    except (TypeError, KeyError, json.JSONDecodeError) as tkje:
+        console.info(f"Unable to process server response for app templates: {tkje}")
+        return {}
+
+
+def create_config_init_app_from_remote_template(
+    app_name: str,
+    template_url: str,
+):
+    """Create new rxconfig and initialize app using a remote template.
+
+    Args:
+        app_name: The name of the app.
+        template_url: The path to the template source code as a zip file.
+
+    Raises:
+        Exit: If any download, file operations fail or unexpected zip file format.
+
+    """
+    # Create a temp directory for the zip download.
+    try:
+        temp_dir = tempfile.mkdtemp()
+    except OSError as ose:
+        console.error(f"Failed to create temp directory for download: {ose}")
+        raise typer.Exit(1) from ose
+
+    # Use httpx GET with redirects to download the zip file.
+    zip_file_path = Path(temp_dir) / "template.zip"
+    try:
+        # Note: following redirects can be risky. We only allow this for reflex built templates at the moment.
+        response = httpx.get(template_url, follow_redirects=True)
+        console.debug(f"Server responded download request: {response}")
+        response.raise_for_status()
+    except httpx.HTTPError as he:
+        console.error(f"Failed to download the template: {he}")
+        raise typer.Exit(1) from he
+    try:
+        with open(zip_file_path, "wb") as f:
+            f.write(response.content)
+            console.debug(f"Downloaded the zip to {zip_file_path}")
+    except OSError as ose:
+        console.error(f"Unable to write the downloaded zip to disk {ose}")
+        raise typer.Exit(1) from ose
+
+    # Create a temp directory for the zip extraction.
+    try:
+        unzip_dir = Path(tempfile.mkdtemp())
+    except OSError as ose:
+        console.error(f"Failed to create temp directory for extracting zip: {ose}")
+        raise typer.Exit(1) from ose
+    try:
+        zipfile.ZipFile(zip_file_path).extractall(path=unzip_dir)
+        # The zip file downloaded from github looks like:
+        # repo-name-branch/**/*, so we need to remove the top level directory.
+        if len(subdirs := os.listdir(unzip_dir)) != 1:
+            console.error(f"Expected one directory in the zip, found {subdirs}")
+            raise typer.Exit(1)
+        template_dir = unzip_dir / subdirs[0]
+        console.debug(f"Template folder is located at {template_dir}")
+    except Exception as uze:
+        console.error(f"Failed to unzip the template: {uze}")
+        raise typer.Exit(1) from uze
+
+    # Move the rxconfig file here first.
+    path_ops.mv(str(template_dir / constants.Config.FILE), constants.Config.FILE)
+    new_config = get_config(reload=True)
+
+    # Get the template app's name from rxconfig in case it is different than
+    # the source code repo name on github.
+    template_name = new_config.app_name
+
+    create_config(app_name)
+    initialize_app_directory(
+        app_name,
+        template_name=template_name,
+        template_code_dir_name=template_name,
+        template_dir=template_dir,
+    )
+
+    #  Clean up the temp directories.
+    shutil.rmtree(temp_dir)
+    shutil.rmtree(unzip_dir)
+
+
+def initialize_app(app_name: str, template: str | None = None):
+    """Initialize the app either from a remote template or a blank app. If the config file exists, it is considered as reinit.
+
+    Args:
+        app_name: The name of the app.
+        template: The name of the template to use.
+
+    Raises:
+        Exit: If template is directly provided in the command flag and is invalid.
+    """
+    # Local imports to avoid circular imports.
+    from reflex.utils import telemetry
+
+    # Check if the app is already initialized.
+    if os.path.exists(constants.Config.FILE):
+        telemetry.send("reinit")
+        return
+
+    # Get the available templates
+    templates: dict[str, Template] = fetch_app_templates()
+
+    # Prompt for a template if not provided.
+    if template is None and len(templates) > 0:
+        template = prompt_for_template(list(templates.values()))
+    elif template is None:
+        template = constants.Templates.DEFAULT
+    assert template is not None
+
+    # If the blank template is selected, create a blank app.
+    if template == constants.Templates.DEFAULT:
+        # Default app creation behavior: a blank app.
+        create_config(app_name)
+        initialize_app_directory(app_name)
+    else:
+        # Fetch App templates from the backend server.
+        console.debug(f"Available templates: {templates}")
+
+        # If user selects a template, it needs to exist.
+        if template in templates:
+            template_url = templates[template].code_url
+        else:
+            # Check if the template is a github repo.
+            if template.startswith("https://github.com"):
+                template_url = f"{template.strip('/')}/archive/main.zip"
+            else:
+                console.error(f"Template `{template}` not found.")
+                raise typer.Exit(1)
+        create_config_init_app_from_remote_template(
+            app_name=app_name,
+            template_url=template_url,
+        )
+
+    telemetry.send("init")

reflex/utils/processes.py

@@ -14,6 +14,7 @@ import psutil
 import typer
 from redis.exceptions import RedisError
 
+from reflex import constants
 from reflex.utils import console, path_ops, prerequisites
 
 
@@ -227,7 +228,11 @@ def stream_logs(message: str, process: subprocess.Popen, progress=None):
             yield line
 
     # Check if the process failed (not printing the logs for SIGINT).
-    if process.returncode not in [0, -2]:
+
+    # Windows uvicorn bug
+    # https://github.com/reflex-dev/reflex/issues/2335
+    accepted_return_codes = [0, -2, 15] if constants.IS_WINDOWS else [0, -2]
+    if process.returncode not in accepted_return_codes:
         console.error(f"{message} failed with exit code {process.returncode}")
         for line in logs:
             console.error(line, end="")

reflex/utils/telemetry.py

@@ -4,7 +4,13 @@ from __future__ import annotations
 
 import multiprocessing
 import platform
-from datetime import datetime
+
+try:
+    from datetime import UTC, datetime
+except ImportError:
+    from datetime import datetime
+
+    UTC = None
 
 import httpx
 import psutil
@@ -99,6 +105,12 @@ def _prepare_event(event: str) -> dict:
         )
         return {}
 
+    if UTC is None:
+        # for python 3.8, 3.9 & 3.10
+        stamp = datetime.utcnow().isoformat()
+    else:
+        # for python 3.11 & 3.12
+        stamp = datetime.now(UTC).isoformat()
     return {
         "api_key": "phc_JoMo0fOyi0GQAooY3UyO9k0hebGkMyFJrrCw1Gt5SGb",
         "event": event,
@@ -111,7 +123,7 @@ def _prepare_event(event: str) -> dict:
             "cpu_count": get_cpu_count(),
             "memory": get_memory(),
         },
-        "timestamp": datetime.utcnow().isoformat(),
+        "timestamp": stamp,
     }
 
 

reflex/utils/types.py

@@ -416,11 +416,12 @@ def validate_literal(key: str, value: Any, expected_type: Type, comp_name: str):
     ):
         allowed_values = expected_type.__args__
         if value not in allowed_values:
-            value_str = ",".join(
+            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
             raise ValueError(
-                f"prop value for {str(key)} of the `{comp_name}` component should be one of the following: {value_str}. Got '{value}' instead"
+                f"prop value for {str(key)} of the `{comp_name}` component should be one of the following: {allowed_value_str}. Got {value_str} instead"
             )
 
 

reflex/vars.py

@@ -1,4 +1,5 @@
 """Define a state var."""
+
 from __future__ import annotations
 
 import contextlib
@@ -21,7 +22,6 @@ from typing import (
     List,
     Literal,
     Optional,
-    Set,
     Tuple,
     Type,
     Union,
@@ -119,7 +119,7 @@ class VarData(Base):
     imports: ImportDict = {}
 
     # Hooks that need to be present in the component to render this var
-    hooks: Set[str] = set()
+    hooks: Dict[str, None] = {}
 
     # Positions of interpolated strings. This is used by the decoder to figure
     # out where the interpolations are and only escape the non-interpolated
@@ -138,7 +138,7 @@ class VarData(Base):
         """
         state = ""
         _imports = {}
-        hooks = set()
+        hooks = {}
         interpolations = []
         for var_data in others:
             if var_data is None:
@@ -182,7 +182,7 @@ class VarData(Base):
         # not part of the vardata itself.
         return (
             self.state == other.state
-            and self.hooks == other.hooks
+            and self.hooks.keys() == other.hooks.keys()
             and imports.collapse_imports(self.imports)
             == imports.collapse_imports(other.imports)
         )
@@ -200,7 +200,7 @@ class VarData(Base):
                 lib: [import_var.dict() for import_var in import_vars]
                 for lib, import_vars in self.imports.items()
             },
-            "hooks": list(self.hooks),
+            "hooks": self.hooks,
         }
 
 
@@ -1659,7 +1659,7 @@ class Var:
             hooks={
                 "const {0} = useContext(StateContexts.{0})".format(
                     format.format_state_name(state_name)
-                )
+                ): None
             },
             imports={
                 f"/{constants.Dirs.CONTEXTS_PATH}": [ImportVar(tag="StateContexts")],

reflex/vars.pyi

@@ -1,4 +1,5 @@
 """ Generated with stubgen from mypy, then manually edited, do not regen."""
+
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -35,7 +36,7 @@ def _extract_var_data(value: Iterable) -> list[VarData | None]: ...
 class VarData(Base):
     state: str
     imports: dict[str, set[ImportVar]]
-    hooks: set[str]
+    hooks: Dict[str, None]
     interpolations: List[Tuple[int, int]]
     @classmethod
     def merge(cls, *others: VarData | None) -> VarData | None: ...

{reflex-0.4.6a3.dist-info → reflex-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflex
-Version: 0.4.6a3
+Version: 0.4.7
 Summary: Web apps in pure Python.
 Home-page: https://reflex.dev
 License: Apache-2.0
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: alembic (>=1.11.1,<2.0)
 Requires-Dist: build (>=1.0.3,<2.0)
 Requires-Dist: charset-normalizer (>=3.3.2,<4.0)
@@ -74,6 +75,18 @@ Description-Content-Type: text/markdown
 [English](https://github.com/reflex-dev/reflex/blob/main/README.md) | [简体中文](https://github.com/reflex-dev/reflex/blob/main/docs/zh/zh_cn/README.md) | [繁體中文](https://github.com/reflex-dev/reflex/blob/main/docs/zh/zh_tw/README.md) | [Türkçe](https://github.com/reflex-dev/reflex/blob/main/docs/tr/README.md) | [हिंदी](https://github.com/reflex-dev/reflex/blob/main/docs/in/README.md) | [Português (Brasil)](https://github.com/reflex-dev/reflex/blob/main/docs/pt/pt_br/README.md) | [Italiano](https://github.com/reflex-dev/reflex/blob/main/docs/it/README.md) | [Español](https://github.com/reflex-dev/reflex/blob/main/docs/es/README.md) | [한국어](https://github.com/reflex-dev/reflex/blob/main/docs/kr/README.md)
 
 ---
+
+# Reflex
+
+Reflex is a library to build full-stack web apps in pure Python.
+
+Key features:
+* **Pure Python** - Write your app's frontend and backend all in Python, no need to learn Javascript.
+* **Full Flexibility** - Reflex is easy to get started with, but can also scale to complex apps.
+* **Deploy Instantly** - After building, deploy your app with a [single command](https://reflex.dev/docs/hosting/deploy-quick-start/) or host it on your own server.
+
+See our [architecture page](https://reflex.dev/blog/2024-03-21-reflex-architecture/#the-reflex-architecture) to learn how Reflex works under the hood.
+
 ## ⚙️ Installation
 
 Open a terminal and run (Requires Python 3.8+):
@@ -263,19 +276,11 @@ You can create a multi-page app by adding more pages.
 </div>
 
 
-
-
-
 ## ✅ Status
 
 Reflex launched in December 2022 with the name Pynecone.
 
-As of July 2023, we are in the **Public Beta** stage.
-
--   :white_check_mark: **Public Alpha**: Anyone can install and use Reflex. There may be issues, but we are working to resolve them actively.
--   :large_orange_diamond: **Public Beta**: Stable enough for non-enterprise use-cases.
--   **Public Hosting Beta**: _Optionally_, deploy and host your apps on Reflex!
--   **Public**: Reflex is production ready.
+As of February 2024, our hosting service is in alpha! During this time anyone can deploy their apps for free. See our [roadmap](https://github.com/reflex-dev/reflex/issues/2727) to see what's planned.
 
 Reflex has new releases and features coming every week! Make sure to :star: star and :eyes: watch this repository to stay up to date.