Bump tk-core to v0.23.5 (#147)

Author: carlos-villavicencio-adsk

python/tk-core/commit_id

@@ -1 +1 @@
-16655ba7b0141d457135ed870eee7fc0d5a04076
+62d128a8a3e06fe37cc9de5c6a699415c6b51c70

python/tk-core/info.yml

@@ -12,7 +12,7 @@
 # This is automatically replaced with appropriate values
 # as the core bundle is uploaded to the app store.
 
-version: "v0.23.2"
+version: "v0.23.5"
 documentation_url: "https://help.autodesk.com/view/SGDEV/ENU/?contextId=SA_INTEGRATIONS_USER_GUIDE"
 requires_shotgun_version: "v5.0.0"
 

python/tk-core/python/tank/__init__.py

@@ -36,12 +36,30 @@
 import warnings
 
 if sys.version_info < (3, 7):
-    raise Exception("This module requires Python version 3.7 or higher.")
+    if os.environ.get("SHOTGUN_ALLOW_OLD_PYTHON", "0") != "1":
+        # This is our preferred default behavior when using an old
+        # unsupported Python version.
+        # This way, we can control where the exception is raised, and it provides a
+        # comprehensive error message rather than having users facing a random
+        # Python traceback and trying to understand this is due to using an
+        # unsupported Python version.
+
+        raise RuntimeError("This module requires Python version 3.7 or higher.")
+
+    warnings.warn(
+        "Python versions older than 3.7 are no longer supported as of January "
+        "2023. Since the SHOTGUN_ALLOW_OLD_PYTHON variable is enabled, this "
+        "module is raising a warning instead of an exception. "
+        "However, it is very likely that this module will not be able to work "
+        "on this Python version.",
+        RuntimeWarning,
+        stacklevel=2,
+    )
 elif sys.version_info < (3, 9):
     warnings.warn(
-        "Python versions older than 3.9 are no longer supported since 2025-03 "
-        "and compatibility will be removed at any time after 2026-01. "
-        "Please update to Python 3.9 or a newer supported version.",
+        "Python versions older than 3.9 are no longer supported as of March "
+        "2025 and compatibility will be discontinued after March 2026. "
+        "Please update to Python 3.11 or any other supported version.",
         DeprecationWarning,
         stacklevel=2
     )

python/tk-core/python/tank/authentication/sso_saml2/core/__init__.py

@@ -43,23 +43,23 @@ def __getattr__(name):
         if is_import:
             raise
 
+        deprecation_message = (
+            f"Accessing '{__name__}.{name}' directly without explicit import "
+            "is deprecated and compatibility will be discontinued after "
+            f"September 2026. Explicitly import '{__name__}.{name}' instead."
+        )
+
         import warnings
         warnings.warn(
-            f"Accessing '{__name__}.{name}' directly without explicit import "
-            "is deprecated and will be removed at any time after 2026-07. "
-            f"Explicitly import '{__name__}.{name}' instead.",
+            deprecation_message,
             DeprecationWarning,
             stacklevel=2,
         )
 
         try:
             import tank
             logger = tank.LogManager.get_logger(__name__)
-            logger.warning(
-               f"Accessing '{__name__}.{name}' directly without explicit import "
-                "is deprecated and will be removed at any time after 2026-07. "
-                f"Explicitly import '{__name__}.{name}' instead.",
-            )
+            logger.warning(deprecation_message)
         except:
             pass # nosec
 

python/tk-core/python/tank/commands/install.py

@@ -239,7 +239,7 @@ def _run(self, log, env_name, engine_instance_name, app_name, preserve_yaml):
                 % (env_name, engine_instance_name)
             )
 
-        if app_name.endswith(".git"):
+        if util.is_git_repo_uri(app_name):
             # this is a git location!
             # run descriptor factory method
             log.info("Connecting to git...")
@@ -534,7 +534,7 @@ def _run(self, log, env_name, engine_name, preserve_yaml):
                 % (env_name, e)
             )
 
-        if engine_name.endswith(".git"):
+        if util.is_git_repo_uri(engine_name):
             # this is a git location!
             # run descriptor factory method
             log.info("Connecting to git...")

python/tk-core/python/tank/commands/setup_project_params.py

@@ -14,6 +14,7 @@
 import sys
 
 from . import constants
+from . import util
 
 from ..util import StorageRoots
 from ..util import sgre as re
@@ -1171,7 +1172,7 @@ def _process_config(self, config_uri):
         # tk-config-xyz
         # /path/to/file.zip
         # /path/to/folder
