clarifai 10.11.0__py3-none-any.whl → 10.11.1__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.11.0"
+__version__ = "10.11.1"

clarifai/cli/model.py

@@ -1,10 +1,11 @@
 import click
+
 from clarifai.cli.base import cli
 
 
 @cli.group(['model'])
 def model():
-  """Manage models: upload, test locally"""
+  """Manage models: upload, test locally, run_locally, predict"""
   pass
 
 
@@ -39,17 +40,43 @@ def upload(model_path, download_checkpoints, skip_dockerfile):
     type=click.Path(exists=True),
     required=True,
     help='Path to the model directory.')
+@click.option(
+    '--mode',
+    type=click.Choice(['env', 'container'], case_sensitive=False),
+    default='env',
+    show_default=True,
+    help=
+    'Specify how to test the model locally: "env" for virtual environment or "container" for Docker container. Defaults to "env".'
+)
 @click.option(
     '--keep_env',
     is_flag=True,
-    help='Flag to keep the virtual environment after testing the model\
-    locally. Defaults to False, which will delete the virtual environment after testing.')
-def test_locally(model_path, keep_env=False):
+    help=
+    'Keep the virtual environment after testing the model locally (applicable for virtualenv mode). Defaults to False.'
+)
+@click.option(
+    '--keep_image',
+    is_flag=True,
+    help=
+    'Keep the Docker image after testing the model locally (applicable for container mode). Defaults to False.'
+)
+def test_locally(model_path, keep_env=False, keep_image=False, mode='env'):
   """Test model locally."""
   try:
     from clarifai.runners.models import model_run_locally
-    model_run_locally.main(model_path, keep_env=keep_env)
-    click.echo(f"Model tested locally from {model_path}.")
+    if mode == 'env' and keep_image:
+      raise ValueError("'keep_image' is applicable only for 'container' mode")
+    if mode == 'container' and keep_env:
+      raise ValueError("'keep_env' is applicable only for 'env' mode")
+
+    if mode == "env":
+      click.echo("Testing model locally in a virtual environment...")
+      model_run_locally.main(model_path, run_model_server=False, keep_env=keep_env)
+    elif mode == "container":
+      click.echo("Testing model locally inside a container...")
+      model_run_locally.main(
+          model_path, inside_container=True, run_model_server=False, keep_image=keep_image)
+    click.echo("Model tested successfully.")
   except Exception as e:
     click.echo(f"Failed to test model locally: {e}", err=True)
 
@@ -60,11 +87,180 @@ def test_locally(model_path, keep_env=False):
     type=click.Path(exists=True),
     required=True,
     help='Path to the model directory.')
-def run_locally(model_path):
-  """Run model locally and starts a GRPC server to serve the model."""
+@click.option(
+    '--port',
+    '-p',
+    type=int,
+    default=8000,
+    show_default=True,
+    help="The port to host the gRPC server for running the model locally. Defaults to 8000.")
+@click.option(
+    '--mode',
+    type=click.Choice(['env', 'container'], case_sensitive=False),
+    default='env',
+    show_default=True,
+    help=
+    'Specifies how to run the model: "env" for virtual environment or "container" for Docker container. Defaults to "env".'
+)
+@click.option(
+    '--keep_env',
+    is_flag=True,
+    help=
+    'Keep the virtual environment after testing the model locally (applicable for virtualenv mode). Defaults to False.'
+)
+@click.option(
+    '--keep_image',
+    is_flag=True,
+    help=
+    'Keep the Docker image after testing the model locally (applicable for container mode). Defaults to False.'
+)
+def run_locally(model_path, port, mode, keep_env, keep_image):
+  """Run the model locally and start a gRPC server to serve the model."""
   try:
     from clarifai.runners.models import model_run_locally
-    model_run_locally.main(model_path, run_model_server=True)
-    click.echo(f"Model server started locally from {model_path}.")
+    if mode == 'env' and keep_image:
+      raise ValueError("'keep_image' is applicable only for 'container' mode")
+    if mode == 'container' and keep_env:
+      raise ValueError("'keep_env' is applicable only for 'env' mode")
+
+    if mode == "env":
+      click.echo("Running model locally in a virtual environment...")
+      model_run_locally.main(model_path, run_model_server=True, keep_env=keep_env, port=port)
+    elif mode == "container":
+      click.echo("Running model locally inside a container...")
+      model_run_locally.main(
+          model_path,
+          inside_container=True,
+          run_model_server=True,
+          port=port,
+          keep_image=keep_image)
+    click.echo(f"Model server started locally from {model_path} in {mode} mode.")
   except Exception as e:
     click.echo(f"Failed to starts model server locally: {e}", err=True)
