respect container's project name

Author: iLLiCiTiT

client/ayon_core/pipeline/load/utils.py

@@ -1111,22 +1111,15 @@ def filter_containers(containers, project_name):
     'invalid' are invalid containers (invalid content) and 'not_found' has
     some missing entity in database.
 
-    Todos:
-        Respect 'project_name' on containers if is available.
-
     Args:
         containers (Iterable[dict]): List of containers referenced into scene.
-        project_name (str): Name of project in which context shoud look for
-            versions.
+        project_name (str): Current project name.
 
     Returns:
         ContainersFilterResult: Named tuple with 'latest', 'outdated',
             'invalid' and 'not_found' containers.
 
     """
-    # Make sure containers is list that won't change
-    containers = list(containers)
-
     outdated_containers = []
     uptodate_containers = []
     not_found_containers = []
@@ -1138,98 +1131,102 @@ def filter_containers(containers, project_name):
         invalid_containers
     )
     # Query representation docs to get it's version ids
-    repre_ids = {
-        container["representation"]
-        for container in containers
-        if _is_valid_representation_id(container["representation"])
-    }
-    if not repre_ids:
-        if containers:
-            invalid_containers.extend(containers)
-        return output
-
-    repre_entities = ayon_api.get_representations(
-        project_name,
-        representation_ids=repre_ids,
-        fields={"id", "versionId"}
-    )
-    # Store representations by stringified representation id
-    repre_entities_by_id = {}
-    repre_entities_by_version_id = collections.defaultdict(list)
-    for repre_entity in repre_entities:
-        repre_id = repre_entity["id"]
-        version_id = repre_entity["versionId"]
-        repre_entities_by_id[repre_id] = repre_entity
-        repre_entities_by_version_id[version_id].append(repre_entity)
-
-    # Query version docs to get it's product ids
-    # - also query hero version to be able identify if representation
-    #   belongs to existing version
-    version_entities = ayon_api.get_versions(
-        project_name,
-        version_ids=repre_entities_by_version_id.keys(),
-        hero=True,
-        fields={"id", "productId", "version"}
-    )
-    versions_by_id = {}
-    versions_by_product_id = collections.defaultdict(list)
-    hero_version_ids = set()
-    for version_entity in version_entities:
-        version_id = version_entity["id"]
-        # Store versions by their ids
-        versions_by_id[version_id] = version_entity
-        # There's no need to query products for hero versions
-        #   - they are considered as latest?
-        if version_entity["version"] < 0:
-            hero_version_ids.add(version_id)
+    containers_by_project_name = collections.defaultdict(list)
+    for container in containers:
+        if not _is_valid_representation_id(container["representation"]):
+            invalid_containers.append(container)
             continue
-        product_id = version_entity["productId"]
-        versions_by_product_id[product_id].append(version_entity)
+        container_project = container.get("project_name")
+        if not container_project:
+            container_project = project_name
+        containers_by_project_name[container_project].append(container)
 
-    last_versions = ayon_api.get_last_versions(
-        project_name,
-        versions_by_product_id.keys(),
-        fields={"id"}
-    )
-    # Figure out which versions are outdated
-    outdated_version_ids = set()
-    for product_id, last_version_entity in last_versions.items():
-        for version_entity in versions_by_product_id[product_id]:
+    if not containers_by_project_name:
+        return output
+
+    for project_name, p_containers in containers_by_project_name.items():
+        repre_ids = {
+            container["representaiton"]
+            for container in p_containers
+        }
+        repre_entities = ayon_api.get_representations(
+            project_name,
+            representation_ids=repre_ids,
+            fields={"id", "versionId"}
+        )
+        version_ids = set()
+        repre_entities_by_id = {}
+        for repre_entity in repre_entities:
+            repre_id = repre_entity["id"]
+            version_id = repre_entity["versionId"]
+            version_ids.add(version_id)
+            repre_entities_by_id[repre_id] = repre_entity
+
+        # Query version docs to get it's product ids
+        # - also query hero version to be able identify if representation
+        #   belongs to existing version
+        version_entities = ayon_api.get_versions(
+            project_name,
+            version_ids=version_ids,
+            hero=True,
+            fields={"id", "productId", "version"}
+        )
+        versions_by_id = {}
+        versions_by_product_id = collections.defaultdict(list)
+        hero_version_ids = set()
+        for version_entity in version_entities:
             version_id = version_entity["id"]
-            if version_id in hero_version_ids:
+            # Store versions by their ids
+            versions_by_id[version_id] = version_entity
+            # There's no need to query products for hero versions
+            #   - they are considered as latest?
+            if version_entity["version"] < 0:
+                hero_version_ids.add(version_id)
                 continue
-            if version_id != last_version_entity["id"]:
-                outdated_version_ids.add(version_id)
+            product_id = version_entity["productId"]
+            versions_by_product_id[product_id].append(version_entity)
 
-    # Based on all collected data figure out which containers are outdated
-    #   - log out if there are missing representation or version documents
-    for container in containers:
-        container_name = container["objectName"]
-        repre_id = container["representation"]
-        if not _is_valid_representation_id(repre_id):
-            invalid_containers.append(container)
-            continue
+        last_versions = ayon_api.get_last_versions(
+            project_name,
+            versions_by_product_id.keys(),
+            fields={"id"}
+        )
 
-        repre_entity = repre_entities_by_id.get(repre_id)
-        if not repre_entity:
-            log.debug(
-                f"Container '{container_name}' has an invalid representation."
-                " It is missing in the database."
-            )
-            not_found_containers.append(container)
-            continue
+        # Figure out which versions are outdated
+        outdated_version_ids = set()
+        for product_id, last_version_entity in last_versions.items():
+            for version_entity in versions_by_product_id[product_id]:
+                version_id = version_entity["id"]
+                if version_id in hero_version_ids:
+                    continue
+                if version_id != last_version_entity["id"]:
+                    outdated_version_ids.add(version_id)
+
+        # Based on all collected data figure out which containers are outdated
+        #   - log out if there are missing representation or version documents
+        for container in p_containers:
+            container_name = container["objectName"]
+            repre_id = container["representation"]
+            repre_entity = repre_entities_by_id.get(repre_id)
+            if not repre_entity:
+                log.debug(
+                    f"Container '{container_name}' has an invalid representation."
+                    " It is missing in the database."
+                )
+                not_found_containers.append(container)
+                continue
 
-        version_id = repre_entity["versionId"]
-        if version_id not in versions_by_id:
-            log.debug(
-                f"Representation on container '{container_name}' has an"
-                " invalid version. It is missing in the database."
-            )
-            not_found_containers.append(container)
+            version_id = repre_entity["versionId"]
+            if version_id not in versions_by_id:
+                log.debug(
+                    f"Representation on container '{container_name}' has an"
+                    " invalid version. It is missing in the database."
+                )
+                not_found_containers.append(container)
 
-        elif version_id in outdated_version_ids:
-            outdated_containers.append(container)
-        else:
-            uptodate_containers.append(container)
+            elif version_id in outdated_version_ids:
+                outdated_containers.append(container)
+            else:
+                uptodate_containers.append(container)
 
     return output