From bb10fdd041c499f30e5ffa7dd4069828b9f42239 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Mon, 1 Aug 2022 18:00:14 +0200
Subject: [PATCH 01/16] :rotating_light: f-strings and cosmetic issues

---
 igniter/bootstrap_repos.py | 10 +++----
 start.py                   | 55 +++++++++++++++++---------------------
 tools/create_zip.py        |  2 +-
 3 files changed, 29 insertions(+), 38 deletions(-)

diff --git a/igniter/bootstrap_repos.py b/igniter/bootstrap_repos.py
index 08333885c0..8888440f90 100644
--- a/igniter/bootstrap_repos.py
+++ b/igniter/bootstrap_repos.py
@@ -122,7 +122,7 @@ class OpenPypeVersion(semver.VersionInfo):
         if self.staging:
             if kwargs.get("build"):
                 if "staging" not in kwargs.get("build"):
-                    kwargs["build"] = "{}-staging".format(kwargs.get("build"))
+                    kwargs["build"] = f"{kwargs.get('build')}-staging"
             else:
                 kwargs["build"] = "staging"
 
@@ -136,8 +136,7 @@ class OpenPypeVersion(semver.VersionInfo):
         return bool(result and self.staging == other.staging)
 
     def __repr__(self):
-        return "<{}: {} - path={}>".format(
-            self.__class__.__name__, str(self), self.path)
+        return f"<{self.__class__.__name__}: {str(self)} - path={self.path}>"
 
     def __lt__(self, other: OpenPypeVersion):
         result = super().__lt__(other)
@@ -232,10 +231,7 @@ class OpenPypeVersion(semver.VersionInfo):
         return openpype_version
 
     def __hash__(self):
-        if self.path:
-            return hash(self.path)
-        else:
-            return hash(str(self))
+        return hash(self.path) if self.path else hash(str(self))
 
     @staticmethod
     def is_version_in_dir(
diff --git a/start.py b/start.py
index cbf8ffd178..37cc4c063d 100644
--- a/start.py
+++ b/start.py
@@ -187,9 +187,8 @@ else:
 if "--headless" in sys.argv:
     os.environ["OPENPYPE_HEADLESS_MODE"] = "1"
     sys.argv.remove("--headless")
-else:
-    if os.getenv("OPENPYPE_HEADLESS_MODE") != "1":
-        os.environ.pop("OPENPYPE_HEADLESS_MODE", None)
+elif os.getenv("OPENPYPE_HEADLESS_MODE") != "1":
+    os.environ.pop("OPENPYPE_HEADLESS_MODE", None)
 
 # Enabled logging debug mode when "--debug" is passed
 if "--verbose" in sys.argv:
@@ -203,8 +202,8 @@ if "--verbose" in sys.argv:
         value = sys.argv.pop(idx)
     else:
         raise RuntimeError((
-            "Expect value after \"--verbose\" argument. {}"
-        ).format(expected_values))
+            f"Expect value after \"--verbose\" argument. {expected_values}"
+        ))
 
     log_level = None
     low_value = value.lower()
@@ -225,8 +224,9 @@ if "--verbose" in sys.argv:
 
     if log_level is None:
         raise RuntimeError((
-            "Unexpected value after \"--verbose\" argument \"{}\". {}"
-        ).format(value, expected_values))
+            "Unexpected value after \"--verbose\" "
+            f"argument \"{value}\". {expected_values}"
+        ))
 
     os.environ["OPENPYPE_LOG_LEVEL"] = str(log_level)
 
@@ -336,34 +336,33 @@ def run_disk_mapping_commands(settings):
         destination = destination.rstrip('/')
         source = source.rstrip('/')
 
-        if low_platform == "windows":
-            args = ["subst", destination, source]
-        elif low_platform == "darwin":
-            scr = "do shell script \"ln -s {} {}\" with administrator privileges".format(source, destination)  # noqa: E501
+        if low_platform == "darwin":
+            scr = f'do shell script "ln -s {source} {destination}" with administrator privileges'  # noqa
+
             args = ["osascript", "-e", scr]
+        elif low_platform == "windows":
+            args = ["subst", destination, source]
         else:
             args = ["sudo", "ln", "-s", source, destination]
 
-        _print("disk mapping args:: {}".format(args))
+        _print(f"*** disk mapping arguments: {args}")
         try:
             if not os.path.exists(destination):
                 output = subprocess.Popen(args)
                 if output.returncode and output.returncode != 0:
-                    exc_msg = "Executing was not successful: \"{}\"".format(
-                        args)
+                    exc_msg = f'Executing was not successful: "{args}"'
 
                     raise RuntimeError(exc_msg)
         except TypeError as exc:
-            _print("Error {} in mapping drive {}, {}".format(str(exc),
-                                                             source,
-                                                             destination))
+            _print(
+                f"Error {str(exc)} in mapping drive {source}, {destination}")
             raise
 
 
 def set_avalon_environments():
     """Set avalon specific environments.
 
-    These are non modifiable environments for avalon workflow that must be set
+    These are non-modifiable environments for avalon workflow that must be set
     before avalon module is imported because avalon works with globals set with
     environment variables.
     """
@@ -508,7 +507,7 @@ def _process_arguments() -> tuple:
                 )
                 if m and m.group('version'):
                     use_version = m.group('version')
-                    _print(">>> Requested version [ {} ]".format(use_version))
+                    _print(f">>> Requested version [ {use_version} ]")
                     if "+staging" in use_version:
                         use_staging = True
                     break
@@ -614,8 +613,8 @@ def _determine_mongodb() -> str:
             try:
                 openpype_mongo = bootstrap.secure_registry.get_item(
                     "openPypeMongo")
-            except ValueError:
-                raise RuntimeError("Missing MongoDB url")
+            except ValueError as e:
+                raise RuntimeError("Missing MongoDB url") from e
 
     return openpype_mongo
 
@@ -816,11 +815,8 @@ def _bootstrap_from_code(use_version, use_staging):
                 use_version, use_staging
             )
             if version_to_use is None:
-                raise OpenPypeVersionNotFound(
-                    "Requested version \"{}\" was not found.".format(
-                        use_version
-                    )
-                )
+                raise OpenPypeVersionIncompatible(
+                    f"Requested version \"{use_version}\" was not found.")
         else:
             # Staging version should be used
             version_to_use = bootstrap.find_latest_openpype_version(
@@ -906,7 +902,7 @@ def _boot_validate_versions(use_version, local_version):
         use_version, openpype_versions
     )
     valid, message = bootstrap.validate_openpype_version(version_path)
-    _print("{}{}".format(">>> " if valid else "!!! ", message))
+    _print(f'{">>> " if valid else "!!! "}{message}')
 
 
 def _boot_print_versions(use_staging, local_version, openpype_root):
@@ -1043,7 +1039,7 @@ def boot():
         if not result[0]:
             _print(f"!!! Invalid version: {result[1]}")
             sys.exit(1)
-        _print(f"--- version is valid")
+        _print("--- version is valid")
     else:
         try:
             version_path = _bootstrap_from_code(use_version, use_staging)
@@ -1164,8 +1160,7 @@ def get_info(use_staging=None) -> list:
     formatted = []
     for info in inf:
         padding = (maximum - len(info[0])) + 1
-        formatted.append(
-            "... {}:{}[ {} ]".format(info[0], " " * padding, info[1]))
+        formatted.append(f'... {info[0]}:{" " * padding}[ {info[1]} ]')
     return formatted
 
 
diff --git a/tools/create_zip.py b/tools/create_zip.py
index 2fc351469a..6392428f58 100644
--- a/tools/create_zip.py
+++ b/tools/create_zip.py
@@ -61,7 +61,7 @@ def _print(msg: str, message_type: int = 0) -> None:
     else:
         header = term.darkolivegreen3("--- ")
 
-    print("{}{}".format(header, msg))
+    print(f"{header}{msg}")
 
 
 if __name__ == "__main__":

From a9f910ac227fd0f90a589ba9035d232c0c62e6ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Mon, 1 Aug 2022 18:01:03 +0200
Subject: [PATCH 02/16] :recycle: add openpype version env var to deadline job

---
 .../deadline/plugins/publish/submit_aftereffects_deadline.py   | 3 ++-
 .../deadline/plugins/publish/submit_harmony_deadline.py        | 3 ++-
 .../deadline/plugins/publish/submit_houdini_remote_publish.py  | 1 +
 .../deadline/plugins/publish/submit_houdini_render_deadline.py | 1 +
 .../modules/deadline/plugins/publish/submit_maya_deadline.py   | 3 ++-
 .../plugins/publish/submit_maya_remote_publish_deadline.py     | 3 ++-
 .../modules/deadline/plugins/publish/submit_nuke_deadline.py   | 3 ++-
 .../modules/deadline/plugins/publish/submit_publish_job.py     | 3 ++-
 8 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/openpype/modules/deadline/plugins/publish/submit_aftereffects_deadline.py b/openpype/modules/deadline/plugins/publish/submit_aftereffects_deadline.py
