added the ability to strip schema ids and feature schema ids for when you want to inherit an ontology from a different project. also updated options to return an object class and insert nested_classes to Tool and Option

Author: jtsodapop

labelbox/schema/ontology_generator.py

@@ -1,18 +1,8 @@
 '''
 TODO
-2. validate that we can pull in all sorts of project ontology classes
-3. do the rest of the stuff below
-
-validate prior to submission, so likely in the o.build() - like have a way to make sure that classifications that need options have options
-
-work on enforcing certain classifications need options (and work on other things other than text)
-
 maybe there should be a way to check if a project has an existing ontology, and that it would overwrite it?
 
 in the future: work on adding NER capability for tool types (?)
-
-EXTRA
-    #TODO: look into static methods and differences vs. class methods
 '''
 
 from dataclasses import dataclass, field
@@ -34,20 +24,19 @@ class Option:
     value: str    
     schema_id: Optional[str] = None
     feature_schema_id: Optional[str] = None
-    #TODO: need to look further into how to make this so that the user cannot input anything here
-    options: Optional[Classification] = None
+    nested_classes: List[Classification] = field(default_factory=list)
 
     @property
     def label(self):
         return self.value
 
-    def to_dict(self) -> dict:
+    def to_dict(self,for_different_project=False) -> dict:
         return {
-            "schemaNodeId": self.schema_id,
-            "featureSchemaId": self.feature_schema_id,
+            "schemaNodeId": None if for_different_project else self.schema_id,
+            "featureSchemaId": None if for_different_project else self.feature_schema_id,
             "label": self.label,
             "value": self.value,
-            "options": [classification.to_dict() for classification in self.options]
+            "options": [classification.to_dict() for classification in self.nested_classes]
         }
 
     @classmethod
@@ -61,12 +50,19 @@ def has_nested_classifications(dictionary: dict):
             value = dictionary["value"],
             schema_id = dictionary["schemaNodeId"],
             feature_schema_id = dictionary["featureSchemaId"],
-            options = has_nested_classifications(dictionary)
+            nested_classes = has_nested_classifications(dictionary)
         )
+
+    def add_nested_class(self, *args, **kwargs):
+        new_classification = Classification(*args, **kwargs)
+        if new_classification.instructions in (classification.instructions for classification in self.nested_classes):
+            raise InconsistentOntologyException(f"Duplicate nested classification '{new_classification.instructions}' for option '{self.label}'")
+        self.nested_classes.append(new_classification)
+        return new_classification
 
 
 @dataclass
-class Classification:
+class Classification:    
 
     class Type(Enum):
         TEXT = "text"
@@ -81,19 +77,25 @@ class Type(Enum):
     schema_id: Optional[str] = None
     feature_schema_id: Optional[str] = None
 
+    @property
+    def requires_options(self):
+         return set((Classification.Type.CHECKLIST, Classification.Type.RADIO, Classification.Type.DROPDOWN))    
+
     @property
     def name(self):
         return self.instructions
 
-    def to_dict(self) -> dict:
+    def to_dict(self, for_different_project=False) -> dict:
+        if self.class_type in self.requires_options and len(self.options) < 1:
+            raise InconsistentOntologyException(f"Classification '{self.instructions}' requires options.")
         return {
             "type": self.class_type.value,
             "instructions": self.instructions,
             "name": self.name,
             "required": self.required,
-            "options": [option.to_dict() for option in self.options],
-            "schemaNodeId": self.schema_id,
-            "featureSchemaId": self.feature_schema_id
+            "options": [option.to_dict(for_different_project) for option in self.options],
+            "schemaNodeId": None if for_different_project else self.schema_id,
+            "featureSchemaId": None if for_different_project else self.feature_schema_id
         }   
 
     @classmethod
@@ -112,6 +114,7 @@ def add_option(self, *args, **kwargs):
         if new_option.value in (option.value for option in self.options):
             raise InconsistentOntologyException(f"Duplicate option '{new_option.value}' for classification '{self.name}'.")
         self.options.append(new_option)
+        return new_option
 
 @dataclass
 class Tool:
