scale-nucleus 0.12b1__py3-none-any.whl → 0.14.14b0__py3-none-any.whl

cli/slices.py

@@ -23,12 +23,9 @@ def slices(ctx, web):
 @slices.command("list")
 def list_slices():
     """List all available Slices"""
-    with Live(
-        Spinner("dots4", text="Finding your Slices!"),
-        vertical_overflow="visible",
-    ) as live:
-        client = init_client()
-        datasets = client.datasets
+    client = init_client()
+    console = Console()
+    with console.status("Finding your Slices!", spinner="dots4"):
         table = Table(
             Column("id", overflow="fold", min_width=24),
             "name",
@@ -37,26 +34,15 @@ def list_slices():
             title=":cake: Slices",
             title_justify="left",
         )
-        errors = {}
-        for ds in datasets:
-            try:
-                ds_slices = ds.slices
-                if ds_slices:
-                    for slc_id in ds_slices:
-                        slice_url = nucleus_url(f"{ds.id}/{slc_id}")
-                        slice_info = client.get_slice(slc_id).info()
-                        table.add_row(
-                            slc_id, slice_info["name"], ds.name, slice_url
-                        )
-                        live.update(table)
-            except NucleusAPIError as e:
-                errors[ds.id] = e
-
-        error_tree = Tree(
-            ":x: Encountered the following errors while fetching information"
-        )
-        for ds_id, error in errors.items():
-            dataset_branch = error_tree.add(f"Dataset: {ds_id}")
-            dataset_branch.add(f"Error: {error}")
+        datasets = client.datasets
+        id_to_datasets = {d.id: d for d in datasets}
+        all_slices = client.slices
+        for s in all_slices:
+            table.add_row(
+                s.id,
+                s.name,
+                id_to_datasets[s.dataset_id].name,
+                nucleus_url(f"{s.dataset_id}/{s.id}"),
+            )
 
-        Console().print(error_tree)
+    console.print(table)

nucleus/__init__.py

@@ -40,7 +40,7 @@ __all__ = [
 
 import os
 import warnings
-from typing import Dict, List, Optional, Sequence, Union
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 import pkg_resources
 import pydantic
@@ -91,6 +91,7 @@ from .constants import (
     KEEP_HISTORY_KEY,
     MESSAGE_KEY,
     MODEL_RUN_ID_KEY,
+    MODEL_TAGS_KEY,
     NAME_KEY,
     NUCLEUS_ENDPOINT,
     PREDICTIONS_IGNORED_KEY,
@@ -218,6 +219,7 @@ class NucleusClient:
                 reference_id=model["ref_id"],
                 metadata=model["metadata"] or None,
                 client=self,
+                tags=model.get(MODEL_TAGS_KEY, []),
             )
             for model in model_objects["models"]
         ]
@@ -233,6 +235,12 @@ class NucleusClient:
         """
         return self.list_jobs()
 
+    @property
+    def slices(self) -> List[Slice]:
+        response = self.make_request({}, "slice/", requests.get)
+        slices = [Slice.from_request(info, self) for info in response]
+        return slices
+
     @deprecated(msg="Use the NucleusClient.models property in the future.")
     def list_models(self) -> List[Model]:
         return self.models
@@ -439,7 +447,8 @@ class NucleusClient:
         Deletes a dataset by ID.
 
         All items, annotations, and predictions associated with the dataset will
-        be deleted as well.
+        be deleted as well. Note that if this dataset is linked to a Scale or Rapid
+        labeling project, the project itself will not be deleted.
 
         Parameters:
             dataset_id: The ID of the dataset to delete.
@@ -484,6 +493,7 @@ class NucleusClient:
         reference_id: str,
         metadata: Optional[Dict] = None,
         bundle_name: Optional[str] = None,
+        tags: Optional[List[str]] = None,
     ) -> Model:
         """Adds a :class:`Model` to Nucleus.
 
@@ -495,13 +505,15 @@ class NucleusClient:
             metadata: An arbitrary dictionary of additional data about this model
               that can be stored and retrieved. For example, you can store information
               about the hyperparameters used in training this model.