index de8df3dd9e..c55f85c8da 100644
--- a/openpype/modules/deadline/plugins/publish/submit_aftereffects_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_aftereffects_deadline.py
@@ -80,7 +80,8 @@ class AfterEffectsSubmitDeadline(
             "AVALON_TASK",
             "AVALON_APP_NAME",
             "OPENPYPE_DEV",
-            "OPENPYPE_LOG_NO_COLORS"
+            "OPENPYPE_LOG_NO_COLORS",
+            "OPENPYPE_VERSION"
         ]
         # Add mongo url if it's enabled
         if self._instance.context.data.get("deadlinePassMongoUrl"):
diff --git a/openpype/modules/deadline/plugins/publish/submit_harmony_deadline.py b/openpype/modules/deadline/plugins/publish/submit_harmony_deadline.py
index a1ee5e0957..3f9c09b592 100644
--- a/openpype/modules/deadline/plugins/publish/submit_harmony_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_harmony_deadline.py
@@ -274,7 +274,8 @@ class HarmonySubmitDeadline(
             "AVALON_TASK",
             "AVALON_APP_NAME",
             "OPENPYPE_DEV",
-            "OPENPYPE_LOG_NO_COLORS"
+            "OPENPYPE_LOG_NO_COLORS",
+            "OPENPYPE_VERSION"
         ]
         # Add mongo url if it's enabled
         if self._instance.context.data.get("deadlinePassMongoUrl"):
diff --git a/openpype/modules/deadline/plugins/publish/submit_houdini_remote_publish.py b/openpype/modules/deadline/plugins/publish/submit_houdini_remote_publish.py
index fdf67b51bc..95856137e2 100644
--- a/openpype/modules/deadline/plugins/publish/submit_houdini_remote_publish.py
+++ b/openpype/modules/deadline/plugins/publish/submit_houdini_remote_publish.py
@@ -130,6 +130,7 @@ class HoudiniSubmitPublishDeadline(pyblish.api.ContextPlugin):
             # this application with so the Render Slave can build its own
             # similar environment using it, e.g. "houdini17.5;pluginx2.3"
             "AVALON_TOOLS",
+            "OPENPYPE_VERSION"
         ]
         # Add mongo url if it's enabled
         if context.data.get("deadlinePassMongoUrl"):
diff --git a/openpype/modules/deadline/plugins/publish/submit_houdini_render_deadline.py b/openpype/modules/deadline/plugins/publish/submit_houdini_render_deadline.py
index aca88c7440..beda753723 100644
--- a/openpype/modules/deadline/plugins/publish/submit_houdini_render_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_houdini_render_deadline.py
@@ -101,6 +101,7 @@ class HoudiniSubmitRenderDeadline(pyblish.api.InstancePlugin):
             # this application with so the Render Slave can build its own
             # similar environment using it, e.g. "maya2018;vray4.x;yeti3.1.9"
             "AVALON_TOOLS",
+            "OPENPYPE_VERSION"
         ]
         # Add mongo url if it's enabled
         if context.data.get("deadlinePassMongoUrl"):
diff --git a/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py b/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py
index 145b6d795f..f253ceb21a 100644
--- a/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py
@@ -525,7 +525,8 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
             "AVALON_TASK",
             "AVALON_APP_NAME",
             "OPENPYPE_DEV",
-            "OPENPYPE_LOG_NO_COLORS"
+            "OPENPYPE_LOG_NO_COLORS",
+            "OPENPYPE_VERSION"
         ]
         # Add mongo url if it's enabled
         if instance.context.data.get("deadlinePassMongoUrl"):
diff --git a/openpype/modules/deadline/plugins/publish/submit_maya_remote_publish_deadline.py b/openpype/modules/deadline/plugins/publish/submit_maya_remote_publish_deadline.py
index 57572fcb24..9b1852392b 100644
--- a/openpype/modules/deadline/plugins/publish/submit_maya_remote_publish_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_maya_remote_publish_deadline.py
@@ -102,7 +102,8 @@ class MayaSubmitRemotePublishDeadline(pyblish.api.InstancePlugin):
         keys = [
             "FTRACK_API_USER",
             "FTRACK_API_KEY",
-            "FTRACK_SERVER"
+            "FTRACK_SERVER",
+            "OPENPYPE_VERSION"
         ]
         environment = dict({key: os.environ[key] for key in keys
                             if key in os.environ}, **legacy_io.Session)
diff --git a/openpype/modules/deadline/plugins/publish/submit_nuke_deadline.py b/openpype/modules/deadline/plugins/publish/submit_nuke_deadline.py
index 93fb511a34..a328c3633d 100644
--- a/openpype/modules/deadline/plugins/publish/submit_nuke_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_nuke_deadline.py
@@ -261,7 +261,8 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin):
             "PYBLISHPLUGINPATH",
             "NUKE_PATH",
             "TOOL_ENV",
-            "FOUNDRY_LICENSE"
+            "FOUNDRY_LICENSE",
+            "OPENPYPE_VERSION"
         ]
         # Add mongo url if it's enabled
         if instance.context.data.get("deadlinePassMongoUrl"):
diff --git a/openpype/modules/deadline/plugins/publish/submit_publish_job.py b/openpype/modules/deadline/plugins/publish/submit_publish_job.py
index 43ea64e565..5c7998465b 100644
--- a/openpype/modules/deadline/plugins/publish/submit_publish_job.py
+++ b/openpype/modules/deadline/plugins/publish/submit_publish_job.py
@@ -141,7 +141,8 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
         "OPENPYPE_USERNAME",
         "OPENPYPE_RENDER_JOB",
         "OPENPYPE_PUBLISH_JOB",
-        "OPENPYPE_MONGO"
+        "OPENPYPE_MONGO",
+        "OPENPYPE_VERSION"
     ]
 
     # custom deadline attributes

From 0e126a2d829e814d39747b4073cac2fb2cbc7b45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Mon, 1 Aug 2022 18:01:25 +0200
Subject: [PATCH 03/16] :recycle: handle multiple versions

---
 igniter/tools.py |  5 +++
 openpype/cli.py  | 23 ++++++++++++++
 start.py         | 83 ++++++++++++++++++++++++++++++++----------------
 3 files changed, 84 insertions(+), 27 deletions(-)

diff --git a/igniter/tools.py b/igniter/tools.py
index 57159b5e52..a9d592acf0 100644
--- a/igniter/tools.py
+++ b/igniter/tools.py
@@ -21,6 +21,11 @@ class OpenPypeVersionNotFound(Exception):
     pass
 
 
