rename folder

openpype/hooks/pre_add_last_workfile_arg.py

@@ -0,0 +1,29 @@
+import os
+from openpype.lib import PreLaunchHook
+
+
+class AddLastWorkfileToLaunchArgs(PreLaunchHook):
+    """Add last workfile path to launch arguments.
+
+    This is not possible to do for all applications the same way.
+    """
+
+    order = 0
+    app_groups = ["maya", "nuke", "nukex", "hiero", "nukestudio"]
+
+    def execute(self):
+        if not self.data.get("start_last_workfile"):
+            self.log.info("It is set to not start last workfile on start.")
+            return
+
+        last_workfile = self.data.get("last_workfile_path")
+        if not last_workfile:
+            self.log.warning("Last workfile was not collected.")
+            return
+
+        if not os.path.exists(last_workfile):
+            self.log.info("Current context does not have any workfile yet.")
+            return
+
+        # Add path to workfile to arguments
+        self.launch_context.launch_args.append(last_workfile)

openpype/hooks/pre_global_host_data.py

@@ -0,0 +1,93 @@
+from openpype.api import Anatomy
+from openpype.lib import (
+    PreLaunchHook,
+    EnvironmentPrepData,
+    prepare_host_environments,
+    prepare_context_environments
+)
+
+import avalon.api
+
+
+class GlobalHostDataHook(PreLaunchHook):
+    order = -100
+
+    def execute(self):
+        """Prepare global objects to `data` that will be used for sure."""
+        if not self.application.is_host:
+            self.log.info(
+                "Skipped hook {}. Application is not marked as host.".format(
+                    self.__class__.__name__
+                )
+            )
+            return
+
+        self.prepare_global_data()
+
+        if not self.data.get("asset_doc"):
+            return
+
+        app = self.launch_context.application
+        temp_data = EnvironmentPrepData({
+            "project_name": self.data["project_name"],
+            "asset_name": self.data["asset_name"],
+            "task_name": self.data["task_name"],
+
+            "app": app,
+
+            "dbcon": self.data["dbcon"],
+            "project_doc": self.data["project_doc"],
+            "asset_doc": self.data["asset_doc"],
+
+            "anatomy": self.data["anatomy"],
+
+            "env": self.launch_context.env,
+
+            "log": self.log
+        })
+
+        prepare_host_environments(temp_data)
+        prepare_context_environments(temp_data)
+
+        temp_data.pop("log")
+
+        self.data.update(temp_data)
+
+    def prepare_global_data(self):
+        """Prepare global objects to `data` that will be used for sure."""
+        # Mongo documents
+        project_name = self.data.get("project_name")
+        if not project_name:
+            self.log.info(
+                "Skipping global data preparation."
+                " Key `project_name` was not found in launch context."
+            )
+            return
+
+        self.log.debug("Project name is set to \"{}\"".format(project_name))
+        # Anatomy
+        self.data["anatomy"] = Anatomy(project_name)
+
+        # Mongo connection
+        dbcon = avalon.api.AvalonMongoDB()
+        dbcon.Session["AVALON_PROJECT"] = project_name
+        dbcon.install()
+
+        self.data["dbcon"] = dbcon
+
+        # Project document
+        project_doc = dbcon.find_one({"type": "project"})
+        self.data["project_doc"] = project_doc
+
+        asset_name = self.data.get("asset_name")
+        if not asset_name:
+            self.log.warning(
+                "Asset name was not set. Skipping asset document query."
+            )
+            return
+
+        asset_doc = dbcon.find_one({
+            "type": "asset",
+            "name": asset_name
+        })
+        self.data["asset_doc"] = asset_doc

openpype/hooks/pre_non_python_host_launch.py

@@ -0,0 +1,47 @@
+import os
+
+from openpype.lib import (
+    PreLaunchHook,
+    get_pype_execute_args
+)
+
+from openpype import PACKAGE_DIR as PYPE_DIR
+
+
+class NonPythonHostHook(PreLaunchHook):
+    """Launch arguments preparation.
+
+    Non python host implementation do not launch host directly but use
+    python script which launch the host. For these cases it is necessary to
+    prepend python (or pype) executable and script path before application's.
+    """
+    app_groups = ["harmony", "photoshop", "aftereffects"]
+
+    def execute(self):
+        # Pop executable
+        executable_path = self.launch_context.launch_args.pop(0)
+
+        # Pop rest of launch arguments - There should not be other arguments!
+        remainders = []
+        while self.launch_context.launch_args:
+            remainders.append(self.launch_context.launch_args.pop(0))
+
+        script_path = os.path.join(
+            PYPE_DIR,
+            "scripts",
+            "non_python_host_launch.py"
+        )
+
+        new_launch_args = get_pype_execute_args(
+            "run", script_path, executable_path
+        )
+        # Add workfile path if exists
+        workfile_path = self.data["last_workfile_path"]
+        if os.path.exists(workfile_path):
+            new_launch_args.append(workfile_path)
+
+        # Append as whole list as these areguments should not be separated
+        self.launch_context.launch_args.append(new_launch_args)
+
+        if remainders:
+            self.launch_context.launch_args.extend(remainders)

openpype/hooks/pre_python2_vendor.py

@@ -0,0 +1,34 @@
+import os
+from openpype.lib import PreLaunchHook
+
+
+class PrePython2Vendor(PreLaunchHook):
+    """Prepend python 2 dependencies for py2 hosts."""
+    # WARNING This hook will probably be deprecated in Pype 3 - kept for test
+    order = 10
+    app_groups = ["hiero", "nuke", "nukex"]
+
+    def execute(self):
+        # Prepare vendor dir path
+        self.log.info("adding global python 2 vendor")
+        pype_root = os.getenv("OPENPYPE_ROOT")
+        python_2_vendor = os.path.join(
+            pype_root,
+            "pype",
+            "vendor",
+            "python",
+            "python_2"
+        )
+
+        # Add Python 2 modules
+        python_paths = [
+            python_2_vendor
+        ]
+
+        # Load PYTHONPATH from current launch context
+        python_path = self.launch_context.env.get("PYTHONPATH")
+        if python_path:
+            python_paths.append(python_path)
+
+        # Set new PYTHONPATH to launch context environments
+        self.launch_context.env["PYTHONPATH"] = os.pathsep.join(python_paths)

openpype/hooks/pre_with_windows_shell.py

@@ -0,0 +1,24 @@
+import os
+from openpype.lib import PreLaunchHook
+
+
+class LaunchWithWindowsShell(PreLaunchHook):
+    """Add shell command before executable.
+
+    Some hosts have issues when are launched directly from python in that case
+    it is possible to prepend shell executable which will trigger process
+    instead.
+    """
+
+    order = 10
+    app_groups = ["resolve", "nuke", "nukex", "hiero", "nukestudio"]
+    platforms = ["windows"]
+
+    def execute(self):
+        # Get comspec which is cmd.exe in most cases.
+        comspec = os.environ.get("COMSPEC", "cmd.exe")
+        # Add comspec to arguments list and add "/k"
+        new_args = [comspec, "/c"]
+        new_args.extend(self.launch_context.launch_args)
+        # Replace launch args with new one
+        self.launch_context.launch_args = new_args