+
+
+@model.command()
+@click.option(
+    '--config',
+    type=click.Path(exists=True),
+    required=False,
+    help='Path to the model predict config file.')
+@click.option('--model_id', required=False, help='Model ID of the model used to predict.')
+@click.option('--user_id', required=False, help='User ID of the model used to predict.')
+@click.option('--app_id', required=False, help='App ID of the model used to predict.')
+@click.option('--model_url', required=False, help='Model URL of the model used to predict.')
+@click.option('--file_path', required=False, help='File path of file for the model to predict')
+@click.option('--url', required=False, help='URL to the file for the model to predict')
+@click.option('--bytes', required=False, help='Bytes to the file for the model to predict')
+@click.option(
+    '--input_id', required=False, help='Existing input id in the app for the model to predict')
+@click.option('--input_type', required=False, help='Type of input')
+@click.option(
+    '-cc_id',
+    '--compute_cluster_id',
+    required=False,
+    help='Compute Cluster ID to use for the model')
+@click.option('-np_id', '--nodepool_id', required=False, help='Nodepool ID to use for the model')
+@click.option(
+    '-dpl_id', '--deployment_id', required=False, help='Deployment ID to use for the model')
+@click.option(
+    '--inference_params', required=False, default='{}', help='Inference parameters to override')
+@click.option('--output_config', required=False, default='{}', help='Output config to override')
+@click.pass_context
+def predict(ctx, config, model_id, user_id, app_id, model_url, file_path, url, bytes, input_id,
+            input_type, compute_cluster_id, nodepool_id, deployment_id, inference_params,
+            output_config):
+  """Predict using the given model"""
+  import json
+
+  from clarifai.client.deployment import Deployment
+  from clarifai.client.input import Input
+  from clarifai.client.model import Model
+  from clarifai.client.nodepool import Nodepool
+  from clarifai.utils.cli import from_yaml
+  if config:
+    config = from_yaml(config)
+    model_id, user_id, app_id, model_url, file_path, url, bytes, input_id, input_type, compute_cluster_id, nodepool_id, deployment_id, inference_params, output_config = (
+        config.get(k, v)
+        for k, v in [('model_id', model_id), ('user_id', user_id), ('app_id', app_id), (
+            'model_url', model_url), ('file_path', file_path), ('url', url), ('bytes', bytes), (
+                'input_id',
+                input_id), ('input_type',
+                            input_type), ('compute_cluster_id',
+                                          compute_cluster_id), ('nodepool_id', nodepool_id), (
+                                              'deployment_id',
+                                              deployment_id), ('inference_params',
+                                                               inference_params), ('output_config',
+                                                                                   output_config)])
+  if sum([opt[1] for opt in [(model_id, 1), (user_id, 1), (app_id, 1), (model_url, 3)]
+          if opt[0]]) != 3:
+    raise ValueError("Either --model_id & --user_id & --app_id or --model_url must be provided.")
+  if sum([1 for opt in [file_path, url, bytes, input_id] if opt]) != 1:
+    raise ValueError("Exactly one of --file_path, --url, --bytes or --input_id must be provided.")
+  if compute_cluster_id or nodepool_id or deployment_id:
+    if sum([
+        opt[1] for opt in [(compute_cluster_id, 0.5), (nodepool_id, 0.5), (deployment_id, 1)]
+        if opt[0]
+    ]) != 1:
+      raise ValueError(
+          "Either --compute_cluster_id & --nodepool_id or --deployment_id must be provided.")
+  if model_url:
+    model = Model(url=model_url, pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
+  else:
+    model = Model(
+        model_id=model_id,
+        user_id=user_id,
+        app_id=app_id,
+        pat=ctx.obj['pat'],
+        base_url=ctx.obj['base_url'])
+
+  if inference_params:
+    inference_params = json.loads(inference_params)
+  if output_config:
+    output_config = json.loads(output_config)
+
+  if file_path:
+    model_prediction = model.predict_by_filepath(
+        filepath=file_path,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
+  elif url:
+    model_prediction = model.predict_by_url(
+        url=url,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
+  elif bytes:
+    bytes = str.encode(bytes)
+    model_prediction = model.predict_by_bytes(
+        input_bytes=bytes,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
+  elif input_id:
+    inputs = [Input.get_input(input_id)]
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=ctx.obj['user_id'], deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=ctx.obj['user_id'],
+          compute_cluster_id=compute_cluster_id,
+          nodepool_id=nodepool_id)
+    model_prediction = model.predict(
+        inputs=inputs,
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
+  click.echo(model_prediction)

clarifai/rag/rag.py

@@ -45,10 +45,14 @@ class RAG:
       self.logger.info("workflow_url:%s", workflow_url)
       w = Workflow(workflow_url, base_url=base_url, pat=pat)
       self._prompt_workflow = w
-      self._app = App(app_id=w.app_id, base_url=w.base, pat=w.pat)
+      self._app = App(app_id=w.app_id, user_id=w.user_id, base_url=w.base, pat=w.pat)
     elif workflow_url is None and workflow is not None:
       self._prompt_workflow = workflow
-      self._app = App(app_id=workflow.app_id, base_url=workflow.base, pat=workflow.pat)
+      self._app = App(
+          app_id=workflow.app_id,
+          user_id=workflow.user_id,
+          base_url=workflow.base,
+          pat=workflow.pat)
 
   @classmethod
   def setup(cls,

clarifai/runners/dockerfile_template/Dockerfile.template

@@ -22,6 +22,8 @@ ENV CLARIFAI_API_BASE=${CLARIFAI_API_BASE}
 
 # Set the NUMBA cache dir to /tmp
 ENV NUMBA_CACHE_DIR=/tmp/numba_cache
+# Set the TORCHINDUCTOR cache dir to /tmp
+ENV TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor_cache
 ENV HOME=/tmp
 
 # Set the working directory to /app

clarifai/runners/models/model_run_locally.py

@@ -3,9 +3,11 @@ import importlib.util
 import inspect
 import os
 import shutil
+import signal
 import subprocess
 import sys
 import tempfile
+import time
 import traceback
 import venv
 
@@ -24,10 +26,18 @@ class ModelRunLocally:
     self.model_path = model_path
     self.requirements_file = os.path.join(self.model_path, "requirements.txt")
 
+    # ModelUploader contains multiple useful methods to interact with the model
+    self.uploader = ModelUploader(self.model_path)
+    self.config = self.uploader.config
+
+  def _requirements_hash(self):
+    """Generate a hash of the requirements file."""
+    with open(self.requirements_file, "r") as f:
+      return hashlib.md5(f.read().encode('utf-8')).hexdigest()
+
   def create_temp_venv(self):
     """Create a temporary virtual environment."""
-    with open(self.requirements_file, "r") as f:
-      requirements_hash = hashlib.md5(f.read().encode('utf-8')).hexdigest()
+    requirements_hash = self._requirements_hash()
 
     temp_dir = os.path.join(tempfile.gettempdir(), str(requirements_hash))
     venv_dir = os.path.join(temp_dir, "venv")
@@ -105,33 +115,91 @@ class ModelRunLocally:
                 text=resources_pb2.Text(raw="How many people live in new york?"),
                 image=resources_pb2.Image(url="https://samples.clarifai.com/metro-north.jpg"),
                 audio=resources_pb2.Audio(url="https://samples.clarifai.com/GoodMorning.wav"),
+                video=resources_pb2.Video(url="https://samples.clarifai.com/beer.mp4"),
             ))
         ],
     )
 
+  def _build_stream_request(self):
+    request = self._build_request()
+    for i in range(1):
+      yield request
+
   def _run_model_inference(self, runner):
     """Perform inference using the runner."""
     request = self._build_request()
+    stream_request = self._build_stream_request()
 
     ensure_urls_downloaded(request)
-
+    predict_response = None
+    generate_response = None
+    stream_response = None
     try:
-      return runner.predict(request)
+      predict_response = runner.predict(request)
+    except NotImplementedError:
+      logger.info("Model does not implement predict() method.")
     except Exception as e:
       logger.error(f"Model Prediction failed: {e}")
       traceback.print_exc()
-      return service_pb2.MultiOutputResponse(status=status_pb2.Status(
+      predict_response = service_pb2.MultiOutputResponse(status=status_pb2.Status(
           code=status_code_pb2.MODEL_PREDICTION_FAILED,
           description="Prediction failed",
           details="",
           internal_details=str(e),
       ))
 
+    if predict_response:
+      if predict_response.outputs[0].status.code != status_code_pb2.SUCCESS:
+        logger.error(f"Moddel Prediction failed: {predict_response}")
+      else:
+        logger.info(f"Model Prediction succeeded: {predict_response}")
+
+    try:
+      generate_response = runner.generate(request)
+    except NotImplementedError:
+      logger.info("Model does not implement generate() method.")
+    except Exception as e:
+      logger.error(f"Model Generation failed: {e}")
+      traceback.print_exc()
+      generate_response = service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.MODEL_GENERATION_FAILED,
+          description="Generation failed",
+          details="",
+          internal_details=str(e),
+      ))
+
+    if generate_response:
+      generate_first_res = next(generate_response)
+      if generate_first_res.outputs[0].status.code != status_code_pb2.SUCCESS:
+        logger.error(f"Moddel Prediction failed: {generate_first_res}")
+      else:
+        logger.info(
+            f"Model Prediction succeeded for generate and first response: {generate_first_res}")
+
+    try:
+      stream_response = runner.stream(stream_request)
+    except NotImplementedError:
+      logger.info("Model does not implement stream() method.")
+    except Exception as e:
+      logger.error(f"Model Stream failed: {e}")
+      traceback.print_exc()
+      stream_response = service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.MODEL_STREAM_FAILED,
+          description="Stream failed",
+          details="",
+          internal_details=str(e),
+      ))
+
+    if stream_response:
+      stream_first_res = next(stream_response)
+      if stream_first_res.outputs[0].status.code != status_code_pb2.SUCCESS:
+        logger.error(f"Moddel Prediction failed: {stream_first_res}")
+      else:
+        logger.info(
+            f"Model Prediction succeeded for stream and first response: {stream_first_res}")
+
   def _run_test(self):
     """Test the model locally by making a prediction."""
-    # validate that we have checkpoints downloaded before constructing MyRunner
-    uploader = ModelUploader(self.model_path)
-    uploader.download_checkpoints()
     # construct MyRunner which will call load_model()
     MyRunner = self._get_model_runner()
     runner = MyRunner(
@@ -140,13 +208,8 @@ class ModelRunLocally:
         compute_cluster_id="n/a",
         user_id="n/a",
     )
-
     # send an inference.
-    response = self._run_model_inference(runner)
-    if response.outputs[0].status.code != status_code_pb2.SUCCESS:
-      logger.error(f"Moddel Prediction failed: {response}")
-    else:
-      logger.info(f"Model Prediction succeeded: {response}")
+    self._run_model_inference(runner)
 
   def test_model(self):
     """Test the model by running it locally in the virtual environment."""
@@ -156,31 +219,258 @@ class ModelRunLocally:
         f"import sys; sys.path.append('{os.path.dirname(os.path.abspath(__file__))}'); "
         f"from model_run_locally import ModelRunLocally; ModelRunLocally('{self.model_path}')._run_test()",
     ]
+    process = None
     try:
       logger.info("Testing the model locally...")
-      subprocess.check_call(command)
-      logger.info("Model tested successfully!")
+      process = subprocess.Popen(command)
+      # Wait for the process to complete
+      process.wait()
+      if process.returncode == 0:
+        logger.info("Model tested successfully!")
+      if process.returncode != 0:
+        raise subprocess.CalledProcessError(process.returncode, command)
     except subprocess.CalledProcessError as e:
       logger.error(f"Error testing the model: {e}")
       sys.exit(1)
+    except Exception as e:
+      logger.error(f"Unexpected error: {e}")
+      sys.exit(1)
+    finally:
+      # After the function runs, check if the process is still running
+      if process and process.poll() is None:
+        logger.info("Process is still running. Terminating process.")
+        process.terminate()
+        try:
+          process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+          logger.info("Process did not terminate gracefully. Killing process.")
+          # Kill the process if it doesn't terminate after 5 seconds
+          process.kill()
 
   # run the model server
-  def run_model_server(self):
+  def run_model_server(self, port=8080):
     """Run the Clarifai Runners's model server."""
 
     command = [
         self.python_executable, "-m", "clarifai.runners.server", "--model_path", self.model_path,
-        "--start_dev_server"
+        "--start_dev_server", "--port",
+        str(port)
     ]
     try:
-      logger.info(f"Starting model server with model at {self.model_path}...")
+      logger.info(
+          f"Starting model server at localhost:{port} with the model at {self.model_path}...")
       subprocess.check_call(command)
-      logger.info("Model server started successfully!")
+      logger.info("Model server started successfully and running at localhost:{port}")
     except subprocess.CalledProcessError as e:
       logger.error(f"Error running model server: {e}")
       self.clean_up()
       sys.exit(1)
 
+  def _docker_hash(self):
+    """Generate a hash of the combined requirements file and Dockefile"""
+    with open(self.requirements_file, "r") as f:
+      requirements_hash = hashlib.md5(f.read().encode('utf-8')).hexdigest()
+    with open(os.path.join(self.model_path, "Dockerfile"), "r") as f:
+      dockerfile_hash = hashlib.md5(f.read().encode('utf-8')).hexdigest()
+
+    return hashlib.md5(f"{requirements_hash}{dockerfile_hash}".encode('utf-8')).hexdigest()
+
+  def is_docker_installed(self):
+    """Checks if Docker is installed on the system."""
+    try:
+      logger.info("Checking if Docker is installed...")
+      subprocess.run(["docker", "--version"], check=True)
+      return True
+    except subprocess.CalledProcessError:
+      logger.error(
+          "Docker is not installed! Please install Docker to run the model in a container.")
+      return False
+
+  def build_docker_image(
+      self,
+      image_name="model_image",
+  ):
+    """Build the docker image using the Dockerfile in the model directory."""
+    try:
+      logger.info(f"Building docker image from Dockerfile in {self.model_path}...")
+
+      # since we don't want to copy the model directory into the container, we need to modify the Dockerfile and comment out the COPY instruction
+      dockerfile_path = os.path.join(self.model_path, "Dockerfile")
+      # Read the Dockerfile
+      with open(dockerfile_path, 'r') as file:
+        lines = file.readlines()
+
+      # Comment out the COPY instruction that copies the current folder
+      modified_lines = []
+      for line in lines:
+        if 'COPY .' in line and '/app/model_dir/main' in line:
+          modified_lines.append(f'# {line}')
+        else:
+          modified_lines.append(line)
+
+      # Create a temporary directory to store the modified Dockerfile
+      with tempfile.TemporaryDirectory() as temp_dir:
+        temp_dockerfile_path = os.path.join(temp_dir, "Dockerfile.temp")
+
+        # Write the modified Dockerfile to the temporary file
+        with open(temp_dockerfile_path, 'w') as file:
+          file.writelines(modified_lines)
+
+        # Build the Docker image using the temporary Dockerfile
+        subprocess.check_call(
+            ['docker', 'build', '-t', image_name, '-f', temp_dockerfile_path, self.model_path])
+      logger.info(f"Docker image '{image_name}' built successfully!")
+    except subprocess.CalledProcessError as e:
+      logger.info(f"Error occurred while building the Docker image: {e}")
+      sys.exit(1)
+
+  def docker_image_exists(self, image_name):
+    """Check if the Docker image exists."""
+    try:
+      logger.info(f"Checking if Docker image '{image_name}' exists...")
+      subprocess.run(["docker", "inspect", image_name], check=True)
+      logger.info(f"Docker image '{image_name}' exists!")
+      return True
+    except subprocess.CalledProcessError:
+      logger.info(f"Docker image '{image_name}' does not exist!")
+      return False
+
+  def run_docker_container(self,
+                           image_name,
+                           container_name="clarifai-model-container",
+                           port=8080,
+                           env_vars=None):
+    """Runs a Docker container from the specified image."""
+    try:
+      logger.info(f"Running Docker container '{container_name}' from image '{image_name}'...")
+      # Base docker run command
+      cmd = [
+          "docker", "run", "--name", container_name, '--rm', "--gpus", "all", "--network", "host"
+      ]
+      # Add volume mappings
+      cmd.extend(["-v", f"{self.model_path}:/app/model_dir/main"])
+      # Add environment variables
+      if env_vars:
+        for key, value in env_vars.items():
+          cmd.extend(["-e", f"{key}={value}"])
+      # Add the image name
+      cmd.append(image_name)
+      # update the CMD to run the server
+      cmd.extend(
+          ["--model_path", "/app/model_dir/main", "--start_dev_server", "--port",
+           str(port)])
+      # Run the container
+      process = subprocess.Popen(cmd,)
+      logger.info(
+          f"Docker container '{container_name}' is running successfully! access the model at http://localhost:{port}"
+      )
+
+      # Function to handle Ctrl+C (SIGINT) gracefully
+      def signal_handler(sig, frame):
+        logger.info(f"Stopping Docker container '{container_name}'...")
+        subprocess.run(["docker", "stop", container_name], check=True)
+        process.terminate()
+        logger.info(f"Docker container '{container_name}' stopped successfully!")
+        time.sleep(1)
+        sys.exit(0)
+
+      # Register the signal handler for SIGINT (Ctrl+C)
+      signal.signal(signal.SIGINT, signal_handler)
+      # Wait for the process to finish (keeps the container running until it's stopped)
+      process.wait()
+    except subprocess.CalledProcessError as e:
+      logger.info(f"Error occurred while running the Docker container: {e}")
+      sys.exit(1)
+    except Exception as e:
+      logger.info(f"Error occurred while running the Docker container: {e}")
+      sys.exit(1)
+
+  def test_model_container(self,
+                           image_name,
+                           container_name="clarifai-model-container",
+                           env_vars=None):
+    """Test the model inside the Docker container."""
+    try:
+      logger.info("Testing the model inside the Docker container...")
+      # Base docker run command
+      cmd = [
+          "docker", "run", "--name", container_name, '--rm', "--gpus", "all", "--network", "host"
+      ]
+      # update the entrypoint for testing the model
+      cmd.extend(["--entrypoint", "python"])
+      # Add volume mappings
+      cmd.extend(["-v", f"{self.model_path}:/app/model_dir/main"])
+      # Add environment variables
+      if env_vars:
+        for key, value in env_vars.items():
+          cmd.extend(["-e", f"{key}={value}"])
+      # Add the image name
+      cmd.append(image_name)
+      # update the CMD to test the model inside the container
+      cmd.extend([
+          "-c",
+          "from clarifai.runners.models.model_run_locally import ModelRunLocally; ModelRunLocally('/app/model_dir/main')._run_test()"
+      ])
+      # Run the container
+      subprocess.check_call(cmd)
+      logger.info("Model tested successfully!")
+    except subprocess.CalledProcessError as e:
+      logger.error(f"Error testing the model inside the Docker container: {e}")
+      sys.exit(1)
+
+  def container_exists(self, container_name="clarifai-model-container"):
+    """Check if the Docker container exists."""
+    try:
+      # Run docker ps -a to list all containers (running and stopped)
+      result = subprocess.run(
+          ["docker", "ps", "-a", "--filter", f"name={container_name}", "--format", "{{.Names}}"],
+          check=True,
+          capture_output=True,
+          text=True)
+      # If the container name is returned, it exists
+      if result.stdout.strip() == container_name:
+        logger.info(f"Docker container '{container_name}' exists.")
+        return True
+      else:
+        return False
+    except subprocess.CalledProcessError as e:
+      logger.error(f"Error occurred while checking if container exists: {e}")
+      return False
+
+  def stop_docker_container(self, container_name="clarifai-model-container"):
+    """Stop the Docker container if it's running."""
+    try:
+      # Check if the container is running
+      result = subprocess.run(
+          ["docker", "ps", "--filter", f"name={container_name}", "--format", "{{.Names}}"],
+          check=True,
+          capture_output=True,
+          text=True)
+      if result.stdout.strip() == container_name:
+        logger.info(f"Docker container '{container_name}' is running. Stopping it...")
+        subprocess.run(["docker", "stop", container_name], check=True)
+        logger.info(f"Docker container '{container_name}' stopped successfully!")
+    except subprocess.CalledProcessError as e:
+      logger.error(f"Error occurred while stopping the Docker container: {e}")
+
+  def remove_docker_container(self, container_name="clarifai-model-container"):
+    """Remove the Docker container."""
+    try:
+      logger.info(f"Removing Docker container '{container_name}'...")
+      subprocess.run(["docker", "rm", container_name], check=True)
+      logger.info(f"Docker container '{container_name}' removed successfully!")
+    except subprocess.CalledProcessError as e:
+      logger.error(f"Error occurred while removing the Docker container: {e}")
+
+  def remove_docker_image(self, image_name):
+    """Remove the Docker image."""
+    try:
+      logger.info(f"Removing Docker image '{image_name}'...")
+      subprocess.run(["docker", "rmi", image_name], check=True)
+      logger.info(f"Docker image '{image_name}' removed successfully!")
+    except subprocess.CalledProcessError as e:
+      logger.error(f"Error occurred while removing the Docker image: {e}")
+
   def clean_up(self):
     """Clean up the temporary virtual environment."""
     if os.path.exists(self.temp_dir):