+class OpenPypeVersionIncompatible(Exception):
+    """OpenPype version is not compatible with the installed one (build)."""
+    pass
+
+
 def should_add_certificate_path_to_mongo_url(mongo_url):
     """Check if should add ca certificate to mongo url.
 
diff --git a/openpype/cli.py b/openpype/cli.py
index 9a2dfaa141..ffe288040e 100644
--- a/openpype/cli.py
+++ b/openpype/cli.py
@@ -443,3 +443,26 @@ def interactive():
         __version__, sys.version, sys.platform
     )
     code.interact(banner)
+
+
+@main.command()
+@click.option("--build", help="Print only build version",
+              is_flag=True, default=False)
+def version(build):
+    """Print OpenPype version."""
+
+    from openpype.version import __version__
+    from igniter.bootstrap_repos import BootstrapRepos, OpenPypeVersion
+    from pathlib import Path
+    import os
+
+    if getattr(sys, 'frozen', False):
+        local_version = BootstrapRepos.get_version(
+            Path(os.getenv("OPENPYPE_ROOT")))
+    else:
+        local_version = OpenPypeVersion.get_installed_version_str()
+
+    if build:
+        print(local_version)
+        return
+    print(f"{__version__} (booted: {local_version})")
diff --git a/start.py b/start.py
index 37cc4c063d..5cdffafb6e 100644
--- a/start.py
+++ b/start.py
@@ -103,6 +103,9 @@ import site
 import distutils.spawn
 from pathlib import Path
 
+
+silent_mode = False
+
 # OPENPYPE_ROOT is variable pointing to build (or code) directory
 # WARNING `OPENPYPE_ROOT` must be defined before igniter import
 # - igniter changes cwd which cause that filepath of this script won't lead
@@ -138,40 +141,44 @@ if sys.__stdout__:
     term = blessed.Terminal()
 
     def _print(message: str):
+        if silent_mode:
+            return
         if message.startswith("!!! "):
-            print("{}{}".format(term.orangered2("!!! "), message[4:]))
+            print(f'{term.orangered2("!!! ")}{message[4:]}')
             return
         if message.startswith(">>> "):
-            print("{}{}".format(term.aquamarine3(">>> "), message[4:]))
+            print(f'{term.aquamarine3(">>> ")}{message[4:]}')
             return
         if message.startswith("--- "):
-            print("{}{}".format(term.darkolivegreen3("--- "), message[4:]))
+            print(f'{term.darkolivegreen3("--- ")}{message[4:]}')
             return
         if message.startswith("*** "):
-            print("{}{}".format(term.gold("*** "), message[4:]))
+            print(f'{term.gold("*** ")}{message[4:]}')
             return
         if message.startswith("  - "):
-            print("{}{}".format(term.wheat("  - "), message[4:]))
+            print(f'{term.wheat("  - ")}{message[4:]}')
             return
         if message.startswith("  . "):
-            print("{}{}".format(term.tan("  . "), message[4:]))
+            print(f'{term.tan("  . ")}{message[4:]}')
             return
         if message.startswith("     - "):
-            print("{}{}".format(term.seagreen3("     - "), message[7:]))
+            print(f'{term.seagreen3("     - ")}{message[7:]}')
             return
         if message.startswith("     ! "):
-            print("{}{}".format(term.goldenrod("     ! "), message[7:]))
+            print(f'{term.goldenrod("     ! ")}{message[7:]}')
             return
         if message.startswith("     * "):
-            print("{}{}".format(term.aquamarine1("     * "), message[7:]))
+            print(f'{term.aquamarine1("     * ")}{message[7:]}')
             return
         if message.startswith("    "):
-            print("{}{}".format(term.darkseagreen3("    "), message[4:]))
+            print(f'{term.darkseagreen3("    ")}{message[4:]}')
             return
 
         print(message)
 else:
     def _print(message: str):
+        if silent_mode:
+            return
         print(message)
 
 
@@ -242,13 +249,14 @@ from igniter.tools import (
     get_openpype_global_settings,
     get_openpype_path_from_settings,
     validate_mongo_connection,
-    OpenPypeVersionNotFound
+    OpenPypeVersionNotFound,
+    OpenPypeVersionIncompatible
 )  # noqa
 from igniter.bootstrap_repos import OpenPypeVersion  # noqa: E402
 
 bootstrap = BootstrapRepos()
 silent_commands = {"run", "igniter", "standalonepublisher",
-                   "extractenvironments"}
+                   "extractenvironments", "version"}
 
 
 def list_versions(openpype_versions: list, local_version=None) -> None:
@@ -686,40 +694,47 @@ def _find_frozen_openpype(use_version: str = None,
         # Specific version is defined
         if use_version.lower() == "latest":
             # Version says to use latest version
-            _print("Finding latest version defined by use version")
+            _print(">>> Finding latest version defined by use version")
             openpype_version = bootstrap.find_latest_openpype_version(
-                use_staging
+                use_staging, compatible_with=installed_version
             )
         else:
-            _print("Finding specified version \"{}\"".format(use_version))
+            _print(f">>> Finding specified version \"{use_version}\"")
             openpype_version = bootstrap.find_openpype_version(
                 use_version, use_staging
             )
 
         if openpype_version is None:
             raise OpenPypeVersionNotFound(
-                "Requested version \"{}\" was not found.".format(
-                    use_version
-                )
+                f"Requested version \"{use_version}\" was not found."
             )
 
+        if not openpype_version.is_compatible(installed_version):
+            raise OpenPypeVersionIncompatible((
+                f"Requested version \"{use_version}\" is not compatible "
+                f"with installed version \"{installed_version}\""
+            ))
+
     elif studio_version is not None:
         # Studio has defined a version to use
-        _print("Finding studio version \"{}\"".format(studio_version))
+        _print(f">>> Finding studio version \"{studio_version}\"")
         openpype_version = bootstrap.find_openpype_version(
-            studio_version, use_staging
+            studio_version, use_staging, compatible_with=installed_version
         )
         if openpype_version is None:
             raise OpenPypeVersionNotFound((
-                "Requested OpenPype version \"{}\" defined by settings"
+                "Requested OpenPype version "
+                f"\"{studio_version}\" defined by settings"
                 " was not found."
-            ).format(studio_version))
+            ))
 
     else:
         # Default behavior to use latest version
-        _print("Finding latest version")
+        _print((
+            ">>> Finding latest version compatible "
+            f"with [ {installed_version} ]"))
         openpype_version = bootstrap.find_latest_openpype_version(
-            use_staging
+            use_staging, compatible_with=installed_version
         )
         if openpype_version is None:
             if use_staging:
@@ -800,7 +815,7 @@ def _bootstrap_from_code(use_version, use_staging):
 
     if getattr(sys, 'frozen', False):
         local_version = bootstrap.get_version(Path(_openpype_root))
-        switch_str = f" - will switch to {use_version}" if use_version else ""
+        switch_str = f" - will switch to {use_version}" if use_version and use_version != local_version else ""  # noqa
         _print(f"  - booting version: {local_version}{switch_str}")
         assert local_version
     else:
@@ -913,13 +928,24 @@ def _boot_print_versions(use_staging, local_version, openpype_root):
         _print("--- This will list only staging versions detected.")
         _print("    To see other version, omit --use-staging argument.")
 
-    openpype_versions = bootstrap.find_openpype(include_zips=True,
-                                                staging=use_staging)
     if getattr(sys, 'frozen', False):
         local_version = bootstrap.get_version(Path(openpype_root))
     else:
         local_version = OpenPypeVersion.get_installed_version_str()
 
+    compatible_with = OpenPypeVersion(version=local_version)
+    if "--all" in sys.argv:
+        compatible_with = None
+        _print("--- Showing all version (even those not compatible).")
+    else:
+        _print(("--- Showing only compatible versions "
+                f"with [ {compatible_with.major}.{compatible_with.minor} ]"))
+
+    openpype_versions = bootstrap.find_openpype(
+        include_zips=True,
+        staging=use_staging,
+        compatible_with=compatible_with)
+
     list_versions(openpype_versions, local_version)
 
 
@@ -936,6 +962,9 @@ def _boot_handle_missing_version(local_version, use_staging, message):
 
 def boot():
     """Bootstrap OpenPype."""
+    global silent_mode
+    if any(arg in silent_commands for arg in sys.argv):
+        silent_mode = True
 
     # ------------------------------------------------------------------------
     # Set environment to OpenPype root path

From 9205d4bde12baf8901a2ba675157cc0b4ad65919 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Mon, 1 Aug 2022 18:02:24 +0200
Subject: [PATCH 04/16] :recycle: changes in bootstrapping for multiple
 versions

---
 igniter/bootstrap_repos.py | 196 ++++++++++++++++++++++++++++++-------
 1 file changed, 158 insertions(+), 38 deletions(-)

diff --git a/igniter/bootstrap_repos.py b/igniter/bootstrap_repos.py
index 8888440f90..47f2525952 100644
--- a/igniter/bootstrap_repos.py
+++ b/igniter/bootstrap_repos.py
@@ -380,7 +380,8 @@ class OpenPypeVersion(semver.VersionInfo):
 
     @classmethod
     def get_local_versions(
-        cls, production: bool = None, staging: bool = None
+        cls, production: bool = None,
+        staging: bool = None, compatible_with: OpenPypeVersion = None
     ) -> List:
         """Get all versions available on this machine.
 
@@ -390,6 +391,8 @@ class OpenPypeVersion(semver.VersionInfo):
         Args:
             production (bool): Return production versions.
             staging (bool): Return staging versions.
+            compatible_with (OpenPypeVersion): Return only those compatible
+                with specified version.
         """
         # Return all local versions if arguments are set to None
         if production is None and staging is None:
@@ -406,10 +409,19 @@ class OpenPypeVersion(semver.VersionInfo):
         if not production and not staging:
             return []
 
+        # DEPRECATED: backwards compatible way to look for versions in root
         dir_to_search = Path(user_data_dir("openpype", "pypeclub"))
         versions = OpenPypeVersion.get_versions_from_directory(
-            dir_to_search
+            dir_to_search, compatible_with=compatible_with
         )
+        if compatible_with:
+            dir_to_search = Path(
+                user_data_dir("openpype", "pypeclub")) / f"{compatible_with.major}.{compatible_with.minor}"  # noqa
+            versions += OpenPypeVersion.get_versions_from_directory(
+                dir_to_search, compatible_with=compatible_with
+            )
+
+
         filtered_versions = []
         for version in versions:
             if version.is_staging():
@@ -421,7 +433,8 @@ class OpenPypeVersion(semver.VersionInfo):
 
     @classmethod
     def get_remote_versions(
-        cls, production: bool = None, staging: bool = None
+        cls, production: bool = None,
+        staging: bool = None, compatible_with: OpenPypeVersion = None
     ) -> List:
         """Get all versions available in OpenPype Path.
 
@@ -431,6 +444,8 @@ class OpenPypeVersion(semver.VersionInfo):
         Args:
             production (bool): Return production versions.
             staging (bool): Return staging versions.
+            compatible_with (OpenPypeVersion): Return only those compatible
+                with specified version.
         """
         # Return all local versions if arguments are set to None
         if production is None and staging is None:
@@ -464,7 +479,14 @@ class OpenPypeVersion(semver.VersionInfo):
         if not dir_to_search:
             return []
 
-        versions = cls.get_versions_from_directory(dir_to_search)
+        # DEPRECATED: look for version in root directory
+        versions = cls.get_versions_from_directory(
+            dir_to_search, compatible_with=compatible_with)
+        if compatible_with:
+            dir_to_search = dir_to_search / f"{compatible_with.major}.{compatible_with.minor}"  # noqa
+            versions += cls.get_versions_from_directory(
+                dir_to_search, compatible_with=compatible_with)
+
         filtered_versions = []
         for version in versions:
             if version.is_staging():
@@ -475,11 +497,15 @@ class OpenPypeVersion(semver.VersionInfo):
         return list(sorted(set(filtered_versions)))
 
     @staticmethod
-    def get_versions_from_directory(openpype_dir: Path) -> List:
+    def get_versions_from_directory(
+            openpype_dir: Path,
+            compatible_with: OpenPypeVersion = None) -> List:
         """Get all detected OpenPype versions in directory.
 
         Args:
             openpype_dir (Path): Directory to scan.
