support derived class

Author: Matt Sokoloff

labelbox/schema/ontology.py

@@ -17,7 +17,7 @@
 class Option:
     """
     An option is a possible answer within a Classification object in
-    a Project's ontology. 
+    a Project's ontology.
 
     To instantiate, only the "value" parameter needs to be passed in.
 
@@ -41,11 +41,11 @@ def label(self):
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
-        return Option(value=dictionary["value"],
+        return cls(value=dictionary["value"],
                       schema_id=dictionary.get("schemaNodeId", None),
                       feature_schema_id=dictionary.get("featureSchemaId", None),
                       options=[
-                          Classification.from_dict(o)
+                          cls.from_dict(o)
                           for o in dictionary.get("options", [])
                       ])
 
@@ -69,13 +69,13 @@ def add_option(self, option: 'Classification'):
 @dataclass
 class Classification:
     """
-    A classfication to be added to a Project's ontology. The  
+    A classfication to be added to a Project's ontology. The
     classification is dependent on the Classification Type.
 
     To instantiate, the "class_type" and "instructions" parameters must
     be passed in.
 
-    The "options" parameter holds a list of Option objects. This is not 
+    The "options" parameter holds a list of Option objects. This is not
     necessary for some Classification types, such as TEXT. To see which
     types require options, look at the "_REQUIRES_OPTIONS" class variable.
 
@@ -120,16 +120,16 @@ def name(self):
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
-        return Classification(
-            class_type=Classification.Type(dictionary["type"]),
+        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 Classification._REQUIRES_OPTIONS \
+        if self.class_type in self._REQUIRES_OPTIONS \
                 and len(self.options) < 1:
             raise InconsistentOntologyException(
                 f"Classification '{self.instructions}' requires options.")
@@ -160,13 +160,13 @@ class Tool:
     To instantiate, the "tool" and "name" parameters must
     be passed in.
 
-    The "classifications" parameter holds a list of Classification objects. 
+    The "classifications" parameter holds a list of Classification objects.
     This can be used to add nested classifications to a tool.
 
     Example(s):
         tool = Tool(
             tool = Tool.Type.LINE,
-            name = "Tool example")    
+            name = "Tool example")
         classification = Classification(
             class_type = Classification.Type.TEXT,
             instructions = "Classification Example")
@@ -200,11 +200,11 @@ class Type(Enum):
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
-        return Tool(name=dictionary['name'],
+        return cls(name=dictionary['name'],
                     schema_id=dictionary.get("schemaNodeId", None),
                     feature_schema_id=dictionary.get("featureSchemaId", None),
                     required=dictionary.get("required", False),
-                    tool=Tool.Type(dictionary["tool"]),
+                    tool=cls.Type(dictionary["tool"]),
                     classifications=[
                         Classification.from_dict(c)
                         for c in dictionary["classifications"]
@@ -287,9 +287,9 @@ class OntologyBuilder:
     for making Project ontologies from scratch. OntologyBuilder can also
     pull from an already existing Project's ontology.
 
-    There are no required instantiation arguments. 
+    There are no required instantiation arguments.
 
-    To create an ontology, use the asdict() method after fully building your 
+    To create an ontology, use the asdict() method after fully building your
     ontology within this class, and inserting it into project.setup() as the
     "labeling_frontend_options" parameter.
 
@@ -303,14 +303,14 @@ class OntologyBuilder:
         tools: (list)
         classifications: (list)
 
-    
+
     """
     tools: List[Tool] = field(default_factory=list)
     classifications: List[Classification] = field(default_factory=list)
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
-        return OntologyBuilder(
+        return cls(
             tools=[Tool.from_dict(t) for t in dictionary["tools"]],
             classifications=[
                 Classification.from_dict(c)
@@ -337,7 +337,7 @@ def _update_colors(self):
     @classmethod
     def from_project(cls, project: Project):
         ontology = project.ontology().normalized
-        return OntologyBuilder.from_dict(ontology)
+        return cls.from_dict(ontology)
 
     def add_tool(self, tool: Tool):
         if tool.name in (t.name for t in self.tools):