Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2025-12-24 12:54:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix(all): rename attributes

Browse source 
- `frameRate` to `fps`
- `startFrame` to `frameStart`
- `endFrame` to `frameEnd`
- `fstart` to `frameStart`
- `fend` to `frameEnd`
- `handle_start` to `handleStart`
- `handle_end` to `handleEnd`
- `resolution_width` to `resolutionWidth`
- `resolution_height` to `resolutionHeight`
- `pixel_aspect` to `pixelAspect`
This commit is contained in:
Jakub Jezek 2019-07-31 12:38:14 +02:00
parent 74ede172ef
commit b40e1f5511
80 changed files with 316 additions and 1299 deletions
Download patch file Download diff file Expand all files Collapse all files

4
pype/fusion/scripts/fusion_switch_shot.py
View file

@ -138,8 +138,8 @@ def update_frame_range(comp, representations):
versions = io.find({"type": "version", "_id": {"$in": version_ids}})
versions = list(versions)
start = min(v["data"]["startFrame"] for v in versions)
end = max(v["data"]["endFrame"] for v in versions)
start = min(v["data"]["frameStart"] for v in versions)
end = max(v["data"]["frameEnd"] for v in versions)
fusion_lib.update_frame_range(start, end, comp=comp)

4
pype/lib.py
View file

@ -17,8 +17,8 @@ log = logging.getLogger(__name__)
def get_handle_irregular(asset):
data = asset["data"]
handle_start = data.get("handle_start", 0)
handle_end = data.get("handle_end", 0)
handle_start = data.get("handleStart", 0)
handle_end = data.get("handleEnd", 0)
return (handle_start, handle_end)

8
pype/maya/lib.py
View file

@ -280,8 +280,8 @@ def collect_animation_data():
# build attributes
data = OrderedDict()
data["startFrame"] = start
data["endFrame"] = end
data["frameStart"] = start
data["frameEnd"] = end
data["handles"] = 0
data["step"] = 1.0
data["fps"] = fps
@ -1866,8 +1866,8 @@ def set_context_settings():
set_scene_fps(fps)
# Set project resolution
width_key = "resolution_width"
height_key = "resolution_height"
width_key = "resolutionWidth"
height_key = "resolutionHeight"
width = asset_data.get(width_key, project_data.get(width_key, 1920))
height = asset_data.get(height_key, project_data.get(height_key, 1080))

88
pype/nuke/lib.py
View file

