ontology features working

Author: Matt Sokoloff

labelbox/client.py

@@ -196,6 +196,7 @@ def check_errors(keywords, *path):
             return None
 
         def get_error_status_code(error):
+            print(error)
             return error["extensions"]["exception"].get("status")
 
         if check_errors(["AUTHENTICATION_ERROR"], "extensions",
@@ -409,7 +410,7 @@ def get_project(self, project_id):
             labelbox.exceptions.ResourceNotFoundError: If there is no
                 Project with the given ID.
         """
-        return self._get_single(Project, project_id)
+        return self._get_single(Entity.Project, project_id)
 
     def get_dataset(self, dataset_id):
         """ Gets a single Dataset with the given ID.
@@ -720,7 +721,62 @@ def get_ontologies(self, name_contains: str):
         res = PaginatedCollection(
             self, query_str, {'search' : name_contains, 'filter' :{'status' : 'ALL'}}, ['ontologies', 'nodes'],
             Entity.Ontology, ['ontologies', 'nextCursor'])
+        # status can be ALL or UNUSED
         return res
 
+    def get_root_schema(self, root_schema_id):
+        return self._get_single(Entity.RootSchemaNode, root_schema_id)
+
+
+    def get_root_schemas(self, name_contains):
+        query_str = """query getRootSchemaNodePyApi($search: String, $filter: RootSchemaNodeFilter, $from : String, $first: PageSize){
+            rootSchemaNodes(where: {filter: $filter, search: $search}, after: $from, first: $first){
+                nodes {%s}
+                nextCursor
+            }
+        }
+        """ % query.results_query_part(Entity.RootSchemaNode)
+        return PaginatedCollection(
+            self, query_str, {'search' : name_contains, 'filter' :{'status' : 'ALL'}}, ['rootSchemaNodes', 'nodes'],
+            Entity.RootSchema, ['rootSchemaNodes', 'nextCursor'])
+
+        # TODO: Also supports FeatreSchemaKind in the filter
+        # status can be ALL or UNUSED
+
+    def create_ontology(self, name , normalized_ontology = None, root_schema_ids = None):
+        """
+        - If I create an ontology with an empty ontology does it create the root schemas?
+        - If I mix ontology with root schemas it reuses right?
+
+        - should be able to lookup root schema nodes for an ontology. Add relationship..
+        """
+        query_str = """mutation upsertRootSchemaNodePyApi($data:  UpsertOntologyInput!){
+            upsertOntology(data: $data){
+             %s
+            }
+        } """ % query.results_query_part(Entity.Ontology)
+        if normalized_ontology is None:
+            if root_schema_ids is None:
+                raise ValueError("Must provide either a normalized ontology or a list of root_schema_ids")
+            return root_schema_ids
+
+        res = self.execute(query_str, {'data' : {'name' : name ,'normalized' : json.dumps(normalized_ontology)}})
+        return Entity.Ontology(self, res['upsertOntology'])
+
+
+    def create_root_schema(self, normalized_ontology):
+        query_str = """mutation upsertRootSchemaNodePyApi($data:  UpsertRootSchemaNodeInput!){
+            upsertRootSchemaNode(data: $data){
+             %s
+            }
+        } """ % query.results_query_part(Entity.RootSchema)
+        # TODO: Is this necessary?
+        normalized_ontology = {k:v for k,v in normalized_ontology.items() if v}
+        # Check color. Quick gotcha..
+        if 'color' not in normalized_ontology:
+            raise KeyError("Must provide color.")
+        return Entity.RootSchemaNode(self, self.execute(query_str, {'data' : {'normalized' : json.dumps(normalized_ontology)}})['upsertRootSchemaNode'])
+
+
 
 

labelbox/schema/ontology.py

@@ -16,6 +16,14 @@
 SchemaId: Type[str] = constr(min_length=25, max_length=25)
 
 
+
+class RootSchemaNode(DbObject):
+    name = Field.String("name")
+    color = Field.String("name")
+    definition = Field.Json("definition")
+    normalized = Field.Json("normalized")
+
+
 @dataclass
 class Option:
     """
@@ -52,6 +60,10 @@ def from_dict(cls, dictionary: Dict[str, Any]):
                        for o in dictionary.get("options", [])
                    ])
 
+    @classmethod
+    def from_root_schema(cls, root_schema: RootSchemaNode):
+        return cls.from_dict(root_schema.normalized)
+
     def asdict(self) -> Dict[str, Any]:
         return {
             "schemaNodeId": self.schema_id,
@@ -130,6 +142,10 @@ def from_dict(cls, dictionary: Dict[str, Any]):
                    schema_id=dictionary.get("schemaNodeId", None),
                    feature_schema_id=dictionary.get("featureSchemaId", None))
 
+    @classmethod
+    def from_root_schema(cls, root_schema: RootSchemaNode):
+        return cls.from_dict(root_schema.normalized)
+
     def asdict(self) -> Dict[str, Any]:
         if self.class_type in self._REQUIRES_OPTIONS \
                 and len(self.options) < 1:
@@ -233,11 +249,6 @@ def add_classification(self, classification: Classification):
         self.classifications.append(classification)
 
 
-class FeatureSchema(DbObject):
-    ...
-
-
-
 class Ontology(DbObject):
     """An ontology specifies which tools and classifications are available
     to a project. This is read only for now.
@@ -345,6 +356,11 @@ def from_project(cls, project: "project.Project"):
         ontology = project.ontology().normalized
         return cls.from_dict(ontology)
 
+    @classmethod
+    def from_ontology(cls, ontology: Ontology):
+        return cls.from_dict(ontology.normalized)
+
+
     def add_tool(self, tool: Tool):
         if tool.name in (t.name for t in self.tools):
             raise InconsistentOntologyException(
@@ -358,3 +374,6 @@ def add_classification(self, classification: Classification):
                 f"Duplicate classification instructions '{classification.instructions}'. "
             )
         self.classifications.append(classification)
+
+
+

labelbox/schema/project.py

@@ -1,5 +1,6 @@
 import enum
 import json
+from labelbox.schema.labeling_frontend import LabelingFrontend
 import logging
 import time
 import warnings
@@ -422,6 +423,16 @@ def review_metrics(self, net_score):
         res = self.client.execute(query_str, {id_param: self.uid})
         return res["project"]["reviewMetrics"]["labelAggregate"]["count"]
 
+
+    def setup_editor(self, ontology):
+        fe  = next(self.client.get_labeling_frontends(where = LabelingFrontend.name == "Editor"))
+        self.labeling_frontend.connect(fe)
+        query_str = """mutation ConnectOntology($projectId: ID!, $ontologyId: ID!) {project(where: {id: $projectId}) {connectOntology(ontologyId: $ontologyId) {id}}}"""
+        self.client.execute(query_str, {'ontologyId' : ontology.uid, 'projectId' :  self.uid})
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        self.update(setup_complete=timestamp)
+
+
     def setup(self, labeling_frontend, labeling_frontend_options):
         """ Finalizes the Project setup.
 
@@ -481,7 +492,7 @@ def _post_batch(self, method, data_row_ids: List[str]):
                   }
                 }
               }
-            }         
+            }
         """ % (method, method)
 
         res = self.client.execute(query, {
@@ -517,7 +528,7 @@ def _update_queue_mode(self, mode: QueueMode) -> QueueMode:
                     tagSetStatus
                 }
             }
-        }       
+        }
         """ % "setTagSetStatusPyApi"
 
         self.client.execute(query_str, {
@@ -533,7 +544,7 @@ def queue_mode(self):
               project(where: {id: $projectId}) {
                  tagSetStatus
             }
-        }       
+        }
         """ % "GetTagSetStatusPyApi"
 
         status = self.client.execute(

tests/integration/annotation_import/test_model.py

@@ -29,3 +29,6 @@ def test_model_delete(client, model):
     after = list(client.get_models())
 
     assert len(before) == len(after) + 1
+
+
+

tests/integration/conftest.py

@@ -333,3 +333,4 @@ def configured_project_with_label(client, rand_gen, image_url):
     yield [project, label]
     dataset.delete()
     project.delete()
+

tests/integration/test_ontology.py

@@ -240,3 +240,9 @@ def test_ontology_asdict(project) -> None:
 def test_from_project_ontology(client, project) -> None:
     o = OntologyBuilder.from_project(project)
     assert o.asdict() == project.ontology().normalized
+
+
+
+def test_create_ontology(client, rand_gen):
+    client.create_ontology(name = f"test-ontology-{rand_gen(str)}")
+