Fixed machine comparisons via default variant

Author: rgaudin

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+[Unreleased]
+
+### Changed
+
+- Default-variant-safe `Platform` comparison (fixes linux/arm64/v8 not == linux/arm64)
+
 ## [1.0] - 2023-08-10
 
 ### Added

src/docker_export/__init__.py

@@ -140,6 +140,14 @@ def __repr__(self):
             value += f"/{self.variant}"
         return value
 
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, Platform):
+            return False
+        if self.os != __value.os or self.architecture != __value.architecture:
+            return False
+        default_variant: str = self.default_variant(self.architecture)
+        return (self.variant or default_variant) == (__value.variant or default_variant)
+
     @classmethod
     def parse(cls, platform_str: str) -> Platform:
         if platform_str == "auto":
@@ -161,6 +169,8 @@ def parse(cls, platform_str: str) -> Platform:
             architecture = "amd64"
         if architecture == "arm32":
             architecture = "arm"
+        if architecture == "i386":
+            architecture = "386"
 
         if os not in ("linux", "windows"):
             raise ValueError(f"Invalid OS “{os}” from `{platform_str}`")
@@ -180,11 +190,6 @@ def parse(cls, platform_str: str) -> Platform:
         ):
             raise ValueError(f"Invalid arch “{architecture}” from `{platform_str}`")
 
-        if architecture == "arm" and not variant:
-            raise ValueError(
-                f"Missing variant for arch “{architecture}” from `{platform_str}`"
-            )
-
         return cls(architecture=architecture, os=os, variant=variant)
 
     @classmethod
@@ -204,7 +209,7 @@ def auto(cls):
             return cls.parse("linux/arm64/v8")
         elif machine.startswith("arm"):
             return cls.parse("linux/arm/v6")
-        elif machine.startswith("i686") or machine.startswith("i386"):
+        elif re.match(r"^i(3|5|6)86", machine):
             return cls.parse("linux/i386")
         return cls.parse("linux/amd64")
 
@@ -216,18 +221,6 @@ def from_payload(cls, payload: dict[str, str]):
             variant=payload.get("variant", ""),
         )
 
-    def match(self, payload: dict[str, str]) -> bool:
-        if self.variant and self.variant != (
-            # allows matching linux/arm64 images with linux/arm/v8 requests
-            payload.get("variant")
-            or self.default_variant(payload.get("architecture", ""))
-        ):
-            return False
-
-        return self.os == payload.get("os") and self.architecture == payload.get(
-            "architecture"
-        )
-
 
 @dataclass
 class Image:
@@ -431,7 +424,7 @@ def get_layers_from_v1_manifest(
     architecture = manifest.get("architecture", "amd64")
     os = manifest.get("os", "linux")
 
-    if not platform.match({"architecture": architecture, "os": os}):
+    if platform != Platform(architecture=architecture, os=os, variant=""):
         raise ValueError(
             f"Requested platform ({platform}) is not available "
             f"for single-platform image {image}"
@@ -476,15 +469,16 @@ def get_layers_manifest(image: Image, platform: Platform, auth: RegistryAuth):
         manifest = fat_manifests
     else:
         # multi-platform image
+        platforms: list[Platform] = []
         for arch_manifest in fat_manifests.get("manifests", []):
-            if platform.match(arch_manifest.get("platform", {})):
+            if not arch_manifest.get("platform"):
+                continue
+            manifest_platform = Platform.from_payload(arch_manifest["platform"])
+            if platform == manifest_platform:
                 manifest = get_layers_manifest_for(image, auth, arch_manifest["digest"])
+            platforms.append(manifest_platform)
 
         if not manifest:
-            platforms = [
-                Platform.from_payload(man.get("platform"))
-                for man in fat_manifests.get("manifests", [])
-            ]
             raise V2ImageNotFoundError(image, platform, platforms)
 
     logger.debug(f"layers_manifest={format_json(manifest)}")
@@ -778,16 +772,15 @@ def get_image_digest(image: Image, platform: Platform) -> str:
         if platform != platform.default():
             raise V1ImageNotFoundError(image=image, platform=platform)
         return fat_manifests["config"]["digest"]
-    else:
-        # multi-platform image
-        platforms: list[Platform] = []
-        for arch_manifest in fat_manifests.get("manifests", []):
-            if not arch_manifest.get("platform"):
-                continue
-            manifest_platform = Platform.from_payload(arch_manifest["platform"])
-            if platform == manifest_platform:
-                return arch_manifest["digest"]
-            platforms.append(manifest_platform)
+    # multi-platform image
+    platforms: list[Platform] = []
+    for arch_manifest in fat_manifests.get("manifests", []):
+        if not arch_manifest.get("platform"):
+            continue
+        manifest_platform = Platform.from_payload(arch_manifest["platform"])
+        if platform == manifest_platform:
+            return arch_manifest["digest"]
+        platforms.append(manifest_platform)
 
     raise V2ImageNotFoundError(image=image, platform=platform, platforms=platforms)
 

tests/test_digest.py

@@ -33,6 +33,11 @@
             "linux/arm64",
             "sha256:f7d859179210c4407447e4e37e401cefc831dfe3e686b66988a225417db884c8",
         ),
+        (
+            f"{kiwix_tools}:3.5.0-2",
+            "linux/arm64/v8",
+            "sha256:f7d859179210c4407447e4e37e401cefc831dfe3e686b66988a225417db884c8",
+        ),
         (
             f"{kiwix_tools}:3.5.0-2",
             "linux/armv7",

tests/test_platform.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Any
-
 import pytest
 
 from docker_export import Platform
@@ -54,32 +52,19 @@ def test_from_payload():
 
 
 @pytest.mark.parametrize(
-    "value_a, payload, should_match",
+    "value_a, value_b, should_match",
     [
-        ("linux/amd64", {"architecture": "linux", "os": "amd64"}, False),
-        ("linux/amd64", {"architecture": "amd64", "os": "linux"}, True),
-        (
-            "linux/amd64",
-            {"architecture": "amd64", "os": "linux", "variant": "v3"},
-            True,
-        ),
-        ("linux/armv6", {"architecture": "arm", "os": "linux", "variant": "v6"}, True),
-        ("linux/armv6", {"architecture": "arm", "os": "linux"}, False),
-        ("linux/armv6", {"architecture": "arm", "os": "linux", "variant": "v7"}, False),
-        ("linux/armv6", {"architecture": "arm", "os": "linux", "variant": "v8"}, False),
-        ("linux/armv7", {"architecture": "arm", "os": "linux"}, True),
-        ("linux/armv7", {"architecture": "arm", "os": "linux", "variant": "v7"}, True),
-        (
-            "linux/arm64/v8",
-            {"architecture": "arm64", "os": "linux", "variant": "v8"},
-            True,
-        ),
-        (
-            "linux/arm64",
-            {"architecture": "arm64", "os": "linux", "variant": "v8"},
-            True,
-        ),
+        ("linux/amd64", "linux/amd64", True),
+        ("linux/amd64", "linux/amd64/v3", False),
+        ("linux/armv6", "linux/arm", False),
+        ("linux/armv7", "linux/arm", True),
+        ("linux/armv6", "linux/arm/v6", True),
+        ("linux/armv6", "linux/arm/v7", False),
+        ("linux/armv6", "linux/arm/v8", False),
+        ("linux/armv7", "linux/arm/v7", True),
+        ("linux/arm64/v8", "linux/arm64/v8", True),
+        ("linux/arm64", "linux/arm64/v8", True),
     ],
 )
-def test_match(*, value_a: str, payload: dict[str, Any], should_match: bool):
-    assert Platform.parse(value_a).match(payload) is should_match
+def test_match(*, value_a: str, value_b: str, should_match: bool):
+    assert (Platform.parse(value_a) == Platform.parse(value_b)) is should_match