Merge remote-tracking branch 'origin/develop' into mno/AL-2849

mnoszczak · mnoszczak · commit 37286318865d · 2022-08-16T06:57:53.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,33 @@
 # Changelog
 
+# Version 3.26.0 (2022-08-15)
+## Added
+* `Batch.delete()` which will delete an existing `Batch`
+* `Batch.delete_labels()`  which will delete all `Label`’s created after a `Project`’s mode has been set to batch.
+    * Note: Does not include labels that were imported via model-assisted labeling or label imports
+* Support for creating model config when creating a model run
+* `RAW_TEXT` and `TEXT_FILE` attachment types to replace the `TEXT` type.
+
+# Version 3.25.3 (2022-08-10)
+## Fixed
+* Label export will continue polling if the downloadUrl is None
+
+# Version 3.25.2 (2022-07-26)
+## Updated
+* Mask downloads now have retries
+* Failed `upload_data` now shows more details in the error message
+
+## Fixed
+* Fixed Metadata not importing with DataRows when bulk importing local files.
+* Fixed COCOConverter failing for empty annotations
+
+## Documentation
+* Notebooks are up-to-date with examples of importing annotations without `schema_id`
+
+# Version 3.25.1 (2022-07-20)
+## Fixed
+* Removed extra dependency causing import errors.
+
 # Version 3.25.0 (2022-07-20)
 
 ## Added
@@ -10,7 +38,7 @@
     * `Batch.export_data_rows(include_metadata=True)`
     * `Dataset.export_data_rows(include_metadata=True)`
     * `Project.export_queued_data_rows(include_metadata=True)`
-* `VideoObjectAnnotation` has `segment_index` to group video annotations into video segments    
+* `VideoObjectAnnotation` has `segment_index` to group video annotations into video segments
 
 ## Removed
 * `Project.video_label_generator`. Use `Project.label_generator` instead.
@@ -21,7 +49,7 @@
     * 150,000 rows per upload without metadata
     * 30,000 rows per upload with metadata
 
-    
+
 # Version 3.24.1 (2022-07-07)
 ## Updated
 * Added `refresh_ontology()` as part of create/update/delete metadata schema functions
@@ -635,3 +663,7 @@ a `Label`. Default value is 0.0.
 
 ## Version 2.2 (2019-10-18)
 Changelog not maintained before version 2.2.
