Add ConfidenceMixin to Classification annotation and it's *values*

Author: Val Brodsky

labelbox/data/annotation_types/annotation.py

@@ -16,7 +16,7 @@ class BaseAnnotation(FeatureSchema, abc.ABC):
     extra: Dict[str, Any] = {}
 
 
-class ClassificationAnnotation(BaseAnnotation):
+class ClassificationAnnotation(BaseAnnotation, ConfidenceMixin):
     """Classification annotations (non localized)
 
     >>> ClassificationAnnotation(

labelbox/data/annotation_types/classification/classification.py

@@ -13,7 +13,7 @@
 
 
 # TODO: Replace when pydantic adds support for unions that don't coerce types
-class _TempName(BaseModel):
+class _TempName(ConfidenceMixin, BaseModel):
     name: str
 
     def dict(self, *args, **kwargs):
@@ -43,7 +43,7 @@ def dict(self, *args, **kwargs) -> Dict[str, str]:
         return res
 
 
-class Radio(BaseModel):
+class Radio(ConfidenceMixin, BaseModel):
     """ A classification with only one selected option allowed
 
     >>> Radio(answer = ClassificationAnswer(name = "dog"))
@@ -62,7 +62,7 @@ class Checklist(_TempName):
     answer: List[ClassificationAnswer]
 
 
-class Text(BaseModel):
+class Text(ConfidenceMixin, BaseModel):
     """ Free form text
 
     >>> Text(answer = "some text answer")

labelbox/data/serialization/ndjson/classification.py

@@ -120,25 +120,33 @@ def from_common(cls, radio: Radio, name: str,
 class NDText(NDAnnotation, NDTextSubclass):
 
     @classmethod
-    def from_common(cls, text: Text, name: str, feature_schema_id: Cuid,
-                    extra: Dict[str, Any], data: Union[TextData,
-                                                       ImageData]) -> "NDText":
+    def from_common(cls,
+                    text: Text,
+                    name: str,
+                    feature_schema_id: Cuid,
+                    extra: Dict[str, Any],
+                    data: Union[TextData, ImageData],
+                    confidence: Optional[float] = None) -> "NDText":
         return cls(
             answer=text.answer,
             data_row=DataRow(id=data.uid, global_key=data.global_key),
             name=name,
             schema_id=feature_schema_id,
             uuid=extra.get('uuid'),
+            confidence=confidence,
         )
 
 
 class NDChecklist(NDAnnotation, NDChecklistSubclass, VideoSupported):
 
     @classmethod
-    def from_common(
-            cls, checklist: Checklist, name: str, feature_schema_id: Cuid,
-            extra: Dict[str, Any], data: Union[VideoData, TextData,
-                                               ImageData]) -> "NDChecklist":
+    def from_common(cls,
+                    checklist: Checklist,
+                    name: str,
+                    feature_schema_id: Cuid,
+                    extra: Dict[str, Any],
+                    data: Union[VideoData, TextData, ImageData],
+                    confidence: Optional[float] = None) -> "NDChecklist":
         return cls(answer=[
             NDFeature(name=answer.name,
                       schema_id=answer.feature_schema_id,
@@ -149,23 +157,29 @@ def from_common(
                    name=name,
                    schema_id=feature_schema_id,
                    uuid=extra.get('uuid'),
-                   frames=extra.get('frames'))
+                   frames=extra.get('frames'),
+                   confidence=confidence)
 
 
 class NDRadio(NDAnnotation, NDRadioSubclass, VideoSupported):
 
     @classmethod
-    def from_common(cls, radio: Radio, name: str, feature_schema_id: Cuid,
-                    extra: Dict[str, Any], data: Union[VideoData, TextData,
-                                                       ImageData]) -> "NDRadio":
+    def from_common(cls,
+                    radio: Radio,
+                    name: str,
+                    feature_schema_id: Cuid,
+                    extra: Dict[str, Any],
+                    data: Union[VideoData, TextData, ImageData],
+                    confidence: Optional[float] = None) -> "NDRadio":
         return cls(answer=NDFeature(name=radio.answer.name,
                                     schema_id=radio.answer.feature_schema_id,
                                     confidence=radio.answer.confidence),
                    data_row=DataRow(id=data.uid, global_key=data.global_key),
                    name=name,
                    schema_id=feature_schema_id,
                    uuid=extra.get('uuid'),
-                   frames=extra.get('frames'))
+                   frames=extra.get('frames'),
+                   confidence=confidence)
 
 
 class NDSubclassification:
@@ -235,7 +249,8 @@ def from_common(
             )
         return classify_obj.from_common(annotation.value, annotation.name,
                                         annotation.feature_schema_id,
-                                        annotation.extra, data)
+                                        annotation.extra, data,
+                                        annotation.confidence)
 
     @staticmethod
     def lookup_classification(

tests/data/serialization/ndjson/test_text.py

@@ -1,20 +1,28 @@
 import json
+from labelbox.data.annotation_types.annotation import ClassificationAnnotation
+from labelbox.data.annotation_types.classification.classification import ClassificationAnswer, Radio, Text
+from labelbox.data.annotation_types.data.text import TextData
+from labelbox.data.annotation_types.label import Label
 
 from labelbox.data.serialization.ndjson.converter import NDJsonConverter
 
 
-def test_text():
-    with open('tests/data/assets/ndjson/text_import.json', 'r') as file:
-        data = json.load(file)
-    res = list(NDJsonConverter.deserialize(data))
-    res = list(NDJsonConverter.serialize(res))
-    assert res == data
+def test_serialization():
+    label = Label(uid="ckj7z2q0b0000jx6x0q2q7q0d",
+                  data=TextData(
+                      uid="bkj7z2q0b0000jx6x0q2q7q0d",
+                      text="This is a test",
+                  ),
+                  annotations=[
+                      ClassificationAnnotation(
+                          name="radio_question_geo",
+                          confidence=0.5,
+                          value=Text(answer="first_radio_answer"))
+                  ])
 
-
-def test_text_name_only():
-    with open('tests/data/assets/ndjson/text_import_name_only.json',
-              'r') as file:
-        data = json.load(file)
-    res = list(NDJsonConverter.deserialize(data))
-    res = list(NDJsonConverter.serialize(res))
-    assert res == data
+    serialized = NDJsonConverter.serialize([label])
+    res = next(serialized)
+    assert res['confidence'] == 0.5
+    assert res['name'] == "radio_question_geo"
+    assert res['answer'] == "first_radio_answer"
+    assert res['dataRow']['id'] == "bkj7z2q0b0000jx6x0q2q7q0d"