nextmv 1.0.0.dev4__tar.gz → 1.0.0.dev5__tar.gz

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 1.0.0.dev4
+Version: 1.0.0.dev5
 Summary: The all-purpose Python SDK for Nextmv
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://nextmv-py.docs.nextmv.io/en/latest/nextmv/

nextmv-1.0.0.dev5/nextmv/__about__.py

@@ -0,0 +1 @@
+__version__ = "v1.0.0.dev5"

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/nextmv/__entrypoint__.py

@@ -10,13 +10,12 @@ human to use it during local development. It is the standard way in which a
 from mlflow.pyfunc import load_model
 
 import nextmv
-from nextmv import cloud
 
 
 def main() -> None:
     """Entry point for the program."""
 
-    manifest = cloud.Manifest.from_yaml(".")
+    manifest = nextmv.Manifest.from_yaml(".")
 
     # Load the options from the manifest.
     options = manifest.extract_options()

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/nextmv/__init__.py

@@ -11,7 +11,6 @@ from .input import LocalInputLoader as LocalInputLoader
 from .input import csv_data_file as csv_data_file
 from .input import json_data_file as json_data_file
 from .input import load as load
-from .input import load_local as load_local
 from .input import text_data_file as text_data_file
 from .logger import log as log
 from .logger import redirect_stdout as redirect_stdout
@@ -31,7 +30,6 @@ from .model import Model as Model
 from .model import ModelConfiguration as ModelConfiguration
 from .options import Option as Option
 from .options import Options as Options
-from .options import Parameter as Parameter
 from .output import Asset as Asset
 from .output import DataPoint as DataPoint
 from .output import LocalOutputWriter as LocalOutputWriter
@@ -50,7 +48,6 @@ from .output import csv_solution_file as csv_solution_file
 from .output import json_solution_file as json_solution_file
 from .output import text_solution_file as text_solution_file
 from .output import write as write
-from .output import write_local as write_local
 from .polling import DEFAULT_POLLING_OPTIONS as DEFAULT_POLLING_OPTIONS
 from .polling import PollingOptions as PollingOptions
 from .polling import default_polling_options as default_polling_options
@@ -79,7 +76,6 @@ from .run import TrackedRunStatus as TrackedRunStatus
 from .run import run_duration as run_duration
 from .safe import safe_id as safe_id
 from .safe import safe_name_and_id as safe_name_and_id
-from .status import Status as Status
 from .status import StatusV2 as StatusV2
 
 VERSION = __version__

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/nextmv/_serialization.py

