Merge pull request #20 from planetx-vfx/feature/FP-81/add-frame-deliv…

…ery-compression-choice

FP-81 Add choice for frames delivery compression

info.yml

@@ -73,6 +73,21 @@ configuration:
         settings:
           type: dict
 
+  delivery_sequence_outputs:
+    type: list
+    description: "List of version statuses to match exr render settings to."
+    values:
+      type: dict
+      items:
+        name:
+          type: str
+        extension:
+          type: str
+        status:
+          type: str
+        settings:
+          type: dict
+
   # --- STRINGS ---
   shot_status_field:
     type: str
@@ -86,6 +101,12 @@ configuration:
     allows_empty: True
     description: Field to check the version status with.
 
+  delivery_sequence_outputs_field:
+    type: str
+    default_value: "sg_submitting_for"
+    allows_empty: True
+    description: Field to match the delivery sequence output settings with.
+
   shot_delivery_status:
     type: str
     default_value: "rfd"

python/app/external/parse_exr_metadata.py

@@ -41,6 +41,8 @@ class EXR_ATTRIBUTES:
         "PXR24_COMPRESSION",
         "B44_COMPRESSION",
         "B44A_COMPRESSION",
+        "DWAA_COMPRESSION",
+        "DWAB_COMPRESSION",
     )
 
     LINE_ORDER = ("INCREASING_Y", "DECREASING_Y", "RANDOM_Y")

python/app/model.py

@@ -36,6 +36,7 @@
 
 import sgtk
 
+from .external import parse_exr_metadata
 from .models import (
     Shot,
     Version,
@@ -108,6 +109,7 @@ def __init__(self, controller) -> None:
             os.path.join(os.getcwd(), os.path.dirname(__file__))
         )
         self.slate_path = os.path.join(__location__, "slate_cli.py")
