ImageService

class ImageService()

Image build/pull/list namespace.

ImageService.__init__

def __init__(impl: AsyncImageService, bridge: SyncBridge) -> None

ImageService.build

def build(builder: ImageBuilder,
          /,
          *,
          name: Optional[str] = None,
          idle_expiry_seconds: Optional[int] = None,
          region: Optional[str] = None,
          cpu_arch: Optional[str] = None,
          timeout: Optional[float] = None) -> Image

Build (or import) an image from an ImageBuilder declaration.

ImageService.delete

def delete(image_id: str) -> None

ImageService.follow_build_logs

def follow_build_logs(image_id: str,
                      *,
                      on_logs: _LogsCallback,
                      on_event: Optional[_EventCallback] = None,
                      cursor: Optional[str] = None,
                      timeout: Optional[float] = None) -> BuildLogFollowResult

Observe a submitted image build. Timeout is in seconds, not execution TTL.

ImageService.get

def get(image_id: str,
        *,
        wait: Literal['ready'] | None = None,
        timeout: Optional[float] = None) -> Image

ImageService.iter

def iter(*,
         anonymous: bool = False,
         sandbox_id: Optional[str] = None,
         name: Optional[str] = None,
         cursor: Optional[str] = None,
         limit: Optional[int] = None,
         platform: Optional[Literal['true', 'false', 'any']] = None) -> Iterator[Image]

ImageService.list

def list(*,
         anonymous: bool = False,
         sandbox_id: Optional[str] = None,
         name: Optional[str] = None,
         cursor: Optional[str] = None,
         limit: Optional[int] = None,
         platform: Optional[Literal['true', 'false', 'any']] = None) -> ListResult[Image]

List images (GET /images).

ImageService.promote

def promote(image_id: str, name: str) -> Image

Name an ANONYMOUS image, making it permanent (PATCH /images/{id}).

ImageService.pull

def pull(image: str,
         *,
         name: Optional[str] = None,
         region: Optional[str] = None,
         wait: bool = True,
         timeout: Optional[float] = None) -> Image

Import a registry image, waiting until ready unless wait=False.

AsyncImageService

class AsyncImageService()

Image build/pull/list namespace.

AsyncImageService.__init__

def __init__(transport: AsyncTransport) -> None

AsyncImageService.follow_build_logs

async def follow_build_logs(image_id: str,
                            *,
                            on_logs: _LogsCallback,
                            on_event: Optional[_EventCallback] = None,
                            cursor: Optional[str] = None,
                            timeout: Optional[float] = None) -> BuildLogFollowResult

Observe a submitted image build. Timeout is in seconds, not execution TTL.

AsyncImageService.build

async def build(builder: ImageBuilder,
                /,
                *,
                name: Optional[str] = None,
                idle_expiry_seconds: Optional[int] = None,
                region: Optional[str] = None,
                cpu_arch: Optional[str] = None,
                timeout: Optional[float] = None) -> Image

Build (or import) an image from an ImageBuilder declaration.

