update to make the ability to separate between label and value and update to test cases

Author: jtsodapop

labelbox/schema/ontology.py

@@ -34,17 +34,19 @@ class Option:
         options: (list)
     """
     value: Union[str, int]
+    label: Optional[Union[str, int]] = None
     schema_id: Optional[str] = None
     feature_schema_id: Optional[FeatureSchemaId] = None
     options: List["Classification"] = field(default_factory=list)
 
-    @property
-    def label(self):
-        return self.value
+    def __post_init__(self):
+        if self.label is None:
+            self.label = self.value
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
         return cls(value=dictionary["value"],
+                   label=dictionary["label"],
                    schema_id=dictionary.get("schemaNodeId", None),
                    feature_schema_id=dictionary.get("featureSchemaId", None),
                    options=[
@@ -101,7 +103,6 @@ class Classification:
         schema_id: (str)
         feature_schema_id: (str)
     """
-
     class Type(Enum):
         TEXT = "text"
         CHECKLIST = "checklist"
@@ -123,12 +124,13 @@ def name(self):
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
-        return cls(class_type=cls.Type(dictionary["type"]),
-                   instructions=dictionary["instructions"],
-                   required=dictionary.get("required", False),
-                   options=[Option.from_dict(o) for o in dictionary["options"]],
-                   schema_id=dictionary.get("schemaNodeId", None),
-                   feature_schema_id=dictionary.get("featureSchemaId", None))
+        return cls(
+            class_type=cls.Type(dictionary["type"]),
+            instructions=dictionary["instructions"],
+            required=dictionary.get("required", False),
+            options=[Option.from_dict(o) for o in dictionary["options"]],
+            schema_id=dictionary.get("schemaNodeId", None),
+            feature_schema_id=dictionary.get("featureSchemaId", None))
 
     def asdict(self) -> Dict[str, Any]:
         if self.class_type in self._REQUIRES_OPTIONS \
@@ -183,7 +185,6 @@ class Tool:
         schema_id: (str)
         feature_schema_id: (str)
     """
-
     class Type(Enum):
         POLYGON = "polygon"
         SEGMENTATION = "superpixel"
@@ -225,8 +226,8 @@ def asdict(self) -> Dict[str, Any]:
         }
 
     def add_classification(self, classification: Classification):
-        if classification.instructions in (
-                c.instructions for c in self.classifications):
+        if classification.instructions in (c.instructions
+                                           for c in self.classifications):
             raise InconsistentOntologyException(
                 f"Duplicate nested classification '{classification.instructions}' "
                 f"for tool '{self.name}'")
@@ -347,8 +348,8 @@ def add_tool(self, tool: Tool):
         self.tools.append(tool)
 
     def add_classification(self, classification: Classification):
-        if classification.instructions in (
-                c.instructions for c in self.classifications):
+        if classification.instructions in (c.instructions
+                                           for c in self.classifications):
             raise InconsistentOntologyException(
                 f"Duplicate classification instructions '{classification.instructions}'. "
             )

tests/integration/test_ontology.py

@@ -22,39 +22,39 @@
         "classifications": []
     }, {
         "schemaNodeId":
-            None,
+        None,
         "featureSchemaId":
-            None,
+        None,
         "required":
-            False,
+        False,
         "name":
-            "bbox",
+        "bbox",
         "color":
-            "#FF0000",
+        "#FF0000",
         "tool":
-            "rectangle",
+        "rectangle",
         "classifications": [{
             "schemaNodeId":
-                None,
+            None,
             "featureSchemaId":
-                None,
+            None,
             "required":
-                True,
+            True,
             "instructions":
-                "nested classification",
+            "nested classification",
             "name":
-                "nested classification",
+            "nested classification",
             "type":
-                "radio",
+            "radio",
             "options": [{
                 "schemaNodeId":
-                    None,
+                None,
                 "featureSchemaId":
-                    None,
+                None,
                 "label":
-                    "first",
+                "first",
                 "value":
-                    "first",
+                "first",
                 "options": [{
                     "schemaNodeId": None,
                     "featureSchemaId": None,
@@ -107,28 +107,28 @@
     }],
     "classifications": [{
         "schemaNodeId":
-            None,
+        None,
         "featureSchemaId":
-            None,
+        None,
         "required":
-            True,
+        True,
         "instructions":
-            "This is a question.",
+        "This is a question.",
         "name":
-            "This is a question.",
+        "This is a question.",
         "type":
-            "radio",
+        "radio",
         "options": [{
             "schemaNodeId": None,
             "featureSchemaId": None,
             "label": "yes",
-            "value": "yes",
+            "value": "definitely yes",
             "options": []
         }, {
             "schemaNodeId": None,
             "featureSchemaId": None,
             "label": "no",
-            "value": "no",
+            "value": "definitely not",
             "options": []
         }]
     }]
@@ -149,12 +149,22 @@ def test_create_classification(class_type) -> None:
 
 @pytest.mark.parametrize("value, expected_value, typing",
                          [(3, 3, int), ("string", "string", str)])
-def test_create_option(value, expected_value, typing) -> None:
+def test_create_option_with_value(value, expected_value, typing) -> None:
     o = Option(value=value)
     assert (o.value == expected_value)
     assert (o.value == o.label)
 
 
+@pytest.mark.parametrize("value, label, expected_value, typing",
+                         [(3, 2, 3, int),
+                          ("string", "another string", "string", str)])
+def test_create_option_with_value_and_label(value, label, expected_value,
+                                            typing) -> None:
+    o = Option(value=value, label=label)
+    assert (o.value == expected_value)
+    assert o.value != o.label
+
+
 def test_create_empty_ontology() -> None:
     o = OntologyBuilder()
     assert (o.tools == [])
@@ -200,7 +210,8 @@ def test_add_ontology_classification() -> None:
 
 def test_tool_add_classification() -> None:
     t = Tool(tool=Tool.Type.SEGMENTATION, name="segmentation")
-    c = Classification(class_type=Classification.Type.TEXT, instructions="text")
+    c = Classification(class_type=Classification.Type.TEXT,
+                       instructions="text")
     t.add_classification(c)
     assert t.classifications == [c]
 
@@ -223,7 +234,8 @@ def test_classification_add_option() -> None:
 
 def test_option_add_option() -> None:
     o = Option(value="option")
-    c = Classification(class_type=Classification.Type.TEXT, instructions="text")
+    c = Classification(class_type=Classification.Type.TEXT,
+                       instructions="text")
     o.add_option(c)
     assert o.options == [c]