+            bundle_name: Optional name of bundle attached to this model
+            tags: Optional list of tags to attach to this model
 
         Returns:
             :class:`Model`: The newly created model as an object.
         """
         response = self.make_request(
             construct_model_creation_payload(
-                name, reference_id, metadata, bundle_name
+                name, reference_id, metadata, bundle_name, tags
             ),
             "models/add",
         )
@@ -516,6 +528,197 @@ class NucleusClient:
             metadata=metadata,
             bundle_name=bundle_name,
             client=self,
+            tags=tags,
+        )
+
+    def create_launch_model(
+        self,
+        name: str,
+        reference_id: str,
+        bundle_args: Dict[str, Any],
+        metadata: Optional[Dict] = None,
+    ) -> Model:
+        """
+        Adds a :class:`Model` to Nucleus, as well as a Launch bundle from a given function.
+
+        Parameters:
+            name: A human-readable name for the model.
+            reference_id: Unique, user-controlled ID for the model. This can be
+              used, for example, to link to an external storage of models which
+              may have its own id scheme.
+            bundle_args: Dict for kwargs for the creation of a Launch bundle,
+              more details on the keys below.
+            metadata: An arbitrary dictionary of additional data about this model
+              that can be stored and retrieved. For example, you can store information
+              about the hyperparameters used in training this model.
+
+        Returns:
+            :class:`Model`: The newly created model as an object.
+
+        Details on `bundle_args`:
+                Grabs a s3 signed url and uploads a model bundle to Scale Launch.
+
+        A model bundle consists of exactly {predict_fn_or_cls}, {load_predict_fn + model}, or {load_predict_fn + load_model_fn}.
+        Pre/post-processing code can be included inside load_predict_fn/model or in predict_fn_or_cls call.
+
+        Parameters:
+            model_bundle_name: Name of model bundle you want to create. This acts as a unique identifier.
+            predict_fn_or_cls: Function or a Callable class that runs end-to-end (pre/post processing and model inference) on the call.
+                I.e. `predict_fn_or_cls(REQUEST) -> RESPONSE`.
+            model: Typically a trained Neural Network, e.g. a Pytorch module
+            load_predict_fn: Function that when called with model, returns a function that carries out inference
+                I.e. `load_predict_fn(model) -> func; func(REQUEST) -> RESPONSE`
+            load_model_fn: Function that when run, loads a model, e.g. a Pytorch module
+                I.e. `load_predict_fn(load_model_fn()) -> func; func(REQUEST) -> RESPONSE`
+            bundle_url: Only for self-hosted mode. Desired location of bundle.
+            Overrides any value given by self.bundle_location_fn
+            requirements: A list of python package requirements, e.g.
+                ["tensorflow==2.3.0", "tensorflow-hub==0.11.0"]. If no list has been passed, will default to the currently
+                imported list of packages.
+            app_config: Either a Dictionary that represents a YAML file contents or a local path to a YAML file.
+            env_params: A dictionary that dictates environment information e.g.
+                the use of pytorch or tensorflow, which cuda/cudnn versions to use.
+                Specifically, the dictionary should contain the following keys:
+                "framework_type": either "tensorflow" or "pytorch".
+                "pytorch_version": Version of pytorch, e.g. "1.5.1", "1.7.0", etc. Only applicable if framework_type is pytorch
+                "cuda_version": Version of cuda used, e.g. "11.0".
+                "cudnn_version" Version of cudnn used, e.g. "cudnn8-devel".
+                "tensorflow_version": Version of tensorflow, e.g. "2.3.0". Only applicable if framework_type is tensorflow
+            globals_copy: Dictionary of the global symbol table. Normally provided by `globals()` built-in function.
+        """
+        from launch import LaunchClient
+
+        launch_client = LaunchClient(api_key=self.api_key)
+
+        model_exists = any(model.name == name for model in self.list_models())
+        bundle_exists = any(
+            bundle.name == name + "-nucleus-autogen"
+            for bundle in launch_client.list_model_bundles()
+        )
+
+        if bundle_exists or model_exists:
+            raise ModelCreationError(
+                "Bundle with the given name already exists, please try a different name"
+            )
+
+        kwargs = {
+            "model_bundle_name": name + "-nucleus-autogen",
+            **bundle_args,
+        }
+
+        bundle = launch_client.create_model_bundle(**kwargs)
+        return self.create_model(
+            name,
+            reference_id,
+            metadata,
+            bundle.name,
+        )
+
+    def create_launch_model_from_dir(
+        self,
+        name: str,
+        reference_id: str,
+        bundle_from_dir_args: Dict[str, Any],
+        metadata: Optional[Dict] = None,
+    ) -> Model:
+        """
+        Adds a :class:`Model` to Nucleus, as well as a Launch bundle from a directory.
+
+        Parameters:
+            name: A human-readable name for the model.
+            reference_id: Unique, user-controlled ID for the model. This can be
+              used, for example, to link to an external storage of models which
+              may have its own id scheme.
+            bundle_from_dir_args: Dict for kwargs for the creation of a bundle from directory,
+              more details on the keys below.
+            metadata: An arbitrary dictionary of additional data about this model
+              that can be stored and retrieved. For example, you can store information
+              about the hyperparameters used in training this model.
+
+        Returns:
+            :class:`Model`: The newly created model as an object.
+
+        Details on `bundle_from_dir_args`
+        Packages up code from one or more local filesystem folders and uploads them as a bundle to Scale Launch.
+        In this mode, a bundle is just local code instead of a serialized object.
+
+        For example, if you have a directory structure like so, and your current working directory is also `my_root`:
+
+        ```
+        my_root/
+            my_module1/
+                __init__.py
+                ...files and directories
+                my_inference_file.py
+            my_module2/
+                __init__.py
+                ...files and directories
+        ```
+
+        then calling `create_model_bundle_from_dirs` with `base_paths=["my_module1", "my_module2"]` essentially
+        creates a zip file without the root directory, e.g.:
+
+        ```
+        my_module1/
+            __init__.py
+            ...files and directories
+            my_inference_file.py
+        my_module2/
+            __init__.py
+            ...files and directories
+        ```
+
+        and these contents will be unzipped relative to the server side `PYTHONPATH`. Bear these points in mind when
+        referencing Python module paths for this bundle. For instance, if `my_inference_file.py` has `def f(...)`
+        as the desired inference loading function, then the `load_predict_fn_module_path` argument should be
+        `my_module1.my_inference_file.f`.
+
+
+        Keys for `bundle_from_dir_args`:
+            model_bundle_name: Name of model bundle you want to create. This acts as a unique identifier.
+            base_paths: The paths on the local filesystem where the bundle code lives.
+            requirements_path: A path on the local filesystem where a requirements.txt file lives.
+            env_params: A dictionary that dictates environment information e.g.
+                the use of pytorch or tensorflow, which cuda/cudnn versions to use.
+                Specifically, the dictionary should contain the following keys:
+                "framework_type": either "tensorflow" or "pytorch".
+                "pytorch_version": Version of pytorch, e.g. "1.5.1", "1.7.0", etc. Only applicable if framework_type is pytorch
+                "cuda_version": Version of cuda used, e.g. "11.0".
+                "cudnn_version" Version of cudnn used, e.g. "cudnn8-devel".
+                "tensorflow_version": Version of tensorflow, e.g. "2.3.0". Only applicable if framework_type is tensorflow
+            load_predict_fn_module_path: A python module path for a function that, when called with the output of
+                load_model_fn_module_path, returns a function that carries out inference.
+            load_model_fn_module_path: A python module path for a function that returns a model. The output feeds into
+                the function located at load_predict_fn_module_path.
+            app_config: Either a Dictionary that represents a YAML file contents or a local path to a YAML file.
+        """
+        from launch import LaunchClient
+
+        launch_client = LaunchClient(api_key=self.api_key)
+
+        model_exists = any(model.name == name for model in self.list_models())
+        bundle_exists = any(
+            bundle.name == name + "-nucleus-autogen"
+            for bundle in launch_client.list_model_bundles()
+        )
+
+        if bundle_exists or model_exists:
+            raise ModelCreationError(
+                "Bundle with the given name already exists, please try a different name"
+            )
+
+        kwargs = {
+            "model_bundle_name": name + "-nucleus-autogen",
+            **bundle_from_dir_args,
+        }
+
+        bundle = launch_client.create_model_bundle_from_dir(**kwargs)
+
+        return self.create_model(
+            name,
+            reference_id,
+            metadata,
+            bundle.name,
         )
 
     @deprecated(
@@ -656,7 +859,7 @@ class NucleusClient:
 
     @deprecated("Prefer calling Dataset.delete_annotations instead.")
     def delete_annotations(
-        self, dataset_id: str, reference_ids: list = None, keep_history=False
+        self, dataset_id: str, reference_ids: list = None, keep_history=True
     ) -> AsyncJob:
         dataset = self.get_dataset(dataset_id)
         return dataset.delete_annotations(reference_ids, keep_history)
@@ -824,6 +1027,7 @@ class NucleusClient:
         payload: Optional[dict],
         route: str,
         requests_command=requests.post,
+        return_raw_response: bool = False,
     ) -> dict:
         """Makes a request to a Nucleus API endpoint.
 
