class ShotgunFindOne(node.BaseNode):
category = "shotgun"
documentation = "Calls 'find_one' method on the shotgun instance and returns the result as an attribute dict"
shotgunConnection = attribute.AttributeDefinition(isInput=True,
type_="shotgun",
array=False,
default=None)
entityType = attribute.AttributeDefinition(isInput=True,
type_=str,
array=False,
default="")
filters = attribute.AttributeDefinition(isInput=True,
type_=list,
array=True,
default=list())
fields = attribute.AttributeDefinition(isInput=True,
type_=list,
array=True,
default=list())
output = attribute.AttributeDefinition(isOutput=True,
type_=dict,
array=False,
default=dict())
def execute(self):
self.output = self.shotgunConnection.value().find_one(
self.entityType.value(), list(self.filters.value()),
list(self.fields.value()))
class FolderInDirectory(node.BaseNode):
category = "directories"
documentation = "returns a list of folders in a directory, if recursive is True(default is False) then all subfolders will be returned as well"
directory = attribute.AttributeDefinition(isInput=True,
type_="directory",
default="")
recursive = attribute.AttributeDefinition(isInput=True,
type_=bool,
default=False)
output = attribute.AttributeDefinition(isOutput=True,
type_="directory",
array=True,
default=[])
def execute(self):
directory = os.path.normpath(self.directory.value())
if not self.recursive:
self.output.setValue([
os.path.join(directory, i) for i in os.listdir(directory)
if os.path.isdir(i)
])
return
outFiles = []
for root, dirs, files in os.walk(directory):
outFiles.extend([os.path.join(root, d) for d in dirs])
self.output.setValue(outFiles)
class TestCompound(compound.Compound):
"""Root compound node which contains other nodes, compounds do not expand until executed via the executor class
"""
input = attribute.AttributeDefinition(isInput=True, type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,
type_=float,
default=0)
execution = attribute.AttributeDefinition(isOutput=True,
type_=float,
default=0)
def mutate(self):
firstNode = sum.Sum("firstNode", application=self.application)
firstNode.inputA = 20
firstNode.inputB = 10
secondNode = sum.Sum("secondNode", application=self.application)
secondNode.inputB = 10
thirdNodeComp = TestSubCompound("thirdNodeComp",
application=self.application)
# add the nodes as children
self.addChild(secondNode)
self.addChild(thirdNodeComp)
self.addChild(firstNode)
self.execution = thirdNodeComp.output
thirdNodeComp.input = secondNode.output
secondNode.inputA = firstNode.output
class SubStringNode(node.BaseNode):
"""Returns a list of strings that have the search string in it.
"""
category = "string"
documentation = __doc__
value = attribute.AttributeDefinition(isInput=True,
type_=str,
default="",
array=True)
search = attribute.AttributeDefinition(isInput=True, type_=str, default="")
replace = attribute.AttributeDefinition(isInput=True,
type_=str,
default="")
output = attribute.AttributeDefinition(isOutput=True,
type_=str,
array=True,
default=[])
def execute(self):
result = [
re.sub(self.self.search.value(), self.replace.value(), char)
for char in self.valuePlug_.value()
]
self.output.setValue(result)
return result
class ConvertToVideo(node.BaseNode):
category = "ffmpeg"
documentation = "convert's an image sequence to a video"
directory = attribute.AttributeDefinition(isInput=True,
type_="directory",
default="",
required=True)
pattern = attribute.AttributeDefinition(isInput=True,
type_=str,
default="%03d",
required=True)
framerate = attribute.AttributeDefinition(isInput=True,
type_=int,
default=25,
required=True)
outputPath = attribute.AttributeDefinition(isInput=True,
type_="file",
default="",
required=True)
output = attribute.AttributeDefinition(isOutput=True,
type_="file",
array=True,
default="")
def execute(self):
directory = os.path.normpath(self.directory.value())
(ffmpeg.input(os.path.join(directory, self.pattern.value()),
framerate=self.framerate.value()).output(
self.outputPath.value()).run())
class FilesInDirectory(node.BaseNode):
category = "directories"
documentation = "returns a list of files in a directory"
directory = attribute.AttributeDefinition(isInput=True,
type_="directory",
default="")
recursive = attribute.AttributeDefinition(isInput=True,
type_=bool,
default=False)
output = attribute.AttributeDefinition(isOutput=True,
type_="file",
array=True,
default=[])
def execute(self):
directory = os.path.normpath(self.directory.value())
if not self.recursive:
self.output.setValue([
os.path.join(directory, i) for i in os.listdir(directory)
if os.path.isfile(i)
])
return
outFiles = []
for root, dirs, files in os.walk(directory):
outFiles.extend([os.path.join(root, f) for f in files])
self.output.setValue(outFiles)
class Boolean(node.BaseNode):
category = "constant"
documentation = "boolean"
value = attribute.AttributeDefinition(type_=bool, default=True, isInput=True)
output = attribute.AttributeDefinition(type_=bool, default=True, isOutput=True)
def execute(self):
self.output.setValue(bool(self.input.value()))
class ArcTan(node.BaseNode):
category = "math"
documentation = "Arc tan"
input = attribute.AttributeDefinition(isInput=True,type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,type_=float, default=0)
def execute(self):
self.output.setValue(math.atan(self.input.value()))
class GreaterThanOrEqualToNode(node.BaseNode):
value1 = attribute.AttributeDefinition(float, isInput=True)
value2 = attribute.AttributeDefinition(float, isInput=True)
result = attribute.AttributeDefinition(bool, isOutput=True)
def execute(self):
result = self.value1Plug_ >= self.value2Plug_
self.result.setValue(result)
class Floor(node.BaseNode):
category = "math"
documentation = "The floor of the input value"
input = attribute.AttributeDefinition(isInput=True,type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,type_=float, default=0)
def execute(self):
self.output.setValue(abs(self.input.value()))
class Scalar(node.BaseNode):
category = "constant"
documentation = "Scalar"
value = attribute.AttributeDefinition(isInput=True,type_=float, default=0.0)
output = attribute.AttributeDefinition(isOutput=True,type_=float, default=0.0)
def execute(self):
self.output.setValue(float(self.input.value()))
class EqualToNode(node.BaseNode):
value1 = attribute.AttributeDefinition(float, isInput=True)
value2 = attribute.AttributeDefinition(float, isInput=True)
result = attribute.AttributeDefinition(bool, isOutput=True)
def execute(self):
result = self.value1.value() == self.value2.value()
self.result.setValue(result)
class Substract(node.BaseNode):
category = "math"
documentation = "subtracts the input values"
inputA = attribute.AttributeDefinition(isInput=True,type_=float, default=0)
inputB = attribute.AttributeDefinition(isInput=True,type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,type_=float, default=0)
def execute(self):
self.output.setValue(self.inputA.value() - self.inputB.value())
class Integer(node.BaseNode):
category = "constant"
documentation = "integer"
value = attribute.AttributeDefinition(isInput=True, type_=int, default=0)
output = attribute.AttributeDefinition(isOutput=True, type_=int, default=0)
def execute(self):
self.output.setValue(int(self.input.value()))
class Glob(node.BaseNode):
category = "directories"
documentation = "returns a list of files in a directory"
directory = attribute.AttributeDefinition(isInput=True, type_="directory", default="", required=True)
pattern = attribute.AttributeDefinition(isInput=True, type_=str, default="*", required=True)
output = attribute.AttributeDefinition(isOutput=True, type_="file", array=True, default="")
def execute(self):
directory = os.path.normpath(self.directory.value())
self.output.setValue(glob.glob(os.path.join(directory, self.pattern.value())))
class SquareRoot(node.BaseNode):
category = "math"
documentation = "SquareRoot of the input values"
input = attribute.AttributeDefinition(isInput=True, type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,
type_=float,
default=0)
def execute(self):
self.output.setValue(math.sqrt(self.input.value()))
class StringNode(node.BaseNode):
category = "constant"
documentation = "String constant"
value = attribute.AttributeDefinition(isInput=True, type_=str, default="")
output = attribute.AttributeDefinition(isOutput=True,
type_=str,
default="")
def execute(self):
self.output.setValue(str(self.input.value()))
class Rename(node.BaseNode):
category = "directories"
documentation = "Rename"
file = attribute.AttributeDefinition(isInput=True,
type_="file",
default="")
name = attribute.AttributeDefinition(isInput=True, type_=str, default="")
def execute(self):
self.output.setValue(math.pi)
os.rename(self.file.value(), self.name.value())
class TestSubCompound(compound.Compound):
input = attribute.AttributeDefinition(isInput=True, type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,
type_=float,
default=0)
def mutate(self):
fourthNode = sum.Sum("fourthNodeSub", application=self.application)
fourthNode.inputB = 20
self.addChild(fourthNode)
# connection between two attributes
fourthNode.inputA = self.input
class Dictionary(node.BaseNode):
category = "constant"
documentation = "Dictionary"
input = attribute.AttributeDefinition(isOutput=False,
type_=dict,
default=dict())
output = attribute.AttributeDefinition(isOutput=True,
type_=dict,
default=dict())
def execute(self):
self.output.setValue(dict(self.input.value()))
class PathExists(node.BaseNode):
category = "directories"
documentation = "Checks if file path exists(os.path.exists)"
file = attribute.AttributeDefinition(isInput=True,
type_="file",
default="")
output = attribute.AttributeDefinition(isInput=False,
isOutput=True,
type_=bool,
default=False)
def execute(self):
self.output.setValue(os.path.exists(self.file.value()))
class Divide(node.BaseNode):
category = "math"
documentation = "Divides the input values together, raises ZooDivisionError if dividing by 0"
inputA = attribute.AttributeDefinition(isInput=True,type_=float, default=0)
inputB = attribute.AttributeDefinition(isInput=True,type_=float, default=0)
output = attribute.AttributeDefinition(isOutput=True,type_=float, default=0)
def execute(self):
# @todo log
try:
self.output.setValue(self.inputA.value() / self.inputB.value())
except ZeroDivisionError:
raise
class IfNode(node.BaseNode):
ifTrue = attribute.AttributeDefinition(float, isInput=True)
ifFalse = attribute.AttributeDefinition(float, isInput=True)
condition = attribute.AttributeDefinition(float, isInput=True)
result = attribute.AttributeDefinition(bool, isOutput=True)
def execute(self):
if self.conditionPlug_.value:
result = self.ifTruePlug_.value
else:
result = self.ifFalsePlug.value
self.result.setValue(result)
class SplitString(node.BaseNode):
category = "string"
documentation = "splits a string by a delimiter"
string = attribute.AttributeDefinition(isInput=True, type_=str, default="")
delimiter = attribute.AttributeDefinition(isInput=True,
type_=str,
default=",")
output = attribute.AttributeDefinition(isOutput=True,
type_=str,
array=True,
default="")
def execute(self):
self.output.setValue(self.input.value().split(self.delimiter.value()))
class Multiply(node.BaseNode):
category = "math"
documentation = "Multiplies the input values together"
inputA = attribute.AttributeDefinition(isInput=True,
type_=float,
default=0)
inputB = attribute.AttributeDefinition(isInput=True,
type_=float,
default=0)
output = attribute.AttributeDefinition(isOutput=True,
type_=float,
default=0)
def execute(self):
self.output.setValue(self.inputA.value() % self.inputB.value())
class DestroyTankEngine(node.BaseNode):
category = "shotgun"
documentation = "Destroys the shotgun toolkit engine by calling destroy_engine on the instance"
engine = attribute.AttributeDefinition(isOutput=True, type_="sgtkengine", array=False, default=None)
def execute(self):
if self.engine is not None:
self.engine.destroy_engine()
class HalfPiNode(node.BaseNode):
category = "constant"
documentation = "HalfPiNode"
output = attribute.AttributeDefinition(isOutput=True,
type_=bool,
default=True)
def execute(self):
self.output.setValue(math.pi * 0.5)
class OrderDict(node.BaseNode):
category = "constant"
documentation = "OrderedDict"
output = attribute.AttributeDefinition(isOutput=True,
type_=dict,
default=OrderedDict())
def execute(self):
self.output.setValue(OrderedDict(self.value.value()))
class InitTankEngine(node.BaseNode):
category = "shotgun"
documentation = "Initializes a shotgun tank instance using the supplied environment"
modulePath = attribute.AttributeDefinition(isInput=True, type_=str, array=False, default="")
apiScript = attribute.AttributeDefinition(isInput=True, type_=str, array=False, default="")
context = attribute.AttributeDefinition(isInput=True, type_=dict, array=False, default=dict())
apiKey = attribute.AttributeDefinition(isInput=True, type_=str, default="")
host = attribute.AttributeDefinition(isInput=True, type_=str, default="")
configUri = attribute.AttributeDefinition(isInput=True, type_=str, default="")
plugins = attribute.AttributeDefinition(isInput=True, type_=str, default="")
engine_name = attribute.AttributeDefinition(isInput=True, type_=str, default="")
engine = attribute.AttributeDefinition(isOutput=True, type_="sgtkengine", array=False, default=None)
def execute(self):
context = self.context.value()
if not context or not any(i in context.keys() for i in ("SHOTGUN_ENTITY_ID", "SHOTGUN_ENTITY_TYPE")):
raise ValueError("Incorrect argument context values, must have only:{}, supplied: {}".format(
str(("SHOTGUN_ENTITY_ID", "SHOTGUN_ENTITY_TYPE")),
str(context)))
os.environ.update(context)
TK_CORE_PATH = self.modulePath.value()
if TK_CORE_PATH and TK_CORE_PATH not in sys.path:
sys.path.append(TK_CORE_PATH)
import sgtk
engine = sgtk.platform.current_engine()
if engine is not None:
self.engine = engine
return
# Authenticate using a pre-defined script user.
sa = sgtk.authentication.ShotgunAuthenticator()
user = sa.create_script_user(
api_script=self.apiScript.value(),
api_key=self.apiKey.value(),
host=self.host.value()
)
mgr = sgtk.bootstrap.ToolkitManager(sg_user=user)
mgr.base_configuration = self.configUri.value()
mgr.do_shotgun_config_lookup = False
mgr.plugin_id = self.plugins.value()
sg_entity = mgr.get_entity_from_environment()
engine = mgr.bootstrap_engine(self.engine_name.value(), entity=sg_entity)
self.engine = engine
class Regex(node.BaseNode):
category = "string"
documentation = "Returns a list of items the have the characters"
strings = attribute.AttributeDefinition(isInput=True,
type_=str,
array=True,
default=[])
searchString = attribute.AttributeDefinition(isInput=True,
type_=str,
default="")
output = attribute.AttributeDefinition(isOutput=True,
type_=str,
array=True,
default=[])
def execute(self):
self.output.setValue([
char for char in self.strings.value()
if re.search(self.searchString.value(), char)
])