The builder is the only way to say WHAT to build — ImageBuilder. from_dockerfile(...), .from_registry(...), or the fluent .run_commands / .env / .workdir chain — in both SDKs (parity with TypeScript's images.build(builder, options)). name omitted makes the image anonymous; idle_expiry_seconds is then its idle-retention window — deleted once that long has passed without a sandbox being created from it (every create restarts the clock); omitted ⇒ the maximum retention supported by the API.

AsyncImageService.pull

async def pull(image: str,
               *,
               name: Optional[str] = None,
               region: Optional[str] = None,
               wait: bool = True,
               timeout: Optional[float] = None) -> Image

Import a registry image, waiting until ready unless wait=False.

timeout is the submission and readiness budget in seconds; omitted or zero waits without a deadline. A failed import raises ImageBuildFailedError with the server's recorded error.

AsyncImageService.get

async def get(image_id: str,
              *,
              wait: Literal['ready'] | None = None,
              timeout: Optional[float] = None) -> Image

AsyncImageService.promote

async def promote(image_id: str, name: str) -> Image

Name an ANONYMOUS image, making it permanent (PATCH /images/{id}).

Promotion only: an image that already has a name answers 409 — renaming a named image is not offered (sandboxes reference images by id, so a rename would silently relabel every sandbox created from it).

AsyncImageService.delete

async def delete(image_id: str) -> None

AsyncImageService.list

async def list(*,
               anonymous: bool = False,
               sandbox_id: Optional[str] = None,
               name: Optional[str] = None,
               cursor: Optional[str] = None,
               limit: Optional[int] = None,
               platform: Optional[Literal['true', 'false', 'any']] = None) -> ListResult[Image]

List images (GET /images).

platform picks the shared images Daytona publishes for every project: "false" (the server default) lists the project's own images, "true" lists only the non-deprecated platform images (the default one carries default=True), and "any" lists both.

AsyncImageService.iter

async def iter(*,
               anonymous: bool = False,
               sandbox_id: Optional[str] = None,
               name: Optional[str] = None,
               cursor: Optional[str] = None,
               limit: Optional[int] = None,
               platform: Optional[Literal['true', 'false', 'any']] = None) -> AsyncIterator[Image]

ImageListItem

class ImageListItem(BaseModel)

An image with its pagination cursor.

Attributes:

• anonymous StrictBool = Field(description='Whether the image has no permanent name.')
• bytes Optional[StrictInt] = Field(default=None, description='The image size in bytes, or null until the build completes.')
• var_class StrictStr = Field(description='The sandbox class supported by the image.', alias='class')
• created_at datetime = Field(description='When the image was created.')
• cursor StrictStr = Field(description='Opaque continuation token for the next image in the list.')
• default StrictBool = Field(description='Whether this is the image a sandbox create without image boots.')
• deprecated StrictBool = Field(description='Whether this platform image is deprecated. A deprecated image is not listed and cannot be used by name, but its ID still resolves.')
• disk_mib Optional[StrictInt] = Field(default=None, description='The disk size in MiB that a macOS sandbox created from this image gets when the create omits disk_mib. Set for saved macOS sandbox disks; null for every other image.')
• error Optional[StrictStr] = Field(default=None, description='Build failure reason; null unless status is failed.')
• expires_at Optional[datetime] = Field(default=None, description='When an anonymous image expires, or null for a permanent image.')
• format_outdated StrictBool = Field(description='format_version is below the current format. Such an image converts on its first Linux sandbox create (which waits queued meanwhile) or ahead of time with POST /images/{id}/convert; other operations refuse it with IMAGE_FORMAT_OUTDATED until then.')
• format_version StrictInt = Field(description='Image format version: 1 for images imported from Daytona v0, 2 for the current format. See status for image readiness.')
• id StrictStr = Field(description='The image ID.')
• imported_from Optional[ImportedFrom] = None
• layer_count Optional[StrictInt] = Field(default=None, description='The number of filesystem layers, or null until the build completes.')
• name Optional[StrictStr] = Field(default=None, description='The image name, or null for an anonymous image.')
• origin StrictStr = Field(description='How the image was created.')
• platform StrictBool = Field(description="Whether the platform publishes this image for every project. A project's own image with the same name takes precedence for that project, and platform images cannot be renamed, converted, or deleted.")
• region_id StrictStr = Field(description='The home region.')
• region_ids List[StrictStr] = Field(description='Every region where the image is available.')
• retention ImageRetention
• source Optional[ImageSourceValue] = None
• status StrictStr = Field(description='The build status.')
• updated_at datetime = Field(description='When the image was last updated.')
• additional_properties Dict[str, Any] = {}

model_config

model_config = ConfigDict(populate_by_name=True, validate_assignment=True, protected_namespaces=())

ImageListItem.to_str

def to_str() -> str

Returns the string representation of the model using alias

ImageListItem.to_json

def to_json() -> str

Returns the JSON representation of the model using alias

ImageListItem.from_json

@classmethod
def from_json(json_str: str) -> Optional[Self]

Create an instance of ImageListItem from a JSON string

ImageListItem.to_dict

def to_dict() -> Dict[str, Any]

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.
• Fields in self.additional_properties are added to the output dict.

ImageListItem.from_dict

@classmethod
def from_dict(obj: Optional[Dict[str, Any]]) -> Optional[Self]

Create an instance of ImageListItem from a dict

BuildLogFollowResult

@dataclass(frozen=True)
class BuildLogFollowResult()

Attributes:

• status str
• reason BuildLogDoneReason
• output_complete bool
• cursor str | None = None
• raw_reason str | None = None

BuildLogStateEvent

@dataclass(frozen=True)
class BuildLogStateEvent()

Attributes:

• status str
• error str | None = None
• deadline_at str | None = None
• type Literal['state'] = 'state'

BuildLogChunkEvent

@dataclass(frozen=True)
class BuildLogChunkEvent()

Attributes:

• data_base64 str
• start_offset str
• next_offset str
• cursor str
• type Literal['log'] = 'log'

BuildLogGapEvent

@dataclass(frozen=True)
class BuildLogGapEvent()

Attributes:

• requested_offset str
• first_available_offset str
• dropped_bytes str
• cursor str
• reason BuildLogGapReason = 'truncated'
• type Literal['gap'] = 'gap'
• raw_reason str | None = None

BuildLogUnavailableEvent

@dataclass(frozen=True)
class BuildLogUnavailableEvent()

Attributes:

• reason str
• type Literal['unavailable'] = 'unavailable'

BuildLogSourceChangedEvent

@dataclass(frozen=True)
class BuildLogSourceChangedEvent()

Attributes:

• reason str
• type Literal['source_changed'] = 'source_changed'

BuildLogDoneEvent

@dataclass(frozen=True)
class BuildLogDoneEvent()

Attributes:

• result BuildLogFollowResult
• type Literal['done'] = 'done'

BuildLogErrorEvent

@dataclass(frozen=True)
class BuildLogErrorEvent()

Attributes:

• error str
• code str
• retryable bool
• trace_id str | None = None
• type Literal['error'] = 'error'

ImageBuilder

@dataclass(frozen=True, slots=True)
class ImageBuilder()

ImageBuilder.from_registry

@classmethod
def from_registry(ref: str) -> Self

ImageBuilder.from_dockerfile

@classmethod
def from_dockerfile(content: str) -> Self

ImageBuilder.pip_install

def pip_install(*packages: str) -> Self

ImageBuilder.run_commands

def run_commands(*commands: str) -> Self

ImageBuilder.env

@overload
def env(name: str, value: str, /) -> Self

ImageBuilder.env

@overload
def env(values: Mapping[str, str], /) -> Self

ImageBuilder.workdir

def workdir(path: str, /) -> Self

ImageBuilder.build_request_source

def build_request_source() -> tuple[dict[str, str] | None, str | None]

ImageBuilder.render_dockerfile

def render_dockerfile() -> str

Render the Dockerfile the build request carries.

Byte-identical to TypeScript's ImageBuilder.toDockerfile() for the same builder: one line per layer, a single trailing newline (a POSIX text file), no trailing whitespace.

ImageRef

@dataclass(frozen=True, slots=True)
class ImageRef()

Attributes:

• id str
• name Optional[str] = None

Image

@dataclass(frozen=True, slots=True)
class Image()

Attributes:

• id str
• name Optional[str]
• status str
• region str
• anonymous bool
• retention ArtifactRetention
• var_class str
• available_in list[str]
• origin str
• created_at Optional[str] = None
• error Optional[str] = None
• expires_at Optional[str] = None
• source Optional[ImageSource] = None
• bytes Optional[int] = None
• layer_count Optional[int] = None
• cursor Optional[str] = None
• format_version Optional[int] = None
• format_outdated bool = False
• platform bool = False
• default bool = False
• deprecated bool = False
• updated_at Optional[str] = None
• disk_mib Optional[int] = None
• raw_retention str = field(default='', kw_only=True)

BuildLogDoneReason

BuildLogDoneReason = Literal['terminal', 'deadline', 'not_applicable', 'resource_deleted', 'unknown']

BuildLogGapReason

BuildLogGapReason = Literal['truncated', 'unknown']

BuildLogEvent

BuildLogEvent = BuildLogStateEvent | BuildLogChunkEvent | BuildLogGapEvent | BuildLogUnavailableEvent | BuildLogSourceChangedEvent | BuildLogDoneEvent | BuildLogErrorEvent

ImageBuildResponse

ImageBuildResponse = _gen.api.AsyncOperation

ArtifactRetention

ArtifactRetention = Literal['permanent', 'idle', 'unknown']

ImageSource

ImageSource = Union[RegistryImageSource, DockerfileImageSource, NamedImageSource, ManifestImageSource]