+            compatible_with (OpenPypeVersion): Return only versions compatible
+                with build version specified as OpenPypeVersion.
 
         Returns:
             list of OpenPypeVersion
@@ -514,6 +540,10 @@ class OpenPypeVersion(semver.VersionInfo):
                 )[0]:
                     continue
 
+                if compatible_with and not detected_version.is_compatible(
+                        compatible_with):
+                    continue
+
                 detected_version.path = item
                 _openpype_versions.append(detected_version)
 
@@ -545,8 +575,9 @@ class OpenPypeVersion(semver.VersionInfo):
     def get_latest_version(
         staging: bool = False,
         local: bool = None,
-        remote: bool = None
-    ) -> OpenPypeVersion:
+        remote: bool = None,
+        compatible_with: OpenPypeVersion = None
+    ) -> Union[OpenPypeVersion, None]:
         """Get latest available version.
 
         The version does not contain information about path and source.
@@ -564,6 +595,9 @@ class OpenPypeVersion(semver.VersionInfo):
             staging (bool, optional): List staging versions if True.
             local (bool, optional): List local versions if True.
             remote (bool, optional): List remote versions if True.
+            compatible_with (OpenPypeVersion, optional) Return only version
+                compatible with compatible_with.
+
         """
         if local is None and remote is None:
             local = True
@@ -594,7 +628,12 @@ class OpenPypeVersion(semver.VersionInfo):
             return None
 
         all_versions.sort()
-        return all_versions[-1]
+        latest_version: OpenPypeVersion
+        latest_version = all_versions[-1]
+        if compatible_with and not latest_version.is_compatible(
+                compatible_with):
+            return None
+        return latest_version
 
     @classmethod
     def get_expected_studio_version(cls, staging=False, global_settings=None):
@@ -617,6 +656,21 @@ class OpenPypeVersion(semver.VersionInfo):
             return None
         return OpenPypeVersion(version=result)
 
+    def is_compatible(self, version: OpenPypeVersion):
+        """Test build compatibility.
+
+        This will simply compare major and minor versions (ignoring patch
+        and the rest).
+
+        Args:
+            version (OpenPypeVersion): Version to check compatibility with.
+
+        Returns:
+            bool: if the version is compatible
+
+        """
+        return self.major == version.major and self.minor == version.minor
+
 
 class BootstrapRepos:
     """Class for bootstrapping local OpenPype installation.
@@ -737,8 +791,9 @@ class BootstrapRepos:
             return
 
         # create destination directory
-        if not self.data_dir.exists():
-            self.data_dir.mkdir(parents=True)
+        destination = self.data_dir / f"{installed_version.major}.{installed_version.minor}"  # noqa
+        if not destination.exists():
+            destination.mkdir(parents=True)
 
         # create zip inside temporary directory.
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -766,7 +821,9 @@ class BootstrapRepos:
             Path to moved zip on success.
 
         """
-        destination = self.data_dir / zip_file.name
+        version = OpenPypeVersion.version_in_str(zip_file.name)
+        destination_dir = self.data_dir / f"{version.major}.{version.minor}"
+        destination = destination_dir / zip_file.name
 
         if destination.exists():
             self._print(
@@ -778,7 +835,7 @@ class BootstrapRepos:
                 self._print(str(e), LOG_ERROR, exc_info=True)
                 return None
         try:
-            shutil.move(zip_file.as_posix(), self.data_dir.as_posix())
+            shutil.move(zip_file.as_posix(), destination_dir.as_posix())
         except shutil.Error as e:
             self._print(str(e), LOG_ERROR, exc_info=True)
             return None
@@ -991,6 +1048,16 @@ class BootstrapRepos:
 
     @staticmethod
     def _validate_dir(path: Path) -> tuple:
+        """Validate checksums in a given path.
+
+        Args:
+            path (Path): path to folder to validate.
+
+        Returns:
+            tuple(bool, str): returns status and reason as a bool
+                and str in a tuple.
+
+        """
         checksums_file = Path(path / "checksums")
         if not checksums_file.exists():
             # FIXME: This should be set to False sometimes in the future
@@ -1072,7 +1139,20 @@ class BootstrapRepos:
         sys.path.insert(0, directory.as_posix())
 
     @staticmethod
-    def find_openpype_version(version, staging):
+    def find_openpype_version(
+            version: Union[str, OpenPypeVersion],
+            staging: bool,
+            compatible_with: OpenPypeVersion = None
+    ) -> Union[OpenPypeVersion, None]:
+        """Find location of specified OpenPype version.
+
+        Args:
+            version (Union[str, OpenPypeVersion): Version to find.
+            staging (bool): Filter staging versions.
+            compatible_with (OpenPypeVersion, optional): Find only
+                versions compatible with specified one.
+
+        """
         if isinstance(version, str):
             version = OpenPypeVersion(version=version)
 
@@ -1081,7 +1161,8 @@ class BootstrapRepos:
             return installed_version
 
         local_versions = OpenPypeVersion.get_local_versions(
-            staging=staging, production=not staging
+            staging=staging, production=not staging,
+            compatible_with=compatible_with
         )
         zip_version = None
         for local_version in local_versions:
@@ -1095,7 +1176,8 @@ class BootstrapRepos:
             return zip_version
 
         remote_versions = OpenPypeVersion.get_remote_versions(
-            staging=staging, production=not staging
+            staging=staging, production=not staging,
+            compatible_with=compatible_with
         )
         for remote_version in remote_versions:
             if remote_version == version:
@@ -1103,13 +1185,14 @@ class BootstrapRepos:
         return None
 
     @staticmethod
-    def find_latest_openpype_version(staging):
+    def find_latest_openpype_version(
+            staging, compatible_with: OpenPypeVersion = None):
         installed_version = OpenPypeVersion.get_installed_version()
         local_versions = OpenPypeVersion.get_local_versions(
-            staging=staging
+            staging=staging, compatible_with=compatible_with
         )
         remote_versions = OpenPypeVersion.get_remote_versions(
-            staging=staging
+            staging=staging, compatible_with=compatible_with
         )
         all_versions = local_versions + remote_versions
         if not staging:
@@ -1134,7 +1217,9 @@ class BootstrapRepos:
             self,
             openpype_path: Union[Path, str] = None,
             staging: bool = False,
-            include_zips: bool = False) -> Union[List[OpenPypeVersion], None]:
+            include_zips: bool = False,
+            compatible_with: OpenPypeVersion = None
+    ) -> Union[List[OpenPypeVersion], None]:
         """Get ordered dict of detected OpenPype version.
 
         Resolution order for OpenPype is following:
@@ -1150,6 +1235,8 @@ class BootstrapRepos:
                 otherwise.
             include_zips (bool, optional): If set True it will try to find
                 OpenPype in zip files in given directory.
+            compatible_with (OpenPypeVersion, optional): Find only those
+                versions compatible with the one specified.
 
         Returns:
             dict of Path: Dictionary of detected OpenPype version.
@@ -1168,30 +1255,56 @@ class BootstrapRepos:
                 ("Finding OpenPype in non-filesystem locations is"
                  " not implemented yet."))
 
-        dir_to_search = self.data_dir
-        user_versions = self.get_openpype_versions(self.data_dir, staging)
-        # if we have openpype_path specified, search only there.
+        version_dir = ""
+        if compatible_with:
+            version_dir = f"{compatible_with.major}.{compatible_with.minor}"
+
+        # if checks bellow for OPENPYPE_PATH and registry fails, use data_dir
+        # DEPRECATED: lookup in root of this folder is deprecated in favour
+        #             of major.minor sub-folders.
+        dirs_to_search = [
+            self.data_dir
+        ]
+        if compatible_with:
+            dirs_to_search.append(self.data_dir / version_dir)
+
         if openpype_path:
-            dir_to_search = openpype_path
+            dirs_to_search = [openpype_path]
+
+            if compatible_with:
+                dirs_to_search.append(openpype_path / version_dir)
         else:
-            if os.getenv("OPENPYPE_PATH"):
-                if Path(os.getenv("OPENPYPE_PATH")).exists():
-                    dir_to_search = Path(os.getenv("OPENPYPE_PATH"))
+            # first try OPENPYPE_PATH and if that is not available,
+            # try registry.
+            if os.getenv("OPENPYPE_PATH") \
+                    and Path(os.getenv("OPENPYPE_PATH")).exists():
+                dirs_to_search = [Path(os.getenv("OPENPYPE_PATH"))]
+
+                if compatible_with:
+                    dirs_to_search.append(
+                        Path(os.getenv("OPENPYPE_PATH")) / version_dir)
             else:
                 try:
                     registry_dir = Path(
                         str(self.registry.get_item("openPypePath")))
                     if registry_dir.exists():
-                        dir_to_search = registry_dir
+                        dirs_to_search = [registry_dir]
+                    if compatible_with:
+                        dirs_to_search.append(registry_dir / version_dir)
 
                 except ValueError:
                     # nothing found in registry, we'll use data dir
                     pass
 
-        openpype_versions = self.get_openpype_versions(dir_to_search, staging)
-        openpype_versions += user_versions
+        openpype_versions = []
+        for dir_to_search in dirs_to_search:
+            try:
+                openpype_versions += self.get_openpype_versions(
+                    dir_to_search, staging, compatible_with=compatible_with)
+            except ValueError:
+                # location is invalid, skip it
+                pass
 
-        # remove zip file version if needed.
         if not include_zips:
             openpype_versions = [
                 v for v in openpype_versions if v.path.suffix != ".zip"
@@ -1304,9 +1417,8 @@ class BootstrapRepos:
             raise ValueError(
                 f"version {version} is not associated with any file")
 
-        destination = self.data_dir / version.path.stem
-        if destination.exists():
-            assert destination.is_dir()
+        destination = self.data_dir / f"{version.major}.{version.minor}" / version.path.stem  # noqa
+        if destination.exists() and destination.is_dir():
             try:
                 shutil.rmtree(destination)
             except OSError as e:
@@ -1375,7 +1487,7 @@ class BootstrapRepos:
         else:
             dir_name = openpype_version.path.stem
 
-        destination = self.data_dir / dir_name
+        destination = self.data_dir / f"{openpype_version.major}.{openpype_version.minor}" / dir_name  # noqa
 
         # test if destination directory already exist, if so lets delete it.
         if destination.exists() and force:
@@ -1553,14 +1665,18 @@ class BootstrapRepos:
             return False
         return True
 
-    def get_openpype_versions(self,
-                              openpype_dir: Path,
-                              staging: bool = False) -> list:
+    def get_openpype_versions(
+            self,
+            openpype_dir: Path,
+            staging: bool = False,
+            compatible_with: OpenPypeVersion = None) -> list:
         """Get all detected OpenPype versions in directory.
 
         Args:
             openpype_dir (Path): Directory to scan.
             staging (bool, optional): Find staging versions if True.
