agenta 0.2.12__tar.gz → 0.3.0__tar.gz

{agenta-0.2.12 → agenta-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.2.12
+Version: 0.3.0
 Summary: SDK for Agenta an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering

{agenta-0.2.12 → agenta-0.3.0}/agenta/__init__.py

@@ -1,4 +1,5 @@
 from . import sdk
+from . import config
 from .sdk import post, ingest, app
 from .sdk.types import (
     TextParam,

{agenta-0.2.12 → agenta-0.3.0}/agenta/cli/helper.py

@@ -7,19 +7,20 @@ from agenta.client.api_models import AppVariant
 
 
 def update_variants_from_backend(
-    app_name: str, config: MutableMapping[str, Any], host: str
+    app_id: str, config: MutableMapping[str, Any], host: str
 ) -> MutableMapping[str, Any]:
     """Reads the list of variants from the backend and updates the config accordingly
 
     Arguments:
-        app_name -- the app name
+        app_id -- the app id
         config -- the config loaded using toml.load
 
     Returns:
         a new config object later to be saved using toml.dump(config, config_file.open('w'))
     """
-    variants: List[AppVariant] = client.list_variants(app_name, host)
+    variants: List[AppVariant] = client.list_variants(app_id, host)
     config["variants"] = [variant.variant_name for variant in variants]
+    config["variant_ids"] = [variant.variant_id for variant in variants]
     return config
 
 
@@ -31,10 +32,12 @@ def update_config_from_backend(config_file: Path, host: str):
     """
     assert config_file.exists(), "Config file does not exist!"
     config = toml.load(config_file)
-    app_name = config["app-name"]
+    app_id = config["app_id"]
     if "variants" not in config:
         config["variants"] = []
-    config = update_variants_from_backend(app_name, config, host)
+    if "variant_ids" not in config:
+        config["variant_ids"] = []
+    config = update_variants_from_backend(app_id, config, host)
     toml.dump(config, config_file.open("w"))
 
 

{agenta-0.2.12 → agenta-0.3.0}/agenta/cli/main.py

@@ -7,6 +7,8 @@ from pathlib import Path
 import click
 import questionary
 import toml
+
+from agenta.client import client
 from agenta.cli import variant_commands
 
 
@@ -29,7 +31,7 @@ def check_latest_version() -> Union[str, None]:
     import requests
 
     try:
-        response = requests.get("https://pypi.org/pypi/agenta/json")
+        response = requests.get("https://pypi.org/pypi/agenta/json", timeout=360)
         response.raise_for_status()
         latest_version = response.json()["info"]["version"]
         return latest_version
@@ -103,7 +105,11 @@ def init(app_name: str):
         else "http://" + backend_host
     )
 
-    config = {"app-name": app_name, "backend_host": backend_host}
+    # Get app_id after creating new app in the backend server
+    app_id = client.create_new_app(app_name, backend_host)
+
+    # Set app toml configuration
+    config = {"app_name": app_name, "app_id": app_id, "backend_host": backend_host}
     with open("config.toml", "w") as config_file:
         toml.dump(config, config_file)
 

{agenta-0.2.12 → agenta-0.3.0}/agenta/cli/variant_commands.py

@@ -39,8 +39,11 @@ def add_variant(app_folder: str, file_name: str, host: str) -> str:
     app_path = Path(app_folder)
     config_file = app_path / "config.toml"
     config = toml.load(config_file)
-    app_name = config["app-name"]
-    variant_name = file_name.removesuffix(".py")
+    app_name = config["app_name"]
+    app_id = config["app_id"]
+    base_name = file_name.removesuffix(".py")
+    config_name = "default"
+    variant_name = f"{base_name}.{config_name}"
     # check files in folder
     app_file = app_path / file_name
     if not app_file.exists():
@@ -71,7 +74,7 @@ def add_variant(app_folder: str, file_name: str, host: str) -> str:
             sys.exit(0)
 
     # Validate variant name
-    if not re.match("^[a-zA-Z0-9_]+$", variant_name):
+    if not re.match("^[a-zA-Z0-9_]+$", base_name):
         click.echo(
             click.style(
                 "Invalid input. Please use only alphanumeric characters without spaces.",
@@ -82,6 +85,7 @@ def add_variant(app_folder: str, file_name: str, host: str) -> str:
 
     # update the config file with the variant names from the backend
     overwrite = False
+
     if variant_name in config["variants"]:
         overwrite = questionary.confirm(
             "This variant already exists. Do you want to overwrite it?"
@@ -90,22 +94,22 @@ def add_variant(app_folder: str, file_name: str, host: str) -> str:
             click.echo("Operation cancelled.")
             sys.exit(0)
 
-    if not overwrite:
-        config["variants"].append(variant_name)
     try:
         click.echo(
             click.style(
-                f"Preparing variant {variant_name} into a tar file...", fg="yellow"
+                f"Preparing variant {base_name} into a tar file...",
+                fg="yellow",
             )
         )
         tar_path = build_tar_docker_container(folder=app_path, file_name=file_name)
 
         click.echo(
             click.style(
-                f"Building variant {variant_name} into a docker image...", fg="yellow"
+                f"Building variant {base_name} into a docker image...",
+                fg="yellow",
             )
         )
-        image: Image = client.send_docker_tar(app_name, variant_name, tar_path, host)
+        image: Image = client.send_docker_tar(app_id, base_name, tar_path, host)
         # docker_image: DockerImage = build_and_upload_docker_image(
         #     folder=app_path, app_name=app_name, variant_name=variant_name)
     except Exception as ex:
@@ -115,15 +119,18 @@ def add_variant(app_folder: str, file_name: str, host: str) -> str:
         if overwrite:
             click.echo(
                 click.style(
-                    f"Updating variant {variant_name} to server...", fg="yellow"
+                    f"Updating {base_name} to server...",
+                    fg="yellow",
                 )
             )
-            client.update_variant_image(app_name, variant_name, image, host)
+            variant_id = config["variant_ids"][config["variants"].index(variant_name)]
+            client.update_variant_image(variant_id, image, host)
         else:
-            click.echo(
-                click.style(f"Adding variant {variant_name} to server...", fg="yellow")
-            )
-            client.add_variant_to_server(app_name, variant_name, image, host)
+            click.echo(click.style(f"Adding {variant_name} to server...", fg="yellow"))
+            response = client.add_variant_to_server(app_id, base_name, image, host)
+            variant_id = response["variant_id"]
+            config["variants"].append(variant_name)
+            config["variant_ids"].append(variant_id)
     except Exception as ex:
         if overwrite:
             click.echo(click.style(f"Error while updating variant: {ex}", fg="red"))
@@ -151,10 +158,10 @@ def add_variant(app_folder: str, file_name: str, host: str) -> str:
         # TODO: Improve this stupid design
         return None
     else:
-        return variant_name
+        return variant_id
 
 
-def start_variant(variant_name: str, app_folder: str, host: str):
+def start_variant(variant_id: str, app_folder: str, host: str):
     """
     Starts a container for an existing variant
     Args:
@@ -164,17 +171,18 @@ def start_variant(variant_name: str, app_folder: str, host: str):
     app_folder = Path(app_folder)
     config_file = app_folder / "config.toml"
     config = toml.load(config_file)
-    app_name = config["app-name"]
+    app_name = config["app_name"]
+    app_id = config["app_id"]
 
     if len(config["variants"]) == 0:
         click.echo("No variants found. Please add a variant first.")
         return
 
-    if variant_name:
-        if variant_name not in config["variants"]:
+    if variant_id:
+        if variant_id not in config["variant_ids"]:
             click.echo(
                 click.style(
-                    f"Variant {variant_name} not found in backend. Maybe you removed it in the webUI?",
+                    f"Variant {variant_id} not found in backend. Maybe you removed it in the webUI?",
                     fg="red",
                 )
             )
@@ -183,30 +191,30 @@ def start_variant(variant_name: str, app_folder: str, host: str):
         variant_name = questionary.select(
             "Please choose a variant", choices=config["variants"]
         ).ask()
+        variant_id = config["variant_ids"][config["variants"].index(variant_name)]
 
-    endpoint = client.start_variant(app_name, variant_name, host=host)
+    endpoint = client.start_variant(variant_id=variant_id, host=host)
     click.echo("\n" + click.style("Congratulations! 🎉", bold=True, fg="green"))
     click.echo(
-        click.style(f"Your app has been deployed locally as an API. 🚀", fg="cyan")
-        + click.style(f" You can access it here: ", fg="white")
+        click.style("Your app has been deployed locally as an API. 🚀", fg="cyan")
+        + click.style(" You can access it here: ", fg="white")
         + click.style(f"{endpoint}/", bold=True, fg="yellow")
     )
 
     click.echo(
-        click.style(f"\nRead the API documentation. 📚", fg="cyan")
-        + click.style(f" It's available at: ", fg="white")
+        click.style("\nRead the API documentation. 📚", fg="cyan")
+        + click.style(" It's available at: ", fg="white")
         + click.style(f"{endpoint}/docs", bold=True, fg="yellow")
     )
 
     webui_host = "http://localhost:3000" if host == "localhost" else host
     click.echo(
         click.style(
-            "\nStart experimenting with your app in the playground. 🎮", fg="cyan"
+            "\nStart experimenting with your app in the playground. 🎮",
+            fg="cyan",
         )
         + click.style(" Go to: ", fg="white")
-        + click.style(
-            f"{webui_host}/apps/{app_name}/playground", bold=True, fg="yellow"
-        )
+        + click.style(f"{webui_host}/apps/{app_id}/playground", bold=True, fg="yellow")
         + "\n"
     )
 
@@ -220,7 +228,7 @@ def remove_variant(variant_name: str, app_folder: str, host: str):
     """
     config_file = Path(app_folder) / "config.toml"
     config = toml.load(config_file)
-    app_name = config["app-name"]
+    app_name = config["app_name"]
 
     if variant_name:
         if variant_name not in config["variants"]:
@@ -235,8 +243,9 @@ def remove_variant(variant_name: str, app_folder: str, host: str):
         variant_name = questionary.select(
             "Please choose a variant", choices=config["variants"]
         ).ask()
+    variant_id = config["variant_ids"][config["variants"].index(variant_name)]
     try:
-        client.remove_variant(app_name, variant_name, host)
+        client.remove_variant(variant_id, host)
     except Exception as ex:
         click.echo(
             click.style(
@@ -263,8 +272,9 @@ def list_variants(app_folder: str, host: str):
     """
     config_file = Path(app_folder) / "config.toml"
     config = toml.load(config_file)
-    app_name = config["app-name"]
-    variants: List[AppVariant] = client.list_variants(app_name, host)
+    app_id = config["app_id"]
+    app_name = config["app_name"]
+    variants: List[AppVariant] = client.list_variants(app_id, host)
     if variants:
         for variant in variants:
             helper.display_app_variant(variant)
@@ -313,7 +323,9 @@ def remove_variant_cli(variant_name: str, app_folder: str):
     """Remove an existing variant."""
     config_check(app_folder)
     remove_variant(
-        variant_name=variant_name, app_folder=app_folder, host=get_host(app_folder)
+        variant_name=variant_name,
+        app_folder=app_folder,
+        host=get_host(app_folder),
     )
 
 
@@ -344,17 +356,15 @@ def serve_cli(app_folder: str, file_name: str):
         return
 
     try:
-        variant_name = add_variant(
-            app_folder=app_folder, file_name=file_name, host=host
-        )
+        variant_id = add_variant(app_folder=app_folder, file_name=file_name, host=host)
     except Exception as e:
         click.echo(click.style("Failed to add variant.", fg="red"))
         click.echo(click.style(f"Error message: {str(e)}", fg="red"))
         return
 
-    if variant_name:
+    if variant_id:
         try:
-            start_variant(variant_name=variant_name, app_folder=app_folder, host=host)
+            start_variant(variant_id=variant_id, app_folder=app_folder, host=host)
         except ConnectionError:
             error_msg = "Failed to connect to Agenta backend. Here's how you can solve the issue:\n"
             error_msg += "- First, please ensure that the backend service is running and accessible.\n"

{agenta-0.2.12 → agenta-0.3.0}/agenta/client/api_models.py

@@ -3,12 +3,18 @@ from typing import List, Optional, Dict, Any
 
 
 class AppVariant(BaseModel):
+    app_id: str
     app_name: str
     variant_name: str
+    variant_id: str
     parameters: Optional[Dict[str, Any]]
     previous_variant_name: Optional[str]
 
 
+class Variant(BaseModel):
+    variant_id: str
+
+
 class Image(BaseModel):
     docker_id: str
     tags: str

agenta-0.3.0/agenta/client/client.py

@@ -0,0 +1,253 @@
+import os
+from pathlib import Path
+from typing import List, Optional, Dict
+
+import requests
+from agenta.client.api_models import AppVariant, Image
+from requests.exceptions import RequestException
+
+BACKEND_URL_SUFFIX = os.environ["BACKEND_URL_SUFFIX"]
+
+
+class APIRequestError(Exception):
+    """Exception to be raised when an API request fails."""
+
+
+def get_app_by_name(app_name: str, host: str) -> str:
+    """Get app by its name on the server.
+
+    Args:
+        app_name (str): Name of the app
+        host (str): Hostname of the server
+    """
+
+    response = requests.get(
+        f"{host}/{BACKEND_URL_SUFFIX}/apps/?app_name={app_name}/",
+        timeout=600,
+    )
+    if response.status_code != 200:
+        error_message = response.json()
+        raise APIRequestError(
+            f"Request to get app failed with status code {response.status_code} and error message: {error_message}."
+        )
+    return response.json()["app_id"]
+
+
+def create_new_app(app_name: str, host: str) -> str:
+    """Creates new app on the server.
+
+    Args:
+        app_name (str): Name of the app
+        host (str): Hostname of the server
+    """
+
+    response = requests.post(
+        f"{host}/{BACKEND_URL_SUFFIX}/apps/",
+        json={"app_name": app_name},
+        timeout=600,
+    )
+    if response.status_code != 200:
+        error_message = response.json()
+        raise APIRequestError(
+            f"Request to create new app failed with status code {response.status_code} and error message: {error_message}."
+        )
+    return response.json()["app_id"]
+
+
+def add_variant_to_server(app_id: str, base_name: str, image: Image, host: str) -> Dict:
+    """
+    Adds a variant to the server.
+
+    Args:
+        app_id (str): The ID of the app to add the variant to.
+        variant_name (str): The name of the variant to add.
+        image (Image): The image to use for the variant.
+        host (str): The host URL of the server.
+
+    Returns:
+        dict: The JSON response from the server.
+    Raises:
+        APIRequestError: If the request to the server fails.
+    """
+    variant_name = f"{base_name.lower()}.default"
+    payload = {
+        "variant_name": variant_name,
+        "base_name": base_name.lower(),
+        "config_name": "default",
+        "docker_id": image.docker_id,
+        "tags": image.tags,
+    }
+    response = requests.post(
+        f"{host}/{BACKEND_URL_SUFFIX}/apps/{app_id}/variant/from-image/",
+        json=payload,
+        timeout=600,
+    )
+    if response.status_code != 200:
+        error_message = response.json()
+        raise APIRequestError(
+            f"Request to app_variant endpoint failed with status code {response.status_code} and error message: {error_message}."
+        )
+    return response.json()
+
+
+def start_variant(
+    variant_id: str, host: str, env_vars: Optional[Dict[str, str]] = None
+) -> str:
+    """
+    Starts or stops a container with the given variant and exposes its endpoint.
+
+    Args:
+        variant_id (str): The ID of the variant.
+        host (str): The host URL.
+        env_vars (Optional[Dict[str, str]]): Optional environment variables to inject into the container.
+
+    Returns:
+        str: The endpoint of the container.
+
+    Raises:
+        APIRequestError: If the API request fails.
+    """
+    payload = {}
+    payload["action"] = {"action": "START"}
+    if env_vars:
+        payload["env_vars"] = {"env_vars": env_vars}
+
+    try:
+        response = requests.put(
+            f"{host}/{BACKEND_URL_SUFFIX}/variants/{variant_id}/",
+            json=payload,
+            timeout=600,
+        )
+        if response.status_code == 404:
+            raise APIRequestError(
+                f"404: Variant with ID {variant_id} does not exist on the server."
+            )
+        elif response.status_code != 200:
+            error_message = response.text
+            raise APIRequestError(
+                f"Request to start variant endpoint failed with status code {response.status_code} and error message: {error_message}."
+            )
+        return response.json().get("uri", "")
+
+    except RequestException as e:
+        raise APIRequestError(f"An error occurred while making the request: {e}")
+
+
+def list_variants(app_id: str, host: str) -> List[AppVariant]:
+    """
+    Returns a list of AppVariant objects for a given app_id and host.
+
+    Args:
+        app_id (str): The ID of the app to retrieve variants for.
+        host (str): The URL of the host to make the request to.
+
+    Returns:
+        List[AppVariant]: A list of AppVariant objects for the given app_id and host.
+    """
+    response = requests.get(
+        f"{host}/{BACKEND_URL_SUFFIX}/apps/{app_id}/variants/",
+        timeout=600,
+    )
+
+    # Check for successful request
+    if response.status_code != 200:
+        error_message = response.json()
+        raise APIRequestError(
+            f"Request to apps endpoint failed with status code {response.status_code} and error message: {error_message}."
+        )
+    app_variants = response.json()
+    return [AppVariant(**variant) for variant in app_variants]
+
+
+def remove_variant(variant_id: str, host: str):
+    """
+    Sends a DELETE request to the Agenta backend to remove a variant with the given ID.
+
+    Args:
+        variant_id (str): The ID of the variant to be removed.
+        host (str): The URL of the Agenta backend.
+
+    Raises:
+        APIRequestError: If the request to the remove_variant endpoint fails.
+
+    Returns:
+        None
+    """
+    response = requests.delete(
+        f"{host}/{BACKEND_URL_SUFFIX}/variants/{variant_id}",
+        headers={"Content-Type": "application/json"},
+        timeout=600,
+    )
+
+    # Check for successful request
+    if response.status_code != 200:
+        error_message = response.json()
+        raise APIRequestError(
+            f"Request to remove_variant endpoint failed with status code {response.status_code} and error message: {error_message}"
+        )
+
+
+def update_variant_image(variant_id: str, image: Image, host: str):
+    """
+    Update the image of a variant with the given ID.
+
+    Args:
+        variant_id (str): The ID of the variant to update.
+        image (Image): The new image to set for the variant.
+        host (str): The URL of the host to send the request to.
+
+    Raises:
+        APIRequestError: If the request to update the variant fails.
+
+    Returns:
+        None
+    """
+    response = requests.put(
+        f"{host}/{BACKEND_URL_SUFFIX}/variants/{variant_id}/image/",
+        json=image.dict(),
+        timeout=600,
+    )
+    if response.status_code != 200:
+        error_message = response.json()
+        raise APIRequestError(
+            f"Request to update app_variant failed with status code {response.status_code} and error message: {error_message}."
+        )
+
+
+def send_docker_tar(app_id: str, base_name: str, tar_path: Path, host: str) -> Image:
+    """
+    Sends a Docker tar file to the specified host to build an image for the given app ID and variant name.
+
+    Args:
+        app_id (str): The ID of the app.
+        base_name (str): The name of the codebase.
+        tar_path (Path): The path to the Docker tar file.
+        host (str): The URL of the host to send the request to.
+
+    Returns:
+        Image: The built Docker image.
+
+    Raises:
+        Exception: If the response status code is 500, indicating that serving the variant failed.
+    """
+    with tar_path.open("rb") as tar_file:
+        response = requests.post(
+            f"{host}/{BACKEND_URL_SUFFIX}/containers/build_image/?app_id={app_id}&base_name={base_name}",
+            files={
+                "tar_file": tar_file,
+            },
+            timeout=1200,
+        )
+
+    if response.status_code == 500:
+        response_error = response.json()
+        error_msg = "Serving the variant failed.\n"
+        error_msg += f"Log: {response_error}\n"
+        error_msg += "Here's how you may be able to solve the issue:\n"
+        error_msg += "- First, make sure that the requirements.txt file has all the dependencies that you need.\n"
+        error_msg += "- Second, check the Docker logs for the backend image to see the error when running the Docker container."
+        raise Exception(error_msg)
+
+    response.raise_for_status()
+    image = Image.parse_obj(response.json())
+    return image

{agenta-0.2.12 → agenta-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agenta"
-version = "0.2.12"
+version = "0.3.0"
 description = "SDK for Agenta an open-source LLMOps platform."
 readme = "README.md"
 authors = ["Mahmoud Mabrouk <mahmoud@agenta.ai>"]

agenta-0.2.12/agenta/client/client.py

@@ -1,177 +0,0 @@
-import os
-from pathlib import Path
-from typing import List
-
-import agenta.config
-import requests
-from agenta.client.api_models import AppVariant, Image
-from docker.models.images import Image as DockerImage
-
-BACKEND_URL_SUFFIX = os.environ["BACKEND_URL_SUFFIX"]
-
-
-class APIRequestError(Exception):
-    """Exception to be raised when an API request fails."""
-
-
-def add_variant_to_server(app_name: str, variant_name: str, image: Image, host: str):
-    """Adds a variant to the server.
-
-    Arguments:
-        app_name -- Name of the app
-        variant_name -- Name of the variant
-        image_name -- Name of the image
-    """
-    app_variant: AppVariant = AppVariant(app_name=app_name, variant_name=variant_name)
-    response = requests.post(
-        f"{host}/{BACKEND_URL_SUFFIX}/app_variant/add/from_image/",
-        json={"app_variant": app_variant.dict(), "image": image.dict()},
-        timeout=600,
-    )
-    if response.status_code != 200:
-        error_message = response.json()
-        raise APIRequestError(
-            f"Request to app_variant endpoint failed with status code {response.status_code} and error message: {error_message}."
-        )
-
-
-def start_variant(app_name: str, variant_name: str, host: str) -> str:
-    """Starts a container with the variant an expose its endpoint
-
-    Arguments:
-        app_name --
-        variant_name -- _description_
-
-    Returns:
-        The endpoint of the container
-    """
-    response = requests.post(
-        f"{host}/{BACKEND_URL_SUFFIX}/app_variant/start/",
-        json={"app_variant": {"app_name": app_name, "variant_name": variant_name}},
-        timeout=600,
-    )
-
-    if response.status_code != 200:
-        error_message = response.json()
-        raise APIRequestError(
-            f"Request to start variant endpoint failed with status code {response.status_code} and error message: {error_message}."
-        )
-    return response.json()["uri"]
-
-
-def list_variants(app_name: str, host: str) -> List[AppVariant]:
-    """Lists all the variants registered in the backend for an app
-
-    Arguments:
-        app_name -- the app name to which to return all the variants
-
-    Returns:
-        a list of the variants using the pydantic model
-    """
-    response = requests.get(
-        f"{host}/{BACKEND_URL_SUFFIX}/app_variant/list_variants/?app_name={app_name}",
-        timeout=600,
-    )
-
-    # Check for successful request
-    if response.status_code != 200:
-        error_message = response.json()
-        raise APIRequestError(
-            f"Request to list_variants endpoint failed with status code {response.status_code} and error message: {error_message}."
-        )
-    app_variants = response.json()
-    return [AppVariant(**variant) for variant in app_variants]
-
-
-def get_variant_by_name(app_name: str, variant_name: str, host: str) -> AppVariant:
-    """Gets a variant by name
-
-    Arguments:
-        app_name -- the app name
-        variant_name -- the variant name
-
-    Returns:
-        the variant using the pydantic model
-    """
-    response = requests.get(
-        f"{host}/{BACKEND_URL_SUFFIX}/app_variant/get_variant_by_name/?app_name={app_name}&variant_name={variant_name}",
-        timeout=600,
-    )
-
-    # Check for successful request
-    if response.status_code != 200:
-        error_message = response.json()
-        raise APIRequestError(
-            f"Request to get_variant_by_name endpoint failed with status code {response.status_code} and error message: {error_message}."
-        )
-
-
-def remove_variant(app_name: str, variant_name: str, host: str):
-    """Removes a variant from the backend
-
-    Arguments:
-        app_name -- the app name
-        variant_name -- the variant name
-    """
-    app_variant = AppVariant(app_name=app_name, variant_name=variant_name)
-    app_variant_json = app_variant.json()
-    response = requests.delete(
-        f"{host}/{BACKEND_URL_SUFFIX}/app_variant/remove_variant/",
-        data=app_variant_json,
-        headers={"Content-Type": "application/json"},
-        timeout=600,
-    )
-
-    # Check for successful request
-    if response.status_code != 200:
-        error_message = response.json()
-        raise APIRequestError(
-            f"Request to remove_variant endpoint failed with status code {response.status_code} and error message: {error_message}"
-        )
-
-
-def update_variant_image(app_name: str, variant_name: str, image: Image, host: str):
-    """Adds a variant to the server.
-
-    Arguments:
-        app_name -- Name of the app
-        variant_name -- Name of the variant
-        image_name -- Name of the image
-    """
-    app_variant: AppVariant = AppVariant(app_name=app_name, variant_name=variant_name)
-    response = requests.put(
-        f"{host}/{BACKEND_URL_SUFFIX}/app_variant/update_variant_image/",
-        json={"app_variant": app_variant.dict(), "image": image.dict()},
-        timeout=600,
-    )
-    if response.status_code != 200:
-        error_message = response.json()
-        raise APIRequestError(
-            f"Request to update app_variant failed with status code {response.status_code} and error message: {error_message}."
-        )
-
-
-def send_docker_tar(
-    app_name: str, variant_name: str, tar_path: Path, host: str
-) -> Image:
-    with tar_path.open("rb") as tar_file:
-        response = requests.post(
-            f"{host}/{BACKEND_URL_SUFFIX}/containers/build_image/?app_name={app_name}&variant_name={variant_name}",
-            files={
-                "tar_file": tar_file,
-            },
-            timeout=1200,
-        )
-
-    if response.status_code == 500:
-        response_error = response.json()
-        error_msg = "Serving the variant failed.\n"
-        error_msg += f"Log: {response_error}\n"
-        error_msg += "Here's how you may be able to solve the issue:\n"
-        error_msg += "- First, make sure that the requirements.txt file has all the dependencies that you need.\n"
-        error_msg += "- Second, check the Docker logs for the backend image to see the error when running the Docker container."
-        raise Exception(error_msg)
-
-    response.raise_for_status()
-    image = Image.parse_obj(response.json())
-    return image