Merge remote-tracking branch 'origin/develop' into kkim/AL-2896

Author: Kevin Kim

labelbox/data/annotation_types/collection.py

@@ -34,12 +34,13 @@ def assign_feature_schema_ids(
             self, ontology_builder: "ontology.OntologyBuilder") -> "LabelList":
         """
         Adds schema ids to all FeatureSchema objects in the Labels.
-        This is necessary for MAL.
 
         Args:
             ontology_builder: The ontology that matches the feature names assigned to objects in this LabelList
         Returns:
             LabelList. useful for chaining these modifying functions
+
+        Note: You can now import annotations using names directly without having to lookup schema_ids  
         """
         for label in self._data:
             label.assign_feature_schema_ids(ontology_builder)

labelbox/data/annotation_types/feature.py

@@ -10,9 +10,6 @@ class FeatureSchema(BaseModel):
     Class that represents a feature schema.
     Could be a annotation, a subclass, or an option.
     Schema ids might not be known when constructing these objects so both a name and schema id are valid.
-
-    Use `LabelList.assign_feature_schema_ids` or `LabelGenerator.assign_feature_schema_ids`
-    to retroactively add schema ids by looking them up from the names.
     """
     name: Optional[str] = None
     feature_schema_id: Optional[Cuid] = None
@@ -24,3 +21,11 @@ def must_set_one(cls, values):
                 "Must set either feature_schema_id or name for all feature schemas"
             )
         return values
+
+    def dict(self, *args, **kwargs):
+        res = super().dict(*args, **kwargs)
+        if 'name' in res and res['name'] is None:
+            res.pop('name')
+        if 'featureSchemaId' in res and res['featureSchemaId'] is None:
+            res.pop('featureSchemaId')
+        return res

labelbox/data/annotation_types/label.py

@@ -130,12 +130,13 @@ def assign_feature_schema_ids(
             self, ontology_builder: ontology.OntologyBuilder) -> "Label":
         """
         Adds schema ids to all FeatureSchema objects in the Labels.
-        This is necessary for MAL.
 
         Args:
             ontology_builder: The ontology that matches the feature names assigned to objects in this dataset
         Returns:
             Label. useful for chaining these modifying functions
