flyte 0.2.0b18__py3-none-any.whl → 0.2.0b19__py3-none-any.whl

flyte/_internal/imagebuild/image_builder.py

@@ -10,18 +10,26 @@ from pydantic import BaseModel
 from typing_extensions import Protocol
 
 from flyte._image import Architecture, Image
+from flyte._initialize import _get_init_config
 from flyte._logging import logger
 
 
 class ImageBuilder(Protocol):
     async def build_image(self, image: Image, dry_run: bool) -> str: ...
 
+    def get_checkers(self) -> Optional[typing.List[typing.Type[ImageChecker]]]:
+        """
+        Returns ImageCheckers that can be used to check if the image exists in the registry.
+        If None, then use the default checkers.
+        """
+        return None
+
 
 class ImageChecker(Protocol):
     @classmethod
     async def image_exists(
         cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)
-    ) -> bool: ...
+    ) -> Optional[str]: ...
 
 
 class DockerAPIImageChecker(ImageChecker):
@@ -32,7 +40,9 @@ class DockerAPIImageChecker(ImageChecker):
     """
 
     @classmethod
-    async def image_exists(cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)) -> bool:
+    async def image_exists(
+        cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)
+    ) -> Optional[str]:
         import httpx
 
         if "/" not in repository:
@@ -50,6 +60,7 @@ class DockerAPIImageChecker(ImageChecker):
 
             token = auth_response.json()["token"]
 
+            # ghcr.io/union-oss/flyte:latest
             manifest_url = f"https://registry-1.docker.io/v2/{repository}/manifests/{tag}"
             headers = {
                 "Authorization": f"Bearer {token}",
@@ -62,24 +73,26 @@ class DockerAPIImageChecker(ImageChecker):
             manifest_response = await client.get(manifest_url, headers=headers)
             if manifest_response.status_code != 200:
                 logger.warning(f"Image not found: {repository}:{tag} (HTTP {manifest_response.status_code})")
-                return False
+                return None
 
             manifest_list = manifest_response.json()["manifests"]
             architectures = [f"{m['platform']['os']}/{m['platform']['architecture']}" for m in manifest_list]
 
             if set(arch).issubset(set(architectures)):
                 logger.debug(f"Image {repository}:{tag} found with arch {architectures}")
-                return True
+                return f"{repository}:{tag}"
             else:
                 logger.debug(f"Image {repository}:{tag} has {architectures}, but missing {arch}")
-                return False
+                return None
 
 
 class LocalDockerCommandImageChecker(ImageChecker):
     command_name: ClassVar[str] = "docker"
 
     @classmethod
-    async def image_exists(cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)) -> bool:
+    async def image_exists(
+        cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)
+    ) -> Optional[str]:
         # Check if the image exists locally by running the docker inspect command
         process = await asyncio.create_subprocess_exec(
             cls.command_name,
@@ -90,9 +103,9 @@ class LocalDockerCommandImageChecker(ImageChecker):
             stderr=asyncio.subprocess.PIPE,
         )
         stdout, stderr = await process.communicate()
-        if stderr and "manifest unknown" in stderr.decode():
+        if (stderr and "manifest unknown") or "no such manifest" in stderr.decode():
             logger.debug(f"Image {repository}:{tag} not found using the docker command.")
-            return False
+            return None
 
         if process.returncode != 0:
             raise RuntimeError(f"Failed to run docker image inspect {repository}:{tag}")
@@ -104,11 +117,11 @@ class LocalDockerCommandImageChecker(ImageChecker):
         architectures = [f"{x['platform']['os']}/{x['platform']['architecture']}" for x in manifest_list]
         if set(architectures) >= set(arch):
             logger.debug(f"Image {repository}:{tag} found for architecture(s) {arch}, has {architectures}")
-            return True
+            return f"{repository}:{tag}"
 
         # Otherwise write a message and return false to trigger build
         logger.debug(f"Image {repository}:{tag} not found for architecture(s) {arch}, only has {architectures}")
-        return False
+        return None
 
 
 class LocalPodmanCommandImageChecker(LocalDockerCommandImageChecker):
@@ -120,55 +133,59 @@ class ImageBuildEngine:
     ImageBuildEngine contains a list of builders that can be used to build an ImageSpec.
     """
 