+        self.plate_path = os.path.join(__location__, "plate_cli.py")
 
         self.base_template_fields = {
             "prj": self.get_project_code(),
@@ -193,6 +195,7 @@ def get_versions_to_deliver(self) -> list[Shot]:
             "sg_delivery_note",
             "sg_attachment",
             "image",
+            self.settings.delivery_sequence_outputs_field,
         ]
 
         versions_to_deliver = self.shotgrid_connection.find(
@@ -452,6 +455,9 @@ def get_shots_information_list(
                     task=task,
                     deliver_preview=deliver_preview,
                     deliver_sequence=deliver_sequence,
+                    sequence_output_status=sg_version[
+                        self.settings.delivery_sequence_outputs_field
+                    ],
                 )
                 shot.add_version(version)
 
@@ -794,44 +800,100 @@ def update_progress(progress: float):
                     current_job += 1
 
             if deliverables.deliver_sequence:
+                should_rerender = False
+                outputs = [
+                    output
+                    for output in self.settings.delivery_sequence_outputs
+                    if output.status == version.sequence_output_status
+                ]
+                if len(outputs) > 0:
+                    output = outputs[0]
+
+                    if output.settings.keys() == ["compression"]:
+                        metadata = parse_exr_metadata.read_exr_header(
+                            version.sequence_path % version.first_frame
+                        )
+                        if "compression" in metadata:
+                            if (
+                                output.settings["compression"].lower()
+                                in metadata.get("compression")
+                                .replace("_COMPRESSION", "")
+                                .lower()
+                            ):
+                                self.logger.info("MATCH COMPRESSION")
+                            else:
+                                should_rerender = True
+                    else:
+                        should_rerender = True
+
                 # Create sequence delivery folder
                 sequence_delivery_folder = delivery_sequence_path.parent
                 self.logger.info(
                     f"Creating folder for delivery {sequence_delivery_folder}."
                 )
                 sequence_delivery_folder.mkdir(parents=True, exist_ok=True)
 
-                version.validation_message = "Delivering frames..."
-                show_validation_message(version)
+                if should_rerender:
+                    output = outputs[0]
 
-                can_link = False
-                if (
-                    Path(version.sequence_path).drive
-                    == delivery_sequence_path.drive
-                ):
-                    can_link = True
+                    version.validation_message = f"Rerendering frames for {output.status} - {output.name}..."
+                    show_validation_message(version)
 
-                for frame in range(
-                    version.first_frame, version.last_frame + 1
-                ):
-                    publish_file = Path(version.sequence_path % frame)
-                    delivery_file = delivery_sequence_path.with_name(
-                        delivery_sequence_path.name % frame
+                    publish_file = Path(version.sequence_path)
+
+                    process = NukeProcess(
+                        version,
+                        show_validation_error,
+                        show_validation_message,
+                        update_progress,
+                        f"{output.status} - {output.name}",
                     )
+                    args = [
+                        "-t",
+                        self.plate_path,
+                        str(version.first_frame),
+                        str(version.last_frame),
+                        publish_file.as_posix(),
+                        delivery_sequence_path.as_posix(),
+                        "--write-settings",
+                        output.to_cli_string(),
+                    ]
+                    process.run(
+                        self.nuke_path,
+                        args,
+                    )
+                else:
+                    version.validation_message = "Delivering frames..."
+                    show_validation_message(version)
 
-                    if can_link:
-                        os.link(publish_file, delivery_file)
-                    else:
-                        shutil.copyfile(publish_file, delivery_file)
+                    can_link = False
+                    if (
+                        Path(version.sequence_path).drive
+                        == delivery_sequence_path.drive
+                    ):
+                        can_link = True
+
+                    for frame in range(
+                        version.first_frame, version.last_frame + 1
+                    ):
+                        publish_file = Path(version.sequence_path % frame)
+                        delivery_file = delivery_sequence_path.with_name(
+                            delivery_sequence_path.name % frame
+                        )
 
-                    update_progress(
-                        (frame - version.first_frame)
-                        / (version.last_frame - version.first_frame)
-                    )
+                        if can_link:
+                            os.link(publish_file, delivery_file)
+                        else:
+                            shutil.copyfile(publish_file, delivery_file)
 
-                self.logger.info(
-                    f"Finished linking {version.sequence_path} to {delivery_sequence_path}."
-                )
+                        update_progress(
+                            (frame - version.first_frame)
+                            / (version.last_frame - version.first_frame)
+                        )
+
+                    self.logger.info(
+                        f"Finished linking {version.sequence_path} to {delivery_sequence_path}."
+                    )
 
             # Deliver attachment
             if version.attachment is not None:

python/app/models/ExportShotsThread.py

@@ -70,6 +70,8 @@ def run(self):
             "delivery_preview"
         )
 
+        csv_episode_data = {}
+
         for episode in episodes:
             # Get latest delivery version
             template_fields = {
@@ -120,15 +122,10 @@ def run(self):
                 "delivery_version"
             ]
 
-            # Create csv
-            self.create_csv(
-                validated_shots,
-                episode,
-                delivery_folder,
-                template_fields,
-                delivery_sequence_template,
-                delivery_preview_template,
-            )
+            csv_episode_data[episode] = {
+                "delivery_folder": delivery_folder,
+                "template_fields": template_fields,
+            }
 
         for shot in validated_shots:
             for version in shot.get_versions():
@@ -144,6 +141,17 @@ def run(self):
                         self.update_progress_bars,
                     )
 
