flyte 0.2.0b14__py3-none-any.whl → 0.2.0b15__py3-none-any.whl

flyte/__init__.py

@@ -35,6 +35,7 @@ __all__ = [
     "Timeout",
     "TimeoutType",
     "__version__",
+    "build",
     "ctx",
     "deploy",
     "group",
@@ -48,6 +49,7 @@ __all__ = [
 
 import sys
 
+from ._build import build
 from ._cache import Cache, CachePolicy, CacheRequest
 from ._context import ctx
 from ._deploy import deploy
@@ -69,3 +71,10 @@ from ._trace import trace
 from ._version import __version__
 
 sys.excepthook = custom_excepthook
+
+
+def version() -> str:
+    """
+    Returns the version of the Flyte SDK.
+    """
+    return __version__

flyte/_bin/runtime.py

@@ -118,9 +118,9 @@ def main(
     # File "src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi", line 147,
     # in grpc._cython.cygrpc.PollerCompletionQueue._handle_events
     # BlockingIOError: [Errno 11] Resource temporarily unavailable
-    # init(org=org, project=project, domain=domain, **controller_kwargs)
+    init(org=org, project=project, domain=domain, **controller_kwargs)
     # TODO solution is to use a single channel for both controller and reference tasks, but this requires a refactor
-    init()
+    # init()
     # Controller is created with the same kwargs as init, so that it can be used to run tasks
     controller = create_controller(ct="remote", **controller_kwargs)
 

flyte/_code_bundle/_packaging.py

@@ -91,7 +91,7 @@ def list_files_to_bundle(
     ignore = IgnoreGroup(source, *ignores)
 
     ls, ls_digest = ls_files(source, copy_style, deref_symlinks, ignore)
-    logger.debug(f"Hash digest: {ls_digest}")
+    logger.debug(f"Hash of files to be included in the code bundle: {ls_digest}")
     return ls, ls_digest
 
 

flyte/_deploy.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 import rich.repr
 
+import flyte.errors
 from flyte.models import SerializationContext
 from flyte.syncify import syncify
 
@@ -83,14 +84,18 @@ async def _deploy_task(
     Deploy the given task.
     """
     ensure_client()
+    from ._internal.runtime.convert import convert_upload_default_inputs
     from ._internal.runtime.task_serde import translate_task_to_wire
     from ._protos.workflow import task_definition_pb2, task_service_pb2
 
     image_uri = task.image.uri if isinstance(task.image, Image) else task.image
 
-    spec = translate_task_to_wire(task, serialization_context)
     if dryrun:
-        return spec
+        return translate_task_to_wire(task, serialization_context)
+
+    default_inputs = await convert_upload_default_inputs(task.interface)
+    spec = translate_task_to_wire(task, serialization_context, default_inputs=default_inputs)
+
     msg = f"Deploying task {task.name}, with image {image_uri} version {serialization_context.version}"
     if spec.task_template.HasField("container") and spec.task_template.container.args:
         msg += f" from {spec.task_template.container.args[-3]}.{spec.task_template.container.args[-1]}"
@@ -128,16 +133,16 @@ async def build_images(deployment: DeploymentPlan) -> ImageCache:
     image_identifier_map = {}
     for env_name, env in deployment.envs.items():
         if not isinstance(env.image, str):
-            logger.info(f"Building Image for environment {env_name}, image: {env.image}")
+            logger.warning(f"Building Image for environment {env_name}, image: {env.image}")
             images.append(_build_image_bg(env_name, env.image))
 
         elif env.image == "auto" and "auto" not in image_identifier_map:
-            auto_image = Image.auto()
+            auto_image = Image.from_debian_base()
             image_identifier_map["auto"] = auto_image.uri
     final_images = await asyncio.gather(*images)
 
     for env_name, image_uri in final_images:
-        logger.info(f"Built Image for environment {env_name}, image: {image_uri}")
+        logger.warning(f"Built Image for environment {env_name}, image: {image_uri}")
         env = deployment.envs[env_name]
         if isinstance(env.image, Image):
             image_identifier_map[env.image.identifier] = env.image.uri
@@ -151,12 +156,14 @@ async def apply(deployment: DeploymentPlan, copy_style: CopyFiles, dryrun: bool
 
     cfg = get_common_config()
     image_cache = await build_images(deployment)
-    if copy_style == "none":
-        code_bundle = None
-        assert deployment.version is not None, "Version must be set when copy_style is none"
+
+    version = deployment.version
+    code_bundle = None
+    if copy_style == "none" and not version:
+        raise flyte.errors.DeploymentError("Version must be set when copy_style is none")
     else:
         code_bundle = await build_code_bundle(from_dir=cfg.root_dir, dryrun=dryrun, copy_style=copy_style)
-        deployment.version = code_bundle.computed_version
+        version = version or code_bundle.computed_version
         # TODO we should update the version to include the image cache digest and code bundle digest. This is
         # to ensure that changes in image dependencies, cause an update to the deployment version.
         # TODO Also hash the environment and tasks to ensure that changes in the environment or tasks
@@ -166,7 +173,7 @@ async def apply(deployment: DeploymentPlan, copy_style: CopyFiles, dryrun: bool
         domain=cfg.domain,
         org=cfg.org,
         code_bundle=code_bundle,
-        version=deployment.version,
+        version=version,
         image_cache=image_cache,
         root_dir=cfg.root_dir,
     )
@@ -195,7 +202,7 @@ def _recursive_discover(
         if env.name in planned_envs:
             continue
         # Recursively discover dependent environments
-        for dependent_env in env.env_dep_hints:
+        for dependent_env in env.depends_on:
             _recursive_discover(planned_envs, dependent_env)
         # Add the environment to the existing envs
         planned_envs[env.name] = env

flyte/_environment.py

@@ -28,12 +28,12 @@ class Environment:
     :param resources: Resources to allocate for the environment.
     :param env: Environment variables to set for the environment.
     :param secrets: Secrets to inject into the environment.
-    :param env_dep_hints: Environment dependencies to hint, so when you deploy the environment, the dependencies are
+    :param depends_on: Environment dependencies to hint, so when you deploy the environment, the dependencies are
         also deployed. This is useful when you have a set of environments that depend on each other.
     """
 
     name: str
-    env_dep_hints: List[Environment] = field(default_factory=list)
+    depends_on: List[Environment] = field(default_factory=list)
     pod_template: Optional[Union[str, "V1PodTemplate"]] = None
     description: Optional[str] = None
     secrets: Optional[SecretRequest] = None
@@ -49,7 +49,7 @@ class Environment:
         """
         Add a dependency to the environment.
         """
-        self.env_dep_hints.extend(env)
+        self.depends_on.extend(env)
 
     def clone_with(
         self,
@@ -58,7 +58,7 @@ class Environment:
         resources: Optional[Resources] = None,
         env: Optional[Dict[str, str]] = None,
         secrets: Optional[SecretRequest] = None,
-        env_dep_hints: Optional[List[Environment]] = None,
+        depends_on: Optional[List[Environment]] = None,
         **kwargs: Any,
     ) -> Environment:
         raise NotImplementedError
@@ -68,7 +68,7 @@ class Environment:
         Get the keyword arguments for the environment.
         """
         kwargs: Dict[str, Any] = {
-            "env_dep_hints": self.env_dep_hints,
+            "depends_on": self.depends_on,
             "image": self.image,
         }
         if self.resources is not None:

flyte/_image.py

@@ -238,18 +238,17 @@ class Image:
     registry: Optional[str] = field(default=None)
     name: Optional[str] = field(default=None)
     platform: Tuple[Architecture, ...] = field(default=("linux/amd64",))
-    tag: Optional[str] = field(default=None)
     python_version: Tuple[int, int] = field(default_factory=_detect_python_version)
 
     # For .auto() images. Don't compute an actual identifier.
     _identifier_override: Optional[str] = field(default=None, init=False)
-    # This is set on default images. These images are built from the base Dockerfile in this library and shouldn't be
-    # modified with additional layers.
-    is_final: bool = field(default=False)
 
     # Layers to be added to the image. In init, because frozen, but users shouldn't access, so underscore.
     _layers: Tuple[Layer, ...] = field(default_factory=tuple)
 
+    # Only settable internally.
+    _tag: Optional[str] = field(default=None, init=False)
+
     _DEFAULT_IMAGE_PREFIXES: ClassVar = {
         PYTHON_3_10: "py3.10-",
         PYTHON_3_11: "py3.11-",
@@ -257,6 +256,25 @@ class Image:
         PYTHON_3_13: "py3.13-",
     }
 
+    # class-level token not included in __init__
+    _token: ClassVar[object] = object()
+
+    # check for the guard that we put in place
+    def __post_init__(self):
+        if object.__getattribute__(self, "__dict__").pop("_guard", None) is not Image._token:
+            raise TypeError(
+                "Direct instantiation of Image not allowed, please use one of the various from_...() methods instead"
+            )
+
+    # Private constructor for internal use only
+    @classmethod
+    def _new(cls, **kwargs) -> Image:
+        # call the normal __init__, injecting a private keyword that users won't know
+        obj = cls.__new__(cls)  # allocate
+        object.__setattr__(obj, "_guard", cls._token)  # set guard to prevent direct construction
+        cls.__init__(obj, **kwargs)  # run dataclass generated __init__
+        return obj
+
     @cached_property
     def identifier(self) -> str:
         """
@@ -273,10 +291,9 @@ class Image:
         if self._identifier_override:
             return self._identifier_override
 
-        # Only get the non-None values in the ImageSpec to ensure the hash is consistent
+        # Only get the non-None values in the Image to ensure the hash is consistent
         # across different SDK versions.
-        # Can potentially add a second hashing function to the Layer protocol, but relying on just asdict/str
-        # representation for now.
+        # Layers can specify a _compute_identifier optionally, but the default will just stringify
         image_dict = asdict(self, dict_factory=lambda x: {k: v for (k, v) in x if v is not None and k != "_layers"})
         layers_str_repr = "".join([layer._compute_identifier(layer) for layer in self._layers])
         image_dict["layers"] = layers_str_repr
@@ -293,16 +310,16 @@ class Image:
         # this default image definition may need to be updated once there is a released pypi version
         from flyte._version import __version__
 
-        dev_mode = cls._is_editable_install() or (__version__ and "dev" in __version__)
+        dev_mode = (cls._is_editable_install() or (__version__ and "dev" in __version__)) and not flyte_version
         if flyte_version is None:
             flyte_version = __version__.replace("+", "-")
         preset_tag = flyte_version if flyte_version.startswith("v") else f"v{flyte_version}"
         preset_tag = f"py{python_version[0]}.{python_version[1]}-{preset_tag}"
-        image = Image(
+        image = Image._new(
             base_image=f"python:{python_version[0]}.{python_version[1]}-slim-bookworm",
             registry=_BASE_REGISTRY,
             name=_DEFAULT_IMAGE_NAME,
-            tag=preset_tag,
+            # _tag=preset_tag,
             platform=("linux/amd64", "linux/arm64"),
         )
         labels_and_user = _DockerLines(
@@ -323,17 +340,17 @@ class Image:
                 "UV_LINK_MODE": "copy",
             }
         )
-        image = image.with_apt_packages(["build-essential", "ca-certificates"])
-
-        base_packages = ["kubernetes", "msgpack", "mashumaro"]
+        image = image.with_apt_packages("build-essential", "ca-certificates")
 
         # Add in flyte library
         if dev_mode:
-            image = image.with_pip_packages(base_packages)
-            image = image.with_local_v2()
+            image = image._with_local_v2()
         else:
-            base_packages.append(f"flyte=={flyte_version}")
-            image = image.with_pip_packages(base_packages)
+            image = image.with_pip_packages("flyte=={flyte_version}")
+        object.__setattr__(image, "_tag", preset_tag)
+        # Set this to auto for all auto images because the meaning of "auto" can change (based on logic inside
+        # _get_default_image_for, acts differently in a running task container) so let's make sure it stays auto.
+        object.__setattr__(image, "_identifier_override", "auto")
 
         return image
 
@@ -345,36 +362,7 @@ class Image:
         return pyproject.exists()
 
     @classmethod
-    def from_uv_debian(
-        cls,
-        registry: str,
-        name: str,
-        tag: Optional[str] = None,
-        python_version: Optional[Tuple[int, int]] = None,
-        arch: Union[Architecture, Tuple[Architecture, ...]] = "linux/amd64",
-    ) -> Image:
-        """
-        This creates a new debian-based base image.
-        If using the Union or docker builders, image will have uv available and a virtualenv created at /opt/venv.
-
-        :param registry: Registry to use for the image
-        :param name: Name of the image
-        :param tag: Tag to use for the image
-        :param python_version: Python version to use for the image
-        :param arch: Architecture to use for the image, default is linux/amd64
-        :return: Image
-        """
-        base_image = "debian:bookworm-slim"
-        plat = arch if isinstance(arch, tuple) else (arch,)
-        if python_version is None:
-            python_version = _detect_python_version()
-        img = cls(
-            base_image=base_image, name=name, registry=registry, tag=tag, platform=plat, python_version=python_version
-        )
-        return img
-
-    @classmethod
-    def auto(
+    def from_debian_base(
         cls,
         python_version: Optional[Tuple[int, int]] = None,
         flyte_version: Optional[str] = None,
@@ -402,20 +390,20 @@ class Image:
         if registry and name:
             return base_image.clone(registry=registry, name=name)
 
-        # Set this to auto for all auto images because the meaning of "auto" can change (based on logic inside
-        # _get_default_image_for, acts differently in a running task container) so let's make sure it stays auto.
-        object.__setattr__(base_image, "_identifier_override", "auto")
+        # # Set this to auto for all auto images because the meaning of "auto" can change (based on logic inside
+        # # _get_default_image_for, acts differently in a running task container) so let's make sure it stays auto.
+        # object.__setattr__(base_image, "_identifier_override", "auto")
         return base_image
 
     @classmethod
-    def from_prebuilt(cls, image_uri: str) -> Image:
+    def from_base(cls, image_uri: str) -> Image:
         """
         Use this method to start with a pre-built base image. This image must already exist in the registry of course.
 
         :param image_uri: The full URI of the image, in the format <registry>/<name>:<tag>
         :return:
         """
-        img = cls(base_image=image_uri)
+        img = cls._new(base_image=image_uri)
         return img
 
     @classmethod
@@ -450,6 +438,7 @@ class Image:
         :param registry: registry to use for the image
         :param script: path to the uv script
         :param arch: architecture to use for the image, default is linux/amd64, use tuple for multiple values
+        :param python_version: Python version for the image, if not specified, will use the current Python version
 
         :return: Image
         """
@@ -466,9 +455,16 @@ class Image:
         header = parse_uv_script_file(script)
         if registry is None:
             raise ValueError("registry must be specified")
-        img = cls.from_uv_debian(registry=registry, name=name, arch=arch, python_version=python_version)
+
+        # todo: arch
+        img = cls.from_debian_base(registry=registry, name=name, python_version=python_version)
+
+        # add ca-certificates to the image by default
+        img = img.with_apt_packages("ca-certificates")
+
         if header.dependencies:
-            return img.with_pip_packages(header.dependencies)
+            return img.with_pip_packages(*header.dependencies)
+
         # todo: override the _identifier_override to be the script name or a hash of the script contents
         # This is needed because inside the image, the identifier will be computed to be something different.
         return img
@@ -481,40 +477,42 @@ class Image:
 
         :param registry: Registry to use for the image
         :param name: Name of the image
+        :param addl_layer: Additional layer to add to the image. This will be added on top of the existing layers.
 
         :return:
         """
         registry = registry if registry else self.registry
         name = name if name else self.name
+        if addl_layer and (not name or not registry):
+            raise ValueError(
+                f"Cannot add additional layer {addl_layer} to an image"
+                f" without a registry and name. Please first clone()."
+            )
         new_layers = (*self._layers, addl_layer) if addl_layer else self._layers
-        img = Image(
+        img = Image._new(
             base_image=self.base_image,
             dockerfile=self.dockerfile,
             registry=registry,
             name=name,
-            tag=self.tag,
             platform=self.platform,
             python_version=self.python_version,
-            is_final=self.is_final,
             _layers=new_layers,
         )
 
         return img
 
     @classmethod
-    def from_dockerfile(cls, file: Path, registry: str, name: str, tag: Optional[str] = None) -> Image:
+    def from_dockerfile(cls, file: Path, registry: str, name: str) -> Image:
         """
         Use this method to create a new image with the specified dockerfile
 
         :param file: path to the dockerfile
         :param name: name of the image
         :param registry: registry to use for the image
-        :param tag: tag to use for the image
 
         :return:
         """
-        tag = tag or "latest"
-        img = cls(dockerfile=file, registry=registry, name=name, tag=tag)
+        img = cls(dockerfile=file, registry=registry, name=name)
 
         return img
 
@@ -527,6 +525,8 @@ class Image:
         from ._utils import filehash_update
 
         hasher = hashlib.md5()
+        if self.base_image:
+            hasher.update(self.base_image.encode("utf-8"))
         if self.dockerfile:
             # Note the location of the dockerfile shouldn't matter, only the contents
             filehash_update(self.dockerfile, hasher)
@@ -537,7 +537,7 @@ class Image:
 
     @property
     def _final_tag(self) -> str:
-        t = self.tag if self.tag else self._get_hash_digest()
+        t = self._tag if self._tag else self._get_hash_digest()
         return t or "latest"
 
     @cached_property
@@ -585,7 +585,7 @@ class Image:
 
     def with_pip_packages(
         self,
-        packages: Union[str, List[str], Tuple[str, ...]],
+        *packages: str,
         index_url: Optional[str] = None,
         extra_index_urls: Union[str, List[str], Tuple[str, ...], None] = None,
         pre: bool = False,
@@ -599,7 +599,7 @@ class Image:
         ```python
         @flyte.task(image=(flyte.Image
                         .ubuntu_python()
-                        .with_pip_packages(["requests", "numpy"])))
+                        .with_pip_packages("requests", "numpy")))
         def my_task(x: int) -> int:
             import numpy as np
             return np.sum([x, 1])
@@ -614,8 +614,7 @@ class Image:
         :param extra_args: extra arguments to pass to pip install, default is None
         :return: Image
         """
-
-        new_packages: Optional[Tuple] = _ensure_tuple(packages) if packages else None
+        new_packages: Optional[Tuple] = packages or None
         new_extra_index_urls: Optional[Tuple] = _ensure_tuple(extra_index_urls) if extra_index_urls else None
 
         ll = PipPackages(
@@ -685,15 +684,14 @@ class Image:
         new_image = self.clone(addl_layer=UVProject(pyproject=pyproject_file, uvlock=lock))
         return new_image
 
-    def with_apt_packages(self, packages: Union[str, List[str], Tuple[str, ...]]) -> Image:
+    def with_apt_packages(self, *packages: str) -> Image:
         """
         Use this method to create a new image with the specified apt packages layered on top of the current image
 
         :param packages: list of apt packages to install
         :return: Image
         """
-        pkgs = _ensure_tuple(packages)
-        new_image = self.clone(addl_layer=AptPackages(packages=pkgs))
+        new_image = self.clone(addl_layer=AptPackages(packages=packages))
         return new_image
 
     def with_commands(self, commands: List[str]) -> Image:
@@ -708,7 +706,7 @@ class Image:
         new_image = self.clone(addl_layer=Commands(commands=new_commands))
         return new_image
 
-    def with_local_v2(self) -> Image:
+    def _with_local_v2(self) -> Image:
         """
         Use this method to create a new image with the local v2 builder
         This will override any existing builder

flyte/_interface.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 import inspect
 from typing import Dict, Generator, Tuple, Type, TypeVar, Union, cast, get_args, get_type_hints
 
-from flyte._logging import logger
-
 
 def default_output_name(index: int = 0) -> str:
     return f"o{index}"
@@ -62,12 +60,12 @@ def extract_return_annotation(return_annotation: Union[Type, Tuple, None]) -> Di
         # Options 1 and 2
         bases = return_annotation.__bases__  # type: ignore
         if len(bases) == 1 and bases[0] is tuple and hasattr(return_annotation, "_fields"):
-            logger.debug(f"Task returns named tuple {return_annotation}")
+            # Task returns named tuple
             return dict(get_type_hints(cast(Type, return_annotation), include_extras=True))
 
     if hasattr(return_annotation, "__origin__") and return_annotation.__origin__ is tuple:  # type: ignore
         # Handle option 3
-        logger.debug(f"Task returns unnamed typing.Tuple {return_annotation}")
+        # Task returns unnamed typing.Tuple
         if len(return_annotation.__args__) == 1:  # type: ignore
             raise TypeError("Tuples should be used to indicate multiple return values, found only one return variable.")
         ra = get_args(return_annotation)
@@ -80,5 +78,5 @@ def extract_return_annotation(return_annotation: Union[Type, Tuple, None]) -> Di
 
     else:
         # Handle all other single return types
-        logger.debug(f"Task returns unnamed native tuple {return_annotation}")
+        # Task returns unnamed native tuple
         return {default_output_name(): cast(Type, return_annotation)}

flyte/_internal/controllers/remote/_controller.py

@@ -416,10 +416,11 @@ class RemoteController(Controller):
 
         invoke_seq_num = self.generate_task_call_sequence(_task, current_action_id)
 
-        native_interface = types.guess_interface(_task.spec.task_template.interface)
+        native_interface = types.guess_interface(
+            _task.spec.task_template.interface, default_inputs=_task.spec.default_inputs
+        )
         inputs = await convert.convert_from_native_to_inputs(native_interface, *args, **kwargs)
         serialized_inputs = inputs.proto_inputs.SerializeToString(deterministic=True)
-
         inputs_hash = convert.generate_inputs_hash(serialized_inputs)
         sub_action_id, sub_action_output_path = convert.generate_sub_action_id_and_output_path(
             tctx, task_name, inputs_hash, invoke_seq_num

flyte/_internal/imagebuild/docker_builder.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import shutil
 import subprocess
 import tempfile
@@ -25,6 +26,8 @@ from flyte._image import (
 from flyte._logging import logger
 
 _F_IMG_ID = "_F_IMG_ID"
+FLYTE_DOCKER_BUILDER_CACHE_FROM = "FLYTE_DOCKER_BUILDER_CACHE_FROM"
+FLYTE_DOCKER_BUILDER_CACHE_TO = "FLYTE_DOCKER_BUILDER_CACHE_TO"
 
 UV_LOCK_INSTALL_TEMPLATE = Template("""\
 WORKDIR /root
@@ -193,7 +196,7 @@ class CopyConfigHandler:
             shutil.copy(abs_path, dest_path)
         elif layer.context_source.is_dir():
             # Copy the entire directory
-            shutil.copytree(abs_path, dest_path)
+            shutil.copytree(abs_path, dest_path, dirs_exist_ok=True)
         else:
             raise ValueError(f"Source path is neither file nor directory: {layer.context_source}")
 
@@ -269,9 +272,9 @@ class DockerImageBuilder:
     _builder_name: ClassVar = "flytex"
 
     async def build_image(self, image: Image, dry_run: bool = False) -> str:
-        if image.is_final:
-            if image._layers:
-                raise ValueError("Image is a default image and should already be built")
+        if len(image._layers) == 0:
+            logger.warning("No layers to build, returning the image URI as is.")
+            return image.uri
 
         if image.dockerfile:
             # If a dockerfile is provided, use it directly
@@ -393,11 +396,20 @@ class DockerImageBuilder:
                 f"{image.uri}",
                 "--platform",
                 ",".join(image.platform),
-                "--push" if push else "--load",
             ]
 
+            cache_from = os.getenv(FLYTE_DOCKER_BUILDER_CACHE_FROM)
+            cache_to = os.getenv(FLYTE_DOCKER_BUILDER_CACHE_TO)
+            if cache_from and cache_to:
+                command[3:3] = [
+                    f"--cache-from={cache_from}",
+                    f"--cache-to={cache_to}",
+                ]
+
             if image.registry and push:
                 command.append("--push")
+            else:
+                command.append("--load")
             command.append(tmp_dir)
 
             concat_command = " ".join(command)

flyte/_internal/imagebuild/image_builder.py

@@ -35,10 +35,7 @@ class DockerAPIImageChecker(ImageChecker):
     async def image_exists(cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)) -> bool:
         import httpx
 
-        if "/" in repository:
-            if not repository.startswith("library/"):
-                raise ValueError("This checker only works with Docker Hub")
-        else:
+        if "/" not in repository:
             repository = f"library/{repository}"
 
         auth_url = "https://auth.docker.io/token"
@@ -50,6 +47,7 @@ class DockerAPIImageChecker(ImageChecker):
             auth_response = await client.get(auth_url, params={"service": service, "scope": scope})
             if auth_response.status_code != 200:
                 raise Exception(f"Failed to get auth token: {auth_response.status_code}")
+
             token = auth_response.json()["token"]
 
             manifest_url = f"https://registry-1.docker.io/v2/{repository}/manifests/{tag}"
@@ -60,18 +58,20 @@ class DockerAPIImageChecker(ImageChecker):
                     "application/vnd.docker.distribution.manifest.list.v2+json"
                 ),
             }
-            manifest_response = await client.get(manifest_url, headers=headers)
 
+            manifest_response = await client.get(manifest_url, headers=headers)
             if manifest_response.status_code != 200:
-                raise Exception(f"Failed to get manifest: {manifest_response.status_code}")
+                logger.warning(f"Image not found: {repository}:{tag} (HTTP {manifest_response.status_code})")
+                return False
+
             manifest_list = manifest_response.json()["manifests"]
-            architectures = [f"{x['platform']['os']}/{x['platform']['architecture']}" for x in manifest_list]
+            architectures = [f"{m['platform']['os']}/{m['platform']['architecture']}" for m in manifest_list]
 
-            if set(architectures) >= set(arch):
-                logger.debug(f"Image {repository}:{tag} found for architecture(s) {arch}, has {architectures}")
+            if set(arch).issubset(set(architectures)):
+                logger.debug(f"Image {repository}:{tag} found with arch {architectures}")
                 return True
             else:
-                logger.debug(f"Image {repository}:{tag} not found for architecture(s) {arch}, only has {architectures}")
+                logger.debug(f"Image {repository}:{tag} has {architectures}, but missing {arch}")
                 return False
 
 
@@ -123,7 +123,7 @@ class ImageBuildEngine:
     _REGISTRY: typing.ClassVar[typing.Dict[str, Tuple[ImageBuilder, int]]] = {}
     _SEEN_IMAGES: typing.ClassVar[typing.Dict[str, str]] = {
         # Set default for the auto container. See Image._identifier_override for more info.
-        "auto": Image.auto().uri,
+        "auto": Image.from_debian_base().uri,
     }
 
     @classmethod