Skip to content

validate_marks

ValidateMarks

Bases: OptionalPyblishPluginMixin, ContextPlugin

Validate mark in and out are enabled and it's duration.

Mark In/Out does not have to match frameStart and frameEnd but duration is important.

Source code in client/ayon_tvpaint/plugins/publish/validate_marks.py
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
class ValidateMarks(
    OptionalPyblishPluginMixin,
    pyblish.api.ContextPlugin
):
    """Validate mark in and out are enabled and it's duration.

    Mark In/Out does not have to match frameStart and frameEnd but duration is
    important.
    """

    label = "Validate Mark In/Out"
    order = pyblish.api.ValidatorOrder
    optional = True
    actions = [ValidateMarksRepair]

    settings_category = "tvpaint"

    @staticmethod
    def get_expected_data(context):
        scene_mark_in = context.data["sceneMarkIn"]

        # Data collected in `CollectContextEntities`
        frame_end = context.data["frameEnd"]
        frame_start = context.data["frameStart"]
        handle_start = context.data["handleStart"]
        handle_end = context.data["handleEnd"]

        # Calculate expected Mark out (Mark In + duration - 1)
        expected_mark_out = (
            scene_mark_in
            + (frame_end - frame_start)
            + handle_start + handle_end
        )
        return {
            "markIn": scene_mark_in,
            "markInState": True,
            "markOut": expected_mark_out,
            "markOutState": True
        }

    def process(self, context):
        if not self.is_active(context.data):
            return

        current_data = {
            "markIn": context.data["sceneMarkIn"],
            "markInState": context.data["sceneMarkInState"],
            "markOut": context.data["sceneMarkOut"],
            "markOutState": context.data["sceneMarkOutState"]
        }
        expected_data = self.get_expected_data(context)
        invalid = {}
        for k in current_data.keys():
            if current_data[k] != expected_data[k]:
                invalid[k] = {
                    "current": current_data[k],
                    "expected": expected_data[k]
                }

        # Validation ends
        if not invalid:
            return

        current_frame_range = (
            (current_data["markOut"] - current_data["markIn"]) + 1
        )
        expected_frame_range = (
            (expected_data["markOut"] - expected_data["markIn"]) + 1
        )
        mark_in_enable_state = "disabled"
        if current_data["markInState"]:
            mark_in_enable_state = "enabled"

        mark_out_enable_state = "disabled"
        if current_data["markOutState"]:
            mark_out_enable_state = "enabled"

        raise PublishXmlValidationError(
            self,
            "Marks does not match database:\n{}".format(
                json.dumps(invalid, sort_keys=True, indent=4)
            ),
            formatting_data={
                "current_frame_range": str(current_frame_range),
                "expected_frame_range": str(expected_frame_range),
                "mark_in_enable_state": mark_in_enable_state,
                "mark_out_enable_state": mark_out_enable_state,
                "expected_mark_out": expected_data["markOut"]
            }
        )

ValidateMarksRepair

Bases: Action

Repair the marks.

Source code in client/ayon_tvpaint/plugins/publish/validate_marks.py
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class ValidateMarksRepair(pyblish.api.Action):
    """Repair the marks."""

    label = "Repair"
    icon = "wrench"
    on = "failed"

    def process(self, context, plugin):
        expected_data = ValidateMarks.get_expected_data(context)

        execute_george(
            "tv_markin {} set".format(expected_data["markIn"])
        )
        execute_george(
            "tv_markout {} set".format(expected_data["markOut"])
        )