@@ -833,11 +1037,11 @@ class NucleusClient:
             payload: Given request payload.
             route: Route for the request.
             Requests command: ``requests.post``, ``requests.get``, or ``requests.delete``.
+            return_raw_response: return the request's response object entirely
 
         Returns:
-            Response payload as JSON dict.
+            Response payload as JSON dict or request object.
         """
-        print(payload, route)
         if payload is None:
             payload = {}
         if requests_command is requests.get:
@@ -846,18 +1050,7 @@ class NucleusClient:
                     "Received defined payload with GET request! Will ignore payload"
                 )
             payload = None
-        return self._connection.make_request(payload, route, requests_command)  # type: ignore
-
-    def handle_bad_response(
-        self,
-        endpoint,
-        requests_command,
-        requests_response=None,
-        aiohttp_response=None,
-    ):
-        self._connection.handle_bad_response(
-            endpoint, requests_command, requests_response, aiohttp_response
-        )
+        return self._connection.make_request(payload, route, requests_command, return_raw_response)  # type: ignore
 
     def _set_api_key(self, api_key):
         """Fetch API key from environment variable NUCLEUS_API_KEY if not set"""

nucleus/annotation.py

@@ -105,7 +105,7 @@ class BoxAnnotation(Annotation):  # pylint: disable=R0902
             reference_id="image_1",
             annotation_id="image_1_car_box_1",
             metadata={"vehicle_color": "red"},
-            embedding_vector=[0.1423, 1.432, ...3.829],
+            embedding_vector=[0.1423, 1.432, ..., 3.829],
         )
 
     Parameters:
@@ -180,6 +180,19 @@ class BoxAnnotation(Annotation):  # pylint: disable=R0902
             EMBEDDING_VECTOR_KEY: self.embedding_vector,
         }
 
+    def __eq__(self, other):
+        return (
+            self.label == other.label
+            and self.x == other.x
+            and self.y == other.y
+            and self.width == other.width
+            and self.height == other.height
+            and self.reference_id == other.reference_id
+            and self.annotation_id == other.annotation_id
+            and sorted(self.metadata.items()) == sorted(other.metadata.items())
+            and self.embedding_vector == other.embedding_vector
+        )
+
 
 @dataclass
 class Point:
@@ -297,7 +310,7 @@ class PolygonAnnotation(Annotation):
             reference_id="image_2",
             annotation_id="image_2_bus_polygon_1",
             metadata={"vehicle_color": "yellow"},
-            embedding_vector=[0.1423, 1.432, ...3.829],
+            embedding_vector=[0.1423, 1.432, ..., 3.829],
         )
 
     Parameters:
@@ -426,7 +439,7 @@ class KeypointsAnnotation(Annotation):
             label="face",
             keypoints=[Keypoint(100, 100), Keypoint(120, 120), Keypoint(visible=False), Keypoint(0, 0)],
             names=["point1", "point2", "point3", "point4"],
-            skeleton=[[0, 1], [1, 2], [1, 3], [2, 4]],
+            skeleton=[[0, 1], [1, 2], [1, 3], [2, 3]],
             reference_id="image_2",
             annotation_id="image_2_face_keypoints_1",
             metadata={"face_direction": "forward"},
@@ -473,11 +486,17 @@ class KeypointsAnnotation(Annotation):
                     )
                 seen.add(name)
 
+        max_segment_index = len(self.keypoints) - 1
         for segment in self.skeleton:
             if len(segment) != 2:
                 raise ValueError(
                     "The keypoints skeleton must contain a list of line segments with exactly 2 indices"
                 )
+            for index in segment:
+                if index > max_segment_index:
+                    raise ValueError(
+                        f"The skeleton index {index} is not a valid keypoint index"
+                    )
 
     @classmethod
     def from_json(cls, payload: dict):
@@ -672,7 +691,7 @@ class SegmentationAnnotation(Annotation):
         from nucleus import SegmentationAnnotation
 
         segmentation = SegmentationAnnotation(
-            mask_url="s3://your-bucket-name/segmentation-masks/image_2_mask_id1.png",
+            mask_url="s3://your-bucket-name/segmentation-masks/image_2_mask_id_1.png",
             annotations=[
                 Segment(label="grass", index="1"),
                 Segment(label="road", index="2"),
@@ -685,7 +704,8 @@ class SegmentationAnnotation(Annotation):
 
     Parameters:
         mask_url (str): A URL pointing to the segmentation prediction mask which is
-          accessible to Scale, or a local path. The mask is an HxW int8 array saved in PNG format,
+          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
           segmentation).
@@ -920,6 +940,9 @@ class AnnotationList:
                 ), f"Unexpected annotation type: {type(annotation)}"
                 self.segmentation_annotations.append(annotation)
 
+    def items(self):
+        return self.__dict__.items()
+
     def __len__(self):
         return (
             len(self.box_annotations)

nucleus/connection.py

@@ -40,7 +40,11 @@ class Connection:
         return self.make_request(payload, route, requests_command=requests.put)
 
     def make_request(
-        self, payload: dict, route: str, requests_command=requests.post
+        self,
+        payload: dict,
+        route: str,
+        requests_command=requests.post,
+        return_raw_response: bool = False,
     ) -> dict:
         """
         Makes a request to Nucleus endpoint and logs a warning if not