+            compatible_with (OpenPypeVersion, optional): Get only versions
+                compatible with the one specified.
 
         Returns:
             list of OpenPypeVersion
@@ -1570,7 +1686,7 @@ class BootstrapRepos:
 
         """
         if not openpype_dir.exists() and not openpype_dir.is_dir():
-            raise ValueError("specified directory is invalid")
+            raise ValueError(f"specified directory {openpype_dir} is invalid")
 
         _openpype_versions = []
         # iterate over directory in first level and find all that might
@@ -1595,6 +1711,10 @@ class BootstrapRepos:
                 ):
                     continue
 
+                if compatible_with and \
+                        not detected_version.is_compatible(compatible_with):
+                    continue
+
                 detected_version.path = item
                 if staging and detected_version.is_staging():
                     _openpype_versions.append(detected_version)

From de70521f562084bf5a0cef20179ad2b73efa3bb4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Mon, 1 Aug 2022 18:02:53 +0200
Subject: [PATCH 05/16] :recycle: deadline plugin support for job specific OP
 versions

---
 .../custom/plugins/GlobalJobPreLoad.py        | 87 +++++++++++++++++--
 .../custom/plugins/OpenPype/OpenPype.param    | 11 ++-
 .../custom/plugins/OpenPype/OpenPype.py       | 86 +++++++++++++++++-
 3 files changed, 171 insertions(+), 13 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index bcd853f374..a43c6c7733 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -6,13 +6,29 @@ import subprocess
 import json
 import platform
 import uuid
-from Deadline.Scripting import RepositoryUtils, FileUtils
+import re
+from Deadline.Scripting import RepositoryUtils, FileUtils, DirectoryUtils
+
+
+def get_openpype_version_from_path(path):
+    version_file = os.path.join(path, "openpype", "version.py")
+    if not os.path.isfile(version_file):
+        return None
+    version = {}
+    with open(version_file, "r") as vf:
+        exec(vf.read(), version)
+
+    version_match = re.search(r"(\d+\.\d+.\d+).*", version["__version__"])
+    return version_match[1]
 
 
 def get_openpype_executable():
     """Return OpenPype Executable from Event Plug-in Settings"""
     config = RepositoryUtils.GetPluginConfig("OpenPype")
-    return config.GetConfigEntryWithDefault("OpenPypeExecutable", "")
+    exe_list = config.GetConfigEntryWithDefault("OpenPypeExecutable", "")
+    dir_list = config.GetConfigEntryWithDefault(
+        "OpenPypeInstallationDirs", "")
+    return exe_list, dir_list
 
 
 def inject_openpype_environment(deadlinePlugin):
@@ -25,16 +41,71 @@ def inject_openpype_environment(deadlinePlugin):
     print(">>> Injecting OpenPype environments ...")
     try:
         print(">>> Getting OpenPype executable ...")
-        exe_list = get_openpype_executable()
-        openpype_app = FileUtils.SearchFileList(exe_list)
-        if openpype_app == "":
+        exe_list, dir_list = get_openpype_executable()
+        openpype_versions = []
+        # if the job requires specific OpenPype version,
+        # lets go over all available and find compatible build.
+        requested_version = job.GetJobEnvironmentKeyValue("OPENPYPE_VERSION")
+        if requested_version:
+            print(("Scanning for compatible requested "
+                  f"version {requested_version}"))
+            install_dir = DirectoryUtils.SearchDirectoryList(dir_list)
+            if dir:
+                sub_dirs = [
+                    f.path for f in os.scandir(install_dir)
+                    if f.is_dir()
+                ]
+                for subdir in sub_dirs:
+                    version = get_openpype_version_from_path(subdir)
+                    if not version:
+                        continue
+                    openpype_versions.append((version, subdir))
+
+        exe = FileUtils.SearchFileList(exe_list)
+        if openpype_versions:
+            # if looking for requested compatible version,
+            # add the implicitly specified to the list too.
+            version = get_openpype_version_from_path(
+                os.path.dirname(exe))
+            if version:
+                openpype_versions.append((version, os.path.dirname(exe)))
+
+        if requested_version:
+            # sort detected versions
+            if openpype_versions:
+                openpype_versions.sort(key=lambda ver: ver[0])
+            requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
+            compatible_versions = []
+            for version in openpype_versions:
+                v = version[0].split(".")[:3]
+                if v[0] == requested_major and v[1] == requested_minor:
+                    compatible_versions.append(version)
+            if not compatible_versions:
+                raise RuntimeError(
+                    ("Cannot find compatible version available "
+                     "for version {} requested by the job. "
+                     "Please add it through plugin configuration "
+                     "in Deadline or install it to configured "
+                     "directory.").format(requested_version))
+            # sort compatible versions nad pick the last one
+            compatible_versions.sort(key=lambda ver: ver[0])
+            # create list of executables for different platform and let
+            # Deadline decide.
+            exe_list = [
+                os.path.join(
+                    compatible_versions[-1][1], "openpype_console.exe"),
+                os.path.join(
+                    compatible_versions[-1][1], "openpype_console")
+            ]
+            exe = FileUtils.SearchFileList(";".join(exe_list))
+        if exe == "":
             raise RuntimeError(
                 "OpenPype executable was not found " +
                 "in the semicolon separated list \"" + exe_list + "\". " +
                 "The path to the render executable can be configured " +
                 "from the Plugin Configuration in the Deadline Monitor.")
 
-        print("--- OpenPype executable: {}".format(openpype_app))
+        print("--- OpenPype executable: {}".format(exe))
 
         # tempfile.TemporaryFile cannot be used because of locking
         temp_file_name = "{}_{}.json".format(
@@ -45,7 +116,7 @@ def inject_openpype_environment(deadlinePlugin):
         print(">>> Temporary path: {}".format(export_url))
 
         args = [
-            openpype_app,
+            exe,
             "--headless",
             'extractenvironments',
             export_url
@@ -77,7 +148,7 @@ def inject_openpype_environment(deadlinePlugin):
 
         print(">>> Executing: {}".format(args))
         std_output = subprocess.check_output(args,
-                                             cwd=os.path.dirname(openpype_app),
+                                             cwd=os.path.dirname(exe),
                                              env=env)
         print(">>> Process result {}".format(std_output))
 
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.param b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.param
index 8bd6dce12d..b3ac18e20c 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.param
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.param
@@ -7,11 +7,20 @@ Index=0
 Default=OpenPype Plugin for Deadline
 Description=Not configurable
 
+[OpenPypeInstallationDirs]
+Type=multilinemultifolder
+Label=Directories where OpenPype versions are installed
+Category=OpenPype Installation Directories
+CategoryOrder=0
+Index=0
+Default=C:\Program Files (x86)\OpenPype
+Description=Path or paths to directories where multiple versions of OpenPype might be installed. Enter every such path on separate lines.
+
 [OpenPypeExecutable]
 Type=multilinemultifilename
 Label=OpenPype Executable
 Category=OpenPype Executables
-CategoryOrder=0
+CategoryOrder=1
 Index=0
 Default=
 Description=The path to the OpenPype executable. Enter alternative paths on separate lines.
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index 451d71fb63..b84560f175 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -1,10 +1,18 @@
+#!/usr/bin/env python3
+
 from System.IO import Path
 from System.Text.RegularExpressions import Regex
 
 from Deadline.Plugins import PluginType, DeadlinePlugin
-from Deadline.Scripting import StringUtils, FileUtils, RepositoryUtils
+from Deadline.Scripting import (
+    StringUtils,
+    FileUtils,
+    DirectoryUtils,
+    RepositoryUtils
+)
 
 import re
+import os
 
 
 ######################################################################
@@ -52,13 +60,83 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
         self.AddStdoutHandlerCallback(
             ".*Progress: (\d+)%.*").HandleCallback += self.HandleProgress
 
+    @staticmethod
+    def get_openpype_version_from_path(path):
+        version_file = os.path.join(path, "openpype", "version.py")
+        if not os.path.isfile(version_file):
+            return None
+        version = {}
+        with open(version_file, "r") as vf:
+            exec(vf.read(), version)
+
+        version_match = re.search(r"(\d+\.\d+.\d+).*", version["__version__"])
+        return version_match[1]
+
     def RenderExecutable(self):
-        exeList = self.GetConfigEntry("OpenPypeExecutable")
-        exe = FileUtils.SearchFileList(exeList)
+        job = self.GetJob()
+        openpype_versions = []
+        # if the job requires specific OpenPype version,
+        # lets go over all available and find compatible build.
+        requested_version = job.GetJobEnvironmentKeyValue("OPENPYPE_VERSION")
+        if requested_version:
+            self.LogInfo((
+                "Scanning for compatible requested "
+                f"version {requested_version}"))
+            dir_list = self.GetConfigEntry("OpenPypeInstallationDirs")
+            install_dir = DirectoryUtils.SearchDirectoryList(dir_list)
+            if dir:
+                sub_dirs = [
+                    f.path for f in os.scandir(install_dir)
+                    if f.is_dir()
+                ]
+                for subdir in sub_dirs:
+                    version = self.get_openpype_version_from_path(subdir)
+                    if not version:
+                        continue
+                    openpype_versions.append((version, subdir))
+
+        exe_list = self.GetConfigEntry("OpenPypeExecutable")
+        exe = FileUtils.SearchFileList(exe_list)
+        if openpype_versions:
+            # if looking for requested compatible version,
+            # add the implicitly specified to the list too.
+            version = self.get_openpype_version_from_path(
+                os.path.dirname(exe))
+            if version:
+                openpype_versions.append((version, os.path.dirname(exe)))
+
+        if requested_version:
+            # sort detected versions
+            if openpype_versions:
+                openpype_versions.sort(key=lambda ver: ver[0])
+            requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
+            compatible_versions = []
+            for version in openpype_versions:
+                v = version[0].split(".")[:3]
+                if v[0] == requested_major and v[1] == requested_minor:
+                    compatible_versions.append(version)
+            if not compatible_versions:
+                self.FailRender(("Cannot find compatible version available "
+                                 "for version {} requested by the job. "
+                                 "Please add it through plugin configuration "
+                                 "in Deadline or install it to configured "
+                                 "directory.").format(requested_version))
+            # sort compatible versions nad pick the last one
+            compatible_versions.sort(key=lambda ver: ver[0])
+            # create list of executables for different platform and let
+            # Deadline decide.
+            exe_list = [
+                os.path.join(
+                    compatible_versions[-1][1], "openpype_console.exe"),
+                os.path.join(
+                    compatible_versions[-1][1], "openpype_console")
+            ]
+            exe = FileUtils.SearchFileList(";".join(exe_list))
+
         if exe == "":
             self.FailRender(
                 "OpenPype executable was not found " +
-                "in the semicolon separated list \"" + exeList + "\". " +
+                "in the semicolon separated list \"" + exe_list + "\". " +
                 "The path to the render executable can be configured " +
                 "from the Plugin Configuration in the Deadline Monitor.")
         return exe

From 3d7e1953075809af9323951046fc3d321da8352b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Tue, 2 Aug 2022 11:26:33 +0200
Subject: [PATCH 06/16] :recycle: skip non-existent local path

when finding  local version, stop crashing if directory to search doesn't exist - this will allow to just use build version
---
 igniter/bootstrap_repos.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/igniter/bootstrap_repos.py b/igniter/bootstrap_repos.py
index 47f2525952..750b2f1bf7 100644
--- a/igniter/bootstrap_repos.py
+++ b/igniter/bootstrap_repos.py
@@ -514,10 +514,10 @@ class OpenPypeVersion(semver.VersionInfo):
             ValueError: if invalid path is specified.
 
         """