-    _REGISTRY: typing.ClassVar[typing.Dict[str, Tuple[ImageBuilder, int]]] = {}
+    ImageBuilderType = typing.Literal["local", "remote"]
+
     _SEEN_IMAGES: typing.ClassVar[typing.Dict[str, str]] = {
         # Set default for the auto container. See Image._identifier_override for more info.
         "auto": Image.from_debian_base().uri,
     }
 
-    @classmethod
-    def register(cls, builder_type: str, image_builder: ImageBuilder, priority: int = 5):
-        cls._REGISTRY[builder_type] = (image_builder, priority)
-
-    @classmethod
-    def get_registry(cls) -> Dict[str, Tuple[ImageBuilder, int]]:
-        return cls._REGISTRY
-
     @staticmethod
     @alru_cache
-    async def image_exists(image: Image) -> bool:
+    async def image_exists(image: Image) -> Optional[str]:
         if image.base_image is not None and not image._layers:
             logger.debug(f"Image {image} has a base image: {image.base_image} and no layers. Skip existence check.")
-            return True
-        assert image.registry is not None, f"Image registry is not set for {image}"
+            return image.uri
         assert image.name is not None, f"Image name is not set for {image}"
 
-        repository = image.registry + "/" + image.name
         tag = image._final_tag
 
         if tag == "latest":
             logger.debug(f"Image {image} has tag 'latest', skip existence check, always build")
-            return True
+            return image.uri
 
-        # Can get a public token for docker.io but ghcr requires a pat, so harder to get the manifest anonymously.
-        checkers = [LocalDockerCommandImageChecker, LocalPodmanCommandImageChecker, DockerAPIImageChecker]
-        for checker in checkers:
+        builder = None
+        cfg = _get_init_config()
+        if cfg and cfg.image_builder:
+            builder = cfg.image_builder
+        image_builder = ImageBuildEngine._get_builder(builder)
+        image_checker = image_builder.get_checkers()
+        if image_checker is None:
+            logger.info(f"No image checkers found for builder `{image_builder}`, assuming it exists")
+            return image.uri
+        for checker in image_checker:
             try:
-                exists = await checker.image_exists(repository, tag, tuple(image.platform))
-                logger.debug(f"Image {image} {exists=} in registry")
-                return exists
+                repository = image.registry + "/" + image.name if image.registry else image.name
+                image_uri = await checker.image_exists(repository, tag, tuple(image.platform))
+                if image_uri:
+                    logger.debug(f"Image {image_uri} in registry")
+                return image_uri
             except Exception as e:
                 logger.debug(f"Error checking image existence with {checker.__name__}: {e}")
                 continue
 
         # If all checkers fail, then assume the image exists. This is current flytekit behavior
         logger.info(f"All checkers failed to check existence of {image.uri}, assuming it does exists")
-        return True
+        return image.uri
 
     @classmethod
     @alru_cache
     async def build(
-        cls, image: Image, builder: Optional[str] = None, dry_run: bool = False, force: bool = False
+        cls,
+        image: Image,
+        builder: ImageBuildEngine.ImageBuilderType | None = None,
+        dry_run: bool = False,
+        force: bool = False,
     ) -> str:
         """
         Build the image. Images to be tagged with latest will always be built. Otherwise, this engine will check the
@@ -181,30 +198,40 @@ class ImageBuildEngine:
         :return:
         """
         # Always trigger a build if this is a dry run since builder shouldn't really do anything, or a force.
+        image_uri = (await cls.image_exists(image)) or image.uri
         if force or dry_run or not await cls.image_exists(image):
-            logger.info(f"Image {image.uri} does not exist in registry or force/dry-run, building...")
+            logger.info(f"Image {image_uri} does not exist in registry or force/dry-run, building...")
 
             # Validate the image before building
             image.validate()
 
