clarifai 11.3.0rc2__py3-none-any.whl → 11.4.0__py3-none-any.whl

clarifai/datasets/upload/features.py

@@ -5,57 +5,62 @@ from typing import List, Optional, Union
 
 @dataclass
 class TextFeatures:
-  """Text classification datasets preprocessing output features."""
-  text: str
-  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
+    """Text classification datasets preprocessing output features."""
+
+    text: str
+    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
 
 
 @dataclass
 class VisualClassificationFeatures:
-  """Image classification datasets preprocessing output features."""
-  image_path: str
-  labels: List[Union[str, int]]  # List[str or int] to cater for multi-class tasks
-  geo_info: Optional[List[float]] = None  #[Longitude, Latitude]
-  id: Optional[int] = None  # image_id
-  metadata: Optional[dict] = None
-  image_bytes: Optional[bytes] = None
-  label_ids: Optional[List[str]] = None
+    """Image classification datasets preprocessing output features."""
+
+    image_path: str
+    labels: List[Union[str, int]]  # List[str or int] to cater for multi-class tasks
+    geo_info: Optional[List[float]] = None  # [Longitude, Latitude]
+    id: Optional[int] = None  # image_id
+    metadata: Optional[dict] = None
+    image_bytes: Optional[bytes] = None
+    label_ids: Optional[List[str]] = None
 
 
 @dataclass
 class VisualDetectionFeatures:
-  """Image Detection datasets preprocessing output features."""
-  image_path: str
-  labels: List[Union[str, int]]
-  bboxes: List[List[float]]
-  geo_info: Optional[List[float]] = None  #[Longitude, Latitude]
-  id: Optional[int] = None  # image_id
-  metadata: Optional[dict] = None
-  image_bytes: Optional[bytes] = None
-  label_ids: Optional[List[str]] = None
+    """Image Detection datasets preprocessing output features."""
+
+    image_path: str
+    labels: List[Union[str, int]]
+    bboxes: List[List[float]]
+    geo_info: Optional[List[float]] = None  # [Longitude, Latitude]
+    id: Optional[int] = None  # image_id
+    metadata: Optional[dict] = None
+    image_bytes: Optional[bytes] = None
+    label_ids: Optional[List[str]] = None
 
 
 @dataclass
 class VisualSegmentationFeatures:
-  """Image Segmentation datasets preprocessing output features."""
-  image_path: str
-  labels: List[Union[str, int]]
-  polygons: List[List[List[float]]]
-  geo_info: Optional[List[float]] = None  #[Longitude, Latitude]
-  id: Optional[int] = None  # image_id
-  metadata: Optional[dict] = None
-  image_bytes: Optional[bytes] = None
-  label_ids: Optional[List[str]] = None
+    """Image Segmentation datasets preprocessing output features."""
+
+    image_path: str
+    labels: List[Union[str, int]]
+    polygons: List[List[List[float]]]
+    geo_info: Optional[List[float]] = None  # [Longitude, Latitude]
+    id: Optional[int] = None  # image_id
+    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
+    """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

@@ -11,217 +11,247 @@ from clarifai.utils.misc import get_uuid
 
 
 class VisualClassificationDataset(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 __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]]:
-    """Create input image and annotation 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.
-      annotation_protos: List of annotation protos.
-    """
-    input_protos, annotation_protos = [], []
-
-    def process_data_item(id):
-      data_item = self.data_generator[id]
-      metadata = Struct()
-      image_path = data_item.image_path
-      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}-{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)
-      elif image_path is not None:
-        metadata.update({"filename": os.path.basename(image_path)})
-      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=data_item.image_bytes,
-                dataset_id=self.dataset_id,
-                labels=labels,
-                label_ids=label_ids,
-                geo_info=geo_info,
-                metadata=metadata))
-      else:
-        input_protos.append(
-            Inputs.get_input_from_file(
-                input_id=input_id,
-                image_file=image_path,
-                dataset_id=self.dataset_id,
-                labels=labels,
-                label_ids=label_ids,
-                geo_info=geo_info,
-                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
+    def _extract_protos(
+        self, batch_input_ids: List[str]
+    ) -> Tuple[List[resources_pb2.Input], List[resources_pb2.Annotation]]:
+        """Create input image and annotation 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.
+          annotation_protos: List of annotation protos.
+        """
+        input_protos, annotation_protos = [], []
+
+        def process_data_item(id):
+            data_item = self.data_generator[id]
+            metadata = Struct()
+            image_path = data_item.image_path
+            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}-{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)
+            elif image_path is not None:
+                metadata.update({"filename": os.path.basename(image_path)})
+            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=data_item.image_bytes,
+                        dataset_id=self.dataset_id,
+                        labels=labels,
+                        label_ids=label_ids,
+                        geo_info=geo_info,
+                        metadata=metadata,
+                    )
+                )
+            else:
+                input_protos.append(
+                    Inputs.get_input_from_file(
+                        input_id=input_id,
+                        image_file=image_path,
+                        dataset_id=self.dataset_id,
+                        labels=labels,
+                        label_ids=label_ids,
+                        geo_info=geo_info,
+                        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
 
 
 class VisualDetectionDataset(ClarifaiDataset):
-  """Visual detection dataset proto class."""
-
-  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]]:
-    """Create input image protos for each data generator item.
-    Args:
-      batch_input_ids: List of input IDs to retrieve the protos for.
-    Returns:
-      input_protos: List of input protos.
-      annotation_protos: List of annotation protos.
-    """
-    input_protos, annotation_protos = [], []
-
-    def process_data_item(id):
-      data_item = self.data_generator[id]
-      metadata = Struct()
-      image = data_item.image_path
-      labels = data_item.labels  # list:[l1,...,ln]
-      if data_item.label_ids is not None:
-        assert len(labels) == len(
-            data_item.label_ids), "Length of labels and label_ids must be equal"
-        label_ids = data_item.label_ids
-      else:
-        label_ids = None
-      bboxes = data_item.bboxes  # [[xmin,ymin,xmax,ymax],...,[xmin,ymin,xmax,ymax]]
-      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:
-        metadata.update({"filename": os.path.basename(image)})
-      geo_info = data_item.geo_info
-
-      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=data_item.image_bytes,
-                dataset_id=self.dataset_id,
-                geo_info=geo_info,
-                metadata=metadata))
-      else:
-        input_protos.append(
-            Inputs.get_input_from_file(
-                input_id=input_id,
-                image_file=image,
-                dataset_id=self.dataset_id,
-                geo_info=geo_info,
-                metadata=metadata))
-      # iter over bboxes and labels
-      # one id could have more than one bbox and label
-      for i in range(len(bboxes)):
-        annotation_protos.append(
-            Inputs.get_bbox_proto(
-                input_id=input_id,
-                label=labels[i],
-                bbox=bboxes[i],
-                label_id=label_ids[i] if label_ids else None))
-
-    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
+    """Visual detection dataset proto class."""
+
+    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]]:
+        """Create input image protos for each data generator item.
+        Args:
+          batch_input_ids: List of input IDs to retrieve the protos for.
+        Returns:
+          input_protos: List of input protos.
+          annotation_protos: List of annotation protos.
+        """
+        input_protos, annotation_protos = [], []
+
+        def process_data_item(id):
+            data_item = self.data_generator[id]
+            metadata = Struct()
+            image = data_item.image_path
+            labels = data_item.labels  # list:[l1,...,ln]
+            if data_item.label_ids is not None:
+                assert len(labels) == len(data_item.label_ids), (
+                    "Length of labels and label_ids must be equal"
+                )
+                label_ids = data_item.label_ids
+            else:
+                label_ids = None
+            bboxes = data_item.bboxes  # [[xmin,ymin,xmax,ymax],...,[xmin,ymin,xmax,ymax]]
+            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:
+                metadata.update({"filename": os.path.basename(image)})
+            geo_info = data_item.geo_info
+
+            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=data_item.image_bytes,
+                        dataset_id=self.dataset_id,
+                        geo_info=geo_info,
+                        metadata=metadata,
+                    )
+                )
+            else:
+                input_protos.append(
+                    Inputs.get_input_from_file(
+                        input_id=input_id,
+                        image_file=image,
+                        dataset_id=self.dataset_id,
+                        geo_info=geo_info,
+                        metadata=metadata,
+                    )
+                )
+            # iter over bboxes and labels
+            # one id could have more than one bbox and label
+            for i in range(len(bboxes)):
+                annotation_protos.append(
+                    Inputs.get_bbox_proto(
+                        input_id=input_id,
+                        label=labels[i],
+                        bbox=bboxes[i],
+                        label_id=label_ids[i] if label_ids else None,
+                    )
+                )
+
+        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
 
 
 class VisualSegmentationDataset(ClarifaiDataset):
-  """Visual segmentation dataset proto class."""
-
-  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]]:
-    """Create input image and annotation 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.
-      annotation_protos: List of annotation protos.
-    """
-    input_protos, annotation_protos = [], []
-
-    def process_data_item(id):
-      data_item = self.data_generator[id]
-      metadata = Struct()
-      image = data_item.image_path
-      labels = data_item.labels
-      if data_item.label_ids is not None:
-        assert len(labels) == len(
-            data_item.label_ids), "Length of labels and label_ids must be equal"
-        label_ids = data_item.label_ids
-      else:
-        label_ids = None
-      _polygons = data_item.polygons  # list of polygons: [[[x,y],...,[x,y]],...]
-      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:
-        metadata.update({"filename": os.path.basename(image)})
-      geo_info = data_item.geo_info
-
-      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=data_item.image_bytes,
-                dataset_id=self.dataset_id,
-                geo_info=geo_info,
-                metadata=metadata))
-      else:
-        input_protos.append(
-            Inputs.get_input_from_file(
-                input_id=input_id,
-                image_file=image,
-                dataset_id=self.dataset_id,
-                geo_info=geo_info,
-                metadata=metadata))
-
-      ## Iterate over each masked image and create a proto for upload to clarifai
-      ## The length of masks/polygons-list and labels must be equal
-      for i, _polygon in enumerate(_polygons):
-        try:
-          annotation_protos.append(
-              Inputs.get_mask_proto(
-                  input_id=input_id,
-                  label=labels[i],
-                  polygons=_polygon,
-                  label_id=label_ids[i] if label_ids else None))
-        except IndexError:
-          continue
-
-    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
+    """Visual segmentation dataset proto class."""
+
+    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]]:
+        """Create input image and annotation 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.
+          annotation_protos: List of annotation protos.
+        """
+        input_protos, annotation_protos = [], []
+
+        def process_data_item(id):
+            data_item = self.data_generator[id]
+            metadata = Struct()
+            image = data_item.image_path
+            labels = data_item.labels
+            if data_item.label_ids is not None:
+                assert len(labels) == len(data_item.label_ids), (
+                    "Length of labels and label_ids must be equal"
+                )
+                label_ids = data_item.label_ids
+            else:
+                label_ids = None
+            _polygons = data_item.polygons  # list of polygons: [[[x,y],...,[x,y]],...]
+            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:
+                metadata.update({"filename": os.path.basename(image)})
+            geo_info = data_item.geo_info
+
+            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=data_item.image_bytes,
+                        dataset_id=self.dataset_id,
+                        geo_info=geo_info,
+                        metadata=metadata,
+                    )
+                )
+            else:
+                input_protos.append(
+                    Inputs.get_input_from_file(
+                        input_id=input_id,
+                        image_file=image,
+                        dataset_id=self.dataset_id,
+                        geo_info=geo_info,
+                        metadata=metadata,
+                    )
+                )
+
+            ## Iterate over each masked image and create a proto for upload to clarifai
+            ## The length of masks/polygons-list and labels must be equal
+            for i, _polygon in enumerate(_polygons):
+                try:
+                    annotation_protos.append(
+                        Inputs.get_mask_proto(
+                            input_id=input_id,
+                            label=labels[i],
+                            polygons=_polygon,
+                            label_id=label_ids[i] if label_ids else None,
+                        )
+                    )
+                except IndexError:
+                    continue
+
+        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/loaders/coco_captions.py

@@ -6,49 +6,51 @@ from clarifai.datasets.upload.base import ClarifaiDataLoader
 
 from ..features import VisualClassificationFeatures
 
-#pycocotools is a dependency for this loader
+# pycocotools is a dependency for this loader
 try:
-  from pycocotools.coco import COCO
+    from pycocotools.coco import COCO
 except ImportError:
-  raise ImportError("Could not import pycocotools package. "
-                    "Please do `pip install 'clarifai[all]'` to import pycocotools.")
+    raise ImportError(
+        "Could not import pycocotools package. "
+        "Please do `pip install 'clarifai[all]'` to import pycocotools."
+    )
 
 
 class COCOCaptionsDataLoader(ClarifaiDataLoader):
-  """COCO Image Captioning Dataset."""
+    """COCO Image Captioning Dataset."""
 
-  def __init__(self, images_dir, label_filepath):
-    """
-    Args:
-      images_dir: Directory containing the images.
-      label_filepath: Path to the COCO annotation file.
-    """
-    self.images_dir = images_dir
-    self.label_filepath = label_filepath
+    def __init__(self, images_dir, label_filepath):
+        """
+        Args:
+          images_dir: Directory containing the images.
+          label_filepath: Path to the COCO annotation file.
+        """
+        self.images_dir = images_dir
+        self.label_filepath = label_filepath
 
-    self.map_ids = {}
-    self.load_data()
+        self.map_ids = {}
+        self.load_data()
 
-  @property
-  def task(self):
-    return "visual_captioning"
+    @property
+    def task(self):
+        return "visual_captioning"
 
-  def load_data(self) -> None:
-    self.coco = COCO(self.label_filepath)
-    self.map_ids = {i: img_id for i, img_id in enumerate(list(self.coco.imgs.keys()))}
+    def load_data(self) -> None:
+        self.coco = COCO(self.label_filepath)
+        self.map_ids = {i: img_id for i, img_id in enumerate(list(self.coco.imgs.keys()))}
 
-  def __len__(self):
-    return len(self.coco.imgs)
+    def __len__(self):
+        return len(self.coco.imgs)
 
-  def __getitem__(self, index):
-    value = self.coco.imgs[self.map_ids[index]]
-    image_path = os.path.join(self.images_dir, value['file_name'])
-    annots = []
+    def __getitem__(self, index):
+        value = self.coco.imgs[self.map_ids[index]]
+        image_path = os.path.join(self.images_dir, value['file_name'])
+        annots = []
 
-    input_ann_ids = self.coco.getAnnIds(imgIds=[value['id']])
-    input_anns = self.coco.loadAnns(input_ann_ids)
+        input_ann_ids = self.coco.getAnnIds(imgIds=[value['id']])
+        input_anns = self.coco.loadAnns(input_ann_ids)
 
-    for ann in input_anns:
-      annots.append(ann['caption'])
+        for ann in input_anns:
+            annots.append(ann['caption'])
 
-    return VisualClassificationFeatures(image_path, labels=annots[0], id=str(value['id']))
+        return VisualClassificationFeatures(image_path, labels=annots[0], id=str(value['id']))