automatic queries for cached relationships

Author: Matt Sokoloff

labelbox/client.py

@@ -76,8 +76,8 @@ def __init__(self,
             'X-User-Agent': f'python-sdk {SDK_VERSION}'
         }
 
-    @retry.Retry(predicate=retry.if_exception_type(
-        labelbox.exceptions.InternalServerError))
+    #@retry.Retry(predicate=retry.if_exception_type(
+    #    labelbox.exceptions.InternalServerError))
     def execute(self, query, params=None, timeout=30.0, experimental=False):
         """ Sends a request to the server for the execution of the
         given query.

labelbox/orm/db_object.py

@@ -43,9 +43,8 @@ def __init__(self, client, field_values):
         """
         self.client = client
         self._set_field_values(field_values)
-
         for relationship in self.relationships():
-            value = field_values.get(relationship.name)
+            value = field_values.get(utils.camel_case(relationship.name))
             if relationship.cache and value is None:
                 raise KeyError(
                     f"Expected field  values for {relationship.name}")
@@ -168,6 +167,7 @@ def _to_one(self):
         result = result and result.get(rel.graphql_name)
         if result is None:
             return None
+
         return rel.destination_type(self.source.client, result)
 
     def connect(self, other):

labelbox/orm/model.py

@@ -242,8 +242,43 @@ class EntityMeta(type):
 
     def __init__(cls, clsname, superclasses, attributedict):
         super().__init__(clsname, superclasses, attributedict)
+        cls.validate_cached_relationships()
         if clsname != "Entity":
             setattr(Entity, clsname, cls)
+            if not hasattr(Entity, 'entities'):
+                setattr(Entity, 'entities', [])
+            Entity.entities.append(cls)
+
+    def validate_cached_relationships(cls):
+        """
+        Graphql doesn't allow for infinite nesting in queries. 
+        This function checks that cached relationships result in valid queries.
+            - A cached object and not have its own cached relationships.
+        """
+
+        cached_rels = [r for r in cls.relationships() if r.cache]
+        print(cached_rels)
+        # Check if any cached classes have their own cached fields
+        for rel in cached_rels:
+            child_name = utils.title_case(rel.name)
+            if hasattr(Entity, child_name):
+                for sub_rel in getattr(Entity, child_name).relationships():
+                    if sub_rel.cache:
+                        raise TypeError(
+                            "Cannot cache a relationship to an Entity with its own cached relationship(s). "
+                            f"`{utils.snake_case(cls.__name__)}` caches `{rel.name}` which caches `{sub_rel}`"
+                        )
+
+        # If this cls has cached fields check if any existing object caches this cls.
+        if cached_rels:
+            for entity in Entity.entities:
+                attr = {rel.name: rel for rel in entity.relationships()
+                       }.get(utils.snake_case(cls.__name__))
+                if attr and attr.cache:
+                    raise TypeError(
+                        "Cannot cache a relationship to an Entity with its own cached relationship(s). "
+                        f"`{utils.snake_case(entity.__name__)}` caches `{utils.snake_case(cls.__name__)}` which caches `{cached_rels}`"
+                    )
 
 
 class Entity(metaclass=EntityMeta):

labelbox/orm/query.py

@@ -40,7 +40,13 @@ def results_query_part(entity):
     Args:
         entity (type): The entity which needs fetching.
     """
-    return " ".join(field.graphql_name for field in entity.fields())
+    fields = [field.graphql_name for field in entity.fields()]
+    for relationship in entity.relationships():
+        if relationship.cache:
+            fields.append(
+                Query(relationship.graphql_name,
+                      relationship.destination_type).format()[0])
+    return " ".join(fields)
 
 
 class Query:
@@ -292,9 +298,13 @@ def relationship(source, relationship, where, order_by):
     to_many = relationship.relationship_type == Relationship.Type.ToMany
     subquery = Query(relationship.graphql_name, relationship.destination_type,
                      where, to_many, order_by)
+
+
+
     query_where = type(source).uid == source.uid if isinstance(source, Entity) \
         else None
     query = Query(utils.camel_case(source.type_name()), subquery, query_where)
+
     return query.format_top("Get" + source.type_name() +
                             utils.title_case(relationship.graphql_name))
 

labelbox/schema/project.py

@@ -641,6 +641,7 @@ class LabelingParameterOverride(DbObject):
     """
     priority = Field.Int("priority")
     number_of_labels = Field.Int("number_of_labels")
+    data_row = Relationship.ToOne("DataRow", cache=True)
 
 
 LabelerPerformance = namedtuple(

labelbox/schema/webhook.py

@@ -112,7 +112,7 @@ def delete(self):
         """
         Deletes the webhook
         """
-        self.update(status=self.Status.INACTIVE)
+        self.update(status=self.Status.INACTIVE.value)
 
     def update(self, topics=None, url=None, status=None):
         """ Updates the Webhook.

tests/integration/test_labeling_parameter_overrides.py

@@ -26,6 +26,9 @@ def test_labeling_parameter_overrides(project, rand_gen):
     assert {o.number_of_labels for o in overrides} == {3, 2, 5}
     assert {o.priority for o in overrides} == {4, 3, 8}
 
+    for override in overrides:
+        assert isinstance(override.data_row(), DataRow)
+
     success = project.unset_labeling_parameter_overrides(
         [data[0][0], data[1][0]])
     assert success

tests/integration/test_webhook.py

@@ -38,3 +38,5 @@ def test_webhook_create_update(project, rand_gen):
         webhook.update(topics="invalid..")
     assert str(exc_info.value) == \
         "Topics must be List[Webhook.Topic]. Found `invalid..`"
+
+    webhook.delete()

tests/test_entity_meta.py

@@ -0,0 +1,34 @@
+import pytest
+
+from labelbox.orm.model import Relationship
+from labelbox.orm.db_object import DbObject
+
+
+def test_illegal_cache_cond1():
+
+    class TestEntityA(DbObject):
+        test_entity_b = Relationship.ToOne("TestEntityB", cache=True)
+
+    with pytest.raises(TypeError) as exc_info:
+
+        class TestEntityB(DbObject):
+            another_entity = Relationship.ToOne("AnotherEntity", cache=True)
+
+    assert str(exc_info.value) == \
+        "Cannot cache a relationship to an Entity with its own cached relationship(s)." \
+        " `test_entity_a` caches `test_entity_b` which caches `[<Relationship: 'another_entity'>]`"
+
+
+def test_illegal_cache_cond2():
+
+    class TestEntityD(DbObject):
+        another_entity = Relationship.ToOne("AnotherEntity", cache=True)
+
+    with pytest.raises(TypeError) as exc_info:
+
+        class TestEntityC(DbObject):
+            test_entity_d = Relationship.ToOne("TestEntityD", cache=True)
+
+    assert str(exc_info.value) == \
+        "Cannot cache a relationship to an Entity with its own cached relationship(s)." \
+        " `test_entity_c` caches `test_entity_d` which caches `another_entity`"