+
+### Changed
+* `Model.create_model_run()`
+    * Add training metadata config as a model run creation param
diff --git a/README.md b/README.md
@@ -20,7 +20,7 @@ The Labelbox Python API offers a simple, user-friendly way to interact with the
 
 - Use Python 3.7, 3.8 or 3.9
 - [Create an account](http://app.labelbox.com/)
-- [Generate an API key](https://labelbox.com/docs/api/getting-started#create_api_key)
+- [Generate an API key](https://docs.labelbox.com/docs/create-an-api-key)
 
 ## Installation
 
@@ -59,9 +59,9 @@ pip install labelbox[data]
 
 ## Documentation
 
-- [Visit our docs](https://labelbox.com/docs/python-api) to learn how the SDK works
+- [Visit our docs](https://docs.labelbox.com/reference) to learn how the SDK works
 - Checkout our [notebook examples](examples/) to follow along with interactive tutorials
-- view our [API reference](https://labelbox.com/docs/python-api/api-reference).
+- view our [API reference](https://labelbox-python.readthedocs.io/en/latest/index.html).
 
 ## Authentication
 
diff --git a/examples/annotation_import/image.ipynb b/examples/annotation_import/image.ipynb
diff --git a/examples/model_diagnostics/model_diagnostics_guide.ipynb b/examples/model_diagnostics/model_diagnostics_guide.ipynb
@@ -350,7 +350,8 @@
    "source": [
     "lb_model = client.create_model(name=f\"{project.name}-model\",\n",
     "                               ontology_id=project.ontology().uid)\n",
-    "lb_model_run = lb_model.create_model_run(\"0.0.0\")\n",
+    "lb_model_run_hyperparameters = {\"batch_size\": 1000}\n",
+    "lb_model_run = lb_model.create_model_run(\"0.0.0\", lb_model_run_hyperparameters)\n",
     "lb_model_run.upsert_labels([label.uid for label in labels])"
    ]
   },
diff --git a/labelbox/__init__.py b/labelbox/__init__.py
@@ -1,5 +1,5 @@
 name = "labelbox"
-__version__ = "3.25.1"
+__version__ = "3.26.0"
 
 from labelbox.client import Client
 from labelbox.schema.project import Project
diff --git a/labelbox/client.py b/labelbox/client.py
@@ -381,9 +381,14 @@ def upload_data(self,
                 "Failed to upload, unknown cause", e)
 
         if not file_data or not file_data.get("uploadFile", None):
+            try:
+                errors = response.json().get("errors", [])
+                error_msg = next(iter(errors), {}).get("message",
+                                                       "Unknown error")
+            except Exception as e:
+                error_msg = "Unknown error"
             raise labelbox.exceptions.LabelboxError(
-                "Failed to upload, message: %s" % file_data or
-                file_data.get("error"))
+                "Failed to upload, message: %s" % error_msg)
 
         return file_data["uploadFile"]["url"]
 
diff --git a/labelbox/data/serialization/coco/instance_dataset.py b/labelbox/data/serialization/coco/instance_dataset.py
@@ -28,15 +28,14 @@ def mask_to_coco_object_annotation(
     xmin, ymin, xmax, ymax = shapely.bounds
     # Iterate over polygon once or multiple polygon for each item
     area = shapely.area
-    if shapely.type == 'Polygon':
-        shapely = [shapely]
 
     return COCOObjectAnnotation(
         id=annot_idx,
         image_id=image_id,
         category_id=category_id,
         segmentation=[
-            np.array(s.exterior.coords).ravel().tolist() for s in shapely
+            np.array(s.exterior.coords).ravel().tolist()
+            for s in ([shapely] if shapely.type == "Polygon" else shapely.geoms)
         ],
         area=area,
         bbox=[xmin, ymin, xmax - xmin, ymax - ymin],
diff --git a/labelbox/schema/asset_attachment.py b/labelbox/schema/asset_attachment.py
@@ -9,7 +9,7 @@ class AssetAttachment(DbObject):
     """ Asset attachment provides extra context about an asset while labeling.
 
     Attributes:
-        attachment_type (str): IMAGE, VIDEO, TEXT, IMAGE_OVERLAY, or HTML
+        attachment_type (str): IMAGE, VIDEO, IMAGE_OVERLAY, HTML, RAW_TEXT, or TEXT_URL. TEXT attachment type is deprecated.
         attachment_value (str): URL to an external file or a string of text
     """
 
@@ -19,6 +19,8 @@ class AttachmentType(Enum):
         TEXT = "TEXT"
         IMAGE_OVERLAY = "IMAGE_OVERLAY"
         HTML = "HTML"
+        RAW_TEXT = "RAW_TEXT"
+        TEXT_URL = "TEXT_URL"
 
     for topic in AttachmentType:
         vars()[topic.name] = topic.value
diff --git a/labelbox/schema/batch.py b/labelbox/schema/batch.py
@@ -68,14 +68,15 @@ def remove_queued_data_rows(self) -> None:
 
         project_id_param = "projectId"
         batch_id_param = "batchId"
-        self.client.execute("""mutation ArchiveBatchPyApi($%s: ID!, $%s: ID!) {
-            project(where: {id: $%s}) { archiveBatch(batchId: $%s) { id archivedAt } }
+        self.client.execute(
+            """mutation RemoveQueuedDataRowsFromBatchPyApi($%s: ID!, $%s: ID!) {
+            project(where: {id: $%s}) { removeQueuedDataRowsFromBatch(batchId: $%s) { id } }
         }""" % (project_id_param, batch_id_param, project_id_param,
                 batch_id_param), {
                     project_id_param: self.project_id,
                     batch_id_param: self.uid
                 },
-                            experimental=True)
+            experimental=True)
 
     def export_data_rows(self,
                          timeout_seconds=120,
@@ -125,3 +126,50 @@ def export_data_rows(self,
             logger.debug("Batch '%s' data row export, waiting for server...",
                          self.uid)
             time.sleep(sleep_time)
+
+    def delete(self) -> None:
+        """ Deletes the given batch.
+
+        Note: Batch deletion for batches that has labels is forbidden. 
+
+        Args:
+            batch (Batch): Batch to remove queued data rows from
+        """
+
+        project_id_param = "projectId"
+        batch_id_param = "batchId"
+        self.client.execute("""mutation DeleteBatchPyApi($%s: ID!, $%s: ID!) {
+            project(where: {id: $%s}) { deleteBatch(batchId: $%s) { deletedBatchId } }
+        }""" % (project_id_param, batch_id_param, project_id_param,
+                batch_id_param), {
+                    project_id_param: self.project_id,
+                    batch_id_param: self.uid
+                },
+                            experimental=True)
+
+    def delete_labels(self, set_labels_as_template=False) -> None:
+        """ Deletes labels that were created for data rows in the batch.
+
+        Args:
+            batch (Batch): Batch to remove queued data rows from
+            set_labels_as_template (bool): When set to true, the deleted labels will be kept as templates.
+        """
+
+        project_id_param = "projectId"
+        batch_id_param = "batchId"
+        type_param = "type"
+        res = self.client.execute(
+            """mutation DeleteBatchLabelsPyApi($%s: ID!, $%s: ID!, $%s: DeleteBatchLabelsType!) {
+            project(where: {id: $%s}) { deleteBatchLabels(batchId: $%s, data:{ type: $%s }) { deletedLabelIds } }
+        }""" % (project_id_param, batch_id_param, type_param, project_id_param,
+                batch_id_param, type_param), {
+                    project_id_param:
+                        self.project_id,
+                    batch_id_param:
+                        self.uid,
+                    type_param:
+                        "RequeueDataWithLabelAsTemplate"
+                        if set_labels_as_template else "RequeueData"
+                },
+            experimental=True)
+        return res
diff --git a/labelbox/schema/model.py b/labelbox/schema/model.py
@@ -18,23 +18,26 @@ class Model(DbObject):
     name = Field.String("name")
     model_runs = Relationship.ToMany("ModelRun", False)
 
-    def create_model_run(self, name) -> "ModelRun":
+    def create_model_run(self, name, config=None) -> "ModelRun":
         """ Creates a model run belonging to this model.
 
         Args:
             name (string): The name for the model run.
+            config (json): Model run's training metadata config
         Returns:
             ModelRun, the created model run.
         """
         name_param = "name"
+        config_param = "config"
         model_id_param = "modelId"
         ModelRun = Entity.ModelRun
-        query_str = """mutation CreateModelRunPyApi($%s: String!, $%s: ID!) {
-            createModelRun(data: {name: $%s, modelId: $%s}) {%s}}""" % (
-            name_param, model_id_param, name_param, model_id_param,
-            query.results_query_part(ModelRun))
+        query_str = """mutation CreateModelRunPyApi($%s: String!, $%s: Json, $%s: ID!) {
+            createModelRun(data: {name: $%s, trainingMetadata: $%s, modelId: $%s}) {%s}}""" % (
+            name_param, config_param, model_id_param, name_param, config_param,
+            model_id_param, query.results_query_part(ModelRun))
         res = self.client.execute(query_str, {
             name_param: name,
+            config_param: config,
             model_id_param: self.uid
         })
         return ModelRun(self.client, res["createModelRun"])
diff --git a/labelbox/schema/model_run.py b/labelbox/schema/model_run.py
@@ -34,6 +34,7 @@ class ModelRun(DbObject):
     created_at = Field.DateTime("created_at")
     created_by_id = Field.String("created_by_id", "createdBy")
     model_id = Field.String("model_id")
+    training_metadata = Field.Json("training_metadata")
 
     class Status(Enum):
         EXPORTING_DATA = "EXPORTING_DATA"
diff --git a/labelbox/schema/project.py b/labelbox/schema/project.py
@@ -205,6 +205,7 @@ def export_queued_data_rows(
             {exportQueuedDataRows(data:{projectId: $%s , includeMetadataInput: $%s}) {downloadUrl createdAt status} }
         """ % (id_param, metadata_param, id_param, metadata_param)
         sleep_time = 2
+        start_time = time.time()
         while True:
             res = self.client.execute(query_str, {
                 id_param: self.uid,
@@ -219,8 +220,8 @@ def export_queued_data_rows(
             elif res["status"] == "FAILED":
                 raise LabelboxError("Data row export failed.")
 
-            timeout_seconds -= sleep_time
-            if timeout_seconds <= 0:
+            current_time = time.time()
+            if current_time - start_time > timeout_seconds:
                 raise LabelboxError(
                     f"Unable to export data rows within {timeout_seconds} seconds."
                 )
@@ -328,10 +329,11 @@ def _validate_datetime(string_date: str) -> bool:
             {exportLabels(data:{projectId: $%s%s}) {downloadUrl createdAt shouldPoll} }
         """ % (id_param, id_param, filter_param)
 
+        start_time = time.time()
         while True:
             res = self.client.execute(query_str, {id_param: self.uid})
             res = res["exportLabels"]
-            if not res["shouldPoll"]:
+            if not res["shouldPoll"] and res["downloadUrl"] is not None:
                 url = res['downloadUrl']
                 if not download:
                     return url
@@ -340,8 +342,8 @@ def _validate_datetime(string_date: str) -> bool:
                     response.raise_for_status()
                     return response.json()
 
-            timeout_seconds -= sleep_time
-            if timeout_seconds <= 0:
+            current_time = time.time()
+            if current_time - start_time > timeout_seconds:
                 return None
 
             logger.debug("Project '%s' label export, waiting for server...",
diff --git a/pytest.ini b/pytest.ini
@@ -1,4 +1,4 @@
 [pytest]
-addopts = -s -vv -x --reruns 5 --reruns-delay 10
+addopts = -s -vv -x --reruns 5 --reruns-delay 10 --durations=100
 markers =
     slow: marks tests as slow (deselect with '-m "not slow"')
diff --git a/tests/integration/annotation_import/test_model_run.py b/tests/integration/annotation_import/test_model_run.py
@@ -14,8 +14,11 @@ def test_model_run(client, configured_project_with_label, rand_gen):
     model = client.create_model(data["name"], data["ontology_id"])
 
     name = rand_gen(str)
-    model_run = model.create_model_run(name)
+    config = {"batch_size": 100, "reruns": None}
+    model_run = model.create_model_run(name, config)
     assert model_run.name == name
+    assert model_run.training_metadata["batchSize"] == config["batch_size"]
+    assert model_run.training_metadata["reruns"] == config["reruns"]
     assert model_run.model_id == model.uid
     assert model_run.created_by_id == client.get_user().uid
 
@@ -32,6 +35,12 @@ def test_model_run(client, configured_project_with_label, rand_gen):
     assert fetch_model_run == model_run
 
 
+def test_model_run_no_config(rand_gen, model):
+    name = rand_gen(str)
+    model_run = model.create_model_run(name)
+    assert model_run.name == name
+
+
 def test_model_run_delete(client, model_run):
     models_before = list(client.get_models())
     model_before = models_before[0]
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
@@ -18,7 +18,7 @@
 from labelbox.schema.invite import Invite
 from labelbox.schema.user import User
 
-IMG_URL = "https://picsum.photos/200/300"
+IMG_URL = "https://picsum.photos/200/300.jpg"
 
 
 class Environ(Enum):
@@ -147,8 +147,8 @@ def client(environ: str):
 @pytest.fixture(scope="session")
 def image_url(client):
     return client.upload_data(requests.get(IMG_URL).content,
-                              content_type="application/json",
-                              filename="json_import.json",
+                              content_type="image/jpeg",
+                              filename="image.jpeg",
                               sign=True)
 
 
diff --git a/tests/integration/test_batch.py b/tests/integration/test_batch.py
diff --git a/tests/integration/test_label.py b/tests/integration/test_label.py
diff --git a/tests/integration/test_project.py b/tests/integration/test_project.py