@@ -90,7 +90,7 @@ def _custom_serial(obj: Any) -> str:
         If the object type is not supported for serialization.
     """
 
-    if isinstance(obj, (datetime.datetime, datetime.date)):
+    if isinstance(obj, datetime.datetime | datetime.date):
         return obj.isoformat()
 
     raise TypeError(f"Type {type(obj)} not serializable")

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/nextmv/cli/cloud/acceptance/create.py

@@ -45,7 +45,7 @@ app = typer.Typer()
     - Multiple metrics as a [magenta]json[/magenta] array in a single --metrics flag.
 
     Each metric must have the following fields:
-    - [magenta]field[/magenta]: Field of the metric to measure (e.g., "solution.objective").
+    - [magenta]field[/magenta]: Field of the metric to measure (e.g., "result.custom.unassigned").
     - [magenta]metric_type[/magenta]: Type of metric comparison. Allowed values: {enum_values(MetricType)}.
     - [magenta]params[/magenta]: Parameters of the metric comparison.
         - [magenta]operator[/magenta]: Comparison operator. Allowed values: {enum_values(Comparison)}.
@@ -71,8 +71,8 @@ app = typer.Typer()
     [bold][underline]Examples[/underline][/bold]
 
     - Create an acceptance test with a single metric.
-        $ [dim]METRIC='{{
-            "field": "solution.objective",
+        $ [green]METRIC='{{
+            "field": "result.custom.unassigned",
             "metric_type": "direct-comparison",
             "params": {{
                 "operator": "lt",
@@ -85,8 +85,8 @@ app = typer.Typer()
             --metrics "$METRIC" --input-set-id input-set-123[/dim]
 
     - Create with multiple metrics by repeating the flag.
-        $ [dim]METRIC1='{{
-            "field": "solution.objective",
+        $ [green]METRIC1='{{
+            "field": "result.custom.unassigned",
             "metric_type": "direct-comparison",
             "params": {{
                 "operator": "lt",
@@ -95,7 +95,7 @@ app = typer.Typer()
             "statistic": "mean"
         }}'
         METRIC2='{{
-            "field": "statistics.run.duration",
+            "field": "run.duration",
             "metric_type": "direct-comparison",
             "params": {{
                 "operator": "le",
@@ -110,7 +110,7 @@ app = typer.Typer()
     - Create with multiple metrics in a single [magenta]json[/magenta] array.
         $ [dim]METRICS='[
             {{
-                "field": "solution.objective",
+                "field": "result.custom.unassigned",
                 "metric_type": "direct-comparison",
                 "params": {{
                     "operator": "lt",
@@ -119,7 +119,7 @@ app = typer.Typer()
                 "statistic": "mean"
             }},
             {{
-                "field": "statistics.run.duration",
+                "field": "run.duration",
                 "metric_type": "direct-comparison",
                 "params": {{
                     "operator": "le",
@@ -133,8 +133,8 @@ app = typer.Typer()
             --metrics "$METRICS" --input-set-id input-set-123[/dim]
 
     - Create an acceptance test and wait for it to complete.
-        $ [dim]METRIC='{{
-            "field": "solution.objective",
+        $ [green]METRIC='{{
+            "field": "result.custom.unassigned",
             "metric_type": "direct-comparison",
             "params": {{
                 "operator": "lt",
@@ -147,8 +147,8 @@ app = typer.Typer()
             --metrics "$METRIC" --input-set-id input-set-123 --wait[/dim]
 
     - Create an acceptance test and save the results to a file, waiting for completion.
-        $ [dim]METRIC='{{
-            "field": "solution.objective",
+        $ [green]METRIC='{{
+            "field": "result.custom.unassigned",
             "metric_type": "direct-comparison",
             "params": {{
                 "operator": "lt",

nextmv-1.0.0.dev5/nextmv/cli/cloud/app/push.py

@@ -0,0 +1,451 @@
+"""
+This module defines the cloud app push command for the Nextmv CLI.
+"""
+
+import sys
+from datetime import datetime, timezone
+from typing import Annotated
+
+import typer
+from rich.prompt import Prompt
+
+from nextmv.cli.configuration.config import build_app
+from nextmv.cli.confirm import get_confirmation
+from nextmv.cli.message import error, in_progress, info, success
+from nextmv.cli.options import AppIDOption, ProfileOption
+from nextmv.cloud.application import Application
+from nextmv.manifest import Manifest
+
+# Set up subcommand application.
+app = typer.Typer()
+
+
+@app.command()
+def push(
+    app_id: AppIDOption,
+    app_dir: Annotated[
+        str | None,
+        typer.Option(
+            "--app-dir",
+            "-d",
+            help="The path to the application's root directory.",
+            metavar="APP_DIR",
+        ),
+    ] = ".",
+    manifest: Annotated[
+        str | None,
+        typer.Option(
+            "--manifest",
+            "-m",
+            help="Path to the application manifest file ([magenta]app.yaml[/magenta]).",
+            metavar="MANIFEST_PATH",
+        ),
+    ] = None,
+    # Options for version control.
+    version_id: Annotated[
+        str | None,
+        typer.Option(
+            "--version-id",
+            "-v",
+            help="Custom ID for version creation after app push. Automatically generated if not provided. "
+            "Activates --version-yes.",
+            metavar="VERSION_ID",
+            rich_help_panel="Version control",
+        ),
+    ] = None,
+    version_yes: Annotated[
+        bool,
+        typer.Option(
+            "--version-yes",
+            "-y",
+            help="Create a new version after push. Skips confirmation prompt. Useful for non-interactive sessions.",
+            rich_help_panel="Version control",
+        ),
+    ] = False,
+    # Options for instance control.
+    create_instance_id: Annotated[
+        str | None,
+        typer.Option(
+            "--create-instance-id",
+            "-c",
+            help="Link the newly created version to a [yellow]new[/yellow] instance with this ID. "
+            "Skips prompt to provide an instance ID. Useful for non-interactive sessions.",
+            metavar="CREATE_INSTANCE_ID",
+            rich_help_panel="Instance control",
+        ),
+    ] = None,
+    update_instance_id: Annotated[
+        str | None,
+        typer.Option(
+            "--update-instance-id",
+            "-u",
+            help="Link the newly created version to an [yellow]existing[/yellow] instance with this ID. "
+            "Skips prompt to provide an instance ID. Useful for non-interactive sessions.",
+            metavar="UPDATE_INSTANCE_ID",
+            rich_help_panel="Instance control",
+        ),
+    ] = None,
+    profile: ProfileOption = None,
+) -> None:
+    """
+    Push (deploy) a Nextmv application to Nextmv Cloud.
+
+    Use the --app-dir option to specify the path to your application's root
+    directory. By default, the current working directory is used.
+
+    You can also provide a custom manifest file using the --manifest option. If
+    not provided, the CLI will look for a file named
+    [magenta]app.yaml[/magenta] in the application's root.
+
+    By default, this command only pushes the app. After the push, you will be
+    prompted to create a new version. If a new version is created, you will be
+    prompted to link it to an instance. If the instance exists, you will be
+    asked if you want to update it. If it doesn't, you will be asked to create
+    it. You can use the following flags to skip the prompts, useful in
+    non-interactive sessions like in a CI/CD pipeline: --version-yes,
+    --version-id, --create-instance-id, and --update-instance-id.
+
+    [bold][underline]Examples[/underline][/bold]
+
+    - Push an application, with ID [magenta]hare-app[/magenta], from the current directory.
+        $ [dim]nextmv cloud app push --app-id hare-app[/dim]
+
+    - Push an application, with ID [magenta]hare-app[/magenta], from the [magenta]./my-app[/magenta] directory.
+        $ [dim]nextmv cloud app push --app-id hare-app --app-dir ./my-app[/dim]
+
+    - Push an application, with ID [magenta]hare-app[/magenta], using a custom manifest file.
+        $ [dim]nextmv cloud app push --app-id hare-app --manifest ./custom-manifest.yaml[/dim]
+
+    - Push and automatically create a new version (no prompt).
+        $ [dim]nextmv cloud app push --app-id hare-app --version-yes[/dim]
+
+    - Push and create a new version with a custom version ID (no prompt).
+        $ [dim]nextmv cloud app push --app-id hare-app --version-id v1.0.0[/dim]
+
+    - Push and create a new version, then link it to a new instance with a specific ID (no prompt).
+        $ [dim]nextmv cloud app push --app-id hare-app --version-yes --create-instance-id inst-1[/dim]
+
+    - Push and create a new version, then link it to an existing instance (no prompt).
+        $ [dim]nextmv cloud app push --app-id hare-app --version-yes --update-instance-id inst-1[/dim]
+    """
+
+    # We cannot create and update an instance at the same time.
+    update_defined = update_instance_id is not None and update_instance_id != ""
+    create_defined = create_instance_id is not None and create_instance_id != ""
+    if update_defined and create_defined:
+        error("Cannot use --update-instance-id and --create-instance-id at the same time.")
+
+    cloud_app = build_app(app_id=app_id, profile=profile)
+
+    # We cannot update an instance that does not exist.
+    if update_defined and not cloud_app.instance_exists(instance_id=update_instance_id):
+        error(
+            f"Used option --update-instance-id but the instance {update_instance_id} does not exist. "
+            "Use --create-instance-id instead."
+        )
+
+    # We cannot create an instance that already exists.
+    if create_defined and cloud_app.instance_exists(instance_id=create_instance_id):
+        error(
+            f"Used option --create-instance-id but the instance {create_instance_id} already exists. "
+            "Use --update-instance-id instead."
+        )
+
+    # Do the normal push first.
+    loaded_manifest = Manifest.from_yaml(dirpath=manifest) if manifest is not None and manifest != "" else None
+    cloud_app.push(
+        manifest=loaded_manifest,
+        app_dir=app_dir,
+        verbose=True,
+        rich_print=True,
+    )
+
+    now = datetime.now(timezone.utc)
+    version_id, should_continue = _handle_version_creation(
+        cloud_app=cloud_app,
+        app_id=app_id,
+        version_id=version_id,
+        version_yes=version_yes,
+        now=now,
+    )
+    if not should_continue:
+        return
+
+    # If the override for updating an instance was used, we update the instance
+    # and we are done.
+    if update_defined:
+        info("Used option --update-instance-id to link version to existing instance.", emoji=":bulb:")
+        _update_instance(
+            cloud_app=cloud_app,
+            app_id=app_id,
+            version_id=version_id,
+            instance_id=update_instance_id,
+        )
+
+        return
+
+    # If the override for creating a new instance was used, we create the
+    # instance and we are done.
+    if create_defined:
+        info("Used option --create-instance-id to link version to new instance.", emoji=":bulb:")
+        _create_instance(
+            cloud_app=cloud_app,
+            app_id=app_id,
+            version_id=version_id,
+            instance_id=create_instance_id,
+            now=now,
+        )
+
+        return
+
+    # If no overrides are used, we handle instance prompting.
+    _handle_instance_prompting(
+        cloud_app=cloud_app,
+        app_id=app_id,
+        version_id=version_id,
+        now=now,
+    )
+
+
+def _handle_version_creation(
+    cloud_app: Application,
+    app_id: str,
+    version_id: str | None,
+    version_yes: bool,
+    now: datetime,
+) -> tuple[str, bool]:
+    """
+    Handle the logic for version creation after pushing an application.
+
+    If a version ID is provided and exists, it is used directly. If not, the user is prompted (unless auto-confirmed)
+    to create a new version. If confirmed, a new version is created with an automatic description.
+
+    Parameters
+    ----------
+    cloud_app : Application
+        The cloud application object to interact with Nextmv Cloud.
+    app_id : str
+        The application ID.
+    version_id : str or None
+        The version ID to use or check for existence. If None or empty, a new version may be created.
+    version_yes : bool
+        Whether to skip the prompt and auto-create a new version.
+    now : datetime
+        The current datetime, used for version description.
+
+    Returns
+    -------
+    tuple[str, bool]
+        A tuple containing the version ID (empty string if not created) and a boolean indicating
+        whether to continue with subsequent steps (True if a version is selected or created, False otherwise).
+    """
+
+    # If the user provides a version, and it exists, we use it directly and we
+    # are done.
+    if version_id is not None and version_id != "":
+        exists = cloud_app.version_exists(version_id=version_id)
+        if exists:
+            error(
+                f"Version [magenta]{version_id}[/magenta] already exists for application [magenta]{app_id}[/magenta]."
+            )
+
+            return "", False
+
+        info(
+            msg=f"Version [magenta]{version_id}[/magenta] does not exist. A new version will be created.",
+            emoji=":bulb:",
+        )
+
+        version_yes = True  # Activate auto-confirm since user provided a version ID.
+
+    # If we are not auto-confirming version creation, ask the user.
+    if not version_yes:
+        should_create = get_confirmation(
+            msg=f"Do you want to create a new version [magenta]{app_id}[/magenta] now?",
+            default=True,
+        )
+
+        # If the user does not want to create a new version, we are done.
+        if not should_create:
+            info(
+                msg="Will not create a new version.",
+                emoji=":bulb:",
+            )
+            return "", False
+
+    # Create a new version if either the user confirms by prompt or by using
+    # the flag.
+    in_progress("Creating a new version...")
+    version_description = f"Version created automatically from push at {now.strftime('%Y-%m-%dT%H:%M:%SZ')}"
+    version = cloud_app.new_version(
+        id=version_id,
+        description=version_description,
+    )
+    version_id = version.id
+    success(f"New version [magenta]{version_id}[/magenta] created for application [magenta]{app_id}[/magenta].")
+
+    return version_id, True
+
+
+def _handle_instance_prompting(
+    cloud_app: Application,
+    app_id: str,
+    version_id: str,
+    now: datetime,
+) -> None:
+    """
+    Handle interactive prompting for linking a version to an instance after a push.
+
+    In interactive terminals, prompts the user to link the new version to an existing or new instance.
+    If the terminal is non-interactive, skips prompting. Handles both updating existing instances and creating new ones.
+
+    Parameters
+    ----------
+    cloud_app : Application
+        The cloud application object to interact with Nextmv Cloud.
+    app_id : str
+        The application ID.
+    version_id : str
+        The version ID to link to an instance.
+    now : datetime
+        The current datetime, used for instance description if a new instance is created.
+    """
+
+    # If this is not an interactive terminal, do not ask for instance linking,
+    # to avoid hanging indefinitely waiting for a user response.
+    if not sys.stdin.isatty():
+        info(
+            msg="Non-interactive terminal detected. Skipping instance linking.",
+            emoji=":bulb:",
+        )
+
+        return
+
+    # Prompt the user for an instance ID to link the new version to.
+    instance_id = Prompt.ask(
+        f"Do you want to link version [magenta]{version_id}[/magenta] to an instance? If so, enter the instance ID. "
+        "Leave blank to abort",
+        case_sensitive=False,
+    )
+    if instance_id == "":
+        info(
+            msg="No instance ID provided. Skipping instance linking.",
+            emoji=":bulb:",
+        )
+        return
+
+    # Based on whether the instance exists or not, ask the user if they want to
+    # update or create it.
+    exists = cloud_app.instance_exists(instance_id=instance_id)
+
+    # If the instance exists, ask if we want to update it.
+    if exists:
+        should_update = get_confirmation(
+            msg=f"Instance [magenta]{instance_id}[/magenta] exists. "
+            f"Do you want to link it to version [magenta]{version_id}[/magenta]?",
+            default=True,
+        )
+
+        if not should_update:
+            info(
+                msg=f"Will not update instance [magenta]{instance_id}[/magenta].",
+                emoji=":bulb:",
+            )
+            return
+
+        _update_instance(
+            cloud_app=cloud_app,
+            app_id=app_id,
+            version_id=version_id,
+            instance_id=instance_id,
+        )
+
+        return
+
+    # If the instance does not exist, ask if we want to create it.
+    should_create = get_confirmation(
+        msg=f"Instance [magenta]{instance_id}[/magenta] does not exist. "
+        f"Do you want to create it using version [magenta]{version_id}[/magenta]?",
+        default=True,
+    )
+
+    if not should_create:
+        info(
+            msg=f"Will not create instance [magenta]{instance_id}[/magenta].",
+            emoji=":bulb:",
+        )
+        return
+
+    _create_instance(
+        cloud_app=cloud_app,
+        app_id=app_id,
+        version_id=version_id,
+        instance_id=instance_id,
+        now=now,
+    )
+
+
+def _update_instance(
+    cloud_app: Application,
+    app_id: str,
+    version_id: str,
+    instance_id: str,
+) -> None:
+    """
+    Update an existing instance to use a new version.
+
+    Parameters
+    ----------
+    cloud_app : Application
+        The cloud application object to interact with Nextmv Cloud.
+    app_id : str
+        The application ID.
+    version_id : str
+        The version ID to link to the instance.
+    instance_id : str
+        The instance ID to update.
+    """
+
+    in_progress(f"Updating instance [magenta]{instance_id}[/magenta] to use version [magenta]{version_id}[/magenta]...")
+    cloud_app.update_instance(id=instance_id, version_id=version_id)
+    success(
+        f"Instance [magenta]{instance_id}[/magenta] updated to use version [magenta]{version_id}[/magenta] "
+        f"for application [magenta]{app_id}[/magenta]."
+    )
+
+
+def _create_instance(
+    cloud_app: Application,
+    app_id: str,
+    version_id: str,
+    instance_id: str,
+    now: datetime,
+) -> None:
+    """
+    Create a new instance linked to a specific version.
+
+    Parameters
+    ----------
+    cloud_app : Application
+        The cloud application object to interact with Nextmv Cloud.
+    app_id : str
+        The application ID.
+    version_id : str
+        The version ID to link to the new instance.
+    instance_id : str
+        The instance ID to create.
+    now : datetime
+        The current datetime, used for the instance description.
+    """
+
+    in_progress(f"Creating a new instance with ID [magenta]{instance_id}[/magenta]...")
+    instance_description = f"Instance created automatically from push at {now.strftime('%Y-%m-%dT%H:%M:%SZ')}"
+    instance = cloud_app.new_instance(
+        version_id=version_id,
+        id=instance_id,
+        description=instance_description,
+    )
+    success(
+        f"New instance [magenta]{instance.id}[/magenta] created using version [magenta]{version_id}[/magenta] "
+        f"for application [magenta]{app_id}[/magenta]."
+    )

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/nextmv/cli/confirm.py

@@ -3,7 +3,7 @@ import sys
 from rich.prompt import Confirm
 
 
-def get_confirmation(msg: str) -> bool:
+def get_confirmation(msg: str, default: bool = False) -> bool:
     """
     Method to get a yes/no confirmation from the user.
 
