gcore 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

gcore/types/cloud/floating_ip_list_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["FloatingIPListParams"]
 
 
@@ -24,7 +25,7 @@ class FloatingIPListParams(TypedDict, total=False):
     Offset value is used to exclude the first set of records from the result
     """
 
-    tag_key: List[str]
+    tag_key: SequenceNotStr[str]
     """Optional. Filter by tag keys. ?`tag_key`=key1&`tag_key`=key2"""
 
     tag_key_value: str

gcore/types/cloud/gpu_baremetal_cluster.py

@@ -1,78 +1,133 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Optional
-from typing_extensions import Literal
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypeAlias
 
 from .tag import Tag
+from ..._utils import PropertyInfo
 from ..._models import BaseModel
-from .gpu_baremetal_cluster_server import GPUBaremetalClusterServer
 
-__all__ = ["GPUBaremetalCluster", "Interface"]
+__all__ = [
+    "GPUBaremetalCluster",
+    "ServersSettings",
+    "ServersSettingsInterface",
+    "ServersSettingsInterfaceExternalInterfaceOutputSerializer",
+    "ServersSettingsInterfaceSubnetInterfaceOutputSerializer",
+    "ServersSettingsInterfaceSubnetInterfaceOutputSerializerFloatingIP",
+    "ServersSettingsInterfaceAnySubnetInterfaceOutputSerializer",
+    "ServersSettingsInterfaceAnySubnetInterfaceOutputSerializerFloatingIP",
+    "ServersSettingsSecurityGroup",
+]
 
 
-class Interface(BaseModel):
-    network_id: str
-    """Network ID"""
+class ServersSettingsInterfaceExternalInterfaceOutputSerializer(BaseModel):
+    ip_family: Literal["dual", "ipv4", "ipv6"]
+    """Which subnets should be selected: IPv4, IPv6, or use dual stack."""
+
+    name: Optional[str] = None
+    """Interface name"""
+
+    type: Literal["external"]
+
+
+class ServersSettingsInterfaceSubnetInterfaceOutputSerializerFloatingIP(BaseModel):
+    source: Literal["new"]
 
-    port_id: str
+
+class ServersSettingsInterfaceSubnetInterfaceOutputSerializer(BaseModel):
+    floating_ip: Optional[ServersSettingsInterfaceSubnetInterfaceOutputSerializerFloatingIP] = None
+    """Floating IP config for this subnet attachment"""
+
+    name: Optional[str] = None
+    """Interface name"""
+
+    network_id: str
     """Network ID the subnet belongs to. Port will be plugged in this network"""
 
     subnet_id: str
-    """Port is assigned to IP address from the subnet"""
+    """Port is assigned an IP address from this subnet"""
 
-    type: str
-    """Network type"""
+    type: Literal["subnet"]
 
 
-class GPUBaremetalCluster(BaseModel):
-    cluster_id: str
-    """GPU Cluster ID"""
+class ServersSettingsInterfaceAnySubnetInterfaceOutputSerializerFloatingIP(BaseModel):
+    source: Literal["new"]
 
-    cluster_name: str
-    """GPU Cluster Name"""
 
-    cluster_status: Literal["ACTIVE", "ERROR", "PENDING", "SUSPENDED"]
-    """GPU Cluster status"""
+class ServersSettingsInterfaceAnySubnetInterfaceOutputSerializer(BaseModel):
+    floating_ip: Optional[ServersSettingsInterfaceAnySubnetInterfaceOutputSerializerFloatingIP] = None
+    """Floating IP config for this subnet attachment"""
 
-    created_at: Optional[str] = None
-    """Datetime when the cluster was created"""
+    ip_address: Optional[str] = None
+    """Fixed IP address"""
 
-    creator_task_id: Optional[str] = None
-    """Task that created this entity"""
+    ip_family: Literal["dual", "ipv4", "ipv6"]
+    """Which subnets should be selected: IPv4, IPv6, or use dual stack"""
 
-    flavor: str
-    """Flavor ID is the same as the name"""
+    name: Optional[str] = None
+    """Interface name"""
 
-    image_id: str
-    """Image ID"""
+    network_id: str
+    """Network ID the subnet belongs to. Port will be plugged in this network"""
 
-    image_name: Optional[str] = None
-    """Image name"""
+    type: Literal["any_subnet"]
 
-    interfaces: Optional[List[Interface]] = None
-    """Networks managed by user and associated with the cluster"""
 
-    password: Optional[str] = None
-    """A password for a bare metal server.
+ServersSettingsInterface: TypeAlias = Annotated[
+    Union[
+        ServersSettingsInterfaceExternalInterfaceOutputSerializer,
+        ServersSettingsInterfaceSubnetInterfaceOutputSerializer,
+        ServersSettingsInterfaceAnySubnetInterfaceOutputSerializer,
+    ],
+    PropertyInfo(discriminator="type"),
+]
 