@@ -49,6 +53,7 @@ class Connection:
         :param payload: given payload
         :param route: route for the request
         :param requests_command: requests.post, requests.get, requests.delete
+        :param return_raw_response: return the request's response object entirely
         :return: response JSON
         """
         endpoint = f"{self.endpoint}/{route}"
@@ -73,6 +78,9 @@ class Connection:
         if not response.ok:
             self.handle_bad_response(endpoint, requests_command, response)
 
+        if return_raw_response:
+            return response
+
         return response.json()
 
     def handle_bad_response(

nucleus/constants.py

@@ -27,6 +27,8 @@ ANNOTATION_UPDATE_KEY = "update"
 AUTOTAGS_KEY = "autotags"
 AUTOTAG_SCORE_THRESHOLD = "score_threshold"
 EXPORTED_ROWS = "exportedRows"
+EXPORTED_SCALE_TASK_INFO_ROWS = "exportedScaleTaskInfoRows"
+EXPORT_FOR_TRAINING_KEY = "data"
 CAMERA_MODEL_KEY = "camera_model"
 CAMERA_PARAMS_KEY = "camera_params"
 CLASS_PDF_KEY = "class_pdf"
@@ -81,7 +83,6 @@ JOB_CREATION_TIME_KEY = "job_creation_time"
 KEYPOINTS_KEY = "keypoints"
 KEYPOINTS_NAMES_KEY = "names"
 KEYPOINTS_SKELETON_KEY = "skeleton"
-LAST_PAGE = "lastPage"
 LABEL_KEY = "label"
 LABELS_KEY = "labels"
 MASK_URL_KEY = "mask_url"
@@ -89,6 +90,7 @@ MAX_PAYLOAD_SIZE = 0x1FFFFFE8  # Set to max string size since we currently conve
 MESSAGE_KEY = "message"
 METADATA_KEY = "metadata"
 MODEL_BUNDLE_NAME_KEY = "bundle_name"
+MODEL_TAGS_KEY = "tags"
 MODEL_ID_KEY = "model_id"
 MODEL_RUN_ID_KEY = "model_run_id"
 NAME_KEY = "name"
@@ -96,8 +98,9 @@ NEW_ITEMS = "new_items"
 NUCLEUS_ENDPOINT = "https://api.scale.com/v1/nucleus"
 NUM_SENSORS_KEY = "num_sensors"
 ORIGINAL_IMAGE_URL_KEY = "original_image_url"
-PAGE_SIZE = "pageSize"
-PAGE_TOKEN = "pageToken"
+PAGE_SIZE_KEY = "pageSize"
+PAGE_TOKEN_KEY = "pageToken"
+NEXT_TOKEN_KEY = "nextPageToken"
 P1_KEY = "p1"
 P2_KEY = "p2"
 POINTCLOUD_KEY = "pointcloud"
@@ -105,11 +108,14 @@ POINTCLOUD_LOCATION_KEY = "pointcloud_location"
 POINTCLOUD_URL_KEY = "pointcloud_url"
 POSITION_KEY = "position"
 PREDICTIONS_IGNORED_KEY = "predictions_ignored"
+PREDICTIONS_KEY = "predictions"
 PREDICTIONS_PROCESSED_KEY = "predictions_processed"
 REFERENCE_IDS_KEY = "reference_ids"
 REFERENCE_ID_KEY = "reference_id"
 BACKEND_REFERENCE_ID_KEY = "ref_id"  # TODO(355762): Our backend returns this instead of the "proper" key sometimes.
 REQUEST_ID_KEY = "requestId"
+SCALE_TASK_INFO_KEY = "scale_task_info"
+SCENE_KEY = "scene"
 SCENES_KEY = "scenes"
 SERIALIZED_REQUEST_KEY = "serialized_request"
 SEGMENTATIONS_KEY = "segmentations"