-        if not openpype_dir.exists() and not openpype_dir.is_dir():
-            raise ValueError("specified directory is invalid")
-
         _openpype_versions = []
+        if not openpype_dir.exists() and not openpype_dir.is_dir():
+            return _openpype_versions
+
         # iterate over directory in first level and find all that might
         # contain OpenPype.
         for item in openpype_dir.iterdir():

From 9ed329aebe6e114d47195e6dc456898569e0d404 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Wed, 3 Aug 2022 14:26:05 +0200
Subject: [PATCH 07/16] :bug: filter out non-build versions

and fixing the error message
---
 .../custom/plugins/GlobalJobPreLoad.py         | 18 ++++++++++++++++--
 .../custom/plugins/OpenPype/OpenPype.py        | 18 ++++++++++++++++--
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index a43c6c7733..5e923eb09a 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -10,10 +10,23 @@ import re
 from Deadline.Scripting import RepositoryUtils, FileUtils, DirectoryUtils
 
 
-def get_openpype_version_from_path(path):
+def get_openpype_version_from_path(path, build=True):
+    """Get OpenPype version from provided path.
+         path (str): Path to scan.
+         build (bool, optional): Get only builds, not sources
+
+    Returns:
+        str or None: version of OpenPype if found.
+
+    """
     version_file = os.path.join(path, "openpype", "version.py")
     if not os.path.isfile(version_file):
         return None
+    # skip if the version is not build
+    if not build and \
+            (not os.path.isfile(os.path.join(path, "openpype_console")) or
+             not os.path.isfile(os.path.join(path, "openpype_console.exe"))):
+        return None
     version = {}
     with open(version_file, "r") as vf:
         exec(vf.read(), version)
@@ -101,7 +114,8 @@ def inject_openpype_environment(deadlinePlugin):
         if exe == "":
             raise RuntimeError(
                 "OpenPype executable was not found " +
-                "in the semicolon separated list \"" + exe_list + "\". " +
+                "in the semicolon separated list " +
+                "\"" + ";".join(exe_list) + "\". " +
                 "The path to the render executable can be configured " +
                 "from the Plugin Configuration in the Deadline Monitor.")
 
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index b84560f175..764dc4c4ba 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -61,10 +61,23 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
             ".*Progress: (\d+)%.*").HandleCallback += self.HandleProgress
 
     @staticmethod
-    def get_openpype_version_from_path(path):
+    def get_openpype_version_from_path(path, build=True):
+        """Get OpenPype version from provided path.
+             path (str): Path to scan.
+             build (bool, optional): Get only builds, not sources
+
+        Returns:
+            str or None: version of OpenPype if found.
+
+        """
         version_file = os.path.join(path, "openpype", "version.py")
         if not os.path.isfile(version_file):
             return None
+        # skip if the version is not build
+        if not build and \
+                (not os.path.isfile(os.path.join(path, "openpype_console")) or
+                 not os.path.isfile(os.path.join(path, "openpype_console.exe"))):
+            return None
         version = {}
         with open(version_file, "r") as vf:
             exec(vf.read(), version)
@@ -136,7 +149,8 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
         if exe == "":
             self.FailRender(
                 "OpenPype executable was not found " +
-                "in the semicolon separated list \"" + exe_list + "\". " +
+                "in the semicolon separated list " +
+                "\"" + ";".join(exe_list) + "\". " +
                 "The path to the render executable can be configured " +
                 "from the Plugin Configuration in the Deadline Monitor.")
         return exe

From c64925fb665ee3bcb49837dcb2fff7f03a7390f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Wed, 3 Aug 2022 16:12:21 +0200
Subject: [PATCH 08/16] :rotating_light: I hate you Hound so much

---
 .../deadline/repository/custom/plugins/OpenPype/OpenPype.py     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index 764dc4c4ba..79101bb90c 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -76,7 +76,7 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
         # skip if the version is not build
         if not build and \
                 (not os.path.isfile(os.path.join(path, "openpype_console")) or
-                 not os.path.isfile(os.path.join(path, "openpype_console.exe"))):
+                 not os.path.isfile(os.path.join(path, "openpype_console.exe"))):  # noqa: E501
             return None
         version = {}
         with open(version_file, "r") as vf:

From 3137644299e4ade30ff8e9fe1184cf0430e3a925 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 11:07:29 +0200
Subject: [PATCH 09/16] :recycle: change macos installer

