frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/commands/models/executions/start/_logic.py

@@ -0,0 +1,83 @@
+from typing import Tuple
+
+from frogml.core.clients.batch_job_management import BatchJobManagerClient
+from frogml.core.clients.batch_job_management.executions_config import ExecutionConfig
+from frogml.core.clients.batch_job_management.results import StartExecutionResult
+from frogml.core.clients.instance_template.client import (
+    InstanceTemplateManagementClient,
+)
+from frogml.core.tools.logger.logger import get_frogml_logger
+from frogml_inference.batch_client.instance_validation import verify_template_id
+
+logger = get_frogml_logger()
+
+
+def execute_start_execution(config: ExecutionConfig) -> Tuple[str, bool, str]:
+    if config.resources.instance_size:
+        verify_template_id(
+            config.resources.instance_size, InstanceTemplateManagementClient()
+        )
+    batch_job_start_response: StartExecutionResult = (
+        BatchJobManagerClient().start_execution(config)
+    )
+    return (
+        batch_job_start_response.execution_id,
+        batch_job_start_response.success,
+        batch_job_start_response.failure_message,
+    )
+
+
+def execute_in_local_mode(kwargs):
+    from frogml_inference.batch_client.batch_client import BatchInferenceClient
+
+    logger.info("Executing a batch run in local file mode...")
+
+    model_id = kwargs.get("model_id")
+    source_folder = kwargs.get("source_folder")
+    destination_folder = kwargs.get("destination_folder")
+    input_file_type = kwargs.get("input_file_type")
+    output_file_type = kwargs.get("output_file_type", None)
+    job_timeout = kwargs.get("job_timeout", 0)
+    task_timeout = kwargs.get("task_timeout", 0)
+    executors = kwargs.get("executors", None)
+    cpus = kwargs.get("cpus", None)
+    memory = kwargs.get("memory", None)
+    gpus = kwargs.get("gpus", 0)
+    gpu_type = kwargs.get("gpu_type", None)
+    iam_role_arn = kwargs.get("iam_role_arn", None)
+    build_id = kwargs.get("build_id", None)
+    parameters = kwargs.get("parameters", None)
+    instance = kwargs.get("instance", "")
+
+    if (
+        not model_id
+        or not source_folder
+        or not destination_folder
+        or not input_file_type
+    ):
+        raise ValueError(
+            "model-id, source-folder, destination-folder and input-file-type are required"
+        )
+
+    client = BatchInferenceClient()
+    client.local_file_run(
+        model_id=model_id,
+        source_folder=source_folder,
+        destination_folder=destination_folder,
+        input_file_type=input_file_type,
+        output_file_type=output_file_type,
+        job_timeout=job_timeout,
+        task_timeout=task_timeout,
+        executors=executors,
+        cpus=cpus,
+        memory=memory,
+        gpus=gpus,
+        gpu_type=gpu_type,
+        iam_role_arn=iam_role_arn,
+        build_id=build_id,
+        parameters=parameters,
+        instance=instance,
+    )
+    logger.info(
+        "Batch run completed successfully. Results are available in the destination folder."
+    )

frogml_cli/commands/models/executions/start/ui.py