-            # If builder is not specified, use the first registered builder
+            # If a builder is not specified, use the first registered builder
+            cfg = _get_init_config()
+            if cfg and cfg.image_builder:
+                builder = builder or cfg.image_builder
             img_builder = ImageBuildEngine._get_builder(builder)
+            logger.debug(f"Using `{img_builder}` image builder to build image.")
 
             result = await img_builder.build_image(image, dry_run=dry_run)
             return result
         else:
-            logger.info(f"Image {image.uri} already exists in registry. Skipping build.")
-            return image.uri
+            logger.info(f"Image {image_uri} already exists in registry. Skipping build.")
+            return image_uri
 
     @classmethod
-    def _get_builder(cls, builder: Optional[str]) -> ImageBuilder:
-        if not builder:
-            from .docker_builder import DockerImageBuilder
+    def _get_builder(cls, builder: ImageBuildEngine.ImageBuilderType | None = "local") -> ImageBuilder:
+        if builder is None:
+            builder = "local"
+        if builder == "remote":
+            from flyte._internal.imagebuild.remote_builder import RemoteImageBuilder
+
+            return RemoteImageBuilder()
+        elif builder == "local":
+            from flyte._internal.imagebuild.docker_builder import DockerImageBuilder
 
             return DockerImageBuilder()
-        if builder not in cls._REGISTRY:
-            raise AssertionError(f"Image builder {builder} is not registered.")
-        return cls._REGISTRY[builder][0]
+        else:
+            raise ValueError(f"Unknown image builder type: {builder}. Supported types are 'local' and 'remote'.")
 
 
 class ImageCache(BaseModel):

flyte/_internal/imagebuild/remote_builder.py

