cleaned up

Author: Matt Sokoloff

labelbox/client.py

@@ -1,6 +1,5 @@
 from datetime import datetime, timezone
 import json
-from labelbox.schema.ontology import Ontology
 import logging
 import mimetypes
 import os
@@ -415,12 +414,6 @@ def get_datasets(self, where=None):
         """
         return self._get_all(Dataset, where)
 
-    def get_ontologies(self, where=None):
-        """
-        #TODO
-        """
-        return self._get_all(Ontology, where)
-
     def get_labeling_frontends(self, where=None):
         """ Fetches all the labeling frontends.
 
@@ -479,9 +472,7 @@ def create_dataset(self, **kwargs):
         """
         return self._create(Dataset, kwargs)
 
-    def create_project(self,
-                       ontology=None,
-                       **kwargs):  #<<<<<   TODO: Do we want that signature
+    def create_project(self, **kwargs):
         """ Creates a Project object on the server.
 
         Attribute values are passed as keyword arguments.

labelbox/schema/labeling_frontend.py

@@ -35,6 +35,7 @@ class LabelingFrontendOptions(DbObject):
         organization (Relationship): `ToOne` relationship to Organization
     """
     customization_options = Field.String("customization_options")
+
     project = Relationship.ToOne("Project")
     labeling_frontend = Relationship.ToOne("LabelingFrontend")
     organization = Relationship.ToOne("Organization")

labelbox/schema/ontology.py

@@ -63,55 +63,9 @@ def from_json(cls, json_dict):
         return cls(**_dict)
 
 
-"""
-* The reason that an ontology is read only is because it is a second class citizen to labeling front end options.
-** This is because it is a more specific implementation of this.
-
-- However, we want to support ontologies as if they were labeling front ends.
-- With this special relationship we can override the default behavior to mock the appropriate changes to the labeling front end
-
-
-###Note: The only problem is that you can't just create a stand alone ontology. right? 
-# - Since you need to create a project and query the project ontology before one exists.
-
-^^^^^^^ This is the worst. Even with hackery, you can't force a DB entry without create a new proj :(
-     However, labeling front-ends cannot be created without projects either! So maybe we just copy the use cases of that.
-     Use this as the simpler interface and make it clear that this is just a limited version
-
-"""
-
-
-class OntologyRelationship(Relationship):
-
-    def __get__(self, parent):
-        if not self.parent:
-            self.parent = parent
-        return self
-
-    def __init__(self):
-        super(OntologyRelationship, self).__init__()
-        self.parent = None
-
-    def __call__(self):
-        if self.parent.setup_complete is None:
-            #As it currently stands, it creates a new ontology with no new tools and the ontology cannot be edited.
-            return None
-        return super().__call__
-
-    def connect(self, other_ontology):
-        if not isinstance(other_ontology, OntologyRelationship):
-            raise Exception("only support ")
-
-    def disconnect(self):
-        raise Exception(
-            "Disconnect is not supported for Onotlogy. Instead connect another ontology to replace the current one."
-        )
-
-
 class Ontology(DbObject):
     """An ontology specifies which tools and classifications are available
     to a project. This is read only for now.
-
     Attributes:
         name (str)
         description (str)
@@ -120,7 +74,6 @@ class Ontology(DbObject):
         normalized (json)
         object_schema_count (int)
         classification_schema_count (int)
-
         projects (Relationship): `ToMany` relationship to Project
         created_by (Relationship): `ToOne` relationship to User
     """

labelbox/schema/project.py

@@ -221,16 +221,6 @@ def review_metrics(self, net_score):
         res = self.client.execute(query_str, {id_param: self.uid})
         return res["project"]["reviewMetrics"]["labelAggregate"]["count"]
 
-    def setup_from_ontology(self, ontology):
-        """
-        * An ontology is a specific kind of a labeling frontend option that is compatible with the Editor.
-        * Most customers use this interface
-        """
-        frontend = list(
-            client.get_labeling_frontends(
-                where=LabelingFrontend.name == "Editor"))[0]
-        return self.setup(frontend, ontology.normalized)
-
     def setup(self, labeling_frontend, labeling_frontend_options):
         """ Finalizes the Project setup.