scale-nucleus 0.14.7__py3-none-any.whl → 0.14.14b0__py3-none-any.whl

nucleus/dataset_item.py

@@ -139,11 +139,21 @@ class DatasetItem:  # pylint: disable=R0902
         image_url = payload.get(IMAGE_URL_KEY, None) or payload.get(
             ORIGINAL_IMAGE_URL_KEY, None
         )
+        pointcloud_url = payload.get(POINTCLOUD_URL_KEY, None)
+
+        # handle case when re-converting Scene.from_json
+        url = payload.get(URL_KEY, None)
+        if url and not image_url and not pointcloud_url:
+            if url.split(".")[-1] in ("jpg", "png"):
+                image_url = url
+            elif url.split(".")[-1] in ("json",):
+                pointcloud_url = url
+
         if BACKEND_REFERENCE_ID_KEY in payload:
             payload[REFERENCE_ID_KEY] = payload[BACKEND_REFERENCE_ID_KEY]
         return cls(
             image_location=image_url,
-            pointcloud_location=payload.get(POINTCLOUD_URL_KEY, None),
+            pointcloud_location=pointcloud_url,
             reference_id=payload.get(REFERENCE_ID_KEY, None),
             metadata=payload.get(METADATA_KEY, {}),
             upload_to_scale=payload.get(UPLOAD_TO_SCALE_KEY, True),

nucleus/job.py

@@ -80,7 +80,7 @@ class AsyncJob:
             ::
 
                 [
-                    '{"annotation":{"label":"car","type":"box","geometry":{"x":50,"y":60,"width":70,"height":80},"referenceId":"bad_ref_id","annotationId":"attempted_annot_upload","metadata":{}},"error":"Item with id bad_ref_id doesn\'t exist."}'
+                    '{"annotation":{"label":"car","type":"box","geometry":{"x":50,"y":60,"width":70,"height":80},"referenceId":"bad_ref_id","annotationId":"attempted_annot_upload","metadata":{}},"error":"Item with id bad_ref_id does not exist."}'
                 ]
         """
         errors = self.client.make_request(

nucleus/metrics/categorization_metrics.py

@@ -2,8 +2,6 @@ from abc import abstractmethod
 from dataclasses import dataclass
 from typing import List, Optional, Set, Tuple, Union
 
-from sklearn.metrics import f1_score
-
 from nucleus.annotation import AnnotationList, CategoryAnnotation
 from nucleus.metrics.base import Metric, MetricResult, ScalarResult
 from nucleus.metrics.filtering import ListOfAndFilters, ListOfOrAndFilters
@@ -35,6 +33,9 @@ class CategorizationResult(MetricResult):
 
     @property
     def value(self):
+        # late import to avoid slow CLI init
+        from sklearn.metrics import f1_score
+
         annotation_labels = to_taxonomy_labels(self.annotations)
         prediction_labels = to_taxonomy_labels(self.predictions)
 
@@ -245,6 +246,9 @@ class CategorizationF1(CategorizationMetric):
         )
 
     def aggregate_score(self, results: List[CategorizationResult]) -> ScalarResult:  # type: ignore[override]
+        # late import to avoid slow CLI init
+        from sklearn.metrics import f1_score
+
         gt = []
         predicted = []
         for result in results:

nucleus/metrics/segmentation_loader.py

@@ -1,27 +1,23 @@
+import abc
 from typing import Dict
 
 import numpy as np
-from PIL import Image
 
-try:
-    import fsspec
-except (ModuleNotFoundError, OSError):
-    from ..package_not_installed import PackageNotInstalled
 
-    fsspec = PackageNotInstalled
+class SegmentationMaskLoader(abc.ABC):
+    @abc.abstractmethod
+    def fetch(self, url: str) -> np.ndarray:
+        pass
 
 
-class SegmentationMaskLoader:
-    def __init__(self, fs: fsspec):
-        self.fs = fs
-
-    def fetch(self, url: str):
-        with self.fs.open(url) as fh:
-            img = Image.open(fh)
-        return np.asarray(img)
+class DummyLoader(SegmentationMaskLoader):
+    def fetch(self, url: str) -> np.ndarray:
+        raise NotImplementedError(
+            "This dummy loader has to be replaced with an actual implementation of an image loader"
+        )
 
 
-class InMemoryLoader:
+class InMemoryLoader(SegmentationMaskLoader):
     """We use this loader in the tests, this allows us to serve images from memory instead of fetching
     from a filesystem.
     """

nucleus/metrics/segmentation_metrics.py

@@ -9,7 +9,7 @@ from nucleus.metrics.filtering import ListOfAndFilters, ListOfOrAndFilters
 from nucleus.prediction import PredictionList, SegmentationPrediction
 
 from .base import Metric, ScalarResult
-from .segmentation_loader import SegmentationMaskLoader
+from .segmentation_loader import DummyLoader, SegmentationMaskLoader
 from .segmentation_utils import (
     FALSE_POSITIVES,
     convert_to_instance_seg_confusion,
@@ -18,14 +18,6 @@ from .segmentation_utils import (
     setup_iou_thresholds,
 )
 
-try:
-    from s3fs import S3FileSystem
-except (ModuleNotFoundError, OSError):
-    from ..package_not_installed import PackageNotInstalled
-
-    S3FileSystem = PackageNotInstalled
-
-
 # pylint: disable=useless-super-delegation
 
 
@@ -64,7 +56,7 @@ class SegmentationMaskMetric(Metric):
         """
         # TODO -> add custom filtering to Segmentation(Annotation|Prediction).annotations.(metadata|label)
         super().__init__(annotation_filters, prediction_filters)
-        self.loader = SegmentationMaskLoader(S3FileSystem(anon=False))
+        self.loader: SegmentationMaskLoader = DummyLoader()
         self.iou_threshold = iou_threshold
 
     def call_metric(
@@ -219,25 +211,21 @@ class SegmentationMaskMetric(Metric):
 
     def _filter_confusion_matrix(self, confusion, annotation, prediction):
         if self.annotation_filters or self.prediction_filters:
+            new_confusion = np.zeros_like(confusion)
             # we mask the confusion matrix instead of the images
             if self.annotation_filters:
                 annotation_indexes = {
                     segment.index for segment in annotation.annotations
                 }
-                indexes_to_remove = (
-                    set(range(confusion.shape[0] - 1)) - annotation_indexes
-                )
-                for row in indexes_to_remove:
-                    confusion[row, :] = 0
+                for row in annotation_indexes:
+                    new_confusion[row, :] = confusion[row, :]
             if self.prediction_filters:
                 prediction_indexes = {
                     segment.index for segment in prediction.annotations
                 }
-                indexes_to_remove = (
-                    set(range(confusion.shape[0] - 1)) - prediction_indexes
-                )
-                for col in indexes_to_remove:
-                    confusion[:, col] = 0
+                for col in prediction_indexes:
+                    new_confusion[:, col] = confusion[:, col]
+            confusion = new_confusion
         return confusion
 
 

nucleus/metrics/segmentation_to_poly_metrics.py

@@ -20,21 +20,6 @@ from nucleus.metrics.segmentation_utils import (
 )
 from nucleus.prediction import PredictionList
 
-from .segmentation_loader import InMemoryLoader, SegmentationMaskLoader
-from .segmentation_metrics import (
-    SegmentationIOU,
-    SegmentationMAP,
-    SegmentationPrecision,
-    SegmentationRecall,
-)
-
-try:
-    from s3fs import S3FileSystem
-except (ModuleNotFoundError, OSError):
-    from ..package_not_installed import PackageNotInstalled
-
-    S3FileSystem = PackageNotInstalled
-
 from .base import Metric, ScalarResult
 from .polygon_metrics import (
     PolygonAveragePrecision,
@@ -42,6 +27,17 @@ from .polygon_metrics import (
     PolygonPrecision,
     PolygonRecall,
 )
+from .segmentation_loader import (
+    DummyLoader,
+    InMemoryLoader,
+    SegmentationMaskLoader,
+)
+from .segmentation_metrics import (
+    SegmentationIOU,
+    SegmentationMAP,
+    SegmentationPrecision,
+    SegmentationRecall,
+)
 
 
 class SegToPolyMode(str, Enum):
@@ -93,7 +89,7 @@ class SegmentationMaskToPolyMetric(Metric):
         self.enforce_label_match = enforce_label_match
         assert 0 <= confidence_threshold <= 1
         self.confidence_threshold = confidence_threshold
-        self.loader = SegmentationMaskLoader(S3FileSystem(anon=False))
+        self.loader: SegmentationMaskLoader = DummyLoader()
         self.mode = mode
 
     def call_metric(

nucleus/metrics/segmentation_utils.py

@@ -166,7 +166,7 @@ def non_max_suppress_confusion(confusion: np.ndarray, iou_threshold):
 
 
 def rasterize_polygons_to_segmentation_mask(
-    annotations: Sequence[BoxOrPolygonAnnotation], shape: Tuple[int, int]
+    annotations: Sequence[BoxOrPolygonAnnotation], shape: Tuple
 ) -> Tuple[np.ndarray, List[Segment]]:
     polys = [polygon_annotation_to_shape(a) for a in annotations]
     segments = [

nucleus/model.py

@@ -27,7 +27,7 @@ class Model:
 
     Within Nucleus, Models work in the following way:
 
-    1. You first :meth:`create a Model<NucleusClient.add_model>`. You can do this
+    1. You first :meth:`create a Model<NucleusClient.create_model>`. You can do this
        just once and reuse the model on multiple datasets.
     2. You then :meth:`upload predictions <Dataset.upload_predictions>` to a dataset.
     3. Trigger :meth:`calculation of metrics <Dataset.calculate_evaluation_metrics>`
@@ -68,7 +68,7 @@ class Model:
             class_pdf={"label": 0.2, "other_label": 0.8},
         )
 
-        model = client.add_model(
+        model = client.create_model(
             name="My Model", reference_id="My-CNN", metadata={"timestamp": "121012401"}
         )
 
@@ -89,7 +89,7 @@ class Model:
         dataset.calculate_evaluation_metrics(model)
 
     Models cannot be instantiated directly and instead must be created via API
-    endpoint, using :meth:`NucleusClient.add_model`.
+    endpoint, using :meth:`NucleusClient.create_model`.
     """
 
     def __init__(
@@ -100,7 +100,7 @@ class Model:
         metadata,
         client,
         bundle_name=None,
-        tags: List[str] = None,
+        tags=None,
     ):
         self.id = model_id
         self.name = name
@@ -111,7 +111,7 @@ class Model:
         self._client = client
 
     def __repr__(self):
-        return f"Model(model_id='{self.id}', name='{self.name}', reference_id='{self.reference_id}', metadata={self.metadata}, bundle_name={self.bundle_name}, client={self._client})"
+        return f"Model(model_id='{self.id}', name='{self.name}', reference_id='{self.reference_id}', metadata={self.metadata}, bundle_name={self.bundle_name}, tags={self.tags}, client={self._client})"
 
     def __eq__(self, other):
         return (
@@ -210,9 +210,9 @@ class Model:
             model.run("ds_123456")
 
         Args:
-            dataset_id: id of dataset to run inference on
-            job_id: nucleus job used to track async job progress
-            slice_id: (optional) id of slice of the dataset to run inference on
+            dataset_id: The ID of the dataset to run inference on.
+            job_id: The ID of the :class:`AsyncJob` used to track job progress.
+            slice_id: The ID of the slice of the dataset to run inference on.
         """
         response = self._client.make_request(
             {"dataset_id": dataset_id, "slice_id": slice_id},
@@ -234,16 +234,17 @@ class Model:
         Args:
             tags: list of tag names
         """
-        response = self._client.make_request(
+        response: requests.Response = self._client.make_request(
             {MODEL_TAGS_KEY: tags},
             f"model/{self.id}/tag",
             requests_command=requests.post,
+            return_raw_response=True,
         )
 
-        if response.get("msg", False):
+        if response.ok:
             self.tags.extend(tags)
 
-        return response
+        return response.json()
 
     def remove_tags(self, tags: List[str]):
         """Remove tag(s) from the model. ::
@@ -257,13 +258,14 @@ class Model:
         Args:
             tags: list of tag names to remove
         """
-        response = self._client.make_request(
+        response: requests.Response = self._client.make_request(
             {MODEL_TAGS_KEY: tags},
             f"model/{self.id}/tag",
             requests_command=requests.delete,
+            return_raw_response=True,
         )
 
-        if response.get("msg", False):
+        if response.ok:
             self.tags = list(filter(lambda t: t not in tags, self.tags))
 
-        return response
+        return response.json()

nucleus/model_run.py

@@ -8,7 +8,7 @@ For example::
     client = nucleus.NucleusClient(YOUR_SCALE_API_KEY)
     prediction_1 = nucleus.BoxPrediction(label="label", x=0, y=0, width=10, height=10, reference_id="1", confidence=0.9, class_pdf={'label': 0.9, 'other_label': 0.1})
     prediction_2 = nucleus.BoxPrediction(label="label", x=0, y=0, width=10, height=10, reference_id="2", confidence=0.2, class_pdf={'label': 0.2, 'other_label': 0.8})
-    model = client.add_model(name="My Model", reference_id="My-CNN", metadata={"timestamp": "121012401"})
+    model = client.create_model(name="My Model", reference_id="My-CNN", metadata={"timestamp": "121012401"})
     response = dataset.upload_predictions(model, [prediction_1, prediction_2])
 """
 

nucleus/prediction.py

@@ -75,7 +75,7 @@ class SegmentationPrediction(SegmentationAnnotation):
         from nucleus import SegmentationPrediction
 
         segmentation = SegmentationPrediction(
-            mask_url="s3://your-bucket-name/pred-seg-masks/image_2_pred_mask_id1.png",
+            mask_url="s3://your-bucket-name/pred-seg-masks/image_2_pred_mask_id_1.png",
             annotations=[
                 Segment(label="grass", index="1"),
                 Segment(label="road", index="2"),
@@ -88,7 +88,7 @@ class SegmentationPrediction(SegmentationAnnotation):
 
     Parameters:
         mask_url (str): A URL pointing to the segmentation prediction mask which is
-          accessible to Scale. This URL can be a path to a local file.
+          accessible to Scale. This "URL" can also be a path to a local file.
           The mask is an HxW int8 array saved in PNG format,
           with each pixel value ranging from [0, N), where N is the number of
           possible classes (for semantic segmentation) or instances (for instance
@@ -226,7 +226,7 @@ class LinePrediction(LineAnnotation):
 
     Parameters:
         label (str): The label for this prediction (e.g. car, pedestrian, bicycle).
-        vertices List[:class:`Point`]: The list of points making up the line.
+        vertices (List[:class:`Point`]): The list of points making up the line.
         reference_id (str): User-defined ID of the image to which to apply this
             annotation.
         confidence: 0-1 indicating the confidence of the prediction.

nucleus/slice.py

@@ -1,17 +1,17 @@
+import datetime
 import warnings
-from typing import Dict, Iterable, List, Set, Tuple, Union
+from typing import Dict, Iterable, List, Optional, Set, Tuple, Union
 
 import requests
 
 from nucleus.annotation import Annotation
-from nucleus.constants import EXPORTED_ROWS, ITEMS_KEY
+from nucleus.constants import EXPORT_FOR_TRAINING_KEY, EXPORTED_ROWS, ITEMS_KEY
 from nucleus.dataset_item import DatasetItem
 from nucleus.errors import NucleusAPIError
 from nucleus.job import AsyncJob
 from nucleus.utils import (
     KeyErrorDict,
     convert_export_payload,
-    format_dataset_item_response,
     format_scale_task_info_response,
     paginate_generator,
 )
@@ -50,9 +50,11 @@ class Slice:
         self._client = client
         self._name = None
         self._dataset_id = None
+        self._created_at = None
+        self._pending_job_count = None
 
     def __repr__(self):
-        return f"Slice(slice_id='{self.id}', client={self._client})"
+        return f"Slice(slice_id='{self.id}', name={self._name}, dataset_id={self._dataset_id})"
 
     def __eq__(self, other):
         if self.id == other.id:
@@ -60,6 +62,43 @@ class Slice:
                 return True
         return False
 
+    @property
+    def created_at(self) -> Optional[datetime.datetime]:
+        """Timestamp of creation of the slice
+
+        Returns:
+            datetime of creation or None if not created yet
+        """
+        if self._created_at is None:
+            self._created_at = self.info().get("created_at", None)
+        return self._created_at
+
+    @property
+    def pending_job_count(self) -> Optional[int]:
+        if self._pending_job_count is None:
+            self._pending_job_count = self.info().get(
+                "pending_job_count", None
+            )
+        return self._pending_job_count
+
+    @classmethod
+    def from_request(cls, request, client):
+        instance = cls(request["id"], client)
+        instance._name = request.get("name", None)
+        instance._dataset_id = request.get("dataset_id", None)
+        created_at_str = request.get("created_at").rstrip("Z")
+        if hasattr(datetime.datetime, "fromisoformat"):
+            instance._created_at = datetime.datetime.fromisoformat(
+                created_at_str
+            )
+        else:
+            fmt_str = r"%Y-%m-%dT%H:%M:%S.%f"  # replaces the fromisoformatm, not available in python 3.6
+            instance._created_at = datetime.datetime.strptime(
+                created_at_str, fmt_str
+            )
+        instance._pending_job_count = request.get("pending_job_count", None)
+        return instance
+
     @property
     def slice_id(self):
         warnings.warn(
@@ -86,9 +125,11 @@ class Slice:
         """Generator yielding all dataset items in the dataset.
 
         ::
-            sum_example_field = 0
-            for item in slice.items_generator():
-                sum += item.metadata["example_field"]
+
+            collected_ref_ids = []
+            for item in dataset.items_generator():
+                print(f"Exporting item: {item.reference_id}")
+                collected_ref_ids.append(item.reference_id)
 
         Args:
             page_size (int, optional): Number of items to return per page. If you are
@@ -111,7 +152,7 @@ class Slice:
     def items(self):
         """All DatasetItems contained in the Slice.
 
-        For fetching more than 200k items see :meth:`Slice.items_generator`.
+        We recommend using :meth:`Slice.items_generator` if the Slice has more than 200k items.
 
         """
         try:
@@ -185,7 +226,7 @@ class Slice:
 
         Returns:
             Generator where each element is a dict containing the DatasetItem
-            and all of its associated Annotations, grouped by type.
+            and all of its associated Annotations, grouped by type (e.g. box).
             ::
 
                 Iterable[{
@@ -194,18 +235,22 @@ class Slice:
                         "box": List[BoxAnnotation],
                         "polygon": List[PolygonAnnotation],
                         "cuboid": List[CuboidAnnotation],
+                        "line": List[LineAnnotation],
                         "segmentation": List[SegmentationAnnotation],
                         "category": List[CategoryAnnotation],
+                        "keypoints": List[KeypointsAnnotation],
                     }
                 }]
         """
-        for item_metadata in self.items:
-            yield format_dataset_item_response(
-                self._client.dataitem_loc(
-                    dataset_id=self.dataset_id,
-                    dataset_item_id=item_metadata["id"],
-                )
-            )
+        json_generator = paginate_generator(
+            client=self._client,
+            endpoint=f"slice/{self.id}/exportForTrainingPage",
+            result_key=EXPORT_FOR_TRAINING_KEY,
+            page_size=100000,
+        )
+        for data in json_generator:
+            for ia in convert_export_payload([data], has_predictions=False):
+                yield ia
 
     def items_and_annotations(
         self,
@@ -223,8 +268,10 @@ class Slice:
                         "box": List[BoxAnnotation],
                         "polygon": List[PolygonAnnotation],
                         "cuboid": List[CuboidAnnotation],
+                        "line": List[LineAnnotation],
                         "segmentation": List[SegmentationAnnotation],
                         "category": List[CategoryAnnotation],
+                        "keypoints": List[KeypointsAnnotation],
                     }
                 }]
         """
@@ -250,7 +297,7 @@ class Slice:
 
                 List[{
                     "item": DatasetItem,
-                    "predicions": {
+                    "predictions": {
                         "box": List[BoxAnnotation],
                         "polygon": List[PolygonAnnotation],
                         "cuboid": List[CuboidAnnotation],
@@ -266,6 +313,40 @@ class Slice:
         )
         return convert_export_payload(api_payload[EXPORTED_ROWS], True)
 
+    def export_predictions_generator(
+        self, model
+    ) -> Iterable[Dict[str, Union[DatasetItem, Dict[str, List[Annotation]]]]]:
+        """Provides a list of all DatasetItems and Predictions in the Slice for the given Model.
+
+        Parameters:
+            model (Model): the nucleus model objects representing the model for which to export predictions.
+
+        Returns:
+            Iterable where each element is a dict containing the DatasetItem
+            and all of its associated Predictions, grouped by type (e.g. box).
+            ::
+
+                List[{
+                    "item": DatasetItem,
+                    "predictions": {
+                        "box": List[BoxAnnotation],
+                        "polygon": List[PolygonAnnotation],
+                        "cuboid": List[CuboidAnnotation],
+                        "segmentation": List[SegmentationAnnotation],
+                        "category": List[CategoryAnnotation],
+                    }
+                }]
+        """
+        json_generator = paginate_generator(
+            client=self._client,
+            endpoint=f"slice/{self.id}/{model.id}/exportForTrainingPage",
+            result_key=EXPORT_FOR_TRAINING_KEY,
+            page_size=100000,
+        )
+        for data in json_generator:
+            for ip in convert_export_payload([data], has_predictions=True):
+                yield ip
+
     def export_scale_task_info(self):
         """Fetches info for all linked Scale tasks of items/scenes in the slice.
 
@@ -274,7 +355,7 @@ class Slice:
             and info on their corresponding Scale tasks within the dataset::
 
                 List[{
-                    "item" | "scene": Union[:class:`DatasetItem`, :class:`Scene`],
+                    "item" | "scene": Union[DatasetItem, Scene],
                     "scale_task_info": {
                         "task_id": str,
                         "subtask_id": str,
@@ -285,7 +366,7 @@ class Slice:
                         "batch": str,
                         "created_at": str,
                         "completed_at": Optional[str]
-                    }[]
+                    }]
                 }]
 
         """

nucleus/validate/client.py

@@ -107,13 +107,17 @@ class Validate:
             ).dict(),
             "validate/scenario_test",
         )
-        return ScenarioTest(response[SCENARIO_TEST_ID_KEY], self.connection)
+        return ScenarioTest.from_id(
+            response[SCENARIO_TEST_ID_KEY], self.connection
+        )
 
     def get_scenario_test(self, scenario_test_id: str) -> ScenarioTest:
         response = self.connection.get(
             f"validate/scenario_test/{scenario_test_id}",
         )
-        return ScenarioTest(response["unit_test"]["id"], self.connection)
+        return ScenarioTest.from_id(
+            response["unit_test"]["id"], self.connection
+        )
 
     @property
     def scenario_tests(self) -> List[ScenarioTest]:
@@ -131,12 +135,13 @@ class Validate:
             A list of ScenarioTest objects.
         """
         response = self.connection.get(
-            "validate/scenario_test",
+            "validate/scenario_test/details",
         )
-        return [
-            ScenarioTest(test_id, self.connection)
-            for test_id in response["scenario_test_ids"]
+        tests = [
+            ScenarioTest.from_response(payload, self.connection)
+            for payload in response
         ]
+        return tests
 
     def delete_scenario_test(self, scenario_test_id: str) -> bool:
         """Deletes a Scenario Test. ::

nucleus/validate/data_transfer_objects/scenario_test_evaluations.py

@@ -5,14 +5,6 @@ from pydantic import validator
 from nucleus.pydantic_base import ImmutableModel
 
 
-class EvalDetail(ImmutableModel):
-    id: str
-
-
-class GetEvalHistory(ImmutableModel):
-    evaluations: List[EvalDetail]
-
-
 class EvaluationResult(ImmutableModel):
     item_ref_id: str
     score: float