---
 setup.py       | 2 +-
 tools/build.sh | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/setup.py b/setup.py
index 8b5a545c16..eab0187983 100644
--- a/setup.py
+++ b/setup.py
@@ -152,7 +152,7 @@ build_exe_options = dict(
 )
 
 bdist_mac_options = dict(
-    bundle_name="OpenPype",
+    bundle_name=f"OpenPype {__version__}",
     iconfile=mac_icon_path
 )
 
diff --git a/tools/build.sh b/tools/build.sh
index 79fb748cd5..fa2c580648 100755
--- a/tools/build.sh
+++ b/tools/build.sh
@@ -193,15 +193,15 @@ if [ "$disable_submodule_update" == 1 ]; then
 
   if [[ "$OSTYPE" == "darwin"* ]]; then
     # fix code signing issue
-    codesign --remove-signature "$openpype_root/build/OpenPype.app/Contents/MacOS/lib/Python"
+    codesign --remove-signature "$openpype_root/build/OpenPype $openpype_version.app/Contents/MacOS/lib/Python"
     if command -v create-dmg > /dev/null 2>&1; then
       create-dmg \
-        --volname "OpenPype Installer" \
+        --volname "OpenPype $openpype_version Installer" \
         --window-pos 200 120 \
         --window-size 600 300 \
         --app-drop-link 100 50 \
-        "$openpype_root/build/OpenPype-Installer.dmg" \
-        "$openpype_root/build/OpenPype.app"
+        "$openpype_root/build/OpenPype-Installer-$openpype_version.dmg" \
+        "$openpype_root/build/OpenPype $openpype_version.app"
     else
       echo -e "${BIYellow}!!!${RST} ${BIWhite}create-dmg${RST} command is not available."
     fi

From 633c7a5cde89a27c69ad24108ef802c66da02c41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 11:26:33 +0200
Subject: [PATCH 10/16] :hammer: add more verbose info to Deadline

---
 .../repository/custom/plugins/GlobalJobPreLoad.py         | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index 5e923eb09a..793ee782f4 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -63,7 +63,7 @@ def inject_openpype_environment(deadlinePlugin):
             print(("Scanning for compatible requested "
                   f"version {requested_version}"))
             install_dir = DirectoryUtils.SearchDirectoryList(dir_list)
-            if dir:
+            if install_dir:
                 sub_dirs = [
                     f.path for f in os.scandir(install_dir)
                     if f.is_dir()
@@ -72,6 +72,7 @@ def inject_openpype_environment(deadlinePlugin):
                     version = get_openpype_version_from_path(subdir)
                     if not version:
                         continue
+                    print(f" - found: {version} - {subdir}")
                     openpype_versions.append((version, subdir))
 
         exe = FileUtils.SearchFileList(exe_list)
@@ -81,12 +82,15 @@ def inject_openpype_environment(deadlinePlugin):
             version = get_openpype_version_from_path(
                 os.path.dirname(exe))
             if version:
+                print(f" - found: {version} - {os.path.dirname(exe)}")
                 openpype_versions.append((version, os.path.dirname(exe)))
 
         if requested_version:
             # sort detected versions
             if openpype_versions:
                 openpype_versions.sort(key=lambda ver: ver[0])
+            print(("Latest available version found is "
+                   f"{openpype_versions[-1][0]}"))
             requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
             compatible_versions = []
             for version in openpype_versions:
@@ -102,6 +106,8 @@ def inject_openpype_environment(deadlinePlugin):
                      "directory.").format(requested_version))
             # sort compatible versions nad pick the last one
             compatible_versions.sort(key=lambda ver: ver[0])
