1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
from __future__ import annotations
from typing import TYPE_CHECKING
from dateutil.parser import isoparse
from ..core import BaseDomain, DomainIdentityMixin
if TYPE_CHECKING:
from ..actions import BoundAction
from ..servers import BoundServer, Server
from .client import BoundImage
class Image(BaseDomain, DomainIdentityMixin):
"""Image Domain
:param id: int
ID of the image
:param type: str
Type of the image Choices: `system`, `snapshot`, `backup`, `app`
:param status: str
Whether the image can be used or if it’s still being created Choices: `available`, `creating`
:param name: str, None
Unique identifier of the image. This value is only set for system images.
:param description: str
Description of the image
:param image_size: number, None
Size of the image file in our storage in GB. For snapshot images this is the value relevant for calculating costs for the image.
:param disk_size: number
Size of the disk contained in the image in GB.
:param created: datetime
Point in time when the image was created
:param created_from: :class:`BoundServer <hcloud.servers.client.BoundServer>`, None
Information about the server the image was created from
:param bound_to: :class:`BoundServer <hcloud.servers.client.BoundServer>`, None
ID of server the image is bound to. Only set for images of type `backup`.
:param os_flavor: str
Flavor of operating system contained in the image Choices: `ubuntu`, `centos`, `debian`, `fedora`, `unknown`
:param os_version: str, None
Operating system version
:param architecture: str
CPU Architecture that the image is compatible with. Choices: `x86`, `arm`
:param rapid_deploy: bool
Indicates that rapid deploy of the image is available
:param protection: dict
Protection configuration for the image
:param deprecated: datetime, None
Point in time when the image is considered to be deprecated (in ISO-8601 format)
:param labels: Dict
User-defined labels (key-value pairs)
"""
__api_properties__ = (
"id",
"name",
"type",
"description",
"image_size",
"disk_size",
"bound_to",
"os_flavor",
"os_version",
"architecture",
"rapid_deploy",
"created_from",
"status",
"protection",
"labels",
"created",
"deprecated",
)
__slots__ = __api_properties__
# pylint: disable=too-many-locals
def __init__(
self,
id: int | None = None,
name: str | None = None,
type: str | None = None,
created: str | None = None,
description: str | None = None,
image_size: int | None = None,
disk_size: int | None = None,
deprecated: str | None = None,
bound_to: Server | BoundServer | None = None,
os_flavor: str | None = None,
os_version: str | None = None,
architecture: str | None = None,
rapid_deploy: bool | None = None,
created_from: Server | BoundServer | None = None,
protection: dict | None = None,
labels: dict[str, str] | None = None,
status: str | None = None,
):
self.id = id
self.name = name
self.type = type
self.created = isoparse(created) if created else None
self.description = description
self.image_size = image_size
self.disk_size = disk_size
self.deprecated = isoparse(deprecated) if deprecated else None
self.bound_to = bound_to
self.os_flavor = os_flavor
self.os_version = os_version
self.architecture = architecture
self.rapid_deploy = rapid_deploy
self.created_from = created_from
self.protection = protection
self.labels = labels
self.status = status
class CreateImageResponse(BaseDomain):
"""Create Image Response Domain
:param image: :class:`BoundImage <hcloud.images.client.BoundImage>`
The Image which was created
:param action: :class:`BoundAction <hcloud.actions.client.BoundAction>`
The Action which shows the progress of the Floating IP Creation
"""
__api_properties__ = ("action", "image")
__slots__ = __api_properties__
def __init__(
self,
action: BoundAction,
image: BoundImage,
):
self.action = action
self.image = image
|
