reflex-hosting-cli 0.1.13__py3-none-any.whl

reflex_cli/deployments.py

@@ -0,0 +1,354 @@
+"""The Hosting CLI deployments sub-commands."""
+
+import asyncio
+import json
+from datetime import datetime
+from typing import Optional, Tuple
+
+import typer
+from tabulate import tabulate
+
+from reflex_cli import constants
+from reflex_cli.utils import console
+
+deployments_cli = typer.Typer()
+
+TIME_FORMAT_HELP = "Accepts ISO 8601 format, unix epoch or time relative to now. For time relative to now, use the format: <d><unit>. Valid units are d (day), h (hour), m (minute), s (second). For example, 1d for 1 day ago from now."
+MIN_LOGS_LIMIT = 50
+MAX_LOGS_LIMIT = 1000
+
+
+@deployments_cli.command(name="list")
+def list_deployments(
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+    as_json: bool = typer.Option(
+        False, "-j", "--json", help="Whether to output the result in json format."
+    ),
+):
+    """List all the hosted deployments of the authenticated user.
+
+    Args:
+        loglevel: The log level to use.
+        as_json: Whether to output the result in json format.
+
+    Raises:
+        Exit: If the command fails.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+    try:
+        deployments = hosting.list_deployments()
+    except Exception as ex:
+        console.error(f"Unable to list deployments")
+        raise typer.Exit(1) from ex
+
+    if as_json:
+        console.print(json.dumps(deployments))
+        return
+    if deployments:
+        headers = list(deployments[0].keys())
+        table = [list(deployment.values()) for deployment in deployments]
+        console.print(tabulate(table, headers=headers))
+    else:
+        # If returned empty list, print the empty
+        console.print(str(deployments))
+
+
+@deployments_cli.command(name="delete")
+def delete_deployment(
+    key: str = typer.Argument(..., help="The name of the deployment."),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+):
+    """Delete a hosted instance.
+
+    Args:
+        key: The name of the deployment.
+        loglevel: The log level to use.
+
+    Raises:
+        Exit: If the command fails.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+
+    try:
+        hosting.delete_deployment(key)
+    except Exception as ex:
+        console.error(f"Unable to delete deployment")
+        raise typer.Exit(1) from ex
+    console.print(f"Successfully deleted [ {key} ].")
+
+
+@deployments_cli.command(name="status")
+def get_deployment_status(
+    key: str = typer.Argument(..., help="The name of the deployment."),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+):
+    """Check the status of a deployment.
+
+    Args:
+        key: The name of the deployment.
+        loglevel: The log level to use.
+
+    Raises:
+        Exit: If the command fails.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+
+    try:
+        console.print(f"Getting status for [ {key} ] ...\n")
+        status = hosting.get_deployment_status(key)
+
+        # TODO: refactor all these tabulate calls
+        status.backend.updated_at = hosting.convert_to_local_time_str(
+            status.backend.updated_at or "N/A"
+        )
+        backend_status = status.backend.dict(exclude_none=True)
+        headers = list(backend_status.keys())
+        table = list(backend_status.values())
+        console.print(tabulate([table], headers=headers))
+        # Add a new line in console
+        console.print("\n")
+        status.frontend.updated_at = hosting.convert_to_local_time_str(
+            status.frontend.updated_at or "N/A"
+        )
+        frontend_status = status.frontend.dict(exclude_none=True)
+        headers = list(frontend_status.keys())
+        table = list(frontend_status.values())
+        console.print(tabulate([table], headers=headers))
+    except Exception as ex:
+        console.error(f"Unable to get deployment status")
+        raise typer.Exit(1) from ex
+
+
+def _process_command_options_timestamps_limit(
+    from_timestamp, to_timestamp, limit
+) -> Tuple[Optional[str], Optional[str], Optional[int]]:
+    """Helper function to process/sanity check the command options for timestamps and limit.
+
+    Args:
+        from_timestamp: The start time of the logs.
+        to_timestamp: The end time of the logs.
+        limit: The maximum number of logs to return.
+
+    Raises:
+        Exit: If the command options format/value is invalid.
+
+    Returns:
+        The processed timestamps and limit.
+    """
+    from reflex_cli.utils import hosting
+
+    command_timestamp = datetime.now().astimezone()
+    if (
+        from_timestamp is not None
+        and (
+            from_timestamp := hosting.process_user_entered_timestamp(
+                from_timestamp, command_timestamp
+            )
+        )
+        is None
+    ):
+        console.error("Unable to process --from timestamp.")
+        raise typer.Exit(1)
+
+    if (
+        to_timestamp is not None
+        and (
+            to_timestamp := hosting.process_user_entered_timestamp(
+                to_timestamp, command_timestamp
+            )
+        )
+        is None
+    ):
+        console.error("Unable to process --to timestamp.")
+        raise typer.Exit(1)
+
+    if limit is not None and not MIN_LOGS_LIMIT <= limit <= MAX_LOGS_LIMIT:
+        console.error(f"Limit must be between {MIN_LOGS_LIMIT} and {MAX_LOGS_LIMIT}.")
+        raise typer.Exit(1)
+
+    return from_timestamp, to_timestamp, limit
+
+
+@deployments_cli.command(name="logs")
+def get_deployment_logs(
+    key: str = typer.Argument(..., help="The name of the deployment."),
+    from_timestamp: Optional[str] = typer.Option(
+        None,
+        "--from",
+        help=f"The start time of the logs. {TIME_FORMAT_HELP}",
+    ),
+    to_timestamp: Optional[str] = typer.Option(
+        None, "--to", help=f"The end time of the logs. {TIME_FORMAT_HELP}"
+    ),
+    limit: Optional[int] = typer.Option(
+        None,
+        "--limit",
+        help=f"The number of logs to return. The acceptable range is {MIN_LOGS_LIMIT}-{MAX_LOGS_LIMIT}.",
+    ),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+):
+    """Get the logs for a deployment.
+
+    Args:
+        key: The name of the deployment.
+        from_timestamp: The start time of the logs.
+        to_timestamp: The end time of the logs.
+        limit: The maximum number of logs to return.
+        loglevel: The log level to use.
+
+    Raises:
+        Exit: If the command fails.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+
+    from_timestamp, to_timestamp, limit = _process_command_options_timestamps_limit(
+        from_timestamp, to_timestamp, limit
+    )
+
+    console.print("Note: there is a few seconds delay for logs to be available.")
+    # This is a case where it is not streaming logs
+    if to_timestamp is not None or limit is not None:
+        hosting.get_logs(
+            key=key,
+            log_type=hosting.LogType.APP_LOG,
+            from_iso_timestamp=from_timestamp,
+            to_iso_timestamp=to_timestamp,
+            limit=limit,
+        )
+    else:
+        try:
+            asyncio.get_event_loop().run_until_complete(
+                hosting.stream_logs(key, from_iso_timestamp=from_timestamp)
+            )
+        except Exception as ex:
+            console.error(f"Unable to get deployment logs")
+            raise typer.Exit(1) from ex
+
+
+@deployments_cli.command(name="build-logs")
+def get_deployment_build_logs(
+    key: str = typer.Argument(..., help="The name of the deployment."),
+    from_timestamp: Optional[str] = typer.Option(
+        None,
+        "--from",
+        help=f"The start time of the logs. {TIME_FORMAT_HELP}",
+    ),
+    to_timestamp: Optional[str] = typer.Option(
+        None, "--to", help=f"The end time of the logs. {TIME_FORMAT_HELP}"
+    ),
+    limit: Optional[int] = typer.Option(
+        None,
+        "--limit",
+        help=f"The number of logs to return. The acceptable range is {MIN_LOGS_LIMIT}-{MAX_LOGS_LIMIT}.",
+    ),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+):
+    """Get the build logs for a deployment.
+
+    Args:
+        key: The name of the deployment.
+        from_timestamp: The start time of the logs.
+        to_timestamp: The end time of the logs.
+        limit: The maximum number of logs to return.
+        loglevel: The log level to use.
+
+    Raises:
+        Exit: If the command fails.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+
+    from_timestamp, to_timestamp, limit = _process_command_options_timestamps_limit(
+        from_timestamp, to_timestamp, limit
+    )
+
+    console.print("Note: there is a few seconds delay for logs to be available.")
+    # This is a case where it is not streaming logs
+    if to_timestamp is not None or limit is not None:
+        hosting.get_logs(
+            key=key,
+            log_type=hosting.LogType.BUILD_LOG,
+            from_iso_timestamp=from_timestamp,
+            to_iso_timestamp=to_timestamp,
+            limit=limit,
+        )
+    else:
+        try:
+            # TODO: we need to find a way not to fetch logs
+            # that match the deployed app name but not previously of a different owner
+            # This should not happen often
+            asyncio.run(hosting.stream_logs(key, log_type=hosting.LogType.BUILD_LOG))
+        except Exception as ex:
+            console.error(f"Unable to get deployment logs")
+            raise typer.Exit(1) from ex
+
+
+@deployments_cli.command(name="regions")
+def get_deployment_regions(
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+    as_json: bool = typer.Option(
+        False, "-j", "--json", help="Whether to output the result in json format."
+    ),
+):
+    """List all the regions of the hosting service.
+
+    Args:
+        loglevel: The log level to use.
+        as_json: Whether to output the result in json format.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+
+    list_regions_info = hosting.get_regions()
+    if as_json:
+        console.print(json.dumps(list_regions_info))
+        return
+    if list_regions_info:
+        headers = list(list_regions_info[0].keys())
+        table = [list(deployment.values()) for deployment in list_regions_info]
+        console.print(tabulate(table, headers=headers))
+
+
+@deployments_cli.command(name="share")
+def share_deployment(
+    url: Optional[str] = typer.Option(
+        None,
+        help="The URL of the deployed app to share. If not provided, the latest deployment is shared.",
+    ),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
+):
+    """Share a deployment.
+
+    Args:
+        url: The URL of the deployed app to share.
+        loglevel: The log level to use.
+    """
+    from reflex_cli.utils import hosting
+
+    console.set_log_level(loglevel)
+
+    hosting.collect_deployment_info_interactive(demo_url=url)

