add cuid type

Author: Matt Sokoloff

labelbox/data/annotation_types/annotation.py

@@ -49,9 +49,5 @@ class VideoClassificationAnnotation(ClassificationAnnotation):
     frame: int
 
 
-AnnotationType = Union[ClassificationAnnotation, ObjectAnnotation]
-VideoAnnotationType = Union[VideoObjectAnnotation,
-                            VideoClassificationAnnotation]
-
 VideoObjectAnnotation.update_forward_refs()
 ObjectAnnotation.update_forward_refs()

labelbox/data/annotation_types/feature.py

@@ -2,6 +2,8 @@
 
 from pydantic import BaseModel, root_validator
 
+from .types import Cuid
+
 
 class FeatureSchema(BaseModel):
     """
@@ -13,7 +15,7 @@ class FeatureSchema(BaseModel):
     to retroactively add schema ids by looking them up from the names.
     """
     name: Optional[str] = None
-    schema_id: Optional[str] = None
+    schema_id: Optional[Cuid] = None
 
     @root_validator
     def must_set_one(cls, values):

labelbox/data/annotation_types/label.py

@@ -8,13 +8,15 @@
 from .data import VideoData, TextData, RasterData
 from .geometry.mask import Mask
 from .metrics import Metric
-from .annotation import (AnnotationType, ClassificationAnnotation,
-                         ObjectAnnotation, VideoAnnotationType)
+from .annotation import (ClassificationAnnotation, ObjectAnnotation,
+                         VideoClassificationAnnotation, VideoObjectAnnotation)
 
 
 class Label(BaseModel):
     data: Union[VideoData, RasterData, TextData]
-    annotations: List[Union[AnnotationType, VideoAnnotationType, Metric]] = []
+    annotations: List[Union[ClassificationAnnotation, ObjectAnnotation,
+                            VideoObjectAnnotation,
+                            VideoClassificationAnnotation, Metric]] = []
     extra: Dict[str, Any] = {}
 
     def add_url_to_data(self, signer) -> "Label":

labelbox/data/annotation_types/types.py

@@ -0,0 +1,4 @@
+from pydantic import Field
+from typing_extensions import Annotated
+
+Cuid = Annotated[str, Field(min_length=25, max_length=25)]

labelbox/data/serialization/labelbox_v1/classification.py

@@ -4,6 +4,7 @@
 
 from ...annotation_types.annotation import ClassificationAnnotation
 from ...annotation_types.classification import Checklist, ClassificationAnswer, Radio, Text, Dropdown
+from ...annotation_types.types import Cuid
 from .feature import LBV1Feature
 
 
@@ -24,7 +25,7 @@ def to_common(self):
             }))
 
     @classmethod
-    def from_common(cls, radio: Radio, schema_id: str, **extra) -> "LBV1Radio":
+    def from_common(cls, radio: Radio, schema_id: Cuid, **extra) -> "LBV1Radio":
         return cls(schema_id=schema_id,
                    answer=LBV1ClassificationAnswer(
                        schema_id=radio.answer.schema_id,
@@ -48,7 +49,7 @@ def to_common(self):
         ])
 
     @classmethod
-    def from_common(cls, checklist: Checklist, schema_id: str,
+    def from_common(cls, checklist: Checklist, schema_id: Cuid,
                     **extra) -> "LBV1Checklist":
         return cls(schema_id=schema_id,
                    answers=[
@@ -69,22 +70,14 @@ def to_common(self):
         return Text(answer=self.answer)
 
     @classmethod
-    def from_common(cls, text: Text, schema_id: str, **extra) -> "LBV1Text":
+    def from_common(cls, text: Text, schema_id: Cuid, **extra) -> "LBV1Text":
         return cls(schema_id=schema_id, answer=text.answer, **extra)
 
 
-classification_mapping = {
-    Text: LBV1Text,
-    Dropdown: LBV1Checklist,
-    Checklist: LBV1Checklist,
-    Radio: LBV1Radio
-}
-
-
 class LBV1Classifications(BaseModel):
     classifications: List[Union[LBV1Radio, LBV1Checklist, LBV1Text]] = []
 
-    def to_common(self):
+    def to_common(self) -> List[ClassificationAnnotation]:
         classifications = [
             ClassificationAnnotation(value=classification.to_common(),
                                      classifications=[],
@@ -103,7 +96,7 @@ def from_common(
     ) -> "LBV1Classifications":
         classifications = []
         for annotation in annotations:
-            classification = classification_mapping.get(type(annotation.value))
+            classification = cls.lookup_classification(annotation)
             if classification is not None:
                 classifications.append(
                     classification.from_common(annotation.value,
@@ -112,3 +105,14 @@ def from_common(
             else:
                 raise TypeError(f"Unexpected type {type(annotation.value)}")
         return cls(classifications=classifications)
+
+    @staticmethod
+    def lookup_classification(
+        annotation: ClassificationAnnotation
+    ) -> Union[LBV1Text, LBV1Checklist, LBV1Radio]:
+        return {
+            Text: LBV1Text,
+            Dropdown: LBV1Checklist,
+            Checklist: LBV1Checklist,
+            Radio: LBV1Radio
+        }.get(type(annotation.value))

labelbox/data/serialization/labelbox_v1/converter.py

@@ -73,7 +73,6 @@ class LBV1VideoIterator(PrefetchGenerator):
 
     def __init__(self, examples, client):
         self.client = client
-
         super().__init__(examples)
 
     def _process(self, value):

labelbox/data/serialization/labelbox_v1/feature.py

@@ -1,14 +1,17 @@
 from typing import Optional
 
-from pydantic import BaseModel, Field, root_validator
+from pydantic import BaseModel, root_validator
+
+from labelbox.utils import camel_case
+from ...annotation_types.types import Cuid
 
 
 class LBV1Feature(BaseModel):
-    keyframe: Optional[bool] = Field(None)
+    keyframe: Optional[bool] = None
     title: str = None
     value: Optional[str] = None
-    schema_id: str = Field(None, alias='schemaId')
-    feature_id: Optional[str] = Field(None, alias='featureId')
+    schema_id: Optional[Cuid] = None
+    feature_id: Optional[Cuid] = None
 
     @root_validator
     def check_ids(cls, values):
@@ -25,3 +28,4 @@ def dict(self, *args, **kwargs):
 
     class Config:
         allow_population_by_field_name = True
+        alias_generator = camel_case