Dynamic tree of Assets in workfiles and loader

Pipeline Integrations
, ,
1

Hello,

Does anyone know if it’s possible to configure the entities setting for tk-multi-workfiles2 and tk-multi-loader2 so that the heirarchy for Assets pays attention to the “parent assets” field?

The fact that field is multi entity I don’t think introduces any ambiguities.

e.g.
I have two Assets without parents: Tree and FruitBowl

And I have an Asset: Apple with “parent assets” set to both of those.

I then want to work on Apple, and I see it appear under both Tree and FruitBowl in the tree.

(and then same concept with the Loader)

2

I recall trying this out and was able to get this working, but the caveat here is that I may have used a single entity field, but not 100% on this.

What I am sure about though, was displaying multiple levels of hierarchy with children of children was not possible, as only direct Parent ↔ Child pairs would be displayed in the navigation.

3

Thanks for the reply.

Yes, my gut is saying that making customisations to tk-multi-workfiles2 might be in order.

Though, I’ve wondered about how a fully dynamic number of levels might not be completely necessary.

e.g. if in practice there’s only ever a maximum of 3 levels then we could just configure it to support 3 levels.

I’ll have a play using a new single parent field.

Cheers.

4

I’m not sure if it works with Multi-Enity Parents.
If it doesn’t, it may be a solution to create a Single Entity Link field and make an automation that copies the value (if your workflow doesn’t use multiple “Parent Assets”).

Also, if your workflow shouldn’t allow multiple Parent Assets per Asset then you could also just create a Single Entity field called Parent Asset and use that.
That will definitely work.

5

btw, I’ve found a way to use the existing parents field to have a hierarchy with a hard-coded number of levels with only one tiny tweak to the tk-multi-workfiles 2 code.

This is the tweak to file_form_base.py

            # Note that this currently doesn't work for non-project entities!
            # (except AssetAssetConnection, which I've just hacked in - JH)
            if entity_type == "Project":
                # special case if the entity type is 'Project' - this will show only
                # the current project in the tree!
                resolved_filters.append(["id", "is", app.context.project["id"]])
            elif entity_type == "AssetAssetConnection":
                resolved_filters.append(["asset.Asset.project", "is", app.context.project])
            else:
                # filter entities on the current project:
                resolved_filters.append(["project", "is", app.context.project])

Then to configure tk-multi-workfiles2 in the env files:

  - caption: Assets (Top)
    entity_type: Asset
    filters: 
      - [parents, is, null]
    hierarchy:
      - sg_asset_type
      - code
    sub_hierarchy:
      entity_type: Task
      link_field: entity
      hierarchy: [step]
  - caption: Assets (Children)
    entity_type: AssetAssetConnection
    filters: 
      - [parent, is_not, null]
      - [parent.Asset.parents, is, null]
    hierarchy: 
      - parent.Asset.sg_asset_type
      - parent.Asset.code
      - asset.Asset.sg_asset_type
      - asset.Asset.code
    sub_hierarchy:
      entity_type: Task
      link_field: asset
      hierarchy: [step]

One tab shows parentless Assets.

The second shows Assets with one level of ancestry.

so can add as many tabs as needed.

2 Likes
6

Nice! I like how you went for the connection entity. I recall if you configure simply the Asset entity then you might have some Assets with no parent, but they should fall under a grouping item of No Parent or similar.

7

Btw, I’ve realised tk-multi-workfiles2 needs a couple of extra small tweaks:

These in deferred_model.py:

__init__:

...
        # A bool used to track if a data_refreshed signal emission has been posted
        # in the event queue, to ensure there is only one at any given time.
        self._pending_delayed_data_refreshed = False
        if deferred_query and deferred_query["linked_to_field"]:
            fields += [deferred_query["linked_to_field"]]
        super().__init__(entity_type, filters, hierarchy, fields, *args, **kwargs)
...

_run_deferred_query_for_entity:

...
        # Retrieve the deferred query filters and amend them to return results
        # linked to the given Entity.
        filters = deferred_query["filters"][:]
        link_field_name = deferred_query["link_field"]
        linked_to_field_name = deferred_query["linked_to_field"]
        linked_to_entity = sg_entity[linked_to_field_name] if linked_to_field_name else sg_entity
        filters.append([link_field_name, "is", linked_to_entity])
        # Append extra filters, (step filtering).
        if self._extra_filter:
            filters.append(self._extra_filter)
...

and this in _build_entity_models in file_form_base.py:

...
                # A list of fields to retrieve in the sub query.
                sub_hierarchy = sub_query.get("hierarchy") or []
                # The PTR field allowing linking the sub query Entity to its
                # parent Entity.
                sub_link_field = sub_query.get("link_field", "entity")
                sub_linked_to_field = sub_query.get("linked_to_field")
                deferred_query = {
                    "entity_type": sub_entity_type,
                    "filters": sub_filters,
                    "hierarchy": sub_hierarchy,
                    "link_field": sub_link_field,
                    "linked_to_field": sub_linked_to_field,
                }
            # Check the hierarchy to use for the model for this entity:
            if not hierarchy:
...

And now my configuration of the app is:

...
  - caption: Assets
    entity_type: Asset
    filters: 
      - [parents, is, null]
    hierarchy:
      - sg_asset_type
      - code
    sub_hierarchy: &tk-multi-workfiles2_all_engines_entities_Asset_sub_hierarchy
      entity_type: Task
      link_field: entity
      hierarchy: [step]
  - caption: Subassets
    entity_type: AssetAssetConnection
    filters: 
      - [parent, is_not, null]
    hierarchy: 
      - parent.Asset.code
      - asset.Asset.sg_asset_type
      - asset.Asset.code
    sub_hierarchy:
      <<: *tk-multi-workfiles2_all_engines_entities_Asset_sub_hierarchy
      entity_type: Task
      link_field: entity
      linked_to_field: asset
...

Because I’ve realised that because of the ambiguity of the link table, it’s only possible to have two tiers of of Assets in the tree.

I can’t do a third or beyond, because hierarchy would need to navigate beyond the parent Asset into another AssetAssetConnection and at that point it becomes ambiguous because it’s one-to-many.

(but as previously established, this would all be very straightforward by adding a field to Asset which links to a single parent Asset)