match_shotgrid_hierarchy_in_ayon

def match_shotgrid_hierarchy_in_ayon(
    entity_hub: ayon_api.entity_hub.EntityHub,
    sg_project: Dict,
    sg_session: shotgun_api3.Shotgun,
    sg_enabled_entities: List[str],
    project_code_field: str,
    custom_attribs_map: Dict[str, str],
    addon_settings: Dict[str, str]
):
    """Replicate a Shotgrid project into AYON.

    This function creates a "deck" which we keep increasing while traversing
    the Shotgrid project and finding new children, this is more efficient than
    creating a dictionary with the while Shotgrid project structure since we
    `popleft` the elements when processing them.

    Args:
        entity_hub (ayon_api.entity_hub.EntityHub): The AYON EntityHub.
        sg_project (dict): The Shotgrid project.
        sg_project (shotgun_api3.Shotgun): The Shotgrid session.
        project_code_field (str): The Shotgrid project code field.
    """
    log.info("Getting Shotgrid entities.")
    sg_ay_dicts, sg_ay_dicts_parents = get_sg_entities(
        sg_session,
        sg_project,
        sg_enabled_entities,
        project_code_field,
        custom_attribs_map,
        addon_settings=addon_settings,
    )

    sg_ay_dicts_deck = collections.deque()

    # Append the project's direct children.
    for sg_ay_dict_child_id in sg_ay_dicts_parents[sg_project["id"]]:
        sg_ay_dicts_deck.append(
            (entity_hub.project_entity, sg_ay_dict_child_id)
        )

    sg_project_sync_status = "Synced"
    processed_ids = set()

    while sg_ay_dicts_deck:
        (ay_parent_entity, sg_ay_dict_child_id) = sg_ay_dicts_deck.popleft()
        sg_ay_dict = sg_ay_dicts[sg_ay_dict_child_id]
        sg_entity_id = sg_ay_dict["attribs"][SHOTGRID_ID_ATTRIB]
        if sg_ay_dict_child_id in processed_ids:
            msg = (
                f"Entity {sg_entity_id} already processed, skipping..."
                f"Sg Ay Dict: {sg_ay_dict} - "
                f"Ay Parent Entity: {ay_parent_entity}"
            )
            log.warning(msg)
            continue

        processed_ids.add(sg_ay_dict_child_id)

        log.debug(f"Deck size: {len(sg_ay_dicts_deck)}")

        if sg_ay_dict["type"].lower() == "comment":
            handle_comment(sg_ay_dict, sg_session, entity_hub)
            continue

        if sg_ay_dict["type"].lower() == "entity_list":
            ayon_list_id = sg_ay_dict["data"].get(CUST_FIELD_CODE_ID)
            ay_list_exists = ayon_list_id and any(
                lst["id"] == ayon_list_id
                for lst in ayon_api.get_entity_lists(
                    entity_hub.project_name, fields=["id"]
                )
            )
            sync_ay_entity_list_from_sg_event(
                {
                    "type": "attribute_change" if ay_list_exists else "new_entity",
                    "entity_id": sg_entity_id,
                    "attribute_name": "versions",
                },
                sg_project,
                sg_session,
            )
            continue

        shotgrid_type = sg_ay_dict["attribs"].get(SHOTGRID_TYPE_ATTRIB)
        ay_id = sg_ay_dict["data"].get(CUST_FIELD_CODE_ID)

        ay_entity = None
        sg_entity_sync_status = "Synced"

        if ay_id:
            ay_entity = entity_hub.get_or_query_entity_by_id(
                ay_id, [sg_ay_dict["type"]])

        if shotgrid_type == "Version" and not ay_entity:
            log.warning(
                "Version creation from Flow is not implemented because "
                "Flow entity is much less strict than AYON product with reviewable "
                "(e.g. product name and integer are not mandatory in Flow)."
            )
            continue

        # If we haven't found the ay_entity by its id, check by its name
        # to avoid creating duplicates and erroring out
        if ay_entity is None:

            sg_parent_field = get_sg_entity_parent_field(
                sg_session,
                sg_project,
                shotgrid_type,
                sg_enabled_entities,
            )
            asset_category_parent = sg_parent_field == "sg_asset_type"

            if (
                shotgrid_type == "Asset"
                and asset_category_parent
            ):
                # Parenting to AssetCategory is enabled.
                # reparenting under already set parent (asset category folder).
                log.debug("Reparenting %r under %r.", sg_ay_dict, ay_parent_entity)

            elif shotgrid_type in ("Sequence", "Episode", "Shot", "AssetCategory", "Asset"):
                ay_parent_entity = get_reparenting_from_settings(
                    entity_hub,
                    sg_ay_dict,
                    addon_settings
                ) or ay_parent_entity

            name = slugify_string(sg_ay_dict["name"])
            for child in ay_parent_entity.children:
                if child.name.lower() == name.lower():
                    ay_entity = child
                    break

        # If we couldn't find it we create it.
        if ay_entity is None:
            ay_entity = create_new_ayon_entity(
                sg_session,
                entity_hub,
                ay_parent_entity,
                sg_ay_dict
            )
        else:

            if not _update_ay_entity(
                ay_entity,
                custom_attribs_map,
                entity_hub,
                sg_ay_dict,
                sg_entity_id,
            ):
                sg_entity_sync_status = "Failed"
                sg_project_sync_status = "Failed"


        # skip if no ay_entity is found
        # perhaps due Task with project entity as parent
        if not ay_entity:
            log.error(f"Entity {sg_ay_dict} not found in AYON.")
            continue

        # pass AYON id to SG
        _update_sg_entity(
            ay_entity,
            sg_ay_dict,
            sg_ay_dicts,
            sg_entity_id,
            sg_entity_sync_status,
            sg_session
        )

        # If the entity has children, add it to the deck
        for sg_child_id in sg_ay_dicts_parents.get(sg_ay_dict_child_id, []):
            sg_ay_dicts_deck.append((ay_entity, sg_child_id))

    _sync_project_attributes(entity_hub, custom_attribs_map, sg_project)

    try:
        entity_hub.commit_changes()
    except Exception:
        log.error(
            "Unable to commit all entities to AYON!", exc_info=True)

    log.info(
        "Processed entities successfully!. "
        f"Amount of entities: {len(processed_ids)}"
    )

    # Update Shotgrid project with AYON ID and sync status
    sg_session.update(
        "Project",
        sg_project["id"],
        {
            CUST_FIELD_CODE_ID: entity_hub.project_entity.id,
            CUST_FIELD_CODE_SYNC: sg_project_sync_status
        }
    )