-    This parameter is used to set a password for the "Admin" user on a Windows
-    instance, a default user or a new user on a Linux instance
-    """
 
-    project_id: int
-    """Project ID"""
+class ServersSettingsSecurityGroup(BaseModel):
+    name: str
+    """Name."""
 
-    region: str
-    """Region name"""
 
-    region_id: int
-    """Region ID"""
+class ServersSettings(BaseModel):
+    interfaces: List[ServersSettingsInterface]
 
-    servers: List[GPUBaremetalClusterServer]
-    """GPU cluster servers"""
+    security_groups: List[ServersSettingsSecurityGroup]
+    """Security groups names"""
 
     ssh_key_name: Optional[str] = None
-    """Keypair name to inject into new cluster(s)"""
+    """SSH key name"""
+
+    user_data: Optional[str] = None
+    """Optional custom user data (Base64-encoded) Mutually exclusive with 'password'."""
+
+
+class GPUBaremetalCluster(BaseModel):
+    id: str
+    """Cluster unique identifier"""
+
+    created_at: datetime
+    """Cluster creation date time"""
+
+    flavor: str
+    """Cluster flavor name"""
+
+    managed_by: Literal["k8s", "user"]
+    """User type managing the resource"""
+
+    name: str
+    """Cluster name"""
+
+    servers_count: int
+    """Cluster servers count"""
+
+    servers_ids: List[str]
+    """List of cluster nodes"""
+
+    servers_settings: ServersSettings
+
+    status: Literal["active", "deleting", "error", "new", "resizing"]
+    """Cluster status"""
 
     tags: List[Tag]
     """List of key-value tags associated with the resource.
@@ -84,33 +139,5 @@ class GPUBaremetalCluster(BaseModel):
     values.
     """
 
-    task_id: Optional[str] = None
-    """Task ID associated with the cluster"""
-
-    task_status: Literal[
-        "CLUSTER_CLEAN_UP",
-        "CLUSTER_RESIZE",
-        "CLUSTER_RESUME",
-        "CLUSTER_SUSPEND",
-        "ERROR",
-        "FINISHED",
-        "IPU_SERVERS",
-        "NETWORK",
-        "POPLAR_SERVERS",
-        "POST_DEPLOY_SETUP",
-        "VIPU_CONTROLLER",
-    ]
-    """Task status"""
-
-    user_data: Optional[str] = None
-    """String in base64 format.
-
-    Must not be passed together with 'username' or 'password'. Examples of the
-    `user_data`: https://cloudinit.readthedocs.io/en/latest/topics/examples.html
-    """
-
-    username: Optional[str] = None
-    """A name of a new user in the Linux instance.
-
-    It may be passed with a 'password' parameter
-    """
+    updated_at: Optional[datetime] = None
+    """Cluster update date time"""

gcore/types/cloud/gpu_baremetal_cluster_create_params.py

@@ -2,61 +2,44 @@
 
 from __future__ import annotations
 
-from typing import Dict, Union, Iterable, Optional
+from typing import Dict, Union, Iterable
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
-from .interface_ip_family import InterfaceIPFamily
-
 __all__ = [
     "GPUBaremetalClusterCreateParams",
-    "Interface",
-    "InterfaceCreateGPUClusterExternalInterfaceSerializer",
-    "InterfaceCreateGPUClusterSubnetInterfaceSerializer",
-    "InterfaceCreateGPUClusterSubnetInterfaceSerializerFloatingIP",
-    "InterfaceCreateGPUClusterAnySubnetInterfaceSerializer",
-    "InterfaceCreateGPUClusterAnySubnetInterfaceSerializerFloatingIP",
-    "SecurityGroup",
+    "ServersSettings",
+    "ServersSettingsInterface",
+    "ServersSettingsInterfaceExternalInterfaceInputSerializer",
+    "ServersSettingsInterfaceSubnetInterfaceInputSerializer",
+    "ServersSettingsInterfaceSubnetInterfaceInputSerializerFloatingIP",
+    "ServersSettingsInterfaceAnySubnetInterfaceInputSerializer",
+    "ServersSettingsInterfaceAnySubnetInterfaceInputSerializerFloatingIP",
+    "ServersSettingsCredentials",
+    "ServersSettingsSecurityGroup",
 ]
 
 
 class GPUBaremetalClusterCreateParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     flavor: Required[str]
-    """Flavor name"""
+    """Cluster flavor ID"""
 
     image_id: Required[str]
-    """Image ID"""
-
-    interfaces: Required[Iterable[Interface]]
-    """A list of network interfaces for the server.
-
-    You can create one or more interfaces - private, public, or both.
-    """
+    """System image ID"""
 
     name: Required[str]
-    """GPU Cluster name"""
+    """Cluster name"""
 
-    instances_count: int
-    """Number of servers to create"""
+    servers_count: Required[int]
+    """Number of servers in the cluster"""
 
-    password: str
-    """A password for a bare metal server.
-
-    This parameter is used to set a password for the "Admin" user on a Windows
-    instance, a default user or a new user on a Linux instance
-    """
-
-    security_groups: Iterable[SecurityGroup]
-    """Security group UUIDs"""
-
-    ssh_key_name: str
-    """
-    Specifies the name of the SSH keypair, created via the
-    [/v1/`ssh_keys` endpoint](/docs/api-reference/cloud/ssh-keys/add-or-generate-ssh-key).
-    """
+    servers_settings: Required[ServersSettings]
+    """Configuration settings for the servers in the cluster"""
 
     tags: Dict[str, str]
     """Key-value tags to associate with the resource.
