load_sequence

class FusionLoadSequence(load.LoaderPlugin):
    """Load image sequence into Fusion"""

    product_types = {
        "imagesequence",
        "review",
        "render",
        "plate",
        "image",
        "online",
    }
    representations = {"*"}
    extensions = set(
        ext.lstrip(".") for ext in IMAGE_EXTENSIONS.union(VIDEO_EXTENSIONS)
    )

    label = "Load sequence"
    order = -10
    icon = "code-fork"
    color = "orange"

    def load(self, context, name, namespace, data):
        # Fallback to folder name when namespace is None
        if namespace is None:
            namespace = context["folder"]["name"]

        # Use the first file for now
        path = self.filepath_from_context(context)

        # Create the Loader with the filename path set
        comp = get_current_comp()
        with comp_lock_and_undo_chunk(comp, "Create Loader"):
            args = (-32768, -32768)
            tool = comp.AddTool("Loader", *args)
            tool["Clip"] = comp.ReverseMapPath(path)
            tool.SetAttrs({"TOOLB_NameSet": True, "TOOLS_Name": name})

            # Set global in point to start frame (if in version.data)
            start = self._get_start(context["version"], tool)
            loader_shift(tool, start, relative=False)

            imprint_container(
                tool,
                name=name,
                namespace=namespace,
                context=context,
                loader=self.__class__.__name__,
            )

    def switch(self, container, context):
        self.update(container, context)

    def update(self, container, context):
        """Update the Loader's path

        Fusion automatically tries to reset some variables when changing
        the loader's path to a new file. These automatic changes are to its
        inputs:
            - ClipTimeStart: Fusion reset to 0 if duration changes
              - We keep the trim in as close as possible to the previous value.
                When there are less frames then the amount of trim we reduce
                it accordingly.

            - ClipTimeEnd: Fusion reset to 0 if duration changes
              - We keep the trim out as close as possible to the previous value
                within new amount of frames after trim in (ClipTimeStart) has
                been set.

            - GlobalIn: Fusion reset to comp's global in if duration changes
              - 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.

            - HoldFirstFrame: Fusion resets this to 0
              - We preserve the value.

            - HoldLastFrame: Fusion resets this to 0
              - We preserve the value.

            - Reverse: Fusion resets to disabled if "Loop" is not enabled.
              - We preserve the value.

            - Depth: Fusion resets to "Format"
              - We preserve the value.

            - KeyCode: Fusion resets to ""
              - We preserve the value.

            - TimeCodeOffset: Fusion resets to 0
              - We preserve the value.

        """

        tool = container["_tool"]
        assert tool.ID == "Loader", "Must be Loader"
        comp = tool.Comp()

        repre_entity = context["representation"]
        path = self.filepath_from_context(context)

        # Get start frame from version data
        start = self._get_start(context["version"], tool)

        with comp_lock_and_undo_chunk(comp, "Update Loader"):
            # Update the loader's path whilst preserving some values
            with preserve_trim(tool, log=self.log):
                with preserve_inputs(
                    tool,
                    inputs=(
                        "HoldFirstFrame",
                        "HoldLastFrame",
                        "Reverse",
                        "Depth",
                        "KeyCode",
                        "TimeCodeOffset",
                    ),
                ):
                    tool["Clip"] = comp.ReverseMapPath(path)
                    tool.SetAttrs(
                        {
                            "TOOLB_NameSet": True,
                            "TOOLS_Name": repre_entity["context"]["product"][
                                "name"
                            ],
                        }
                    )

            # Set the global in to the start frame of the sequence
            global_in_changed = loader_shift(tool, start, relative=False)
            if global_in_changed:
                # Log this change to the user
                self.log.debug(
                    "Changed '%s' global in: %d" % (tool.Name, start)
                )

            # Update the imprinted representation
            tool.SetData("avalon.representation", repre_entity["id"])

    def remove(self, container):
        tool = container["_tool"]
        assert tool.ID == "Loader", "Must be Loader"
        comp = tool.Comp()

        with comp_lock_and_undo_chunk(comp, "Remove Loader"):
            tool.Delete()

    def _get_start(self, version_entity, tool):
        """Return real start frame of published files (incl. handles)"""
        attributes = version_entity["attrib"]

        # Get start frame directly with handle if it's in data
        start = attributes.get("frameStartHandle")
        if start is not None:
            return start

        # Get frame start without handles
        start = attributes.get("frameStart")
        if start is None:
            self.log.warning(
                "Missing start frame for version "
                "assuming starts at frame 0 for: "
                "{}".format(tool.Name)
            )
            return 0

        # Use `handleStart` if the data is available
        handle_start = attributes.get("handleStart")
        if handle_start:
            start -= handle_start

        return start