@@ -0,0 +1,259 @@
+import os
+import shutil
+import tempfile
+import typing
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Tuple, cast
+from uuid import uuid4
+
+import click
+
+import flyte
+from flyte import Image, remote
+from flyte._image import (
+    AptPackages,
+    Architecture,
+    Commands,
+    CopyConfig,
+    Env,
+    PipPackages,
+    PythonWheels,
+    Requirements,
+    UVProject,
+)
+from flyte._internal.imagebuild.image_builder import ImageBuilder, ImageChecker
+from flyte._logging import logger
+from flyte.remote import ActionOutputs, Run
+
+if TYPE_CHECKING:
+    from flyte._protos.imagebuilder import definition_pb2 as image_definition_pb2
+
+IMAGE_TASK_NAME = "build-image"
+IMAGE_TASK_PROJECT = "system"
+IMAGE_TASK_DOMAIN = "production"
+
+
+class RemoteImageChecker(ImageChecker):
+    _images_client = None
+
+    @classmethod
+    async def image_exists(
+        cls, repository: str, tag: str, arch: Tuple[Architecture, ...] = ("linux/amd64",)
+    ) -> Optional[str]:
+        try:
+            import flyte.remote as remote
+
+            remote.Task.get(
+                name=IMAGE_TASK_NAME,
+                project=IMAGE_TASK_PROJECT,
+                domain=IMAGE_TASK_DOMAIN,
+                auto_version="latest",
+            )
+        except Exception as e:
+            msg = "remote image builder is not enabled. Please contact Union support to enable it."
+            raise click.ClickException(msg) from e
+
+        image_name = f"{repository.split('/')[-1]}:{tag}"
+
+        try:
+            from flyte._initialize import _get_init_config
+            from flyte._protos.imagebuilder import definition_pb2 as image_definition__pb2
+            from flyte._protos.imagebuilder import payload_pb2 as image_payload__pb2
+            from flyte._protos.imagebuilder import service_pb2_grpc as image_service_pb2_grpc
+
+            cfg = _get_init_config()
+            if cfg is None:
+                raise ValueError("Init config should not be None")
+            image_id = image_definition__pb2.ImageIdentifier(name=image_name)
+            req = image_payload__pb2.GetImageRequest(id=image_id, organization=cfg.org)
+            if cls._images_client is None:
+                if cfg.client is None:
+                    raise ValueError("remote client should not be None")
+                cls._images_client = image_service_pb2_grpc.ImageServiceStub(cfg.client._channel)
+            resp = await cls._images_client.GetImage(req)
+            logger.warning(click.style(f"Image {resp.image.fqin} found. Skip building.", fg="blue"))
+            return resp.image.fqin
+        except Exception:
+            logger.warning(click.style(f"Image {image_name} was not found or has expired.", fg="blue"))
+            return None
+
+
+class RemoteImageBuilder(ImageBuilder):
+    def get_checkers(self) -> Optional[typing.List[typing.Type[ImageChecker]]]:
+        """Return the image checker."""
+        return [RemoteImageChecker]
+
+    async def build_image(self, image: Image, dry_run: bool = False) -> str:
+        from flyte._protos.workflow import run_definition_pb2
+
+        image_name = f"{image.name}:{image._final_tag}"
+        spec, context = await _validate_configuration(image)
+
+        start = datetime.now(timezone.utc)
+        entity = remote.Task.get(
+            name=IMAGE_TASK_NAME,
+            project=IMAGE_TASK_PROJECT,
+            domain=IMAGE_TASK_DOMAIN,
+            auto_version="latest",
+        )
+        run = cast(
+            Run,
+            await flyte.with_runcontext(project=IMAGE_TASK_PROJECT, domain=IMAGE_TASK_DOMAIN).run.aio(
+                entity, spec=spec, context=context, target_image=image_name
+            ),
+        )
+        logger.warning(click.style("🐳 Submitting a new build...", fg="blue", bold=True))
+
+        logger.warning(click.style("⏳ Waiting for build to finish at: " + click.style(run.url, fg="cyan"), bold=True))
+        await run.wait.aio(quiet=True)
+        run_details = await run.details.aio()
+
+        elapsed = str(datetime.now(timezone.utc) - start).split(".")[0]
+
+        if run_details.action_details.raw_phase == run_definition_pb2.PHASE_SUCCEEDED:
+            logger.warning(click.style(f"✅ Build completed in {elapsed}!", bold=True, fg="green"))
+        else:
+            raise click.ClickException(f"❌ Build failed in {elapsed} at {click.style(run.url, fg='cyan')}")
+
+        outputs = await run_details.outputs()
+        return _get_fully_qualified_image_name(outputs)
+
+
+async def _validate_configuration(image: Image) -> Tuple[str, Optional[str]]:
+    """Validate the configuration and prepare the spec and context files."""  # Prepare the spec file
+    tmp_path = Path(tempfile.gettempdir()) / str(uuid4())
+    os.makedirs(tmp_path, exist_ok=True)
+
+    context_path = tmp_path / "build.uc-image-builder"
+    context_path.mkdir(exist_ok=True)
+
+    image_idl = _get_layers_proto(image, context_path)
+
+    spec_path = tmp_path / "spec.pb"
+    with spec_path.open("wb") as f:
+        f.write(image_idl.SerializeToString())
+
+    _, spec_url = await remote.upload_file.aio(spec_path)
+
+    if any(context_path.iterdir()):
+        # If there are files in the context directory, upload it
+        _, context_url = await remote.upload_file.aio(
+            Path(shutil.make_archive(str(tmp_path / "context"), "xztar", context_path))
+        )
+    else:
+        context_url = ""
+
+    return spec_url, context_url
+
+
+def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2.ImageSpec":
+    from flyte._protos.imagebuilder import definition_pb2 as image_definition_pb2
+
+    layers = []
+    for layer in image._layers:
+        if isinstance(layer, AptPackages):
+            apt_layer = image_definition_pb2.Layer(
+                apt_packages=image_definition_pb2.AptPackages(packages=layer.packages)
+            )
+            layers.append(apt_layer)
+        elif isinstance(layer, PythonWheels):
+            dst_path = _copy_files_to_context(layer.wheel_dir, context_path)
+            wheel_layer = image_definition_pb2.Layer(
+                python_wheels=image_definition_pb2.PythonWheels(
+                    dir=str(dst_path.relative_to(context_path)),
+                    options=image_definition_pb2.PipOptions(
+                        index_url=layer.index_url,
+                        extra_index_urls=layer.extra_index_urls,
+                        pre=layer.pre,
+                        extra_args=layer.extra_args,
+                    ),
+                )
+            )
+            layers.append(wheel_layer)
+
+        elif isinstance(layer, Requirements):
+            dst_path = _copy_files_to_context(layer.file, context_path)
+            requirements_layer = image_definition_pb2.Layer(
+                requirements=image_definition_pb2.Requirements(
+                    file=str(dst_path.relative_to(context_path)),
+                    options=image_definition_pb2.PipOptions(
+                        index_url=layer.index_url,
+                        extra_index_urls=layer.extra_index_urls,
+                        pre=layer.pre,
+                        extra_args=layer.extra_args,
+                    ),
+                )
+            )
+            layers.append(requirements_layer)
+        elif isinstance(layer, PipPackages):
+            pip_layer = image_definition_pb2.Layer(
+                pip_packages=image_definition_pb2.PipPackages(
+                    packages=layer.packages,
+                    options=image_definition_pb2.PipOptions(
+                        index_url=layer.index_url,
+                        extra_index_urls=layer.extra_index_urls,
+                        pre=layer.pre,
+                        extra_args=layer.extra_args,
+                    ),
+                )
+            )
+            layers.append(pip_layer)
+        elif isinstance(layer, UVProject):
+            for line in layer.pyproject.read_text().splitlines():
+                if "tool.uv.index" in line:
+                    raise ValueError("External sources are not supported in pyproject.toml")
+            shutil.copy2(layer.pyproject, context_path / layer.pyproject.name)
+
+            uv_layer = image_definition_pb2.Layer(
+                uv_project=image_definition_pb2.UVProject(
+                    pyproject=str(layer.pyproject.name),
+                    uvlock=str(layer.uvlock.name),
+                )
+            )
+            layers.append(uv_layer)
+        elif isinstance(layer, Commands):
+            commands_layer = image_definition_pb2.Layer(
+                commands=image_definition_pb2.Commands(cmd=list(layer.commands))
+            )
+            layers.append(commands_layer)
+        elif isinstance(layer, CopyConfig):
+            dst_path = _copy_files_to_context(layer.src, context_path)
+
+            copy_layer = image_definition_pb2.Layer(
+                copy_config=image_definition_pb2.CopyConfig(
+                    src=str(dst_path.relative_to(context_path)),
+                    dst=str(layer.dst),
+                )
+            )
+            layers.append(copy_layer)
+        elif isinstance(layer, Env):
+            env_layer = image_definition_pb2.Layer(
+                env=image_definition_pb2.Env(
+                    env_variables=dict(layer.env_vars),
+                )
+            )
+            layers.append(env_layer)
+
+    return image_definition_pb2.ImageSpec(
+        base_image=image.base_image,
+        python_version=f"{image.python_version[0]}.{image.python_version[1]}",
+        layers=layers,
+    )
+
+
+def _copy_files_to_context(src: Path, context_path: Path) -> Path:
+    if src.is_absolute() or ".." in str(src):
+        dst_path = context_path / str(src.absolute()).replace("/", "./_flyte_abs_context/", 1)
+    else:
+        dst_path = context_path / src
+    dst_path.parent.mkdir(parents=True, exist_ok=True)
+    if src.is_dir():
+        shutil.copytree(src, dst_path, dirs_exist_ok=True)
+    else:
+        shutil.copy(src, dst_path)
+    return dst_path
+
+
+def _get_fully_qualified_image_name(outputs: ActionOutputs) -> str:
+    return outputs.pb2.literals[0].value.scalar.primitive.string_value