+        for episode in episodes:
+            # Create csv
+            self.create_csv(
+                validated_shots,
+                episode,
+                csv_episode_data[episode]["delivery_folder"],
+                csv_episode_data[episode]["template_fields"],
+                delivery_sequence_template,
+                delivery_preview_template,
+            )
+
         self.finish_export_versions()
 
     def create_csv(
@@ -216,13 +224,13 @@ def create_csv(
 
                     to_deliver = []
                     if deliverables.deliver_sequence:
-                        sequence_name = Path(
+                        sequence_path = Path(
                             delivery_sequence_template.apply_fields(
                                 version_template_fields
                             )
-                        ).name
+                        )
                         to_deliver.append(
-                            (sequence_name, version.sequence_path, "")
+                            (sequence_path.name, sequence_path.as_posix(), "")
                         )
                     if deliverables.deliver_preview:
                         for (
@@ -232,15 +240,15 @@ def create_csv(
                                 **version_template_fields,
                                 "delivery_preview_extension": output.extension,
                             }
-                            preview_name = Path(
+                            preview_path = Path(
                                 delivery_preview_template.apply_fields(
                                     output_template_fields
                                 )
-                            ).name
+                            )
                             to_deliver.append(
                                 (
-                                    preview_name,
-                                    version.path_to_movie,
+                                    preview_path.name,
+                                    preview_path.as_posix(),
                                     output.name,
                                 )
                             )
@@ -271,7 +279,7 @@ def create_csv(
                         else:
                             csv_data[entity] = {}
 
-                    for file_name, source_file_path, codec in to_deliver:
+                    for file_name, output_file_path, codec in to_deliver:
                         csv_fields = []
 
                         for key, value in self.user_settings.csv_fields:
@@ -296,7 +304,7 @@ def create_csv(
                                     if file_name.endswith(".exr"):
                                         metadata = (
                                             parse_exr_metadata.read_exr_header(
-                                                source_file_path
+                                                output_file_path
                                                 % version.first_frame
                                             )
                                         )

python/app/models/NukeProcess.py

@@ -30,7 +30,6 @@ def __init__(
         show_validation_error: Callable[[Version], None],
         show_validation_message: Callable[[Version], None],
         update_progress_bars: Callable[[float], None],
-        progress_part: float,
         name: str = None,
     ):
         self.version = version

python/app/models/SequenceOutput.py

@@ -0,0 +1,41 @@
+import json
+
+
+class SequenceOutput:
+    name: str
+    extension: str
+    status: str
+    settings: dict
+
+    def __init__(self, name: str, extension: str, status: str, settings: dict):
+        self.name = name
+        self.extension = extension
+        self.status = status
+        self.settings = settings
+
+    def to_cli_string(self):
+        return json.dumps({**self.settings, "file_type": self.extension})
+
+    @staticmethod
+    def from_dict(data: dict):
+        """Get a SequenceOutput from a dict"""
+        return SequenceOutput(
+            data["name"],
+            data["extension"],
+            data["status"],
+            data["settings"],
+        )
+
+    def __eq__(self, other):
+        if not isinstance(other, SequenceOutput):
+            return NotImplemented
+
+        return (
+            self.name == other.name
+            and self.extension == other.extension
+            and self.status == other.status
+            and self.settings == other.settings
+        )
+
+    def __str__(self):
+        return f"<SequenceOutput {self.name} ext={self.extension} status={self.status} settings={self.settings}>"

python/app/models/Settings.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from . import PreviewOutput
+from . import PreviewOutput, SequenceOutput
 
 
 class Settings:
@@ -9,6 +9,8 @@ class Settings:
     """
 
     delivery_preview_outputs: list[PreviewOutput]
+    delivery_sequence_outputs: list[SequenceOutput]
+    delivery_sequence_outputs_field: str
     shot_status_field: str
     version_status_field: str
     shot_delivery_status: str
@@ -36,7 +38,17 @@ def __init__(self, app):
                 PreviewOutput.from_dict(output)
             )
 
+        delivery_sequence_outputs = self._app.get_setting(
+            "delivery_sequence_outputs"
+        )
+        self.delivery_sequence_outputs = []
+        for output in delivery_sequence_outputs:
+            self.delivery_sequence_outputs.append(
+                SequenceOutput.from_dict(output)
+            )
+
         for setting in [
+            "delivery_sequence_outputs_field",
             "shot_status_field",
             "version_status_field",
             "shot_delivery_status",