SG-32814 Review and unify code handling supported DCC versions (shotgunsoftware#49)

* Update Max supported versions

* Fixup minor regexp issue matching too large

* Unify pre-commit config file

* Better version management

* Fixup forgotten changes

* Black

* Improvements

* Black

* Add missing comment

* Remove warning

* Apply review from Copilot

Author: julien-lang

engine.py

@@ -16,6 +16,13 @@
 
 import pymxs
 
+# Max versions compatibility constants
+VERSION_OLDEST_COMPATIBLE = 2023
+VERSION_OLDEST_SUPPORTED = 2024
+VERSION_NEWEST_SUPPORTED = 2025
+# Caution: make sure compatibility_dialog_min_version default value in info.yml
+# is equal to VERSION_NEWEST_SUPPORTED
+
 
 class MaxEngine(sgtk.platform.Engine):
     """
@@ -47,17 +54,13 @@ def host_info(self):
             }
 
         References:
-        http://docs.autodesk.com/3DSMAX/16/ENU/3ds-Max-Python-API-Documentation/index.html
+        https://help.autodesk.com/view/MAXDEV/2026/ENU/?guid=MAXDEV_Python_what_s_new_in_3ds_max_python_api_html
         """
         host_info = {"name": "3ds Max", "version": "unknown"}
 
-        try:
-            host_info["version"] = str(
-                self._max_version_to_year(self._get_max_version())
-            )
-        except:
-            # Fallback to initialized values above
-            pass
+        max_version_year = self.max_version_year
+        if max_version_year:
+            host_info["version"] = str(max_version_year)
 
         return host_info
 
@@ -73,6 +76,7 @@ def __init__(self, *args, **kwargs):
         self._dock_widgets = []
 
         self._max_version = None
+        self._max_version_year = None
 
         # proceed about your business
         sgtk.platform.Engine.__init__(self, *args, **kwargs)
@@ -98,35 +102,133 @@ def pre_app_init(self):
 
         self.log_debug("%s: Initializing..." % self)
 
-        if self._get_max_version() > MaxEngine.MAXIMUM_SUPPORTED_VERSION:
-            # Untested max version
+        url_doc_supported_versions = "https://help.autodesk.com/view/SGDEV/ENU/?guid=SGD_si_integrations_engine_supported_versions_html"
+
+        if self.max_version_year < VERSION_OLDEST_COMPATIBLE:
+            # Old incompatible version
+            message = """
+Flow Production Tracking is no longer compatible with {product} versions older
+than {version}.
+
+For information regarding support engine versions, please visit this page:
+{url_doc_supported_versions}
+            """.strip()
+
+            if self.has_ui:
+                try:
+                    QtGui.QMessageBox.critical(
+                        None,  # parent
+                        "Error - Flow Production Tracking Compatibility!".ljust(
+                            # Padding to try to prevent the dialog being insanely narrow
+                            70
+                        ),
+                        message.replace(
+                            # Presence of \n breaks the Rich Text Format
+                            "\n",
+                            "<br>",
+                        ).format(
+                            product="3ds Max",
+                            url_doc_supported_versions='<a href="{u}">{u}</a>'.format(
+                                u=url_doc_supported_versions,
+                            ),
+                            version=VERSION_OLDEST_COMPATIBLE,
+                        ),
+                    )
+                except:  # nosec B110
+                    # It is unlikely that the above message will go through
+                    # on old versions of Max (Python2, Qt4, ...).
+                    # But there is nothing more we can do here.
+                    pass
+
+            raise sgtk.TankError(
+                message.format(
+                    product="3ds Max",
+                    url_doc_supported_versions=url_doc_supported_versions,
+                    version=VERSION_OLDEST_COMPATIBLE,
+                )
+            )
 
-            highest_supported_version = self._max_version_to_year(
-                MaxEngine.MAXIMUM_SUPPORTED_VERSION
+        elif self.max_version_year < VERSION_OLDEST_SUPPORTED:
+            # Older than the oldest supported version
+            self.logger.warning(
+                "Flow Production Tracking no longer supports {product} "
+                "versions older than {version}".format(
+                    product="3ds Max",
+                    version=VERSION_OLDEST_SUPPORTED,
+                )
             )
 
-            msg = (
-                "Flow Production Tracking!\n\n"
-                "The Flow Production Tracking has not yet been fully tested with 3ds Max versions greater than %s. "
-                "You can continue to use the Toolkit but you may experience bugs or instability. "
-                "Please report any issues you see via %s."
-                % (
-                    highest_supported_version,
-                    sgtk.support_url,
+            if self.has_ui:
+                QtGui.QMessageBox.warning(
+                    None,  # parent
+                    "Warning - Flow Production Tracking Compatibility!".ljust(
+                        # Padding to try to prevent the dialog being insanely narrow
+                        70
+                    ),
+                    """
+Flow Production Tracking no longer supports {product} versions older than
+{version}.
+You can continue to use Toolkit but you may experience bugs or instabilities.
+
+For information regarding support engine versions, please visit this page:
+{url_doc_supported_versions}
+                    """.strip()
+                    .replace(
+                        # Presence of \n breaks the Rich Text Format
+                        "\n",
+                        "<br>",
+                    )
+                    .format(
+                        product="3ds Max",
+                        url_doc_supported_versions='<a href="{u}">{u}</a>'.format(
+                            u=url_doc_supported_versions,
+                        ),
+                        version=VERSION_OLDEST_SUPPORTED,
+                    ),
+                )
+
+        elif self.max_version_year <= VERSION_NEWEST_SUPPORTED:
+            # Within the range of supported versions
+            self.logger.debug(f"Running 3ds Max version {self.max_version_year}")
+        else:  # Newer than the newest supported version (untested)
+            self.logger.warning(
+                "Flow Production Tracking has not yet been fully tested with "
+                "{product} version {version}.".format(
+                    product="3ds Max",
+                    version=self.max_version_year,
                 )
             )
 
-            # Display warning dialog
-            max_year = self._max_version_to_year(self._get_max_version())
-            max_next_year = highest_supported_version + 1
-            if max_year >= self.get_setting(
-                "compatibility_dialog_min_version", max_next_year
+            if self.has_ui and self.max_version_year >= self.get_setting(
+                "compatibility_dialog_min_version"
             ):
                 QtGui.QMessageBox.warning(
-                    None, "PTR Warning", "Warning - {0}".format(msg)
+                    None,  # parent
+                    "Warning - Flow Production Tracking Compatibility!".ljust(
+                        # Padding to try to prevent the dialog being insanely narrow
+                        70
+                    ),
+                    """
+Flow Production Tracking has not yet been fully tested with {product} version
+{version}.
+You can continue to use Toolkit but you may experience bugs or instabilities.
+
+Please report any issues to:
+{support_url}
+                    """.strip()
+                    .replace(
+                        # Presence of \n breaks the Rich Text Format
+                        "\n",
+                        "<br>",
+                    )
+                    .format(
+                        product="3ds Max",
+                        support_url='<a href="{u}">{u}</a>'.format(
+                            u=sgtk.support_url,
+                        ),
+                        version=self.max_version_year,
+                    ),
                 )
-            # and log the warning
-            self.log_warning(msg)
 
         self._safe_dialog = []
         # Keep the dialog to prevent the garbage collector from delete it
@@ -165,7 +267,7 @@ def eventFilter(self, obj, event):
         # possible that we'll get back a QCoreApplication from Max, which won't
         # carry references to a stylesheet. In that case, we apply our styling
         # to the dialog parent, which will be the top-level Max window.
-        if self._max_version_to_year(self._get_max_version()) < 2018:
+        if self.max_version_year < 2018:
             parent_widget = sgtk.platform.qt.QtCore.QCoreApplication.instance()
         else:
             parent_widget = self._get_dialog_parent()
@@ -175,7 +277,7 @@ def eventFilter(self, obj, event):
         if "toolkit 3dsmax style extension" not in curr_stylesheet:
             # If we're in pre-2017 Max then we need to handle our own styling. Otherwise
             # we just inherit from Max.
-            if self._max_version_to_year(self._get_max_version()) < 2017:
+            if self.max_version_year < 2017:
                 self._initialize_dark_look_and_feel()
 
             curr_stylesheet += "\n\n /* toolkit 3dsmax style extension */ \n\n"
@@ -239,7 +341,7 @@ def _post_app_init(self):
         Called from the main thread when all apps have initialized
         """
         # set up menu handler
-        if self._max_version_to_year(self._get_max_version()) >= 2025:
+        if self.max_version_year >= 2025:
             self._menu_generator = self.tk_3dsmax.MenuGenerator_callbacks(self)
             self._add_shotgun_menu()
 
@@ -361,8 +463,7 @@ def destroy_engine(self):
         Called when the engine is shutting down
         """
         self.log_debug("%s: Destroying..." % self)
-
-        if self._max_version_to_year(self._get_max_version()) < 2025:
+        if self.max_version_year < 2025:
             pymxs.runtime.callbacks.removeScripts(
                 pymxs.runtime.Name("postLoadingMenus"),
                 id=pymxs.runtime.Name("sg_tk_on_menus_loaded"),
@@ -410,7 +511,7 @@ def _get_dialog_parent(self):
         # Older versions of Max make use of special logic in _create_dialog
         # to handle window parenting. If we can, though, we should go with
         # the more standard approach to getting the main window.
-        if self._max_version_to_year(self._get_max_version()) > 2020:
+        if self.max_version_year > 2020:
             # getMAXHWND returned a float instead of a long, which was completely
             # unusable with PySide in 2017 to 2020, but starting 2021
             # we can start using it properly.
@@ -442,7 +543,7 @@ def show_panel(self, panel_id, title, bundle, widget_class, *args, **kwargs):
 
         self.log_debug("Begin showing panel %s" % panel_id)
 
-        if self._max_version_to_year(self._get_max_version()) <= 2017:
+        if self.max_version_year <= 2017:
             # Qt docking is supported in version 2018 and later.
             self.log_warning(
                 "Panel functionality not implemented. Falling back to showing "
@@ -657,17 +758,22 @@ def safe_dialog_exec(self, func):
                 dialog.activateWindow()  # for Windows
                 dialog.raise_()  # for MacOS
 
-    ##########################################################################################
-    # Latest supported max version
-    MAXIMUM_SUPPORTED_VERSION = 28000
-
-    def _max_version_to_year(self, version):
+    @property
+    def max_version_year(self):
         """
         Get the max year from the max release version.
-        Note that while 17000 is 2015, 17900 would be 2016 alpha
         """
-        year = 2000 + (math.ceil(version / 1000.0) - 2)
-        return year
+
+        if self._max_version_year is None:
+            max_version = self._get_max_version()
+            try:
+                assert isinstance(max_version[7], int)
+                self._max_version_year = max_version[7]
+            except (AssertionError, IndexError, TypeError) as err:
+                self.log_debug("Unable to extract Max version {}".format(err))
+                self._max_version_year = 0
+
+        return self._max_version_year
 
     def _get_max_version(self):
         """
@@ -677,7 +783,7 @@ def _get_max_version(self):
             # Make sure this gets executed from the main thread because pymxs can't be used
             # from a background thread.
             self._max_version = self.execute_in_main_thread(
-                lambda: pymxs.runtime.maxVersion()[0]
+                lambda: pymxs.runtime.maxVersion()
             )
         # 3dsMax Version returns a number which contains max version, sdk version, etc...
         return self._max_version

hooks/tk-multi-loader2/basic/scene_actions.py

@@ -161,7 +161,7 @@ def execute_action(self, name, params, sg_publish_data):
         # If this is an Alembic cache, then we can import that.
         if path.lower().endswith(".abc"):
             # Note that native Alembic support is only available in Max 2016+.
-            if app.engine._max_version_to_year(app.engine._get_max_version()) >= 2016:
+            if app.engine.max_version_year >= 2016:
                 self._import_alembic(path)
             else:
                 app.log_warning(

hooks/tk-multi-shotgunpanel/basic/scene_actions.py

@@ -118,10 +118,7 @@ def execute_action(self, name, params, sg_data):
             # If this is an Alembic cache, then we can import that.
             if name == "merge" and path.lower().endswith(".abc"):
                 # Note that native Alembic support is only available in Max 2016+.
-                if (
-                    app.engine._max_version_to_year(app.engine._get_max_version())
-                    >= 2016
-                ):
+                if app.engine.max_version_year >= 2016:
                     self._import_alembic(path)
                 else:
                     app.log_warning(

info.yml

@@ -52,9 +52,9 @@ configuration:
         type:           int
         description:    "Specify the minimum Application major version that will prompt a warning if
                         it isn't yet fully supported and tested with Toolkit.  To disable the warning
-                        dialog for the version you are testing, it is recomended that you set this
+                        dialog for the version you are testing, it is recommended that you set this
                         value to the current major version + 1."
-        default_value:  2026
+        default_value: 2026
 
     launch_builtin_plugins:
         type: list

startup.py

@@ -15,6 +15,9 @@
 
 from sgtk.platform import SoftwareLauncher, SoftwareVersion, LaunchInformation
 
+# Max versions compatibility constants
+VERSION_OLDEST_COMPATIBLE = 2021
+
 
 class MaxLauncher(SoftwareLauncher):
     """
@@ -28,7 +31,7 @@ def minimum_supported_version(self):
         """
         The minimum software version that is supported by the launcher.
         """
-        return "2021"
+        return str(VERSION_OLDEST_COMPATIBLE)
 
     def scan_software(self):
         """