flyte/_protos/imagebuilder/definition_pb2.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: imagebuilder/definition.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from flyte._protos.validate.validate import validate_pb2 as validate_dot_validate__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dimagebuilder/definition.proto\x12\x15\x63loudidl.imagebuilder\x1a\x17validate/validate.proto\".\n\x0fImageIdentifier\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xfa\x42\x04r\x02\x10\x01R\x04name\"S\n\x05Image\x12\x36\n\x02id\x18\x01 \x01(\x0b\x32&.cloudidl.imagebuilder.ImageIdentifierR\x02id\x12\x12\n\x04\x66qin\x18\x02 \x01(\tR\x04\x66qin\")\n\x0b\x41ptPackages\x12\x1a\n\x08packages\x18\x01 \x03(\tR\x08packages\"\x84\x01\n\nPipOptions\x12\x1b\n\tindex_url\x18\x02 \x01(\tR\x08indexUrl\x12(\n\x10\x65xtra_index_urls\x18\x03 \x03(\tR\x0e\x65xtraIndexUrls\x12\x10\n\x03pre\x18\x04 \x01(\x08R\x03pre\x12\x1d\n\nextra_args\x18\x05 \x01(\tR\textraArgs\"f\n\x0bPipPackages\x12\x1a\n\x08packages\x18\x01 \x03(\tR\x08packages\x12;\n\x07options\x18\x02 \x01(\x0b\x32!.cloudidl.imagebuilder.PipOptionsR\x07options\"_\n\x0cRequirements\x12\x12\n\x04\x66ile\x18\x01 \x01(\tR\x04\x66ile\x12;\n\x07options\x18\x02 \x01(\x0b\x32!.cloudidl.imagebuilder.PipOptionsR\x07options\"]\n\x0cPythonWheels\x12\x10\n\x03\x64ir\x18\x01 \x01(\tR\x03\x64ir\x12;\n\x07options\x18\x02 \x01(\x0b\x32!.cloudidl.imagebuilder.PipOptionsR\x07options\"~\n\tUVProject\x12\x1c\n\tpyproject\x18\x01 \x01(\tR\tpyproject\x12\x16\n\x06uvlock\x18\x02 \x01(\tR\x06uvlock\x12;\n\x07options\x18\x03 \x01(\x0b\x32!.cloudidl.imagebuilder.PipOptionsR\x07options\"\x1c\n\x08\x43ommands\x12\x10\n\x03\x63md\x18\x02 \x03(\tR\x03\x63md\"#\n\x07WorkDir\x12\x18\n\x07workdir\x18\x01 \x01(\tR\x07workdir\"0\n\nCopyConfig\x12\x10\n\x03src\x18\x01 \x01(\tR\x03src\x12\x10\n\x03\x64st\x18\x02 \x01(\tR\x03\x64st\"\x99\x01\n\x03\x45nv\x12Q\n\renv_variables\x18\x01 \x03(\x0b\x32,.cloudidl.imagebuilder.Env.EnvVariablesEntryR\x0c\x65nvVariables\x1a?\n\x11\x45nvVariablesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\xed\x04\n\x05Layer\x12G\n\x0c\x61pt_packages\x18\x01 \x01(\x0b\x32\".cloudidl.imagebuilder.AptPackagesH\x00R\x0b\x61ptPackages\x12G\n\x0cpip_packages\x18\x02 \x01(\x0b\x32\".cloudidl.imagebuilder.PipPackagesH\x00R\x0bpipPackages\x12=\n\x08\x63ommands\x18\x03 \x01(\x0b\x32\x1f.cloudidl.imagebuilder.CommandsH\x00R\x08\x63ommands\x12I\n\x0crequirements\x18\x04 \x01(\x0b\x32#.cloudidl.imagebuilder.RequirementsH\x00R\x0crequirements\x12J\n\rpython_wheels\x18\x05 \x01(\x0b\x32#.cloudidl.imagebuilder.PythonWheelsH\x00R\x0cpythonWheels\x12:\n\x07workdir\x18\x06 \x01(\x0b\x32\x1e.cloudidl.imagebuilder.WorkDirH\x00R\x07workdir\x12\x44\n\x0b\x63opy_config\x18\x07 \x01(\x0b\x32!.cloudidl.imagebuilder.CopyConfigH\x00R\ncopyConfig\x12\x41\n\nuv_project\x18\x08 \x01(\x0b\x32 .cloudidl.imagebuilder.UVProjectH\x00R\tuvProject\x12.\n\x03\x65nv\x18\t \x01(\x0b\x32\x1a.cloudidl.imagebuilder.EnvH\x00R\x03\x65nvB\x07\n\x05layer\"\xa3\x01\n\tImageSpec\x12\x1d\n\nbase_image\x18\x01 \x01(\tR\tbaseImage\x12%\n\x0epython_version\x18\x02 \x01(\tR\rpythonVersion\x12\x34\n\x06layers\x18\x03 \x03(\x0b\x32\x1c.cloudidl.imagebuilder.LayerR\x06layers\x12\x1a\n\x08platform\x18\x04 \x03(\tR\x08platformB\xd4\x01\n\x19\x63om.cloudidl.imagebuilderB\x0f\x44\x65\x66initionProtoH\x02P\x01Z/github.com/unionai/cloud/gen/pb-go/imagebuilder\xa2\x02\x03\x43IX\xaa\x02\x15\x43loudidl.Imagebuilder\xca\x02\x15\x43loudidl\\Imagebuilder\xe2\x02!Cloudidl\\Imagebuilder\\GPBMetadata\xea\x02\x16\x43loudidl::Imagebuilderb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'imagebuilder.definition_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\031com.cloudidl.imagebuilderB\017DefinitionProtoH\002P\001Z/github.com/unionai/cloud/gen/pb-go/imagebuilder\242\002\003CIX\252\002\025Cloudidl.Imagebuilder\312\002\025Cloudidl\\Imagebuilder\342\002!Cloudidl\\Imagebuilder\\GPBMetadata\352\002\026Cloudidl::Imagebuilder'
+  _IMAGEIDENTIFIER.fields_by_name['name']._options = None
+  _IMAGEIDENTIFIER.fields_by_name['name']._serialized_options = b'\372B\004r\002\020\001'
+  _ENV_ENVVARIABLESENTRY._options = None
+  _ENV_ENVVARIABLESENTRY._serialized_options = b'8\001'
+  _globals['_IMAGEIDENTIFIER']._serialized_start=81
+  _globals['_IMAGEIDENTIFIER']._serialized_end=127
+  _globals['_IMAGE']._serialized_start=129
+  _globals['_IMAGE']._serialized_end=212
+  _globals['_APTPACKAGES']._serialized_start=214
+  _globals['_APTPACKAGES']._serialized_end=255
+  _globals['_PIPOPTIONS']._serialized_start=258
+  _globals['_PIPOPTIONS']._serialized_end=390
+  _globals['_PIPPACKAGES']._serialized_start=392
+  _globals['_PIPPACKAGES']._serialized_end=494
+  _globals['_REQUIREMENTS']._serialized_start=496
+  _globals['_REQUIREMENTS']._serialized_end=591
+  _globals['_PYTHONWHEELS']._serialized_start=593
+  _globals['_PYTHONWHEELS']._serialized_end=686
+  _globals['_UVPROJECT']._serialized_start=688
+  _globals['_UVPROJECT']._serialized_end=814
+  _globals['_COMMANDS']._serialized_start=816
+  _globals['_COMMANDS']._serialized_end=844
+  _globals['_WORKDIR']._serialized_start=846
+  _globals['_WORKDIR']._serialized_end=881
+  _globals['_COPYCONFIG']._serialized_start=883
+  _globals['_COPYCONFIG']._serialized_end=931
+  _globals['_ENV']._serialized_start=934
+  _globals['_ENV']._serialized_end=1087
+  _globals['_ENV_ENVVARIABLESENTRY']._serialized_start=1024
+  _globals['_ENV_ENVVARIABLESENTRY']._serialized_end=1087
+  _globals['_LAYER']._serialized_start=1090
+  _globals['_LAYER']._serialized_end=1711
+  _globals['_IMAGESPEC']._serialized_start=1714
+  _globals['_IMAGESPEC']._serialized_end=1877
+# @@protoc_insertion_point(module_scope)