-        if config_uri.endswith(".git"):
+        if util.is_git_repo_uri(config_uri):
             # this is a git repository!
             self._log.info("Hang on, loading configuration from git...")
             descriptor = self._create_git_descriptor(config_uri)

python/tk-core/python/tank/commands/switch.py

@@ -130,7 +130,7 @@ def run_interactive(self, log, args):
 
         if fourth_param == "app_store":
             mode = "app_store"
-        elif fourth_param.endswith(".git"):
+        elif util.is_git_repo_uri(fourth_param):
             mode = "git"
             path = fourth_param
         else:

python/tk-core/python/tank/commands/util.py

@@ -12,10 +12,12 @@
 Utility methods that are specific to tank commands
 """
 
+from typing import List, Tuple
+
 from . import constants
 
 
-def should_use_legacy_yaml_parser(args):
+def should_use_legacy_yaml_parser(args: List[str]) -> Tuple[bool, List[str]]:
     """
     Given a set of command line args, determine if the
     legacy yaml parser should be used.
@@ -33,3 +35,19 @@ def should_use_legacy_yaml_parser(args):
         legacy_parser = False
 
     return (legacy_parser, args)
+
+
+def is_git_repo_uri(uri: str) -> bool:
+    """
+    Checks if the given config URI is a Git repository URI.
+    """
+    return any(
+        (
+            # GitHub repo URLs end with .git
+            uri.endswith(".git"),
+            # Git SSH URLs start with git@
+            uri.startswith("git@"),
+            # Azure DevOps repo URLs contain `_git` in the HTTPS URLs
+            uri.startswith("https://") and "_git" in uri,
+        )
+    )

python/tk-core/python/tank/util/version.py

@@ -7,34 +7,41 @@
 # By accessing, using, copying or modifying this work you indicate your
 # agreement to the Shotgun Pipeline Toolkit Source Code License. All rights
 # not expressly granted therein are reserved by Shotgun Software Inc.
-import warnings
 import contextlib
-import sys
-
-LooseVersion = None
-try:
-    import packaging.version
-except ModuleNotFoundError:
-    try:
-        # Try importing from setuptools.
-        # If it fails, then we can't do much at the moment
-        # The DCC should have either setuptools or packaging installed.
-        from setuptools._distutils.version import LooseVersion
-    except ModuleNotFoundError:
-        try:
-            # DCCs with older versions of Python 3.12
-            from distutils.version import LooseVersion
-        except ModuleNotFoundError:
-            pass
+import warnings
+
+from tank_vendor.packaging.version import parse as version_parse
 
-from . import sgre as re
 from .. import LogManager
 from ..errors import TankError
-
+from . import sgre as re
 
 logger = LogManager.get_logger(__name__)
 GITHUB_HASH_RE = re.compile("^[0-9a-fA-F]{7,40}$")
 
+# Normalize non-standard version formats
+# into PEP 440–compliant forms ("1.2.3") to ensure compatibility with
+# Python’s version parsing utilities (e.g., packaging.version.parse).
+# Reference: https://peps.python.org/pep-0440/
+_VERSION_PATTERNS = [
+    (  # Extract version from software names: "Software Name 21.0" -> "21.0"
+        re.compile(r"^[a-zA-Z\s]+(\d+(?:\.\d+)*(?:v\d+(?:\.\d+)*)?)$"),
+        r"\1",
+    ),
+    (  # Dot-v format: "6.3v6" -> "6.3.6"
+        re.compile(r"^(\d+)\.(\d+)v(\d+)$"),
+        r"\1.\2.\3",
+    ),
+    (  # Simple v format: "2019v0.1" -> "2019.0.1"
+        re.compile(r"^(\d+)v(\d+(?:\.\d+)*)$"),
+        r"\1.\2",
+    ),
+    (  # Service pack with/without dot: "2017.2sp1" or "2017.2.sp1" -> "2017.2.post1"
+        re.compile(r"^(\d+(?:\.\d+)*)\.?(sp|hotfix|hf)(\d+)$"),
+        r"\1.post\3",
+    ),
+]
+
 
 def is_version_head(version):
     """
@@ -150,28 +157,29 @@ def suppress_known_deprecation():
         yield ctx
 
 
-def version_parse(version_string):
+def normalize_version_format(version: str) -> str:
     """
-    Parse a version string into a Version object. We also support LooseVersion
-    for compatibility with older versions of Python.
+    Normalize version strings by applying common format transformations.
+
+    This function exists because packaging.version.parse() follows PEP 440
+    and cannot handle non-standard version formats like "v1.2.3" or "6.3v6",
+    which are commonly found in various software tools and DCCs but don't
+    conform to the PEP 440 specification.
 