@ -459,7 +459,7 @@ def reset_frame_range_handles():
data = asset["data"]
missing_cols = []
check_cols = ["fps", "fstart", "fend", "handle_start", "handle_end"]
check_cols = ["fps", "frameStart", "frameEnd", "handleStart", "handleEnd"]
for col in check_cols:
if col not in data:
@ -477,26 +477,24 @@ def reset_frame_range_handles():
handle_start, handle_end = pype.get_handle_irregular(asset)
fps = asset["data"]["fps"]
edit_in = int(asset["data"]["fstart"]) - handle_start
edit_out = int(asset["data"]["fend"]) + handle_end
frame_start= int(asset["data"]["frameStart"]) - handle_start
frame_end= int(asset["data"]["frameEnd"]) + handle_end
root["fps"].setValue(fps)
root["first_frame"].setValue(edit_in)
root["last_frame"].setValue(edit_out)
root["first_frame"].setValue(frame_start)
root["last_frame"].setValue(frame_end)
log.info("__ handles: `{}`".format(handles))
log.info("__ handle_start: `{}`".format(handle_start))
log.info("__ handle_end: `{}`".format(handle_end))
log.info("__ edit_in: `{}`".format(edit_in))
log.info("__ edit_out: `{}`".format(edit_out))
log.info("__ fps: `{}`".format(fps))
# setting active viewers
nuke.frame(int(asset["data"]["fstart"]))
nuke.frame(int(asset["data"]["frameStart"]))
range = '{0}-{1}'.format(
int(asset["data"]["fstart"]),
int(asset["data"]["fend"]))
int(asset["data"]["frameStart"]),
int(asset["data"]["frameEnd"]))
for node in nuke.allNodes(filter="Viewer"):
node['frame_range'].setValue(range)
@ -510,8 +508,8 @@ def reset_frame_range_handles():
# adding handle_start/end to root avalon knob
if not avalon.nuke.set_avalon_knob_data(root, {
"handle_start": int(handle_start),
"handle_end": int(handle_end)
"handleStart": int(handle_start),
"handleEnd": int(handle_end)
}):
log.warning("Cannot set Avalon knob to Root node!")
@ -532,9 +530,9 @@ def reset_resolution():
asset = api.Session["AVALON_ASSET"]
asset = io.find_one({"name": asset, "type": "asset"})
width = asset.get('data', {}).get('resolution_width')
height = asset.get('data', {}).get('resolution_height')
pixel_aspect = asset.get('data', {}).get('pixel_aspect')
width = asset.get('data', {}).get("resolutionWidth")
height = asset.get('data', {}).get("resolutionHeight")
pixel_aspect = asset.get('data', {}).get("pixelAspect")
log.info("pixel_aspect: {}".format(pixel_aspect))
if any(not x for x in [width, height, pixel_aspect]):
@ -575,7 +573,7 @@ def reset_resolution():
crnt_fmt_kargs = {
"width": (check_format.width()),
"height": (check_format.height()),
"pixel_aspect": float(check_format.pixelAspect())
"pixelAspect": float(check_format.pixelAspect())
}
if bbox:
crnt_fmt_kargs.update({
@ -590,7 +588,7 @@ def reset_resolution():
new_fmt_kargs = {
"width": int(width),
"height": int(height),
"pixel_aspect": float(pixel_aspect),
"pixelAspect": float(pixel_aspect),
"project_name": format_name
}
if bbox:
@ -668,60 +666,6 @@ def get_hierarchical_attr(entity, attr, default=None):
return get_hierarchical_attr(parent, attr)
# TODO: bellow functions are wip and needs to be check where they are used
# ------------------------------------
#
# def update_frame_range(start, end, root=None):
# """Set Nuke script start and end frame range
#
# Args:
# start (float, int): start frame
# end (float, int): end frame
# root (object, Optional): root object from nuke's script
#
# Returns:
# None
#
# """
#
# knobs = {
# "first_frame": start,
# "last_frame": end
# }
#
# with avalon.nuke.viewer_update_and_undo_stop():
# for key, value in knobs.items():
# if root:
# root[key].setValue(value)
# else:
# nuke.root()[key].setValue(value)
#
# #
# def get_additional_data(container):
# """Get Nuke's related data for the container
#
# Args:
# container(dict): the container found by the ls() function
#
# Returns:
# dict
# """
#
# node = container["_node"]
# tile_color = node['tile_color'].value()
# if tile_color is None:
# return {}
#
# hex = '%08x' % tile_color
# rgba = [
# float(int(hex[0:2], 16)) / 255.0,
# float(int(hex[2:4], 16)) / 255.0,
# float(int(hex[4:6], 16)) / 255.0
# ]
#
# return {"color": Qt.QtGui.QColor().fromRgbF(rgba[0], rgba[1], rgba[2])}
def get_write_node_template_attr(node):
''' Gets all defined data from presets
@ -747,7 +691,7 @@ def get_write_node_template_attr(node):
# adding dataflow template
{correct_data.update({k: v})
for k, v in nuke_dataflow_writes.items()
if k not in ["id", "previous"]}
if k not in ["_id", "_previous"]}
# adding colorspace template
{correct_data.update({k: v})

6
pype/nukestudio/lib.py
View file

@ -51,9 +51,9 @@ def set_workfiles():
log.info("project_data: {}".format(project_data))
# get format and fps property from avalon db on project
width = project_data['resolution_width']
height = project_data['resolution_height']
pixel_aspect = project_data['pixel_aspect']
width = project_data["resolutionWidth"]
height = project_data["resolutionHeight"]
pixel_aspect = project_data["pixelAspect"]
fps = project_data['fps']
format_name = project_data['code']

20
pype/nukestudio/precomp_clip.py
View file

@ -14,9 +14,9 @@ def create_nk_script_clips(script_lst, seq=None):
'handles': 10,
'handleStart': 15, # added asymetrically to handles
'handleEnd': 10, # added asymetrically to handles
'timelineIn': 16,
'startFrame': 991,
'endFrame': 1023,
"clipIn": 16,
"frameStart": 991,
"frameEnd": 1023,
'task': 'Comp-tracking',
'work_dir': 'VFX_PR',
'shot': '00010'
@ -55,12 +55,12 @@ def create_nk_script_clips(script_lst, seq=None):
if media_in:
source_in = media_in + handle_start
else:
source_in = nk['startFrame'] + handle_start
source_in = nk["frameStart"] + handle_start
if media_duration:
source_out = (media_in + media_duration - 1) - handle_end
else:
source_out = nk['endFrame'] - handle_end
source_out = nk["frameEnd"] - handle_end
print("__ media: `{}`".format(media))
print("__ media_in: `{}`".format(media_in))
@ -98,8 +98,8 @@ def create_nk_script_clips(script_lst, seq=None):
trackItem.setSourceIn(source_in)
trackItem.setSourceOut(source_out)
trackItem.setSourceIn(source_in)
trackItem.setTimelineIn(nk['timelineIn'])
trackItem.setTimelineOut(nk['timelineIn'] + (source_out - source_in))
trackItem.setTimelineIn(nk["clipIn"])
trackItem.setTimelineOut(nk["clipIn"] + (source_out - source_in))
track.addTrackItem(trackItem)
track.addTrackItem(trackItem)
clips_lst.append(trackItem)
@ -179,9 +179,9 @@ script_lst = [{
'handles': 10,
'handleStart': 10,
'handleEnd': 10,
'timelineIn': 16,
'startFrame': 991,
'endFrame': 1023,
"clipIn": 16,
"frameStart": 991,
"frameEnd": 1023,
'task': 'platesMain',
'work_dir': 'shots',
'shot': '120sh020'

8
pype/plugins/aport/publish/collect_instances.py
View file

@ -43,15 +43,15 @@ class CollectInstancesFromJson(pyblish.api.ContextPlugin):
"type": "asset"})
# get frame start > first try from asset data
frame_start = context.data["assetData"].get("fstart", None)
frame_start = context.data["assetData"].get("frameStart", None)
if not frame_start:
self.log.debug("frame_start not on assetData")
# get frame start > second try from parent data
frame_start = pype.get_data_hierarchical_attr(entity, "fstart")
frame_start = pype.get_data_hierarchical_attr(entity, "frameStart")
if not frame_start:
self.log.debug("frame_start not on any parent entity")
# get frame start > third try from parent data
frame_start = asset_default["fstart"]
frame_start = asset_default["frameStart"]
assert frame_start, "No `frame_start` data found, "
"please set `fstart` on asset"
@ -129,7 +129,7 @@ class CollectInstancesFromJson(pyblish.api.ContextPlugin):
instance.data.update({
"subset": subset_name,
"task": task,
"fstart": frame_start,
"frameStart": frame_start,
"handles": handles,
"host": host,
"asset": asset,

8
pype/plugins/ftrack/publish/integrate_ftrack_instances.py
View file

@ -76,11 +76,11 @@ class IntegrateFtrackInstance(pyblish.api.InstancePlugin):
)
else:
end_frame += (
instance.data['endFrame'] - instance.data['startFrame']
instance.data["frameEnd"] - instance.data["frameStart"]
)
if not comp.get('frameRate'):
comp['frameRate'] = instance.context.data['fps']
if not comp.get('fps'):
comp['fps'] = instance.context.data['fps']
location = self.get_ftrack_location(
'ftrack.server', ft_session
)
@ -90,7 +90,7 @@ class IntegrateFtrackInstance(pyblish.api.InstancePlugin):
"metadata": {'ftr_meta': json.dumps({
'frameIn': int(start_frame),
'frameOut': int(end_frame),
'frameRate': float(comp['frameRate'])})}
'frameRate': float(comp['fps'])})}
}
comp['thumbnail'] = False
else:

8
pype/plugins/fusion/load/actions.py
View file

@ -27,8 +27,8 @@ class FusionSetFrameRangeLoader(api.Loader):
version = context['version']
version_data = version.get("data", {})
start = version_data.get("startFrame", None)
end = version_data.get("endFrame", None)
start = version_data.get("frameStart", None)
end = version_data.get("frameEnd", None)
if start is None or end is None:
print("Skipping setting frame range because start or "
@ -60,8 +60,8 @@ class FusionSetFrameRangeWithHandlesLoader(api.Loader):
version = context['version']
version_data = version.get("data", {})
start = version_data.get("startFrame", None)
end = version_data.get("endFrame", None)
start = version_data.get("frameStart", None)
end = version_data.get("frameEnd", None)
if start is None or end is None:
print("Skipping setting frame range because start or "

6
pype/plugins/fusion/load/load_sequence.py
View file

@ -145,7 +145,7 @@ class FusionLoadSequence(api.Loader):
tool["Clip"] = path
# Set global in point to start frame (if in version.data)
start = context["version"]["data"].get("startFrame", None)
start = context["version"]["data"].get("frameStart", None)
if start is not None:
loader_shift(tool, start, relative=False)
@ -175,7 +175,7 @@ class FusionLoadSequence(api.Loader):
been set.
- GlobalIn: Fusion reset to comp's global in if duration changes
- We change it to the "startFrame"
- We change it to the "frameStart"
- GlobalEnd: Fusion resets to globalIn + length if duration changes
- We do the same like Fusion - allow fusion to take control.
@ -212,7 +212,7 @@ class FusionLoadSequence(api.Loader):
# Get start frame from version data
version = io.find_one({"type": "version",
"_id": representation["parent"]})
start = version["data"].get("startFrame")
start = version["data"].get("frameStart")
if start is None:
self.log.warning("Missing start frame for updated version"
"assuming starts at frame 0 for: "

6
pype/plugins/fusion/publish/collect_instances.py
View file

@ -23,7 +23,7 @@ class CollectInstances(pyblish.api.ContextPlugin):
"""Collect Fusion saver instances
This additionally stores the Comp start and end render range in the
current context's data as "startFrame" and "endFrame".
current context's data as "frameStart" and "frameEnd".
"""
@ -43,8 +43,8 @@ class CollectInstances(pyblish.api.ContextPlugin):
savers = [tool for tool in tools if tool.ID == "Saver"]
start, end = get_comp_render_range(comp)
context.data["startFrame"] = start
context.data["endFrame"] = end
context.data["frameStart"] = start
context.data["frameEnd"] = end
for tool in savers:
path = tool["Clip"][comp.TIME_UNDEFINED]

4
pype/plugins/fusion/publish/publish_image_sequences.py
View file

@ -53,8 +53,8 @@ class PublishImageSequence(pyblish.api.InstancePlugin):
# The instance has most of the information already stored
metadata = {
"regex": regex,
"startFrame": instance.context.data["startFrame"],
"endFrame": instance.context.data["endFrame"],
"frameStart": instance.context.data["frameStart"],
"frameEnd": instance.context.data["frameEnd"],
"families": ["imagesequence"],
}

4
pype/plugins/fusion/publish/submit_deadline.py
View file

@ -79,8 +79,8 @@ class FusionSubmitDeadline(pyblish.api.InstancePlugin):
"Plugin": "Fusion",
"Frames": "{start}-{end}".format(
start=int(context.data["startFrame"]),
end=int(context.data["endFrame"])
start=int(context.data["frameStart"]),
end=int(context.data["frameEnd"])
),
"Comment": comment,

6
pype/plugins/global/publish/collect_context.py
View file

@ -67,9 +67,9 @@ class CollectContextDataSAPublish(pyblish.api.ContextPlugin):
if isinstance(component['files'], list):
collections, remainder = clique.assemble(component['files'])
self.log.debug("collecting sequence: {}".format(collections))
instance.data['startFrame'] = int(component['startFrame'])
instance.data['endFrame'] = int(component['endFrame'])
instance.data['frameRate'] = int(component['frameRate'])
instance.data["frameStart"] = int(component["frameStart"])
instance.data["frameEnd"] = int(component["frameEnd"])
instance.data['fps'] = int(component['fps'])
instance.data["representations"].append(component)

27
pype/plugins/global/publish/collect_filesequences.py
View file

@ -6,14 +6,13 @@ from pprint import pformat
import pyblish.api
from avalon import api
import pype.api as pype
def collect(root,
regex=None,
exclude_regex=None,
startFrame=None,
endFrame=None):
frame_start=None,
frame_end=None):
"""Collect sequence collections in root"""
from avalon.vendor import clique
@ -52,10 +51,10 @@ def collect(root,
# Exclude any frames outside start and end frame.
for collection in collections:
for index in list(collection.indexes):
if startFrame is not None and index < startFrame:
if frame_start is not None and index < frame_start:
collection.indexes.discard(index)
continue
if endFrame is not None and index > endFrame:
if frame_end is not None and index > frame_end:
collection.indexes.discard(index)
continue
@ -77,8 +76,8 @@ class CollectRenderedFrames(pyblish.api.ContextPlugin):
api.Session["AVALON_ASSET"]
subset (str): The subset to publish to. If not provided the sequence's
head (up to frame number) will be used.
startFrame (int): The start frame for the sequence
endFrame (int): The end frame for the sequence
frame_start (int): The start frame for the sequence
frame_end (int): The end frame for the sequence
root (str): The path to collect from (can be relative to the .json)
regex (str): A regex for the sequence filename
exclude_regex (str): A regex for filename to exclude from collection
@ -143,8 +142,8 @@ class CollectRenderedFrames(pyblish.api.ContextPlugin):
collections = collect(root=root,
regex=regex,
exclude_regex=data.get("exclude_regex"),
startFrame=data.get("startFrame"),
endFrame=data.get("endFrame"))
frame_start=data.get("frameStart"),
frame_end=data.get("frameEnd"))
self.log.info("Found collections: {}".format(collections))
@ -179,8 +178,8 @@ class CollectRenderedFrames(pyblish.api.ContextPlugin):
# If no start or end frame provided, get it from collection
indices = list(collection.indexes)
start = data.get("startFrame", indices[0])
end = data.get("endFrame", indices[-1])
start = data.get("frameStart", indices[0])
end = data.get("frameEnd", indices[-1])
# root = os.path.normpath(root)
# self.log.info("Source: {}}".format(data.get("source", "")))
@ -194,8 +193,8 @@ class CollectRenderedFrames(pyblish.api.ContextPlugin):
"subset": subset,
"asset": data.get("asset", api.Session["AVALON_ASSET"]),
"stagingDir": root,
"startFrame": start,
"endFrame": end,
"frameStart": start,
"frameEnd": end,
"fps": fps,
"source": data.get('source', '')
})
@ -211,7 +210,7 @@ class CollectRenderedFrames(pyblish.api.ContextPlugin):
'files': list(collection),
"stagingDir": root,
"anatomy_template": "render",
"frameRate": fps,
"fps": fps,
"tags": ['review']
}
instance.data["representations"].append(representation)

2
pype/plugins/global/publish/extract_burnin.py
View file

@ -33,7 +33,7 @@ class ExtractBurnin(pype.api.Extractor):
"username": instance.context.data['user'],
"asset": os.environ['AVALON_ASSET'],
"task": os.environ['AVALON_TASK'],
"start_frame": int(instance.data['startFrame']),
"start_frame": int(instance.data["frameStart"]),
"version": version
}
self.log.debug("__ prep_data: {}".format(prep_data))

2
pype/plugins/global/publish/extract_jpeg.py
View file

@ -22,7 +22,7 @@ class ExtractJpegEXR(pyblish.api.InstancePlugin):
def process(self, instance):
start = instance.data.get("startFrame")
start = instance.data.get("frameStart")
stagingdir = os.path.normpath(instance.data.get("stagingDir"))
collected_frames = os.listdir(stagingdir)

2
pype/plugins/global/publish/extract_review.py
View file

@ -29,7 +29,7 @@ class ExtractReview(pyblish.api.InstancePlugin):
inst_data = instance.data
fps = inst_data.get("fps")
start_frame = inst_data.get("startFrame")
start_frame = inst_data.get("frameStart")
self.log.debug("Families In: `{}`".format(instance.data["families"]))

2
pype/plugins/global/publish/integrate.py
View file

@ -404,7 +404,7 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
# Include optional data if present in
optionals = [
"startFrame", "endFrame", "step", "handles", "sourceHashes"
"frameStart", "frameEnd", "step", "handles", "sourceHashes"
]
for key in optionals:
if key in instance.data:

16
pype/plugins/global/publish/integrate_new.py
View file

@ -36,9 +36,9 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
template from anatomy that should be used for
integrating this file. Only the first level can
be specified right now.
'startFrame'
'endFrame'
'framerate'
"frameStart"
"frameEnd"
'fps'
"""
label = "Integrate Asset New"
@ -303,10 +303,10 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
dst_tail = dst_collection.format("{tail}")
index_frame_start = None
if repre.get('startFrame'):
if repre.get("frameStart"):
frame_start_padding = len(str(
repre.get('endFrame')))
index_frame_start = repre.get('startFrame')
repre.get("frameEnd")))
index_frame_start = repre.get("frameStart")
dst_padding_exp = src_padding_exp
for i in src_collection.indexes:
@ -544,8 +544,8 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
# Include optional data if present in
optionals = [
"startFrame", "endFrame", "step", "handles",
"handle_end", "handle_start", "sourceHashes"
"frameStart", "frameEnd", "step", "handles",
"handleEnd", "handleStart", "sourceHashes"
]
for key in optionals:
if key in instance.data:

2
pype/plugins/global/publish/integrate_rendered_frames.py
View file

@ -408,7 +408,7 @@ class IntegrateFrames(pyblish.api.InstancePlugin):
"comment": context.data.get("comment")}
# Include optional data if present in
optionals = ["startFrame", "endFrame", "step",
optionals = ["frameStart", "frameEnd", "step",
"handles", "colorspace", "fps", "outputDir"]
for key in optionals:

26
pype/plugins/global/publish/submit_publish_job.py
View file

@ -121,7 +121,7 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
- publishJobState (str, Optional): "Active" or "Suspended"
This defaults to "Suspended"
This requires a "startFrame" and "endFrame" to be present in instance.data
This requires a "frameStart" and "frameEnd" to be present in instance.data
or in context.data.
"""
@ -240,12 +240,12 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
# Get start/end frame from instance, if not available get from context
context = instance.context
start = instance.data.get("startFrame")
start = instance.data.get("frameStart")
if start is None:
start = context.data["startFrame"]
end = instance.data.get("endFrame")
start = context.data["frameStart"]
end = instance.data.get("frameEnd")
if end is None:
end = context.data["endFrame"]
end = context.data["frameEnd"]
# Add in regex for sequence filename
# This assumes the output files start with subset name and ends with
@ -270,8 +270,8 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
metadata = {
"asset": asset,
"regex": regex,
"startFrame": start,
"endFrame": end,
"frameStart": start,
"frameEnd": end,
"fps": context.data.get("fps", None),
"families": ["render"],
"source": source,
@ -319,8 +319,8 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
# Set prev start / end frames for comparison
if not prev_start and not prev_end:
prev_start = version["data"]["startFrame"]
prev_end = version["data"]["endFrame"]
prev_start = version["data"]["frameStart"]
prev_end = version["data"]["frameEnd"]
subset_resources = get_resources(version, _ext)
resource_files = get_resource_files(subset_resources,
@ -356,12 +356,12 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
# Please do so when fixing this.
# Start frame
metadata["startFrame"] = updated_start
metadata["metadata"]["instance"]["startFrame"] = updated_start
metadata["frameStart"] = updated_start
metadata["metadata"]["instance"]["frameStart"] = updated_start
# End frame
metadata["endFrame"] = updated_end
metadata["metadata"]["instance"]["endFrame"] = updated_end
metadata["frameEnd"] = updated_end
metadata["metadata"]["instance"]["frameEnd"] = updated_end
metadata_filename = "{}_metadata.json".format(subset)

4
pype/plugins/global/publish/validate_sequence_frames.py
View file

@ -22,8 +22,8 @@ class ValidateSequenceFrames(pyblish.api.InstancePlugin):
frames = list(collection.indexes)
current_range = (frames[0], frames[-1])
required_range = (instance.data["startFrame"],
instance.data["endFrame"])
required_range = (instance.data["frameStart"],
instance.data["frameEnd"])
if current_range != required_range:
raise ValueError("Invalid frame range: {0} - "

4
pype/plugins/houdini/publish/collect_frames.py
View file

@ -23,8 +23,8 @@ class CollectFrames(pyblish.api.InstancePlugin):
match = re.match("(\w+)\.(\d+)\.vdb", file_name)
result = file_name
start_frame = instance.data.get("startFrame", None)
end_frame = instance.data.get("endFrame", None)
start_frame = instance.data.get("frameStart", None)
end_frame = instance.data.get("frameEnd", None)
if match and start_frame is not None:

6
pype/plugins/houdini/publish/collect_instances.py
View file

@ -55,7 +55,7 @@ class CollectInstances(pyblish.api.ContextPlugin):
# Create nice name if the instance has a frame range.
label = data.get("name", node.name())
if "startFrame" in data and "endFrame" in data:
if "frameStart" in data and "frameEnd" in data:
frames = "[{startFrame} - {endFrame}]".format(**data)
label = "{} {}".format(label, frames)
@ -91,8 +91,8 @@ class CollectInstances(pyblish.api.ContextPlugin):
if node.evalParm("trange") == 0:
return data
data["startFrame"] = node.evalParm("f1")
data["endFrame"] = node.evalParm("f2")
data["frameStart"] = node.evalParm("f1")
data["frameEnd"] = node.evalParm("f2")
data["steps"] = node.evalParm("f3")
return data

4
pype/plugins/maya/create/create_vrayproxy.py
View file

@ -13,8 +13,8 @@ class CreateVrayProxy(avalon.maya.Creator):
super(CreateVrayProxy, self).__init__(*args, **kwargs)
self.data["animation"] = False
self.data["startFrame"] = 1
self.data["endFrame"] = 1
self.data["frameStart"] = 1
self.data["frameEnd"] = 1
# Write vertex colors
self.data["vertexColors"] = False

8
pype/plugins/maya/load/actions.py
View file

@ -25,8 +25,8 @@ class SetFrameRangeLoader(api.Loader):
version = context['version']
version_data = version.get("data", {})
start = version_data.get("startFrame", None)
end = version_data.get("endFrame", None)
start = version_data.get("frameStart", None)
end = version_data.get("frameEnd", None)
if start is None or end is None:
print("Skipping setting frame range because start or "
@ -59,8 +59,8 @@ class SetFrameRangeWithHandlesLoader(api.Loader):
version = context['version']
version_data = version.get("data", {})
start = version_data.get("startFrame", None)
end = version_data.get("endFrame", None)
start = version_data.get("frameStart", None)
end = version_data.get("frameEnd", None)
if start is None or end is None:
print("Skipping setting frame range because start or "

6
pype/plugins/maya/publish/collect_instances.py
View file

@ -106,9 +106,9 @@ class CollectInstances(pyblish.api.ContextPlugin):
data["asset"])
# Append start frame and end frame to label if present
if "startFrame" and "endFrame" in data:
label += " [{0}-{1}]".format(int(data["startFrame"]),
int(data["endFrame"]))
if "frameStart" and "frameEnd" in data:
label += " [{0}-{1}]".format(int(data["frameStart"]),
int(data["frameEnd"]))
instance.data["label"] = label

4
pype/plugins/maya/publish/collect_mayaascii.py
View file

@ -15,8 +15,8 @@ class CollectMayaAscii(pyblish.api.InstancePlugin):
def process(self, instance):
# Extract only current frame (override)
frame = cmds.currentTime(query=True)
instance.data['startFrame'] = frame
instance.data['endFrame'] = frame
instance.data["frameStart"] = frame
instance.data["frameEnd"] = frame
# make ftrack publishable
if instance.data.get('families'):

4
pype/plugins/maya/publish/collect_model.py
View file

@ -22,5 +22,5 @@ class CollectModelData(pyblish.api.InstancePlugin):
def process(self, instance):
# Extract only current frame (override)
frame = cmds.currentTime(query=True)
instance.data['startFrame'] = frame
instance.data['endFrame'] = frame
instance.data["frameStart"] = frame
instance.data["frameEnd"] = frame

8
pype/plugins/maya/publish/collect_renderlayers.py
View file

@ -64,9 +64,9 @@ class CollectMayaRenderlayers(pyblish.api.ContextPlugin):
"subset": layername,
"setMembers": layer,
"publish": True,
"startFrame": self.get_render_attribute("startFrame",
"frameStart": self.get_render_attribute("frameStart",
layer=layer),
"endFrame": self.get_render_attribute("endFrame",
"frameEnd": self.get_render_attribute("frameEnd",
layer=layer),
"byFrameStep": self.get_render_attribute("byFrameStep",
layer=layer),
@ -106,8 +106,8 @@ class CollectMayaRenderlayers(pyblish.api.ContextPlugin):
# Define nice label
label = "{0} ({1})".format(layername, data["asset"])
label += " [{0}-{1}]".format(int(data["startFrame"]),
int(data["endFrame"]))
label += " [{0}-{1}]".format(int(data["frameStart"]),
int(data["frameEnd"]))
instance = context.create_instance(layername)
instance.data["label"] = label

12
pype/plugins/maya/publish/collect_review.py
View file

@ -54,10 +54,10 @@ class CollectReview(pyblish.api.InstancePlugin):
self.log.debug('adding review family to {}'.format(reviewable_subset))
data['review_camera'] = camera
# data["publish"] = False
data['startFrameReview'] = instance.data['startFrame']
data['endFrameReview'] = instance.data['endFrame']
data['startFrame'] = instance.data['startFrame']
data['endFrame'] = instance.data['endFrame']
data['startFrameReview'] = instance.data["frameStart"]
data['endFrameReview'] = instance.data["frameEnd"]
data["frameStart"] = instance.data["frameStart"]
data["frameEnd"] = instance.data["frameEnd"]
data['handles'] = instance.data['handles']
data['step'] = instance.data['step']
data['fps'] = instance.data['fps']
@ -69,8 +69,8 @@ class CollectReview(pyblish.api.InstancePlugin):
else:
instance.data['subset'] = task + 'Review'
instance.data['review_camera'] = camera
instance.data['startFrameReview'] = instance.data['startFrame']
instance.data['endFrameReview'] = instance.data['endFrame']
instance.data['startFrameReview'] = instance.data["frameStart"]
instance.data['endFrameReview'] = instance.data["frameEnd"]
# make ftrack publishable
instance.data["families"] = ['ftrack']

4
pype/plugins/maya/publish/collect_vray_scene.py
View file

@ -82,8 +82,8 @@ class CollectVRayScene(pyblish.api.ContextPlugin):
"subset": subset,
"setMembers": layer,
"startFrame": start_frame,
"endFrame": end_frame,
"frameStart": start_frame,
"frameEnd": end_frame,
"renderer": "vray",
"resolution": resolution,
"ext": ".{}".format(extension),

4
pype/plugins/maya/publish/collect_yeti_rig.py
View file

@ -45,8 +45,8 @@ class CollectYetiRig(pyblish.api.InstancePlugin):
instance.data["resources"] = yeti_resources
# Force frame range for export
instance.data["startFrame"] = 1
instance.data["endFrame"] = 1
instance.data["frameStart"] = 1
instance.data["frameEnd"] = 1
def collect_input_connections(self, instance):
"""Collect the inputs for all nodes in the input_SET"""

4
pype/plugins/maya/publish/extract_animation.py
View file

@ -35,8 +35,8 @@ class ExtractAnimation(pype.api.Extractor):
fullPath=True) or []
# Collect the start and end including handles
start = instance.data["startFrame"]
end = instance.data["endFrame"]
start = instance.data["frameStart"]
end = instance.data["frameEnd"]
handles = instance.data.get("handles", 0)
if handles:
start -= handles

4
pype/plugins/maya/publish/extract_camera_alembic.py
View file

@ -23,8 +23,8 @@ class ExtractCameraAlembic(pype.api.Extractor):
def process(self, instance):
# get settings
framerange = [instance.data.get("startFrame", 1),
instance.data.get("endFrame", 1)]
framerange = [instance.data.get("frameStart", 1),
instance.data.get("frameEnd", 1)]
handles = instance.data.get("handles", 0)
step = instance.data.get("step", 1.0)
bake_to_worldspace = instance.data("bakeToWorldSpace", True)

4
pype/plugins/maya/publish/extract_camera_mayaAscii.py
View file

@ -88,8 +88,8 @@ class ExtractCameraMayaAscii(pype.api.Extractor):
def process(self, instance):
# get settings
framerange = [instance.data.get("startFrame", 1),
instance.data.get("endFrame", 1)]
framerange = [instance.data.get("frameStart", 1),
instance.data.get("frameEnd", 1)]
handles = instance.data.get("handles", 0)
step = instance.data.get("step", 1.0)
bake_to_worldspace = instance.data("bakeToWorldSpace", True)

4
pype/plugins/maya/publish/extract_fbx.py
View file

@ -166,8 +166,8 @@ class ExtractFBX(pype.api.Extractor):
self.log.info("Export options: {0}".format(options))
# Collect the start and end including handles
start = instance.data["startFrame"]
end = instance.data["endFrame"]
start = instance.data["frameStart"]
end = instance.data["frameEnd"]
handles = instance.data.get("handles", 0)
if handles:
start -= handles

4
pype/plugins/maya/publish/extract_pointcache.py
View file

@ -25,8 +25,8 @@ class ExtractAlembic(pype.api.Extractor):
nodes = instance[:]
# Collect the start and end including handles
start = instance.data.get("startFrame", 1)
end = instance.data.get("endFrame", 1)
start = instance.data.get("frameStart", 1)
end = instance.data.get("frameEnd", 1)
handles = instance.data.get("handles", 0)
if handles:
start -= handles

6
pype/plugins/maya/publish/extract_quicktime.py
View file

@ -114,9 +114,9 @@ class ExtractQuicktime(pype.api.Extractor):
'ext': 'mov',
'files': collected_frames,
"stagingDir": stagingdir,
'startFrame': start,
'endFrame': end,
'frameRate': fps,
"frameStart": start,
"frameEnd": end,
'fps': fps,
'preview': True,
'tags': ['review']
}

8
pype/plugins/maya/publish/extract_vrayproxy.py
View file

@ -28,14 +28,14 @@ class ExtractVRayProxy(pype.api.Extractor):
if not anim_on:
# Remove animation information because it is not required for
# non-animated subsets
instance.data.pop("startFrame", None)
instance.data.pop("endFrame", None)
instance.data.pop("frameStart", None)
instance.data.pop("frameEnd", None)
start_frame = 1
end_frame = 1
else:
start_frame = instance.data["startFrame"]
end_frame = instance.data["endFrame"]
start_frame = instance.data["frameStart"]
end_frame = instance.data["frameEnd"]
vertex_colors = instance.data.get("vertexColors", False)

4
pype/plugins/maya/publish/extract_yeti_cache.py
View file

@ -31,8 +31,8 @@ class ExtractYetiCache(pype.api.Extractor):
data_file = os.path.join(dirname, "yeti.fursettings")
# Collect information for writing cache
start_frame = instance.data.get("startFrame")
end_frame = instance.data.get("endFrame")
start_frame = instance.data.get("frameStart")
end_frame = instance.data.get("frameEnd")
preroll = instance.data.get("preroll")
if preroll > 0:
start_frame -= preroll

6
pype/plugins/maya/publish/submit_maya_deadline.py
View file

@ -182,8 +182,8 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
"Plugin": instance.data.get("mayaRenderPlugin", "MayaBatch"),
"Frames": "{start}-{end}x{step}".format(
start=int(instance.data["startFrame"]),
end=int(instance.data["endFrame"]),
start=int(instance.data["frameStart"]),
end=int(instance.data["frameEnd"]),
step=int(instance.data["byFrameStep"]),
),
@ -330,7 +330,7 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
def preflight_check(self, instance):
"""Ensure the startFrame, endFrame and byFrameStep are integers"""
for key in ("startFrame", "endFrame", "byFrameStep"):
for key in ("frameStart", "frameEnd", "byFrameStep"):
value = instance.data[key]
if int(value) == value:

6
pype/plugins/maya/publish/submit_maya_muster.py
View file

@ -389,8 +389,8 @@ class MayaSubmitMuster(pyblish.api.InstancePlugin):
},
"frames_range": {
"value": "{start}-{end}".format(
start=int(instance.data["startFrame"]),
end=int(instance.data["endFrame"])),
start=int(instance.data["frameStart"]),
end=int(instance.data["frameEnd"])),
"state": True,
"subst": False
},
@ -539,7 +539,7 @@ class MayaSubmitMuster(pyblish.api.InstancePlugin):
def preflight_check(self, instance):
"""Ensure the startFrame, endFrame and byFrameStep are integers"""
for key in ("startFrame", "endFrame", "byFrameStep"):
for key in ("frameStart", "frameEnd", "byFrameStep"):
value = instance.data[key]
if int(value) == value:

14
pype/plugins/maya/publish/submit_vray_deadline.py
View file

@ -51,8 +51,8 @@ class VraySubmitDeadline(pyblish.api.InstancePlugin):
filename,
vrscene_output)
start_frame = int(instance.data["startFrame"])
end_frame = int(instance.data["endFrame"])
start_frame = int(instance.data["frameStart"])
end_frame = int(instance.data["frameEnd"])
# Primary job
self.log.info("Submitting export job ..")
@ -123,8 +123,8 @@ class VraySubmitDeadline(pyblish.api.InstancePlugin):
self.log.info("Submitting render job ..")
start_frame = int(instance.data["startFrame"])
end_frame = int(instance.data["endFrame"])
start_frame = int(instance.data["frameStart"])
end_frame = int(instance.data["frameEnd"])
ext = instance.data.get("ext", "exr")
# Create output directory for renders
@ -215,8 +215,8 @@ class VraySubmitDeadline(pyblish.api.InstancePlugin):
return cmd.format(project=instance.context.data["workspaceDir"],
cam=cammera,
startFrame=instance.data["startFrame"],
endFrame=instance.data["endFrame"],
startFrame=instance.data["frameStart"],
endFrame=instance.data["frameEnd"],
layer=instance.name)
def build_jobinfo_environment(self, env):
@ -266,7 +266,7 @@ class VraySubmitDeadline(pyblish.api.InstancePlugin):
if dir:
return output_path.replace("\\", "/")
start_frame = int(instance.data["startFrame"])
start_frame = int(instance.data["frameStart"])
filename_zero = "{}_{:04d}.vrscene".format(output_path, start_frame)
result = filename_zero.replace("\\", "/")

4
pype/plugins/maya/publish/validate_frame_range.py
View file

@ -25,8 +25,8 @@ class ValidateFrameRange(pyblish.api.InstancePlugin):
def process(self, instance):
start = instance.data.get("startFrame", None)
end = instance.data.get("endFrame", None)
start = instance.data.get("frameStart", None)
end = instance.data.get("frameEnd", None)
handles = instance.data.get("handles", None)
# Check if any of the values are present

4
pype/plugins/maya/publish/validate_instancer_frame_ranges.py
View file

@ -51,8 +51,8 @@ class ValidateInstancerFrameRanges(pyblish.api.InstancePlugin):
import pyseq
start_frame = instance.data.get("startFrame", 0)
end_frame = instance.data.get("endFrame", 0)
start_frame = instance.data.get("frameStart", 0)
end_frame = instance.data.get("frameEnd", 0)
required = range(int(start_frame), int(end_frame) + 1)
invalid = list()

2
pype/plugins/maya/publish/validate_vrayproxy.py
View file

@ -23,5 +23,5 @@ class ValidateVrayProxy(pyblish.api.InstancePlugin):
cls.log.error("'%s' is empty! This is a bug" % instance.name)
if data["animation"]:
if data["endFrame"] < data["startFrame"]:
if data["frameEnd"] < data["frameStart"]:
cls.log.error("End frame is smaller than start frame")

4
pype/plugins/nuke/_publish_unused/publish_image_sequences.py
View file

@ -53,8 +53,8 @@ class PublishImageSequence(pyblish.api.InstancePlugin):
# The instance has most of the information already stored
metadata = {
"regex": regex,
"startFrame": instance.context.data["startFrame"],
"endFrame": instance.context.data["endFrame"],
"frameStart": instance.context.data["frameStart"],
"frameEnd": instance.context.data["frameEnd"],
"families": ["imagesequence"],
}

4
pype/plugins/nuke/_publish_unused/submit_deadline.py
View file

@ -78,8 +78,8 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin):
"Plugin": "Nuke",
"Frames": "{start}-{end}".format(
start=int(instance.data["startFrame"]),
end=int(instance.data["endFrame"])
start=int(instance.data["frameStart"]),
end=int(instance.data["frameEnd"])
),
"Comment": comment,

6
pype/plugins/nuke/_publish_unused/validate_nuke_settings.py
View file

@ -19,10 +19,10 @@ class ValidateSettingsNuke(pyblish.api.Validator):
asset = io.find_one({"name": os.environ['AVALON_ASSET']})
try:
avalon_resolution = asset["data"].get("resolution", '')
avalon_pixel_aspect = asset["data"].get("pixel_aspect", '')
avalon_pixel_aspect = asset["data"].get("pixelAspect", '')
avalon_fps = asset["data"].get("fps", '')
avalon_first = asset["data"].get("edit_in", '')
avalon_last = asset["data"].get("edit_out", '')
avalon_first = asset["data"].get("frameStart", '')
avalon_last = asset["data"].get("frameEnd", '')
avalon_crop = asset["data"].get("crop", '')
except KeyError:
print(

8
pype/plugins/nuke/load/actions.py
View file

@ -30,8 +30,8 @@ class SetFrameRangeLoader(api.Loader):
version = context['version']
version_data = version.get("data", {})
start = version_data.get("startFrame", None)
end = version_data.get("endFrame", None)
start = version_data.get("frameStart", None)
end = version_data.get("frameEnd", None)
log.info("start: {}, end: {}".format(start, end))
if start is None or end is None:
@ -64,8 +64,8 @@ class SetFrameRangeWithHandlesLoader(api.Loader):
version = context['version']
version_data = version.get("data", {})
start = version_data.get("startFrame", None)
end = version_data.get("endFrame", None)
start = version_data.get("frameStart", None)
end = version_data.get("frameEnd", None)
if start is None or end is None:
print("Skipping setting frame range because start or "

14
pype/plugins/nuke/load/load_mov.py
View file

@ -92,8 +92,8 @@ class LoadMov(api.Loader):
version = context['version']
version_data = version.get("data", {})
orig_first = version_data.get("startFrame", None)
orig_last = version_data.get("endFrame", None)
orig_first = version_data.get("frameStart", None)
orig_last = version_data.get("frameEnd", None)
diff = orig_first - 1
# set first to 1
first = orig_first - diff
@ -141,7 +141,7 @@ class LoadMov(api.Loader):
read_node["frame"].setValue(str(offset_frame))
# add additional metadata from the version to imprint to Avalon knob
add_keys = [
"startFrame", "endFrame", "handles", "source", "author",
"frameStart", "frameEnd", "handles", "source", "author",
"fps", "version", "handleStart", "handleEnd"
]
@ -207,8 +207,8 @@ class LoadMov(api.Loader):
version_data = version.get("data", {})
orig_first = version_data.get("startFrame", None)
orig_last = version_data.get("endFrame", None)
orig_first = version_data.get("frameStart", None)
orig_last = version_data.get("frameEnd", None)
diff = orig_first - 1
# set first to 1
first = orig_first - diff
@ -250,8 +250,8 @@ class LoadMov(api.Loader):
updated_dict = {}
updated_dict.update({
"representation": str(representation["_id"]),
"startFrame": version_data.get("startFrame"),
"endFrame": version_data.get("endFrame"),
"frameStart": version_data.get("frameStart"),
"frameEnd": version_data.get("frameEnd"),
"version": version.get("name"),
"source": version_data.get("source"),
"handles": version_data.get("handles"),

17
pype/plugins/nuke/load/load_script_precomp.py
View file

@ -27,8 +27,8 @@ class LinkAsGroup(api.Loader):
version_data = version.get("data", {})
vname = version.get("name", None)
first = version_data.get("startFrame", None)
last = version_data.get("endFrame", None)
first = version_data.get("frameStart", None)
last = version_data.get("frameEnd", None)
# Fallback to asset name when namespace is None
if namespace is None:
@ -41,17 +41,14 @@ class LinkAsGroup(api.Loader):
self.log.info("versionData: {}\n".format(context["version"]["data"]))
# Set global in point to start frame (if in version.data)
start = context["version"]["data"].get("startFrame", None)
self.log.info("start: {}\n".format(start))
# add additional metadata from the version to imprint to Avalon knob
add_keys = ["startFrame", "endFrame", "handle_start", "handle_end", "source", "author", "fps"]
add_keys = ["frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps"]
data_imprint = {
"start_frame": start,
"fstart": first,
"fend": last,
"start_frame": first,
"frameStart": first,
"frameEnd": last,
"version": vname
}
for k in add_keys:
@ -138,7 +135,7 @@ class LinkAsGroup(api.Loader):
updated_dict = {}
updated_dict.update({
"representation": str(representation["_id"]),
"endFrame": version["data"].get("endFrame"),
"frameEnd": version["data"].get("frameEnd"),
"version": version.get("name"),
"colorspace": version["data"].get("colorspace"),
"source": version["data"].get("source"),

14
pype/plugins/nuke/load/load_sequence.py
View file

@ -92,8 +92,8 @@ class LoadSequence(api.Loader):
version = context['version']
version_data = version.get("data", {})
first = version_data.get("startFrame", None)
last = version_data.get("endFrame", None)
first = version_data.get("frameStart", None)
last = version_data.get("frameEnd", None)
handles = version_data.get("handles", 0)
handle_start = version_data.get("handleStart", 0)
handle_end = version_data.get("handleEnd", 0)
@ -136,7 +136,7 @@ class LoadSequence(api.Loader):
r["last"].setValue(int(last))
# add additional metadata from the version to imprint to Avalon knob
add_keys = ["startFrame", "endFrame", "handles",
add_keys = ["frameStart", "frameEnd", "handles",
"source", "colorspace", "author", "fps", "version",
"handleStart", "handleEnd"]
@ -198,8 +198,8 @@ class LoadSequence(api.Loader):
version_data = version.get("data", {})
first = version_data.get("startFrame", None)
last = version_data.get("endFrame", None)
first = version_data.get("frameStart", None)
last = version_data.get("frameEnd", None)
handles = version_data.get("handles", 0)
handle_start = version_data.get("handleStart", 0)
handle_end = version_data.get("handleEnd", 0)
@ -234,8 +234,8 @@ class LoadSequence(api.Loader):
updated_dict = {}
updated_dict.update({
"representation": str(representation["_id"]),
"startFrame": version_data.get("startFrame"),
"endFrame": version_data.get("endFrame"),
"frameStart": version_data.get("frameStart"),
"frameEnd": version_data.get("frameEnd"),
"version": version.get("name"),
"colorspace": version_data.get("colorspace"),
"source": version_data.get("source"),

1
pype/plugins/nuke/publish/collect_framerate.py
View file

@ -14,5 +14,4 @@ class CollectFramerate(pyblish.api.ContextPlugin):
]
def process(self, context):
context.data["framerate"] = nuke.root()["fps"].getValue()
context.data["fps"] = nuke.root()["fps"].getValue()

4
pype/plugins/nuke/publish/collect_reads.py
View file

@ -99,8 +99,8 @@ class CollectNukeReads(pyblish.api.ContextPlugin):
"stagingDir": source_dir,
"ext": ext,
"label": label,
"startFrame": first_frame,
"endFrame": last_frame,
"frameStart": first_frame,
"frameEnd": last_frame,
"colorspace": node["colorspace"].value(),
"handles": int(asset_data["data"].get("handles", 0)),
"step": 1,

18
pype/plugins/nuke/publish/collect_workfile.py
View file

@ -38,8 +38,8 @@ class CollectWorkfile(pyblish.api.ContextPlugin):
first_frame = int(root["first_frame"].getValue())
last_frame = int(root["last_frame"].getValue())
handle_start = int(knob_data.get("handle_start", 0))
handle_end = int(knob_data.get("handle_end", 0))
handle_start = int(knob_data.get("handleStart", 0))
handle_end = int(knob_data.get("handleEnd", 0))
# Get format
format = root['format'].value()
@ -54,17 +54,17 @@ class CollectWorkfile(pyblish.api.ContextPlugin):
script_data = {
"asset": os.getenv("AVALON_ASSET", None),
"version": version,
"startFrame": first_frame + handle_start,
"endFrame": last_frame - handle_end,
"resolution_width": resolution_width,
"resolution_height": resolution_height,
"pixel_aspect": pixel_aspect,
"frameStart": first_frame + handle_start,
"frameEnd": last_frame - handle_end,
"resolutionWidth": resolution_width,
"resolutionHeight": resolution_height,
"pixelAspect": pixel_aspect,
# backward compatibility
"handles": handle_start,
"handle_start": handle_start,
"handle_end": handle_end,
"handleStart": handle_start,
"handleEnd": handle_end,
"step": 1,
"fps": root['fps'].value(),
}

4
pype/plugins/nuke/publish/collect_writes.py
View file

@ -91,8 +91,8 @@ class CollectNukeWrites(pyblish.api.InstancePlugin):
"ext": ext,
"label": label,
"handles": handles,
"startFrame": first_frame,
"endFrame": last_frame,
"frameStart": first_frame,
"frameEnd": last_frame,
"outputType": output_type,
"colorspace": node["colorspace"].value(),
})

4
pype/plugins/nuke/publish/extract_render_local.py
View file

@ -24,8 +24,8 @@ class NukeRenderLocal(pype.api.Extractor):
self.log.debug("instance collected: {}".format(instance.data))
first_frame = instance.data.get("startFrame", None)
last_frame = instance.data.get("endFrame", None)
first_frame = instance.data.get("frameStart", None)
last_frame = instance.data.get("frameEnd", None)
node_subset_name = instance.data.get("name", None)
self.log.info("Starting render")

8
pype/plugins/nuke/publish/extract_review_data.py
View file

@ -67,8 +67,8 @@ class ExtractReviewData(pype.api.Extractor):
else:
fname = os.path.basename(instance.data.get("path", None))
fhead = os.path.splitext(fname)[0] + "."
first_frame = instance.data.get("startFrame", None)
last_frame = instance.data.get("endFrame", None)
first_frame = instance.data.get("frameStart", None)
last_frame = instance.data.get("frameEnd", None)
node = previous_node = nuke.createNode("Read")
@ -149,8 +149,8 @@ class ExtractReviewData(pype.api.Extractor):
'ext': representation,
'files': file,
"stagingDir": stagingDir,
"startFrame": first_frame,
"endFrame": last_frame,
"frameStart": first_frame,
"frameEnd": last_frame,
"anatomy_template": "render",
"tags": tags
}

6
pype/plugins/nuke/publish/submit_nuke_deadline.py
View file

@ -77,8 +77,8 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin):
"Plugin": "Nuke",
"Frames": "{start}-{end}".format(
start=int(instance.data["startFrame"]),
end=int(instance.data["endFrame"])
start=int(instance.data["frameStart"]),
end=int(instance.data["frameEnd"])
),
"Comment": comment,
@ -199,7 +199,7 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin):
def preflight_check(self, instance):
"""Ensure the startFrame, endFrame and byFrameStep are integers"""
for key in ("startFrame", "endFrame"):
for key in ("frameStart", "frameEnd"):
value = instance.data[key]
if int(value) == value:

2
pype/plugins/nuke/publish/validate_rendered_frames.py
View file

@ -51,7 +51,7 @@ class ValidateRenderedFrames(pyblish.api.InstancePlugin):
collection = collections[0]
frame_length = int(
instance.data["endFrame"] - instance.data["startFrame"] + 1
instance.data["frameEnd"] - instance.data["frameStart"] + 1
)
if frame_length != 1:

50
pype/plugins/nuke/publish/validate_script.py
View file

@ -24,22 +24,22 @@ class ValidateScript(pyblish.api.InstancePlugin):
# These attributes will be checked
attributes = [
"fps",
"fstart",
"fend",
"resolution_width",
"resolution_height",
"handle_start",
"handle_end"
"frameStart",
"frameEnd",
"resolutionWidth",
"resolutionHeight",
"handleStart",
"handleEnd"
]
# Value of these attributes can be found on parents
hierarchical_attributes = [
"fps",
"resolution_width",
"resolution_height",
"pixel_aspect",
"handle_start",
"handle_end"
"resolutionWidth",
"resolutionHeight",
"pixelAspect",
"handleStart",
"handleEnd"
]
missing_attributes = []
@ -72,25 +72,25 @@ class ValidateScript(pyblish.api.InstancePlugin):
# Get handles from database, Default is 0 (if not found)
handle_start = 0
handle_end = 0
if "handle_start" in asset_attributes:
handle_start = asset_attributes["handle_start"]
if "handle_end" in asset_attributes:
handle_end = asset_attributes["handle_end"]
if "handleStart" in asset_attributes:
handle_start = asset_attributes["handleStart"]
if "handleEnd" in asset_attributes:
handle_end = asset_attributes["handleEnd"]
# Set frame range with handles
# asset_attributes["fstart"] -= handle_start
# asset_attributes["fend"] += handle_end
# asset_attributes["frameStart"] -= handle_start
# asset_attributes["frameEnd"] += handle_end
# Get values from nukescript
script_attributes = {
"handle_start": ctx_data["handle_start"],
"handle_end": ctx_data["handle_end"],
"handleStart": ctx_data["handleStart"],
"handleEnd": ctx_data["handleEnd"],
"fps": ctx_data["fps"],
"fstart": ctx_data["startFrame"],
"fend": ctx_data["endFrame"],
"resolution_width": ctx_data["resolution_width"],
"resolution_height": ctx_data["resolution_height"],
"pixel_aspect": ctx_data["pixel_aspect"]
"frameStart": ctx_data["frameStart"],
"frameEnd": ctx_data["frameEnd"],
"resolutionWidth": ctx_data["resolutionWidth"],
"resolutionHeight": ctx_data["resolutionHeight"],
"pixelAspect": ctx_data["pixelAspect"]
}
# Compare asset's values Nukescript X Database
@ -107,7 +107,7 @@ class ValidateScript(pyblish.api.InstancePlugin):
msg = "Attributes '{}' are not set correctly"
# Alert user that handles are set if Frame start/end not match
if (
(("fstart" in not_matching) or ("fend" in not_matching)) and
(("frameStart" in not_matching) or ("frameEnd" in not_matching)) and
((handle_start > 0) or (handle_end > 0))
):
msg += " (`handle_start` are set to {})".format(handle_start)

191
pype/plugins/nukestudio/_unused/collect.py
View file

@ -1,191 +0,0 @@
from pyblish import api
class CollectFramerate(api.ContextPlugin):
"""Collect framerate from selected sequence."""
order = api.CollectorOrder
label = "Collect Framerate"
hosts = ["nukestudio"]
def process(self, context):
for item in context.data.get("selection", []):
context.data["framerate"] = item.sequence().framerate().toFloat()
return
class CollectTrackItems(api.ContextPlugin):
"""Collect all tasks from submission."""
order = api.CollectorOrder
label = "Collect Track Items"
hosts = ["nukestudio"]
def process(self, context):
import os
submission = context.data.get("submission", None)
data = {}
# Set handles
handles = 0
if submission:
for task in submission.getLeafTasks():
if task._cutHandles:
handles = task._cutHandles
self.log.info("__ handles: '{}'".format(handles))
# Skip audio track items
media_type = "core.Hiero.Python.TrackItem.MediaType.kAudio"
if str(task._item.mediaType()) == media_type:
continue
item = task._item
if item.name() not in data:
data[item.name()] = {"item": item, "tasks": [task]}
else:
data[item.name()]["tasks"].append(task)
data[item.name()]["startFrame"] = task.outputRange()[0]
data[item.name()]["endFrame"] = task.outputRange()[1]
else:
for item in context.data.get("selection", []):
# Skip audio track items
# Try/Except is to handle items types, like EffectTrackItem
try:
media_type = "core.Hiero.Python.TrackItem.MediaType.kVideo"
if str(item.mediaType()) != media_type:
continue
except:
continue
data[item.name()] = {
"item": item,
"tasks": [],
"startFrame": item.timelineIn(),
"endFrame": item.timelineOut()
}
for key, value in data.items():
context.create_instance(
name=key,
subset="trackItem",
asset=value["item"].name(),
item=value["item"],
family="trackItem",
tasks=value["tasks"],
startFrame=value["startFrame"] + handles,
endFrame=value["endFrame"] - handles,
handles=handles
)
context.create_instance(
name=key + "_review",
subset="reviewItem",
asset=value["item"].name(),
item=value["item"],
family="trackItem_review",
families=["output"],
handles=handles,
output_path=os.path.abspath(
os.path.join(
context.data["activeProject"].path(),
"..",
"workspace",
key + ".mov"
)
)
)
class CollectTasks(api.ContextPlugin):
"""Collect all tasks from submission."""
order = api.CollectorOrder + 0.01
label = "Collect Tasks"
hosts = ["nukestudio"]
def process(self, context):
import os
import re
import hiero.exporters as he
import clique
for parent in context:
if "trackItem" != parent.data["family"]:
continue
for task in parent.data["tasks"]:
asset_type = None
hiero_cls = he.FnSymLinkExporter.SymLinkExporter
if isinstance(task, hiero_cls):
asset_type = "img"
movie_formats = [".mov", ".R3D"]
ext = os.path.splitext(task.resolvedExportPath())[1]
if ext in movie_formats:
asset_type = "mov"
hiero_cls = he.FnTranscodeExporter.TranscodeExporter
if isinstance(task, hiero_cls):
asset_type = "img"
if task.resolvedExportPath().endswith(".mov"):
asset_type = "mov"
hiero_cls = he.FnNukeShotExporter.NukeShotExporter
if isinstance(task, hiero_cls):
asset_type = "scene"
hiero_cls = he.FnAudioExportTask.AudioExportTask
if isinstance(task, hiero_cls):
asset_type = "audio"
# Skip all non supported export types
if not asset_type:
continue
resolved_path = task.resolvedExportPath()
# Formatting the basename to not include frame padding or
# extension.
name = os.path.splitext(os.path.basename(resolved_path))[0]
name = name.replace(".", "")
name = name.replace("#", "")
name = re.sub(r"%.*d", "", name)
instance = context.create_instance(name=name, parent=parent)
instance.data["task"] = task
instance.data["item"] = parent.data["item"]
instance.data["family"] = "trackItem.task"
instance.data["families"] = [asset_type, "local", "task"]
label = "{1}/{0} - {2} - local".format(
name, parent, asset_type
)
instance.data["label"] = label
instance.data["handles"] = parent.data["handles"]
# Add collection or output
if asset_type == "img":
collection = None
if "#" in resolved_path:
head = resolved_path.split("#")[0]
padding = resolved_path.count("#")
tail = resolved_path.split("#")[-1]
collection = clique.Collection(
head=head, padding=padding, tail=tail
)
if "%" in resolved_path:
collection = clique.parse(
resolved_path, pattern="{head}{padding}{tail}"
)
instance.data["collection"] = collection
else:
instance.data["output_path"] = resolved_path

215
pype/plugins/nukestudio/_unused/collect_plates.py
View file

@ -1,215 +0,0 @@
from pyblish import api
import pype
class CollectPlates(api.InstancePlugin):
"""Collect plates"""
order = api.CollectorOrder + 0.49
label = "Collect Plates"
hosts = ["nukestudio"]
families = ["plate"]
def process(self, instance):
import os
# add to representations
if not instance.data.get("representations"):
instance.data["representations"] = list()
version_data = dict()
context = instance.context
anatomy = context.data.get("anatomy", None)
padding = int(anatomy.templates['render']['padding'])
name = instance.data["subset"]
asset = instance.data["asset"]
track = instance.data["track"]
family = instance.data["family"]
families = instance.data["families"]
version = instance.data["version"]
source_path = instance.data["sourcePath"]
source_file = os.path.basename(source_path)
# staging dir creation
staging_dir = os.path.dirname(
source_path)
item = instance.data["item"]
# get handles
handles = int(instance.data["handles"])
handle_start = int(instance.data["handleStart"])
handle_end = int(instance.data["handleEnd"])
# get source frames
source_in = int(instance.data["sourceIn"])
source_out = int(instance.data["sourceOut"])
# get source frames
frame_start = int(instance.data["startFrame"])
frame_end = int(instance.data["endFrame"])
# get source frames
source_in_h = int(instance.data["sourceInH"])
source_out_h = int(instance.data["sourceOutH"])
# get timeline frames
timeline_in = int(instance.data["timelineIn"])
timeline_out = int(instance.data["timelineOut"])
# frame-ranges with handles
timeline_frame_start = int(instance.data["timelineInHandles"])
timeline_frame_end = int(instance.data["timelineOutHandles"])
# get colorspace
colorspace = item.sourceMediaColourTransform()
# get sequence from context, and fps
fps = float(str(instance.data["fps"]))
# test output
self.log.debug("__ handles: {}".format(handles))
self.log.debug("__ handle_start: {}".format(handle_start))
self.log.debug("__ handle_end: {}".format(handle_end))
self.log.debug("__ frame_start: {}".format(frame_start))
self.log.debug("__ frame_end: {}".format(frame_end))
self.log.debug("__ f duration: {}".format(frame_end - frame_start + 1))
self.log.debug("__ source_in: {}".format(source_in))
self.log.debug("__ source_out: {}".format(source_out))
self.log.debug("__ s duration: {}".format(source_out - source_in + 1))
self.log.debug("__ source_in_h: {}".format(source_in_h))
self.log.debug("__ source_out_h: {}".format(source_out_h))
self.log.debug("__ sh duration: {}".format(source_out_h - source_in_h + 1))
self.log.debug("__ timeline_in: {}".format(timeline_in))
self.log.debug("__ timeline_out: {}".format(timeline_out))
self.log.debug("__ t duration: {}".format(timeline_out - timeline_in + 1))
self.log.debug("__ timeline_frame_start: {}".format(
timeline_frame_start))
self.log.debug("__ timeline_frame_end: {}".format(timeline_frame_end))
self.log.debug("__ colorspace: {}".format(colorspace))
self.log.debug("__ track: {}".format(track))
self.log.debug("__ fps: {}".format(fps))
self.log.debug("__ source_file: {}".format(source_file))
self.log.debug("__ staging_dir: {}".format(staging_dir))
self.log.debug("__ before family: {}".format(family))
self.log.debug("__ before families: {}".format(families))
#
# this is just workaround because 'clip' family is filtered
instance.data["family"] = families[-1]
instance.data["families"].append(family)
# add to data of representation
version_data.update({
"handles": handles,
"handleStart": handle_start,
"handleEnd": handle_end,
"sourceIn": source_in,
"sourceOut": source_out,
"startFrame": frame_start,
"endFrame": frame_end,
"timelineIn": timeline_in,
"timelineOut": timeline_out,
"timelineInHandles": timeline_frame_start,
"timelineOutHandles": timeline_frame_end,
"fps": fps,
"colorspace": colorspace,
"families": [f for f in families if 'ftrack' not in f],
"asset": asset,
"subset": name,
"track": track,
"version": int(version)
})
instance.data["versionData"] = version_data
try:
basename, ext = os.path.splitext(source_file)
head, padding = os.path.splitext(basename)
ext = ext[1:]
padding = padding[1:]
# head, padding, ext = source_file.split('.')
source_first_frame = int(padding)
padding = len(padding)
file = "{head}.%0{padding}d.{ext}".format(
head=head,
padding=padding,
ext=ext
)
start_frame = source_first_frame
end_frame = source_first_frame + source_out
files = [file % i for i in range(
(source_first_frame + source_in_h),
((source_first_frame + source_out_h) + 1), 1)]
except Exception as e:
self.log.debug("Exception in file: {}".format(e))
head, ext = os.path.splitext(source_file)
ext = ext[1:]
files = source_file
start_frame = source_in_h
end_frame = source_out_h
mov_file = head + ".mov"
mov_path = os.path.normpath(os.path.join(staging_dir, mov_file))
if os.path.exists(mov_path):
# adding mov into the representations
self.log.debug("__ mov_path: {}".format(mov_path))
plates_mov_representation = {
'files': mov_file,
'stagingDir': staging_dir,
'startFrame': 0,
'endFrame': source_out - source_in + 1,
'step': 1,
'frameRate': fps,
'preview': True,
'thumbnail': False,
'name': "preview",
'ext': "mov",
}
instance.data["representations"].append(
plates_mov_representation)
thumb_file = head + ".png"
thumb_path = os.path.join(staging_dir, thumb_file)
self.log.debug("__ thumb_path: {}".format(thumb_path))
thumbnail = item.thumbnail(source_in).save(
thumb_path,
format='png'
)
self.log.debug("__ thumbnail: {}".format(thumbnail))
thumb_representation = {
'files': thumb_file,
'stagingDir': staging_dir,
'name': "thumbnail",
'thumbnail': True,
'ext': "png"
}
instance.data["representations"].append(
thumb_representation)
# adding representation for plates
plates_representation = {
'files': files,
'stagingDir': staging_dir,
'name': ext,
'ext': ext,
'startFrame': start_frame,
'endFrame': end_frame,
}
instance.data["representations"].append(plates_representation)
# testing families
family = instance.data["family"]
families = instance.data["families"]
# test prints version_data
self.log.debug("__ version_data: {}".format(version_data))
self.log.debug("__ plates_representation: {}".format(
plates_representation))
self.log.debug("__ after family: {}".format(family))
self.log.debug("__ after families: {}".format(families))
# # this will do FnNsFrameServer
# FnNsFrameServer.renderFrames(*_args)

140
pype/plugins/nukestudio/_unused/extract_plate.py
View file

@ -1,140 +0,0 @@
import os
import subprocess
from hiero.exporters.FnExportUtil import writeSequenceAudioWithHandles
import pype.api
from pype.vendor import ffmpeg
class ExtractPlate(pype.api.Extractor):
"""Extract plate cut to the timeline.
Only supporting mov plates for now. Image sequences already get cut down to
timeline range.
"""
label = "Plate"
hosts = ["nukestudio"]
families = ["plate"]
optional = True
def process(self, instance):
if not instance.data["sourcePath"].endswith(".mov"):
self.log.debug(
"Skipping {} because its not a \"*.mov\" "
"format.".format(instance)
)
return
staging_dir = self.staging_dir(instance)
filename = "{0}_without_sound".format(instance.name) + ".mov"
output_path = os.path.join(staging_dir, filename)
input_path = instance.data["sourcePath"]
self.log.info("Outputting movie to %s" % output_path)
# Cut plate to timeline.
item = instance.data["item"]
start_frame = item.mapTimelineToSource(
item.timelineIn() - (
instance.data["handleStart"]
)
)
end_frame = item.mapTimelineToSource(
item.timelineOut() + (
instance.data["handleEnd"]
)
)
framerate = item.sequence().framerate().toFloat()
output_options = {
"vcodec": "copy",
"ss": start_frame / framerate,
"frames": int(end_frame - start_frame) + 1
}
try:
(
ffmpeg
.input(input_path)
.output(output_path, **output_options)
.run(overwrite_output=True,
capture_stdout=True,
capture_stderr=True)
)
except ffmpeg.Error as e:
ffmpeg_error = "ffmpeg error: {}".format(e.stderr)
self.log.error(ffmpeg_error)
raise RuntimeError(ffmpeg_error)
# Extract audio.
filename = "{0}".format(instance.name) + ".wav"
audio_path = os.path.join(staging_dir, filename)
writeSequenceAudioWithHandles(
audio_path,
item.sequence(),
item.timelineIn(),
item.timelineOut(),
0,
0
)
input_path = output_path
filename = "{0}_with_sound".format(instance.name) + ".mov"
output_path = os.path.join(staging_dir, filename)
args = [
"ffmpeg",
"-i", input_path,
"-i", audio_path,
"-vcodec", "copy",
output_path
]
self.log.debug(subprocess.list2cmdline(args))
p = subprocess.Popen(
args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
cwd=os.path.dirname(args[-1])
)
output = p.communicate()[0]
if p.returncode != 0:
raise ValueError(output)
self.log.debug(output)
# Adding representation.
ext = os.path.splitext(output_path)[1][1:]
representation = {
"files": os.path.basename(output_path),
"staging_dir": staging_dir,
"startFrame": 0,
"endFrame": end_frame - start_frame,
"step": 1,
"frameRate": framerate,
"thumbnail": False,
"name": ext,
"ext": ext
}
instance.data["representations"] = [representation]
self.log.debug("Adding representation: {}".format(representation))
# Adding thumbnail representation.
path = instance.data["sourcePath"].replace(".mov", ".png")
if not os.path.exists(path):
item.thumbnail(start_frame).save(path, format="png")
representation = {
"files": os.path.basename(path),
"stagingDir": os.path.dirname(path),
"name": "thumbnail",
"thumbnail": True,
"ext": "png"
}
instance.data["representations"].append(representation)
self.log.debug("Adding representation: {}".format(representation))

238
pype/plugins/nukestudio/_unused/extract_plates.py
View file

@ -1,238 +0,0 @@
from pyblish import api
import pype
class ExtractPlates(pype.api.Extractor):
"""Extracts plates"""
order = api.ExtractorOrder
label = "Extract Plates"
hosts = ["nukestudio"]
families = ["encode"]
def process(self, instance):
import os
import hiero.core
# from hiero.ui.nuke_bridge import FnNsFrameServer
# add to representations
if not instance.data.get("representations"):
instance.data["representations"] = list()
version_data = dict()
context = instance.context
anatomy = context.data.get("anatomy", None)
padding = int(anatomy.templates['render']['padding'])
name = instance.data["subset"]
asset = instance.data["asset"]
track = instance.data["track"]
family = instance.data["family"]
families = instance.data["families"]
attrs = instance.data["attributes"]
version = instance.data["version"]
# staging dir creation
self.log.debug("creating staging dir")
self.staging_dir(instance)
staging_dir = instance.data['stagingDir']
Nuke_writer = hiero.core.nuke.ScriptWriter()
item = instance.data["item"]
# get handles
handles = int(instance.data["handles"])
handle_start = int(instance.data["handleStart"])
handle_end = int(instance.data["handleEnd"])
# get timeline frames
timeline_in = int(instance.data["timelineIn"])
timeline_out = int(instance.data["timelineOut"])
# frame-ranges with handles
timeline_frame_start = int(instance.data["timelineInHandles"])
timeline_frame_end = int(instance.data["timelineOutHandles"])
# creating comp frame range
frame_start = int(instance.data["startFrame"])
frame_end = int(instance.data["endFrame"])
# get colorspace
colorspace = instance.context.data["colorspace"]
# get sequence from context, and fps
fps = int(instance.data["fps"])
# test output
self.log.debug("__ handles: {}".format(handles))
self.log.debug("__ handle_start: {}".format(handle_start))
self.log.debug("__ handle_end: {}".format(handle_end))
self.log.debug("__ timeline_in: {}".format(timeline_in))
self.log.debug("__ timeline_out: {}".format(timeline_out))
self.log.debug("__ timeline_frame_start: {}".format(
timeline_frame_start))
self.log.debug("__ timeline_frame_end: {}".format(timeline_frame_end))
self.log.debug("__ frame_start: {}".format(frame_start))
self.log.debug("__ frame_end: {}".format(frame_end))
self.log.debug("__ colorspace: {}".format(colorspace))
self.log.debug("__ track: {}".format(track))
self.log.debug("__ fps: {}".format(fps))
# Generate Nuke script
write_name = "Write_out"
# root node
root_node = hiero.core.nuke.RootNode(
frame_start,
frame_end,
fps=fps
)
root_node.addProjectSettings(colorspace)
# create write node and link it to root node
Nuke_writer.addNode(root_node)
'''TrackItem.addToNukeScript(script=, firstFrame=None, additionalNodes=[], additionalNodesCallback=None, includeRetimes=False, retimeMethod=None, startHandle=None, endHandle=None, colourTransform=None, offset=0, nodeLabel=None, includeAnnotations=False, includeEffects=True, outputToSequenceFormat=False)'''
item.addToNukeScript(
script=Nuke_writer,
firstFrame=frame_start,
includeRetimes=attrs["includeRetimes"],
retimeMethod=attrs["retimeMethod"],
startHandle=handle_start,
endHandle=handle_end,
includeEffects=attrs["includeEffects"],
includeAnnotations=attrs["includeAnnotations"]
)
write_knobs = attrs["nodes"]["write"]["attributes"]
# TODO: take template from anatomy
nukescript_file = "{asset}_{name}_v{version}.{ext}".format(
asset=asset,
name=name,
version=version,
ext="nk"
)
nukescript_path = os.path.join(
staging_dir, nukescript_file
)
# TODO: take template from anatomy
output_file = "{asset}_{name}_v{version}.%0{padding}d.{ext}".format(
asset=asset,
name=name,
version=version,
padding=padding,
ext=write_knobs["file_type"]
)
output_path = os.path.join(
staging_dir, output_file
)
write_node = hiero.core.nuke.WriteNode(output_path.replace("\\", "/"))
write_node.setKnob("name", write_name)
write_node.setKnob("file_type", write_knobs["file_type"])
for knob, value in write_knobs.items():
write_node.setKnob(knob, value)
Nuke_writer.addNode(write_node)
Nuke_writer.writeToDisk(nukescript_path)
# test prints
self.log.debug("__ output_file: {}".format(output_file))
self.log.debug("__ output_path: {}".format(output_path))
self.log.debug("__ nukescript_file: {}".format(nukescript_file))
self.log.debug("__ nukescript_path: {}".format(nukescript_path))
self.log.debug("__ write_knobs: {}".format(write_knobs))
self.log.debug("__ write_name: {}".format(write_name))
self.log.debug("__ Nuke_writer: {}".format(Nuke_writer))
# create rendering arguments for FnNsFrameServer
_args = [
nukescript_path,
"{}-{}".format(frame_start, frame_end),
write_name,
["main"]
]
# add to data of representation
version_data.update({
"handles": handles,
"handleStart": handle_start,
"handleEnd": handle_end,
"timelineIn": timeline_in,
"timelineOut": timeline_out,
"timelineInHandles": timeline_frame_start,
"timelineOutHandles": timeline_frame_end,
"compFrameIn": frame_start,
"compFrameOut": frame_end,
"fps": fps,
"colorspace": write_knobs["colorspace"],
"nukeScriptFileName": nukescript_file,
"nukeWriteFileName": output_file,
"nukeWriteName": write_name,
"FnNsFrameServer_renderFrames_args": str(_args),
"family": family,
"families": families,
"asset": asset,
"subset": name,
"track": track,
"version": int(version)
})
instance.data["versionData"] = version_data
# adding representation for nukescript
nk_representation = {
'files': nukescript_file,
'stagingDir': staging_dir,
'name': "nk",
'ext': "nk",
}
instance.data["representations"].append(nk_representation)
# adding representation for plates
plates_representation = {
'files': [output_file % i for i in range(
frame_start, (frame_end + 1), 1)],
'stagingDir': staging_dir,
'name': write_knobs["file_type"],
'ext': write_knobs["file_type"],
}
instance.data["representations"].append(plates_representation)
# adding checking file to context for ExtractPlateCheck(context) plugin
context.data["platesCheck"] = os.path.join(
staging_dir, output_file % frame_end
)
if not context.data.get("frameServerRenderQueue"):
context.data["frameServerRenderQueue"] = list()
# add to render queue list
context.data["frameServerRenderQueue"].append(_args)
# test prints
self.log.debug("__ before family: {}".format(family))
self.log.debug("__ before families: {}".format(families))
# this is just workaround because 'clip' family is filtered
instance.data["family"] = families[-1]
instance.data["families"].append(family)
# testing families
family = instance.data["family"]
families = instance.data["families"]
# test prints version_data
self.log.debug("__ version_data: {}".format(version_data))
self.log.debug("__ nk_representation: {}".format(nk_representation))
self.log.debug("__ plates_representation: {}".format(
plates_representation))
self.log.debug("__ after family: {}".format(family))
self.log.debug("__ after families: {}".format(families))
# # this will do FnNsFrameServer
# FnNsFrameServer.renderFrames(*_args)

138
pype/plugins/nukestudio/_unused/extract_review.py
View file

@ -1,138 +0,0 @@
import os
import subprocess
from hiero.exporters.FnExportUtil import writeSequenceAudioWithHandles
import pype.api
class ExtractReview(pype.api.Extractor):
"""Extract Quicktime with optimized codec for reviewing."""
label = "Review"
hosts = ["nukestudio"]
families = ["review"]
optional = True
def process(self, instance):
staging_dir = self.staging_dir(instance)
filename = "{0}_without_sound".format(instance.name) + ".mov"
output_path = os.path.join(staging_dir, filename)
input_path = instance.data["sourcePath"]
item = instance.data["item"]
# Has to be yuv420p for compatibility with older players and smooth
# playback. This does come with a sacrifice of more visible banding
# issues.
start_frame = item.mapTimelineToSource(item.timelineIn())
end_frame = item.mapTimelineToSource(item.timelineOut())
args = [
"ffmpeg",
"-ss", str(start_frame / item.sequence().framerate().toFloat()),
"-i", input_path,
"-pix_fmt", "yuv420p",
"-crf", "18",
"-timecode", "00:00:00:01",
"-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
"-frames", str(int(end_frame - start_frame) + 1),
output_path
]
self.log.debug(subprocess.list2cmdline(args))
p = subprocess.Popen(
args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
cwd=os.path.dirname(args[-1])
)
output = p.communicate()[0]
if p.returncode != 0:
raise ValueError(output)
self.log.debug(output)
# Extract audio.
filename = "{0}".format(instance.name) + ".wav"
audio_path = os.path.join(staging_dir, filename)
writeSequenceAudioWithHandles(
audio_path,
item.sequence(),
item.timelineIn(),
item.timelineOut(),
0,
0
)
input_path = output_path
filename = "{0}_with_sound".format(instance.name) + ".mov"
output_path = os.path.join(staging_dir, filename)
args = [
"ffmpeg",
"-i", input_path,
"-i", audio_path,
"-vcodec", "copy",
output_path
]
self.log.debug(subprocess.list2cmdline(args))
p = subprocess.Popen(
args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
cwd=os.path.dirname(args[-1])
)
output = p.communicate()[0]
if p.returncode != 0:
raise ValueError(output)
self.log.debug(output)
# Adding movie representation.
start_frame = int(
instance.data["sourceIn"] - (
instance.data["handleStart"]
)
)
end_frame = int(
instance.data["sourceOut"] + (
instance.data["handleEnd"]
)
)
representation = {
"files": os.path.basename(output_path),
"staging_dir": staging_dir,
"startFrame": 0,
"endFrame": end_frame - start_frame,
"step": 1,
"frameRate": (
instance.context.data["activeSequence"].framerate().toFloat()
),
"preview": True,
"thumbnail": False,
"name": "preview",
"ext": "mov",
}
instance.data["representations"] = [representation]
self.log.debug("Adding representation: {}".format(representation))
# Adding thumbnail representation.
path = instance.data["sourcePath"].replace(".mov", ".png")
if not os.path.exists(path):
item.thumbnail(start_frame).save(path, format="png")
representation = {
"files": os.path.basename(path),
"stagingDir": os.path.dirname(path),
"name": "thumbnail",
"thumbnail": True,
"ext": "png"
}
instance.data["representations"].append(representation)
self.log.debug("Adding representation: {}".format(representation))

4
pype/plugins/nukestudio/publish/collect_clips.py
View file

@ -78,8 +78,8 @@ class CollectClips(api.ContextPlugin):
"sourceFirst": source_first_frame,
"sourceIn": int(item.sourceIn()),
"sourceOut": int(item.sourceOut()),
"timelineIn": int(item.timelineIn()),
"timelineOut": int(item.timelineOut())
"clipIn": int(item.timelineIn()),
"clipOut": int(item.timelineOut())
}
)

16
pype/plugins/nukestudio/publish/collect_frame_ranges.py
View file

@ -18,14 +18,14 @@ class CollectClipFrameRanges(pyblish.api.InstancePlugin):
source_in_h = instance.data["sourceIn"] - handle_start
source_out_h = instance.data["sourceOut"] + handle_end
timeline_in = instance.data["timelineIn"]
timeline_out = instance.data["timelineOut"]
timeline_in = instance.data["clipIn"]
timeline_out = instance.data["clipOut"]
timeline_in_h = timeline_in - handle_start
timeline_out_h = timeline_out + handle_end
# set frame start with tag or take it from timeline
frame_start = instance.data.get("frameStart")
frame_start = instance.data.get("startingFrame")
if not frame_start:
frame_start = timeline_in
@ -36,12 +36,10 @@ class CollectClipFrameRanges(pyblish.api.InstancePlugin):
{
"sourceInH": source_in_h,
"sourceOutH": source_out_h,
"startFrame": frame_start,
"endFrame": frame_end,
"timelineInH": timeline_in_h,
"timelineOutH": timeline_out_h,
"edit_in": timeline_in,
"edit_out": timeline_out
"frameStart": frame_start,
"frameEnd": frame_end,
"clipInH": timeline_in_h,
"clipOutH": timeline_out_h
}
)
self.log.debug("__ data: {}".format(data))

3
pype/plugins/nukestudio/publish/collect_handles.py
View file

@ -1,4 +1,3 @@
import json
from pyblish import api
@ -56,6 +55,8 @@ class CollectClipHandles(api.ContextPlugin):
"handleStart", 0
)
instance.data["handleEnd"] = s_asset_data.get("handleEnd", 0)
# debug printing
self.log.debug("_ s_asset_data: `{}`".format(
s_asset_data))
self.log.debug("_ instance.data[handles]: `{}`".format(

32
pype/plugins/nukestudio/publish/collect_hierarchy_context.py
View file

@ -161,10 +161,10 @@ class CollectHierarchyInstance(pyblish.api.ContextPlugin):
})
# adding frame start if any on instance
start_frame = instance.data.get("frameStart")
start_frame = instance.data.get("startingFrame")
if start_frame:
asset_shared.update({
"frameStart": start_frame
"startingFrame": start_frame
})
@ -218,12 +218,12 @@ class CollectHierarchyContext(pyblish.api.ContextPlugin):
instance.data["tasks"] = s_asset_data["tasks"]
# adding frame start if any on instance
start_frame = s_asset_data.get("frameStart")
start_frame = s_asset_data.get("startingFrame")
if start_frame:
instance.data["startFrame"] = start_frame
instance.data["endFrame"] = start_frame + (
instance.data["timelineOut"] -
instance.data["timelineIn"])
instance.data["frameStart"] = start_frame
instance.data["frameEnd"] = start_frame + (
instance.data["clipOut"] -
instance.data["clipIn"])
@ -254,13 +254,11 @@ class CollectHierarchyContext(pyblish.api.ContextPlugin):
if instance.data.get("main"):
in_info['custom_attributes'] = {
'handles': int(instance.data.get('handles', 0)),
'handle_start': handle_start,
'handle_end': handle_end,
'fstart': instance.data["startFrame"],
'fend': instance.data["endFrame"],
'fps': instance.context.data["fps"],
"edit_in": instance.data["timelineIn"],
"edit_out": instance.data["timelineOut"]
"handleStart": handle_start,
"handleEnd": handle_end,
"frameStart": instance.data["frameStart"],
"frameEnd": instance.data["frameEnd"],
'fps': instance.context.data["fps"]
}
# adding SourceResolution if Tag was present
@ -272,9 +270,9 @@ class CollectHierarchyContext(pyblish.api.ContextPlugin):
width, height, pixel_aspect))
in_info['custom_attributes'].update({
"resolution_width": width,
"resolution_height": height,
"pixel_aspect": pixel_aspect
"resolutionWidth": width,
"resolutionHeight": height,
"pixelAspect": pixel_aspect
})
in_info['tasks'] = instance.data['tasks']

17
pype/plugins/nukestudio/publish/collect_plates.py
View file

@ -54,7 +54,8 @@ class CollectPlates(api.InstancePlugin):
data["name"] = data["subset"] + "_" + data["asset"]
data["label"] = "{} - {} - ({})".format(
data['asset'], data["subset"], os.path.splitext(data["sourcePath"])[1]
data['asset'], data["subset"], os.path.splitext(data["sourcePath"])[
1]
)
if "review" in instance.data["families"]:
@ -120,7 +121,9 @@ class CollectPlatesData(api.InstancePlugin):
item = instance.data["item"]
transfer_data = [
"handleStart", "handleEnd", "sourceIn", "sourceOut", "startFrame", "endFrame", "sourceInH", "sourceOutH", "timelineIn", "timelineOut", "timelineInH", "timelineOutH", "asset", "track", "version"
"handleStart", "handleEnd", "sourceIn", "sourceOut", "frameStart",
"frameEnd", "sourceInH", "sourceOutH", "clipIn", "clipOut",
"clipInH", "clipOutH", "asset", "track", "version"
]
# pass data to version
@ -170,10 +173,10 @@ class CollectPlatesData(api.InstancePlugin):
plates_mov_representation = {
'files': mov_file,
'stagingDir': staging_dir,
'startFrame': 0,
'endFrame': instance.data["sourceOut"] - instance.data["sourceIn"] + 1,
"frameStart": 0,
"frameEnd": instance.data["sourceOut"] - instance.data["sourceIn"] + 1,
'step': 1,
'frameRate': instance.context.data["fps"],
'fps': instance.context.data["fps"],
'preview': True,
'thumbnail': False,
'name': "preview",
@ -209,8 +212,8 @@ class CollectPlatesData(api.InstancePlugin):
'stagingDir': staging_dir,
'name': ext,
'ext': ext,
'startFrame': instance.data["startFrame"] - instance.data["handleStart"],
'endFrame': instance.data["endFrame"] + instance.data["handleEnd"],
"frameStart": instance.data["frameStart"] - instance.data["handleStart"],
"frameEnd": instance.data["frameEnd"] + instance.data["handleEnd"],
}
instance.data["representations"].append(plates_representation)

8
pype/plugins/nukestudio/publish/collect_reviews.py
View file

@ -91,10 +91,10 @@ class CollectReviews(api.InstancePlugin):
representation = {
"files": file,
"stagingDir": file_dir,
"startFrame": rev_inst.data.get("sourceIn"),
"endFrame": rev_inst.data.get("sourceOut"),
"frameStart": rev_inst.data.get("sourceIn"),
"frameEnd": rev_inst.data.get("sourceOut"),
"step": 1,
"frameRate": rev_inst.data.get("fps"),
"fps": rev_inst.data.get("fps"),
"preview": True,
"thumbnail": False,
"name": "preview",
@ -140,7 +140,7 @@ class CollectReviews(api.InstancePlugin):
item = instance.data["item"]
transfer_data = [
"handleStart", "handleEnd", "sourceIn", "sourceOut", "startFrame", "endFrame", "sourceInH", "sourceOutH", "timelineIn", "timelineOut", "timelineInH", "timelineOutH", "asset", "track", "version"
"handleStart", "handleEnd", "sourceIn", "sourceOut", "frameStart", "frameEnd", "sourceInH", "sourceOutH", "clipIn", "clipOut", "clipInH", "clipOutH", "asset", "track", "version"
]
version_data = dict()

4
pype/plugins/nukestudio/publish/collect_tag_framestart.py
View file

@ -18,7 +18,7 @@ class CollectClipTagFrameStart(api.InstancePlugin):
t_family = t_metadata.get("tag.family", "")
# gets only task family tags and collect labels
if "frameStart" in t_family:
if "startingFrame" in t_family:
t_number = t_metadata.get("tag.number", "")
start_frame = int(t_number)
instance.data["frameStart"] = start_frame
instance.data["startingFrame"] = start_frame

4
pype/scripts/fusion_switch_shot.py
View file

@ -138,8 +138,8 @@ def update_frame_range(comp, representations):
versions = io.find({"type": "version", "_id": {"$in": version_ids}})
versions = list(versions)
start = min(v["data"]["startFrame"] for v in versions)
end = max(v["data"]["endFrame"] for v in versions)
start = min(v["data"]["frameStart"] for v in versions)
end = max(v["data"]["frameEnd"] for v in versions)
fusion_lib.update_frame_range(start, end, comp=comp)

10
pype/standalonepublish/widgets/widget_component_item.py
View file

@ -301,11 +301,11 @@ class ComponentItem(QtWidgets.QFrame):
'preview': self.is_preview()
}
if ('startFrame' in self.in_data and 'endFrame' in self.in_data):
data['startFrame'] = self.in_data['startFrame']
data['endFrame'] = self.in_data['endFrame']
if ("frameStart" in self.in_data and "frameEnd" in self.in_data):
data["frameStart"] = self.in_data["frameStart"]
data["frameEnd"] = self.in_data["frameEnd"]
if 'frameRate' in self.in_data:
data['frameRate'] = self.in_data['frameRate']
if 'fps' in self.in_data:
data['fps'] = self.in_data['fps']
return data

22
pype/standalonepublish/widgets/widget_drop_frame.py
View file

@ -185,8 +185,8 @@ class DropDataFrame(QtWidgets.QFrame):
'name': file_base,
'ext': file_ext,
'file_info': range,
'startFrame': startFrame,
'endFrame': endFrame,
"frameStart": startFrame,
"frameEnd": endFrame,
'representation': repr_name,
'folder_path': folder_path,
'is_sequence': True,
@ -253,24 +253,24 @@ class DropDataFrame(QtWidgets.QFrame):
ext in self.presets['extensions']['video_file']
):
probe_data = self.load_data_with_probe(filepath)
if 'frameRate' not in data:
if 'fps' not in data:
# default value
frameRate = 25
frameRate_string = probe_data.get('r_frame_rate')
if frameRate_string:
frameRate = int(frameRate_string.split('/')[0])
fps = 25
fps_string = probe_data.get('r_frame_rate')
if fps_string:
fps = int(fps_string.split('/')[0])
output['frameRate'] = frameRate
output['fps'] = fps
if 'startFrame' not in data or 'endFrame' not in data:
if "frameStart" not in data or "frameEnd" not in data:
startFrame = endFrame = 1
endFrame_string = probe_data.get('nb_frames')
if endFrame_string:
endFrame = int(endFrame_string)
output['startFrame'] = startFrame
output['endFrame'] = endFrame
output["frameStart"] = startFrame
output["frameEnd"] = endFrame
if (ext == '.mov') and (not file_info):
file_info = probe_data.get('codec_name')

8
pype/widgets/project_settings.py
View file

@ -274,10 +274,10 @@ class Project_name_getUI(QtWidgets.QWidget):
# update all values in resolution
if self.resolution_w.text():
self.projects[self.new_index]['custom_attributes'][
'resolution_width'] = int(self.resolution_w.text())
"resolutionWidth"] = int(self.resolution_w.text())
if self.resolution_h.text():
self.projects[self.new_index]['custom_attributes'][
'resolution_height'] = int(self.resolution_h.text())
"resolutionHeight"] = int(self.resolution_h.text())
def _update_attributes_by_list_selection(self):
# generate actual selection index
@ -451,8 +451,8 @@ class Project_name_get(Project_name_getUI):
# int(self.projects[self.new_index]['custom_attributes']['fps']))
# project.projectRoot()
# print 'handles: {}'.format(self.projects[self.new_index]['custom_attributes']['handles'])
# print 'resolution_width: {}'.format(self.projects[self.new_index]['custom_attributes']['resolution_width'])
# print 'resolution_width: {}'.format(self.projects[self.new_index]['custom_attributes']['resolution_height'])
# print 'resolution_width: {}'.format(self.projects[self.new_index]['custom_attributes']["resolutionWidth"])
# print 'resolution_width: {}'.format(self.projects[self.new_index]['custom_attributes']["resolutionHeight"])
# print "<< {}".format(self.projects[self.new_index])
# get path for the hrox file