tinybird 0.0.1.dev34__py3-none-any.whl → 0.0.1.dev36__py3-none-any.whl

tinybird/tb/modules/datasource.py

@@ -5,39 +5,22 @@
 
 import asyncio
 import json
-import logging
 import re
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Optional
 
 import click
 import humanfriendly
 from click import Context
 
-from tinybird.client import AuthNoTokenException, CanNotBeDeletedException, DoesNotExistException, TinyB
-from tinybird.config import get_display_host
-from tinybird.tb.modules.config import CLIConfig
-
-if TYPE_CHECKING:
-    from tinybird.connectors import Connector
-
+from tinybird.client import AuthNoTokenException, DoesNotExistException, TinyB
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import (
     _analyze,
-    _generate_datafile,
-    ask_for_user_token,
-    autocomplete_topics,
-    check_user_token,
     coro,
     echo_safe_humanfriendly_tables_format_smart_table,
     get_format_from_filename_or_url,
     load_connector_config,
     push_data,
-    sync_data,
-    validate_datasource_name,
-    validate_kafka_auto_offset_reset,
-    validate_kafka_group,
-    validate_kafka_topic,
-    wait_job,
 )
 from tinybird.tb.modules.datafile.common import get_name_version
 from tinybird.tb.modules.exceptions import CLIDatasourceException
@@ -66,7 +49,7 @@ async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
 
     client: TinyB = ctx.ensure_object(dict)["client"]
     ds = await client.datasources()
-    columns = ["version", "shared from", "name", "row_count", "size", "created at", "updated at", "connection"]
+    columns = ["shared from", "name", "row_count", "size", "created at", "updated at", "connection"]
     table_human_readable = []
     table_machine_readable = []
     pattern = re.compile(match) if match else None