@@ -0,0 +1,208 @@
+import click
+from frogml.core.clients.batch_job_management.executions_config import (
+    GPU_TYPE_MAP,
+    INPUT_FORMATTERS_MAP,
+    OUTPUT_FORMATTERS_MAP,
+    ExecutionConfig,
+)
+from frogml.core.exceptions import FrogmlException
+from frogml.core.tools.logger.logger import get_frogml_logger
+from tabulate import tabulate
+
+from frogml_cli.commands.models.executions.start._logic import (
+    execute_in_local_mode,
+    execute_start_execution,
+)
+from frogml_cli.inner.tools.cli_tools import DeprecatedOption, FrogMLCommand
+from frogml_cli.inner.tools.config_handler import config_handler
+from frogml_cli.tools.const import GPU_TYPES
+
+logger = get_frogml_logger()
+
+
+@click.command(
+    name="start", help="Start an execution job on a deployed model.", cls=FrogMLCommand
+)
+@click.option("--model-id", required=True, help="Model ID", type=str)
+@click.option(
+    "--build-id",
+    type=str,
+    help="Explicit Build ID to invoke the execution against. If empty, the deployed build ID will be applied",
+)
+@click.option(
+    "--bucket",
+    type=str,
+    help="The bucket to read and write the data to/from.",
+)
+@click.option(
+    "--source-bucket",
+    type=str,
+    help="The source bucket to read the data from.",
+)
+@click.option(
+    "--source-folder",
+    required=True,
+    type=str,
+    help="The source folder to read the data from.",
+)
+@click.option(
+    "--destination-bucket",
+    type=str,
+    help="The destination bucket to store results on.",
+)
+@click.option(
+    "--destination-folder",
+    type=str,
+    required=True,
+    help="The destination folder to store results on.",
+)
+@click.option(
+    "--input-file-type",
+    type=click.Choice(
+        [fmt for fmt in INPUT_FORMATTERS_MAP.keys()], case_sensitive=False
+    ),
+    help="The input file type to read.",
+)
+@click.option(
+    "--output-file-type",
+    type=click.Choice(
+        [fmt for fmt in OUTPUT_FORMATTERS_MAP.keys()], case_sensitive=False
+    ),
+    help="The output file type to to receive.",
+)
+@click.option(
+    "--access-token-name",
+    type=str,
+    required=False,
+    help="The access token secret name (should be created before by using `frogml secret`).",
+)
+@click.option(
+    "--access-secret-name",
+    type=str,
+    required=False,
+    help="The access secret secret name (should be created before by using `frogml secret`).",
+)
+@click.option(
+    "--job-timeout",
+    type=int,
+    default=0,
+    help="Total inference job timeout in seconds, (e.g. 2000). Default is unlimited.",
+)
+@click.option(
+    "--file-timeout",
+    type=int,
+    default=0,
+    help="A single file inference timeout in seconds, (e.g. 2000). Default is unlimited.",
+)
+@click.option(
+    "--pods",
+    "--replicas",
+    type=int,
+    default=0,
+    help="Number of replicas to deploy. (concurrent files processing). Default is as deployed.",
+    deprecated=["--pods"],
+    preferred="--replicas",
+    cls=DeprecatedOption,
+)
+@click.option(
+    "--cpus",
+    type=float,
+    default=0,
+    help="Number of CPU cores, can be fraction of a core "
+    "(e.g. 0.4). Default is as deployed.",
+)
+@click.option(
+    "--memory",
+    type=int,
+    default=0,
+    help="Memory amount in Mib (e.g. 256). Default is as deployed.",
+)
+@click.option(
+    "--gpu-type",
+    type=click.Choice([fmt for fmt in GPU_TYPE_MAP.keys()], case_sensitive=False),
+    help=f"Type of GPU to use on the deployment ({', '.join([x for x in GPU_TYPES])}).",
+)
+@click.option(
+    "--gpu-amount",
+    type=int,
+    help="Amount of GPU's to use on the in the batch inference.",
+)
+@click.option(
+    "-f",
+    "--from-file",
+    help="Build by run_config file, Command arguments will overwrite any run_config.",
+    required=False,
+    type=click.Path(exists=True, resolve_path=True, dir_okay=False),
+)
+@click.option(
+    "--out-conf",
+    help="Extract deploy conf from command arguments, the command will not run it wil only output valid yaml "
+    "structure",
+    default=False,
+    is_flag=True,
+)
+@click.option(
+    "-P",
+    "--param-list",
+    required=False,
+    metavar="NAME=VALUE",
+    multiple=True,
+    help="A parameter for the batch execution, of the form -P name=value",
+)
+@click.option(
+    "--instance",
+    required=False,
+    type=str,
+    help="The instance size to run batch on - 'small', 'medium', 'large', etc...",
+    default=None,
+)
+@click.option(
+    "--purchase-option",
+    required=False,
+    type=str,
+    help="The instance purchase option 'on-demand' or 'spot'",
+    default=None,
+)
+def execution_start(from_file: str, out_conf: bool, **kwargs):
+    if kwargs["source_folder"].startswith("file:") and kwargs[
+        "destination_folder"
+    ].startswith("file:"):
+        execute_in_local_mode(kwargs)
+        return
+    else:
+        access_token_name = kwargs.get("access_token_name", None)
+        access_secret_name = kwargs.get("access_secret_name", None)
+        if access_token_name is None or access_secret_name is None:
+            raise FrogmlException(
+                "Both access-token-name and access-secret-name must be provided"
+            )
+
+    config: ExecutionConfig = config_handler(
+        config=ExecutionConfig,
+        from_file=from_file,
+        out_conf=out_conf,
+        sections=("execution", "resources"),
+        **kwargs,
+    )
+    if not out_conf:
+        try:
+            execution_id, success, fail_message = execute_start_execution(config)
+            if success:
+                logger.info(
+                    tabulate(
+                        tabular_data=[
+                            ["Model ID", config.execution.model_id],
+                            ["Execution ID", execution_id],
+                        ],
+                        tablefmt="fancy_grid",
+                    )
+                )
+            else:
+                raise FrogmlException(fail_message + f" {execution_id}")
+
+            logger.info(
+                "Execution initiated successfully, Use --status to get execution current status."
+            )
+        except Exception as e:
+            logger.error(f"Execution failed, Error: {e}")
+            raise

