pipeline

class HoudiniHost(HostBase, IWorkfileHost, ILoadHost, IPublishHost):
    name = "houdini"

    def __init__(self):
        super(HoudiniHost, self).__init__()
        self._op_events = {}
        self._has_been_setup = False

    def get_app_information(self):
        from ayon_core.host import ApplicationInformation

        hou_name = hou.applicationName()
        license_name = hou.licenseCategory().name()
        if hou_name == "houdinicore":
            app_name = "Houdini Core"

        elif hou_name == "houdinifx":
            app_name = "Houdini FX"

        elif hou_name == "happrentice":
            app_name = "Houdini"
        else:
            print(f"Unknown houdini app name: {hou_name}")
            app_name = "Houdini"

        full_app_name = f"{app_name} {license_name}"

        return ApplicationInformation(
            app_name=full_app_name,
            app_version=hou.applicationVersionString(),
        )

    def install(self):
        pyblish.api.register_host("houdini")
        pyblish.api.register_host("hython")
        pyblish.api.register_host("hpython")

        pyblish.api.register_plugin_path(PUBLISH_PATH)
        register_loader_plugin_path(LOAD_PATH)
        register_creator_plugin_path(CREATE_PATH)
        register_inventory_action_path(INVENTORY_PATH)
        register_workfile_build_plugin_path(WORKFILE_BUILD_PATH)

        log.info("Installing callbacks ... ")
        # register_event_callback("init", on_init)
        self._register_callbacks()
        register_event_callback("workfile.save.before", before_workfile_save)
        register_event_callback("before.save", before_save)
        register_event_callback("save", on_save)
        register_event_callback("open", on_open)
        register_event_callback("new", on_new)
        register_event_callback("taskChanged", on_task_changed)

        self._has_been_setup = True

        # Manually call on_new callback as it doesn't get called when AYON
        # launches for the first time on a context, only when going to
        # File -> New
        on_new()

        if not IS_HEADLESS:
            import hdefereval  # noqa, hdefereval is only available in ui mode
            # Defer generation of shelves due to issue on Windows where shelf
            # initialization during start up delays Houdini UI by minutes
            # making it extremely slow to launch.
            hdefereval.executeDeferred(shelves.generate_shelves)
            hdefereval.executeDeferred(creator_node_shelves.install)
            if env_value_to_bool("AYON_WORKFILE_TOOL_ON_START"):
                hdefereval.executeDeferred(
                    lambda: host_tools.show_workfiles(
                        parent=hou.qt.mainWindow()
                    )
                )

    def workfile_has_unsaved_changes(self):
        return hou.hipFile.hasUnsavedChanges()

    def get_workfile_extensions(self):
        return [".hip", ".hiplc", ".hipnc"]

    def save_workfile(self, dst_path=None):
        # Force forwards slashes to avoid segfault
        if dst_path:
            dst_path = dst_path.replace("\\", "/")
        hou.hipFile.save(file_name=dst_path,
                         save_to_recent_files=True)
        return dst_path

    def open_workfile(self, filepath):
        # Force forwards slashes to avoid segfault
        filepath = filepath.replace("\\", "/")

        try:
            hou.hipFile.load(filepath,
                             suppress_save_prompt=True,
                             ignore_load_warnings=False)
        except hou.LoadWarning as exc:
            log.warning(exc)

        return filepath

    def get_current_workfile(self):
        current_filepath = hou.hipFile.path()
        if (os.path.basename(current_filepath) == "untitled.hip" and
                not os.path.exists(current_filepath)):
            # By default a new scene in houdini is saved in the current
            # working directory as "untitled.hip" so we need to capture
            # that and consider it 'not saved' when it's in that state.
            return None

        return current_filepath

    def get_containers(self):
        return ls()

    def _register_callbacks(self):
        for event in self._op_events.copy().values():
            if event is None:
                continue

            try:
                hou.hipFile.removeEventCallback(event)
            except RuntimeError as e:
                log.info(e)

        self._op_events[on_file_event_callback] = hou.hipFile.addEventCallback(
            on_file_event_callback
        )

    @staticmethod
    def create_context_node():
        """Helper for creating context holding node.

        Returns:
            hou.Node: context node

        """
        parent_name, name  = CONTEXT_CONTAINER.rsplit("/", 1)
        obj_network = hou.node(parent_name)
        op_ctx = obj_network.createNode("subnet",
                                        node_name=name,
                                        run_init_scripts=False,
                                        load_contents=False)

        op_ctx.moveToGoodPosition()
        op_ctx.setBuiltExplicitly(False)
        op_ctx.setCreatorState("AYON")
        op_ctx.setComment("AYON node to hold context metadata")
        op_ctx.setColor(hou.Color((0.081, 0.798, 0.810)))
        op_ctx.setDisplayFlag(False)
        op_ctx.hide(True)
        return op_ctx

    @staticmethod
    def get_context_node() -> "Optional[hou.OpNode]":
        return (
            hou.node(CONTEXT_CONTAINER)
            or hou.node(LEGACY_CONTEXT_CONTAINER)
        )

    def update_context_data(self, data, changes):
        context_node = self.get_context_node() or self.create_context_node()
        lib.imprint(context_node, data, update=True)

    def get_context_data(self) -> dict:
        context_node = self.get_context_node()
        if not context_node:
            return {}
        return lib.read(context_node)