@@ -89,7 +72,6 @@ async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
 
         table_human_readable.append(
             (
-                tk["version"] if tk["version"] is not None else "",
                 shared_from,
                 name,
                 humanfriendly.format_number(stats.get("row_count")) if stats.get("row_count", None) else "-",
@@ -101,7 +83,6 @@ async def datasource_ls(ctx: Context, match: Optional[str], format_: str):
         )
         table_machine_readable.append(
             {
-                "version": tk["version"] if tk["version"] is not None else "",
                 "shared from": shared_from,
                 "name": name,
                 "row_count": stats.get("row_count", None) or "-",
@@ -249,62 +230,6 @@ async def datasource_analyze(ctx, url_or_file, connector):
         _table("dialect", ("name", "value"), values)
 
 
-@datasource.command(name="rm")
-@click.argument("datasource_name")
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.pass_context
-@coro
-async def datasource_delete(ctx: Context, datasource_name: str, yes: bool):
-    """Delete a data source"""
-    client: TinyB = ctx.ensure_object(dict)["client"]
-    try:
-        datasource = await client.get_datasource(datasource_name)
-    except AuthNoTokenException:
-        raise
-    except DoesNotExistException:
-        raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
-    except Exception as e:
-        raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
-    connector = datasource.get("service", False)
-
-    if connector:
-        click.echo(FeedbackManager.warning_datasource_is_connected(datasource=datasource_name, connector=connector))
-
-    try:
-        response = await client.datasource_delete(datasource_name, dry_run=True)
-        dependencies_information = f'The Data Source is used in => Pipes="{response["dependent_pipes"]}", nodes="{response["dependent_pipes"]}"'
-        dependencies_information = (
-            dependencies_information if response["dependent_pipes"] else "The Data Source is not used in any Pipe"
-        )
-        warning_message = f"\nDo you want to delete {datasource_name}? Once deleted, it can't be recovered."
-    except CanNotBeDeletedException as e:
-        if "downstream" not in str(e):
-            dependencies_information = str(e)
-            warning_message = f"\nDo you want to unlink and delete {datasource_name}? This action can't be undone."
-        else:
-            raise CLIDatasourceException(
-                FeedbackManager.error_datasource_can_not_be_deleted(datasource=datasource_name, error=e)
-            )
-
-    if yes or click.confirm(
-        FeedbackManager.warning_confirm_delete_datasource(
-            warning_message=warning_message, dependencies_information=dependencies_information
-        )
-    ):
-        try:
-            await client.datasource_delete(datasource_name, force=True)
-        except DoesNotExistException:
-            raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
-        except CanNotBeDeletedException as e:
-            raise CLIDatasourceException(
-                FeedbackManager.error_datasource_can_not_be_deleted(datasource=datasource_name, error=e)
-            )
-        except Exception as e:
-            raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
-
-        click.echo(FeedbackManager.success_delete_datasource(datasource=datasource_name))
-
-
 @datasource.command(name="truncate")
 @click.argument("datasource_name", required=True)
 @click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
@@ -433,396 +358,3 @@ async def datasource_delete_rows(ctx, datasource_name, sql_condition, yes, wait,
             raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
         except Exception as e:
             raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
-
-
-@datasource.command(
-    name="generate",
-    short_help="Generates a .datasource file based on a sample CSV, NDJSON or Parquet file from local disk or url",
-)
-@click.argument("filenames", nargs=-1, default=None)
-@click.option("--force", is_flag=True, default=False, help="Override existing files")
-@click.option(
-    "--connector",
-    type=click.Choice(["bigquery", "snowflake"], case_sensitive=True),
-    help="Use from one of the selected connectors. In this case pass a table name as a parameter instead of a file name",
-    hidden=True,
-)
-@click.pass_context
-@coro
-async def generate_datasource(ctx: Context, connector: str, filenames, force: bool):
-    """Generate a data source file based on a sample CSV file from local disk or url"""
-    client: TinyB = ctx.ensure_object(dict)["client"]
-
-    _connector: Optional[Connector] = None
-    if connector:
-        load_connector_config(ctx, connector, False, check_uninstalled=False)
-        if connector not in ctx.ensure_object(dict):
-            raise CLIDatasourceException(FeedbackManager.error_connector_not_configured(connector=connector))
-        else:
-            _connector = ctx.ensure_object(dict)[connector]
-
-    for filename in filenames:
-        await _generate_datafile(
-            filename, client, force=force, format=get_format_from_filename_or_url(filename), connector=_connector
-        )
-
-
-@datasource.command(name="connect")
-@click.argument("connection")
-@click.argument("datasource_name")
-@click.option("--kafka-topic", "topic", help="For Kafka connections: topic", shell_complete=autocomplete_topics)
-@click.option("--topic", "topic", hidden=True)
-@click.option("--kafka-group", "group", help="For Kafka connections: group ID")
-@click.option("--group", "group", hidden=True)
-@click.option(
-    "--kafka-auto-offset-reset",
-    "auto_offset_reset",
-    default=None,
-    type=click.Choice(["latest", "earliest"], case_sensitive=False),
-    help='Kafka auto.offset.reset config. Valid values are: ["latest", "earliest"]',
-)
-@click.option("--auto-offset-reset", "auto_offset_reset", hidden=True)
-@click.pass_context
-@coro
-# Example usage: tb datasource connect 776824da-ac64-4de4-b8b8-b909f69d5ed5 new_ds --topic a --group b --auto-offset-reset latest
-async def datasource_connect(ctx, connection, datasource_name, topic, group, auto_offset_reset):
-    """Create a new datasource from an existing connection"""
-
-    validate_datasource_name(datasource_name)
-
-    client: TinyB = ctx.obj["client"]
-
-    connector = await client.get_connector(connection, key="name") or await client.get_connector(connection, key="id")
-    if not connector:
-        raise CLIDatasourceException(FeedbackManager.error_connection_does_not_exists(connection=connection))
-
-    service: str = connector.get("service", "")
-    if service == "kafka":
-        topic and validate_kafka_topic(topic)
-        group and validate_kafka_group(group)
-        auto_offset_reset and validate_kafka_auto_offset_reset(auto_offset_reset)
-
-        if not topic:
-            try:
-                topics = await client.kafka_list_topics(connection)
-                click.echo("We've discovered the following topics:")
-                for t in topics:
-                    click.echo(f"    {t}")
-            except Exception as e:
-                logging.debug(f"Error listing topics: {e}")
-            topic = click.prompt("Kafka topic")
-            validate_kafka_topic(topic)
-        if not group:
-            group = click.prompt("Kafka group")
-            validate_kafka_group(group)
-        if not auto_offset_reset:
-            click.echo("Kafka doesn't seem to have prior commits on this topic and group ID")
-            click.echo("Setting auto.offset.reset is required. Valid values:")
-            click.echo("  latest          Skip earlier messages and ingest only new messages")
-            click.echo("  earliest        Start ingestion from the first message")
-            auto_offset_reset = click.prompt("Kafka auto.offset.reset config")
-            validate_kafka_auto_offset_reset(auto_offset_reset)
-            if not click.confirm("Proceed?"):
-                return
-        resp = await client.datasource_kafka_connect(connection, datasource_name, topic, group, auto_offset_reset)
-        datasource_id = resp["datasource"]["id"]
-        click.echo(FeedbackManager.success_datasource_kafka_connected(id=datasource_id))
-    else:
-        raise CLIDatasourceException(FeedbackManager.error_unknown_connection_service(service=service))
-
-
-@datasource.command(name="share")
-@click.argument("datasource_name")
-@click.argument("workspace_name_or_id")
-@click.option("--user_token", default=None, help="When passed, we won't prompt asking for it")
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.pass_context
-@coro
-async def datasource_share(ctx: Context, datasource_name: str, workspace_name_or_id: str, user_token: str, yes: bool):
-    """Share a datasource"""
-
-    config = CLIConfig.get_project_config()
-    client: TinyB = ctx.ensure_object(dict)["client"]
-    host = config.get_host() or CLIConfig.DEFAULTS["host"]
-    ui_host = get_display_host(host)
-
-    _datasource: Dict[str, Any] = {}
-    try:
-        _datasource = await client.get_datasource(datasource_name)
-    except AuthNoTokenException:
-        raise
-    except DoesNotExistException:
-        raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
-    except Exception as e:
-        raise CLIDatasourceException(FeedbackManager.error_exception(error=str(e)))
-
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces()).get("workspaces", [])
-    destination_workspace = next(
-        (
-            workspace
-            for workspace in workspaces
-            if workspace["name"] == workspace_name_or_id or workspace["id"] == workspace_name_or_id
-        ),
-        None,
-    )
-    current_workspace = next((workspace for workspace in workspaces if workspace["id"] == config["id"]), None)
-
-    if not destination_workspace:
-        raise CLIDatasourceException(FeedbackManager.error_workspace(workspace=workspace_name_or_id))
-
-    if not current_workspace:
-        raise CLIDatasourceException(FeedbackManager.error_not_authenticated())
-
-    if not user_token:
-        user_token = ask_for_user_token("share a Data Source", ui_host)
-    await check_user_token(ctx, user_token)
-
-    client.token = user_token
-
-    if yes or click.confirm(
-        FeedbackManager.warning_datasource_share(
-            datasource=datasource_name,
-            source_workspace=current_workspace.get("name"),
-            destination_workspace=destination_workspace["name"],
-        )
-    ):
-        try:
-            await client.datasource_share(
-                datasource_id=_datasource.get("id", ""),
-                current_workspace_id=current_workspace.get("id", ""),
-                destination_workspace_id=destination_workspace.get("id", ""),
-            )
-            click.echo(
-                FeedbackManager.success_datasource_shared(
-                    datasource=datasource_name, workspace=destination_workspace["name"]
-                )
-            )
-        except Exception as e:
-            raise CLIDatasourceException(FeedbackManager.error_exception(error=str(e)))
-
-
-@datasource.command(name="unshare")
-@click.argument("datasource_name")
-@click.argument("workspace_name_or_id")
-@click.option("--user_token", default=None, help="When passed, we won't prompt asking for it")
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.pass_context
-@coro
-async def datasource_unshare(ctx: Context, datasource_name: str, workspace_name_or_id: str, user_token: str, yes: bool):
-    """Unshare a datasource"""
-
-    config = CLIConfig.get_project_config()
-    client = config.get_client()
-    host = config.get_host() or CLIConfig.DEFAULTS["host"]
-    ui_host = get_display_host(host)
-
-    _datasource: Dict[str, Any] = {}
-    try:
-        _datasource = await client.get_datasource(datasource_name)
-    except AuthNoTokenException:
-        raise
-    except DoesNotExistException:
-        raise CLIDatasourceException(FeedbackManager.error_datasource_does_not_exist(datasource=datasource_name))
-    except Exception as e:
-        raise CLIDatasourceException(FeedbackManager.error_exception(error=str(e)))
-
-    workspaces: List[Dict[str, Any]] = (await client.user_workspaces()).get("workspaces", [])
-    destination_workspace = next(
-        (
-            workspace
-            for workspace in workspaces
-            if workspace["name"] == workspace_name_or_id or workspace["id"] == workspace_name_or_id
-        ),
-        None,
-    )
-    current_workspace = next((workspace for workspace in workspaces if workspace["id"] == config["id"]), None)
-
-    if not destination_workspace:
-        raise CLIDatasourceException(FeedbackManager.error_workspace(workspace=workspace_name_or_id))
-
-    if not current_workspace:
-        raise CLIDatasourceException(FeedbackManager.error_not_authenticated())
-
-    if not user_token:
-        user_token = ask_for_user_token("unshare a Data Source", ui_host)
-    await check_user_token(ctx, user_token)
-
-    client.token = user_token
-
-    if yes or click.confirm(
-        FeedbackManager.warning_datasource_unshare(
-            datasource=datasource_name,
-            source_workspace=current_workspace.get("name"),
-            destination_workspace=destination_workspace["name"],
-        )
-    ):
-        try:
-            await client.datasource_unshare(
-                datasource_id=_datasource.get("id", ""),
-                current_workspace_id=current_workspace.get("id", ""),
-                destination_workspace_id=destination_workspace.get("id", ""),
-            )
-            click.echo(
-                FeedbackManager.success_datasource_unshared(
-                    datasource=datasource_name, workspace=destination_workspace["name"]
-                )
-            )
-        except Exception as e:
-            raise CLIDatasourceException(FeedbackManager.error_exception(error=str(e)))
-
-
-@datasource.command(name="sync")
-@click.argument("datasource_name")
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.pass_context
-@coro
-async def datasource_sync(ctx, datasource_name: str, yes: bool):
-    """Sync from connector defined in .datasource file"""
-
-    try:
-        await sync_data(ctx, datasource_name, yes)
-    except AuthNoTokenException:
-        raise
-    except Exception as e:
-        raise CLIDatasourceException(FeedbackManager.error_syncing_datasource(datasource=datasource_name, error=str(e)))
-
-
-@datasource.command(name="exchange", hidden=True)
-@click.argument("datasource_a", required=True)
-@click.argument("datasource_b", required=True)
-@click.option("--yes", is_flag=True, default=False, help="Do not ask for confirmation")
-@click.pass_context
-@coro
-async def datasource_exchange(ctx, datasource_a: str, datasource_b: str, yes: bool):
-    """Exchange two data sources"""
-
-    client = ctx.obj["client"]
-
-    try:
-        if yes or click.confirm(FeedbackManager.warning_exchange(datasource_a=datasource_a, datasource_b=datasource_b)):
-            await client.datasource_exchange(datasource_a, datasource_b)
-    except Exception as e:
-        raise CLIDatasourceException(FeedbackManager.error_exception(error=e))
-
-    click.echo(FeedbackManager.success_exchange_datasources(datasource_a=datasource_a, datasource_b=datasource_b))
-
-
-@datasource.command(name="copy")
-@click.argument("datasource_name")
-@click.option(
-    "--sql",
-    default=None,
-    help="Freeform SQL query to select what is copied from Main into the Branch Data Source",
-    required=False,
-)
-@click.option(
-    "--sql-from-main",
-    is_flag=True,
-    default=False,
-    help="SQL query selecting * from the same Data Source in Main",
-    required=False,
-)
-@click.option("--wait", is_flag=True, default=False, help="Wait for copy job to finish, disabled by default")
-@click.pass_context
-@coro
-async def datasource_copy_from_main(
-    ctx: Context, datasource_name: str, sql: str, sql_from_main: bool, wait: bool
-) -> None:
-    """Copy data source from Main."""
-
-    client: TinyB = ctx.ensure_object(dict)["client"]
-
-    if sql and sql_from_main:
-        click.echo(FeedbackManager.error_exception(error="Use --sql or --sql-from-main but not both"))
-        return
-
-    if not sql and not sql_from_main:
-        click.echo(FeedbackManager.error_exception(error="Use --sql or --sql-from-main"))
-        return
-
-    response = await client.datasource_query_copy(
-        datasource_name, sql if sql else f"SELECT * FROM main.{datasource_name}"
-    )
-    if "job" not in response:
-        raise Exception(response)
-    job_id = response["job"]["job_id"]
-    job_url = response["job"]["job_url"]
-    if sql:
-        click.echo(FeedbackManager.info_copy_with_sql_job_url(sql=sql, datasource_name=datasource_name, url=job_url))
-    else:
-        click.echo(FeedbackManager.info_copy_from_main_job_url(datasource_name=datasource_name, url=job_url))
-    if wait:
-        base_msg = "Copy from Main Workspace" if sql_from_main else f"Copy from {sql}"
-        await wait_job(client, job_id, job_url, f"{base_msg} to {datasource_name}")
-
-
-@datasource.group(name="scheduling")
-@click.pass_context
-def datasource_scheduling(ctx: Context) -> None:
-    """Data Source scheduling commands."""
-
-
-@datasource_scheduling.command(name="state")
-@click.argument("datasource_name")
-@click.pass_context
-@coro
-async def datasource_scheduling_state(ctx: Context, datasource_name: str) -> None:
-    """Get the scheduling state of a Data Source."""
-    client: TinyB = ctx.obj["client"]
-    try:
-        await client.get_datasource(datasource_name)  # Check if datasource exists
-        state = await client.datasource_scheduling_state(datasource_name)
-        click.echo(FeedbackManager.info_datasource_scheduling_state(datasource=datasource_name, state=state))
-
-    except AuthNoTokenException:
-        raise
-    except Exception as e:
-        raise CLIDatasourceException(
-            FeedbackManager.error_datasource_scheduling_state(datasource=datasource_name, error=e)
-        )
-
-
-@datasource_scheduling.command(name="pause")
-@click.argument("datasource_name")
-@click.pass_context
-@coro
-async def datasource_scheduling_pause(ctx: Context, datasource_name: str) -> None:
-    """Pause the scheduling of a Data Source."""
-
-    click.echo(FeedbackManager.info_datasource_scheduling_pause())
-    client: TinyB = ctx.ensure_object(dict)["client"]
-
-    try:
-        await client.get_datasource(datasource_name)  # Check if datasource exists
-        await client.datasource_scheduling_pause(datasource_name)
-        click.echo(FeedbackManager.success_datasource_scheduling_paused(datasource=datasource_name))
-
-    except AuthNoTokenException:
-        raise
-    except Exception as e:
-        raise CLIDatasourceException(
-            FeedbackManager.error_pausing_datasource_scheduling(datasource=datasource_name, error=e)
-        )
-
-
-@datasource_scheduling.command(name="resume")
-@click.argument("datasource_name")
-@click.pass_context
-@coro
-async def datasource_scheduling_resume(ctx: Context, datasource_name: str) -> None:
-    """Resume the scheduling of a Data Source."""
-
-    click.echo(FeedbackManager.info_datasource_scheduling_resume())
-    client: TinyB = ctx.ensure_object(dict)["client"]
-
-    try:
-        await client.get_datasource(datasource_name)  # Check if datasource exists
-        await client.datasource_scheduling_resume(datasource_name)
-        click.echo(FeedbackManager.success_datasource_scheduling_resumed(datasource=datasource_name))
-
-    except AuthNoTokenException:
-        raise
-    except Exception as e:
-        raise CLIDatasourceException(
-            FeedbackManager.error_resuming_datasource_scheduling(datasource=datasource_name, error=e)
-        )

tinybird/tb/modules/{deploy.py → deployment.py}

@@ -2,6 +2,7 @@ import glob
 import json
 import logging
 import time
+from datetime import datetime
 from pathlib import Path
 from typing import List, Optional
 
@@ -105,15 +106,15 @@ def rollback_deployment(host: Optional[str], headers: dict) -> None:
     click.echo(FeedbackManager.success(message="Deployment rolled back successfully"))
 
 
-@cli.group(name="deploy")
-def deploy_group() -> None:
+@cli.group(name="deployment")
+def deployment_group() -> None:
     """
-    Deploy commands.
+    Deployment commands.
     """
     pass
 
 
-@deploy_group.command(name="create")
+@deployment_group.command(name="create")
 @click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
 @click.option(
     "--wait/--no-wait",
@@ -192,6 +193,9 @@ def create(ctx: click.Context, project_path: Path, wait: bool, auto: bool) -> No
             deployment = result.get("deployment")
             if deployment.get("status") == "failed":
                 click.echo(FeedbackManager.error(message="Deployment failed"))
+                if auto:
+                    click.echo(FeedbackManager.error(message="Rolling back deployment"))
+                    rollback_deployment(client.host, HEADERS)
                 return
 
         click.echo(FeedbackManager.success(message="Deployment is ready"))
@@ -200,10 +204,10 @@ def create(ctx: click.Context, project_path: Path, wait: bool, auto: bool) -> No
             promote_deployment(client.host, HEADERS)
 
 
-@deploy_group.command(name="list")
+@deployment_group.command(name="ls")
 @click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
 @click.pass_context
-def deploy_list(ctx: click.Context, project_path: Path) -> None:
+def deployment_ls(ctx: click.Context, project_path: Path) -> None:
     """
     List all the deployments you have in the project.
     """
@@ -217,20 +221,26 @@ def deploy_list(ctx: click.Context, project_path: Path) -> None:
     result = r.json()
     logging.debug(json.dumps(result, indent=2))
 
-    columns = ["id", "status", "created_at", "live"]
+    status_map = {"data_ready": "Ready", "failed": "Failed"}
+    columns = ["ID", "Status", "Created at", "Live"]
     table = []
     for deployment in result.get("deployments"):
         table.append(
-            [deployment.get("id"), deployment.get("status"), deployment.get("created_at"), deployment.get("live")]
+            [
+                deployment.get("id"),
+                status_map.get(deployment.get("status"), "In progress"),
+                datetime.fromisoformat(deployment.get("created_at")).strftime("%Y-%m-%d %H:%M:%S"),
+                deployment.get("live"),
+            ]
         )
 
     echo_safe_humanfriendly_tables_format_smart_table(table, column_names=columns)
 
 
-@deploy_group.command(name="promote")
+@deployment_group.command(name="promote")
 @click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
 @click.pass_context
-def deploy_promote(ctx: click.Context, project_path: Path) -> None:
+def deployment_promote(ctx: click.Context, project_path: Path) -> None:
     """
     Promote last deploy to ready and remove old one.
     """
@@ -242,10 +252,10 @@ def deploy_promote(ctx: click.Context, project_path: Path) -> None:
     promote_deployment(client.host, HEADERS)
 
 
-@deploy_group.command(name="rollback")
+@deployment_group.command(name="rollback")
 @click.argument("project_path", type=click.Path(exists=True), default=Path.cwd())
 @click.pass_context
-def deploy_rollback(ctx: click.Context, project_path: Path) -> None:
+def deployment_rollback(ctx: click.Context, project_path: Path) -> None:
     """
     Rollback to the previous deployment.
     """