clarifai 10.8.4__py3-none-any.whl → 10.8.6__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.8.4"
+__version__ = "10.8.6"

clarifai/client/dataset.py

@@ -25,6 +25,7 @@ from clarifai.datasets.export.inputs_annotations import (DatasetExportReader,
 from clarifai.datasets.upload.base import ClarifaiDataLoader
 from clarifai.datasets.upload.image import (VisualClassificationDataset, VisualDetectionDataset,
                                             VisualSegmentationDataset)
+from clarifai.datasets.upload.multimodal import MultiModalDataset
 from clarifai.datasets.upload.text import TextClassificationDataset
 from clarifai.datasets.upload.utils import DisplayUploadStatus
 from clarifai.errors import UserError
@@ -352,14 +353,15 @@ class Dataset(Lister, BaseClient):
         if input_details:
           failed_input_details = [
               index, failed_id, input_details.status.details,
-              dataset_obj.data_generator[index].image_path,
+              getattr(dataset_obj.data_generator[index], 'image_path', None) or
+              getattr(dataset_obj.data_generator[index], 'text', None),
               dataset_obj.data_generator[index].labels, dataset_obj.data_generator[index].metadata
           ]
           failed_inputs_logs.append(failed_input_details)
 
       failed_table = tabulate(
           failed_inputs_logs,
-          headers=["Index", "Input ID", "Status", "Image Path", "Labels", "Metadata"],
+          headers=["Index", "Input ID", "Status", "Input", "Labels", "Metadata"],
           tablefmt="grid")
       timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
       self.logger.warning(
@@ -422,7 +424,8 @@ class Dataset(Lister, BaseClient):
     if self.task not in DATASET_UPLOAD_TASKS:
       raise UserError("Task should be one of \
                       'text_classification', 'visual_classification', \
-                      'visual_detection', 'visual_segmentation', 'visual_captioning'")
+                      'visual_detection', 'visual_segmentation', 'visual_captioning', 'multimodal_dataset'"
+                     )
 
     if self.task == "text_classification":
       dataset_obj = TextClassificationDataset(dataloader, self.id)
@@ -433,6 +436,9 @@ class Dataset(Lister, BaseClient):
     elif self.task == "visual_segmentation":
       dataset_obj = VisualSegmentationDataset(dataloader, self.id)
 
+    elif self.task == "multimodal_dataset":
+      dataset_obj = MultiModalDataset(dataloader, self.id)
+
     else:  # visual_classification & visual_captioning
       dataset_obj = VisualClassificationDataset(dataloader, self.id)
 

clarifai/constants/dataset.py

@@ -1,6 +1,6 @@
 DATASET_UPLOAD_TASKS = [
     "visual_classification", "text_classification", "visual_detection", "visual_segmentation",
-    "visual_captioning"
+    "visual_captioning", "multimodal_dataset"
 ]
 
 TASK_TO_ANNOTATION_TYPE = {

clarifai/datasets/upload/base.py

@@ -4,21 +4,24 @@ from typing import Iterator, List, Tuple, TypeVar, Union
 from clarifai_grpc.grpc.api import resources_pb2
 
 from clarifai.constants.dataset import DATASET_UPLOAD_TASKS
-from clarifai.datasets.upload.features import (TextFeatures, VisualClassificationFeatures,
+from clarifai.datasets.upload.features import (MultiModalFeatures, TextFeatures,
+                                               VisualClassificationFeatures,
                                                VisualDetectionFeatures, VisualSegmentationFeatures)
 
 OutputFeaturesType = TypeVar(
     'OutputFeaturesType',
     bound=Union[TextFeatures, VisualClassificationFeatures, VisualDetectionFeatures,
-                VisualSegmentationFeatures])
+                VisualSegmentationFeatures, MultiModalFeatures])
 
 
 class ClarifaiDataset:
   """Clarifai datasets base class."""
 
-  def __init__(self, data_generator: 'ClarifaiDataLoader', dataset_id: str) -> None:
+  def __init__(self, data_generator: 'ClarifaiDataLoader', dataset_id: str,
+               max_workers: int = 4) -> None:
     self.data_generator = data_generator
     self.dataset_id = dataset_id
+    self.max_workers = max_workers
     self.all_input_ids = {}
     self._all_input_protos = {}
     self._all_annotation_protos = defaultdict(list)

clarifai/datasets/upload/features.py

@@ -49,3 +49,13 @@ class VisualSegmentationFeatures:
   metadata: Optional[dict] = None
   image_bytes: Optional[bytes] = None
   label_ids: Optional[List[str]] = None
+
+
+@dataclass
+class MultiModalFeatures:
+  """Multi-modal datasets preprocessing output features."""
+  text: str
+  image_bytes: str
+  labels: List[Union[str, int]] = None  # List[str or int] to cater for multi-class tasks
+  id: Optional[int] = None  # image_id
+  metadata: Optional[dict] = None

clarifai/datasets/upload/image.py

@@ -1,5 +1,4 @@
 import os
-import uuid
 from concurrent.futures import ThreadPoolExecutor
 from typing import List, Tuple, Type
 
@@ -8,12 +7,16 @@ from google.protobuf.struct_pb2 import Struct
 
 from clarifai.client.input import Inputs
 from clarifai.datasets.upload.base import ClarifaiDataLoader, ClarifaiDataset
+from clarifai.utils.misc import get_uuid
 
 
 class VisualClassificationDataset(ClarifaiDataset):
 
-  def __init__(self, data_generator: Type[ClarifaiDataLoader], dataset_id: str) -> None:
-    super().__init__(data_generator, dataset_id)
+  def __init__(self,
+               data_generator: Type[ClarifaiDataLoader],
+               dataset_id: str,
+               max_workers: int = 4) -> None:
+    super().__init__(data_generator, dataset_id, max_workers)
 
   def _extract_protos(self, batch_input_ids: List[str]
                      ) -> Tuple[List[resources_pb2.Input], List[resources_pb2.Annotation]]:
@@ -33,7 +36,7 @@ class VisualClassificationDataset(ClarifaiDataset):
       labels = data_item.labels if isinstance(data_item.labels,
                                               list) else [data_item.labels]  # clarifai concept
       label_ids = data_item.label_ids
-      input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
+      input_id = f"{self.dataset_id}-{get_uuid(8)}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       geo_info = data_item.geo_info
       if data_item.metadata is not None:
         metadata.update(data_item.metadata)
@@ -64,7 +67,7 @@ class VisualClassificationDataset(ClarifaiDataset):
                 geo_info=geo_info,
                 metadata=metadata))
 
