Merge pull request #208 from Labelbox/ms/remove-deprecated-fix-tests

removed deprecated functions, fix tests

Author: msokoloff1

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+# Next Release
+
+## Removed
+* Deprecated functions
+    - project.reviews()
+    - project.create_prediction()
+    - project.create_prediction_model()
+    - project.create_label()
+
 # Version 2.7.0 (2021-06-27)
 ## Added
 * Added `dataset.export_data_rows()` which returns all `DataRows` for a `Dataset`.

Makefile

@@ -6,7 +6,7 @@ test-staging: build
 	docker run -it -v ${PWD}:/usr/src -w /usr/src \
 		-e LABELBOX_TEST_ENVIRON="staging" \
 		-e LABELBOX_TEST_API_KEY_STAGING=${LABELBOX_TEST_API_KEY_STAGING} \
-		local/labelbox-python:test pytest $(PATH_TO_TEST) -svvx
+		local/labelbox-python:test pytest $(PATH_TO_TEST) -svv
 
 test-prod: build
 	docker run -it -v ${PWD}:/usr/src -w /usr/src \

labelbox/schema/ontology.py

@@ -38,11 +38,13 @@ def label(self):
 
     @classmethod
     def from_dict(cls, dictionary: Dict[str, Any]):
-        return cls(
-            value=dictionary["value"],
-            schema_id=dictionary.get("schemaNodeId", None),
-            feature_schema_id=dictionary.get("featureSchemaId", None),
-            options=[cls.from_dict(o) for o in dictionary.get("options", [])])
+        return cls(value=dictionary["value"],
+                   schema_id=dictionary.get("schemaNodeId", None),
+                   feature_schema_id=dictionary.get("featureSchemaId", None),
+                   options=[
+                       Classification.from_dict(o)
+                       for o in dictionary.get("options", [])
+                   ])
 
     def asdict(self) -> Dict[str, Any]:
         return {

labelbox/schema/project.py

@@ -67,7 +67,6 @@ class Project(DbObject, Updateable, Deletable):
     datasets = Relationship.ToMany("Dataset", True)
     created_by = Relationship.ToOne("User", False, "created_by")
     organization = Relationship.ToOne("Organization", False)
-    reviews = Relationship.ToMany("Review", True)
     labeling_frontend = Relationship.ToOne("LabelingFrontend")
     labeling_frontend_options = Relationship.ToMany(
         "LabelingFrontendOptions", False, "labeling_frontend_options")
@@ -96,38 +95,6 @@ def members(self):
                                    {id_param: str(self.uid)},
                                    ["project", "members"], ProjectMember)
 
-    def create_label(self, **kwargs):
-        """ Creates a label on a Legacy Editor project. Not supported in the new Editor.
-        Args:
-            **kwargs: Label attributes. At minimum, the label `DataRow`.
-        """
-        # Copy-paste of Client._create code so we can inject
-        # a connection to Type. Type objects are on their way to being
-        # deprecated and we don't want the Py client lib user to know
-        # about them. At the same time they're connected to a Label at
-        # label creation in a non-standard way (connect via name).
-        logger.warning(
-            "`create_label` is deprecated and is not compatible with the new editor."
-        )
-
-        Label = Entity.Label
-
-        kwargs[Label.project] = self
-        kwargs[Label.seconds_to_label] = kwargs.get(Label.seconds_to_label.name,
-                                                    0.0)
-        data = {
-            Label.attribute(attr) if isinstance(attr, str) else attr:
-            value.uid if isinstance(value, DbObject) else value
-            for attr, value in kwargs.items()
-        }
-
-        query_str, params = query.create(Label, data)
-        # Inject connection to Type
-        query_str = query_str.replace(
-            "data: {", "data: {type: {connect: {name: \"Any\"}} ")
-        res = self.client.execute(query_str, params)
-        return Label(self.client, res["createLabel"])
-
     def labels(self, datasets=None, order_by=None):
         """ Custom relationship expansion method to support limited filtering.
 
@@ -537,77 +504,6 @@ def extend_reservations(self, queue_type):
         res = self.client.execute(query_str, {id_param: self.uid})
         return res["extendReservations"]
 
-    def create_prediction_model(self, name, version):
-        """ Creates a PredictionModel connected to a Legacy Editor Project.
-
-        Args:
-            name (str): The new PredictionModel's name.
-            version (int): The new PredictionModel's version.
-        Returns:
-            A newly created PredictionModel.
-        """
-
-        logger.warning(
-            "`create_prediction_model` is deprecated and is not compatible with the new editor."
-        )
-
-        PM = Entity.PredictionModel
-        model = self.client._create(PM, {
-            PM.name.name: name,
-            PM.version.name: version
-        })
-        self.active_prediction_model.connect(model)
-        return model
-
-    def create_prediction(self, label, data_row, prediction_model=None):
-        """ Creates a Prediction within a Legacy Editor Project. Not supported
-        in the new Editor.
-
-        Args:
-            label (str): The `label` field of the new Prediction.
-            data_row (DataRow): The DataRow for which the Prediction is created.
-            prediction_model (PredictionModel or None): The PredictionModel
-                within which the new Prediction is created. If None then this
-                Project's active_prediction_model is used.
-        Return:
-            A newly created Prediction.
-        Raises:
-            labelbox.excepions.InvalidQueryError: if given `prediction_model`
-                is None and this Project's active_prediction_model is also
-                None.
-        """
-        logger.warning(
-            "`create_prediction` is deprecated and is not compatible with the new editor."
-        )
-
-        if prediction_model is None:
-            prediction_model = self.active_prediction_model()
-            if prediction_model is None:
-                raise InvalidQueryError(
-                    "Project '%s' has no active prediction model" % self.name)
-
-        label_param = "label"
-        model_param = "prediction_model_id"
-        project_param = "project_id"
-        data_row_param = "data_row_id"
-
-        Prediction = Entity.Prediction
-        query_str = """mutation CreatePredictionPyApi(
-            $%s: String!, $%s: ID!, $%s: ID!, $%s: ID!) {createPrediction(
-            data: {label: $%s, predictionModelId: $%s, projectId: $%s,
-                   dataRowId: $%s})
-            {%s}}""" % (label_param, model_param, project_param, data_row_param,
-                        label_param, model_param, project_param, data_row_param,
-                        query.results_query_part(Prediction))
-        params = {
-            label_param: label,
-            model_param: prediction_model.uid,
-            data_row_param: data_row.uid,
-            project_param: self.uid
-        }
-        res = self.client.execute(query_str, params)
-        return Prediction(self.client, res["createPrediction"])
-
     def enable_model_assisted_labeling(self, toggle: bool = True) -> bool:
         """ Turns model assisted labeling either on or off based on input
 

