Allow defining Python requirements through special packages

Author: Jackenmen

redbot/_update/cmd/cog_compatibility.py

@@ -90,6 +90,7 @@ async def _check_cog_compatibility_command_impl(
     if red_version is None or python_version is None:
         with console.status("Checking latest version..."):
             latest = await fetch_latest_red_version()
+            await latest.fetch_extra_info()
             red_version = latest.version
 
         python_version = Version(".".join(map(str, sys.version_info[:3])))

redbot/_update/updater.py

@@ -301,6 +301,7 @@ async def _prepare_metadata(self) -> None:
         with self.console.status("Checking latest version..."):
             available_versions = await fetch_available_red_versions()
             latest_major = available_versions[0]
+            await latest_major.fetch_extra_info()
 
         self.metadata = UpdaterMetadata(
             self.options,
@@ -347,6 +348,8 @@ async def _prepare_metadata(self) -> None:
                     )
                     raise SystemExit(1)
 
+        await self.metadata.latest.fetch_extra_info()
+
     async def _show_changelog(self) -> None:
         with self.console.status("Fetching changelogs..."):
             changelogs = await changelog.fetch_changelogs()

redbot/core/utils/_internal_utils.py

@@ -43,7 +43,7 @@
 from packaging.metadata import Metadata
 from packaging.requirements import Requirement
 from packaging.specifiers import SpecifierSet
-from packaging.utils import parse_sdist_filename
+from packaging.utils import canonicalize_name, parse_sdist_filename
 from packaging.version import Version
 import rapidfuzz
 import rich.progress
@@ -414,6 +414,16 @@ async def preprocessor(bot: Red, destination: discord.abc.Messageable, content:
     },
 )
 
+_REQUIRES_PYTHON_PKG_NAMES = tuple(
+    map(
+        canonicalize_name,
+        (
+            "Red-does-not-support-this-version-of-Python.-Please-follow-one-of-the-install-guides-at-docs.discord.red",
+            "package-does-not-support-this-version-of-python",
+        ),
+    )
+)
+
 
 class AvailableVersion:
     def __init__(self, version: Version, files: Dict[str, ReleaseFile]) -> None:
@@ -422,23 +432,51 @@ def __init__(self, version: Version, files: Dict[str, ReleaseFile]) -> None:
         required_pythons = {f.get("requires-python") or "" for f in files.values()}
         if len(required_pythons) > 1:
             raise ValueError("found multiple files with different Requires-Python values")
-        self.requires_python = SpecifierSet(required_pythons.pop())
+        self.base_requires_python = SpecifierSet(required_pythons.pop())
+        self._requires_python: Optional[SpecifierSet] = None
+        self._metadata: Optional[Metadata] = None
+
+    @property
+    def requires_python(self) -> SpecifierSet:
+        if self._requires_python is None:
+            raise TypeError(
+                "`requires_python` attribute is missing - call `fetch_extra_info()` first."
+            )
+        return self._requires_python
+
+    @property
+    def metadata(self) -> Metadata:
+        if self._metadata is None:
+            raise TypeError("`metadata` attribute is missing - call `fetch_extra_info()` first.")
+        return self._metadata
+
+    async def fetch_extra_info(self) -> None:
+        if self._metadata is not None:
+            return
+        metadata = await self._fetch_core_metadata()
+        # requires https://github.com/pypa/packaging/pull/1182
+        version_range = self.base_requires_python.to_range()
+        for req in metadata.requires_dist or ():
+            if canonicalize_name(req.name) in _REQUIRES_PYTHON_PKG_NAMES:
+                version_range &= ~req.specifier.to_range()
+        self._requires_python = version_range.to_specifier_set()
+        self._metadata = metadata
 
     @classmethod
     def from_json_dict(cls, data: Dict[str, Any]) -> Self:
         ret = cls(Version(data["version"]), data["files"])
-        if str(ret.requires_python) != data["requires_python"]:
+        if str(ret.base_requires_python) != data["base_requires_python"]:
             raise ValueError("requires_python key in given data is inconsistent with files")
         return ret
 
     def to_json_dict(self) -> Dict[str, Any]:
         return {
             "version": str(self.version),
-            "requires_python": str(self.requires_python),
+            "base_requires_python": str(self.base_requires_python),
             "files": self.files,
         }
 
-    async def fetch_core_metadata(self) -> Metadata:
+    async def _fetch_core_metadata(self) -> Metadata:
         for release_file in self.files.values():
             core_metadata_hashes = release_file.get("core-metadata", False)
             if core_metadata_hashes is False: