Subclassed version of Version that supports -platform

Author: tony

libtmux/_compat.py

@@ -28,10 +28,13 @@ def str_from_console(s):
 
 
 try:
+    import collections
+    import functools
     import re
     from typing import Iterator, List, Tuple
 
-    from packaging.version import Version, _BaseVersion
+    from packaging import version as V
+    from packaging.version import VERSION_PATTERN, Version, _BaseVersion
 
     ###
     ### Legacy support for LooseVersion / LegacyVersion, e.g. 2.4-openbsd
@@ -127,6 +130,126 @@ def base_version(self) -> str:
         def epoch(self) -> int:
             return -1
 
+    @functools.total_ordering
+    class _VersionCmpMixin:
+        # Credit: @layday
+        # Link: https://github.com/pypa/packaging/issues/465#issuecomment-1013715662
+        def __eq__(self, other: object) -> bool:
+            if isinstance(other, str):
+                other = self.__class__(other)
+            return super().__eq__(other)
+
+        def __lt__(self, other: object) -> bool:
+            if isinstance(other, str):
+                other = self.__class__(other)
+            return super().__lt__(other)
+
+    _Version = collections.namedtuple(
+        "_Version", ["epoch", "release", "dev", "pre", "post", "local", "platform"]
+    )
+
+    def _cmpkey(
+        epoch,  # type: int
+        release,  # type: Tuple[int, ...]
+        pre,  # type: Optional[Tuple[str, int]]
+        post,  # type: Optional[Tuple[str, int]]
+        dev,  # type: Optional[Tuple[str, int]]
+        local,  # type: Optional[Tuple[SubLocalType]]
+        platform,  # type: Optional[Tuple[SubLocalType]]
+    ):
+        return V._cmpkey(epoch, release, pre, post, dev, local) + (
+            tuple(
+                (i, "") if isinstance(i, int) else (V.NegativeInfinity, i)
+                for i in platform
+            )
+        )
+
+    class LegacyVersion(Version):
+        _regex = re.compile
+        _regex = re.compile(
+            r"^\s*"
+            + VERSION_PATTERN
+            + r"(?:(?P<platform>(?:[-_\.][a-z0-9]+)*))?       # platform version"
+            + r"\s*$",
+            re.VERBOSE | re.IGNORECASE,
+        )
+
+        def __init__(self, version):
+            # type: (str) -> None
+
+            # Validate the version and parse it into pieces
+            match = self._regex.search(version)
+            if not match:
+                raise V.InvalidVersion("Invalid version: '{0}'".format(version))
+
+            # Store the parsed out pieces of the version
+            self._version = _Version(
+                epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+                release=tuple(int(i) for i in match.group("release").split(".")),
+                pre=V._parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+                post=V._parse_letter_version(
+                    match.group("post_l"),
+                    match.group("post_n1") or match.group("post_n2"),
+                ),
+                dev=V._parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+                local=V._parse_local_version(match.group("local")),
+                platform=str(match.group("platform"))
+                if match.group("platform")
+                else "",
+            )
+
+            # Generate a key which will be used for sorting
+            self._key = _cmpkey(
+                self._version.epoch,
+                self._version.release,
+                self._version.pre,
+                self._version.post,
+                self._version.dev,
+                self._version.local,
+                self._version.platform,
+            )
+
+        @property
+        def platform(self):
+            # type: () -> Optional[str]
+            if self._version.platform:
+                return ".".join(str(x) for x in self._version.platform)
+            else:
+                return None
+
+        def __str__(self):
+            # type: () -> str
+            parts = []
+
+            # Epoch
+            if self.epoch != 0:
+                parts.append("{0}!".format(self.epoch))
+
+            # Release segment
+            parts.append(".".join(str(x) for x in self.release))
+
+            # Pre-release
+            if self.pre is not None:
+                parts.append("".join(str(x) for x in self.pre))
+
+            # Post-release
+            if self.post is not None:
+                parts.append(".post{0}".format(self.post))
+
+            # Development release
+            if self.dev is not None:
+                parts.append(".dev{0}".format(self.dev))
+
+            # Local version segment
+            if self.local is not None:
+                parts.append("+{0}".format(self.local))
+
+            # Platform version segment
+            if self.platform is not None:
+                parts.append("_{0}".format(self.platform))
+
+            return "".join(parts)
+
     LooseVersion = LegacyVersion
 except ImportError:
     from distutils.version import LooseVersion, Version