clarifai 10.11.0__py3-none-any.whl → 10.11.2rc1__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.11.0"
+__version__ = "10.11.2rc1"

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/client/dataset.py

@@ -281,9 +281,9 @@ class Dataset(Lister, BaseClient):
       failed_input_ids = list(set(failed_input_ids) - set(duplicate_input_ids))
       duplicate_details = [[
           input_ids[id], id, "Input has a duplicate ID.",
-          dataset_obj.data_generator[input_ids[id]].image_path,
-          dataset_obj.data_generator[input_ids[id]].labels,
-          dataset_obj.data_generator[input_ids[id]].metadata
+          getattr(dataset_obj.data_generator[input_ids[id]], 'image_path', None),
+          getattr(dataset_obj.data_generator[input_ids[id]], 'labels', None),
+          getattr(dataset_obj.data_generator[input_ids[id]], 'metadata', None)
       ] for id in duplicate_input_ids]
       duplicate_table = tabulate(
           duplicate_details,
@@ -386,7 +386,7 @@ class Dataset(Lister, BaseClient):
           tablefmt="grid")
       timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
       self.logger.warning(
-          f"{timestamp}\nFailed to upload {len(failed_retrying_inputs)} inputs in current batch {batch_no}:\n{failed_table}\n\n"
+          f"{timestamp}\nFailed to upload {len(failed_retrying_inputs)} inputs in current batch {batch_no} due to {retry_response}:\n{failed_table}\n\n"
       )
 
   def _data_upload(self,

clarifai/client/model.py

@@ -503,6 +503,7 @@ class Model(Lister, BaseClient):
                           compute_cluster_id: str = None,
                           nodepool_id: str = None,
                           deployment_id: str = None,
+                          user_id: str = None,
                           inference_params: Dict = {},
                           output_config: Dict = {}):
     """Predicts the model based on the given filepath.
@@ -534,7 +535,7 @@ class Model(Lister, BaseClient):
       file_bytes = f.read()
 
     return self.predict_by_bytes(file_bytes, input_type, compute_cluster_id, nodepool_id,
-                                 deployment_id, inference_params, output_config)
+                                 deployment_id, user_id, inference_params, output_config)
 
   def predict_by_bytes(self,
                        input_bytes: bytes,
@@ -542,6 +543,7 @@ class Model(Lister, BaseClient):
                        compute_cluster_id: str = None,
                        nodepool_id: str = None,
                        deployment_id: str = None,
+                       user_id: str = None,
                        inference_params: Dict = {},
                        output_config: Dict = {}):
     """Predicts the model based on the given bytes.
@@ -581,11 +583,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.predict(
         inputs=[input_proto],
@@ -599,6 +613,7 @@ class Model(Lister, BaseClient):
                      compute_cluster_id: str = None,
                      nodepool_id: str = None,
                      deployment_id: str = None,
+                     user_id: str = None,
                      inference_params: Dict = {},
                      output_config: Dict = {}):
     """Predicts the model based on the given URL.
@@ -639,11 +654,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.predict(
         inputs=[input_proto],
@@ -712,6 +739,7 @@ class Model(Lister, BaseClient):
                            compute_cluster_id: str = None,
                            nodepool_id: str = None,
                            deployment_id: str = None,
+                           user_id: str = None,
                            inference_params: Dict = {},
                            output_config: Dict = {}):
     """Generate the stream output on model based on the given filepath.
@@ -748,6 +776,7 @@ class Model(Lister, BaseClient):
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,
         deployment_id=deployment_id,
+        user_id=user_id,
         inference_params=inference_params,
         output_config=output_config)
 
@@ -757,6 +786,7 @@ class Model(Lister, BaseClient):
                         compute_cluster_id: str = None,
                         nodepool_id: str = None,
                         deployment_id: str = None,
+                        user_id: str = None,
                         inference_params: Dict = {},
                         output_config: Dict = {}):
     """Generate the stream output on model based on the given bytes.
@@ -798,11 +828,21 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.generate(
         inputs=[input_proto],
@@ -816,6 +856,7 @@ class Model(Lister, BaseClient):
                       compute_cluster_id: str = None,
                       nodepool_id: str = None,
                       deployment_id: str = None,
+                      user_id: str = None,
                       inference_params: Dict = {},
                       output_config: Dict = {}):
     """Generate the stream output on model based on the given URL.
@@ -857,11 +898,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.generate(
         inputs=[input_proto],
@@ -930,6 +983,7 @@ class Model(Lister, BaseClient):
                          compute_cluster_id: str = None,
                          nodepool_id: str = None,
                          deployment_id: str = None,
+                         user_id: str = None,
                          inference_params: Dict = {},
                          output_config: Dict = {}):
     """Stream the model output based on the given filepath.
@@ -964,6 +1018,7 @@ class Model(Lister, BaseClient):
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,
         deployment_id=deployment_id,
+        user_id=user_id,
         inference_params=inference_params,
         output_config=output_config)
 
@@ -973,6 +1028,7 @@ class Model(Lister, BaseClient):
                       compute_cluster_id: str = None,
                       nodepool_id: str = None,
                       deployment_id: str = None,
+                      user_id: str = None,
                       inference_params: Dict = {},
                       output_config: Dict = {}):
     """Stream the model output based on the given bytes.
@@ -1016,11 +1072,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.stream(
         inputs=input_generator(),
@@ -1034,6 +1102,7 @@ class Model(Lister, BaseClient):
                     compute_cluster_id: str = None,
                     nodepool_id: str = None,
                     deployment_id: str = None,
+                    user_id: str = None,
                     inference_params: Dict = {},
                     output_config: Dict = {}):
     """Stream the model output based on the given URL.
@@ -1075,11 +1144,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.stream(
         inputs=input_generator(),

clarifai/datasets/upload/features.py

@@ -7,7 +7,7 @@ from typing import List, Optional, Union
 class TextFeatures:
   """Text classification datasets preprocessing output features."""
   text: str
-  labels: List[Union[str, int]]  # List[str or int] to cater for multi-class tasks
+  labels: List[Union[str, int]] = None  # List[str or int] to cater for multi-class tasks
   id: Optional[int] = None  # text_id
   metadata: Optional[dict] = None
   label_ids: Optional[List[str]] = None

clarifai/datasets/upload/multimodal.py

@@ -34,7 +34,8 @@ class MultiModalDataset(ClarifaiDataset):
       metadata = Struct()
       image_bytes = data_item.image_bytes
       text = data_item.text
-      labels = data_item.labels if isinstance(data_item.labels, list) else [data_item.labels]
+      labels = data_item.labels if ((data_item.labels is None) or
+                                    isinstance(data_item.labels, list)) else [data_item.labels]
       input_id = f"{self.dataset_id}-{id}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None:
         metadata.update(data_item.metadata)

clarifai/datasets/upload/text.py

@@ -34,8 +34,9 @@ class TextClassificationDataset(ClarifaiDataset):
       data_item = self.data_generator[id]
       metadata = Struct()
       text = data_item.text
-      labels = data_item.labels if isinstance(data_item.labels,
-                                              list) else [data_item.labels]  # clarifai concept
+      labels = data_item.labels if ((data_item.labels is None) or
+                                    isinstance(data_item.labels, list)) else [data_item.labels
+                                                                             ]  # clarifai concept
       label_ids = data_item.label_ids
       input_id = f"{self.dataset_id}-{get_uuid(8)}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None: