Nuke Python Developer's Guide

https://learn.foundry.com/nuke/developers/150/pythondevguide/
Admin
The Nuke Python Developer's Guide provides comprehensive documentation and API reference for...
Tokens:977,282
Snippets:8,247
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### pyWxAppHelper class to initialize wxWidgets in a separate thread

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/pyWxAppUtils.html

Defines a helper class that initializes a wxWidgets application in a separate thread. The constructor accepts a wxApp class and an optional start flag; if start is true, it calls start(). The getApplication method creates the wxApp instance, and on non-macOS platforms starts its MainLoop. The start method initiates the thread and runs getApplication.

```python
# Copyright (c) 2009 The Foundry Visionmongers Ltd.  All Rights Reserved.

from nukescripts import pyAppUtils


[docs]class pyWxAppHelper(pyAppUtils.pyAppHelper):
  """ Helper class to initialise wxWidgets in a separate thread """

  def __init__(self, wxApp, start = None):
    super(pyWxAppHelper, self).__init__(start)
    self.__pyWxAppType = wxApp
    self.__pyWxApp = None
    if start:
      self.start()

  def getApplication(self):
    import wx
    if self.__pyWxApp is None:
      self.__pyWxApp = self.__pyWxAppType()
      import nuke
      if not nuke.env['MACOS']:
        self.__pyWxApp.MainLoop()
    return self.__pyWxApp

  def start(self):
    super(pyWxAppHelper, self).initiate()
    self.run(self.getApplication)



```

--------------------------------

### Get all knobs of a node with allKnobs()

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nuke.BackdropNode.html

Shows how to get a list of all knobs on a node. The example creates a Blur node and calls allKnobs() to retrieve its knobs, including nameless ones.

```python
>>> b = nuke.nodes.Blur()
>>> b.allKnobs()
```

--------------------------------

### Example performanceInfo output for a simple tree

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/performance.html

Example output from the performanceInfo() loop for a simple tree (CheckerBoard -> Blur -> Defocus -> Viewer). Shows the dictionary keys callCount, timeTakenWall, and timeTakenCPU with values in microseconds.

```text
Defocus1
{'callCount': 10228, 'timeTakenWall': 28524348, 'timeTakenCPU': 624512794}
Blur1
{'callCount': 9607, 'timeTakenWall': 9906815, 'timeTakenCPU': 151406143}
Viewer1
{'callCount': 0, 'timeTakenWall': 0, 'timeTakenCPU': 0}
CheckerBoard1
{'callCount': 34396, 'timeTakenWall': 3923322, 'timeTakenCPU': 29982254}

```

--------------------------------

### QVBoxLayout.startTimer

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nukescripts.scripteditorknob.QVBoxLayout.html

Starts a timer for the layout.

```APIDOC
## QVBoxLayout.startTimer

### Description
Starts a timer for the layout.

### Method
startTimer

### Signature
startTimer(_self_, _interval: int_, _timerType: PySide2.QtCore.Qt.TimerType = PySide2.QtCore.Qt.TimerType.CoarseTimer_) → int

### Parameters
- **interval** (int) - Required - The timer interval in milliseconds.
- **timerType** (PySide2.QtCore.Qt.TimerType) - Optional - The timer type. Default is CoarseTimer.

### Returns
int - The timer ID.
```

--------------------------------

### autoComp: get node channels

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/channels.html

Starts the autoComp function, grabbing the node's channels. This is the first step of the autoComp example.

```python
def autoComp( node ):
    channels = node.channels()
```

--------------------------------

### begin()

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nuke.Gizmo.html

Executes all following python code in the context of the node.

```APIDOC
## begin() → Group

### Description
All python code that follows will be executed in the context of node. All names are evaluated relative to this object. Must be paired with end.

### Returns
- Group.

```

--------------------------------

### Original Tcl start procedure (commented out)

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/openurl.html

Commented-out Tcl implementation of the start procedure. It shows the original logic for opening URLs across Windows, macOS, and other platforms, including browser detection and error handling.

```tcl
#proc start {url} {
#  if [catch {set command [getenv BROWSER]}] {
#    global WIN32
#    global MACOS
#    if $WIN32 {
#      set command "rundll32.exe url.dll,FileProtocolHandler"
#    } elseif $MACOS {
#      set command "/usr/bin/open"
#    } else {
#      global browser
#      if [catch {set browser}] {set browser "firefox"}
#      if [catch {set browser [get_input "\$BROWSER is not set.\nPlease type the name of your browser here.\nSome examples: firefox, konqueror, netscape, mozilla, opera" $browser]}] return
#      set command $browser
#    }
#    setenv BROWSER $command
#  }
#  if [catch {eval [concat exec $command [list $url] &]} msg] {
#    unsetenv BROWSER
#    message "$msg\nSet the environment variable \$BROWSER to fix this"
#  }
#}

```

--------------------------------

### Loop through frames and get knob values

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

Loop through the requested frames and get the knob's value at each frame for the paintTrajectory example.

```python
for f in frameRange:
    pos = knob.valueAt(f)
```

--------------------------------

### Get node object for 'Blur1' with nuke.toNode

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/basics.html

Example of using nuke.toNode to get the node object for a node named 'Blur1' in the Node Graph.

```python
myblurNode = nuke.toNode( 'Blur1' )

```

--------------------------------

### nukescripts.toolbars.setup_toolbars()

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nukescripts.toolbars.setup_toolbars.html

This function is called to set up toolbars in Nuke. It takes no arguments and returns nothing.

```APIDOC
## nukescripts.toolbars.setup_toolbars()

### Description
Sets up toolbars in Nuke. This function is part of the nukescripts.toolbars module and is intended to be called directly by users to initialize toolbar configurations.

### Method
Function call

### Signature
`nukescripts.toolbars.setup_toolbars()`

### Parameters
None

### Returns
None

### Example
```python
import nukescripts.toolbars
nukescripts.toolbars.setup_toolbars()
```
```

--------------------------------

### Get knobs of a node

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nuke.BackdropNode.html

Use this to get a dictionary of (name, knob) pairs for all knobs in a node. The example creates a Blur node and calls knobs().

```python
>>> b = nuke.nodes.Blur()
>>> b.knobs()
```

--------------------------------

### Call setUpMultiView with default views

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/stereo.html

Runs the setUpMultiView function without arguments, using the default left (green) and right (red) views.

```python
setUpMultiView()
```

--------------------------------

### Enable OpenAssetIO after launch with _asset.setupManager

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/openassetio.html

Enable OpenAssetIO after Nuke has launched by setting up the manager with the given configuration path.

```python
_asset.setupManager(config_path)

```

--------------------------------

### Start run() loop with 10 increments

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/threading.html

Starts the threaded run() method that will move nodes in 10 increments. The ellipsis indicates the loop body is filled in by subsequent examples.

```python
def run( self ):
        incs = 10
        for i in xrange( incs ):
                ...

```

--------------------------------

### ExampleRVFlipbook class implementation for RV flipbook

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/pyQtExamples/flipbookingExample.html

Complete source code for the ExampleRVFlipbook class, which subclasses nukescripts.flipbooking.FlipbookApplication. It includes a placeholder RV path, methods for name, path, cache directory, run, and capabilities, and registers the class. The run method constructs RV command-line arguments, handling Windows paths, ROI, LUT, and frame ranges. The capabilities method returns a dictionary with supported options and file types. The code contains TODO comments indicating required modifications for a working implementation.

```python
# Copyright (c) 2010 The Foundry Visionmongers Ltd.  All Rights Reserved.
import platform
import sys
import os.path
import re
import _thread
import nuke
import subprocess
import nukescripts
import nukescripts.flipbooking as flipbooking

################################################################################
# README
#
# This is an example script that demonstrated how to subimplement for RV.
# You need to modify this to get it to work!
#
# To include this in nuke please add this to somewhere in the python search path
# and add the following line to __init__.py (or menu.py):
# from rv import *
################################################################################


[docs]class ExampleRVFlipbook(flipbooking.FlipbookApplication):
  """This is an example implementation of how to deal with implementing a
     flipbook application other than FrameCycler for Nuke. This script needs
     to be modified in several places before it can work, so please read all
     of the notes marked with TODO and modify them where necessary."""
  def __init__(self):
    # TODO: Please put your own path in here or add RV path discovery.
    self._rvPath = "/Applications/RV64.app/Contents/MacOS/RV64"


[docs]  def name(self):
    return "RV"



[docs]  def path(self):
    return self._rvPath



[docs]  def cacheDir(self):
    return os.environ["NUKE_TEMP_DIR"]



[docs]  def run(self, filename, frameRanges, views, options):
    # TODO: You probably want more involved handling of frame ranges!
    sequence_interval = str(frameRanges.minFrame())+"-"+str(frameRanges.maxFrame())

    os.path.normpath(filename)

    args = []
    if nuke.env['WIN32']:
      args.append( "\"" + self.path() + "\"" )
      filename = filename.replace("/", "\\")
      filename = "\"" + filename + "\""
    else:
      args.append( self.path() )


    roi = options.get("roi", None)
    if roi != None and not (roi["x"] == 0.0 and roi["y"] == 0.0 and roi["w"] == 0.0 and roi["h"] == 0.0):
      args.append("-c "+str(int(roi["x"])))
      args.append(str(int(roi["y"])))
      args.append(str(int(roi["w"])))
      args.append(str(int(roi["h"])))

    lut = options.get("lut", "")
    if lut == "linear-sRGB":
      args.append("-sRGB")
    elif lut == "linear-rec709":
      args.append('-rec709')

    args.append(filename)

    if sequence_interval:
      args.append(sequence_interval)

    #print args
    os.spawnv(os.P_NOWAITO, self.path(), args)



[docs]  def capabilities(self):
    return {
      'proxyScale': False,
      'crop': True,
      'canPreLaunch': False,
      'supportsArbitraryChannels': True,
      'maximumViews' : 2,
      # TODO: This list is compiled from running rv with the following:
      # RV64 -formats | grep 'format "' | awk '{print $2}' | tr '[:space:]' ','; echo
      # This may differ for your platform!
      'fileTypes' : ["j2k","jpt","jp2","dpx","cin","cineon","jpeg","jpg","rla","rpf","yuv","exr","openexr","sxr","tif","tiff","sm","tex","tx","tdl","shd","targa","tga","tpic","rgbe","hdr","iff","png","z","zfile","sgi","bw","rgb","rgba","*mraysubfile*","movieproc","stdinfb","aiff","aif","aifc","wav","snd","au","mov","avi","mp4","m4v","dv"]

    }


flipbooking.register(ExampleRVFlipbook())

```

--------------------------------

### Get nodes inside a backdrop node

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nuke.BackdropNode.html

Use this to retrieve the list of nodes contained inside a backdrop node. The example creates a reference to a backdrop node by name and calls getNodes() to get the contained nodes.

```python
backdrop = nuke.toNode("BackdropNode1")
nodesInBackdrop = backdrop.getNodes()
```

--------------------------------

### nuke.activeViewer().play(1)

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/basics.html

Starts playback in the active viewer. Used in the example to assign a hotkey to the play action.

```APIDOC
## nuke.activeViewer().play(1)

### Description
Starts playback in the active viewer. Used in the example to assign a hotkey to the play action.

### Method
nuke.activeViewer().play

### Parameters
- **1** (int) - Required - The playback direction (1 for forward).

### Request Example
```python
v = nuke.activeViewer()
if v:
    v.play(1)
```

### Response
No return value is documented.
```

--------------------------------

### Get the root layer from the curves knob

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

Retrieve the root layer from the curves knob, which is the starting point for iterating over shapes.

```python
root = cKnob.rootLayer
```

--------------------------------

### nuke.BackdropNode.fileDependencies

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nuke.BackdropNode.html

Returns file dependencies. 'start' parameter specifies the first frame.

```APIDOC
## fileDependencies

### Description
Returns file dependencies.

### Method
`fileDependencies(start)`

### Parameters
- **start** (int) - first frame.

### Returns
List of file dependencies.
```

--------------------------------

### Execute a Python script at startup with -t

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/command_line.html

Runs a Python script at startup by providing the script file name after the -t switch.

```bash
<Nuke-install-path>/Nuke13.0 -t <mypythonscript.py>
```

--------------------------------

### Get control point by index

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

References the control point by its index (point number 0 in this example) from the shape object.

```python
shapePoint = shape[cvID]

```

--------------------------------

### Render multiple Write nodes with nuke.executeMultiple

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/basics.html

Renders multiple Write nodes or ranges. The first argument is a tuple of node variables, and the second is a tuple of [start, end, incr] lists. For example, nuke.executeMultiple((variable,), ([start,end,incr],)).

```python
nuke.executeMultiple ((variable,), ([start,end,incr],))

```

--------------------------------

### getVersions() example output

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/asset.html

Shows the result of calling getVersions() with sample data. The dictionary contains lists of sequence paths per type.

```python
getVersions()
# Result:
{'plates': ['/Users/frank/Desktop/shows/showA/seq1/shot2/plates/plateA/plateA.%06d.exr 1-10'], 'cg': ['/Users/frank/Desktop/shows/showA/seq1/shot2/cg/cg_creature_v01/cg_creature_v01.%04d.exr 1-10', '/Users/frank/Desktop/shows/showA/seq1/shot2/cg/cg_creature_v02/cg_creature_v02.%04d.exr 1-10', '/Users/frank/Desktop/shows/showA/seq1/shot2/cg/cg_particleTest_v01/cg_particleTest_v01.%04d.exr 1-10'], 'roto': ['/Users/frank/Desktop/shows/showA/seq1/shot2/roto/roto_gMask_v01/roto_gMask_v01.%04d.exr 1-10', '/Users/frank/Desktop/shows/showA/seq1/shot2/roto/roto_tightRoto_v01/roto_tightRoto_v01.%04d.exr 1-10'], 'comp': ['/Users/frank/Desktop/shows/showA/seq1/shot2/comp/comp_finalRender_v03/comp_finalRender_v03.%04d.exr 1-10', '/Users/frank/Desktop/shows/showA/seq1/shot2/comp/comp_testRender_v01/comp_testRender_v01.%04d.exr 1-10', '/Users/frank/Desktop/shows/showA/seq1/shot2/comp/comp_testRender_v02/comp_testRender_v02.%04d.exr 1-1']}
```

--------------------------------

### Get frame range and views with nuke.getFramesAndViews

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/custom_panels.html

Asks the user for a frame range and, if in a stereo setup, for the views to operate on. The return value is a list containing the string entered and the requested views.

```python
ret = nuke.getFramesAndViews('get range', '1-10')

```

--------------------------------

### InputHighlighter.startTimer

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nukescripts.blinkscripteditor.InputHighlighter.html

Starts a timer. This is a Qt method.

```APIDOC
## startTimer(_self_, _interval_: int, _timerType_: PySide2.QtCore.Qt.TimerType = PySide2.QtCore.Qt.TimerType.CoarseTimer) -> int

### Description
Starts a timer. This is a Qt method.

### Method
startTimer

### Signature
`startTimer(_self_, _interval_: int, _timerType_: PySide2.QtCore.Qt.TimerType = PySide2.QtCore.Qt.TimerType.CoarseTimer) -> int`

### Parameters
- **interval** (int) - Required - The timer interval in milliseconds.
- **timerType** (PySide2.QtCore.Qt.TimerType) - Optional - The timer type. Defaults to CoarseTimer.

### Returns
- **int** - The timer ID.
```

--------------------------------

### Launch CV tracking with ShapeAndCVPanel

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

Starts the _cvTracker thread from the ShapeAndCVPanel dialog. Do not run in the main thread because nuke.executeInMainThreadWithResult freezes NUKE. Requires the examples module that contains ShapeAndCVPanel and the _cvTracker function.

```python
import examples

node = nuke.selectedNode()
p = examples.ShapeAndCVPanel(node)
if p.showModalDialog():
    fRange = nuke.FrameRange(p.fRange.value())
    shapeName = p.shape.value()
    cv = p.cv.value()
    threading.Thread(None, _cvTracker, args=(node, shapeName, cv, fRange)).start()

```

--------------------------------

### Call setUpMultiView with custom views

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/stereo.html

Calls setUpMultiView with a custom list of views, setting left to red and right to green.

```python
setUpMultiView([ ('left', (1,0,0)), ('right', (0,1,0)) ])
```

--------------------------------

### Get selected items from a CurveKnob

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nuke.curveknob.CurveKnob.html

Demonstrates how to retrieve the names of selected items in a curve knob. The example shows that if a Bezier curve is selected, the first selected item's name will be 'Bezier1'.

```python
>>> curveKnob = nuke.toNode('RotoPaint1)['curves']
>>> selected = curveKnob.getSelected()
>>> selected[0].name
```

--------------------------------

### trackCV: Get selected Roto node

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

Grabs the currently selected node in the Node Graph (DAG) as the starting point for the trackCV script. Requires a Roto node with an animated Bezier spline to be selected.

```python
node = nuke.selectedNode()

```

--------------------------------

### Create a Read node for C:\Temp\myimage.cin

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/basics.html

Example of creating a Read node to load myimage.cin from C:\Temp. Note that format and other Read node controls may not be set up when using this syntax.

```python
nuke.nodes.Read (file="C:\Temp\myimage.cin")
```

--------------------------------

### nukescripts.clientserver.start_server(host='localhost', port=50007)

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nukescripts.clientserver.start_server.html

Starts a server on the specified host and port. This function is used to initiate a server that can accept client connections for communication.

```APIDOC
## nukescripts.clientserver.start_server(host='localhost', port=50007)

### Description
Starts a server on the specified host and port. This function is used to initiate a server that can accept client connections for communication.

### Method
Function

### Signature
`nukescripts.clientserver.start_server(host='localhost', port=50007)`

### Parameters
- **host** (string) - Optional - The hostname or IP address to bind the server to. Default is 'localhost'.
- **port** (int) - Optional - The port number to listen on. Default is 50007.

### Returns
None (starts the server and blocks or runs in background depending on implementation).

### Example
```python
nukescripts.clientserver.start_server(host='localhost', port=50007)
```
```

--------------------------------

### pyQtAppHelper class for PySide2 in a separate thread

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/pyQtAppUtils.html

Defines the pyQtAppHelper class that initialises PySide2 in a separate thread. It inherits from pyAppUtils.pyAppHelper and nuke.FnPySingleton. The class provides methods to get, close, start, and stop the Qt application, using PySide2's QtWidgets.QApplication.

```python
# Copyright (c) 2009 The Foundry Visionmongers Ltd.  All Rights Reserved.

import nuke_internal as nuke
from nukescripts import pyAppUtils


[docs]class pyQtAppHelper(pyAppUtils.pyAppHelper, nuke.FnPySingleton):
  """ Helper class to initialise PySide2 in a separate thread """

  def __init__(self, argv = [], start = None):
    try:
      if self.__pyQtApp: pass
    except:
      super(pyQtAppHelper, self).__init__(start)
      self.__pyQtApp = None

    if start:
      self.start(argv)


  def getApplication(self, argv):
    from PySide2 import QtCore, QtWidgets
    
    if self.__pyQtApp is None:
      self.__pyQtApp = QtWidgets.QApplication.instance()
    return self.__pyQtApp


  def closeApplication(self):
    self.__pyQtApp = None


  def start(self, argv):
    super(pyQtAppHelper, self).initiate()
    self.run(self.getApplication, (argv,))


  def stop(self):
    self.run(self.closeApplication)
    super(pyQtAppHelper, self).terminate()

```

--------------------------------

### Render a single Write node with nuke.execute

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/basics.html

Renders frames from a Write node. The arguments are the node name, start frame, end frame, and increment. For example, nuke.execute("Write1",1,35,2) renders every other frame from 1 to 35. nuke.render is an equivalent alternative.

```python
nuke.execute ("name",start,end,incr)

```

```python
nuke.execute ("Write1",1,35,2)

```

```python
nuke.execute ("Write1",start=1,end=35,incr=2)

```

--------------------------------

### Create a Camera node named Projection_Cam

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/basics.html

Example of creating a Camera node and renaming it to 'Projection_Cam'.

```python
nuke.nodes.Camera (name="Projection_Cam")
```

--------------------------------

### Create custom view and initialize views knob

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/stereo.html

Builds the script syntax for a custom view named testView with a dark red color and initializes the root's 'views' knob using fromScript. This is the final step in setting up a custom multi-view project.

```python
name = 'testView'
col = (.5, 0, 0)
rgb = tuple([ int(v*255) for v in col ])
hexCol = '#%02x%02x%02x' % rgb
view = '%s %s' % (name, hexCol)
# NOW INITIALIZE THE VIEW KNOB WITH THE NEW VIEW
nuke.root().knob('views').fromScript(view)

```

--------------------------------

### Get position for frame

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

Gets the AnimationControlPoint's position for the current frame in the range.

```python
pos = animPoint.getPosition(f)

```

--------------------------------

### Example output of format properties

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/formats.html

Shows the output of the previous loop for common formats like PC_Video, NTSC, PAL, and HD.

```python
# Result:
PC_Video
640
480
1.0
----------
NTSC
720
486
0.910000026226
----------
PAL
720
576
1.09000003338
----------
HD
1920
1080
1.0
...

```

--------------------------------

### initiate()

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_autosummary/nukescripts.pyQtAppUtils.pyQtAppHelper.html

Starts the thread associated with this object.

```APIDOC
## initiate()

### Description
Starts the thread associated with this object.

### Method
initiate

### Parameters
None

### Returns
None

```

--------------------------------

### Get all animation curves in a knob

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/animation.html

Gets all the animation curves that might be inside a knob.

```python
allCurves = k.animations()

```

--------------------------------

### Initialize Mac software data with mapping

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/hardwareinfo.html

Maps software data from itemDicts to the standard dictionary using the SPSoftwareDataType.

```python
  def initMacSoftware(self, itemDicts):
    mapping = [["os_version", gOSVersion],
               ["kernel_version", gKernelVersion],
               ["local_host_name", gMachineName]]
    self.MapDictionaries(itemDicts, self._standardDict, mapping, "SPSoftwareDataType")
```

--------------------------------

### Getting user input with nuke.getInput

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/custom_panels.html

Gets a string from the user and assigns it to all selected nodes' labels.

```python
txt = nuke.getInput('Change label', 'new label')
if txt:
    for n in nuke.selectedNodes():
        n['label'].setValue(txt)

```

--------------------------------

### Create Camera2 node and enable useMatrix

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/metadata.html

Creates a Camera2 node and sets its useMatrix knob to True.

```python
cam = nuke.createNode( 'Camera2' )
cam['useMatrix'].setValue( True )

```

--------------------------------

### Get geometry from Viewer

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/math.html

Gets the geometry from the Viewer's geo knob and warns if none is found.

```python
geoKnob = geoNode['geo']
objs = geoKnob.getGeometry()
if not objs:
    nuke.message( 'No geometry found in %s' % geoNode.name() )

```

--------------------------------

### Get Shape from Curves Knob

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/rotopaint.html

Gets the 'curves' knob and retrieves the shape object by name using toElement().

```python
curveKnob = node['curves']
shape = curveKnob.toElement(shapeName)

```

--------------------------------

### Initialize Mac hardware data with mapping

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/hardwareinfo.html

Maps hardware data from itemDicts to standard and extended dictionaries, with special handling for unknown L2 cache and unit conversions.

```python
    self.MapDictionaries(itemDicts, self._standardDict, mapping, "SPHardwareDataType")
    if self._standardDict[gL2Cache] == "Unknown":
      fixMacChangingThingsMapping = [["l2_cache_share", gL2Cache]]
      self.MapDictionaries(itemDicts, self._standardDict, fixMacChangingThingsMapping, "SPHardwareDataType")
    self._standardDict[gCPUSpeed] = ConvertSpeedUnitsToMhZ(self._standardDict[gCPUSpeed])
    self._standardDict[gL2Cache] =  ConvertMemSizeToKb(self._standardDict[gL2Cache])
    self._standardDict[gRAM] =  ConvertMemSizeToKb(self._standardDict[gRAM])
    extendedMapping = [["boot_rom_version", gBootROMVersion],
                       ["machine_model", gMachineName]]
    self.MapDictionaries(itemDicts, self._extendedDict, extendedMapping, "SPHardwareDataType")
```

--------------------------------

### Get selected node's channels

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/channels.html

Gets the channels of the currently selected node using nuke.selectedNode() and prints them.

```python
node = nuke.selectedNode()
print( node.channels() )

# Result:
['rgba.red', 'rgba.green', 'rgba.blue', 'rgba.alpha']
```

--------------------------------

### Set example environment variables SHOW, SEQ, SHOT

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/asset.html

Sets the SHOW, SEQ, and SHOT environment variables to an existing shot in the example directory structure. This is a simplified stand-in for a facility's toolset for setting the show environment.

```python
# SET UP EXAMPLE ENVIRONMENT
os.environ['SHOW'] = 'showA'
os.environ['SEQ'] = 'seq1'
os.environ['SHOT'] = 'shot2'

```

--------------------------------

### Print machine info to file

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/_modules/nukescripts/hardwareinfo.html

Creates a HardwareInfo instance and prints its XML representation to the given file.

```python
[docs]def PrintMachineInfoToFile(file, indentLevel = 1):
  info = HardwareInfo()
  info.printXML(file, indentLevel)
```

--------------------------------

### Handle transform knob case - get offsets

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/stereo.html

If the camera is driven by the transform knob, get the x value and offset it.

```python
else:
    knob = node['translate']
    # GET THE NEW VALUES FOR LEFT AND RIGHT EYE
    leftEye = knob.value(0) + leftOffset
    rightEye = knob.value(0) + rightOffset
```

--------------------------------

### Set and get node positions with setXpos/setYpos

Source: https://learn.foundry.com/nuke/developers/150/pythondevguide/dag.html

Uses the convenience methods setXpos/setYpos and xpos/ypos to set and get node positions.

```python
node.setXpos( 111 )
node.setYpos( 222 )

xPos = node.xpos()
yPos = node.ypos()
print 'new x position is', xPos
print 'new y position is', yPos

```
Tokens:
Raw