@@ -188,18 +478,53 @@ class ModelRunLocally:
       shutil.rmtree(self.temp_dir)
 
 
-def main(model_path, run_model_server=False, keep_env=False):
+def main(model_path,
+         run_model_server=False,
+         inside_container=False,
+         port=8080,
+         keep_env=False,
+         keep_image=False):
 
+  if not os.environ['CLARIFAI_PAT']:
+    logger.error(
+        "CLARIFAI_PAT environment variable is not set! Please set your PAT in the 'CLARIFAI_PAT' environment variable."
+    )
+    sys.exit(1)
   manager = ModelRunLocally(model_path)
-  use_existing_env = manager.create_temp_venv()
-
-  try:
-    if not use_existing_env:
-      manager.install_requirements()
-    if run_model_server:
-      manager.run_model_server()
-    else:
-      manager.test_model()
-  finally:
-    if not keep_env:
-      manager.clean_up()
+  manager.uploader.download_checkpoints()
+  if inside_container:
+    if not manager.is_docker_installed():
+      sys.exit(1)
+    manager.uploader.create_dockerfile()
+    image_tag = manager._docker_hash()
+    image_name = f"{manager.config['model']['id']}:{image_tag}"
+    container_name = manager.config['model']['id']
+    if not manager.docker_image_exists(image_name):
+      manager.build_docker_image(image_name=image_name)
+    try:
+      envs = {'CLARIFAI_PAT': os.environ['CLARIFAI_PAT'], 'CLARIFAI_USER_ID': 'n/a'}
+      if run_model_server:
+        manager.run_docker_container(
+            image_name=image_name, container_name=container_name, port=port, env_vars=envs)
+      else:
+        manager.test_model_container(
+            image_name=image_name, container_name=container_name, env_vars=envs)
+    finally:
+      if manager.container_exists(container_name):
+        manager.stop_docker_container(container_name)
+        manager.remove_docker_container(container_name=container_name)
+      if not keep_image:
+        manager.remove_docker_image(image_name)
+
+  else:
+    try:
+      use_existing_env = manager.create_temp_venv()
+      if not use_existing_env:
+        manager.install_requirements()
+      if run_model_server:
+        manager.run_model_server(port)
+      else:
+        manager.test_model()
+    finally:
+      if not keep_env:
+        manager.clean_up()

clarifai/runners/models/model_upload.py

@@ -10,6 +10,9 @@ from google.protobuf import json_format
 from rich import print
 
 from clarifai.client import BaseClient
+from clarifai.runners.utils.const import (AVAILABLE_PYTHON_IMAGES, AVAILABLE_TORCH_IMAGES,
+                                          CONCEPTS_REQUIRED_MODEL_TYPE, DEFAULT_PYTHON_VERSION,
+                                          PYTHON_BASE_IMAGE, TORCH_BASE_IMAGE)
 from clarifai.runners.utils.loader import HuggingFaceLoader
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
@@ -23,48 +26,6 @@ def _clear_line(n: int = 1) -> None:
 
 
 class ModelUploader:
-  DEFAULT_PYTHON_VERSION = 3.11
-  DEFAULT_TORCH_VERSION = '2.4.0'
-  DEFAULT_CUDA_VERSION = '124'
-  # List of available torch images for matrix
-  '''
-        python_version: ['3.8', '3.9', '3.10', '3.11']
-        torch_version: ['2.0.0', '2.1.0', '2.2.0', '2.3.0', '2.4.0', '2.4.1', '2.5.0']
-        cuda_version: ['124']
-  '''
-  AVAILABLE_TORCH_IMAGES = [
-      '2.0.0-py3.8-cuda124',
-      '2.0.0-py3.9-cuda124',
-      '2.0.0-py3.10-cuda124',
-      '2.0.0-py3.11-cuda124',
-      '2.1.0-py3.8-cuda124',
-      '2.1.0-py3.9-cuda124',
-      '2.1.0-py3.10-cuda124',
-      '2.1.0-py3.11-cuda124',
-      '2.2.0-py3.8-cuda124',
-      '2.2.0-py3.9-cuda124',
-      '2.2.0-py3.10-cuda124',
-      '2.2.0-py3.11-cuda124',
-      '2.3.0-py3.8-cuda124',
-      '2.3.0-py3.9-cuda124',
-      '2.3.0-py3.10-cuda124',
-      '2.3.0-py3.11-cuda124',
-      '2.4.0-py3.8-cuda124',
-      '2.4.0-py3.9-cuda124',
-      '2.4.0-py3.10-cuda124',
-      '2.4.0-py3.11-cuda124',
-      '2.4.1-py3.8-cuda124',
-      '2.4.1-py3.9-cuda124',
-      '2.4.1-py3.10-cuda124',
-      '2.4.1-py3.11-cuda124',
-  ]
-  AVAILABLE_PYTHON_IMAGES = ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
-  PYTHON_BASE_IMAGE = 'public.ecr.aws/clarifai-models/python-base:{python_version}'
-  TORCH_BASE_IMAGE = 'public.ecr.aws/clarifai-models/torch:{torch_version}-py{python_version}-cuda{cuda_version}'
-
-  CONCEPTS_REQUIRED_MODEL_TYPE = [
-      'visual-classifier', 'visual-detector', 'visual-segmenter', 'text-classifier'
-  ]
 
   def __init__(self, folder: str):
     self._client = None
@@ -233,33 +194,35 @@ class ModelUploader:
     build_info = self.config.get('build_info', {})
     if 'python_version' in build_info:
       python_version = build_info['python_version']
-      if python_version not in self.AVAILABLE_PYTHON_IMAGES:
+      if python_version not in AVAILABLE_PYTHON_IMAGES:
         logger.error(
-            f"Python version {python_version} not supported, please use one of the following versions: {self.AVAILABLE_PYTHON_IMAGES}"
+            f"Python version {python_version} not supported, please use one of the following versions: {AVAILABLE_PYTHON_IMAGES}"
         )
         return
       logger.info(
           f"Using Python version {python_version} from the config file to build the Dockerfile")
     else:
       logger.info(
-          f"Python version not found in the config file, using default Python version: {self.DEFAULT_PYTHON_VERSION}"
+          f"Python version not found in the config file, using default Python version: {DEFAULT_PYTHON_VERSION}"
       )
-      python_version = self.DEFAULT_PYTHON_VERSION
+      python_version = DEFAULT_PYTHON_VERSION
 
-    base_image = self.PYTHON_BASE_IMAGE.format(python_version=python_version)
+    base_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
 
     # Parse the requirements.txt file to determine the base image
     dependencies = self._parse_requirements()
     if 'torch' in dependencies and dependencies['torch']:
       torch_version = dependencies['torch']
 
-      for image in self.AVAILABLE_TORCH_IMAGES:
+      for image in AVAILABLE_TORCH_IMAGES:
         if torch_version in image and f'py{python_version}' in image:
-          base_image = self.TORCH_BASE_IMAGE.format(
+          cuda_version = image.split('-')[-1].replace('cuda', '')
+          base_image = TORCH_BASE_IMAGE.format(
               torch_version=torch_version,
               python_version=python_version,
-              cuda_version=self.DEFAULT_CUDA_VERSION)
-          logger.info(f"Using Torch version {torch_version} base image  to build the Docker image")
+              cuda_version=cuda_version,
+          )
+          logger.info(f"Using Torch version {torch_version} base image to build the Docker image")
           break
 
     # Replace placeholders with actual values
@@ -314,7 +277,7 @@ class ModelUploader:
       config = yaml.safe_load(file)
     model = config.get('model')
     model_type_id = model.get('model_type_id')
-    assert model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE, f"Model type {model_type_id} not supported for concepts"
+    assert model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE, f"Model type {model_type_id} not supported for concepts"
     concept_protos = self._concepts_protos_from_concepts(labels)
 
     config['concepts'] = [{'id': concept.id, 'name': concept.name} for concept in concept_protos]
@@ -332,7 +295,7 @@ class ModelUploader:
     )
 
     model_type_id = self.config.get('model').get('model_type_id')
-    if model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE:
+    if model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE:
 
       if 'concepts' in self.config:
         labels = self.config.get('concepts')
@@ -347,7 +310,10 @@ class ModelUploader:
         labels = sorted(labels.items(), key=lambda x: int(x[0]))
 
         config_file = os.path.join(self.folder, 'config.yaml')
-        self.hf_labels_to_config(labels, config_file)
+        try:
+          self.hf_labels_to_config(labels, config_file)
+        except Exception as e:
+          logger.error(f"Failed to update the config.yaml file with the concepts: {e}")
 
         model_version_proto.output_info.data.concepts.extend(
             self._concepts_protos_from_concepts(labels))
@@ -359,7 +325,7 @@ class ModelUploader:
 
     model_type_id = self.config.get('model').get('model_type_id')
 
-    if (model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE) and 'concepts' not in self.config:
+    if (model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE) and 'concepts' not in self.config:
       logger.info(
           f"Model type {model_type_id} requires concepts to be specified in the config.yaml file.."
       )
@@ -473,8 +439,21 @@ class ModelUploader:
             is_v3=self.is_v3,
         ))
 
+  def get_model_build_logs(self):
+    logs_request = service_pb2.ListLogEntriesRequest(
+        log_type="builder",
+        user_app_id=self.client.user_app_id,
+        model_id=self.model_proto.id,
+        model_version_id=self.model_version_id,
+        page=1,
+        per_page=50)
+    response = self.client.STUB.ListLogEntries(logs_request)
+
+    return response
+
   def monitor_model_build(self):
     st = time.time()