-    with ThreadPoolExecutor(max_workers=4) as executor:
+    with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
       futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
       for job in futures:
         job.result()
@@ -75,8 +78,11 @@ class VisualClassificationDataset(ClarifaiDataset):
 class VisualDetectionDataset(ClarifaiDataset):
   """Visual detection dataset proto class."""
 
-  def __init__(self, data_generator: Type[ClarifaiDataLoader], dataset_id: str) -> None:
-    super().__init__(data_generator, dataset_id)
+  def __init__(self,
+               data_generator: Type[ClarifaiDataLoader],
+               dataset_id: str,
+               max_workers: int = 4) -> None:
+    super().__init__(data_generator, dataset_id, max_workers)
 
   def _extract_protos(self, batch_input_ids: List[int]
                      ) -> Tuple[List[resources_pb2.Input], List[resources_pb2.Annotation]]:
@@ -101,7 +107,7 @@ class VisualDetectionDataset(ClarifaiDataset):
       else:
         label_ids = None
       bboxes = data_item.bboxes  # [[xmin,ymin,xmax,ymax],...,[xmin,ymin,xmax,ymax]]
-      input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
+      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:
         metadata.update(data_item.metadata)
       else:
@@ -135,7 +141,7 @@ class VisualDetectionDataset(ClarifaiDataset):
                 bbox=bboxes[i],
                 label_id=label_ids[i] if label_ids else None))
 
-    with ThreadPoolExecutor(max_workers=4) as executor:
+    with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
       futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
       for job in futures:
         job.result()
@@ -146,8 +152,11 @@ class VisualDetectionDataset(ClarifaiDataset):
 class VisualSegmentationDataset(ClarifaiDataset):
   """Visual segmentation dataset proto class."""
 
-  def __init__(self, data_generator: Type[ClarifaiDataLoader], dataset_id: str) -> None:
-    super().__init__(data_generator, dataset_id)
+  def __init__(self,
+               data_generator: Type[ClarifaiDataLoader],
+               dataset_id: str,
+               max_workers: int = 4) -> None:
+    super().__init__(data_generator, dataset_id, max_workers)
 
   def _extract_protos(self, batch_input_ids: List[str]
                      ) -> Tuple[List[resources_pb2.Input], List[resources_pb2.Annotation]]:
@@ -172,7 +181,7 @@ class VisualSegmentationDataset(ClarifaiDataset):
       else:
         label_ids = None
       _polygons = data_item.polygons  # list of polygons: [[[x,y],...,[x,y]],...]
-      input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
+      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:
         metadata.update(data_item.metadata)
       else:
@@ -210,7 +219,7 @@ class VisualSegmentationDataset(ClarifaiDataset):
         except IndexError:
           continue
 
-    with ThreadPoolExecutor(max_workers=4) as executor:
+    with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
       futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
       for job in futures:
         job.result()

clarifai/datasets/upload/multimodal.py

@@ -0,0 +1,70 @@
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Tuple, Type
+
+from clarifai_grpc.grpc.api import resources_pb2
+from google.protobuf.struct_pb2 import Struct
+
+from clarifai.client.input import Inputs
+from clarifai.datasets.upload.base import ClarifaiDataLoader, ClarifaiDataset
+from clarifai.utils.misc import get_uuid
+
+
+class MultiModalDataset(ClarifaiDataset):
+
+  def __init__(self,
+               data_generator: Type[ClarifaiDataLoader],
+               dataset_id: str,
+               max_workers: int = 4) -> None:
+    super().__init__(data_generator, dataset_id, max_workers)
+
+  def _extract_protos(
+      self,
+      batch_input_ids: List[str],
+  ) -> Tuple[List[resources_pb2.Input]]:
+    """ Creats Multimodal (image and text) input protos for batch of input ids.
+        Args:
+            batch_input_ids: List of input IDs to retrieve the protos for.
+        Returns:
+            input_protos: List of input protos.
+
+        """
+    input_protos, annotation_protos = [], []
+
+    def process_data_item(id):
+      data_item = self.data_generator[id]
+      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]
+      id = get_uuid(8)
+      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)
+      else:
+        metadata = None
+
+      self.all_input_ids[id] = input_id
+      if data_item.image_bytes is not None:
+        input_protos.append(
+            Inputs.get_input_from_bytes(
+                input_id=input_id,
+                image_bytes=image_bytes,
+                dataset_id=self.dataset_id,
+                labels=labels,
+                metadata=metadata))
+      else:
+        input_protos.append(
+            Inputs.get_text_input(
+                input_id=input_id,
+                raw_text=text,
+                dataset_id=self.dataset_id,
+                labels=labels,
+                metadata=metadata))
+
+    with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+      futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
+
+      for job in futures:
+        job.result()
+
+    return input_protos, annotation_protos

clarifai/datasets/upload/text.py

@@ -1,4 +1,3 @@
-import uuid
 from concurrent.futures import ThreadPoolExecutor
 from typing import List, Tuple, Type
 
@@ -6,6 +5,7 @@ from clarifai_grpc.grpc.api import resources_pb2
 from google.protobuf.struct_pb2 import Struct
 
 from clarifai.client.input import Inputs
+from clarifai.utils.misc import get_uuid
 
 from .base import ClarifaiDataLoader, ClarifaiDataset
 
@@ -13,8 +13,11 @@ from .base import ClarifaiDataLoader, ClarifaiDataset
 class TextClassificationDataset(ClarifaiDataset):
   """Upload text classification datasets to clarifai datasets"""
 
-  def __init__(self, data_generator: Type[ClarifaiDataLoader], dataset_id: str) -> None:
-    super().__init__(data_generator, dataset_id)
+  def __init__(self,
+               data_generator: Type[ClarifaiDataLoader],
+               dataset_id: str,
+               max_workers: int = 4) -> None:
+    super().__init__(data_generator, dataset_id, max_workers)
 
   def _extract_protos(self, batch_input_ids: List[int]
                      ) -> Tuple[List[resources_pb2.Input], List[resources_pb2.Annotation]]:
@@ -34,7 +37,7 @@ class TextClassificationDataset(ClarifaiDataset):
       labels = data_item.labels if isinstance(data_item.labels,
                                               list) else [data_item.labels]  # clarifai concept
       label_ids = data_item.label_ids
-      input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
+      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:
         metadata.update(data_item.metadata)
 
@@ -48,7 +51,7 @@ class TextClassificationDataset(ClarifaiDataset):
               label_ids=label_ids,
               metadata=metadata))
 
-    with ThreadPoolExecutor(max_workers=4) as executor:
+    with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
       futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
       for job in futures:
         job.result()

clarifai/runners/models/model_upload.py

@@ -28,12 +28,11 @@ class ModelUploader:
   ]
 
   def __init__(self, folder: str):