+
+        Note: You can now import annotations using names directly without having to lookup schema_ids
         """
         tool_lookup, classification_lookup = get_feature_schema_lookup(
             ontology_builder)

labelbox/data/serialization/ndjson/base.py

@@ -1,5 +1,6 @@
+from typing import Optional
 from uuid import uuid4
-from pydantic import BaseModel, validator, Field
+from pydantic import BaseModel, root_validator, validator, Field
 
 from labelbox.utils import camel_case
 from ...annotation_types.types import Cuid
@@ -32,12 +33,21 @@ class Config:
 
 
 class NDAnnotation(NDJsonBase):
-    schema_id: Cuid
-
-    @validator('schema_id', pre=True, always=True)
-    def validate_id(cls, v):
-        if v is None:
-            raise ValueError(
-                "Schema ids are not set. Use `LabelGenerator.assign_feature_schema_ids`, `LabelList.assign_feature_schema_ids`, or `Label.assign_feature_schema_ids`."
-            )
-        return v
+    name: Optional[str] = None
+    schema_id: Optional[Cuid] = None
+
+    @root_validator()
+    def must_set_one(cls, values):
+        if ('schema_id' not in values or
+                values['schema_id'] is None) and ('name' not in values or
+                                                  values['name'] is None):
+            raise ValueError("Schema id or name are not set. Set either one.")
+        return values
+
+    def dict(self, *args, **kwargs):
+        res = super().dict(*args, **kwargs)
+        if 'name' in res and res['name'] is None:
+            res.pop('name')
+        if 'schemaId' in res and res['schemaId'] is None:
+            res.pop('schemaId')
+        return res

labelbox/data/serialization/ndjson/classification.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Union, Optional
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, root_validator
 
 from labelbox.utils import camel_case
 from ...annotation_types.annotation import ClassificationAnnotation, VideoClassificationAnnotation
@@ -11,15 +11,24 @@
 
 
 class NDFeature(BaseModel):
-    schema_id: Cuid
+    name: Optional[str] = None
+    schema_id: Optional[Cuid] = None
 
-    @validator('schema_id', pre=True, always=True)
-    def validate_id(cls, v):
-        if v is None:
-            raise ValueError(
-                "Schema ids are not set. Use `LabelGenerator.assign_feature_schema_ids`, `LabelList.assign_feature_schema_ids`, or `Label.assign_feature_schema_ids`."
-            )
-        return v
+    @root_validator()
+    def must_set_one(cls, values):
+        if ('schema_id' not in values or
+                values['schema_id'] is None) and ('name' not in values or
+                                                  values['name'] is None):
+            raise ValueError("Schema id or name are not set. Set either one.")
+        return values
+
+    def dict(self, *args, **kwargs):
+        res = super().dict(*args, **kwargs)
+        if 'name' in res and res['name'] is None:
+            res.pop('name')
+        if 'schemaId' in res and res['schemaId'] is None:
+            res.pop('schemaId')
+        return res
 
     class Config:
         allow_population_by_field_name = True
@@ -50,27 +59,29 @@ def to_common(self) -> Text:
         return Text(answer=self.answer)
 
     @classmethod
-    def from_common(cls, text: Text,
+    def from_common(cls, text: Text, name: str,
                     feature_schema_id: Cuid) -> "NDTextSubclass":
-        return cls(answer=text.answer, schema_id=feature_schema_id)
+        return cls(answer=text.answer, name=name, schema_id=feature_schema_id)
 
 
 class NDChecklistSubclass(NDFeature):
     answer: List[NDFeature] = Field(..., alias='answers')
 
     def to_common(self) -> Checklist:
         return Checklist(answer=[
-            ClassificationAnswer(feature_schema_id=answer.schema_id)
+            ClassificationAnswer(name=answer.name,
+                                 feature_schema_id=answer.schema_id)
             for answer in self.answer
         ])
 
     @classmethod
-    def from_common(cls, checklist: Checklist,
+    def from_common(cls, checklist: Checklist, name: str,
                     feature_schema_id: Cuid) -> "NDChecklistSubclass":
         return cls(answer=[
-            NDFeature(schema_id=answer.feature_schema_id)
+            NDFeature(name=answer.name, schema_id=answer.feature_schema_id)
             for answer in checklist.answer
         ],
+                   name=name,
                    schema_id=feature_schema_id)
 
     def dict(self, *args, **kwargs):
@@ -85,12 +96,14 @@ class NDRadioSubclass(NDFeature):
 
     def to_common(self) -> Radio:
         return Radio(answer=ClassificationAnswer(
-            feature_schema_id=self.answer.schema_id))
+            name=self.answer.name, feature_schema_id=self.answer.schema_id))
 
     @classmethod
-    def from_common(cls, radio: Radio,
+    def from_common(cls, radio: Radio, name: str,
                     feature_schema_id: Cuid) -> "NDRadioSubclass":
-        return cls(answer=NDFeature(schema_id=radio.answer.feature_schema_id),
+        return cls(answer=NDFeature(name=radio.answer.name,
+                                    schema_id=radio.answer.feature_schema_id),
+                   name=name,
                    schema_id=feature_schema_id)
 
 
@@ -100,12 +113,13 @@ def from_common(cls, radio: Radio,
 class NDText(NDAnnotation, NDTextSubclass):
 
     @classmethod
-    def from_common(cls, text: Text, feature_schema_id: Cuid,
+    def from_common(cls, text: Text, name: str, feature_schema_id: Cuid,
                     extra: Dict[str, Any], data: Union[TextData,
                                                        ImageData]) -> "NDText":
         return cls(
             answer=text.answer,
             data_row={'id': data.uid},
+            name=name,
             schema_id=feature_schema_id,
             uuid=extra.get('uuid'),
         )
@@ -115,14 +129,15 @@ class NDChecklist(NDAnnotation, NDChecklistSubclass, VideoSupported):
 
     @classmethod
     def from_common(
-            cls, checklist: Checklist, feature_schema_id: Cuid,
+            cls, checklist: Checklist, name: str, feature_schema_id: Cuid,
             extra: Dict[str, Any], data: Union[VideoData, TextData,
                                                ImageData]) -> "NDChecklist":
         return cls(answer=[
-            NDFeature(schema_id=answer.feature_schema_id)
+            NDFeature(name=answer.name, schema_id=answer.feature_schema_id)
             for answer in checklist.answer
         ],
                    data_row={'id': data.uid},
+                   name=name,
                    schema_id=feature_schema_id,
                    uuid=extra.get('uuid'),
                    frames=extra.get('frames'))
@@ -131,11 +146,13 @@ def from_common(
 class NDRadio(NDAnnotation, NDRadioSubclass, VideoSupported):
 
     @classmethod
-    def from_common(cls, radio: Radio, feature_schema_id: Cuid,
+    def from_common(cls, radio: Radio, name: str, feature_schema_id: Cuid,
                     extra: Dict[str, Any], data: Union[VideoData, TextData,
                                                        ImageData]) -> "NDRadio":
-        return cls(answer=NDFeature(schema_id=radio.answer.feature_schema_id),
+        return cls(answer=NDFeature(name=radio.answer.name,
+                                    schema_id=radio.answer.feature_schema_id),
                    data_row={'id': data.uid},
+                   name=name,
                    schema_id=feature_schema_id,
                    uuid=extra.get('uuid'),
                    frames=extra.get('frames'))
@@ -152,13 +169,14 @@ def from_common(
             raise TypeError(
                 f"Unable to convert object to MAL format. `{type(annotation.value)}`"
             )
-        return classify_obj.from_common(annotation.value,
+        return classify_obj.from_common(annotation.value, annotation.name,
                                         annotation.feature_schema_id)
 
     @staticmethod
     def to_common(
             annotation: "NDClassificationType") -> ClassificationAnnotation:
         return ClassificationAnnotation(value=annotation.to_common(),
+                                        name=annotation.name,
                                         feature_schema_id=annotation.schema_id)
 
     @staticmethod
@@ -182,6 +200,7 @@ def to_common(
     ) -> Union[ClassificationAnnotation, VideoClassificationAnnotation]:
         common = ClassificationAnnotation(
             value=annotation.to_common(),
+            name=annotation.name,
             feature_schema_id=annotation.schema_id,
             extra={'uuid': annotation.uuid})
         if getattr(annotation, 'frames', None) is None:
@@ -204,7 +223,7 @@ def from_common(
             raise TypeError(
                 f"Unable to convert object to MAL format. `{type(annotation.value)}`"
             )
-        return classify_obj.from_common(annotation.value,
+        return classify_obj.from_common(annotation.value, annotation.name,
                                         annotation.feature_schema_id,
                                         annotation.extra, data)
 

labelbox/data/serialization/ndjson/label.py

@@ -50,7 +50,8 @@ def _generate_annotations(
             for annotation in annotations:
                 if isinstance(annotation, NDSegments):
                     annots.extend(
-                        NDSegments.to_common(annotation, annotation.schema_id))
+                        NDSegments.to_common(annotation, annotation.name,
+                                             annotation.schema_id))
                 elif isinstance(annotation, NDObjectType.__args__):
                     annots.append(NDObject.to_common(annotation))
                 elif isinstance(annotation, NDClassificationType.__args__):
@@ -97,7 +98,8 @@ def _create_video_annotations(
             if isinstance(
                     annot,
                 (VideoClassificationAnnotation, VideoObjectAnnotation)):
-                video_annotations[annot.feature_schema_id].append(annot)
+                video_annotations[annot.feature_schema_id or
+                                  annot.name].append(annot)
 
         for annotation_group in video_annotations.values():
             consecutive_frames = cls._get_consecutive_frames(