@@ -11,6 +11,8 @@ def get_confirmation(msg: str) -> bool:
     ----------
     msg : str
         The message to display to the user.
+    default : bool, optional
+        The default value if the user just presses Enter. Default is False.
 
     Returns
     -------
@@ -21,11 +23,11 @@ def get_confirmation(msg: str) -> bool:
     # If this is not an interactive terminal, do not ask for confirmation, to
     # avoid hanging indefinitely waiting for a user response.
     if not sys.stdin.isatty():
-        return False
+        return default
 
     return Confirm.ask(
         msg,
-        default=False,
+        default=default,
         case_sensitive=False,
         show_default=True,
         show_choices=True,

{nextmv-1.0.0.dev4 → nextmv-1.0.0.dev5}/nextmv/cloud/__init__.py

@@ -1,42 +1,5 @@
 """Functionality for interacting with the Nextmv Cloud."""
 
-# These imports are kept for backwards compatibility but the preferred import path is
-# from nextmv directly. These imports will be removed in a future release.
-from nextmv.manifest import MANIFEST_FILE_NAME as MANIFEST_FILE_NAME
-from nextmv.manifest import Manifest as Manifest
-from nextmv.manifest import ManifestBuild as ManifestBuild
-from nextmv.manifest import ManifestContent as ManifestContent
-from nextmv.manifest import ManifestContentMultiFile as ManifestContentMultiFile
-from nextmv.manifest import ManifestContentMultiFileInput as ManifestContentMultiFileInput
-from nextmv.manifest import ManifestContentMultiFileOutput as ManifestContentMultiFileOutput
-from nextmv.manifest import ManifestOption as ManifestOption
-from nextmv.manifest import ManifestPython as ManifestPython
-from nextmv.manifest import ManifestPythonModel as ManifestPythonModel
-from nextmv.manifest import ManifestRuntime as ManifestRuntime
-from nextmv.manifest import ManifestType as ManifestType
-from nextmv.polling import PollingOptions as PollingOptions
-from nextmv.polling import poll as poll
-from nextmv.run import ErrorLog as ErrorLog
-from nextmv.run import ExternalRunResult as ExternalRunResult
-from nextmv.run import Format as Format
-from nextmv.run import FormatInput as FormatInput
-from nextmv.run import FormatOutput as FormatOutput
-from nextmv.run import Metadata as Metadata
-from nextmv.run import RunConfiguration as RunConfiguration
-from nextmv.run import RunInformation as RunInformation
-from nextmv.run import RunLog as RunLog
-from nextmv.run import RunQueuing as RunQueuing
-from nextmv.run import RunResult as RunResult
-from nextmv.run import RunType as RunType
-from nextmv.run import RunTypeConfiguration as RunTypeConfiguration
-from nextmv.run import TrackedRun as TrackedRun
-from nextmv.run import TrackedRunStatus as TrackedRunStatus
-from nextmv.run import run_duration as run_duration
-from nextmv.safe import safe_id as safe_id
-from nextmv.safe import safe_name_and_id as safe_name_and_id
-from nextmv.status import Status as Status
-from nextmv.status import StatusV2 as StatusV2
-
 from .acceptance_test import AcceptanceTest as AcceptanceTest
 from .acceptance_test import AcceptanceTestResults as AcceptanceTestResults
 from .acceptance_test import Comparison as Comparison
@@ -52,7 +15,6 @@ from .acceptance_test import MetricToleranceType as MetricToleranceType
 from .acceptance_test import MetricType as MetricType
 from .acceptance_test import ResultStatistics as ResultStatistics
 from .acceptance_test import StatisticType as StatisticType
-from .acceptance_test import ToleranceType as ToleranceType
 from .account import Account as Account
 from .account import AccountMember as AccountMember
 from .account import Queue as Queue