+            print(("Latest compatible version found is "
+                   f"{compatible_versions[-1][0]}"))
             # create list of executables for different platform and let
             # Deadline decide.
             exe_list = [

From b9703f3fda15a9999edba3ce4be1bae43f74913a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 11:43:48 +0200
Subject: [PATCH 11/16] :bug: fix inverted condition

---
 .../deadline/repository/custom/plugins/GlobalJobPreLoad.py      | 2 +-
 .../deadline/repository/custom/plugins/OpenPype/OpenPype.py     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index 793ee782f4..e0fd22e218 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -23,7 +23,7 @@ def get_openpype_version_from_path(path, build=True):
     if not os.path.isfile(version_file):
         return None
     # skip if the version is not build
-    if not build and \
+    if build and \
             (not os.path.isfile(os.path.join(path, "openpype_console")) or
              not os.path.isfile(os.path.join(path, "openpype_console.exe"))):
         return None
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index 79101bb90c..3eba347770 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -74,7 +74,7 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
         if not os.path.isfile(version_file):
             return None
         # skip if the version is not build
-        if not build and \
+        if build and \
                 (not os.path.isfile(os.path.join(path, "openpype_console")) or
                  not os.path.isfile(os.path.join(path, "openpype_console.exe"))):  # noqa: E501
             return None

From 03c648c8fd897ab374752eea1175f6c67b281afe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 13:08:51 +0200
Subject: [PATCH 12/16] :bug: fix executable detection on platforms

---
 .../custom/plugins/GlobalJobPreLoad.py        | 24 ++++++++++++++-----
 .../custom/plugins/OpenPype/OpenPype.py       | 17 ++++++++++---
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index e0fd22e218..2972eeec40 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -19,14 +19,24 @@ def get_openpype_version_from_path(path, build=True):
         str or None: version of OpenPype if found.
 
     """
+    # fix path for application bundle on macos
+    if platform.system().lower() == "darwin":
+        path = os.path.join(path, "Contents", "MacOS", "lib", "Python")
+
     version_file = os.path.join(path, "openpype", "version.py")
     if not os.path.isfile(version_file):
         return None
+
     # skip if the version is not build
-    if build and \
-            (not os.path.isfile(os.path.join(path, "openpype_console")) or
-             not os.path.isfile(os.path.join(path, "openpype_console.exe"))):
+    exe = os.path.join(path, "openpype_console.exe")
+    if platform.system().lower() in ["linux", "darwin"]:
+        exe = os.path.join(path, "openpype_console")
+
+    # if only builds are requested
+    if build and not os.path.isfile(exe):  # noqa: E501
+        print(f"   ! path is not a build: {path}")
         return None
+
     version = {}
     with open(version_file, "r") as vf:
         exec(vf.read(), version)
@@ -64,6 +74,7 @@ def inject_openpype_environment(deadlinePlugin):
                   f"version {requested_version}"))
             install_dir = DirectoryUtils.SearchDirectoryList(dir_list)
             if install_dir:
+                print(f"Looking for OpenPype at: {install_dir}")
                 sub_dirs = [
                     f.path for f in os.scandir(install_dir)
                     if f.is_dir()
@@ -79,6 +90,7 @@ def inject_openpype_environment(deadlinePlugin):
         if openpype_versions:
             # if looking for requested compatible version,
             # add the implicitly specified to the list too.
+            print(f"Looking for OpenPype at: {os.path.dirname(exe)}")
             version = get_openpype_version_from_path(
                 os.path.dirname(exe))
             if version:
@@ -89,8 +101,8 @@ def inject_openpype_environment(deadlinePlugin):
             # sort detected versions
             if openpype_versions:
                 openpype_versions.sort(key=lambda ver: ver[0])
-            print(("Latest available version found is "
-                   f"{openpype_versions[-1][0]}"))
+                print(("Latest available version found is "
+                       f"{openpype_versions[-1][0]}"))
             requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
             compatible_versions = []
             for version in openpype_versions:
@@ -166,7 +178,7 @@ def inject_openpype_environment(deadlinePlugin):
         env["OPENPYPE_HEADLESS_MODE"] = "1"
         env["AVALON_TIMEOUT"] = "5000"
 
-        print(">>> Executing: {}".format(args))
+        print(">>> Executing: {}".format(" ".join(args)))
         std_output = subprocess.check_output(args,
                                              cwd=os.path.dirname(exe),
                                              env=env)
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index 3eba347770..aa3ddc7088 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -13,6 +13,7 @@ from Deadline.Scripting import (
 
 import re
 import os
+import platform
 
 
 ######################################################################
@@ -70,14 +71,24 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
             str or None: version of OpenPype if found.
 
         """
+        # fix path for application bundle on macos
+        if platform.system().lower() == "darwin":
+            path = os.path.join(path, "Contents", "MacOS", "lib", "Python")
+
         version_file = os.path.join(path, "openpype", "version.py")
         if not os.path.isfile(version_file):
             return None
+
         # skip if the version is not build
-        if build and \
-                (not os.path.isfile(os.path.join(path, "openpype_console")) or
-                 not os.path.isfile(os.path.join(path, "openpype_console.exe"))):  # noqa: E501
+        exe = os.path.join(path, "openpype_console.exe")
+        if platform.system().lower() in ["linux", "darwin"]:
+            exe = os.path.join(path, "openpype_console")
+
+        # if only builds are requested
+        if build and not os.path.isfile(exe):  # noqa: E501
+            print(f"   ! path is not a build: {path}")
             return None
+
         version = {}
         with open(version_file, "r") as vf:
             exec(vf.read(), version)

From 53877ebe96114f3a38e428c502d05ce72ec4dc46 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 13:25:56 +0200
Subject: [PATCH 13/16] :rotating_light: unify output messages

---
 .../repository/custom/plugins/GlobalJobPreLoad.py    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index 2972eeec40..b8a31e01ff 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -70,11 +70,11 @@ def inject_openpype_environment(deadlinePlugin):
         # lets go over all available and find compatible build.
         requested_version = job.GetJobEnvironmentKeyValue("OPENPYPE_VERSION")
         if requested_version:
-            print(("Scanning for compatible requested "
+            print((">>> Scanning for compatible requested "
                   f"version {requested_version}"))
             install_dir = DirectoryUtils.SearchDirectoryList(dir_list)
             if install_dir:
-                print(f"Looking for OpenPype at: {install_dir}")
+                print(f"--- Looking for OpenPype at: {install_dir}")
                 sub_dirs = [
                     f.path for f in os.scandir(install_dir)
                     if f.is_dir()
@@ -83,7 +83,7 @@ def inject_openpype_environment(deadlinePlugin):
                     version = get_openpype_version_from_path(subdir)
                     if not version:
                         continue
-                    print(f" - found: {version} - {subdir}")
+                    print(f"  - found: {version} - {subdir}")
                     openpype_versions.append((version, subdir))
 
         exe = FileUtils.SearchFileList(exe_list)
@@ -94,14 +94,14 @@ def inject_openpype_environment(deadlinePlugin):
             version = get_openpype_version_from_path(
                 os.path.dirname(exe))
             if version:
-                print(f" - found: {version} - {os.path.dirname(exe)}")
+                print(f"  - found: {version} - {os.path.dirname(exe)}")
                 openpype_versions.append((version, os.path.dirname(exe)))
 
         if requested_version:
             # sort detected versions
             if openpype_versions:
                 openpype_versions.sort(key=lambda ver: ver[0])
-                print(("Latest available version found is "
+                print(("*** Latest available version found is "
                        f"{openpype_versions[-1][0]}"))
             requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
             compatible_versions = []
@@ -118,7 +118,7 @@ def inject_openpype_environment(deadlinePlugin):
                      "directory.").format(requested_version))
             # sort compatible versions nad pick the last one
             compatible_versions.sort(key=lambda ver: ver[0])
-            print(("Latest compatible version found is "
+            print(("*** Latest compatible version found is "
                    f"{compatible_versions[-1][0]}"))
             # create list of executables for different platform and let
             # Deadline decide.

From 097638c9e54c6fd6cd02d88d456e820c72c6a9fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 14:35:01 +0200
Subject: [PATCH 14/16] :recycle: natural sort versions

---
 .../repository/custom/plugins/GlobalJobPreLoad.py   | 13 +++++++++++--
 .../repository/custom/plugins/OpenPype/OpenPype.py  | 12 ++++++++++--
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index b8a31e01ff..17f911a686 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -100,7 +100,12 @@ def inject_openpype_environment(deadlinePlugin):
         if requested_version:
             # sort detected versions
             if openpype_versions:
-                openpype_versions.sort(key=lambda ver: ver[0])
+                # use natural sorting
+                openpype_versions.sort(
+                    key=lambda ver: [
+                        int(t) if t.isdigit() else t.lower()
+                        for t in re.split('(\d+)', ver[0])
+                    ])
                 print(("*** Latest available version found is "
                        f"{openpype_versions[-1][0]}"))
             requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
@@ -117,7 +122,11 @@ def inject_openpype_environment(deadlinePlugin):
                      "in Deadline or install it to configured "
                      "directory.").format(requested_version))
             # sort compatible versions nad pick the last one
-            compatible_versions.sort(key=lambda ver: ver[0])
+            compatible_versions.sort(
+                    key=lambda ver: [
+                        int(t) if t.isdigit() else t.lower()
+                        for t in re.split('(\d+)', ver[0])
+                    ])
             print(("*** Latest compatible version found is "
                    f"{compatible_versions[-1][0]}"))
             # create list of executables for different platform and let
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index aa3ddc7088..d270a1b87e 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -132,7 +132,11 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
         if requested_version:
             # sort detected versions
             if openpype_versions:
-                openpype_versions.sort(key=lambda ver: ver[0])
+                openpype_versions.sort(
+                    key=lambda ver: [
+                        int(t) if t.isdigit() else t.lower()
+                        for t in re.split('(\d+)', ver[0])
+                    ])
             requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
             compatible_versions = []
             for version in openpype_versions:
@@ -146,7 +150,11 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
                                  "in Deadline or install it to configured "
                                  "directory.").format(requested_version))
             # sort compatible versions nad pick the last one
-            compatible_versions.sort(key=lambda ver: ver[0])
+            compatible_versions.sort(
+                    key=lambda ver: [
+                        int(t) if t.isdigit() else t.lower()
+                        for t in re.split('(\d+)', ver[0])
+                    ])
             # create list of executables for different platform and let
             # Deadline decide.
             exe_list = [

From 7de8c3394a0aa3ed5dadb6fb78e4b217956509bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 14:38:57 +0200
Subject: [PATCH 15/16] :rotating_light: fix invalid sequence warning

---
 .../deadline/repository/custom/plugins/GlobalJobPreLoad.py    | 4 ++--
 .../deadline/repository/custom/plugins/OpenPype/OpenPype.py   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index 17f911a686..ae5f2e5914 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -104,7 +104,7 @@ def inject_openpype_environment(deadlinePlugin):
                 openpype_versions.sort(
                     key=lambda ver: [
                         int(t) if t.isdigit() else t.lower()
-                        for t in re.split('(\d+)', ver[0])
+                        for t in re.split(r"(\d+)", ver[0])
                     ])
                 print(("*** Latest available version found is "
                        f"{openpype_versions[-1][0]}"))
@@ -125,7 +125,7 @@ def inject_openpype_environment(deadlinePlugin):
             compatible_versions.sort(
                     key=lambda ver: [
                         int(t) if t.isdigit() else t.lower()
-                        for t in re.split('(\d+)', ver[0])
+                        for t in re.split(r"(\d+)", ver[0])
                     ])
             print(("*** Latest compatible version found is "
                    f"{compatible_versions[-1][0]}"))
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index d270a1b87e..00292ed5a9 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -135,7 +135,7 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
                 openpype_versions.sort(
                     key=lambda ver: [
                         int(t) if t.isdigit() else t.lower()
-                        for t in re.split('(\d+)', ver[0])
+                        for t in re.split(r"(\d+)", ver[0])
                     ])
             requested_major, requested_minor, _ = requested_version.split(".")[:3]  # noqa: E501
             compatible_versions = []
@@ -153,7 +153,7 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
             compatible_versions.sort(
                     key=lambda ver: [
                         int(t) if t.isdigit() else t.lower()
-                        for t in re.split('(\d+)', ver[0])
+                        for t in re.split(r"(\d+)", ver[0])
                     ])
             # create list of executables for different platform and let
             # Deadline decide.

From 52eba357d6c1eeae3b2b73d13ec99140a8801a9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ond=C5=99ej=20Samohel?= <ondrej.samohel@pype.club>
Date: Thu, 4 Aug 2022 14:46:24 +0200
Subject: [PATCH 16/16] :rotating_light: fix hound :dog:

---
 .../repository/custom/plugins/GlobalJobPreLoad.py         | 8 ++++----
 .../repository/custom/plugins/OpenPype/OpenPype.py        | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
index ae5f2e5914..172649c951 100644
--- a/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
+++ b/openpype/modules/deadline/repository/custom/plugins/GlobalJobPreLoad.py
@@ -123,10 +123,10 @@ def inject_openpype_environment(deadlinePlugin):
                      "directory.").format(requested_version))
             # sort compatible versions nad pick the last one
             compatible_versions.sort(
-                    key=lambda ver: [
-                        int(t) if t.isdigit() else t.lower()
-                        for t in re.split(r"(\d+)", ver[0])
-                    ])
+                key=lambda ver: [
+                    int(t) if t.isdigit() else t.lower()
+                    for t in re.split(r"(\d+)", ver[0])
+                ])
             print(("*** Latest compatible version found is "
                    f"{compatible_versions[-1][0]}"))
             # create list of executables for different platform and let
diff --git a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
index 00292ed5a9..6b0f69d98f 100644
--- a/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
+++ b/openpype/modules/deadline/repository/custom/plugins/OpenPype/OpenPype.py
@@ -151,10 +151,10 @@ class OpenPypeDeadlinePlugin(DeadlinePlugin):
                                  "directory.").format(requested_version))
             # sort compatible versions nad pick the last one
             compatible_versions.sort(
-                    key=lambda ver: [
-                        int(t) if t.isdigit() else t.lower()
-                        for t in re.split(r"(\d+)", ver[0])
-                    ])
+                key=lambda ver: [
+                    int(t) if t.isdigit() else t.lower()
+                    for t in re.split(r"(\d+)", ver[0])
+                ])
             # create list of executables for different platform and let
             # Deadline decide.
             exe_list = [