reflex_cli/utils/__init__.py

@@ -0,0 +1 @@
+"""Reflex utilities."""

reflex_cli/utils/console.py

@@ -0,0 +1,155 @@
+"""Functions to communicate to the user via console."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
+from rich.prompt import Prompt
+
+from reflex_cli.constants import LogLevel
+
+# Console for pretty printing.
+_console = Console()
+
+# The current log level.
+_LOG_LEVEL = LogLevel.INFO
+
+
+def set_log_level(log_level: LogLevel):
+    """Set the log level.
+
+    Args:
+        log_level: The log level to set.
+    """
+    global _LOG_LEVEL
+    _LOG_LEVEL = log_level
+
+
+def print(msg: str, **kwargs):
+    """Print a message.
+
+    Args:
+        msg: The message to print.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    _console.print(msg, **kwargs)
+
+
+def debug(msg: str, **kwargs):
+    """Print a debug message.
+
+    Args:
+        msg: The debug message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if _LOG_LEVEL <= LogLevel.DEBUG:
+        print(f"[blue]Debug: {msg}[/blue]", **kwargs)
+
+
+def info(msg: str, **kwargs):
+    """Print an info message.
+
+    Args:
+        msg: The info message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if _LOG_LEVEL <= LogLevel.INFO:
+        print(f"[cyan]Info: {msg}[/cyan]", **kwargs)
+
+
+def success(msg: str, **kwargs):
+    """Print a success message.
+
+    Args:
+        msg: The success message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if _LOG_LEVEL <= LogLevel.INFO:
+        print(f"[green]Success: {msg}[/green]", **kwargs)
+
+
+def log(msg: str, **kwargs):
+    """Takes a string and logs it to the console.
+
+    Args:
+        msg: The message to log.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if _LOG_LEVEL <= LogLevel.INFO:
+        _console.log(msg, **kwargs)
+
+
+def rule(title: str, **kwargs):
+    """Prints a horizontal rule with a title.
+
+    Args:
+        title: The title of the rule.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    _console.rule(title, **kwargs)
+
+
+def warn(msg: str, **kwargs):
+    """Print a warning message.
+
+    Args:
+        msg: The warning message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if _LOG_LEVEL <= LogLevel.WARNING:
+        print(f"[orange1]Warning: {msg}[/orange1]", **kwargs)
+
+
+def error(msg: str, **kwargs):
+    """Print an error message.
+
+    Args:
+        msg: The error message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if _LOG_LEVEL <= LogLevel.ERROR:
+        print(f"[red]{msg}[/red]", **kwargs)
+
+
+def ask(
+    question: str, choices: list[str] | None = None, default: str | None = None
+) -> str:
+    """Takes a prompt question and optionally a list of choices
+     and returns the user input.
+
+    Args:
+        question: The question to ask the user.
+        choices: A list of choices to select from.
+        default: The default option selected.
+
+    Returns:
+        A string with the user input.
+    """
+    return Prompt.ask(question, choices=choices, default=default)  # type: ignore
+
+
+def progress():
+    """Create a new progress bar.
+
+
+    Returns:
+        A new progress bar.
+    """
+    return Progress(
+        *Progress.get_default_columns()[:-1],
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+    )
+
+
+def status(*args, **kwargs):
+    """Create a status with a spinner.
+
+    Args:
+        *args: Args to pass to the status.
+        **kwargs: Kwargs to pass to the status.
+
+    Returns:
+        A new status.
+    """
+    return _console.status(*args, **kwargs)

reflex_cli/utils/dependency.py

@@ -0,0 +1,132 @@
+"""Building the app and initializing all prerequisites."""
+
+from __future__ import annotations
+
+import difflib
+import os
+import re
+import subprocess
+import sys
+
+import charset_normalizer
+
+from reflex_cli import constants
+from reflex_cli.utils import console
+
+
+def detect_encoding(filename: str) -> str | None:
+    """Detect the encoding of the given file.
+
+    Args:
+        filename: The file to detect encoding for.
+
+    Raises:
+        FileNotFoundError: If the file `filename` does not exist.
+
+    Returns:
+        The encoding of the file if file exits and encoding is detected, otherwise None.
+    """
+    if not os.path.exists(filename):
+        raise FileNotFoundError
+    # Detect the encoding of the original file
+    charset_matches = charset_normalizer.from_path(filename)
+    maybe_charset_match = charset_matches.best()
+    if maybe_charset_match is None:
+        console.warn(
+            f"Unable to detect encoding of {constants.RequirementsTxt.FILE} to check requirements. Please manually update it if required.."
+        )
+        return None
+    encoding = maybe_charset_match.encoding
+    console.debug(
+        f"Detected encoding for {constants.RequirementsTxt.FILE} as {encoding}."
+    )
+    return encoding
+
+
+def check_requirements():
+    """Check if the requirements.txt needs update based on current environment.
+    Throw warnings if too many installed or unused (based on imports) packages in
+    the local environment.
+    """
+    # First check the encoding of requirements.txt if applicable. If unable to determine encoding
+    # will not proceed to check for requirement updates.
+    encoding = "utf-8"
+    if (
+        os.path.exists(constants.RequirementsTxt.FILE)
+        and (encoding := detect_encoding(constants.RequirementsTxt.FILE)) is None
+    ):
+        return
+
+    # Run the pipdeptree command and get the output
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pipdeptree", "--warn", "silence"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as cpe:
+        console.debug(f"Unable to run pipdeptree util in subprocess: {cpe}")
+        console.warn(
+            "Unable to detect installed packages in your environment. Please make sure your requirements.txt is up to date."
+        )
+        return
+
+    # Filter the output lines using a regular expression
+    lines = result.stdout.split("\n")
+    new_requirements_lines = []
+    for line in lines:
+        if re.match(r"^\w+", line):
+            # Special handling of psycopg2, force the binary version instead
+            if line.startswith("psycopg2=="):
+                line = line.replace("psycopg2==", "psycopg2-binary==")
+            new_requirements_lines.append(f"{line}\n")
+
+    current_requirements_lines = ""
+    if os.path.exists(constants.RequirementsTxt.FILE):
+        with open(constants.RequirementsTxt.FILE, "r", encoding=encoding) as f:
+            current_requirements_lines = list(f)
+            console.debug("Current requirements.txt:")
+            console.debug("".join(current_requirements_lines))
+
+    # Show the differences of current and the newly generated requirements.txt
+    diff_content = "".join(
+        difflib.unified_diff(
+            current_requirements_lines,
+            new_requirements_lines,
+            fromfile="requirements.txt",
+            tofile="new_requirements.txt",
+        )
+    )
+
+    if not diff_content:
+        console.info("No updates required for the requirements.txt.")
+        return
+
+    if not current_requirements_lines:
+        console.info("It seems like there's no requirements.txt in your project.")
+    else:
+        console.info("The requirements.txt may need to be updated.")
+
+    console.print(diff_content)
+
+    user_choice = console.ask(
+        "Would you like to update requirements.txt based on the changes above?",
+        choices=["y", "n"],
+    )
+    if user_choice != "y":
+        console.warn("Please update requirements.txt manually if needed.")
+        # Not exit here since the newly generated requirements.txt is necessarily correct
+        # i.e., user enters `n` to override and proceed to deploy
+        return
+
+    # Write the filtered lines to requirements.txt
+    try:
+        with open(constants.RequirementsTxt.FILE, "w", encoding=encoding) as f:
+            f.writelines(new_requirements_lines)
+            console.info("requirements.txt updated.")
+    except OSError:
+        console.error(
+            f"Unable to write to {constants.RequirementsTxt.FILE}. Please manually update it."
+        )
+        sys.exit(1)