gcore 0.1.0__py3-none-any.whl

gcore/types/cloud/baremetal/baremetal_floating_address.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BaremetalFloatingAddress"]
+
+
+class BaremetalFloatingAddress(BaseModel):
+    addr: str
+    """Address"""
+
+    type: Literal["floating"]
+    """Type of the address"""

gcore/types/cloud/baremetal/baremetal_server.py

@@ -0,0 +1,178 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, TypeAlias
+
+from ..tag import Tag
+from ...._models import BaseModel
+from ..ddos_profile import DDOSProfile
+from ..blackhole_port import BlackholePort
+from ..instance_isolation import InstanceIsolation
+from .baremetal_fixed_address import BaremetalFixedAddress
+from .baremetal_floating_address import BaremetalFloatingAddress
+
+__all__ = ["BaremetalServer", "Address", "FixedIPAssignment", "Flavor", "FlavorHardwareDescription"]
+
+Address: TypeAlias = Union[BaremetalFloatingAddress, BaremetalFixedAddress]
+
+
+class FixedIPAssignment(BaseModel):
+    external: bool
+    """Is network external"""
+
+    ip_address: str
+    """Ip address"""
+
+    subnet_id: str
+    """Interface subnet id"""
+
+
+class FlavorHardwareDescription(BaseModel):
+    cpu: str
+    """Human-readable CPU description"""
+
+    disk: str
+    """Human-readable disk description"""
+
+    license: str
+    """If the flavor is licensed, this field contains the license type"""
+
+    network: str
+    """Human-readable NIC description"""
+
+    ram: str
+    """Human-readable RAM description"""
+
+
+class Flavor(BaseModel):
+    architecture: str
+    """CPU architecture"""
+
+    flavor_id: str
+    """Flavor ID is the same as name"""
+
+    flavor_name: str
+    """Flavor name"""
+
+    hardware_description: FlavorHardwareDescription
+    """Additional hardware description"""
+
+    os_type: str
+    """Operating system"""
+
+    ram: int
+    """RAM size in MiB"""
+
+    resource_class: str
+    """Flavor resource class for mapping to hardware capacity"""
+
+    vcpus: int
+    """Virtual CPU count. For bare metal flavors, it's a physical CPU count"""
+
+
+class BaremetalServer(BaseModel):
+    id: str
+    """Bare metal server ID"""
+
+    addresses: Dict[str, List[Address]]
+    """Map of network_name to list of addresses in that network"""
+
+    blackhole_ports: List[BlackholePort]
+    """IP addresses of the instances that are blackholed by DDoS mitigation system"""
+
+    created_at: datetime
+    """Datetime when bare metal server was created"""
+
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    ddos_profile: Optional[DDOSProfile] = None
+    """Bare metal advanced DDoS protection profile.
+
+    It is always `null` if query parameter `with_ddos=true` is not set.
+    """
+
+    fixed_ip_assignments: List[FixedIPAssignment]
+    """Fixed IP assigned to instance"""
+
+    flavor: Flavor
+    """Flavor details"""
+
+    instance_isolation: Optional[InstanceIsolation] = None
+    """Instance isolation information"""
+
+    name: str
+    """Bare metal server name"""
+
+    project_id: int
+    """Project ID"""
+
+    region: str
+    """Region name"""
+
+    region_id: int
+    """Region ID"""
+
+    ssh_key_name: Optional[str] = None
+    """SSH key assigned to bare metal 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",
+    ]
+    """Bare metal server status"""
+
+    tags: List[Tag]
+    """List of key-value tags associated with the resource.
+
+    A tag is a key-value pair that can be associated with a resource, enabling
+    efficient filtering and grouping for better organization and management. Some
+    tags are read-only and cannot be modified by the user. Tags are also integrated
+    with cost reports, allowing cost data to be filtered based on tag keys or
+    values.
+    """
+
+    task_id: Optional[str] = None
+    """The UUID of the active task that currently holds a lock on the resource.
+
+    This lock prevents concurrent modifications to ensure consistency. If `null`,
+    the resource is not locked.
+    """
+
+    task_state: Optional[str] = None
+    """Task state"""
+
+    vm_state: Literal[
+        "active",
+        "building",
+        "deleted",
+        "error",
+        "paused",
+        "rescued",
+        "resized",
+        "shelved",
+        "shelved_offloaded",
+        "soft-deleted",
+        "stopped",
+        "suspended",
+    ]
+    """Bare metal server state"""

gcore/types/cloud/baremetal/flavor_list_params.py

@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["FlavorListParams"]
+
+
+class FlavorListParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    disabled: bool
+    """Flag for filtering disabled flavors in the region. Defaults to true"""
+
+    exclude_linux: bool
+    """Set to true to exclude flavors dedicated to linux images. Default False"""
+
+    exclude_windows: bool
+    """Set to true to exclude flavors dedicated to windows images. Default False"""
+
+    include_capacity: bool
+    """Set to true if the response should include flavor capacity"""
+
+    include_prices: bool
+    """Set to true if the response should include flavor prices"""
+
+    include_reservation_stock: bool
+    """Optional.
+
+    Set to true if flavor listing should include count of reserved resources in
+    stock.
+    """

gcore/types/cloud/baremetal/flavor_list_suitable_params.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["FlavorListSuitableParams"]
+
+
+class FlavorListSuitableParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    include_prices: bool
+    """Set to true if flavor listing should include flavor prices"""
+
+    apptemplate_id: str
+    """Apptemplate ID"""
+
+    image_id: str
+    """Image ID"""

gcore/types/cloud/baremetal/image_list_params.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ImageListParams"]
+
+
+class ImageListParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    include_prices: bool
+    """Show price"""
+
+    private: str
+    """Any value to show private images"""
+
+    tag_key: List[str]
+    """Filter by tag keys."""
+
+    tag_key_value: str
+    """Filter by tag key-value pairs.
+
+    Must be a valid JSON string. 'curl -G --data-urlencode 'tag_key_value={"key":
+    "value"}' --url 'http://localhost:1111/v1/images/1/1'"
+    """
+
+    visibility: Literal["private", "public", "shared"]
+    """Image visibility. Globally visible images are public"""

gcore/types/cloud/baremetal/server_create_params.py

@@ -0,0 +1,370 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..interface_ip_family import InterfaceIPFamily
+from ..tag_update_map_param import TagUpdateMapParam
+
+__all__ = [
+    "ServerCreateParams",
+    "Interface",
+    "InterfaceCreateBareMetalExternalInterfaceSerializer",
+    "InterfaceCreateBareMetalSubnetInterfaceSerializer",
+    "InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIP",
+    "InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer",
+    "InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer",
+    "InterfaceCreateBareMetalAnySubnetInterfaceSerializer",
+    "InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIP",
+    "InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer",
+    "InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer",
+    "InterfaceCreateBareMetalReservedFixedIPInterfaceSerializer",
+    "InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIP",
+    "InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer",
+    "InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer",
+    "DDOSProfile",
+    "DDOSProfileField",
+]
+
+
+class ServerCreateParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    region_id: int
+    """Region ID"""
+
+    flavor: Required[str]
+    """The flavor of the instance."""
+
+    interfaces: Required[Iterable[Interface]]
+    """A list of network interfaces for the server.
+
+    You can create one or more interfaces - private, public, or both.
+    """
+
+    app_config: Optional[object]
+    """
+    Parameters for the application template if creating the instance from an
+    `apptemplate`.
+    """
+
+    apptemplate_id: str
+    """Apptemplate ID. Either `image_id` or `apptemplate_id` is required."""
+
+    ddos_profile: DDOSProfile
+    """Enable advanced DDoS protection for the server"""
+
+    image_id: str
+    """Image ID. Either `image_id` or `apptemplate_id` is required."""
+
+    name: str
+    """Server name."""
+
+    name_template: str
+    """
+    If you want server names to be automatically generated based on IP addresses,
+    you can provide a name template instead of specifying the name manually. The
+    template should include a placeholder that will be replaced during provisioning.
+    Supported placeholders are: `{ip_octets}` (last 3 octets of the IP),
+    `{two_ip_octets}`, and `{one_ip_octet}`.
+    """
+
+    password: str
+    """For Linux instances, 'username' and 'password' are used to create a new user.
+
+    When only 'password' is provided, it is set as the password for the default user
+    of the image. For Windows instances, 'username' cannot be specified. Use the
+    'password' field to set the password for the 'Admin' user on Windows. Use the
+    'user_data' field to provide a script to create new users on Windows. The
+    password of the Admin user cannot be updated via 'user_data'.
+    """
+
+    ssh_key_name: Optional[str]
+    """
+    Specifies the name of the SSH keypair, created via the
+    <a href="#operation/SSHKeyCollectionViewSet.post">/v1/ssh_keys endpoint</a>.
+    """
+
+    tags: TagUpdateMapParam
+    """Key-value tags to associate with the resource.
+
+    A tag is a key-value pair that can be associated with a resource, enabling
+    efficient filtering and grouping for better organization and management. Some
+    tags are read-only and cannot be modified by the user. Tags are also integrated
+    with cost reports, allowing cost data to be filtered based on tag keys or
+    values.
+    """
+
+    user_data: str
+    """String in base64 format.
+
+    For Linux instances, 'user_data' is ignored when 'password' field is provided.
+    For Windows instances, Admin user password is set by 'password' field and cannot
+    be updated via 'user_data'. Examples of the user_data:
+    https://cloudinit.readthedocs.io/en/latest/topics/examples.html
+    """
+
+    username: str
+    """For Linux instances, 'username' and 'password' are used to create a new user.
+
+    For Windows instances, 'username' cannot be specified. Use 'password' field to
+    set the password for the 'Admin' user on Windows.
+    """
+
+
+class InterfaceCreateBareMetalExternalInterfaceSerializer(TypedDict, total=False):
+    type: Required[Literal["external"]]
+    """A public IP address will be assigned to the instance."""
+
+    interface_name: str
+    """Interface name.
+
+    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."""
+
+    port_group: int
+    """Specifies the trunk group to which this interface belongs.
+
+    Applicable only for bare metal servers. Each unique port group is mapped to a
+    separate trunk port. Use this to control how interfaces are grouped across
+    trunks.
+    """
+
+
+class InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer(
+    TypedDict, total=False
+):
+    source: Required[Literal["new"]]
+    """A new floating IP will be created and attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+class InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer(
+    TypedDict, total=False
+):
+    existing_floating_id: Required[str]
+    """
+    An existing available floating IP id must be specified if the source is set to
+    `existing`
+    """
+
+    source: Required[Literal["existing"]]
+    """An existing available floating IP will be attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIP: TypeAlias = Union[
+    InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer,
+    InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer,
+]
+
+
+class InterfaceCreateBareMetalSubnetInterfaceSerializer(TypedDict, total=False):
+    network_id: Required[str]
+    """The network where the instance will be connected."""
+
+    subnet_id: Required[str]
+    """The instance will get 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: InterfaceCreateBareMetalSubnetInterfaceSerializerFloatingIP
+    """Allows the instance to have a public IP that can be reached from the internet."""
+
+    interface_name: str
+    """Interface name.
+
+    Defaults to `null` and is returned as `null` in the API response if not set.
+    """
+
+    port_group: int
+    """Specifies the trunk group to which this interface belongs.
+
+    Applicable only for bare metal servers. Each unique port group is mapped to a
+    separate trunk port. Use this to control how interfaces are grouped across
+    trunks.
+    """
+
+
+class InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer(
+    TypedDict, total=False
+):
+    source: Required[Literal["new"]]
+    """A new floating IP will be created and attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+class InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer(
+    TypedDict, total=False
+):
+    existing_floating_id: Required[str]
+    """
+    An existing available floating IP id must be specified if the source is set to
+    `existing`
+    """
+
+    source: Required[Literal["existing"]]
+    """An existing available floating IP will be attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIP: TypeAlias = Union[
+    InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer,
+    InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer,
+]
+
+
+class InterfaceCreateBareMetalAnySubnetInterfaceSerializer(TypedDict, total=False):
+    network_id: Required[str]
+    """The network where the instance will be connected."""
+
+    type: Required[Literal["any_subnet"]]
+    """Instance will be attached to a subnet with the largest count of free IPs."""
+
+    floating_ip: InterfaceCreateBareMetalAnySubnetInterfaceSerializerFloatingIP
+    """Allows the instance to have a public IP that can be reached from the internet."""
+
+    interface_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."""
+
+    ip_family: Optional[InterfaceIPFamily]
+    """Specify `ipv4`, `ipv6`, or `dual` to enable both."""
+
+    port_group: int
+    """Specifies the trunk group to which this interface belongs.
+
+    Applicable only for bare metal servers. Each unique port group is mapped to a
+    separate trunk port. Use this to control how interfaces are grouped across
+    trunks.
+    """
+
+
+class InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer(
+    TypedDict, total=False
+):
+    source: Required[Literal["new"]]
+    """A new floating IP will be created and attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+class InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer(
+    TypedDict, total=False
+):
+    existing_floating_id: Required[str]
+    """
+    An existing available floating IP id must be specified if the source is set to
+    `existing`
+    """
+
+    source: Required[Literal["existing"]]
+    """An existing available floating IP will be attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIP: TypeAlias = Union[
+    InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIPNewInstanceFloatingIPInterfaceSerializer,
+    InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIPExistingInstanceFloatingIPInterfaceSerializer,
+]
+
+
+class InterfaceCreateBareMetalReservedFixedIPInterfaceSerializer(TypedDict, total=False):
+    port_id: Required[str]
+    """Network ID the subnet belongs to. Port will be plugged in this network."""
+
+    type: Required[Literal["reserved_fixed_ip"]]
+    """An existing available reserved fixed IP will be attached to the instance.
+
+    If the reserved IP is not public and you choose to add a floating IP, the
+    instance will be accessible from the internet.
+    """
+
+    floating_ip: InterfaceCreateBareMetalReservedFixedIPInterfaceSerializerFloatingIP
+    """Allows the instance to have a public IP that can be reached from the internet."""
+
+    interface_name: str
+    """Interface name.
+
+    Defaults to `null` and is returned as `null` in the API response if not set.
+    """
+
+    port_group: int
+    """Specifies the trunk group to which this interface belongs.
+
+    Applicable only for bare metal servers. Each unique port group is mapped to a
+    separate trunk port. Use this to control how interfaces are grouped across
+    trunks.
+    """
+
+
+Interface: TypeAlias = Union[
+    InterfaceCreateBareMetalExternalInterfaceSerializer,
+    InterfaceCreateBareMetalSubnetInterfaceSerializer,
+    InterfaceCreateBareMetalAnySubnetInterfaceSerializer,
+    InterfaceCreateBareMetalReservedFixedIPInterfaceSerializer,
+]
+
+
+class DDOSProfileField(TypedDict, total=False):
+    base_field: Optional[int]
+    """ID of DDoS profile field"""
+
+    field_name: Optional[str]
+    """Name of DDoS profile field"""
+
+    field_value: Union[Iterable[object], int, str, None]
+    """Complex value. Only one of 'value' or 'field_value' must be specified."""
+
+    value: Optional[str]
+    """Basic type value. Only one of 'value' or 'field_value' must be specified."""
+
+
+class DDOSProfile(TypedDict, total=False):
+    profile_template: Required[int]
+    """DDoS profile template ID"""
+
+    fields: Optional[Iterable[DDOSProfileField]]
+    """DDoS profile parameters"""
+
+    profile_template_name: Optional[str]
+    """DDoS profile template name"""