@@ -131,15 +134,15 @@ class Type(Enum):
     schema_id: Optional[str] = None
     feature_schema_id: Optional[str] = None
 
-    def to_dict(self) -> dict:
+    def to_dict(self,for_different_project=False) -> dict:
         return {
             "tool": self.tool.value,
             "name": self.name,
             "required": self.required,
             "color": self.color,
-            "classifications": [classification.to_dict() for classification in self.classifications],
-            "schemaNodeId": self.schema_id,
-            "featureSchemaId": self.feature_schema_id
+            "classifications": [classification.to_dict(for_different_project) for classification in self.classifications],
+            "schemaNodeId": None if for_different_project else self.schema_id,
+            "featureSchemaId": None if for_different_project else self.feature_schema_id
         }
 
     @classmethod 
@@ -154,6 +157,13 @@ def from_dict(cls, dictionary: dict):
             color = dictionary["color"]
         )
 
+    def add_nested_class(self, *args, **kwargs):
+        new_classification = Classification(*args, **kwargs)
+        if new_classification.instructions in (classification.instructions for classification in self.classifications):
+            raise InconsistentOntologyException(f"Duplicate nested classification '{new_classification.instructions}' for option '{self.label}'")
+        self.classifications.append(new_classification)
+        return new_classification        
+
 
 
 @dataclass
@@ -164,6 +174,8 @@ class Ontology:
 
     @classmethod
     def from_project(cls, project: Project):
+        #TODO: consider if this should take in a Project object, or the project.uid. 
+        #if we take in project.uid, we need to then get the project from a client object. 
         ontology = project.ontology().normalized
         return_ontology = Ontology()
 
@@ -189,15 +201,15 @@ def add_classification(self, *args, **kwargs) -> Classification:
         self.classifications.append(new_classification)
         return new_classification
 
-    def build(self):
+    def build(self, for_different_project=False):
         all_tools = []
         all_classifications = []
 
         for tool in self.tools:
-            all_tools.append(tool.to_dict())
+            all_tools.append(tool.to_dict(for_different_project))
 
-        for classification in self.classifications:
-            all_classifications.append(classification.to_dict())
+        for classification in self.classifications:   
+            all_classifications.append(classification.to_dict(for_different_project))
 
         return {"tools": all_tools, "classifications": all_classifications}
 
@@ -206,8 +218,7 @@ def build(self):
 '''
 def run():
     frontend = list(client.get_labeling_frontends(where=LabelingFrontend.name == "Editor"))[0]
-    project.setup(frontend, o.build())
-    return project
+    project.setup(frontend, o.build(for_different_project=False))
 
 def print_stuff():
     tools = o.tools
@@ -221,30 +232,21 @@ def print_stuff():
         print("\n",classification)
 
 if __name__ == "__main__":
-    import json
     os.system('clear')
-    apikey = os.environ['apikey']
-    client = Client(apikey) 
-    project = client.get_project("ckhchkye62xn30796uui5lu34")
+    # apikey = os.environ['apikey']
+    # client = Client(apikey) 
 
-    o = Ontology().from_project(project)
-    # print_stuff()
-    
+    # print("START\n")
+    # project = client.get_project("ckhchkye62xn30796uui5lu34")
+    # o = Ontology().from_project(project)
 
-    # o.add_tool(tool=Tool.Type.POLYGON, name="I AM HERE FOR TESTING YET AGAIN!!")
-    # checklist = o.add_classification(class_type=Classification.Type.CHECKLIST, instructions="I AM A CHECKLIST2")
-    # checklist.add_option(value="checklist answer 1")
-    # checklist.add_option(value="checklist answer 2")
-    o.add_classification(class_type=Classification.Type.TEXT, instructions="I AM TEXT INFO MAN 2")
+    # tool = o.add_tool(tool = Tool.Type.POINT, name = "first tool")
+    # nested_class = tool.add_nested_class(class_type = Classification.Type.DROPDOWN, instructions = "nested class")
+    # dropdown_option = nested_class.add_option(value="answer")
 
     # print_stuff()
-    # print("\n\n\n\n\n")
-    # print(o.build())
-    # print(type(o.build()))
-    # print(o.build())
-    run()
-
-    
+    # o.build()
+    # run()