+    self._client = None
     self.folder = self._validate_folder(folder)
     self.config = self._load_config(os.path.join(self.folder, 'config.yaml'))
-    self.initialize_client()
     self.model_proto = self._get_model_proto()
     self.model_id = self.model_proto.id
-    self.user_app_id = self.client.user_app_id
     self.inference_compute_info = self._get_inference_compute_info()
     self.is_v3 = True  # Do model build for v3
 
@@ -42,6 +41,8 @@ class ModelUploader:
     if not folder.startswith("/"):
       folder = os.path.join(os.getcwd(), folder)
     print(f"Validating folder: {folder}")
+    if not os.path.exists(folder):
+      raise FileNotFoundError(f"Folder {folder} not found, please provide a valid folder path")
     files = os.listdir(folder)
     assert "requirements.txt" in files, "requirements.txt not found in the folder"
     assert "config.yaml" in files, "config.yaml not found in the folder"
@@ -56,18 +57,21 @@ class ModelUploader:
       config = yaml.safe_load(file)
     return config
 
-  def initialize_client(self):
-    assert "model" in self.config, "model info not found in the config file"
-    model = self.config.get('model')
-    assert "user_id" in model, "user_id not found in the config file"
-    assert "app_id" in model, "app_id not found in the config file"
-    user_id = model.get('user_id')
-    app_id = model.get('app_id')
+  @property
+  def client(self):
+    if self._client is None:
+      assert "model" in self.config, "model info not found in the config file"
+      model = self.config.get('model')
+      assert "user_id" in model, "user_id not found in the config file"
+      assert "app_id" in model, "app_id not found in the config file"
+      user_id = model.get('user_id')
+      app_id = model.get('app_id')
 
-    base = os.environ.get('CLARIFAI_API_BASE', 'https://api-dev.clarifai.com')
+      base = os.environ.get('CLARIFAI_API_BASE', 'https://api-dev.clarifai.com')
 
-    self.client = BaseClient(user_id=user_id, app_id=app_id, base=base)
-    print(f"Client initialized for user {user_id} and app {app_id}")
+      self._client = BaseClient(user_id=user_id, app_id=app_id, base=base)
+      print(f"Client initialized for user {user_id} and app {app_id}")
+    return self._client
 
   def _get_model_proto(self):
     assert "model" in self.config, "model info not found in the config file"
@@ -127,7 +131,14 @@ class ModelUploader:
 
     # Get the Python version from the config file
     build_info = self.config.get('build_info', {})