+    seen_logs = set()  # To avoid duplicate log messages
     while True:
       resp = self.client.STUB.GetModelVersion(
           service_pb2.GetModelVersionRequest(
@@ -485,6 +464,13 @@ class ModelUploader:
       status_code = resp.model_version.status.code
       if status_code == status_code_pb2.MODEL_BUILDING:
         print(f"Model is building... (elapsed {time.time() - st:.1f}s)", end='\r', flush=True)
+
+        # Fetch and display the logs
+        logs = self.get_model_build_logs()
+        for log_entry in logs.log_entries:
+          if log_entry.url not in seen_logs:
+            seen_logs.add(log_entry.url)
+            print(f"Model Building Logs...: {log_entry.message.strip()}")
         time.sleep(1)
       elif status_code == status_code_pb2.MODEL_TRAINED:
         logger.info(f"\nModel build complete! (elapsed {time.time() - st:.1f}s)")

clarifai/runners/server.py

@@ -108,6 +108,7 @@ def main():
         runner_id="n/a",
         nodepool_id="n/a",
         compute_cluster_id="n/a",
+        user_id="n/a",
         health_check_port=None,  # not needed when running local server
     )
 
@@ -127,6 +128,7 @@ def main():
     service_pb2_grpc.add_V2Servicer_to_server(servicer, server)
     server.start()
     logger.info("Started server on port %s", parsed_args.port)
+    logger.info(f"Access the model at http://localhost:{parsed_args.port}")
     server.wait_for_termination()
   else:  # start the runner with the proper env variables and as a runner protocol.
 

clarifai/runners/utils/const.py

@@ -0,0 +1,40 @@
+PYTHON_BASE_IMAGE = 'public.ecr.aws/clarifai-models/python-base:{python_version}'
+TORCH_BASE_IMAGE = 'public.ecr.aws/clarifai-models/torch:{torch_version}-py{python_version}-cuda{cuda_version}'
+
+# List of available python base images
+AVAILABLE_PYTHON_IMAGES = ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+
+DEFAULT_PYTHON_VERSION = 3.11
+
+# List of available torch images
+AVAILABLE_TORCH_IMAGES = [
+    '1.13.1-py3.8-cuda117',
+    '1.13.1-py3.9-cuda117',
+    '1.13.1-py3.10-cuda117',
+    '2.1.2-py3.8-cuda121',
+    '2.1.2-py3.9-cuda121',
+    '2.1.2-py3.10-cuda121',
+    '2.1.2-py3.11-cuda121',
+    '2.2.2-py3.8-cuda121',
+    '2.2.2-py3.9-cuda121',
+    '2.2.2-py3.10-cuda121',
+    '2.2.2-py3.11-cuda121',
+    '2.2.2-py3.12-cuda121',
+    '2.3.1-py3.8-cuda121',
+    '2.3.1-py3.9-cuda121',
+    '2.3.1-py3.10-cuda121',
+    '2.3.1-py3.11-cuda121',
+    '2.3.1-py3.12-cuda121',
+    '2.4.1-py3.8-cuda124',
+    '2.4.1-py3.9-cuda124',
+    '2.4.1-py3.10-cuda124',
+    '2.4.1-py3.11-cuda124',
+    '2.4.1-py3.12-cuda124',
+    '2.5.1-py3.9-cuda124',
+    '2.5.1-py3.10-cuda124',
+    '2.5.1-py3.11-cuda124',
+    '2.5.1-py3.12-cuda124',
+]
+CONCEPTS_REQUIRED_MODEL_TYPE = [
+    'visual-classifier', 'visual-detector', 'visual-segmenter', 'text-classifier'
+]

{clarifai-10.11.0.dist-info → clarifai-10.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.11.0
+Version: 10.11.1
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,8 +20,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=10.10.2
-Requires-Dist: clarifai-protocol>=0.0.6
+Requires-Dist: clarifai-grpc>=10.11.2
+Requires-Dist: clarifai-protocol>=0.0.14
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: tritonclient>=2.34.0
@@ -31,7 +31,6 @@ Requires-Dist: schema==0.7.5
 Requires-Dist: Pillow>=9.5.0
 Requires-Dist: inquirerpy==0.3.4
 Requires-Dist: tabulate>=0.9.0
-Requires-Dist: protobuf==5.27.3
 Requires-Dist: fsspec==2024.6.1
 Requires-Dist: click==8.1.7
 Provides-Extra: all
@@ -73,6 +72,10 @@ Give the repo a star ⭐
 
 * **[Installation](#rocket-installation)**
 * **[Getting Started](#memo-getting-started)**
+* **[Compute Orchestration](#rocket-compute-orchestration)**
+  * [Cluster Operations](#cluster-operations)
+  * [Nodepool Operations](#nodepool-operations)
+  * [Depolyment Operations](#deployment-operations)
 * **[Interacting with Datasets](#floppy_disk-interacting-with-datasets)**
 * **[Interacting with Inputs](#floppy_disk-interacting-with-inputs)**
   * [Input Upload](#input-upload)
@@ -157,6 +160,73 @@ client = User(user_id="user_id", pat="your personal access token")
 ```
 
 
+## :rocket: Compute Orchestration
+
+Clarifai’s Compute Orchestration offers a streamlined solution for managing the infrastructure required for training, deploying, and scaling machine learning models and workflows.
+
+This flexible system supports any compute instance — across various hardware providers and deployment methods — and provides automatic scaling to match workload demands. [More Details](https://www.clarifai.com/products/compute-orchestration)
+
+#### Cluster Operations
+```python
+from clarifai.client.user import User
+client = User(user_id="user_id",base_url="https://api.clarifai.com")
+
+# Create a new compute cluster
+compute_cluster = client.create_compute_cluster(compute_cluster_id="demo-id",config_filepath="computer_cluster_config.yaml")
+
+# List Clusters
+all_compute_clusters = list(client.list_compute_clusters())
+print(all_compute_clusters)
+```
+##### [Example Cluster Config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/compute_cluster_config.yaml)
+
+
+
+#### Nodepool Operations
+```python
+from clarifai.client.compute_cluster import ComputeCluster
+
+# Initialize the ComputeCluster instance
+compute_cluster = ComputeCluster(user_id="user_id",compute_cluster_id="demo-id")
+
+# Create a new nodepool
+nodepool = compute_cluster.create_nodepool(nodepool_id="demo-nodepool-id",config_filepath="nodepool_config.yaml")
+
+#Get a nodepool
+nodepool = compute_cluster.nodepool(nodepool_id="demo-nodepool-id")
+print(nodepool)
+
+# List nodepools
+all_nodepools = list(compute_cluster.list_nodepools())
+print(all_nodepools)
+```
+##### [Example Nodepool config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/nodepool_config.yaml)
+
+#### Deployment Operations
+```python
+from clarifai.client.nodepool import Nodepool
+
+# Initialize the Nodepool instance
+nodepool = Nodepool(user_id="user_id",nodepool_id="demo-nodepool-id")
+
+# Create a new deployment
+deployment = nodepool.create_deployment(deployment_id="demo-deployment-id",config_filepath="deployment_config.yaml")
+
+#Get a deployment
+deployment = nodepool.deployment(nodepool_id="demo-deployment-id")
+print(deployment)
+
+# List deployments
+all_deployments = list(nodepool.list_deployments())
+print(all_deployments)
+
+```
+##### [Example Deployment config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/deployment_config.yaml)
+
+#### Compute Orchestration CLI Operations
+Refer Here: https://github.com/Clarifai/clarifai-python/tree/master/clarifai/cli
+
+
 ## :floppy_disk: Interacting with Datasets
 
 Clarifai datasets help in managing datasets used for model training and evaluation. It provides functionalities like creating datasets,uploading datasets, retrying failed uploads from logs and exporting datasets as .zip files.

{clarifai-10.11.0.dist-info → clarifai-10.11.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=QlkUWf1vZWZO1B4-0PjOW339CFFq5tlWz3teIz9l6-E,24
+clarifai/__init__.py,sha256=FW_6Eb2k6BFCnOXd3YfZT6V1LNiTbns6HVOCriUm7sE,24
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
 clarifai/versions.py,sha256=jctnczzfGk_S3EnVqb2FjRKfSREkNmvNEwAAa_VoKiQ,222
@@ -7,7 +7,7 @@ clarifai/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/cli/base.py,sha256=okuBNlMmLEQw9-0f4yzemCtneNNRTVXUugCwD58-ZtQ,3417
 clarifai/cli/compute_cluster.py,sha256=N2dNQNJEPg9nxsb8x2igEzYuGRzjn7l4kNttjFIxmhI,1827
 clarifai/cli/deployment.py,sha256=sUEuz5-rtozMx8deVcJXLi6lHsP2jc8x3y2MpUAVfqY,2506
-clarifai/cli/model.py,sha256=0DRp3TjySvRwyUnt-v1nqhYOcTnVtEZ0jdXH4TBtuQ8,2183
+clarifai/cli/model.py,sha256=_l-vIqQpVF54SyWadHz-_6-6tS8SYmdDJmpUhKGv9AM,10475
 clarifai/cli/nodepool.py,sha256=yihxS_rIFoBBKzRlqBX8Ab42iPpBMJrJFsk8saph6ms,3049
 clarifai/client/__init__.py,sha256=xI1U0l5AZdRThvQAXCLsd9axxyFzXXJ22m8LHqVjQRU,662
 clarifai/client/app.py,sha256=6pckYme1urV2YJjLIYfeZ-vH0Z5YSQa51jzIMcEfwug,38342
@@ -58,19 +58,20 @@ clarifai/modules/css.py,sha256=kadCEunmyh5h2yf0-4aysE3ZcZ6qaQcxuAgDXS96yF8,2020
 clarifai/modules/pages.py,sha256=iOoM3RNRMgXlV0qBqcdQofxoXo2RuRQh0h9c9BIS0-I,1383
 clarifai/modules/style.css,sha256=j7FNPZVhLPj35vvBksAJ90RuX5sLuqzDR5iM2WIEhiA,6073
 clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
-clarifai/rag/rag.py,sha256=L10TcV9E0PF1aJ2Nn1z1x6WVoUoGxbKt20lQXg8ksqo,12594
+clarifai/rag/rag.py,sha256=bqUWnfdf91OYMucEK0_rJXDwg0oKjz5c7eda-9CPXu8,12680
 clarifai/rag/utils.py,sha256=yr1jAcbpws4vFGBqlAwPPE7v1DRba48g8gixLFw8OhQ,4070
 clarifai/runners/__init__.py,sha256=3vr4RVvN1IRy2SxJpyycAAvrUBbH-mXR7pqUmu4w36A,412
-clarifai/runners/server.py,sha256=CVLrv2DjzCvKVXcJ4SWvcFWUZq0bdlBmyEpfVlfgT2A,4902
-clarifai/runners/dockerfile_template/Dockerfile.template,sha256=-T38Rscpjot8WVuUTUq1_N0xz_gg653FOHV4XQYGG-U,1453
+clarifai/runners/server.py,sha256=Z46BCUqpb3GpcD59qJKb7rL5dpl6vzMYNG3o0MGzox8,5001
+clarifai/runners/dockerfile_template/Dockerfile.template,sha256=mW3Bdu9elMpI75UbBD0JX8rS085FXEPUPDVXkHibxiE,1548
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/models/base_typed_model.py,sha256=DWEUK5ge9NVZE6LkT3BNTFYjYMPHz-nDgPA48Y0DGXU,7859
 clarifai/runners/models/model_class.py,sha256=9JSPAr4U4K7xI0kSl-q0mHB06zknm2OR-8XIgBCto94,1611
-clarifai/runners/models/model_run_locally.py,sha256=6LgRzTTDjmGvAV6gEUhW3T3yoCMpLqkOUGa4anZUbig,7144
+clarifai/runners/models/model_run_locally.py,sha256=OhzQbmaV8Wwgs2H0KhdDF6Z7bYSaIh4RRA0QwSiv5vY,20644
 clarifai/runners/models/model_runner.py,sha256=3vzoastQxkGRDK8T9aojDsLNBb9A3IiKm6YmbFrE9S0,6241
 clarifai/runners/models/model_servicer.py,sha256=X4715PVA5PBurRTYcwSEudg8fShGV6InAF4mmRlRcHg,2826
-clarifai/runners/models/model_upload.py,sha256=N3KCAHibeTJdnlDx1vixYkV1vl6lI6GA8LL7TuvUax8,20430
+clarifai/runners/models/model_upload.py,sha256=xQ0AqeBVePPwmMVM5uOiXRTRV09U-du2FduKv7Qgl-A,20087
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clarifai/runners/utils/const.py,sha256=zINrIjDESUykq6xMLKNghwJ6N8qxDAtAJ6-1bH8VdOw,1238
 clarifai/runners/utils/data_handler.py,sha256=sxy9zlAgI6ETuxCQhUgEXAn2GCsaW1GxpK6GTaMne0g,6966
 clarifai/runners/utils/data_utils.py,sha256=R1iQ82TuQ9JwxCJk8yEB1Lyb0BYVhVbWJI9YDi1zGOs,318
 clarifai/runners/utils/loader.py,sha256=1oktDUQA1Lpv0NiCXFwoxpp0jqqbvB7sWvpymwyWY2E,4243
@@ -91,9 +92,9 @@ clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 clarifai/workflows/export.py,sha256=vICRhIreqDSShxLKjHNM2JwzKsf1B4fdXB0ciMcA70k,1945
 clarifai/workflows/utils.py,sha256=nGeB_yjVgUO9kOeKTg4OBBaBz-AwXI3m-huSVj-9W18,1924
 clarifai/workflows/validate.py,sha256=yJq03MaJqi5AK3alKGJJBR89xmmjAQ31sVufJUiOqY8,2556
-clarifai-10.11.0.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-10.11.0.dist-info/METADATA,sha256=C1A5Myx1yQUdZRhpNDzOV-zm6a7OfBVbSireNn1e7mY,19550
-clarifai-10.11.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-clarifai-10.11.0.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-10.11.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-10.11.0.dist-info/RECORD,,
+clarifai-10.11.1.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-10.11.1.dist-info/METADATA,sha256=w46FTa1y_xtH2ZXLrCYI9dC0o-Uh48q7gqC_kXYZ50A,22220
+clarifai-10.11.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+clarifai-10.11.1.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-10.11.1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-10.11.1.dist-info/RECORD,,