scale-nucleus 0.12b3__tar.gz → 0.12b9__tar.gz

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scale-nucleus
-Version: 0.12b3
+Version: 0.12b9
 Summary: The official Python client library for Nucleus, the Data Platform for AI
 Home-page: https://scale.com/nucleus
 License: MIT
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Provides-Extra: shapely
-Requires-Dist: Pillow (>=8.3.1)
+Requires-Dist: Pillow (>=7.1.2)
 Requires-Dist: Shapely (>=1.8.0); extra == "shapely"
 Requires-Dist: aiohttp (>=3.7.4,<4.0.0)
 Requires-Dist: click (>=7.1.2,<9.0)

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/nucleus/metrics/__init__.py

@@ -5,6 +5,8 @@ from .filtering import (
     FieldFilter,
     ListOfOrAndFilters,
     MetadataFilter,
+    SegmentFieldFilter,
+    SegmentMetadataFilter,
     apply_filters,
 )
 from .polygon_metrics import (

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/nucleus/metrics/filtering.py

@@ -258,7 +258,7 @@ DNFFieldOrMetadataFilters = List[
 def _attribute_getter(
     field_name: str,
     allow_missing: bool,
-    ann_or_pred: Union[AnnotationTypes, PredictionTypes],
+    ann_or_pred: Union[AnnotationTypes, PredictionTypes, Segment],
 ):
     """Create a function to get object fields"""
     if allow_missing:
@@ -296,7 +296,7 @@ class AlwaysFalseComparison:
 def _metadata_field_getter(
     field_name: str,
     allow_missing: bool,
-    ann_or_pred: Union[AnnotationTypes, PredictionTypes],
+    ann_or_pred: Union[AnnotationTypes, PredictionTypes, Segment],
 ):
     """Create a function to get a metadata field"""
     if isinstance(
@@ -331,7 +331,7 @@ def _metadata_field_getter(
 
 def _filter_to_comparison_function(  # pylint: disable=too-many-return-statements
     filter_def: Filter,
-) -> Callable[[Union[AnnotationTypes, PredictionTypes]], bool]:
+) -> Callable[[Union[AnnotationTypes, PredictionTypes, Segment]], bool]:
     """Creates a comparison function from a filter configuration to apply to annotations or predictions
 
     Parameters:
@@ -385,9 +385,10 @@ def _apply_field_or_metadata_filters(
     ],
     filters: DNFFieldOrMetadataFilters,
 ):
-    """Apply filters to list of annotations or list of predictions
+    """Apply filters to list of annotations or list of predictions or to a list of segments
+
     Attributes:
-        filterable_sequence: Prediction or Annotation
+        filterable_sequence: Prediction or Annotation or Segment sequence
         filters: Filter predicates. Allowed formats are:
             ListOfAndFilters where each Filter forms a chain of AND predicates.
             or
@@ -440,7 +441,9 @@ def _split_segment_filters(
 
 
 def _filter_segments(
-    anns_or_preds: Union[Sequence[AnnotationTypes], Sequence[PredictionTypes]],
+    anns_or_preds: Union[
+        Sequence[SegmentationAnnotation], Sequence[SegmentationPrediction]
+    ],
     segment_filters: OrAndDNFFilters,
 ):
     """Filter Segments of a SegmentationAnnotation or Prediction
@@ -451,11 +454,13 @@ def _filter_segments(
         return anns_or_preds
 
     # Transform segment filter types to field and metadata to iterate over annotation sub fields
-    transformed_or_branches = []
+    transformed_or_branches = (
+        []
+    )  # type: List[List[Union[MetadataFilter, FieldFilter]]]
     for and_branch in segment_filters:
-        transformed_and = []
+        transformed_and = []  # type: List[Union[MetadataFilter, FieldFilter]]
         for filter_statement in and_branch:
-            if filter_statement.type is FilterType.SEGMENT_FIELD:
+            if filter_statement.type == FilterType.SEGMENT_FIELD:
                 transformed_and.append(
                     FieldFilter(
                         filter_statement.key,
@@ -464,7 +469,7 @@ def _filter_segments(
                         filter_statement.allow_missing,
                     )
                 )
-            elif filter_statement.type is FilterType.SEGMENT_METADATA:
+            elif filter_statement.type == FilterType.SEGMENT_METADATA:
                 transformed_and.append(
                     MetadataFilter(
                         filter_statement.key,
@@ -484,7 +489,7 @@ def _filter_segments(
             ann_or_pred, (SegmentationAnnotation, SegmentationPrediction)
         ):
             ann_or_pred.annotations = _apply_field_or_metadata_filters(
-                ann_or_pred.annotations, transformed_or_branches
+                ann_or_pred.annotations, transformed_or_branches  # type: ignore
             )
             segments_filtered.append(ann_or_pred)
 
@@ -513,7 +518,7 @@ def apply_filters(
 
     dnf_filters = ensureDNFFilters(filters)
     filters, segment_filters = _split_segment_filters(dnf_filters)
-    filtered = _apply_field_or_metadata_filters(ann_or_pred, filters)
+    filtered = _apply_field_or_metadata_filters(ann_or_pred, filters)  # type: ignore
     filtered = _filter_segments(filtered, segment_filters)
 
     return filtered

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/nucleus/metrics/segmentation_metrics.py

@@ -75,8 +75,6 @@ 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))
-        # NOTE: We store histogram for re-use in subsequently calculated metrics
-        self.confusion: Optional[np.ndarray] = None
 
     def call_metric(
         self, annotations: AnnotationList, predictions: PredictionList
@@ -97,30 +95,54 @@ class SegmentationMaskMetric(Metric):
             if predictions.segmentation_predictions
             else None
         )
-        if annotation is None or prediction is None:
+        if (
+            annotation
+            and prediction
+            and annotation.annotations
+            and prediction.annotations
+        ):
+            annotation_img = self.get_mask_channel(annotation)
+            pred_img = self.get_mask_channel(prediction)
+            return self._metric_impl(
+                np.asarray(annotation_img, dtype=np.int32),
+                np.asarray(pred_img, dtype=np.int32),
+                annotation,
+                prediction,
+            )
+        else:
             return ScalarResult(0, weight=0)
-        annotation_img = self.loader.fetch(annotation.mask_url)
-        pred_img = self.loader.fetch(prediction.mask_url)
-        return self._metric_impl(
-            np.asarray(annotation_img, dtype=np.int32),
-            np.asarray(pred_img, dtype=np.int32),
-            annotation,
-            prediction,
-        )
+
+    def get_mask_channel(self, ann_or_pred):
+        """Some annotations are stored as RGB instead of L (single-channel).
+        We expect the image to be faux-single-channel with all the channels repeating so we choose the first one.
+        """
+        img = self.loader.fetch(ann_or_pred.mask_url)
+        if img.mode not in {"L", "F"}:
+            # TODO: Do we have to do anything more advanced? Currently expect all channels to have same data
+            img = img.getchannel(0)
+        return img
 
     @abc.abstractmethod
     def _metric_impl(
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ):
         pass
 
     def _calculate_confusion_matrix(
         self, annotation, annotation_img, prediction, prediction_img
-    ):
+    ) -> np.ndarray:
+        """This calculates a confusion matrix with ground_truth_index X predicted_index summary
+
+        Notes:
+            If filtering has been applied we filter out missing segments from the confusion matrix.
+
+        TODO(gunnar): Allow pre-seeding confusion matrix (all of the metrics calculate the same confusion matrix ->
+            we can calculate it once and then use it for all other metrics in the chain)
+        """
         # NOTE: This creates a max(class_index) * max(class_index) MAT. If we have np.int16 this could become
         #  huge. We could probably use a sparse matrix instead or change the logic to only create count(index) ** 2
         #  matrix (we only need to keep track of available indexes)
@@ -131,31 +153,26 @@ class SegmentationMaskMetric(Metric):
             )
             + 1  # to include 0
         )
-        confusion = (
-            _fast_hist(annotation_img, prediction_img, num_classes)
-            if self.confusion is None
-            else self.confusion
-        )
+        confusion = _fast_hist(annotation_img, prediction_img, num_classes)
         if self.annotation_filters or self.prediction_filters:
             # we mask the confusion matrix instead of the images
             if self.annotation_filters:
                 annotation_indexes = {
                     segment.index for segment in annotation.annotations
                 }
-                flatten_indexes = (
-                    set(range(confusion.shape[0])) - annotation_indexes
+                indexes_to_remove = (
+                    set(range(confusion.shape[0] - 1)) - annotation_indexes
                 )
-                for row in flatten_indexes:
+                for row in indexes_to_remove:
                     confusion[row, :] = 0
-                confusion[annotation_indexes, :] = 0
             if self.prediction_filters:
                 prediction_indexes = {
                     segment.index for segment in prediction.annotations
                 }
-                flatten_indexes = (
-                    set(range(confusion.shape[0])) - prediction_indexes
+                indexes_to_remove = (
+                    set(range(confusion.shape[0] - 1)) - prediction_indexes
                 )
-                for col in flatten_indexes:
+                for col in indexes_to_remove:
                     confusion[:, col] = 0
         return confusion
 
@@ -201,22 +218,18 @@ class SegmentationIOU(SegmentationMaskMetric):
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ) -> ScalarResult:
-        if annotation is None or prediction is None:
-            # TODO: Throw error when we wrap each item in try catch
-            return ScalarResult(0, weight=0)
-
-        self.confusion = self._calculate_confusion_matrix(
+        confusion = self._calculate_confusion_matrix(
             annotation, annotation_img, prediction, prediction_img
         )
 
         with np.errstate(divide="ignore", invalid="ignore"):
-            iou = np.diag(self.confusion) / (
-                self.confusion.sum(axis=1)
-                + self.confusion.sum(axis=0)
-                - np.diag(self.confusion)
+            iou = np.diag(confusion) / (
+                confusion.sum(axis=1)
+                + confusion.sum(axis=0)
+                - np.diag(confusion)
             )
         return ScalarResult(value=np.nanmean(iou), weight=annotation_img.size)  # type: ignore
 
@@ -265,20 +278,16 @@ class SegmentationPrecision(SegmentationMaskMetric):
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ) -> ScalarResult:
-        if annotation is None or prediction is None:
-            # TODO: Throw error when we wrap each item in try catch
-            return ScalarResult(0, weight=0)
-
-        self.confusion = self._calculate_confusion_matrix(
+        confusion = self._calculate_confusion_matrix(
             annotation, annotation_img, prediction, prediction_img
         )
 
         with np.errstate(divide="ignore", invalid="ignore"):
-            true_pos = np.diag(self.confusion)
-            precision = true_pos / np.sum(self.confusion, axis=0)
+            true_pos = np.diag(confusion)
+            precision = true_pos / np.sum(confusion, axis=1)
             mean_precision = np.nanmean(precision)
         return ScalarResult(value=mean_precision, weight=1)  # type: ignore
 
@@ -327,21 +336,18 @@ class SegmentationAveragePrecision(SegmentationMaskMetric):
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ) -> ScalarResult:
-        if annotation is None or prediction is None:
-            # TODO: Throw error when we wrap each item in try catch
-            return ScalarResult(0, weight=0)
 
-        self.confusion = self._calculate_confusion_matrix(
+        confusion = self._calculate_confusion_matrix(
             annotation, annotation_img, prediction, prediction_img
         )
 
         with np.errstate(divide="ignore", invalid="ignore"):
-            true_pos = np.diag(self.confusion)
-            precision = true_pos / np.sum(self.confusion, axis=0)
-            recall = true_pos / np.sum(self.confusion, axis=1)
+            true_pos = np.diag(confusion)
+            precision = true_pos / np.sum(confusion, axis=1)
+            recall = true_pos / np.sum(confusion, axis=0)
             average_precision = compute_average_precision(
                 np.nan_to_num(recall), np.nan_to_num(precision)
             )
@@ -395,20 +401,17 @@ class SegmentationRecall(SegmentationMaskMetric):
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ) -> ScalarResult:
-        if annotation is None or prediction is None:
-            # TODO: Throw error when we wrap each item in try catch
-            return ScalarResult(0, weight=0)
 
-        self.confusion = self._calculate_confusion_matrix(
+        confusion = self._calculate_confusion_matrix(
             annotation, annotation_img, prediction, prediction_img
         )
 
         with np.errstate(divide="ignore", invalid="ignore"):
-            true_pos = np.diag(self.confusion)
-            recall = np.nanmean(true_pos / np.sum(self.confusion, axis=1))
+            true_pos = np.diag(confusion)
+            recall = np.nanmean(true_pos / np.sum(confusion, axis=0))
         return ScalarResult(value=recall, weight=annotation_img.size)  # type: ignore
 
     def aggregate_score(self, results: List[MetricResult]) -> ScalarResult:
@@ -491,14 +494,11 @@ class SegmentationMAP(SegmentationMaskMetric):
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ) -> ScalarResult:
-        if annotation is None or prediction is None:
-            # TODO: Throw error when we wrap each item in try catch
-            return ScalarResult(0, weight=0)
 
-        self.confusion = self._calculate_confusion_matrix(
+        confusion = self._calculate_confusion_matrix(
             annotation, annotation_img, prediction, prediction_img
         )
         label_to_index = {a.label: a.index for a in annotation.annotations}
@@ -506,8 +506,8 @@ class SegmentationMAP(SegmentationMaskMetric):
         ap_per_class = np.ndarray(num_classes)  # type: ignore
         with np.errstate(divide="ignore", invalid="ignore"):
             for class_idx, (_, index) in enumerate(label_to_index.items()):
-                true_pos = self.confusion[index, index]
-                false_pos = self.confusion[:, index].sum()
+                true_pos = confusion[index, index]
+                false_pos = confusion[:, index].sum()
                 samples = true_pos + false_pos
                 if samples:
                     ap_per_class[class_idx] = true_pos / samples
@@ -600,23 +600,20 @@ class SegmentationFWAVACC(SegmentationMaskMetric):
         self,
         annotation_img: np.ndarray,
         prediction_img: np.ndarray,
-        annotation: Optional[SegmentationAnnotation],
-        prediction: Optional[SegmentationPrediction],
+        annotation: SegmentationAnnotation,
+        prediction: SegmentationPrediction,
     ) -> ScalarResult:
-        if annotation is None or prediction is None:
-            # TODO: Throw error when we wrap each item in try catch
-            return ScalarResult(0, weight=0)
 
-        self.confusion = self._calculate_confusion_matrix(
+        confusion = self._calculate_confusion_matrix(
             annotation, annotation_img, prediction, prediction_img
         )
         with np.errstate(divide="ignore", invalid="ignore"):
-            iu = np.diag(self.confusion) / (
-                self.confusion.sum(axis=1)
-                + self.confusion.sum(axis=0)
-                - np.diag(self.confusion)
+            iu = np.diag(confusion) / (
+                confusion.sum(axis=1)
+                + confusion.sum(axis=0)
+                - np.diag(confusion)
             )
-            freq = self.confusion.sum(axis=1) / self.confusion.sum()
+            freq = confusion.sum(axis=0) / confusion.sum()
             fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()
         return ScalarResult(value=np.nanmean(fwavacc), weight=1)  # type: ignore
 

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/nucleus/metrics/segmentation_to_poly_metrics.py

@@ -88,17 +88,21 @@ class SegmentationMaskToPolyMetric(Metric):
             if predictions.segmentation_predictions
             else None
         )
-        pred_img = self.loader.fetch(prediction.mask_url)
-        pred_value, pred_polys = instance_mask_to_polys(
-            np.asarray(pred_img)
-        )  # typing: ignore
-        code_to_label = {s.index: s.label for s in prediction.annotations}
-        poly_predictions = transform_poly_codes_to_poly_preds(
-            prediction.reference_id, pred_value, pred_polys, code_to_label
-        )
-        return self.call_poly_metric(
-            annotations, PredictionList(polygon_predictions=poly_predictions)
-        )
+        if prediction:
+            pred_img = self.loader.fetch(prediction.mask_url)
+            pred_value, pred_polys = instance_mask_to_polys(
+                np.asarray(pred_img)
+            )  # typing: ignore
+            code_to_label = {s.index: s.label for s in prediction.annotations}
+            poly_predictions = transform_poly_codes_to_poly_preds(
+                prediction.reference_id, pred_value, pred_polys, code_to_label
+            )
+            return self.call_poly_metric(
+                annotations,
+                PredictionList(polygon_predictions=poly_predictions),
+            )
+        else:
+            return ScalarResult(0, weight=0)
 
     @abc.abstractmethod
     def call_poly_metric(

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/pyproject.toml

@@ -21,7 +21,7 @@ exclude = '''
 
 [tool.poetry]
 name = "scale-nucleus"
-version = "0.12b3"
+version = "0.12b9"
 description = "The official Python client library for Nucleus, the Data Platform for AI"
 license =  "MIT"
 authors = ["Scale AI Nucleus Team <nucleusapi@scaleapi.com>"]
@@ -47,7 +47,7 @@ shellingham = "^1.4.0"
 scikit-learn = ">=0.24.0"
 Shapely = { version = ">=1.8.0", optional = true }
 rasterio = "^1.2.10"
-Pillow = ">=8.3.1"
+Pillow = ">=7.1.2"
 s3fs = ">=2022.1.0"
 
 [tool.poetry.dev-dependencies]

{scale-nucleus-0.12b3 → scale-nucleus-0.12b9}/setup.py

@@ -16,7 +16,7 @@ package_data = \
 {'': ['*']}
 
 install_requires = \
-['Pillow>=8.3.1',
+['Pillow>=7.1.2',
  'aiohttp>=3.7.4,<4.0.0',
  'click>=7.1.2,<9.0',
  'nest-asyncio>=1.5.1,<2.0.0',
@@ -40,7 +40,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'scale-nucleus',
-    'version': '0.12b3',
+    'version': '0.12b9',
     'description': 'The official Python client library for Nucleus, the Data Platform for AI',
     'long_description': '# Nucleus\n\nhttps://dashboard.scale.com/nucleus\n\nAggregate metrics in ML are not good enough. To improve production ML, you need to understand their qualitative failure modes, fix them by gathering more data, and curate diverse scenarios.\n\nScale Nucleus helps you:\n\n- Visualize your data\n- Curate interesting slices within your dataset\n- Review and manage annotations\n- Measure and debug your model performance\n\nNucleus is a new way—the right way—to develop ML models, helping us move away from the concept of one dataset and towards a paradigm of collections of scenarios.\n\n## Installation\n\n`$ pip install scale-nucleus`\n\n## CLI installation\n\nWe recommend installing the CLI via `pipx` (https://pypa.github.io/pipx/installation/). This makes sure that\nthe CLI does not interfere with you system packages and is accessible from your favorite terminal.\n\nFor MacOS:\n\n```bash\nbrew install pipx\npipx ensurepath\npipx install scale-nucleus\n# Optional installation of shell completion (for bash, zsh or fish)\nnu install-completions\n```\n\nOtherwise, install via pip (requires pip 19.0 or later):\n\n```bash\npython3 -m pip install --user pipx\npython3 -m pipx ensurepath\npython3 -m pipx install scale-nucleus\n# Optional installation of shell completion (for bash, zsh or fish)\nnu install-completions\n```\n\n## Common issues/FAQ\n\n### Outdated Client\n\nNucleus is iterating rapidly and as a result we do not always perfectly preserve backwards compatibility with older versions of the client. If you run into any unexpected error, it\'s a good idea to upgrade your version of the client by running\n\n```\npip install --upgrade scale-nucleus\n```\n\n## Usage\n\nFor the most up to date documentation, reference: https://dashboard.scale.com/nucleus/docs/api?language=python.\n\n## For Developers\n\nClone from github and install as editable\n\n```\ngit clone git@github.com:scaleapi/nucleus-python-client.git\ncd nucleus-python-client\npip3 install poetry\npoetry install\n```\n\nPlease install the pre-commit hooks by running the following command:\n\n```python\npoetry run pre-commit install\n```\n\nWhen releasing a new version please add release notes to the changelog in `CHANGELOG.md`.\n\n**Best practices for testing:**\n(1). Please run pytest from the root directory of the repo, i.e.\n\n```\npoetry run pytest tests/test_dataset.py\n```\n\n(2) To skip slow integration tests that have to wait for an async job to start.\n\n```\npoetry run pytest -m "not integration"\n```\n\n## Pydantic Models\n\nPrefer using [Pydantic](https://pydantic-docs.helpmanual.io/usage/models/) models rather than creating raw dictionaries\nor dataclasses to send or receive over the wire as JSONs. Pydantic is created with data validation in mind and provides very clear error\nmessages when it encounters a problem with the payload.\n\nThe Pydantic model(s) should mirror the payload to send. To represent a JSON payload that looks like this:\n\n```json\n{\n  "example_json_with_info": {\n    "metadata": {\n      "frame": 0\n    },\n    "reference_id": "frame0",\n    "url": "s3://example/scale_nucleus/2021/lidar/0038711321865000.json",\n    "type": "pointcloud"\n  },\n  "example_image_with_info": {\n    "metadata": {\n      "author": "Picasso"\n    },\n    "reference_id": "frame0",\n    "url": "s3://bucket/0038711321865000.jpg",\n    "type": "image"\n  }\n}\n```\n\nCould be represented as the following structure. Note that the field names map to the JSON keys and the usage of field\nvalidators (`@validator`).\n\n```python\nimport os.path\nfrom pydantic import BaseModel, validator\nfrom typing import Literal\n\n\nclass JsonWithInfo(BaseModel):\n    metadata: dict  # any dict is valid\n    reference_id: str\n    url: str\n    type: Literal["pointcloud", "recipe"]\n\n    @validator("url")\n    def has_json_extension(cls, v):\n        if not v.endswith(".json"):\n            raise ValueError(f"Expected \'.json\' extension got {v}")\n        return v\n\n\nclass ImageWithInfo(BaseModel):\n    metadata: dict  # any dict is valid\n    reference_id: str\n    url: str\n    type: Literal["image", "mask"]\n\n    @validator("url")\n    def has_valid_extension(cls, v):\n        valid_extensions = {".jpg", ".jpeg", ".png", ".tiff"}\n        _, extension = os.path.splitext(v)\n        if extension not in valid_extensions:\n            raise ValueError(f"Expected extension in {valid_extensions} got {v}")\n        return v\n\n\nclass ExampleNestedModel(BaseModel):\n    example_json_with_info: JsonWithInfo\n    example_image_with_info: ImageWithInfo\n\n# Usage:\nimport requests\npayload = requests.get("/example")\nparsed_model = ExampleNestedModel.parse_obj(payload.json())\nrequests.post("example/post_to", json=parsed_model.dict())\n```\n\n### Migrating to Pydantic\n\n- When migrating an interface from a dictionary use `nucleus.pydantic_base.DictCompatibleModel`. That allows you to get\n  the benefits of Pydantic but maintaints backwards compatibility with a Python dictionary by delegating `__getitem__` to\n  fields.\n- When migrating a frozen dataclass use `nucleus.pydantic_base.ImmutableModel`. That is a base class set up to be\n  immutable after initialization.\n\n**Updating documentation:**\nWe use [Sphinx](https://www.sphinx-doc.org/en/master/) to autogenerate our API Reference from docstrings.\n\nTo test your local docstring changes, run the following commands from the repository\'s root directory:\n\n```\npoetry shell\ncd docs\nsphinx-autobuild . ./_build/html --watch ../nucleus\n```\n\n`sphinx-autobuild` will spin up a server on localhost (port 8000 by default) that will watch for and automatically rebuild a version of the API reference based on your local docstring changes.\n\n## Custom Metrics using Shapely in scale-validate\n\nCertain metrics use `shapely` which is added as an optional dependency.\n\n```bash\npip install scale-nucleus[metrics]\n```\n\nNote that you might need to install a local GEOS package since Shapely doesn\'t provide binaries bundled with GEOS for every platform.\n\n```bash\n#Mac OS\nbrew install geos\n# Ubuntu/Debian flavors\napt-get install libgeos-dev\n```\n\nTo develop it locally use\n\n`poetry install --extras shapely`\n',
     'author': 'Scale AI Nucleus Team',