0

tk-multi-publish questions

Hello 

We are in the Client review Beta program and therefore we are making some adjustment to our Pipeline, in order to use LUT's.

The situation:

We want to be able to choose what kind of quicktime gets generated from within Nuke. For example, one for normal sRGB and one for Alexa footage. So in the Publish window we want to have a choice what kind of Quicktime gets sent to screening room.

I can easily make more choices in the Publish window, but to be able to generate a different quicktime using tk-review-submission, we need to make a different version of the app. As far as I know.

So now we need to have 2 Publishers in the Nuke Menu. One for normal sRGB and one for Alexa.
But we don't want 2 Publishers, we would like to have the choices in the Publish window. But there in cannot specify what kind of app the

The steps:

  1. So now I duplicated the app and renamed that to tk-multi-review-submission-alexa. I modified the burnin-nk, so it places a Vectorfield Node with the LUT on the end of the script. So now we have an Alexa LUT burned into the footage.
  2. I duplicated the standard secondary_publish_tk-nuke hook from the Multi Publish app and modified it to point to the tk-multi-review-submission-alexa app. I use this hook as an override in the templates.yml.
  3. In the shot_step.yml I created a second publisher in the Nuke section. So now we have 2 publishers: 
  • tk-multi-publish 
  • tk-multi-publish-alexa with the hook_secondary_publish overridden by the custom hook that points to tk-multi-review-submission-alexa app.
  • If I use the Alexa publisher it works as expected and sends a Quicktime with a LUT burned in to Shotgun.
  • The question:

    Since we can only use one seconday publish hook per publisher, is it possible to add more hooks and use those in one of the secondary outputs? Or maybe specify a different app for another secondary output? This way we can have more choices in the Publish window.

    Kind regards,

    David van Heeswijk
    Storm Post Production

     

    4 comments

    • 0
      Avatar
      Ryan Mayeda

      Hi David.

      I just want to make sure I understand what you're after here so I give you the right advice! Is the end result you want a publish UI that looks like the attached? I *think* this is what you meant, but please confirm! This is totally doable with the tk-multi-publish app and I can follow up with details on how to get this in place...

      Ryan.

      tk-multi-publish-alexa.png

    • 0
      Avatar
      David van Heeswijk

      Hi Ryan,

      Long time no speak!

      So yeah this is exactly what I'm after. Since the multi-review-submission doesn't provide any hooks, it's a bit  more cumbersome to achieve. Are there plans to use hooks with the submission app by the way?

      For now I solved this by building a modified review-submission app and call that one. But this leave me with multiple publish apps inside of Nuke. We just 
      like to keep it nice and clean.

      Cheers!

      David

       

    • 0
      Avatar
      Ryan Mayeda

      Hi David!

      Glad to hear the screengrab I sent is on the right track. So the good news is that you *don't* need to have multiple instances of the publish app. But for now at least, you do need to fork the tk-multi-reviewsubmission app since there's a bunch of stuff that isn't in a hook (as you've found). Let's start by going through how to configure things so there's only one instance of the publish app. Here goes...

      First off, fork the tk-multi-reviewsubmission app so that it can handle the Alexa settings you want (I realize you've already done this but I'm including it for completeness' sake). In my example, my forked app is called ```tk-multi-alexreviewsubmission```. It's basically a copy of the regular app, settings-wise, so my shot_step.yml adds this to the environment, and it also adds an additional secondary output for tk-multi-publish (important changes commented below):

      engines: 
      ... 
      tk-nuke: 
      apps: 
      ... 
      tk-multi-publish: 
      display_name: Publish 
      expand_single_items: false 
      hook_copy_file: default 
      hook_post_publish: default 
      hook_primary_pre_publish: default 
      hook_primary_publish: default 
      hook_scan_scene: default 
      hook_secondary_pre_publish: alexa_secondary_pre_publish_tk-nuke # OVERRIDE SECONDARY HOOK(S) 
      hook_secondary_publish: alexa_secondary_publish_tk-nuke # OVERRIDE SECONDARY HOOK(S) 
      hook_thumbnail: default 
      location: {name: tk-multi-publish, type: app_store, version: v0.3.17} 
      primary_description: Publishes and versions up the current Nuke script. 
      primary_display_name: Nuke Publish 
      primary_icon: icons/publish_nuke_main.png 
      primary_publish_template: nuke_shot_publish 
      primary_scene_item_type: work_file 
      primary_tank_type: Nuke Script 
      secondary_outputs: 
      - {description: Copies renders from work area to publish area., 
      display_group: Shotgun Write Nodes, 
      display_name: Publish Renders, icon: icons/publish_nuke_writenode.png, name: render, 
      publish_template: null, required: false, scene_item_type: write_node, selected: true, 
      tank_type: Rendered Image} 
      - {description: Create quicktime and send to Screening Room, display_group: Shotgun Write Nodes, 
      display_name: Send to Screening Room (sRGB), icon: icons/publish_nuke_review.png, name: quicktime, 
      publish_template: null, required: false, scene_item_type: write_node, selected: true, 
      tank_type: Quicktime} 
      - {description: Create quicktime and send to Screening Room, display_group: Shotgun Write Nodes, # ADDED THIS! 
      display_name: Send to Screening Room (Alexa), icon: icons/arri_alexa.png, name: alexa_quicktime, 
      publish_template: null, required: false, scene_item_type: write_node, selected: true, 
      tank_type: Quicktime} 
      template_work: nuke_shot_work 
      tk-multi-alexareviewsubmission: 
      location: {name: tk-multi-alexareviewsubmission, type: app_store, version: v0.1.9} 
      movie_height: 540 
      movie_path_template: nuke_shot_render_movie_alexa # NOTE NEW TEMPLATE! 
      movie_width: 1024 
      new_version_status: rev 
      slate_logo: icons/review_submit_logo.png 
      store_on_disk: true 
      upload_to_shotgun: true 
      version_number_padding: 3 
      tk-multi-reviewsubmission: 
      location: {name: tk-multi-reviewsubmission, type: app_store, version: v0.1.9} 
      movie_height: 540 
      movie_path_template: nuke_shot_render_movie 
      movie_width: 1024 
      new_version_status: rev 
      slate_logo: icons/review_submit_logo.png 
      store_on_disk: true 
      upload_to_shotgun: true 
      version_number_padding: 3

      As you can see from the environment configuration, there are a few other changes to make. Next up is the templates, where my template for the Alexa quicktime should be different from the regular one. As a result, I added a new ```nuke_shot_render_alexa``` template:

      # review output 
      shot_quicktime_quick: '@shot_root/review/quickdaily/{Shot}_{name}_{iteration}.mov' 
      nuke_shot_render_movie: '@shot_root/review/{Shot}_{name}_{channel}_v{version}.mov' 
      nuke_shot_render_movie_alexa: '@shot_root/review/{Shot}_{name}_{channel}_v{version}_alexa.mov'

      And, I also modified both the hook_secondary_pre_publish and hook_secondary_publish to account for the new ```alex_quicktime``` output that I need to account for. In both cases, I *basically* copy and paste the existing reviewsubmission code, with slight changes to direct things to my Alexa app. In hook_secondary_pre_publish, I added this, starting at line 103 of the default hook:

      elif output["name"] == "quicktime": 
      # Make sure a 'Publish Renders' task is checked. 
      if not self._get_render_task_for_task(tasks, task): 
      raise TankError("If you have the 'Send to Screening Room' box ticked, you " 
      "must also have the 'Publish Renders' box ticked!") 

      # Copy and paste of the regular SR check, but changed over to check for Alexa 
      elif output["name"] == "alexa_quicktime": 
      # Make sure a 'Publish Renders' task is checked. 
      if not self._get_render_task_for_task(tasks, task): 
      raise TankError("If you have the 'Send to Screening Room' box ticked, you " 
      "must also have the 'Publish Renders' box ticked!")

      For the pre_publish, it's exactly the same check, where you need to make sure the renders are published in order to also create the Alexa quicktime.

      In hook_secondary_publish, the changes are similar but there are a few more tweaks. At line 112, you need to account for the Alexa reviewsubmission app in addition to the regular reviewsubmission app:

      >review_submission_app = None 
      if tasks_by_output.get("quicktime"): 
      # If we have the tk-multi-reviewsubmission app we can create versions 
      review_submission_app = self.parent.engine.apps.get("tk-multi-reviewsubmission") 
      if not review_submission_app: 
      raise TankError("Unable to publish Review Versions without the tk-multi-reviewsubmission app!") alexa_review_submission_app = None 
      if tasks_by_output.get("alexa_quicktime"): 
      # If we have the tk-multi-reviewsubmission app we can create versions 
      alexa_review_submission_app = self.parent.engine.apps.get("tk-multi-alexareviewsubmission") 
      if not alexa_review_submission_app: 
      raise TankError("Unable to publish Review Versions without the tk-multi-alexareviewsubmission app!")

      Same essential code, just using the Alexa reviewsubmission app instead. Similarly, at line 197, you need to handle the ```alexa_quicktime``` output and direct it to the Alexa reviewsubmission app (see comment below):

      # Copy and paste of the regular SR submission, but changed over to call the Alexa app 
      elif output_name == "alexa_quicktime": 
      # Publish the reviewable quicktime movie for a Shotgun Write Node 

      # each publish task is connected to a nuke write node 
      # this value was populated via the scan scene hook 
      write_node = task["item"].get("other_params", dict()).get("node") 
      if not write_node: 
      raise TankError("Could not determine nuke write node for item '%s'!" % str(task)) 

      # Submit published sequence to Screening Room 
      try: 
      # pick up sg data from the render dict we are maintianing 
      # note: we assume that the rendering tasks always happen 
      # before the review tasks inside the publish... 
      (sg_publish, thumbnail_path) = render_publishes[ write_node.name() ] 

      self._send_to_screening_room ( 
      write_node, 
      write_node_app, 
      alexa_review_submission_app, # Changed this to the Alexa app 
      sg_publish, 
      sg_task, 
      comment, 
      thumbnail_path, 
      progress_cb 
      )

      That should do it! I have attached my shot_step.yml environment config, my updated hooks, and the Arri icon I used. Let me know if this doesn't work for you and you're still stuck!

      On the hooks front for tk-multi-reviewsubmission, this thread has gotten us thinking about what the right thing is. We're trying to figure out the balance between having more configuration settings, and pushing people to actually write code to override things. What do you think the right balance is? Are there certain things that *should* be settings, to save coding time (ex. quality, codec, etc.)? We're trying to keep the app as simple as possible, but also flexible enough to meet people's needs. There's a balance there that can be tricky, and we're hoping to avoid a scenario where there are a *ton* of settings that each user has to wade through, with many of them being irrelevant to their workflow (but totally relevant to someone else's, and vice versa).

      Just out of curiosity, what did you end up changing in the app to handle your Alexa output? Did you touch any other nodes in the group that tk-multi-reviewsubmission generates *besides* the write node? Hearing about these details is very useful to us, as it helps us think through the scope of what our feature enhancements should be!

      Ryan.

      [click here to download the config]
      (Note: this references older versions of apps and engines than are available currently)

    • 0
      Avatar
      David Mason

      Hi Ryan/team,

      I've been implementing a version of this in our pipeline and I have it working except that the quicktimes both write to the same file, my hook_secondary_publish doesn't pick up my "nuke_shot_render_movie_lut" path defined in templates.yml.  both options make a the quicktime.

      I think my hangup is in the `alexa_quicktime` (mines avid_quicktime} output in hook_secondary_publish shown in your example, my problem is I copied the code from;

      elif output_name == "quicktime": 

       

      but the version of I am using looks like this;

      #elif output_name == "avid_quicktime":
      # Publish the reviewable quicktime movie for a Shotgun Write Node ...
      ...
      ...
      self._send_to_screening_room (
      write_node,
      sg_publish,
      sg_task,
      comment,
      thumbnail_path,
      progress_cb
      )

       

      there was no write_node_app ore review_node_app to modify, and when I tried adding them I got problems re: defined variables.

       

      I just cant seem to get my second, secondary publish to use the branched "tk-multi-avidreviewsubmission" app instead of the default.

      Feels like I've almost got it, can you help me over the last hurdle?

      David.

    Please sign in to leave a comment.