-    python_version = build_info.get('python_version', self.DEFAULT_PYTHON_VERSION)
+    if 'python_version' in build_info:
+      python_version = build_info['python_version']
+      print(f"Using Python version {python_version} from the config file to build the Dockerfile")
+    else:
+      print(
+          f"Python version not found in the config file, using default Python version: {self.DEFAULT_PYTHON_VERSION}"
+      )
+      python_version = self.DEFAULT_PYTHON_VERSION
 
     # Replace placeholders with actual values
     dockerfile_content = dockerfile_template.safe_substitute(
@@ -153,7 +164,12 @@ class ModelUploader:
       assert "repo_id" in self.config.get("checkpoints"), "No repo_id specified in the config file"
       repo_id = self.config.get("checkpoints").get("repo_id")
 
-      hf_token = self.config.get("checkpoints").get("hf_token", None)
+      # prefer env var for HF_TOKEN but if not provided then use the one from config.yaml if any.
+      if 'HF_TOKEN' in os.environ:
+        hf_token = os.environ['HF_TOKEN']
+      else:
+        hf_token = self.config.get("checkpoints").get("hf_token", None)
+        assert hf_token != 'hf_token', "The default 'hf_token' is not valid. Please provide a valid token or leave that field out of config.yaml if not needed."
       loader = HuggingFaceLoarder(repo_id=repo_id, token=hf_token)
 
       checkpoint_path = os.path.join(self.folder, '1', 'checkpoints')
@@ -230,6 +246,7 @@ class ModelUploader:
       print(
           f"Status: {response.status.description}, "
           f"Progress: {percent_completed}% - {details} ",
+          f"request_id: {response.status.req_id}",
           end='\r',
           flush=True)
     print()
@@ -247,24 +264,35 @@ class ModelUploader:
       file_size = os.path.getsize(file_path)
       chunk_size = int(127 * 1024 * 1024)  # 127MB chunk size
       num_chunks = (file_size // chunk_size) + 1
-
+      print("Uploading file...")
+      print("File size: ", file_size)
+      print("Chunk size: ", chunk_size)
+      print("Number of chunks: ", num_chunks)
       read_so_far = 0
       for part_id in range(num_chunks):
-        chunk = f.read(chunk_size)
-        read_so_far += len(chunk)
-        yield service_pb2.PostModelVersionsUploadRequest(
-            content_part=resources_pb2.UploadContentPart(
-                data=chunk,
-                part_number=part_id + 1,
-                range_start=read_so_far,
-            ))
-    print("\nUpload complete!, waiting for model build...")
+        try:
+          chunk_size = min(chunk_size, file_size - read_so_far)
+          chunk = f.read(chunk_size)
+          if not chunk:
+            break
+          read_so_far += len(chunk)
+          yield service_pb2.PostModelVersionsUploadRequest(
+              content_part=resources_pb2.UploadContentPart(
+                  data=chunk,
+                  part_number=part_id + 1,
+                  range_start=read_so_far,
+              ))
+        except Exception as e:
+          print(f"\nError uploading file: {e}")
+          break
+
+    if read_so_far == file_size:
+      print("\nUpload complete!, waiting for model build...")
 
   def init_upload_model_version(self, model_version, file_path):
     file_size = os.path.getsize(file_path)
-    print(
-        f"Uploading model version '{model_version.id}' with file '{os.path.basename(file_path)}' of size {file_size} bytes..."
-    )
+    print(f"Uploading model version '{model_version.id}' of model {self.model_proto.id}")
+    print(f"Using file '{os.path.basename(file_path)}' of size: {file_size} bytes")
     return service_pb2.PostModelVersionsUploadRequest(
         upload_config=service_pb2.PostModelVersionsUploadConfig(
             user_app_id=self.client.user_app_id,
@@ -290,7 +318,7 @@ class ModelUploader:
       elif status_code == status_code_pb2.MODEL_TRAINED:
         print("\nModel build complete!")
         print(
-            f"Check out the model at https://clarifai.com/{self.user_app_id.user_id}/apps/{self.user_app_id.app_id}/models/{self.model_id}/versions/{model_version_id}"
+            f"Check out the model at https://clarifai.com/{self.client.user_app_id.user_id}/apps/{self.client.user_app_id.app_id}/models/{self.model_id}/versions/{model_version_id}"
         )
         break
       else:
@@ -298,9 +326,10 @@ class ModelUploader:
         break
 
 
-def main(folder):
+def main(folder, download_checkpoints):
   uploader = ModelUploader(folder)
-  uploader.download_checkpoints()
+  if download_checkpoints:
+    uploader.download_checkpoints()
   uploader.create_dockerfile()
   input("Press Enter to continue...")
   uploader.upload_model_version()
@@ -310,6 +339,13 @@ if __name__ == "__main__":
   parser = argparse.ArgumentParser()
   parser.add_argument(
       '--model_path', type=str, help='Path of the model folder to upload', required=True)
+  # flag to default to not download checkpoints
+  parser.add_argument(
+      '--download_checkpoints',
+      action='store_true',
+      help=
+      'Flag to download checkpoints before uploading and including them in the tar file that is uploaded. Defaults to False, which will attempt to download them at docker build time.',
+  )
   args = parser.parse_args()
 
-  main(args.model_path)
+  main(args.model_path, args.download_checkpoints)

clarifai/runners/utils/loader.py

@@ -57,7 +57,6 @@ class HuggingFaceLoarder:
   def validate_download(self, checkpoint_path: str):
     # check if model exists on HF
     from huggingface_hub import list_repo_files
-
     return (len(os.listdir(checkpoint_path)) >= len(list_repo_files(self.repo_id))) and len(
         list_repo_files(self.repo_id)) > 0
 

clarifai/utils/misc.py

@@ -1,4 +1,5 @@
 import os
+import uuid
 from typing import Any, Dict, List
 
 from clarifai.errors import UserError
@@ -69,3 +70,8 @@ def concept_relations_accumulation(relations_dict: Dict[str, Any], subject_conce
     relations_dict[object_concept] = []
     relations_dict[subject_concept] = []
   return relations_dict
+
+
+def get_uuid(val: int) -> str:
+  """Generates a UUID."""
+  return uuid.uuid4().hex[:val]

{clarifai-10.8.4.dist-info → clarifai-10.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.8.4
+Version: 10.8.6
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -32,6 +32,7 @@ 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
 Provides-Extra: all
 Requires-Dist: pycocotools ==2.0.6 ; extra == 'all'