[tk-multi-publish2] Where do I add resolving logic for a custom key?

Ricardo_Musch · December 19, 2019, 4:33pm

If I want to resolve a custom key in our templates.yml when I publish from Nuke, where would I add the logic to resolve that key?

philip.scadding · December 19, 2019, 4:55pm

It depends what exactly you are publishing from Nuke, but if you are talking about the Nuke script, you would need to take over the nuke_publish_script.py hook. However this hook by default doesn’t actually handle the path generation, it instead relies on the base hook to do this:

github.com

shotgunsoftware/tk-nuke/blob/v0.12.5/hooks/tk-multi-publish2/basic/nuke_publish_script.py#L321


    _save_session(path)


    # update the item with the saved session path
    item.properties["path"] = path


    # add dependencies for the base class to register when publishing
    item.properties["publish_dependencies"] = \
        _nuke_find_additional_script_dependencies()


    # let the base class register the publish
    super(NukeSessionPublishPlugin, self).publish(settings, item)


def finalize(self, settings, item):
    """
    Execute the finalization pass. This pass executes once all the publish
    tasks have completed, and can for example be used to version up files.


    :param settings: Dictionary of Settings. The keys are strings, matching
        the keys returned in the settings property. The values are `Setting`
        instances.
    :param item: Item to process

The base publish hook then runs this:

github.com

shotgunsoftware/tk-multi-publish2/blob/v2.4.1/hooks/publish_file.py#L378




# ---- determine the information required to publish


# We allow the information to be pre-populated by the collector or a
# base class plugin. They may have more information than is available
# here such as custom type or template settings.


publish_type = self.get_publish_type(settings, item)
publish_name = self.get_publish_name(settings, item)
publish_version = self.get_publish_version(settings, item)
publish_path = self.get_publish_path(settings, item)
publish_dependencies_paths = self.get_publish_dependencies(settings, item)
publish_user = self.get_publish_user(settings, item)
publish_fields = self.get_publish_fields(settings, item)
# catch-all for any extra kwargs that should be passed to register_publish.
publish_kwargs = self.get_publish_kwargs(settings, item)


# if the parent item has publish data, get it id to include it in the list of
# dependencies
publish_dependencies_ids = []
if "sg_publish_data" in item.parent.properties:

which calls this method to generate the path:

github.com

shotgunsoftware/tk-multi-publish2/blob/v2.4.1/hooks/publish_file.py#L540-L595


def get_publish_path(self, settings, item):
    """
    Get a publish path for the supplied settings and item.


    :param settings: This plugin instance's configured settings
    :param item: The item to determine the publish path for


    :return: A string representing the output path to supply when
        registering a publish for the supplied item


    Extracts the publish path via the configured work and publish templates
    if possible.
    """


    # publish type explicitly set or defined on the item
    publish_path = item.get_property("publish_path")
    if publish_path:
        return publish_path


    # fall back to template/path logic

This file has been truncated. show original

So in short you should take over the nuke_publish_script.py hook or add a new hook to the end of the dependancy chain, and override the get_publish_path method, so you can resolve the custom fields/keys.

Ricardo_Musch · December 19, 2019, 5:02pm

I kind of want to make it possible to publish read nodes in the Publisher (instead of Shotgun Writenodes).
The filenames may not necesarily match exactly to the templates so therefore I would like the work_file name to not matter and the publish filename to have a path defined with custom keys like {filename} which would be the basename (without extension).

The publisher would then, upon publish move the files to the publish path and rename as necesary.

philip.scadding · December 19, 2019, 5:25pm

OK, you would need to modify the collector so that it collected your read node paths as items. I’d use the write node collection methods as an example.

The creating playable media/version is handled via the submit_for_review plugin. I think this would largely work without modification, but you would need to modify this line to ensure you are passing through the resolved fields to the review submission app (which handles the generation of the playable media.)

Ricardo_Musch · December 19, 2019, 5:32pm

I think I’m just going to copy the publish_file.py and hook it and recode what is needed.
We also do our custom playable media creation on teh farm so will adjust those as necesary.

I previously made my own Nuke Publisher from scratch since I wasn’t yet very comfortable adjusting the Publish2 but I think I’m getting teh hang of it now so trying to revert to that (I don’t want to keep maintaining all these loose apps )

Thanks, I’ll report back!

philip.scadding · December 19, 2019, 5:38pm

No worries let me know if I can be of any more help!

Ricardo_Musch · December 23, 2019, 2:30am

Happy Monday (morning)!

So I’ve gotten further, finaly understanding more of the relationships of these files and plugins.

Question 1)
Is there an easy way to create a link field on my items which can be used to select an existing playlist on Shotgun? (Preferably with filtering, so it could just be a dropdown populated by a sg_find call)

Reason: Our Nuke artists are supposed to put their comps into a daillies playlist.
In my custom Nuke Publisher it would search for an open playlist with certain filter parameters (a status) and display None, and the found playlist(s) to the user.

Question 2)
Can I disable Notes on the individual items?
And how can I then acces the Notes on the parent item to add these to my publish?

philip.scadding · January 2, 2020, 8:54am

Hi Ricardo, Happy new year!

You can create a custom UI on the publish plugin, but not the item itself. A drop down of playlists should be fairly straight forward once you understand how to had a custom UI which I provide an example of here.

You can’t disable the notes on items, but you could choose to ignore the entered description in the publish plugin. You should be able to access the parent item via parent, so it would be something like item.parent.description I think.

Ricardo_Musch · January 2, 2020, 3:21pm

Hapy New Year!

Thanks!

Then one more Q:

Just as the collector.py can be seen as the init for the Publisher (i.e. I could run code in that before the dialog shows), is there a place I can place code that needs to run after all the publish logic is completed for all items?

philip.scadding · January 2, 2020, 3:31pm

The post phase hook sounds like it’s what you’re after.

github.com

shotgunsoftware/tk-multi-publish2/blob/v2.4.1/hooks/post_phase.py

# Copyright (c) 2018 Shotgun Software Inc.
#
# CONFIDENTIAL AND PROPRIETARY
#
# This work is provided "AS IS" and subject to the Shotgun Pipeline Toolkit
# Source Code License included in this distribution package. See LICENSE.
# By accessing, using, copying or modifying this work you indicate your
# agreement to the Shotgun Pipeline Toolkit Source Code License. All rights
# not expressly granted therein are reserved by Shotgun Software Inc.

import sgtk

HookBaseClass = sgtk.get_hook_baseclass()


class PostPhaseHook(HookBaseClass):
    """
    This hook defines methods that are executed after each phase of a publish:
    validation, publish, and finalization. Each method receives the publish
    tree instance being used by the publisher, giving full control to further