@@ -68,96 +51,96 @@ class GPUBaremetalClusterCreateParams(TypedDict, total=False):
     values.
     """
 
-    user_data: str
-    """String in base64 format.
-
-    Must not be passed together with 'username' or 'password'. Examples of the
-    `user_data`: https://cloudinit.readthedocs.io/en/latest/topics/examples.html
-    """
-
-    username: str
-    """A name of a new user in the Linux instance.
-
-    It may be passed with a 'password' parameter
-    """
-
 
-class InterfaceCreateGPUClusterExternalInterfaceSerializer(TypedDict, total=False):
+class ServersSettingsInterfaceExternalInterfaceInputSerializer(TypedDict, total=False):
     type: Required[Literal["external"]]
-    """A public IP address will be assigned to the server."""
 
-    interface_name: str
-    """Interface name.
+    ip_family: Literal["dual", "ipv4", "ipv6"]
+    """Which subnets should be selected: IPv4, IPv6, or use dual stack."""
 
-    Defaults to `null` and is returned as `null` in the API response if not set.
-    """
-
-    ip_family: Optional[InterfaceIPFamily]
-    """Specify `ipv4`, `ipv6`, or `dual` to enable both."""
+    name: str
+    """Interface name"""
 
 
-class InterfaceCreateGPUClusterSubnetInterfaceSerializerFloatingIP(TypedDict, total=False):
+class ServersSettingsInterfaceSubnetInterfaceInputSerializerFloatingIP(TypedDict, total=False):
     source: Required[Literal["new"]]
 
 
-class InterfaceCreateGPUClusterSubnetInterfaceSerializer(TypedDict, total=False):
+class ServersSettingsInterfaceSubnetInterfaceInputSerializer(TypedDict, total=False):
     network_id: Required[str]
-    """The network where the server will be connected."""
+    """Network ID the subnet belongs to. Port will be plugged in this network"""
 
     subnet_id: Required[str]
-    """The server will get an IP address from this subnet."""
+    """Port is assigned an IP address from this subnet"""
 
     type: Required[Literal["subnet"]]
-    """The instance will get an IP address from the selected network.
 