frogml_cli/commands/models/executions/status/_logic.py

@@ -0,0 +1,13 @@
+from frogml.core.clients.batch_job_management import BatchJobManagerClient
+from frogml.core.clients.batch_job_management.results import ExecutionStatusResult
+
+
+def execute_execution_status(execution_id: str):
+    batch_job_status_response: ExecutionStatusResult = (
+        BatchJobManagerClient().get_execution_status(execution_id)
+    )
+    return (
+        batch_job_status_response.status,
+        batch_job_status_response.success,
+        batch_job_status_response.failure_message,
+    )

frogml_cli/commands/models/executions/status/ui.py

@@ -0,0 +1,27 @@
+import click
+from frogml.core.exceptions import FrogmlException
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.executions.status._logic import execute_execution_status
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+logger = get_frogml_logger()
+
+
+@click.command(name="status", help="Get the status of an execution.", cls=FrogMLCommand)
+@click.option(
+    "--execution-id",
+    type=str,
+    help="The execution id.",
+)
+def execution_status(execution_id: str, **kwargs):
+    try:
+        job_status, success, fail_message = execute_execution_status(execution_id)
+        if not success:
+            raise FrogmlException(fail_message)
+
+        logger.info(f"Status is: {job_status}.")
+
+    except Exception as e:
+        logger.error(f"Failed to cancel execution, Error: {e}")
+        raise

frogml_cli/commands/models/init/_logic/initialize_model_structure.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+from cookiecutter import generate
+from frogml.core.exceptions import FrogmlException
+
+
+def initialize_model_structure(uri: str, template: str, logger, **template_args):
+    if Path(uri).is_file():
+        raise FrogmlException(
+            f"Unable to create the model directory structure - given path {uri} is an existing file"
+        )
+
+    if not Path(uri).is_dir():
+        logger.info(f"Given path {uri} doesn't exists - creating it")
+        Path(uri).mkdir(parents=True, exist_ok=True)
+
+    context = generate.generate_context(
+        context_file=(
+            Path(__file__).parent / "template" / template / "cookiecutter.json"
+        ).resolve(),
+        default_context=None,
+        extra_context={**template_args},
+    )
+
+    output_dir = uri + "/" + context.get("cookiecutter", {}).get("model_directory")
+    if Path(output_dir).exists():
+        raise FrogmlException(
+            f"Folder with the name {output_dir} is already exists. "
+            f"Please change model name or change the working path."
+        )
+    logger.info("Generating structure...")
+    generate.generate_files(
+        (Path(__file__).parent / "template" / template).resolve(),
+        context,
+        output_dir=uri,
+        overwrite_if_exists=False,
+        skip_if_file_exists=False,
+    )
+
+    logger.info(f"Created base model at {Path(output_dir).resolve()}")

frogml_cli/commands/models/init/_logic/template/churn/cookiecutter.json

@@ -0,0 +1,3 @@
+{
+    "model_directory": "churn"
+}

frogml_cli/commands/models/init/_logic/template/churn/{{cookiecutter.model_directory}}/main/__init__.py

@@ -0,0 +1,5 @@
+from .model import ChurnPrediction
+
+
+def load_model():
+    return ChurnPrediction()

frogml_cli/commands/models/init/_logic/template/churn/{{cookiecutter.model_directory}}/main/conda.yml

@@ -0,0 +1,10 @@
+# name: churn-example
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - python=3.9
+  - pip=22.2.2
+  - pandas=1.1.5
+  - scikit-learn=0.24.1
+  - catboost=0.26.1