Merge pull request #141 from Labelbox/ms/cached-relationships

Ms/cached relationships

Author: msokoloff1

CHANGELOG.md

@@ -9,7 +9,7 @@
     * Delete users from organization
     * Example notebook added under examples/basics
 * Issues and comments export
-    * Bulk export issues and comments. See `Project.export_labels`
+    * Bulk export issues and comments. See `Project.export_issues`
 * MAL on Tiled Imagery
     * Example notebook added under examples/model_assisted_labeling
     * `Dataset.create_data_rows` now allows users to upload tms imagery

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

@@ -1,5 +1,5 @@
 from enum import Enum, auto
-from typing import Union
+from typing import Dict, List, Union
 
 from labelbox import utils
 from labelbox.exceptions import InvalidAttributeError
@@ -239,11 +239,74 @@ class EntityMeta(type):
     of the Entity class object so they can be referenced for example like:
         Entity.Project.
     """
+    # Maps Entity name to Relationships for all currently defined Entities
+    relationship_mappings: Dict[str, List[Relationship]] = {}
 
     def __init__(cls, clsname, superclasses, attributedict):
         super().__init__(clsname, superclasses, attributedict)
+        cls.validate_cached_relationships()
         if clsname != "Entity":
             setattr(Entity, clsname, cls)
+            EntityMeta.relationship_mappings[utils.snake_case(
+                cls.__name__)] = cls.relationships()
+
+    @staticmethod
+    def raise_for_nested_cache(first: str, middle: str, last: List[str]):
+        raise TypeError(
+            "Cannot cache a relationship to an Entity with its own cached relationship(s). "
+            f"`{first}` caches `{middle}` which caches `{last}`")
+
+    @staticmethod
+    def cached_entities(entity_name: str):
+        """
+        Return all cached entites for a given Entity name
+        """
+        cached_entities = EntityMeta.relationship_mappings.get(entity_name, [])
+        return {
+            entity.name: entity for entity in cached_entities if entity.cache
+        }
+
+    def validate_cached_relationships(cls):
+        """
+        Graphql doesn't allow for infinite nesting in queries. 
+        This function checks that cached relationships result in valid queries.
+            * It does this by making sure that a cached relationship do not
+              reference any entity with its own cached relationships.
+
+        This check is performed by looking to see if this entity caches 
+        any entities that have their own cached fields. If this entity 
+        that we are checking has any cached fields then we also check 
+        all currently defined entities to see if they cache this entity.
+
+        A two way check is necessary because checks are performed as classes are being defined.
+        As opposed to after all objects have been created.
+        """
+        # All cached relationships
+        cached_rels = [r for r in cls.relationships() if r.cache]
+
+        # Check if any cached entities have their own cached fields
+        for rel in cached_rels:
+            nested = cls.cached_entities(rel.name)
+            if nested:
+                cls.raise_for_nested_cache(utils.snake_case(cls.__name__),
+                                           rel.name, list(nested.keys()))
+
+        # If the current Entity (cls) has any cached relationships (cached_rels)
+        #  then no other defined Entity (entities in EntityMeta.relationship_mappings) can cache this Entity.
+        if cached_rels:
+            # For all currently defined Entities
+            for entity_name in EntityMeta.relationship_mappings:
+                # Get all cached ToOne relationships
+                rels = cls.cached_entities(entity_name)
+                # Check if the current Entity (cls) is referenced by the Entity with `entity_name`
+                rel = rels.get(utils.snake_case(cls.__name__))
+                # If rel exists and is cached then raise an exception
+                # This means `entity_name` caches `cls` which cached items in `cached_rels`
+                if rel and rel.cache:
+                    cls.raise_for_nested_cache(
+                        utils.snake_case(entity_name),
+                        utils.snake_case(cls.__name__),
+                        [entity.name for entity in cached_rels])
 
 
 class Entity(metaclass=EntityMeta):

labelbox/orm/query.py

@@ -40,7 +40,16 @@ def results_query_part(entity):
     Args:
         entity (type): The entity which needs fetching.
     """
-    return " ".join(field.graphql_name for field in entity.fields())
+    # Query for fields
+    fields = [field.graphql_name for field in entity.fields()]
+
+    # Query for cached relationships
+    fields.extend([
+        Query(rel.graphql_name, rel.destination_type).format()[0]
+        for rel in entity.relationships()
+        if rel.cache
+    ])
+    return " ".join(fields)
 
 
 class Query:

labelbox/schema/project.py

@@ -676,6 +676,8 @@ class LabelingParameterOverride(DbObject):
     priority = Field.Int("priority")
     number_of_labels = Field.Int("number_of_labels")
 
+    data_row = Relationship.ToOne("DataRow", cache=True)
+
 
 LabelerPerformance = namedtuple(
     "LabelerPerformance", "user count seconds_per_label, total_time_labeling "

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,32 @@
+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 "`test_entity_a` caches `test_entity_b` which caches `['another_entity']`" in str(
+        exc_info.value)
+
+
+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 "`test_entity_c` caches `test_entity_d` which caches `['another_entity']`" in str(
+        exc_info.value)