-    If you choose to add a floating IP, the instance will be reachable from the
-    internet. Otherwise, it will only have a private IP within the network.
-    """
-
-    floating_ip: InterfaceCreateGPUClusterSubnetInterfaceSerializerFloatingIP
+    floating_ip: ServersSettingsInterfaceSubnetInterfaceInputSerializerFloatingIP
     """Floating IP config for this subnet attachment"""
 
-    interface_name: str
-    """Interface name.
-
-    Defaults to `null` and is returned as `null` in the API response if not set.
-    """
+    name: str
+    """Interface name"""
 
 
-class InterfaceCreateGPUClusterAnySubnetInterfaceSerializerFloatingIP(TypedDict, total=False):
+class ServersSettingsInterfaceAnySubnetInterfaceInputSerializerFloatingIP(TypedDict, total=False):
     source: Required[Literal["new"]]
 
 
-class InterfaceCreateGPUClusterAnySubnetInterfaceSerializer(TypedDict, total=False):
+class ServersSettingsInterfaceAnySubnetInterfaceInputSerializer(TypedDict, total=False):
     network_id: Required[str]
-    """The network where the server will be connected."""
+    """Network ID the subnet belongs to. Port will be plugged in this network"""
 
     type: Required[Literal["any_subnet"]]
-    """Server will be attached to a subnet with the largest count of free IPs."""
 
-    floating_ip: InterfaceCreateGPUClusterAnySubnetInterfaceSerializerFloatingIP
-    """Allows the server to have a public IP that can be reached from the internet."""
+    floating_ip: ServersSettingsInterfaceAnySubnetInterfaceInputSerializerFloatingIP
+    """Floating IP config for this subnet attachment"""
 
-    interface_name: str
-    """Interface name.
+    ip_family: Literal["dual", "ipv4", "ipv6"]
+    """Which subnets should be selected: IPv4, IPv6, or use dual stack"""
+
+    name: str
+    """Interface name"""
 
-    Defaults to `null` and is returned as `null` in the API response if not set.
-    """
 
-    ip_address: str
-    """You can specify a specific IP address from your subnet."""
+ServersSettingsInterface: TypeAlias = Union[
+    ServersSettingsInterfaceExternalInterfaceInputSerializer,
+    ServersSettingsInterfaceSubnetInterfaceInputSerializer,
+    ServersSettingsInterfaceAnySubnetInterfaceInputSerializer,
+]
 
-    ip_family: InterfaceIPFamily
-    """Specify `ipv4`, `ipv6`, or `dual` to enable both."""
 
+class ServersSettingsCredentials(TypedDict, total=False):
+    password: str
+    """Used to set the password for the specified 'username' on Linux instances.
 
-Interface: TypeAlias = Union[
-    InterfaceCreateGPUClusterExternalInterfaceSerializer,
-    InterfaceCreateGPUClusterSubnetInterfaceSerializer,
-    InterfaceCreateGPUClusterAnySubnetInterfaceSerializer,
-]
+    If 'username' is not provided, the password is applied to the default user of
+    the image. Mutually exclusive with '`user_data`' - only one can be specified.
+    """
+
+    ssh_key_name: str
+    """
+    Specifies the name of the SSH keypair, created via the
+    [/v1/`ssh_keys` endpoint](/docs/api-reference/cloud/ssh-keys/add-or-generate-ssh-key).
+    """
+
+    username: str
+    """The 'username' and 'password' fields create a new user on the system"""
 
 
-class SecurityGroup(TypedDict, total=False):
+class ServersSettingsSecurityGroup(TypedDict, total=False):
     id: Required[str]
     """Resource ID"""
+
+
+class ServersSettings(TypedDict, total=False):
+    interfaces: Required[Iterable[ServersSettingsInterface]]
+    """Subnet IPs and floating IPs"""
+
+    credentials: ServersSettingsCredentials
+    """Optional server access credentials"""
+
+    security_groups: Iterable[ServersSettingsSecurityGroup]
+    """List of security groups UUIDs"""
+
+    user_data: str
+    """Optional custom user data (Base64-encoded)"""

gcore/types/cloud/gpu_baremetal_cluster_delete_params.py

@@ -4,25 +4,32 @@ from __future__ import annotations
 
 from typing_extensions import TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["GPUBaremetalClusterDeleteParams"]
 
 
 class GPUBaremetalClusterDeleteParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
-    delete_floatings: bool
-    """True if it is required to delete floating IPs assigned to the servers.
-
-    Can't be used with floatings.
+    all_floating_ips: bool
+    """
+    Flag indicating whether the floating ips associated with server / cluster are
+    deleted
     """
 