tests/integration/conftest.py

@@ -1,6 +1,7 @@
 from collections import namedtuple
 from enum import Enum
 from datetime import datetime
+
 from random import randint
 from string import ascii_letters
 from types import SimpleNamespace
@@ -11,6 +12,9 @@
 
 from labelbox.orm.query import results_query_part
 from labelbox.schema.invite import Invite
+from labelbox.orm.db_object import DbObject
+from labelbox.orm.model import Entity
+from labelbox.orm import query
 from labelbox.pagination import PaginatedCollection
 from labelbox.schema.user import User
 from labelbox import LabelingFrontend
@@ -143,6 +147,28 @@ def gen(field_type):
 @pytest.fixture
 def project(client, rand_gen):
     project = client.create_project(name=rand_gen(str))
+
+    def create_label(**kwargs):
+        """ Creates a label on a Legacy Editor project. Not supported in the new Editor.
+        Args:
+            **kwargs: Label attributes. At minimum, the label `DataRow`.
+        """
+        Label = Entity.Label
+        kwargs[Label.project] = project
+        kwargs[Label.seconds_to_label] = kwargs.get(Label.seconds_to_label.name,
+                                                    0.0)
+        data = {
+            Label.attribute(attr) if isinstance(attr, str) else attr:
+            value.uid if isinstance(value, DbObject) else value
+            for attr, value in kwargs.items()
+        }
+        query_str, params = query.create(Label, data)
+        query_str = query_str.replace(
+            "data: {", "data: {type: {connect: {name: \"Any\"}} ")
+        res = project.client.execute(query_str, params)
+        return Label(project.client, res["createLabel"])
+
+    project.create_label = create_label
     yield project
     project.delete()
 

tests/integration/test_label.py

@@ -55,8 +55,7 @@ def test_label_update(label_pack):
     assert label.label == "something else"
 
 
-def test_label_filter_order(client, rand_gen):
-    project = client.create_project(name=rand_gen(str))
+def test_label_filter_order(client, project, rand_gen):
     dataset_1 = client.create_dataset(name=rand_gen(str), projects=project)
     dataset_2 = client.create_dataset(name=rand_gen(str), projects=project)
     data_row_1 = dataset_1.create_data_row(row_data=IMG_URL)

tests/integration/test_predictions.py

@@ -8,23 +8,17 @@ def test_reviews(label_pack):
     project, _, _, label = label_pack
 
     assert set(label.reviews()) == set()
-    assert set(project.reviews()) == set()
 
     r1 = label.create_review(score=-1.0)
-    assert r1.project() == project
-    assert r1.label() == label
+    # They work on data that was created in the editor but not with project.create_label
+    #assert r1.project() == project
+    #assert r1.label() == label
     assert r1.score == -1.0
     assert set(label.reviews()) == {r1}
-    assert set(project.reviews()) == {r1}
 
     r2 = label.create_review(score=1.0)
 
     assert set(label.reviews()) == {r1, r2}
-    assert set(project.reviews()) == {r1, r2}
-
-    # Project.reviews supports filtering
-    assert set(project.reviews(where=Review.score > 0.0)) == {r2}
-    assert set(project.reviews(where=Review.score < 0.0)) == {r1}
 
     # Label.reviews doesn't support filtering
     with pytest.raises(InvalidQueryError) as exc_info:
@@ -35,7 +29,6 @@ def test_reviews(label_pack):
     r1.delete()
 
     assert set(label.reviews()) == {r2}
-    assert set(project.reviews()) == {r2}
 
 
 def test_review_metrics(label_pack):