recommended changes

Author: Matt Sokoloff

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/model.py

@@ -1,5 +1,5 @@
 from enum import Enum, auto
-from typing import Dict, Union
+from typing import Dict, List, Union
 
 from labelbox import utils
 from labelbox.exceptions import InvalidAttributeError
@@ -239,22 +239,31 @@ class EntityMeta(type):
     of the Entity class object so they can be referenced for example like:
         Entity.Project.
     """
-    mappings: Dict[str, "Entity"] = {}
+    # 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.mappings[utils.snake_case(
+            EntityMeta.relationship_mappings[utils.snake_case(
                 cls.__name__)] = cls.relationships()
 
     @staticmethod
-    def raise_for_nested_cache(first: str, middle: str, last: str):
+    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. 
@@ -270,23 +279,28 @@ def validate_cached_relationships(cls):
         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:
-            cached_entities = EntityMeta.mappings.get(rel.name, [])
-            nested = [entity.name for entity in cached_entities if entity.cache]
+            nested = cls.cached_entities(rel.name)
             if nested:
                 cls.raise_for_nested_cache(utils.snake_case(cls.__name__),
-                                           rel.name, nested)
+                                           rel.name, list(nested.keys()))
 
-        # If this entity caches any other entity
-        # then check if any entity caches this entity
+        # 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 entity_name, entity_relationships in EntityMeta.mappings.items(
-            ):
-                attr = {rel.name: rel for rel in entity_relationships
-                       }.get(utils.snake_case(cls.__name__))
-                if attr and attr.cache:
+            # 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__),