-    floatings: str
-    """Comma separated list of floating ids that should be deleted.
-
-    Can't be used with `delete_floatings`.
+    all_reserved_fixed_ips: bool
+    """
+    Flag indicating whether the reserved fixed ips associated with server / cluster
+    are deleted
     """
 
-    reserved_fixed_ips: str
-    """Comma separated list of port IDs to be deleted with the servers"""
+    floating_ip_ids: SequenceNotStr[str]
+    """Optional list of floating ips to be deleted"""
+
+    reserved_fixed_ip_ids: SequenceNotStr[str]
+    """Optional list of reserved fixed ips to be deleted"""

gcore/types/cloud/gpu_baremetal_cluster_list_params.py

@@ -2,18 +2,29 @@
 
 from __future__ import annotations
 
-from typing_extensions import TypedDict
+from typing import List
+from typing_extensions import Literal, TypedDict
 
 __all__ = ["GPUBaremetalClusterListParams"]
 
 
 class GPUBaremetalClusterListParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     limit: int
-    """Limit the number of returned clusters"""
+    """Limit of items on a single page"""
+
+    managed_by: List[Literal["k8s", "user"]]
+    """Specifies the entity responsible for managing the resource.
+
+    - `user`: The resource (cluster) is created and maintained directly by the user.
+    - `k8s`: The resource is created and maintained automatically by Managed
+      Kubernetes service
+    """
 
     offset: int
-    """Offset value is used to exclude the first set of records from the result"""
+    """Offset in results list"""

gcore/types/cloud/gpu_baremetal_cluster_rebuild_params.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 from typing_extensions import Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["GPUBaremetalClusterRebuildParams"]
 
 
@@ -13,7 +15,7 @@ class GPUBaremetalClusterRebuildParams(TypedDict, total=False):
 
     region_id: int
 
-    nodes: Required[List[str]]
+    nodes: Required[SequenceNotStr[str]]
     """List of nodes uuids to be rebuild"""
 
     image_id: Optional[str]

gcore/types/cloud/gpu_baremetal_clusters/__init__.py

@@ -3,7 +3,13 @@
 from __future__ import annotations
 
 from .flavor_list_params import FlavorListParams as FlavorListParams
+from .server_list_params import ServerListParams as ServerListParams
 from .image_upload_params import ImageUploadParams as ImageUploadParams
+from .gpu_baremetal_flavor import GPUBaremetalFlavor as GPUBaremetalFlavor
 from .server_delete_params import ServerDeleteParams as ServerDeleteParams
+from .gpu_baremetal_flavor_list import GPUBaremetalFlavorList as GPUBaremetalFlavorList
+from .gpu_baremetal_cluster_server import GPUBaremetalClusterServer as GPUBaremetalClusterServer
 from .server_attach_interface_params import ServerAttachInterfaceParams as ServerAttachInterfaceParams
 from .server_detach_interface_params import ServerDetachInterfaceParams as ServerDetachInterfaceParams
+from .gpu_baremetal_cluster_server_v1 import GPUBaremetalClusterServerV1 as GPUBaremetalClusterServerV1
+from .gpu_baremetal_cluster_server_v1_list import GPUBaremetalClusterServerV1List as GPUBaremetalClusterServerV1List

gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server.py

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..tag import Tag
+from ...._models import BaseModel
+
+__all__ = ["GPUBaremetalClusterServer", "SecurityGroup"]
+
+
+class SecurityGroup(BaseModel):
+    name: str
+    """Name."""
+
+
+class GPUBaremetalClusterServer(BaseModel):
+    id: str
+    """Server unique identifier"""
+
+    created_at: datetime
+    """Server creation date and time"""
+
+    flavor: str
+    """Unique flavor identifier"""
+
+    image_id: Optional[str] = None
+    """Server's image UUID"""
+
+    ip_addresses: List[str]
+    """List of IP addresses"""
+
+    name: str
+    """Server's name generated using cluster's name"""
+
+    security_groups: List[SecurityGroup]
+    """Security groups names"""
+
+    ssh_key_name: Optional[str] = None
+    """SSH key pair assigned to the server"""
+
+    status: Literal[
+        "ACTIVE",
+        "BUILD",
+        "DELETED",
+        "ERROR",
+        "HARD_REBOOT",
+        "MIGRATING",
+        "PASSWORD",
+        "PAUSED",
+        "REBOOT",
+        "REBUILD",
+        "RESCUE",
+        "RESIZE",
+        "REVERT_RESIZE",
+        "SHELVED",
+        "SHELVED_OFFLOADED",
+        "SHUTOFF",
+        "SOFT_DELETED",
+        "SUSPENDED",
+        "UNKNOWN",
+        "VERIFY_RESIZE",
+    ]
+    """Current server status"""
+
+    tags: List[Tag]
+    """User defined tags"""
+
+    task_id: Optional[str] = None
+    """Identifier of the task currently modifying the GPU cluster"""
+
+    updated_at: datetime
+    """Server update date and time"""