-    :param str version_string: The version string to parse.
+    Transformations applied:
+    - Extract version numbers from software names: "Software Name 21.0" -> "21.0"
+    - Convert dot-v format: "6.3v6" -> "6.3.6"
+    - Convert simple v format: "2019v0.1" -> "2019.0.1"
+    - Convert service pack formats: "2017.2sp1" -> "2017.2.post1", "2017.2.sp1" -> "2017.2.post1"
 
-    :rtype: packaging.version.Version, LooseVersion or str as fallback.
+    :param str version: Version string to normalize
+    :return str: Normalized version string compatible with PEP 440
     """
-    if "packaging" in sys.modules:
-        try:
-            return packaging.version.parse(version_string)
-        except packaging.version.InvalidVersion:
-            # Version cannot be parsed with packaging.version (SG-40480)
-            pass
 
-    if LooseVersion:
-        with suppress_known_deprecation():
-            return LooseVersion(version_string)
+    for compiled_pattern, replacement in _VERSION_PATTERNS:
+        version = compiled_pattern.sub(replacement, version)
 
-    # Fallback to string comparison
-    return version_string
+    return version
 
 
 def _compare_versions(a, b):
@@ -205,79 +213,12 @@ def _compare_versions(a, b):
         # comparing against HEAD - our version is always old
         return False
 
-    if a.startswith("v"):
-        a = a[1:]
-    if b.startswith("v"):
-        b = b[1:]
-
-    if "packaging" in sys.modules:
-        version_a = version_parse(a)
-        version_b = version_parse(b)
-        if isinstance(version_a, str) or isinstance(version_b, str):
-            return a > b
-
-        return version_a > version_b
-
-    if LooseVersion:
-        # In Python 3, LooseVersion comparisons between versions where a non-numeric
-        # version component is compared to a numeric one fail.  We'll work around this
-        # as follows:
-        # First, try to use LooseVersion for comparison.  This should work in
-        # most cases.
-        try:
-            with suppress_known_deprecation():
-                # Supress `distutils Version classes are deprecated.` for Python 3.10
-                version_a = LooseVersion(a).version
-                version_b = LooseVersion(b).version
-
-                version_num_a = []
-                version_num_b = []
-                # taking only the integers of the version to make comparison
-                for version in version_a:
-                    if isinstance(version, (int)):
-                        version_num_a.append(version)
-                    elif version == "-":
-                        break
-                for version in version_b:
-                    if isinstance(version, (int)):
-                        version_num_b.append(version)
-                    elif version == "-":
-                        break
-
-                # Comparing equal number versions with with one of them with '-' appended, if a version
-                # has '-' appended it's older than the same version with '-' at the end
-                if version_num_a == version_num_b:
-                    if "-" in a and "-" not in b:
-                        return False  # False, version a is older than b
-                    elif "-" in b and "-" not in a:
-                        return True  # True, version a is older than b
-                    else:
-                        return LooseVersion(a) > LooseVersion(
-                            b
-                        )  # If both has '-' compare '-rcx' versions
-                else:
-                    return LooseVersion(a) > LooseVersion(
-                        b
-                    )  # If they are different numeric versions
-        except TypeError:
-            version_expr = re.compile(r"^((?:\d+)(?:\.\d+)*)(.+)$")
-            match_a = version_expr.match(a)
-            match_b = version_expr.match(b)
-            if match_a and match_b:
-                # If we could get two numeric versions, generate LooseVersions for
-                # them.
-                ver_a = LooseVersion(match_a.group(1))
-                ver_b = LooseVersion(match_b.group(1))
-                if ver_a != ver_b:
-                    # If they're not identical, return based on this comparison
-                    return ver_a > ver_b
-                else:
-                    # If the numeric versions do match, do a string comparsion for
-                    # the rest.
-                    return match_a.group(2) > match_b.group(2)
-            elif match_a or match_b:
-                # If only one had a numeric version, treat that as the newer version.
-                return bool(match_a)
-
-    # In the case that both versions are non-numeric, do a string comparison.
-    return a > b
+    a = normalize_version_format(a)
+    b = normalize_version_format(b)
+
+    # Use packaging.version (either system or vendored)
+    # This is now guaranteed to be available
+    version_a = version_parse(a)
+    version_b = version_parse(b)
+
+    return version_a > version_b

python/tk-core/python/tank_vendor/packaging/__init__.py

@@ -0,0 +1,15 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "25.0"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "[email protected]"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = f"2014 {__author__}"