This file has been truncated. show original

Ricardo_Musch · January 6, 2020, 4:30pm

Strangely, that post_phase hook run’s before the Publisher window opens

Ricardo_Musch · January 6, 2020, 4:32pm

This is my publish yaml:

shot step

settings.tk-multi-publish2.nuke.shot_step:
collector: “{self}/collector.py:{config}/tk-multi-publish2/tk-nuke/basic/collector.py”
collector_settings:
Work Template: nuke_shot_work
publish_plugins:
- name: Publish to Shotgun
hook: “{self}/publish_file.py”
settings: {}
- name: Upload for review
hook: “{self}/upload_version.py”
settings: {}
- name: Begin file versioning
hook: “{engine}/tk-multi-publish2/basic/nuke_start_version_control.py”
settings: {}
- name: Publish to Shotgun
hook: “{self}/publish_file.py:{engine}/tk-multi-publish2/basic/nuke_publish_script.py”
settings:
Publish Template: nuke_shot_publish
- name: Submit for Review
hook: “{engine}/tk-multi-publish2/basic/submit_for_review.py”
settings: {}
- name: Publish and Generate Shotgun Version
hook: “{self}/publish_file.py:{config}/tk-multi-publish2/tk-nuke/basic/publish_version.py”
settings:
Shot Frames Publish Template: custom_shot_frames_output_publish
Shot Movie Publish Template: custom_shot_mov_output_publish
Shot Raw Movie Publish Template: custom_shot_raw_mov_output_publish
- name: Render Playable Media
hook: “{config}/tk-multi-publish2/render_playable_media.py”
settings: {}
post_phase: “{self}/post_phase.py:{config}/tk-multi-publish2/post_phase.py”
# - name: Update Flame Clip
# hook: “{engine}/tk-multi-publish2/basic/nuke_update_flame_clip.py”
# settings:
# Flame Clip Template: flame_shot_clip
help_url: *help_url
location: “@apps.tk-multi-publish2.location”

Ricardo_Musch · January 6, 2020, 4:40pm

No worries, found the info

https://developer.shotgunsoftware.com/tk-multi-publish2/customizing.html#post-phase-hook

philip.scadding · January 13, 2020, 12:03pm

7 posts were split to a new topic: Setting an item’s context in Publish2

philip.scadding · January 13, 2020, 12:05pm

A post was merged into an existing topic: Setting an item’s context in Publish2